[3.3] HtmlFormTag->formFill()

Im Entwickler-Forum können Implementierungsdetails sowie Alternativen der Umsetzung diskutiert werden. // Here, developers can discuss implementation details of features of their projects.
GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

[3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 25.08.2017, 09:57:01

Hallo,
ich habe mich extrem gefreut als ich diese Funktion in der Changelog gesehen habe und Sie natürlich gleich eingesetzt mit ernüchterndem Ergebnis.

Die Funktion benötigt ein eigenes Objekt und kann nicht mit dem GenericOrMapperDataObject genutzt werden, dies wäre jedoch meines Erachtens der häufigste Anwendungsfall. Bisher habe ich meine Formulare immer mit:

Code: Alles auswählen

// Textfelder
      /* @var TextFieldTag[] $FormTextFields /
      $FormTextFields = $Form->getFormElementsByTagName('form:text');
      foreach ($FormTextFields as $FormTextField) {
         $FormTextField->setValue($User->getProperty($FormTextField->getAttribute('name')));
      }
      
sowas befüllt vor allem bei langen Formularen. Die neue Funktion kam mir da gerade recht Sie versprach eine schnelle und nicht redundante Lösung.

Jdoch muss ich jetzt jedesmall erst ein Objekt mit den Daten erstellen welches ich übergebe da die Werte im Generic***DataObject unter Properties liegen.... früher waren sie mal so wie die Funktion sie jetzt benötigt.

Ich habe mir also gedacht ok kann man dies ändern das er auch die DatenObjecte nutzen kann?

Code: Alles auswählen

if ($model instanceof GenericORMapperDataObject) {
         $dummy = new \stdClass();
         foreach ($model->getProperties() as $name => $value) {
            $dummy->$name = $value;
         }
         $model = $dummy;
      }
      
habe ich dann einfach mall in der Funktion fillForm() vor dem erstellen der ReflectionClass eingebunden.
Das $model ist jetzt wie erwartet aufgebaut jedoch gibt die ReflectionClass keine Properties zurück da die Werte in der Klasse zwar sind aber nicht wirklich deklariert (public $name = 'adffads' ....).

Leider weis ich nun nicht ob ich das beim erstellen des $dummy dies irgendwie verbessern kann.

PS: Die funktion HtmlFormTag->fillModel() müste ebenfalls angepasst werden.

GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

Re: [3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 25.08.2017, 10:23:28

PSS: Nachtrag habe nun nachdem ich eine deutsche Doku gefunden habe meine Code dahin geändert:

Code: Alles auswählen

if ($model instanceof GenericORMapperDataObject) {
    $dummy = new \stdClass();
    foreach ($model->getProperties() as $name => $value) {
       $dummy->$name = $value;
    }
    $model = $dummy;
    $class = new \ReflectionObject($model);
} else {
   $class = new ReflectionClass($model);
}
Da **Class sich auf die Klasse bezieht und **Object auf die instance selbiger was ja hier gewünscht ist. Das ganze kann natürlich nun noch etwas gekürzt werden. Dieser Workaround funktioniert nun schon wie gewünscht und ist abwärtskompatibel. Ich schaue nun ob ich HtmlFormTag->fillModel() ebenfalls angepasst kriege.

GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

Re: [3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 25.08.2017, 17:01:56

So ich bin jetzt soweit nur noch in der Testphase:

1. 2 Neue Funktionen in der HTMLFormTag

Code: Alles auswählen

private function convertDataObjectToStdClass(&$model) {
   if ($model instanceof GenericORMapperDataObject) {
         $dummy = new stdClass();
         foreach ($model->getProperties() as $name => $value) {
            $dummy->$name = $value;
         }
         $model = $dummy;
         $class = new ReflectionObject($model);
      } else {
         $class = new ReflectionClass($model);
      }
      return $class;
   }

   private function convertReflectionToDataObject($dataObject,$reflectionClass,$stdClass) {

      $properties = $reflectionClass->getProperties();
      foreach ($properties as $property) {
         $dataObject->setProperty($property->getName(),$property->getValue($stdClass));
      }

      return $dataObject;

   }
2. Jeweils die Zeilen:

Code: Alles auswählen

$class = new ReflectionClass($model);
in den Funktionen HTMLFormTag->fillForm() und ***->filModel() durch

Code: Alles auswählen

$class = $this->convertDataObjectToStdClass($model);
ersetzt.

3. in der Funktion HtmlFormTag->fillModel() zu beginn vor dem Aufruf der neuen Funktion

Code: Alles auswählen

if ($model instanceof GenericORMapperDataObject)
         $dataObject = clone $model;
und am ende vor dem return

Code: Alles auswählen

if (isset($dataObject))
         $model = $this->convertReflectionToDataObject($dataObject,$class,$model);
eingefügt.

Ich Teste das ganze nun ein bischen auch mit den mappings. Vieleicht sind ja noch Ideen da wie man es kürzer oder besser machen kann.
gerne würde ich dann am ende nen Issue eintragen und Bei Github nen request erstellen.

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 25.08.2017, 19:27:09

Hallo Christian,

vielen Dank für deinen Beitrag! Ich schaue mir deinen Vorschlag am Wochenende an und melde mich zurück! :)
Viele Grüße,
Christian

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 28.08.2017, 09:25:30

Guten Morgen Christian,

es ist tatsächlich so, dass die Implementierung im HtmlFormTag bewusst auf Properties und nicht auf Methoden reagiert um nicht u viel implizite "Magic" in der Implementierung zu haben. Zuerst hatte ich bei der Implementierung überlegt einen Mapping-Table mitgeben zu lassen, das ist allerdings dann fast so aufwendig als gleich im Controller das Mapping zu implementieren. Für den Anwendungsfall des GORM funktioniert das dann selbst mit generierten DTOs/Models leider nicht.

Deinen Ansatz über eine stdClass finde ich gut. Hatte mir bei der Code-Analyse noch überlegt, ob so ein zusätzlicher Mapper nicht auch dem GORM-Package beiliegen könnte statt dem HtmlFormTag. Das fände ich sauberer. Weitere Möglichkeit wäre bei der Generierung der Domänen-Objekte über das GORM-Tool die Properties mit in die Klassen-Deklaration zu generieren und die Getter und Setter entsprechend umzubiegen. Dann sollte das Befüllen und auslesen sogar nativ funktionieren.

Vorschlag: als kurzfristige Lösung gehen wir deinen Weg und liefern einen zusätzlichen Mapper mit dem GORM mit, langfristig erweitern wir den GORM, dass du bei generierten DTOs auch gleich die Properties in der abstrakten Klasse hast und das setProperties() dort auch die entsprechenden Properties nutzt.

Einverstanden?
Viele Grüße,
Christian

GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

Re: [3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 29.08.2017, 12:15:18

Ja im GORM würde das ganze natürlich eher rein passen von der Logik her das viel mir auch selbst noch auf. Mein Ansatz war erst mal das der Progger nicht mehr Code generieren muss für diese Funktion.

Ich bin gespannt auf das entresultat und nutze solange meinen Workaround weiter wenn ich etwas neues baue.

mfg Christian.

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 30.08.2017, 10:58:12

Hallo Christian,

so machen wir das! Ich lege noch einen Tracker-Eintrag an, damit ich das Thema weiter verfolgen kann.

Sollten dir in der Zwischenzeit noch weitere Punkte auffallen, lass mich dein Feedback gerne wissen! :)
Viele Grüße,
Christian

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 30.08.2017, 19:59:27

Viele Grüße,
Christian

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 02.09.2017, 19:21:02

Hallo Christian,

ich habe die Implementierung nun (lokal) so angepasst, dass der GenericORMapperDomainObjectGenerator die DTOs mit "echten" Properties generiert. Ein Beispiel aus dem UMGT:

Code: Alles auswählen

namespace APF\modules\usermanagement\biz\model;

//<*UmgtRoleBase:start*> DO NOT CHANGE THIS COMMENT!
/**
 * Automatically generated BaseObject for UmgtRole. !!DO NOT CHANGE THIS BASE-CLASS!!
 * CHANGES WILL BE OVERWRITTEN WHEN UPDATING!!
 * You can change class "UmgtRole" which extends this base-class.
 */
use APF\modules\genericormapper\data\GenericDomainObject;

/**
 * This class provides the descriptive getter and setter methods for the "APF\modules\usermanagement\biz\model\UmgtRole" domain object.
 */
abstract class UmgtRoleBase extends GenericDomainObject {

   /**
    * @var string The value for property "DisplayName".
    */
   protected $DisplayName;

   /**
    * @var string The value for property "Description".
    */
   protected $Description;

   /**
    * @var int The value for the object's ID.
    */
   protected $RoleID;

   /**
    * @var string The creation timestamp.
    */
   protected $CreationTimestamp;

   /**
    * @var string The modification timestamp.
    */
   protected $ModificationTimestamp;

   protected $propertyNames = [
       'RoleID',
       'CreationTimestamp',
       'ModificationTimestamp',
       'DisplayName',
       'Description'
    ];

   public function __construct($objectName = null) {
      parent::__construct('Role');
   }

   public function getProperty($name) {
      if (in_array($name, $this->propertyNames)) {
         return $this->$name;
      }

      return null;
   }

   public function setProperty($name, $value) {
      if (in_array($name, $this->propertyNames)) {
         $this->$name = $value;
      }
   }

   public function getProperties() {
      $properties = []; 
      foreach ($this->propertyNames as $name) {
         if ($this->$name !== null) {
            $properties[$name] = $this->$name;
         }
      }
      return $properties;
   }

   public function setProperties($properties = []) {
      foreach ($properties as $key => $value) {
         if (in_array($key, $this->propertyNames)) {
            $this->$key = $value;
         }
      }
   }

   public function deleteProperty($name) {
      if (in_array($name, $this->propertyNames)) {
         $this->$name = null;
      }
   }

   public function setObjectId($id) {
      $this->RoleID = $id;
   }

   public function getObjectId() {
      return $this->RoleID;
   }

   public function __sleep() {
      return [
            'objectName',
            'RoleID',
            'CreationTimestamp',
            'ModificationTimestamp',
            'DisplayName',
            'Description',
            'relatedObjects'
      ];
   }

   /**
    * @return string The value for property "DisplayName".
    */
   public function getDisplayName() {
      return $this->getProperty('DisplayName');
   }

   /**
    * @param string $value The value to set for property "DisplayName".
    *
    * @return UmgtRole The domain object for further usage.
    */
   public function setDisplayName($value) {
      $this->setProperty('DisplayName', $value);

      return $this;
   }

   /**
    * @return UmgtRole The domain object for further usage.
    */
   public function deleteDisplayName() {
      $this->deleteProperty('DisplayName');

      return $this;
   }

   /**
    * @return string The value for property "Description".
    */
   public function getDescription() {
      return $this->getProperty('Description');
   }

   /**
    * @param string $value The value to set for property "Description".
    *
    * @return UmgtRole The domain object for further usage.
    */
   public function setDescription($value) {
      $this->setProperty('Description', $value);

      return $this;
   }

   /**
    * @return UmgtRole The domain object for further usage.
    */
   public function deleteDescription() {
      $this->deleteProperty('Description');

      return $this;
   }

}

// DO NOT CHANGE THIS COMMENT! <*UmgtRoleBase:end*>
In einem Unit Test konnte ich damit testen, dass das Befüllen und Auslesen des Models korrekt funktioniert:

Code: Alles auswählen

/**
 * Test form mapping capabilities for "new" domain objects.
 */
public function testFormMapping() {

   $_REQUEST = [];
   $_POST = [];
   $_GET = [];

   $form = new HtmlFormTag();

   $doc = new Document();
   $form->setParentObject($doc);

   $form->setAttribute('name', 'foo');
   $form->setContent('<form:text name="Name" />
   <form:text name="Value" />
   <form:button name="send" value="send" />');

   $form->onParseTime();
   $form->onAfterAppend();

   $name = $form->getFormElementByName('Name');
   $this->assertEmpty($name->getValue());

   $value = $form->getFormElementByName('Value');
   $this->assertEmpty($value->getValue());

   // test form presetting
   $model = new \APF\tests\suites\modules\genericormapper\tools\test\Dummy();
   $model->setName('Foo');
   $model->setValue('Bar');

   $form->fillForm($model);

   $this->assertEquals('Foo', $name->getValue());
   $this->assertEquals('Bar', $value->getValue());

   // test model presetting
   $model = new \APF\tests\suites\modules\genericormapper\tools\test\Dummy();

   $this->assertNull($model->getName());
   $this->assertNull($model->getValue());

   $form->fillModel($model);

   $this->assertEquals('Foo', $model->getName());
   $this->assertEquals('Bar', $model->getValue());

}
Das dazugehörige DTO sieht wie folgt aus:

Code: Alles auswählen

namespace APF\tests\suites\modules\genericormapper\tools\test;

/**
 * This class represents the "APF\tests\suites\modules\genericormapper\tools\test\Dummy" domain object.
 * <p/>
 * Please use this class to add your own functionality.
 */
class Dummy extends DummyBase {

   /**
    * Call the parent's constructor because the object name needs to be set.
    * <p/>
    * To create an instance of this object, just call
    * <code>
    * use APF\tests\suites\modules\genericormapper\tools\test\Dummy;
    * $object = new Dummy();
    * </code>
    *
    * @param string $objectName The internal object name of the domain object.
    */
   public function __construct($objectName = null) {
      parent::__construct();
   }

}

namespace APF\tests\suites\modules\genericormapper\tools\test;

//<*DummyBase:start*> DO NOT CHANGE THIS COMMENT!
/**
 * Automatically generated BaseObject for Dummy. !!DO NOT CHANGE THIS BASE-CLASS!!
 * CHANGES WILL BE OVERWRITTEN WHEN UPDATING!!
 * You can change class "Dummy" which extends this base-class.
 */
use APF\modules\genericormapper\data\GenericDomainObject;

/**
 * This class provides the descriptive getter and setter methods for the "APF\tests\suites\modules\genericormapper\tools\test\Dummy" domain object.
 */
abstract class DummyBase extends GenericDomainObject {

   /**
    * @var string The value for property "Name".
    */
   protected $Name;

   /**
    * @var string The value for property "Value".
    */
   protected $Value;

   /**
    * @var int The value for the object's ID.
    */
   protected $DummyID;

   /**
    * @var string The creation timestamp.
    */
   protected $CreationTimestamp;

   /**
    * @var string The modification timestamp.
    */
   protected $ModificationTimestamp;

   protected $propertyNames = [
       'DummyID',
       'CreationTimestamp',
       'ModificationTimestamp',
       'Name',
       'Value'
    ];

   public function __construct($objectName = null) {
      parent::__construct('Dummy');
   }

   public function getProperty($name) {
      if (in_array($name, $this->propertyNames)) {
         return $this->$name;
      }

      return null;
   }

   public function setProperty($name, $value) {
      if (in_array($name, $this->propertyNames)) {
         $this->$name = $value;
      }
   }

   public function getProperties() {
      $properties = []; 
      foreach ($this->propertyNames as $name) {
         if ($this->$name !== null) {
            $properties[$name] = $this->$name;
         }
      }
      return $properties;
   }

   public function setProperties($properties = []) {
      foreach ($properties as $key => $value) {
         if (in_array($key, $this->propertyNames)) {
            $this->$key = $value;
         }
      }
   }

   public function deleteProperty($name) {
      if (in_array($name, $this->propertyNames)) {
         $this->$name = null;
      }
   }

   public function setObjectId($id) {
      $this->DummyID = $id;
   }

   public function getObjectId() {
      return $this->DummyID;
   }

   public function __sleep() {
      return [
            'objectName',
            'DummyID',
            'CreationTimestamp',
            'ModificationTimestamp',
            'Name',
            'Value',
            'relatedObjects'
      ];
   }

   /**
    * @return string The value for property "Name".
    */
   public function getName() {
      return $this->getProperty('Name');
   }

   /**
    * @param string $value The value to set for property "Name".
    *
    * @return Dummy The domain object for further usage.
    */
   public function setName($value) {
      $this->setProperty('Name', $value);

      return $this;
   }

   /**
    * @return Dummy The domain object for further usage.
    */
   public function deleteName() {
      $this->deleteProperty('Name');

      return $this;
   }

   /**
    * @return string The value for property "Value".
    */
   public function getValue() {
      return $this->getProperty('Value');
   }

   /**
    * @param string $value The value to set for property "Value".
    *
    * @return Dummy The domain object for further usage.
    */
   public function setValue($value) {
      $this->setProperty('Value', $value);

      return $this;
   }

   /**
    * @return Dummy The domain object for further usage.
    */
   public function deleteValue() {
      $this->deleteProperty('Value');

      return $this;
   }

}

// DO NOT CHANGE THIS COMMENT! <*DummyBase:end*>
Darf ich dich um einen Test in deiner Applikation bitten? Entweder du passt deine DTOs selbst an oder ich stelle dir den aktuellen Code als neuen Branch auf github.com zur Verfügung. Ich möchte den Code noch nicht einchecken, da ich gerne die Änderungen ausführlich an Hand des UMGT-Moduls testen möchte.

Freue mich auf deine Rückmeldung! :)
Viele Grüße,
Christian

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 03.09.2017, 18:31:02

Hallo Christian,

habe die Funktionalität nun soweit getestet, dass ich sie als "stable" bezeichnen kann. Das UMGT-Modul funktioniert sauber und auch die restlichen, auf dem GORM-basierten Applikationen, die ich geschrieben habe, laufen.

Die Erweiterung des GORM DTO Tool findest du unter https://github.com/AdventurePHP/code/ und kannst sie dort direkt herunter laden. Alternativ kannst du auch mit Composer auf den "dev-master"-Zweig (https://packagist.org/packages/apf/apf#dev-master) aktualisieren.

Bin gespannt auf deine Test-Ergebnisse. :)
Viele Grüße,
Christian

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 05.09.2017, 22:16:51

