Robert.Schöbel.net

Zeiterfassung TimeTracker Online

Robert Schöbel — Sun, 08 Jan 2012 14:09:11 +0000

Die Zeiterfassung ist nun in die Betaphase gegangen und kann genutzt werden.

Einfach kostenlos registrieren und kostenlos die Arbeitszeit erfassen.

mehr Informationen

Startseite der Zeiterfassung

Codeigniter 2 und Doctrine 2 HowTo 5/5

Robert Schöbel — Sun, 19 Jun 2011 15:59:08 +0000

Ziel:

5. Containment Elemente auslesen

Das Ziel ist es, alle Workpackages mit ihren Tasks auszulesen.

Workpackage1
- Task1
- Task2
Workpackage2
- Task3
- Task4

Dazu wird eine neuer Button im View start.php erzeugt

echo form_open("showdoctrine_main/list_packages_with_tasks"); ?>

echo form_close(); ?>

Es muss zusätzlich eine neue Funktion im Controller erzeugt werden

Application/controllers/showdoctrine_main.php

public function list_packages_with_tasks(){
$em = $this->doctrine->em;
$qb = $em->createQueryBuilder();
$qb->select(array('w', 't'))
->from('models\workpackage','w')
->join('w.task_collection','t');
$q = $qb->getQuery();
//$workpackage = $q->getResult();
$this->data['workpackage_list'] = $q->getResult();

$this->load->view('list',$this->data);

}

Wie zu erkennen ist, muss noch ein View erzeugt werden

Application/view/list.php

Welcome to CodeIgniter

List

foreach ($workpackage_list as $workpackage): ?>

foreach ($workpackage->getTask_Collection() as $task): ?>

endforeach; ?>
endforeach; ?>

-	echo $workpackage->getTitle(); ?>	-
-	-	echo $task->getTitle(); ?>

echo form_open("showdoctrine_main"); ?>

echo form_close(); ?>

Damit die Methode $workpackage->getTask_Collection() ausgeführt werden kann, muss diese in die Klasse Workpackage integriert werden

Application/models/workpackage.php

public function getTask_Collection(){
return $this->task_collection;
}

Jetzt kann die Ausgabe der Liste im Browser getestet werden.

Codeigniter 2 und Doctrine 2 HowTo 4/5

Robert Schöbel — Sun, 19 Jun 2011 15:46:06 +0000

Ziele

4. Containment Beziehung nutzen

Die workpackage_id in der Tabelle Task ist aktuell noch Null.

In der Datenbank ist das Feld auch auf Null = true gesetzt.

Ziel: in der Datenbank muss “workpackage_id” = “not null” gelten.

Änderung in der Datei application/models/task.php

– nullable=false

/**
* @ManyToOne(targetEntity="Workpackage", inversedBy="task_collection")
* @JoinColumn(name="workpackage_id", referencedColumnName="id", nullable=false)
*/
private $workpackage;

Update des Schemas über die Konsole

X:\xampp\php\php.exe -f "X:\xampp\htdocs\showdoctrine\application\doctrine_init.php" orm:schema-tool:update --force

Erneutes ausführen des “add Task” Buttons ruft jetzt einen Fehler hervor

Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[23000]: Integrity constraint violation: 1048 Column 'workpackage_id' cannot be null' ......

Das passt!

Jetzt muss als erstes ein Workpackage angelegt werden und dann ein Task mit entsprechender Workpackage Id

Dazu muss im Model des Task folgendes ergänzt werden

/* Workpackage */
public function setWorkpackage($workpackage){
$this->workpackage = $workpackage;
return $this;
}
public function getWorkpackage(){
return $this->workpackage;
}

Der Controller wird ebenfalls angepasst (Funktion “add_task” wird erweitert)

public function add_task(){

/* doctrine entity manager */
$em = $this->doctrine->em;

// Workpackage anlegen
$workpackage = new \models\Workpackage();
$workpackage->setTitle("package");
$em->persist($workpackage);

// Task anlegen
$task = new \models\Task();
$task->setTitle("first");
// Task mit Workpackage ID verknüpfen
$task->setWorkpackage($workpackage);

$em->persist($task);
//flush ist ähnlich zur save Funktion, es führt save für alle nicht gespeicherten records aus
$em->flush();

$this->load->view('start');
}

Das Ausführen über den Button “add_task” erstellt jetzt ein Workpackage und einen Task in der Datenbank.

