FormBuilder - Feld nicht in data eintragen

Hanashi · August 18, 2021 at 7:25 PM

Hallo,

kann man bei SingleSelectionFormField irgendwie einstellen, dass das Feld nach dem Absenden nicht im data-Array von $this->form->getData() ist, sondern zum Beispiel in data2? Ich möchte, dass dieses Feld nicht mit an die DB übergeben wird, sondern vorm Speichern separat verarbeiten.

gn5VmUKCtv6ekrMf · August 18, 2021 at 7:39 PM

Validation and Data - WoltLab Suite Documentation

PHP: MySpecialCoolForm.class.php

    /**
     * @inheritDoc
     */
    public function buildForm() {
        parent::buildForm();
                
        $this->form->getDataHandler()->addProcessor(new CustomFormDataProcessor('fooop', function(IFormDocument $document, array $parameters) {
            if (isset($parameters['data']['bar'])) {
                $parameters['data2']['bar'] = $parameters['data']['bar'];
                unset($parameters['data']['bar']);
            }
            
            return $parameters;
        }));
    }

Display More

Hanashi · August 18, 2021 at 7:42 PM

Habe mir jetzt eine Klasse gebaut, die von SingleSelectionFormField erbt und das wie folgt gemacht:

PHP

class CustomSingleSelectionFormField extends SingleSelectionFormField
{
    /**
     * @inheritDoc
     */
    public function hasSaveValue()
    {
        return false;
    }

    /**
     * @inheritDoc
     */
    public function populate()
    {
        parent::populate();

        $this->getDocument()->getDataHandler()->addProcessor(new CustomFormDataProcessor(
            'customSelection',
            function (IFormDocument $document, array $parameters) {
                $parameters[$this->getObjectProperty()] = $this->getValue();

                return $parameters;
            }
        ));

        return $this;
    }
}

Display More

Danke dir

**Tim Düsterhus** · August 19, 2021 at 9:17 AM Official Post

Hallo,

Quote from Hanashi

erbt

bitte.nicht.erben. An bestehende Klassen kann ich leider kein final dran schreiben

Benutz' (ungetestet) Composition:

PHP

<?php

final class MyFancyFormField implements IFormField
{
 private $f;
 public function __construct(SingleSelectionFormField $f) { $this->f = $f; }
 public function getValue() { return $this->f->getValue(); }
 public function value($value) { $this->f->value($value); return $this; }
 public function populate()
 {
  /* Passende Implementierung goes here. */
 }
}

Display More

Diese ziemlich redundante Boilerplate kann man ggf. dann in ein AbstractFormFieldDecorator auslagern. Im Zweifel freue ich mich da auch über PRs.

Hanashi · August 19, 2021 at 10:16 AM

Wäre hier jetzt nicht noch ein extends AbstractFormField wichtig? Ansonsten sagt mir mein Intellisense:

Code

does not implement methods 'addValidationError', 'addValidator', 'getFieldHtml', 'getJavaScriptDataHandlerModule', 'getObjectProperty', 'getSaveValue', 'getValidationErrors', 'getValidators', 'getValue', 'hasValidator', 'isRequired', 'updatedObject', 'objectProperty', 'readValue', 'removeValidator', 'required', 'value', 'getParent', 'parent', 'addClass', 'addClasses', 'addDependency', 'attribute', 'available', 'cleanup', 'checkDependencies', 'getAttribute', 'getAttributes', 'getClasses', 'getDependencies', 'getDocument', 'getHtml', 'getHtmlVariables', 'getId', 'getPrefixedId', 'hasAttribute', 'hasClass', 'hasDependency', 'id', 'removeAttribute', 'removeClass', 'removeDependency', 'validate', 'create', 'validateAttribute', 'validateClass', 'validateId', 'description', 'getDescription', 'getLabel', 'label', 'requiresLabel'

gn5VmUKCtv6ekrMf · August 19, 2021 at 10:30 AM

Effektiv kannst du einfach die Klasse SingleSelectionFormField 1:1 kopieren und dann deine Änderungen an der Klasse vornehmen. Dann ist Tim zufrieden und du musst nicht alles selbst implementieren bzw. kannst es von Zeit zu Zeit diffen.

Genau das ist übrigens auch der Grund, warum es Vererbungen gibt; damit man eben nicht jeden Furz kopieren muss, nur, weil man einen Parameter ändern will/muss.

