HTMLFormFieldCloner.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\HTMLForm\Field;
 
use InvalidArgumentException;
use MediaWiki\Html\Html;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\HTMLForm\HTMLFormField;
use MediaWiki\Parser\Sanitizer;
use MediaWiki\Request\DerivativeRequest;
 
class HTMLFormFieldCloner extends HTMLFormField {
    private static $counter = 0;
 
    protected $uniqueId;
 
    protected $mFields = [];
 
    private bool $nonJsUpdate = false;
 
    public function __construct( $params ) {
        $this->uniqueId = $this->getClassName() . ++self::$counter . 'x';
        parent::__construct( $params );
 
        if ( empty( $this->mParams['fields'] ) || !is_array( $this->mParams['fields'] ) ) {
            throw new InvalidArgumentException( 'HTMLFormFieldCloner called without any fields' );
        }
 
        // Make sure the delete button, if explicitly specified, is sensible
        if ( isset( $this->mParams['fields']['delete'] ) ) {
            $class = 'mw-htmlform-cloner-delete-button';
            $info = $this->mParams['fields']['delete'] + [
                'formnovalidate' => true,
                'cssclass' => $class
            ];
            unset( $info['name'], $info['class'] );
 
            if ( !isset( $info['type'] ) || $info['type'] !== 'submit' ) {
                throw new InvalidArgumentException(
                    'HTMLFormFieldCloner delete field, if specified, must be of type "submit"'
                );
            }
 
            if ( !in_array( $class, explode( ' ', $info['cssclass'] ) ) ) {
                $info['cssclass'] .= " $class";
            }
 
            $this->mParams['fields']['delete'] = $info;
        }
    }
 
    protected function getFieldsForKey( $key ) {
        if ( !isset( $this->mFields[$key] ) ) {
            $this->mFields[$key] = $this->createFieldsForKey( $key );
        }
        return $this->mFields[$key];
    }
 
    protected function createFieldsForKey( $key ) {
        $fields = [];
        foreach ( $this->mParams['fields'] as $fieldname => $info ) {
            $name = "{$this->mName}[$key][$fieldname]";
            if ( isset( $info['name'] ) ) {
                $info['name'] = "{$this->mName}[$key][{$info['name']}]";
            } else {
                $info['name'] = $name;
            }
            if ( isset( $info['id'] ) ) {
                $info['id'] = Sanitizer::escapeIdForAttribute( "{$this->mID}--$key--{$info['id']}" );
            } else {
                $info['id'] = Sanitizer::escapeIdForAttribute( "{$this->mID}--$key--$fieldname" );
            }
            // Copy the hide-if and disable-if rules to "child" fields, so that the JavaScript code handling them
            // (resources/src/mediawiki.htmlform/cond-state.js) doesn't have to handle nested fields.
            if ( $this->mCondState ) {
                foreach ( [ 'hide', 'disable' ] as $type ) {
                    if ( !isset( $this->mCondState[$type] ) ) {
                        continue;
                    }
                    $param = $type . '-if';
                    if ( isset( $info[$param] ) ) {
                        // Hide or disable child field if either its rules say so, or parent's rules say so.
                        $info[$param] = [ 'OR', $info[$param], $this->mCondState[$type] ];
                    } else {
                        // Hide or disable child field if parent's rules say so.
                        $info[$param] = $this->mCondState[$type];
                    }
                }
            }
            $cloner = $this;
            $info['cloner'] = &$cloner;
            $info['cloner-key'] = $key;
            $field = HTMLForm::loadInputFromParameters( $fieldname, $info, $this->mParent );
            $fields[$fieldname] = $field;
        }
        return $fields;
    }
 
    protected function rekeyValuesArray( $key, $values ) {
        $data = [];
        foreach ( $values as $fieldname => $value ) {
            $name = "{$this->mName}[$key][$fieldname]";
            $data[$name] = $value;
        }
        return $data;
    }
 
    protected function parseFieldPath( $name ) {
        $fieldKeys = [];
        while ( preg_match( '/^(.+)\[([^\]]+)\]$/', $name, $m ) ) {
            array_unshift( $fieldKeys, $m[2] );
            $name = $m[1];
        }
        array_unshift( $fieldKeys, $name );
        return $fieldKeys;
    }
 