Dem Task wird die Workpackage Id zugewiesen.

Codeigniter 2 und Doctrine 2 HowTo 3/5

Robert Schöbel — Sun, 19 Jun 2011 15:38:50 +0000

Ziel:

3. Instanz einer Klasse erzeugen

Ziel: Anlegen einer Aufgabe:

* Controller: showdoctrine_main.php
* Viewer: start.php

Anpassen des Start-Controllers – Ordner “Application/config/routes.php”

$route['default_controller'] = "showdoctrine_main";

Controller angelegen:

Controller: application/controller/showdoctrine_main.php

if ( ! defined('BASEPATH')) exit('No direct script access allowed');
use models\Task;
class Showdoctrine_main extends CI_Controller {

public function add_task(){

$task = new \models\Task();
$task->setTitle("first");
$em = $this->doctrine->em;
$em->persist($task);
$em->flush();
$this->load->view('start');
}

public function index()
{
$this->load->view('start');
}
}

?>

Viewer anlegen:

application/view/start.php

Welcome to CodeIgniter

Welcome to ShowDoctrine

echo form_open("showdoctrine_main/add_task"); ?>

echo form_close(); ?>

wird auf “Task anlegen” geklickt, wird ein neuer Task in der Tabelle Task erstellt (nachfolgende Zusatzinformation beachten).

————————————————————-

Zusatzinformation zum Namespace:

Doctrine muss als Bibliothek automatisch geladen werden

Datei: application/config/autoload.php

$autoload['libraries'] = array('doctrine');

Ein Fehler der darauf hindeutet, dass die Bibliothek noch nicht geladen ist lauted:

Class ‘models\Task’ not found

bezogen auf eine Zeile im Code an der “$task = new \models\Task();” verwendet wird

Zusatzinformation zum Formhelper

Um in einer View-Datei mit dem Form-Helper zu arbeiten, muss dieser unter “Appclication/config/autoload.php” aktiviert werden.

$autoload['helper'] = array('form');

Codeigniter 2 und Doctrine 2 HowTo 2/5

Robert Schöbel — Sat, 09 Apr 2011 10:27:49 +0000

Ziel:

2. Klasse erstellen und Datenbank anlegen

Ein einfaches Klassenmodell

Zwei Klassen aus dem Bereich Projektmanagement:

Workpackage (Arbeitspakete)
Task (Aufgaben)

Die zwei Klassen werden unter dem Ordner “Application/models/” angelegt.

task.php

namespace models;

/**
* @Entity @HasLifecycleCallbacks
* @Table(name="task")
*/
class Task {

/**
* @Id
* @Column(type="integer", nullable=false)
* @GeneratedValue(strategy="AUTO")
*/
private $id;

/**
* @Column(type="string", length=512, nullable=true)
*/
private $comment;

/**
* @Column(type="string", length=512, nullable=true)
*/
private $title;

/**
* @Column(type="decimal", nullable=true)
*/
private $accounting;

/**
* @ManyToOne(targetEntity="Workpackage", inversedBy="task_collection")
* @JoinColumn(name="workpackage_id", referencedColumnName="id")
*/
private $workpackage;

public function __construct() {

}

public function getTitle(){
return $this->title;
}
public function setTitle($title){
$this->title = $title;
return $this;
}

public function getId(){
return $this->id;
}

}

workpackage.php

namespace models;

/**
* @Entity
* @Table(name="workpackage")
*/

class Workpackage {

/**
* @Id
* @Column(type="integer", nullable=false)
* @GeneratedValue(strategy="AUTO")
*/
private $id;

/**
* @Column(type="string", length=32, nullable=false)
*/
private $title;

/**
* @OneToMany(targetEntity="Task", mappedBy="Workpackage")
*/
private $task_collection;

public function __construct() {
$this->task_collection = new \Doctrine\Common\Collections\ArrayCollection();
}

public function getTitle(){
return $this->title;
}
public function setTitle($title){
$this->title = $title;
return $this;
}

public function getId(){
return $this->id;
}

}

Anlegen der Datenbank

Datenbankname: test_db

Ist die Datenbank angelegt, können die Tabellen über das Doctrine Script angelegt werden.

Konsole starten und das Schema erstellen bzw. updaten:

X:\xampp\php\php.exe -f "X:\xampp\htdocs\showdoctrine\application\doctrine_init.php" orm:schema-tool:update --force

Durch das Script werden zwei Tabellen (Workpackage, Task) angelegt.