Hanashi · August 19, 2021 at 10:31 AM

Quote from MysteryCode

Genau das ist übrigens auch der Grund, warum es Vererbungen gibt; damit man eben nicht jeden Furz kopieren muss, nur, weil man einen Parameter ändern will/muss.

Aber wenn ich Tim richtig verstehe, will er, dass ich eben keine Vererbungen benutze.

gn5VmUKCtv6ekrMf · August 19, 2021 at 10:49 AM

Ja, das verstehst du auch richtig. Wir sind da unterschiedlicher Auffassung.

**Tim Düsterhus** · August 19, 2021 at 11:21 AM Official Post

Hallo,

Quote from Hanashi

Wäre hier jetzt nicht noch ein extends AbstractFormField wichtig? Ansonsten sagt mir mein Intellisense:

Ich habe es nicht im Detail geprüft, vermutlich ist das AbstractFormField das falsche, da du den Großteil der Methoden an die gewrappte Klasse weitergeben möchtest. Deswegen auch der Hinweis auf ein neues AbstractFormFieldDecorator. Ich sehe auch kein Problem darin einen solchen Decorator noch mit 5.4 nachzuliefern, wenn er sauber entworfen ist.

Quote from MysteryCode

Effektiv kannst du einfach die Klasse SingleSelectionFormField 1:1 kopieren und dann deine Änderungen an der Klasse vornehmen.

Das ginge auch, aber nur, wenn dann auch das Template und das dazugehörige JavaScript ebenfalls kopiert wird.

Quote from MysteryCode

Genau das ist übrigens auch der Grund, warum es Vererbungen gibt; damit man eben nicht jeden Furz kopieren muss, nur, weil man einen Parameter ändern will/muss.

Nein, genau dafür ist Vererbung nicht gedacht, weil das typischerweise das Liskovsches Substitutionsprinzip verletzt. Hanashis individuelles Feld kann nicht überall da eingesetzt werden wo das ursprüngliche Feld eingesetzt werden kann. Es erweitert die Funktionalität nicht, es ändert sie. Dafür benutzt man Composition (und Interfaces). Vererbung ist wohl die am häufigsten falsch verwendete Funktionalität in der Objekt-orientierten Programmierung. Daran sind vermutlich auch die vielen schlechten Beispiele aus irgendwelchen Tutorials die sich an realen Objekten orientieren („Auto erbt von Reifenfahrzeug erbt von Fahrzeug“) schuld.

Hier mal ein wenig Lektüre: https://www.thoughtworks.com/insights/blog/…ance-how-choose

Hanashi · August 19, 2021 at 6:44 PM

Hallo,

ich habe jetzt bisschen probiert einen Decorator zu basteln, aber ich habe das Gefühl, dass ich den völlig falschen Ansatz verfolge. Ich habe mich dabei am DatabaseObjectDecorator orientiert und folgendes gebaut:

PHP

<?php

namespace wcf\system\form\builder\field;

use wcf\system\exception\SystemException;

abstract class AbstractFormFieldDecorator extends AbstractFormField
{
    protected static $baseClass = '';

    protected $field;

    public function __construct(IFormField $field)
    {
        if (empty(static::$baseClass)) {
            throw new SystemException('Base class not specified');
        }

        if (!($field instanceof static::$baseClass)) {
            throw new SystemException("Object does not match '" . static::$baseClass . "' (given object is of class '" . \get_class($field) . "')");
        }

        $this->field = $field;
    }

    public function __call($name, $arguments)
    {
        if (!\method_exists($this->field, $name) && !($this->field instanceof self)) {
            throw new SystemException("unknown method '" . $name . "'");
        }

        \call_user_func_array([$this->field, $name], $arguments);

        return $this;
    }

    public function readValue()
    {
        $this->field->readValue();
    }
}

Display More

Problem ist jetzt, dass die Methode nicht weitergereicht werden (trotz __call), weil sie bereits im Elternelement existieren. Dann habe ich folgendes probiert:

abstract class AbstractFormFieldDecorator implements IFormField { ... }

und dort dann alle Funktionen vom Interface implementiert und an die Field-Klasse weitergereicht, welche im Konstruktor steht, aber bin mir hier auch noch unsicher ob das richtig wäre. Meine __call-Methode wäre auf jeden Fall falsch