    public function findNearestField( $field, $find ) {
        $findPath = $this->parseFieldPath( $find );
        // Access to fields as child or in other group is not allowed.
        // Further support for a more complicated path may conduct here.
        if ( count( $findPath ) > 1 ) {
            return null;
        }
        if ( !isset( $this->mParams['fields'][$find] ) ) {
            $cloner = $this->mParams['cloner'] ?? null;
            if ( $cloner instanceof self ) {
                return $cloner->findNearestField( $this, $find );
            }
            return null;
        }
        $fields = $this->getFieldsForKey( $field->mParams['cloner-key'] );
        return $fields[$find];
    }
 
    protected function getFieldPath( $field ) {
        $path = [ $this->mParams['fieldname'], $field->mParams['cloner-key'] ];
        $cloner = $this->mParams['cloner'] ?? null;
        if ( $cloner instanceof self ) {
            $path = array_merge( $cloner->getFieldPath( $this ), $path );
        }
        return $path;
    }
 
    public function extractFieldData( $field, $alldata ) {
        if (
            // Is an empty array when first rendering a form with a formIdentifier.
            count( $alldata ) === 0 ||
            // This field is either part of the cloner template or is newly created
            // for non-JS users, which is not tracked in the form's field data (T391882).
            $field->mParams['cloner-key'] === $this->uniqueId
        ) {
            return $field->getDefault();
        }
 
        foreach ( $this->getFieldPath( $field ) as $key ) {
            $alldata = $alldata[$key];
        }
        return $alldata[$field->mParams['fieldname']];
    }
 
    protected function needsLabel() {
        return false;
    }
 
    public function loadDataFromRequest( $request ) {
        // It's possible that this might be posted with no fields. Detect that
        // by looking for an edit token.
        if ( !$request->getCheck( 'wpEditToken' ) && $request->getArray( $this->mName ) === null ) {
            return $this->getDefault();
        }
 
        $values = $request->getArray( $this->mName ) ?? [];
 
        $ret = [];
        foreach ( $values as $key => $value ) {
            if ( $key === 'create' || isset( $value['delete'] ) ) {
                $this->nonJsUpdate = true;
                continue;
            }
 
            // Add back in $request->getValues() so things that look for e.g.
            // wpEditToken don't fail.
            $data = $this->rekeyValuesArray( $key, $value ) + $request->getValues();
 
            $fields = $this->getFieldsForKey( $key );
            $subrequest = new DerivativeRequest( $request, $data, $request->wasPosted() );
            $row = [];
            foreach ( $fields as $fieldname => $field ) {
                if ( $field->skipLoadData( $subrequest ) ) {
                    continue;
                }
                if ( !empty( $field->mParams['disabled'] ) ) {
                    $row[$fieldname] = $field->getDefault();
                } else {
                    $row[$fieldname] = $field->loadDataFromRequest( $subrequest );
                }
            }
            $ret[] = $row;
        }
 
        if ( isset( $values['create'] ) ) {
            // Non-JS client clicked the "create" button.
            $fields = $this->getFieldsForKey( $this->uniqueId );
            $row = [];
            foreach ( $fields as $fieldname => $field ) {
                if ( !empty( $field->mParams['nodata'] ) ) {
                    continue;
                }
                $row[$fieldname] = $field->getDefault();
            }
            $ret[] = $row;
        }
 
        return $ret;
    }
 
    public function filter( $values, $alldata ) {
        // Mimic the later stage of HTMLForm::loadFieldData() as if for normal fields.
        foreach ( $values as $key => &$fieldsValue ) {
            $fields = $this->getFieldsForKey( $key );
            foreach ( $fieldsValue as $fieldname => &$value ) {
                // Reset to default for fields that are supposed to be disabled.
                if ( $fields[$fieldname]->isDisabled( $alldata ) ) {
                    $value = $fields[$fieldname]->getDefault();
                }
 
                // Apply field-specific filters.
                $value = $fields[$fieldname]->filter( $value, $alldata );
            }
        }
 
        // Apply the filter defined by the 'filter-callback' option at the end.
        return parent::filter( $values, $alldata );
    }
 
    public function getDefault() {
        $ret = parent::getDefault();
 
        // Some existing use cases in SecurePoll use an empty string as the default value.
        // TODO: Throw an exception in future versions.
        if ( $ret !== null && !is_array( $ret ) ) {
            $type = gettype( $ret );
            wfDeprecated( __CLASS__ . " with non-array default ($type given)", '1.45' );
        }
 
        // The default is one entry with all subfields at their defaults.
        if ( $ret === null || !is_array( $ret ) ) {
            $fields = $this->getFieldsForKey( $this->uniqueId );
            $row = [];
            foreach ( $fields as $fieldname => $field ) {
                if ( !empty( $field->mParams['nodata'] ) ) {
                    continue;
                }
                $row[$fieldname] = $field->getDefault();
            }
            $ret = [ $row ];
        }
 
        return $ret;
    }
 