für die Tabelle Task wird automatisch die Spalte workspace_id die als Referenz erstellt.

Codeigniter 2 und Doctrine 2 HowTo 1/5

Robert Schöbel — Fri, 08 Apr 2011 19:49:47 +0000

Ziel:

1. Codeigniter 2 mit Doctrine 2 installieren

————-

Info: Die Installation und der Code für die Doctrine integration stammen ursprünglich von dieser Seite (Installation sehr ausführlich erklärt):

http://wildlyinaccurate.com/integrating-doctrine-2-with-codeigniter-2/

————-

Nach dem Download von Codeigniter Version 2.0.2 ergeben sich zwei Ordner:

“system” und “application”.

Zusätzlich wird Doctrine 2.0.4 geladen.

Entpackt ergeben sich die Ordner “bin” und “doctrine”.

Der “doctrine” Ordner wird komplett ins Codeigniter Verzeichnis “/application/libraries” kopiert.

Zur Verwendung von Doctrine 2 fehlt eine Klasse mit die mit Codeigniter genutzt werden kann.

/* use with
* $em = $this->doctrine->em;
*/

use Doctrine\Common\ClassLoader,
Doctrine\ORM\Configuration,
Doctrine\ORM\EntityManager,
Doctrine\Common\Cache\ArrayCache,
Doctrine\DBAL\Logging\EchoSqlLogger;

class Doctrine {

public $em = null;

public function __construct()
{
// load database configuration from CodeIgniter
require_once APPPATH.'config/database.php';

// Set up class loading. You could use different autoloaders, provided by your favorite framework,
// if you want to.
require_once APPPATH.'libraries/Doctrine/Common/ClassLoader.php';

$doctrineClassLoader = new ClassLoader('Doctrine', APPPATH.'libraries');
$doctrineClassLoader->register();
$entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/" ));
$entitiesClassLoader->register();
$proxiesClassLoader = new ClassLoader('Proxies', APPPATH.'models/proxies');
$proxiesClassLoader->register();

// Set up caches
$config = new Configuration;
$cache = new ArrayCache;
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);

// Proxy configuration
$config->setProxyDir(APPPATH.'/models/proxies');
$config->setProxyNamespace('Proxies');

// Set up logger
$logger = new EchoSqlLogger;
$log = 0;
if($log){
$config->setSqlLogger($logger);
}
$config->setAutoGenerateProxyClasses( TRUE );

// Database connection information
$connectionOptions = array(
'driver' => $db['default']['dbdriver'],
'user' =>     $db['default']['username'],
'password' => $db['default']['password'],
'host' =>     $db['default']['hostname'],
'dbname' =>   $db['default']['database']
);

// Mapping Configuration
//      $driverImpl = $config->newDefaultAnnotationDriver(APPPATH.'/application/models');
//      $config->setMetadataDriverImpl($driverImpl);
// Set up driver
$Doctrine_AnnotationReader = new \Doctrine\Common\Annotations\AnnotationReader($cache);
$Doctrine_AnnotationReader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\');
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($Doctrine_AnnotationReader, APPPATH.'models');
$config->setMetadataDriverImpl($driver);

// Create EntityManager
$this->em = EntityManager::create($connectionOptions, $config);
}
}
?>

Dieser Code wird in einer Datei gespeichert (doctrine.php) und im Ordner “application/libraries/” abgelegt.

Zusätzlich fehlt eine Datei zum Initiieren der Tabellen in der Datenbanken.

chdir(dirname(__FILE__) . '/libraries');

require_once 'Doctrine/Common/ClassLoader.php';

$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
$classLoader->register();

$classLoader = new \Doctrine\Common\ClassLoader('Symfony', 'Doctrine');
$classLoader->register();

$configFile = '../cli_config.php';
$helperSet = null;
if (file_exists($configFile)) {
if ( ! is_readable($configFile)) {
trigger_error(
'Configuration file [' . $configFile . '] does not have read permission.', E_ERROR
);
}

require $configFile;

foreach ($GLOBALS as $helperSetCandidate) {
if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
$helperSet = $helperSetCandidate;
break;
}
}
}

$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();