Hallo Christian,

ich habe nun auch die Dokumentation abgeschlossen. Die Änderungen dazu kannst du dir unter https://github.com/AdventurePHP/docs/co ... 1e9f30fc82 ansehen.

Bin gespannt auf dein Feedback! :)
Viele Grüße,
Christian

GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

Re: [3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 06.09.2017, 13:41:05

Man da schaut man mal ne woche nicht mehr ins Forum und dann kommt da einiges hinzu...... muss mal die Benachrichtigungen aktivieren.

Ich schaue mir das ganze mal an aber sehe ich es nun richtig das die Models nun wieder wie früher alle daten direkt besitzen und sie nicht mehr im Array Properties vorhanden sind? Wie ist es mit der Funktion get und set Property ist dieses noch funktionsfähig? Das war der erste gedanke ohne rein zu schauen das mach ich nachher mal.


Nachtrag:
Ok die Funktion wurde angepasst habs gesehen. Würde also bedeuten das alle Models geupdatet werden müssen damit das ganze in 3.4 Funktioniert.

Nachtrag vom Nachtrag :lol: :
Jetz weis ich was mich verwirrt. Du nutzt in deinem test die UmgtRoleBase und hast diese angepasst zu der neuen Funktionalität. In der Doku steht drin das man das nur mit eigenen Objekten machen kann die sozusagen deine UmgtRoleBase Änderung besitzen. Fazit ist es nun notwendig jede Klasse dementsprechend an zu passen nur um das Feature nutzen zu können. Das war ja das was ich verhindern wollte.

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 06.09.2017, 18:11:35

Hallo Christian,

ja, die Anpassung ging doch schneller und unkomplizierter als gedacht! :)