gn5VmUKCtv6ekrMf · August 19, 2021 at 7:45 PM

Quote from Hanashi

Problem ist jetzt, dass die Methode nicht weitergereicht werden (trotz __call), weil sie bereits im Elternelement existieren

Redest du von parent::getSaveValue()? Für das Fallback müsstest du dann $this->getDecoratedField()->getSaveValue() nutzen. getDecoratedField() ist in deinem Example noch nicht implementiert - just bevor du kopierst und dich wunderst, was ich rede.

Ich hätte es so kopiert: https://github.com/mutec/WCF/comm…cb4f5b71b12080d

Hanashi · August 19, 2021 at 8:01 PM

Quote from MysteryCode

Redest du von parent::getSaveValue()

Nicht nur davon, im Prinzip von jeder Methode.

gn5VmUKCtv6ekrMf · August 19, 2021 at 8:04 PM

Quote from Hanashi

Nicht nur davon, im Prinzip von jeder Methode.

Magst du mal evtl. anhand des Commits oder deines Codes die neue Klasse zeigen und demonstrieren, was du meinst? Nicht-Öffentliche Wege kennst du ja.

Hanashi · August 19, 2021 at 8:54 PM

Also meine Idee wäre jetzt folgendes:

PHP

<?php

namespace wcf\system\form\builder\field;

use wcf\data\IStorableObject;
use wcf\system\exception\SystemException;
use wcf\system\form\builder\field\dependency\IFormFieldDependency;
use wcf\system\form\builder\field\validation\IFormFieldValidationError;
use wcf\system\form\builder\field\validation\IFormFieldValidator;
use wcf\system\form\builder\IFormParentNode;

class AbstractFormFieldDecorator implements IFormField
{
    protected static $baseClass = '';

    protected $field;

    public function __construct(IFormField $field)
    {
        if (empty(static::$baseClass)) {
            throw new SystemException('Base class not specified');
        }

        if (!($field instanceof static::$baseClass)) {
            throw new SystemException("Object does not match '" . static::$baseClass . "' (given object is of class '" . \get_class($field) . "')");
        }

        $this->field = $field;
    }

    public function __call($name, $arguments)
    {
        if (!\method_exists($this->field, $name) && !($this->field instanceof self)) {
            throw new SystemException("unknown method '" . $name . "'");
        }

        $response = \call_user_func_array([$this->getDecoratedObject(), $name], $arguments);
        if ($response instanceof static::$baseClass) {
            return $this;
        }

        return $response;
    }

    public function getDecoratedObject()
    {
        return $this->field;
    }

    public function addValidationError(IFormFieldValidationError $error)
    {
        $this->getDecoratedObject()->addValidationError($error);

        return $this;
    }

    public function addValidator(IFormFieldValidator $validator)
    {
        $this->getDecoratedObject()->addValidator($validator);

        return $this;
    }

    public function getFieldHtml()
    {
        return $this->getDecoratedObject()->getFieldHtml();
    }

    public function getJavaScriptDataHandlerModule()
    {
        return $this->getDecoratedObject()->getJavaScriptDataHandlerModule();
    }

    public function getObjectProperty()
    {
        return $this->field->getObjectProperty();
    }

    public function getSaveValue()
    {
        return $this->getDecoratedObject()->getSaveValue();
    }
    
    public function getValidationErrors()
    {
        return $this->getDecoratedObject()->getValidationErrors();
    }

    public function getValidators()
    {
        return $this->getDecoratedObject()->getValidators();
    }

    public function getValue()
    {
        return $this->getDecoratedObject()->getValue();
    }

    public function hasValidator($validatorId)
    {
        return $this->getDecoratedObject()->hasValidator($validatorId);
    }

    public function hasSaveValue()
    {
        return $this->getDecoratedObject()->hasSaveValue();
    }

    public function isRequired()
    {
        return $this->getDecoratedObject()->isRequired();
    }

    public function updatedObject(array $data, IStorableObject $object, $loadValues = true)
    {
        $this->getDecoratedObject()->updatedObject($data, $object, $loadValues);

        return $this;
    }

    public function objectProperty($objectProperty)
    {
        $this->getDecoratedObject()->objectProperty($objectProperty);

        return $this;
    }

    public function readValue()
    {
        $this->getDecoratedObject()->readValue();

        return $this;
    }