$cli = new \Symfony\Component\Console\Application('Doctrine Command Line Interface', Doctrine\ORM\Version::VERSION);
$cli->setCatchExceptions(true);
$cli->setHelperSet($helperSet);
$cli->addCommands(array(
// DBAL Commands
new \Doctrine\DBAL\Tools\Console\Command\RunSqlCommand(),
new \Doctrine\DBAL\Tools\Console\Command\ImportCommand(),

// ORM Commands
new \Doctrine\ORM\Tools\Console\Command\ClearCache\MetadataCommand(),
new \Doctrine\ORM\Tools\Console\Command\ClearCache\ResultCommand(),
new \Doctrine\ORM\Tools\Console\Command\ClearCache\QueryCommand(),
new \Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand(),
new \Doctrine\ORM\Tools\Console\Command\SchemaTool\UpdateCommand(),
new \Doctrine\ORM\Tools\Console\Command\SchemaTool\DropCommand(),
new \Doctrine\ORM\Tools\Console\Command\EnsureProductionSettingsCommand(),
new \Doctrine\ORM\Tools\Console\Command\ConvertDoctrine1SchemaCommand(),
new \Doctrine\ORM\Tools\Console\Command\GenerateRepositoriesCommand(),
new \Doctrine\ORM\Tools\Console\Command\GenerateEntitiesCommand(),
new \Doctrine\ORM\Tools\Console\Command\GenerateProxiesCommand(),
new \Doctrine\ORM\Tools\Console\Command\ConvertMappingCommand(),
new \Doctrine\ORM\Tools\Console\Command\RunDqlCommand(),
new \Doctrine\ORM\Tools\Console\Command\ValidateSchemaCommand(),

));
$cli->run();
?>

Dieser Code wird als Datei doctrine_init.php unter “application/” abgelegt.

Die letzte Datei für Doctrine 2 ist die Konfiguration.

use Doctrine\Common\ClassLoader,
Doctrine\ORM\Configuration,
Doctrine\ORM\EntityManager,
Doctrine\Common\Cache\ArrayCache,
Doctrine\DBAL\Logging\EchoSqlLogger;

define('BASEPATH', __DIR__ . '/../system/');

require_once __DIR__ . '/config/database.php';
require_once __DIR__ . '/libraries/Doctrine/Common/ClassLoader.php';

$doctrineClassLoader = new ClassLoader('Doctrine', __DIR__.'libraries');
$doctrineClassLoader->register();
$entitiesClassLoader = new ClassLoader('models', __DIR__);
$entitiesClassLoader->register();
$proxiesClassLoader = new ClassLoader('Proxies', __DIR__.'models/proxies');
$proxiesClassLoader->register();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache);
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

$cache = new ArrayCache;
// Set up driver
$Doctrine_AnnotationReader = new \Doctrine\Common\Annotations\AnnotationReader($cache);
$Doctrine_AnnotationReader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\');
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($Doctrine_AnnotationReader, realpath('../models'));
$config->setMetadataDriverImpl($driver);

// Database connection information
$connectionOptions = array(
'driver' => 'pdo_mysql',
'user' =>     $db['default']['username'],
'password' => $db['default']['password'],
'host' =>     $db['default']['hostname'],
'dbname' =>   $db['default']['database']
);

$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
));
?>

Der Code wird als “cli_config.php” unter dem Ordner “application/” abgelegt.

Mit den drei zusätzlichen Dateien sind alle Dateien für Doctrine 2 vorhanden.

Es folgt die Konfiguration in Codeigniter

Die Datei database.php muss im Ordner “application/config” konfiguriert werden.

Natürlich muss jetzt noch die “base_url” in der “application/config/config.php” Datei eingestellt werden.

Twitter on Facebook

Robert Schöbel — Fri, 25 Mar 2011 16:51:19 +0000

Um Tweets einfach auf Facebook zu posten, kann folgende Anwendung verwendet werden:

http://apps.facebook.com/selectivetwitter/

Um einen Beitrag auf Facebook zu übertragen, muss nur das Kürzel #fb an die Nachricht angefügt werden

Neues Projekt Zeiterfassung

Robert Schöbel — Mon, 31 Jan 2011 17:42:56 +0000

Ein neues Projekt wird realisiert: Zeiterfassung

Architektur:

Ziel:

jQuery als Ajax Framework

Codeigniter 2 als (H)MVC Framework

Doctrine 2 als ORM Framework

coming soon

Externe USB Festplatte in Debian anbinden

Robert Schöbel — Thu, 06 Jan 2011 20:41:27 +0000

Ziel externe USB Festplatte in Debian anbinden und als Sicherung nutzen

1. Ext3 formatieren

2. Festplatte mounten