Korrekt, die Funktionalität funktioniert nur mit Klassen, die - allgemein gesprochen - "echte" (=statische) Klassen-Properties besitzten.

Die Anpassung deiner Klassen übernimmt der GenericORMapperDomainObjectGenerator für dich. Dieser generiert an Hand der Klassen-Definition eine Base- und eine DTO-Klasse. Lässt du das Tool nochmal laufen, generiert es dir die neue Base-Klassen-Struktur ohne, dass du manuell Hand anlegen musst.

Schau dir mal http://adventure-php-framework.org/Seit ... enerierung an, dort ist beschrieben wir du Objekte generierst und auch gleichzeitig aktualisierst.

Hoffe das hilft dir! :)
Viele Grüße,
Christian

GeneralCrime
Beiträge: 91
Registriert: 14.12.2011, 07:13:16
Kontaktdaten:

Re: [3.3] HtmlFormTag->formFill()

Beitrag von GeneralCrime » 11.09.2017, 13:07:21

Ok jetzt weis ich was mich verwirrt!

In der geänderte Doku sprichst Du davon das das Toll nur mit eigenen Domain Objhekten nutzbar ist weil der Gorm halt die Daten in ein Array legt.
Aber die Änderung die Du gemacht hast ist ja wenn ich es richtig verstanden habe wieder zum alten System das die Daten in keinem Array liegen.
Sonst würde mir ein Update meiner Models mit dem Gorm ja nichts bringen es würde ja sogesehen beim alten bleiben (also im Array).

