robert.schöbel.net
January 8th, 2012
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
Robert Schöbel |
usefull stuff |
June 19th, 2011
Ziel:
- Codeigniter 2 mit Doctrine 2 installieren
- Klasse erstellten und Datenbank anlegen
- Instanz eines Objektes erzeugen
- Containment Beziehung nutzen
- Containment Beziehung auslesen
5. Containment Elemente auslesen
Das Ziel ist es, alle Workpackages mit ihren Tasks auszulesen.
- Workpackage1
- Workpackage2
Dazu wird eine neuer Button im View start.php erzeugt
<?php echo form_open("showdoctrine_main/list_packages_with_tasks"); ?>
<input value="Workpackage auflisten" type="submit">
<?php 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
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Welcome to CodeIgniter</title>
<style type="text/css">
body {
background-color: #fff;
margin: 40px;
font-family: Lucida Grande, Verdana, Sans-serif;
font-size: 14px;
color: #4F5155;
}
a {
color: #003399;
background-color: transparent;
font-weight: normal;
}
h1 {
color: #444;
background-color: transparent;
border-bottom: 1px solid #D0D0D0;
font-size: 16px;
font-weight: bold;
margin: 24px 0 2px 0;
padding: 5px 0 6px 0;
}
code {
font-family: Monaco, Verdana, Sans-serif;
font-size: 12px;
background-color: #f9f9f9;
border: 1px solid #D0D0D0;
color: #002166;
display: block;
margin: 14px 0 14px 0;
padding: 12px 10px 12px 10px;
}
</style>
</head>
<body>
<h1>List</h1>
<table>
<?php foreach ($workpackage_list as $workpackage): ?>
<tr>
<td>-</td>
<td>
<?php echo $workpackage->getTitle(); ?>
</td>
<td>-</td>
</tr>
<?php foreach ($workpackage->getTask_Collection() as $task): ?>
<tr>
<td>-</td>
<td>-</td>
<td>
<?php echo $task->getTitle(); ?>
</td>
</tr>
<?php endforeach; ?>
<?php endforeach; ?>
</table>
<?php echo form_open("showdoctrine_main"); ?>
<input value="back" type="submit">
<?php echo form_close(); ?>
</body>
</html>
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.
Robert Schöbel |
PHP, usefull stuff |
June 19th, 2011
Ziele
- Codeigniter 2 mit Doctrine 2 installieren
- Klasse erstellen und Datenbank anlegen
- Instanz einer Klasse erzeugen
- Containment Beziehung nutzen
- Containment Beziehung auslesen
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.
Robert Schöbel |
PHP, usefull stuff |
June 19th, 2011
Ziel:
- Codeigniter 2 mit Doctrine 2 installieren
- Klasse erstellen und Datenbank anlegen
- Instanz einer Klasse erzeugen
- Containment Beziehung nutzen
- Containment Beziehung auslesen
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
<?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
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Welcome to CodeIgniter</title>
<style type="text/css">
body {
background-color: #fff;
margin: 40px;
font-family: Lucida Grande, Verdana, Sans-serif;
font-size: 14px;
color: #4F5155;
}
a {
color: #003399;
background-color: transparent;
font-weight: normal;
}
h1 {
color: #444;
background-color: transparent;
border-bottom: 1px solid #D0D0D0;
font-size: 16px;
font-weight: bold;
margin: 24px 0 2px 0;
padding: 5px 0 6px 0;
}
code {
font-family: Monaco, Verdana, Sans-serif;
font-size: 12px;
background-color: #f9f9f9;
border: 1px solid #D0D0D0;
color: #002166;
display: block;
margin: 14px 0 14px 0;
padding: 12px 10px 12px 10px;
}
</style>
</head>
<body>
<h1>Welcome to ShowDoctrine</h1>
<?php echo form_open("showdoctrine_main/add_task"); ?>
<input value="Task anlagen" type="submit">
<?php echo form_close(); ?>
</body>
</html>
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');
Robert Schöbel |
PHP, usefull stuff |
April 9th, 2011
Ziel:
- Codeigniter 2 mit Doctrine 2 installieren
- Klasse erstellen und Datenbank anlegen
- Instanz einer Klasse erzeugen
- Containment Beziehung nutzen
- Containment Beziehung auslesen
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.
Robert Schöbel |
PHP, usefull stuff |
April 8th, 2011
Ziel:
- Codeigniter 2 mit Doctrine 2 installieren
- Klasse erstellen und Datenbank anlegen
- Instanz einer Klasse erzeugen
- Containment Beziehung nutzen
- Containment Beziehung auslesen
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.
<?php
/* 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.
<?php
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.
<?php
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.
Robert Schöbel |
PHP, usefull stuff |
March 25th, 2011
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
Robert Schöbel |
usefull stuff |
January 31st, 2011
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
Robert Schöbel |
usefull stuff |
January 6th, 2011
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)
Robert Schöbel |
usefull stuff |
November 21st, 2010
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: <Laufwerk>/…/openLDAP/slapd.conf
Einträge anpassen
database bdb
suffix "dc=domain-name>"
rootdn "cn=Manager,dc=<domain-name>"
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=<domain>
- 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
Robert Schöbel |
usefull stuff |