    public function removeValidator($validatorId)
    {
        $this->getDecoratedObject()->removeValidator($validatorId);

        return $this;
    }

    public function required($required = true)
    {
        $this->getDecoratedObject()->required($required);

        return $this;
    }

    public function value($value)
    {
        $this->getDecoratedObject()->value($value);

        return $this;
    }

    public function getParent()
    {
        return $this->getDecoratedObject()->getParent();
    }

    public function parent(IFormParentNode $parentNode)
    {
        $this->getDecoratedObject()->parent($parentNode);

        return $this;
    }

    public function addClass($class)
    {
        $this->getDecoratedObject()->addClass($class);

        return $this;
    }

    public function addClasses(array $classes)
    {
        $this->getDecoratedObject()->addClasses($classes);

        return $this;
    }

    public function addDependency(IFormFieldDependency $dependency)
    {
        $this->getDecoratedObject()->addDependency($dependency);

        return $this;
    }

    public function attribute($name, $value = null)
    {
        $this->getDecoratedObject()->attribute($name, $value);

        return $this;
    }

    public function available($available = true)
    {
        $this->getDecoratedObject()->available($available);

        return $this;
    }

    public function cleanup()
    {
        $this->getDecoratedObject()->cleanup();

        return $this;
    }

    public function checkDependencies()
    {
        return $this->getDecoratedObject()->checkDependencies();
    }

    public function getAttribute($name)
    {
        return $this->getDecoratedObject()->getAttribute($name);
    }

    public function getAttributes()
    {
        return $this->getDecoratedObject()->getAttributes();
    }

    public function getClasses()
    {
        return $this->getDecoratedObject()->getClasses();
    }

    public function getDependencies()
    {
        return $this->getDecoratedObject()->getDependencies();
    }

    public function getDocument()
    {
        return $this->getDecoratedObject()->getDocument();
    }

    public function getHtml()
    {
        return $this->getDecoratedObject()->getHtml();
    }

    public function getHtmlVariables()
    {
        return $this->getDecoratedObject()->getHtmlVariables();
    }

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

    public function getPrefixedId()
    {
        return $this->getDecoratedObject()->getPrefixedId();
    }

    public function hasAttribute($name)
    {
        return $this->getDecoratedObject()->hasAttribute($name);
    }

    public function hasClass($class)
    {
        return $this->getDecoratedObject()->hasClass($class);
    }

    public function hasDependency($dependencyId)
    {
        return $this->getDecoratedObject()->hasDependency($dependencyId);
    }

    public function id($id)
    {
        $this->getDecoratedObject()->id($id);

        return $this;
    }

    public function isAvailable()
    {
        return $this->getDecoratedObject()->isAvailable();
    }

    public function populate()
    {
        $this->getDecoratedObject()->populate();

        return $this;
    }

    public function removeAttribute($name)
    {
        $this->getDecoratedObject()->removeAttribute($name);

        return $this;
    }

    public function removeClass($class)
    {
        $this->getDecoratedObject()->removeClass($class);

        return $this;
    }

    public function removeDependency($dependencyId)
    {
        $this->getDecoratedObject()->removeDependency($dependencyId);

        return $this;
    }

    public function validate()
    {
        $this->getDecoratedObject()->validate();
    }

    public static function create($id)
    {
        return new static(static::$baseClass::create($id));
    }

    public static function validateAttribute($name)
    {
        static::$baseClass::validateAttribute($name);
    }

    public static function validateClass($class)
    {
        static::$baseClass::validateClass($class);
    }

    public static function validateId($id)
    {
        static::$baseClass::validateId($id);
    }

    public function description($languageItem = null, array $variables = [])
    {
        $this->getDecoratedObject()->description($languageItem, $variables);

        return $this;
    }

    public function getDescription()
    {
        return $this->getDecoratedObject()->getDescription();
    }

    public function getLabel()
    {
        return $this->getDecoratedObject()->getLabel();
    }

    public function label($languageItem = null, array $variables = [])
    {
        $this->getDecoratedObject()->label($languageItem, $variables);

        return $this;
    }

    public function requiresLabel()
    {
        return $this->getDecoratedObject()->requiresLabel();
    }
}

Display More

Prinzipiell klappt das auch, aber das wäre doch ziemlich überladen, oder?

**Tim Düsterhus** · August 20, 2021 at 10:29 AM Official Post

Hallo,

Quote from Hanashi