Benutzeravatar
dr.e.
Administrator
Beiträge: 4606
Registriert: 04.11.2007, 16:13:53

Re: [3.3] HtmlFormTag->formFill()

Beitrag von dr.e. » 11.09.2017, 15:27:31

Hallo Christian,
Ok jetzt weis ich was mich verwirrt!
Das tut mir leid! :roll:
In der geänderte Doku sprichst Du davon das das Toll nur mit eigenen Domain Objhekten nutzbar ist weil der Gorm halt die Daten in ein Array legt.
Korrekt. Gemeint ist folgendes: in der Standard-Konfiguration des GORM wird als Domänen-Objekt/DTO/Model die Klasse GenericDomainObject verwendet. Fragst du z.B. ein Objekt oder eine Liste an erhälst du eine Instanz oder eine Liste vom Typ GenericDomainObject. Damit funktioniert das Feature nicht, da die Implementierung von GenericDomainObject die Eigenschaften im internen Array

Code: Alles auswählen

protected $properties = [];
verwaltet. Das ist meiner Ansicht nach auch ok, denn ich kann im Vorfeld ja nicht wissen, welche Properties du in deiner *_objects.ini definierst - hier kann der GORM ja nur generisch sein.
Aber die Änderung die Du gemacht hast ist ja wenn ich es richtig verstanden habe wieder zum alten System das die Daten in keinem Array liegen.
Nicht ganz. Setzt du keine eigenen Domänen-Objekte/DTOs/Models ein, so werden die Daten immer noch in einem Array gehalten. Generierst du dir hingegen eigene Domänen-Objekte/DTOs/Models, so kann der Generator (GenericORMapperDomainObjectGenerator) ja basieren auf der *_objects.ini schon für deine Applikation vorkonfektionierte Domänen-Objekte/DTOs/Models generieren und dabei auch gleich dafür sorgen, dass die Properties als eigene Klassen-Variablen ausgeführt werden.

Hoffe das hilft dir fürs Verständnis! :)
Viele Grüße,
Christian

Antworten