    public function cancelSubmit( $values, $alldata ) {
        if ( $this->nonJsUpdate ) {
            return true;
        }
 
        foreach ( $values as $key => $value ) {
            $fields = $this->getFieldsForKey( $key );
            foreach ( $fields as $fieldname => $field ) {
                if ( !array_key_exists( $fieldname, $value ) ) {
                    continue;
                }
                if ( $field->cancelSubmit( $value[$fieldname], $alldata ) ) {
                    return true;
                }
            }
        }
 
        return parent::cancelSubmit( $values, $alldata );
    }
 
    public function validate( $values, $alldata ) {
        if ( isset( $this->mParams['required'] )
            && $this->mParams['required'] !== false
            && !$values
        ) {
            return $this->msg( 'htmlform-cloner-required' );
        }
 
        if ( $this->nonJsUpdate ) {
            // The submission was a non-JS create/delete click, so fail
            // validation in case cancelSubmit() somehow didn't already handle
            // it.
            return false;
        }
 
        foreach ( $values as $key => $value ) {
            $fields = $this->getFieldsForKey( $key );
            foreach ( $fields as $fieldname => $field ) {
                if ( !array_key_exists( $fieldname, $value ) || $field->isHidden( $alldata ) ) {
                    continue;
                }
                $ok = $field->validate( $value[$fieldname], $alldata );
                if ( $ok !== true ) {
                    return false;
                }
            }
        }
 
        return parent::validate( $values, $alldata );
    }
 
    protected function getInputHTMLForKey( $key, array $values ) {
        $displayFormat = $this->mParams['format'] ?? $this->mParent->getDisplayFormat();
 
        // Conveniently, PHP method names are case-insensitive.
        $getFieldHtmlMethod = $displayFormat == 'table' ? 'getTableRow' : ( 'get' . $displayFormat );
 
        $html = '';
        $hidden = '';
        $hasLabel = false;
 
        $fields = $this->getFieldsForKey( $key );
        foreach ( $fields as $fieldname => $field ) {
            $v = array_key_exists( $fieldname, $values )
                ? $values[$fieldname]
                : $field->getDefault();
 
            if ( $field instanceof HTMLHiddenField ) {
                // HTMLHiddenField doesn't generate its own HTML
                [ $name, $value, $params ] = $field->getHiddenFieldData( $v );
                $hidden .= Html::hidden( $name, $value, $params ) . "\n";
            } else {
                $html .= $field->$getFieldHtmlMethod( $v );
 
                $labelValue = trim( $field->getLabel() );
                if ( $labelValue !== "\u{00A0}" && $labelValue !== '&#160;' && $labelValue !== '' ) {
                    $hasLabel = true;
                }
            }
        }
 
        if ( !isset( $fields['delete'] ) ) {
            $field = $this->getDeleteButtonHtml( $key );
 
            if ( $displayFormat === 'table' ) {
                $html .= $field->$getFieldHtmlMethod( $field->getDefault() );
            } else {
                $html .= $field->getInputHTML( $field->getDefault() );
            }
        }
 
        if ( $displayFormat !== 'raw' ) {
            $classes = [ 'mw-htmlform-cloner-row' ];
 
            if ( !$hasLabel ) { // Avoid strange spacing when no labels exist
                $classes[] = 'mw-htmlform-nolabel';
            }
 
            $attribs = [ 'class' => $classes ];
 
            if ( $displayFormat === 'table' ) {
                $html = Html::rawElement( 'table',
                    $attribs,
                    Html::rawElement( 'tbody', [], "\n$html\n" ) ) . "\n";
            } else {
                $html = Html::rawElement( 'div', $attribs, "\n$html\n" );
            }
        }
 
        $html .= $hidden;
 
        if ( !empty( $this->mParams['row-legend'] ) ) {
            $legend = $this->msg( $this->mParams['row-legend'] )->text();
            $legend = $legend ? Html::element( 'legend', [], $legend ) : '';
            $html = Html::rawElement(
                'fieldset',
                [],
                $legend . $html
            );
        }
 
        return $html;
    }
 