Prinzipiell klappt das auch, aber das wäre doch ziemlich überladen, oder?

Genau so soll es aussehen, du implementierst genau die Funktionen des Interfaces. Die Decorators bei den DatabaseObjects sind leider kein besonders gutes Beispiel und verdienen den Namen eigentlich nicht. Die ->getDecoratedObject()-Methode sollte eigentlich nicht existieren müssen, ist da aber dem Mangel an Interfaces geschuldet. Decorator sollen an allen Stellen des regulären Objekts als Drop-In-Replacement funktionieren.

That said: Ein bisschen muss man noch aufräumen.

Entferne __call(). Die Interface-Methoden müssen für die Interoperabilität mit anderem Code ausreichend sein. Etwaige zusätzliche Methoden (mit zusätzlichem Interface) müssten dann in dem spezifischen Decorator implementiert werden (ggf. mit trait).
Entferne $baseClass.
Ergänze das fehlende abstract an der Klasse.
Ergänze einmal das @inheritDoc an jeder Methode.
Ergänze einen Klassenkommentar. Trag dich gerne als Autor ein, du hast die Arbeit gemacht.
Wirf in den 4 statischen Methoden jeweils eine new \BadMethodCallException('This method is available on a decorator.');. Statische Methoden sind in einem Interface absolut nutzlos (weil man eben gar kein Objekt zur Hand hat). Die FormBuilder-Interfaces sind offenbar bisweilen ein wenig überspezifisch. Ich habe eine Issue erstellt, damit man das Interface mit 5.5 ebenfalls aufräumt: https://github.com/WoltLab/WCF/issues/4468
Ansonsten überlege ich noch, ob man das besser als Trait oder als abstrakte Klasse löst.

Dass das ein wenig überladen (ich würde eher sagen: „voll“) wirkt, liegt einfach daran, dass die FormField eine recht umfangreiche API haben. Aber dafür implementiert man die Methoden ja einmalig in der Elternklasse.

Benutzung ist dafür hinterher ganz simpel:

PHP

<?php
final class NoSaveValueDecorator extends AbstractFormFieldDecorator
{
    public function hasSaveValue()
    {
        return false;
    }
}

oder wenn die Implementierung nur für bestimmte Klassen sinnvoll ist:

PHP

<?php
final class MinimalMaximumDecorator extends AbstractFormFieldDecorator
    implements IMaximumLengthFormField
{
    private $minimum = 0;

    /**
     * @var IMaximumLengthFormField
     */
    protected $field;

    public function __construct(IMaximumLengthFormField $field, int $minimum)
    {
        parent::__construct($field);

        $this->minimum = $minimum;

        if ($field->getMaximumLength() < $this->minimum) {
            throw new \InvalidArgumentException('Existing maximum is lower than the minimal maximum.');
        }
    }

    public function getMaximumLength()
    {
        return $this->field->getMaximumLength();
    }

    public function maximumLength($maximumLength = null)
    {
        if ($maximumLength < $this->minimum) {
            throw new \InvalidArgumentException('Maximum is lower than the minimal maximum.');
        }

        $this->field->maximumLength($maximumLength);

        return $this;
    }

    public function validateMaximumLength($text, ?Language $language = null)
    {
        $this->field->validateMaximumLength($text, $language);
    }
}

Display More

Hanashi · August 20, 2021 at 10:40 AM

Hallo,

dann wäre das jetzt die angepasste Klasse:

PHP

<?php

namespace wcf\system\form\builder\field;

use wcf\data\IStorableObject;
use wcf\system\form\builder\field\dependency\IFormFieldDependency;
use wcf\system\form\builder\field\validation\IFormFieldValidationError;
use wcf\system\form\builder\field\validation\IFormFieldValidator;
use wcf\system\form\builder\IFormParentNode;

/**
 * Decorator for form field objects.
 *
 * @author  Peter Lohse
 * @copyright   2001-2021 WoltLab GmbH
 * @license GNU Lesser General Public License <http://opensource.org/licenses/lgpl-license.php>
 * @package WoltLabSuite\Core\System\Form\Builder\Field
 * @since   5.4
 */
abstract class AbstractFormFieldDecorator implements IFormField
{
    /**
     * decorated field
     *
     * @var IFormField
     */
    protected $field;
    
