includes/htmlform/HTMLFormFieldCloner.php

   1 <?php
   2
   3 /**
   4  * A container for HTMLFormFields that allows for multiple copies of the set of
   5  * fields to be displayed to and entered by the user.
   6  *
   7  * Recognized parameters, besides the general ones, include:
   8  *   fields - HTMLFormField descriptors for the subfields this cloner manages.
   9  *     The format is just like for the HTMLForm. A field with key 'delete' is
  10  *     special: it must have type = submit and will serve to delete the group
  11  *     of fields.
  12  *   required - If specified, at least one group of fields must be submitted.
  13  *   format - HTMLForm display format to use when displaying the subfields:
  14  *     'table', 'div', or 'raw'.
  15  *   row-legend - If non-empty, each group of subfields will be enclosed in a
  16  *     fieldset. The value is the name of a message key to use as the legend.
  17  *   create-button-message - Message key to use as the text of the button to
  18  *     add an additional group of fields.
  19  *   delete-button-message - Message key to use as the text of automatically-
  20  *     generated 'delete' button. Ignored if 'delete' is included in 'fields'.
  21  *
  22  * In the generated HTML, the subfields will be named along the lines of
  23  * "clonerName[index][fieldname]", with ids "clonerId--index--fieldid". 'index'
  24  * may be a number or an arbitrary string, and may likely change when the page
  25  * is resubmitted. Cloners may be nested, resulting in field names along the
  26  * lines of "cloner1Name[index1][cloner2Name][index2][fieldname]" and
  27  * corresponding ids.
  28  *
  29  * Use of cloner may result in submissions of the page that are not submissions
  30  * of the HTMLForm, when non-JavaScript clients use the create or remove buttons.
  31  *
  32  * The result is an array, with values being arrays mapping subfield names to
  33  * their values. On non-HTMLForm-submission page loads, there may also be
  34  * additional (string) keys present with other types of values.
  35  *
  36  * @since 1.23
  37  */
  38 class HTMLFormFieldCloner extends HTMLFormField {
  39         private static $counter = 0;
  40
  41         /**
  42          * @var string String uniquely identifying this cloner instance and
  43          * unlikely to exist otherwise in the generated HTML, while still being
  44          * valid as part of an HTML id.
  45          */
  46         protected $uniqueId;
  47
  48         public function __construct( $params ) {
  49                 $this->uniqueId = get_class( $this ) . ++self::$counter . 'x';
  50                 parent::__construct( $params );
  51
  52                 if ( empty( $this->mParams['fields'] ) || !is_array( $this->mParams['fields'] ) ) {
  53                         throw new MWException( 'HTMLFormFieldCloner called without any fields' );
  54                 }
  55
  56                 // Make sure the delete button, if explicitly specified, is sane
  57                 if ( isset( $this->mParams['fields']['delete'] ) ) {
  58                         $class = 'mw-htmlform-cloner-delete-button';
  59                         $info = $this->mParams['fields']['delete'] + array(
  60                                 'cssclass' => $class
  61                         );
  62                         unset( $info['name'], $info['class'] );
  63
  64                         if ( !isset( $info['type'] ) || $info['type'] !== 'submit' ) {
  65                                 throw new MWException(
  66                                         'HTMLFormFieldCloner delete field, if specified, must be of type "submit"'
  67                                 );
  68                         }
  69
  70                         if ( !in_array( $class, explode( ' ', $info['cssclass'] ) ) ) {
  71                                 $info['cssclass'] .= " $class";
  72                         }
  73
  74                         $this->mParams['fields']['delete'] = $info;
  75                 }
  76         }
  77
  78         /**
  79          * Create the HTMLFormFields that go inside this element, using the
  80          * specified key.
  81          *
  82          * @param string $key Array key under which these fields should be named
  83          * @return HTMLFormFields[]
  84          */
  85         protected function createFieldsForKey( $key ) {
  86                 $fields = array();
  87                 foreach ( $this->mParams['fields'] as $fieldname => $info ) {
  88                         $name = "{$this->mName}[$key][$fieldname]";
  89                         if ( isset( $info['name'] ) ) {
  90                                 $info['name'] = "{$this->mName}[$key][{$info['name']}]";
  91                         } else {
  92                                 $info['name'] = $name;
  93                         }
  94                         if ( isset( $info['id'] ) ) {
  95                                 $info['id'] = Sanitizer::escapeId( "{$this->mID}--$key--{$info['id']}" );
  96                         } else {
  97                                 $info['id'] = Sanitizer::escapeId( "{$this->mID}--$key--$fieldname" );
  98                         }
  99                         $field = HTMLForm::loadInputFromParameters( $name, $info );
 100                         $field->mParent = $this->mParent;
 101                         $fields[$fieldname] = $field;
 102                 }
 103                 return $fields;
 104         }
 105
 106         /**
 107          * Re-key the specified values array to match the names applied by
 108          * createFieldsForKey().
 109          *
 110          * @param string $key Array key under which these fields should be named
 111          * @param array $values Values array from the request
 112          * @return array
 113          */
 114         protected function rekeyValuesArray( $key, $values ) {
 115                 $data = array();
 116                 foreach ( $values as $fieldname => $value ) {
 117                         $name = "{$this->mName}[$key][$fieldname]";
 118                         $data[$name] = $value;
 119                 }
 120                 return $data;
 121         }
 122
 123         protected function needsLabel() {
 124                 return false;
 125         }
 126
 127         public function loadDataFromRequest( $request ) {
 128                 // It's possible that this might be posted with no fields. Detect that
 129                 // by looking for an edit token.
 130                 if ( !$request->getCheck( 'wpEditToken' ) && $request->getArray( $this->mName ) === null ) {
 131                         return $this->getDefault();
 132                 }
 133
 134                 $values = $request->getArray( $this->mName );
 135                 if ( $values === null ) {
 136                         $values = array();
 137                 }
 138
 139                 $ret = array();
 140                 foreach ( $values as $key => $value ) {
 141                         if ( $key === 'create' || isset( $value['delete'] ) ) {
 142                                 $ret['nonjs'] = 1;
 143                                 continue;
 144                         }
 145
 146                         // Add back in $request->getValues() so things that look for e.g.
 147                         // wpEditToken don't fail.
 148                         $data = $this->rekeyValuesArray( $key, $value ) + $request->getValues();
 149
 150                         $fields = $this->createFieldsForKey( $key );
 151                         $subrequest = new DerivativeRequest( $request, $data, $request->wasPosted() );
 152                         $row = array();
 153                         foreach ( $fields as $fieldname => $field ) {
 154                                 if ( !empty( $field->mParams['nodata'] ) ) {
 155                                         continue;
 156                                 } elseif ( !empty( $field->mParams['disabled'] ) ) {
 157                                         $row[$fieldname] = $field->getDefault();
 158                                 } else {
 159                                         $row[$fieldname] = $field->loadDataFromRequest( $subrequest );
 160                                 }
 161                         }
 162                         $ret[] = $row;
 163                 }
 164
 165                 if ( isset( $values['create'] ) ) {
 166                         // Non-JS client clicked the "create" button.
 167                         $fields = $this->createFieldsForKey( $this->uniqueId );
 168                         $row = array();
 169                         foreach ( $fields as $fieldname => $field ) {
 170                                 if ( !empty( $field->mParams['nodata'] ) ) {
 171                                         continue;
 172                                 } else {
 173                                         $row[$fieldname] = $field->getDefault();
 174                                 }
 175                         }
 176                         $ret[] = $row;
 177                 }
 178
 179                 return $ret;
 180         }
 181
 182         public function getDefault() {
 183                 $ret = parent::getDefault();
 184
 185                 // The default default is one entry with all subfields at their
 186                 // defaults.
 187                 if ( $ret === null ) {
 188                         $fields = $this->createFieldsForKey( $this->uniqueId );
 189                         $row = array();
 190                         foreach ( $fields as $fieldname => $field ) {
 191                                 if ( !empty( $field->mParams['nodata'] ) ) {
 192                                         continue;
 193                                 } else {
 194                                         $row[$fieldname] = $field->getDefault();
 195                                 }
 196                         }
 197                         $ret = array( $row );
 198                 }
 199
 200                 return $ret;
 201         }
 202
 203         public function cancelSubmit( $values, $alldata ) {
 204                 if ( isset( $values['nonjs'] ) ) {
 205                         return true;
 206                 }
 207
 208                 foreach ( $values as $key => $value ) {
 209                         $fields = $this->createFieldsForKey( $key );
 210                         foreach ( $fields as $fieldname => $field ) {
 211                                 if ( !empty( $field->mParams['nodata'] ) ) {
 212                                         continue;
 213                                 }
 214                                 if ( $field->cancelSubmit( $value[$fieldname], $alldata ) ) {
 215                                         return true;
 216                                 }
 217                         }
 218                 }
 219
 220                 return parent::cancelSubmit( $values, $alldata );
 221         }
 222
 223         public function validate( $values, $alldata ) {
 224                 if ( isset( $this->mParams['required'] )
 225                         && $this->mParams['required'] !== false
 226                         && !$values
 227                 ) {
 228                         return $this->msg( 'htmlform-cloner-required' )->parseAsBlock();
 229                 }
 230
 231                 if ( isset( $values['nonjs'] ) ) {
 232                         // The submission was a non-JS create/delete click, so fail
 233                         // validation in case cancelSubmit() somehow didn't already handle
 234                         // it.
 235                         return false;
 236                 }
 237
 238                 foreach ( $values as $key => $value ) {
 239                         $fields = $this->createFieldsForKey( $key );
 240                         foreach ( $fields as $fieldname => $field ) {
 241                                 if ( !empty( $field->mParams['nodata'] ) ) {
 242                                         continue;
 243                                 }
 244                                 $ok = $field->validate( $value[$fieldname], $alldata );
 245                                 if ( $ok !== true ) {
 246                                         return false;
 247                                 }
 248                         }
 249                 }
 250
 251                 return parent::validate( $values, $alldata );
 252         }
 253
 254         /**
 255          * Get the input HTML for the specified key.
 256          *
 257          * @param string $key Array key under which the fields should be named
 258          * @param array $values
 259          * @return string
 260          */
 261         protected function getInputHTMLForKey( $key, $values ) {
 262                 $displayFormat = isset( $this->mParams['format'] )
 263                         ? $this->mParams['format']
 264                         : $this->mParent->getDisplayFormat();
 265
 266                 switch ( $displayFormat ) {
 267                         case 'table':
 268                                 $getFieldHtmlMethod = 'getTableRow';
 269                                 break;
 270                         case 'vform':
 271                                 // Close enough to a div.
 272                                 $getFieldHtmlMethod = 'getDiv';
 273                                 break;
 274                         default:
 275                                 $getFieldHtmlMethod = 'get' . ucfirst( $displayFormat );
 276                 }
 277
 278                 $html = '';
 279                 $hasLabel = false;
 280
 281                 $fields = $this->createFieldsForKey( $key );
 282                 foreach ( $fields as $fieldname => $field ) {
 283                         $v = ( empty( $field->mParams['nodata'] ) && $values !== null )
 284                                 ? $values[$fieldname]
 285                                 : $field->getDefault();
 286                         $html .= $field->$getFieldHtmlMethod( $v );
 287
 288                         $labelValue = trim( $field->getLabel() );
 289                         if ( $labelValue != '&#160;' && $labelValue !== '' ) {
 290                                 $hasLabel = true;
 291                         }
 292                 }
 293
 294                 if ( !isset( $fields['delete'] ) ) {
 295                         $name = "{$this->mName}[$key][delete]";
 296                         $label = isset( $this->mParams['delete-button-message'] )
 297                                 ? $this->mParams['delete-button-message']
 298                                 : 'htmlform-cloner-delete';
 299                         $field = HTMLForm::loadInputFromParameters( $name, array(
 300                                 'type' => 'submit',
 301                                 'name' => $name,
 302                                 'id' => Sanitizer::escapeId( "{$this->mID}--$key--delete" ),
 303                                 'cssclass' => 'mw-htmlform-cloner-delete-button',
 304                                 'default' => $this->msg( $label )->text(),
 305                         ) );
 306                         $v = $field->getDefault();
 307
 308                         if ( $displayFormat === 'table' ) {
 309                                 $html .= $field->$getFieldHtmlMethod( $v );
 310                         } else {
 311                                 $html .= $field->getInputHTML( $v );
 312                         }
 313                 }
 314
 315                 if ( $displayFormat !== 'raw' ) {
 316                         $classes = array(
 317                                 'mw-htmlform-cloner-row',
 318                         );
 319
 320                         if ( !$hasLabel ) { // Avoid strange spacing when no labels exist
 321                                 $classes[] = 'mw-htmlform-nolabel';
 322                         }
 323
 324                         $attribs = array(
 325                                 'class' => implode( ' ', $classes ),
 326                         );
 327
 328                         if ( $displayFormat === 'table' ) {
 329                                 $html = Html::rawElement( 'table',
 330                                         $attribs,
 331                                         Html::rawElement( 'tbody', array(), "\n$html\n" ) ) . "\n";
 332                         } elseif ( $displayFormat === 'div' || $displayFormat === 'vform' ) {
 333                                 $html = Html::rawElement( 'div', $attribs, "\n$html\n" );
 334                         }
 335                 }
 336
 337                 if ( !empty( $this->mParams['row-legend'] ) ) {
 338                         $legend = $this->msg( $this->mParams['row-legend'] )->text();
 339                         $html = Xml::fieldset( $legend, $html );
 340                 }
 341
 342                 return $html;
 343         }
 344
 345         public function getInputHTML( $values ) {
 346                 $html = '';
 347
 348                 foreach ( (array)$values as $key => $value ) {
 349                         if ( $key === 'nonjs' ) {
 350                                 continue;
 351                         }
 352                         $html .= Html::rawElement( 'li', array( 'class' => 'mw-htmlform-cloner-li' ),
 353                                 $this->getInputHTMLForKey( $key, $value )
 354                         );
 355                 }
 356
 357                 $template = $this->getInputHTMLForKey( $this->uniqueId, null );
 358                 $html = Html::rawElement( 'ul', array(
 359                         'id' => "mw-htmlform-cloner-list-{$this->mID}",
 360                         'class' => 'mw-htmlform-cloner-ul',
 361                         'data-template' => $template,
 362                         'data-unique-id' => $this->uniqueId,
 363                 ), $html );
 364
 365                 $name = "{$this->mName}[create]";
 366                 $label = isset( $this->mParams['create-button-message'] )
 367                         ? $this->mParams['create-button-message']
 368                         : 'htmlform-cloner-create';
 369                 $field = HTMLForm::loadInputFromParameters( $name, array(
 370                         'type' => 'submit',
 371                         'name' => $name,
 372                         'id' => Sanitizer::escapeId( "{$this->mID}--create" ),
 373                         'cssclass' => 'mw-htmlform-cloner-create-button',
 374                         'default' => $this->msg( $label )->text(),
 375                 ) );
 376                 $html .= $field->getInputHTML( $field->getDefault() );
 377
 378                 return $html;
 379         }
 380 }