3. einmal pro Tag Sicherung ziehen

Befehle:

fdisk -l

Festplatten anzeigen

Usb ist /dev/sdb

und besitzt Einstiegspunkt /dev/sdb1

mkfs.ext3 /dev/sdb1

formatiert das Medium

Befehl um Uuid anzuzeigen: blkid

sdb1 wird jetzt in die fstab Datei eingetragen

nano /etc/fstab

listet die Festplatten

Uuid wird benötigt damit die Festplatte immer an die selbe Stelle gemountet wird

Batch Datei zur Datensicherung erzeugen

nano backup.sh

Inhalt:

#!/bin/bash
mount /mnt/usbsicherung
DATUM=`date +%Y%m%d`
PFAD=/mnt/usbsicherung/sicherung/
DATEI=backup_${DATUM}.tar
FULLSAVE=${PFAD}_${DATEI}
echo Speichere in $FULLSAVE
tar -Pcf ${FULLSAVE} /var/
echo Umount
umount /mnt/usbsicherung
echo END

Script ausführbar machen

chmod u+x backup.sh

Datei in die Cronjobs eintragen (jede Nacht eine Sicherung)

crontab -e

1 2 * * * /home/userfolder/backup.sh

(Backup um 2 Uhr und eine Minute)

OpenLdap HowTo

Robert Schöbel — Sun, 21 Nov 2010 16:49:26 +0000

Ziele:

OpenLdap auf Windows nutzen

OU, User und Gruppen anlegen mit Benutzeroberfläche

Struktur:

Vorgehen:

OpenLdap downloaden und installieren
slapd.conf anpassen
LDIF Datei anlegen
JXplorer nutzen um LDAP mit GUI zu bearbeiten

1. OpenLdap

für Windows gibt es einen Server auf der Userbooster-Seite

Sonst auf OpenLdap

Installation erfolgt über GUI

Datenbank: Barkley Datenbank

Server: sonne

2. slapd.conf anpassen

Verzeichnis: /…/openLDAP/slapd.conf

Einträge anpassen

database    bdb
suffix        "dc=domain-name>"
rootdn        "cn=Manager,dc="
rootpw    secret
directory ./data

mein Domain ist nur “sonne” (Testumgebung)

database    bdb
suffix        "dc=sonne"
rootdn        "cn=Manager,dc=sonne"
rootpw    secret
directory ./data

!Bei copy & paste entstehen evtl. Leerzeichen die dann Fehler hervorrufen!

3. LDIF – Datei erstellen

Ohne eine initiale LDIF Datei (LDAP Data Interchange Format) enstanden bei immer Fehler mit dem JXplorer, da die Objekte die in der slapd.conf festgelegt waren, noch nicht existierten.

folgende Fehler im JXplorer deuten daruf hin:

unable to list dc=
Unable to perform Read entry operation.
LDAP: error code 32 – No Such Object

d.h. eine Datei init.ldif erzeugen (die Datei muss nicht im openLDAP Ordner abgelegt werden)

dn: dc=sonne
objectClass: dcObject
objectClass: organization
dc: sonne
o: Standort

dn: ou=myUsers,dc=sonne
objectClass: organizationalUnit
objectClass: top
ou: myUser

dn: uid=user1,ou=myUsers,dc=sonne
objectClass: inetOrgPerson
objectClass: organizationalPerson
objectClass: person
objectClass: top
cn: Robert Schoebel
sn: schoebel
uid: user1

dn: cn=Manager,dc=sonne
objectClass: organizationalRole
objectClass: top
cn: Manager

dn: ou=myGroups,dc=sonne
objectClass: organizationalUnit
objectClass: top
ou: myGroups

dn: cn=projectadmin,ou=myGroups,dc=sonne
objectClass: groupOfNames
objectClass: top
cn: projectadmin
member: cn=robert schoebel,ou=myUsers,dc=sonne

!Achtung bei Copy und Paste, Leerzeichen erzeugen Fehler beim Import!

4. JXplorer nutzen um LDAP mit GUI zu bearbeiten

dazu JXplorer laden

nach der Installation muss eine Verbindung zum Ldap hergestellt werden

dazu im openLDAP Ordner die slapd.exe ausführen

und im JXplorer die Connection wie folgt einstellen:

jetzt wird die LDIF-Datei importiert und reconnected und schon steht das LDAP bereit

alle weiteren Änderungen können jetzt mit dem JXplorer erfolgen