    /**
     * Creates a decorator object for form fields
     *
     * @param  IFormField $field
     * @return void
     */
    public function __construct(IFormField $field)
    {
        $this->field = $field;
    }

    /**
     * @inheritDoc
     */
    public function addValidationError(IFormFieldValidationError $error)
    {
        $this->field->addValidationError($error);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function addValidator(IFormFieldValidator $validator)
    {
        $this->field->addValidator($validator);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getFieldHtml()
    {
        return $this->field->getFieldHtml();
    }

    /**
     * @inheritDoc
     */
    public function getJavaScriptDataHandlerModule()
    {
        return $this->field->getJavaScriptDataHandlerModule();
    }

    /**
     * @inheritDoc
     */
    public function getObjectProperty()
    {
        return $this->field->getObjectProperty();
    }

    /**
     * @inheritDoc
     */
    public function getSaveValue()
    {
        return $this->field->getSaveValue();
    }

    /**
     * @inheritDoc
     */
    public function getValidationErrors()
    {
        return $this->field->getValidationErrors();
    }

    /**
     * @inheritDoc
     */
    public function getValidators()
    {
        return $this->field->getValidators();
    }

    /**
     * @inheritDoc
     */
    public function getValue()
    {
        return $this->field->getValue();
    }

    /**
     * @inheritDoc
     */
    public function hasValidator($validatorId)
    {
        return $this->field->hasValidator($validatorId);
    }

    /**
     * @inheritDoc
     */
    public function hasSaveValue()
    {
        return $this->field->hasSaveValue();
    }

    /**
     * @inheritDoc
     */
    public function isRequired()
    {
        return $this->field->isRequired();
    }

    /**
     * @inheritDoc
     */
    public function updatedObject(array $data, IStorableObject $object, $loadValues = true)
    {
        $this->field->updatedObject($data, $object, $loadValues);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function objectProperty($objectProperty)
    {
        $this->field->objectProperty($objectProperty);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function readValue()
    {
        $this->field->readValue();

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function removeValidator($validatorId)
    {
        $this->field->removeValidator($validatorId);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function required($required = true)
    {
        $this->field->required($required);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function value($value)
    {
        $this->field->value($value);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getParent()
    {
        return $this->field->getParent();
    }

    /**
     * @inheritDoc
     */
    public function parent(IFormParentNode $parentNode)
    {
        $this->field->parent($parentNode);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function addClass($class)
    {
        $this->field->addClass($class);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function addClasses(array $classes)
    {
        $this->field->addClasses($classes);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function addDependency(IFormFieldDependency $dependency)
    {
        $this->field->addDependency($dependency);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function attribute($name, $value = null)
    {
        $this->field->attribute($name, $value);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function available($available = true)
    {
        $this->field->available($available);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function cleanup()
    {
        $this->field->cleanup();

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function checkDependencies()
    {
        return $this->field->checkDependencies();
    }

    /**
     * @inheritDoc
     */
    public function getAttribute($name)
    {
        return $this->field->getAttribute($name);
    }

    /**
     * @inheritDoc
     */
    public function getAttributes()
    {
        return $this->field->getAttributes();
    }

    /**
     * @inheritDoc
     */
    public function getClasses()
    {
        return $this->field->getClasses();
    }

    /**
     * @inheritDoc
     */
    public function getDependencies()
    {
        return $this->field->getDependencies();
    }

    /**
     * @inheritDoc
     */
    public function getDocument()
    {
        return $this->field->getDocument();
    }

    /**
     * @inheritDoc
     */
    public function getHtml()
    {
        return $this->field->getHtml();
    }

    /**
     * @inheritDoc
     */
    public function getHtmlVariables()
    {
        return $this->field->getHtmlVariables();
    }

    /**
     * @inheritDoc
     */
    public function getId()
    {
        return $this->field->getId();
    }

    /**
     * @inheritDoc
     */
    public function getPrefixedId()
    {
        return $this->field->getPrefixedId();
    }

    /**
     * @inheritDoc
     */
    public function hasAttribute($name)
    {
        return $this->field->hasAttribute($name);
    }

    /**
     * @inheritDoc
     */
    public function hasClass($class)
    {
        return $this->field->hasClass($class);
    }

    /**
     * @inheritDoc
     */
    public function hasDependency($dependencyId)
    {
        return $this->field->hasDependency($dependencyId);
    }

    /**
     * @inheritDoc
     */
    public function id($id)
    {
        $this->field->id($id);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function isAvailable()
    {
        return $this->field->isAvailable();
    }

    /**
     * @inheritDoc
     */
    public function populate()
    {
        $this->field->populate();

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function removeAttribute($name)
    {
        $this->field->removeAttribute($name);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function removeClass($class)
    {
        $this->field->removeClass($class);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function removeDependency($dependencyId)
    {
        $this->field->removeDependency($dependencyId);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function validate()
    {
        $this->field->validate();
    }

    /**
     * @inheritDoc
     */
    public static function create($id)
    {
        throw new \BadMethodCallException('This method is available on a decorator.');
    }

    /**
     * @inheritDoc
     */
    public static function validateAttribute($name)
    {
        throw new \BadMethodCallException('This method is available on a decorator.');
    }

    /**
     * @inheritDoc
     */
    public static function validateClass($class)
    {
        throw new \BadMethodCallException('This method is available on a decorator.');
    }

    /**
     * @inheritDoc
     */
    public static function validateId($id)
    {
        throw new \BadMethodCallException('This method is available on a decorator.');
    }

    /**
     * @inheritDoc
     */
    public function description($languageItem = null, array $variables = [])
    {
        $this->field->description($languageItem, $variables);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getDescription()
    {
        return $this->field->getDescription();
    }

    /**
     * @inheritDoc
     */
    public function getLabel()
    {
        return $this->field->getLabel();
    }

    /**
     * @inheritDoc
     */
    public function label($languageItem = null, array $variables = [])
    {
        $this->field->label($languageItem, $variables);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function requiresLabel()
    {
        return $this->field->requiresLabel();
    }
}

Display More

Wenn das so passt, würde ich einen entsprechenden PR machen

**Tim Düsterhus** · August 20, 2021 at 10:47 AM Official Post

Hallo,

Quote from Hanashi

Wenn das so passt, würde ich einen entsprechenden PR machen

Sieht im gut aus. Achte darauf den korrekten Target-Branch auszuwählen. Ich hab noch ein paar Anmerkungen, die mache ich dann aber direkt am PR, das ist einfacher, da ich direkt einzelne Zeilen annotieren kann.

Hanashi · August 20, 2021 at 11:02 AM

Hallo,

ich habe den PR erstellt: https://github.com/WoltLab/WCF/pull/4469

Leider hatte ich noch ein paar Spaces zu viel und musste einen korrigierenden Commit machen. Da ich zu blöd bin die Commits zu einem zusammenzufassen, sind es jetzt leider 2 geworden

**Tim Düsterhus** · August 20, 2021 at 11:08 AM Official Post

Hallo,

Quote from Hanashi

Leider hatte ich noch ein paar Spaces zu viel und musste einen korrigierenden Commit machen. Da ich zu blöd bin die Commits zu einem zusammenzufassen, sind es jetzt leider 2 geworden

da kommt ohnehin noch ein Commit für meine Annotationen. Um das Squashing würde ich ich mich hinterher kümmern, hier aber die Kurzanleitung:

1. Die offenen Änderungen in den direkt vorhergehenden Commit integrieren oder die Commit-Nachricht anpassen: git commit --amend.

2. Wenn ältere Commits angepasst werden müssen, dann einen Commit mit den gewünschten Änderungen erstellen und beim interaktiven Rebase git rebase -i 5.4 passend einsortieren und fixup bzw. squash statt pick wählen.

In jeden Fall ist hinterher ein force-Push notwendig: git push origin <mybranch> --force-with-lease.

Morik · August 25, 2021 at 10:14 AM

kann es sein dass die Fehlermeldung um ein "not" erweitert werden müsste ?

Add AbstractFormFieldDecorator (#4469) · WoltLab/WCF@9beed6b

github.com

So ergibt sie mMn nicht wirklich Sinn, selbiges gilt bei den folgenden statischen Methoden.

FormBuilder - Feld nicht in data eintragen

Participate now!

Similar Threads

Einmalcode automatisch ausfüllen (Passwort Manager)

Deaktivierte Smiley-Kategorien werden im FormBuilder WYSIWYG-Field angezeigt und führen zu Fehlermeldung

Deaktivierte User nach Import

Filebase: Dateien wieder nach Namen sortierbar machen? Seit 5.3 nicht mehr möglich.

"required" wird in SingleMediaSelectionFormField ignoriert