    protected function getDeleteButtonHtml( $key ): HTMLFormField {
        $name = "{$this->mName}[$key][delete]";
        $label = $this->mParams['delete-button-message'] ?? 'htmlform-cloner-delete';
        $field = HTMLForm::loadInputFromParameters( $name, [
            'type' => 'submit',
            'formnovalidate' => true,
            'name' => $name,
            'id' => Sanitizer::escapeIdForAttribute( "{$this->mID}--$key--delete" ),
            'cssclass' => 'mw-htmlform-cloner-delete-button',
            'default' => $this->getMessage( $label )->text(),
            'disabled' => $this->mParams['disabled'] ?? false,
        ], $this->mParent );
        return $field;
    }
 
    protected function getCreateButtonHtml(): HTMLFormField {
        $name = "{$this->mName}[create]";
        $label = $this->mParams['create-button-message'] ?? 'htmlform-cloner-create';
        return HTMLForm::loadInputFromParameters( $name, [
            'type' => 'submit',
            'formnovalidate' => true,
            'name' => $name,
            'id' => Sanitizer::escapeIdForAttribute( "{$this->mID}--create" ),
            'cssclass' => 'mw-htmlform-cloner-create-button',
            'default' => $this->getMessage( $label )->text(),
            'disabled' => $this->mParams['disabled'] ?? false,
        ], $this->mParent );
    }
 
    public function getInputHTML( $values ) {
        $html = '';
 
        foreach ( (array)$values as $key => $value ) {
            $html .= Html::rawElement( 'li', [ 'class' => 'mw-htmlform-cloner-li' ],
                $this->getInputHTMLForKey( $key, $value )
            );
        }
 
        $template = $this->getInputHTMLForKey( $this->uniqueId, [] );
        $html = Html::rawElement( 'ul', [
            'id' => "mw-htmlform-cloner-list-{$this->mID}",
            'class' => 'mw-htmlform-cloner-ul',
            'data-template' => $template,
            'data-unique-id' => $this->uniqueId,
        ], $html );
 
        $field = $this->getCreateButtonHtml();
        $html .= $field->getInputHTML( $field->getDefault() );
 
        return $html;
    }
 
    protected function getInputOOUIForKey( $key, array $values ) {
        $html = '';
        $hidden = '';
 
        $fields = $this->getFieldsForKey( $key );
        foreach ( $fields as $fieldname => $field ) {
            $v = array_key_exists( $fieldname, $values )
                ? $values[$fieldname]
                : $field->getDefault();
 
            if ( $field instanceof HTMLHiddenField ) {
                // HTMLHiddenField doesn't generate its own HTML
                [ $name, $value, $params ] = $field->getHiddenFieldData( $v );
                $hidden .= Html::hidden( $name, $value, $params ) . "\n";
            } else {
                $html .= $field->getOOUI( $v );
            }
        }
 
        if ( !isset( $fields['delete'] ) ) {
            $field = $this->getDeleteButtonHtml( $key );
            $fieldHtml = $field->getInputOOUI( $field->getDefault() );
            $fieldHtml->setInfusable( true );
 
            $html .= $fieldHtml;
        }
 
        $html = Html::rawElement( 'div', [ 'class' => 'mw-htmlform-cloner-row' ], "\n$html\n" );
 
        $html .= $hidden;
 
        if ( !empty( $this->mParams['row-legend'] ) ) {
            $legend = $this->msg( $this->mParams['row-legend'] )->text();
            $legend = $legend ? Html::element( 'legend', [], $legend ) : '';
            $html = Html::rawElement(
                'fieldset',
                [],
                $legend . $html
            );
        }
 
        return $html;
    }
 
    public function getInputOOUI( $values ) {
        $html = '';
 
        foreach ( (array)$values as $key => $value ) {
            $html .= Html::rawElement( 'li', [ 'class' => 'mw-htmlform-cloner-li' ],
                $this->getInputOOUIForKey( $key, $value )
            );
        }
 
        $template = $this->getInputOOUIForKey( $this->uniqueId, [] );
        $html = Html::rawElement( 'ul', [
            'id' => "mw-htmlform-cloner-list-{$this->mID}",
            'class' => 'mw-htmlform-cloner-ul',
            'data-template' => $template,
            'data-unique-id' => $this->uniqueId,
        ], $html );
 
        $field = $this->getCreateButtonHtml();
        $fieldHtml = $field->getInputOOUI( $field->getDefault() );
        $fieldHtml->setInfusable( true );
 
        $html .= $fieldHtml;
 
        return $html;
    }
}
 
class_alias( HTMLFormFieldCloner::class, 'HTMLFormFieldCloner' );