vendor/contao/core-bundle/src/Resources/contao/forms/Form.php line 96

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. /**
  14.  * Provide methods to handle front end forms.
  15.  *
  16.  * @property integer $id
  17.  * @property string  $title
  18.  * @property string  $formID
  19.  * @property string  $method
  20.  * @property boolean $allowTags
  21.  * @property string  $attributes
  22.  * @property boolean $novalidate
  23.  * @property integer $jumpTo
  24.  * @property boolean $sendViaEmail
  25.  * @property boolean $skipEmpty
  26.  * @property string  $format
  27.  * @property string  $recipient
  28.  * @property string  $subject
  29.  * @property boolean $storeValues
  30.  * @property string  $targetTable
  31.  * @property string  $customTpl
  32.  */
  33. class Form extends Hybrid
  34. {
  35.     /**
  36.      * Model
  37.      * @var FormModel
  38.      */
  39.     protected $objModel;
  41.     /**
  42.      * Key
  43.      * @var string
  44.      */
  45.     protected $strKey = 'form';
  47.     /**
  48.      * Table
  49.      * @var string
  50.      */
  51.     protected $strTable = 'tl_form';
  53.     /**
  54.      * Template
  55.      * @var string
  56.      */
  57.     protected $strTemplate = 'form_wrapper';
  59.     /**
  60.      * Remove name attributes in the back end so the form is not validated
  61.      *
  62.      * @return string
  63.      */
  64.     public function generate()
  65.     {
  66.         $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  68.         if ($request && System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  69.         {
  70.             $objTemplate = new BackendTemplate('be_wildcard');
  71.             $objTemplate->wildcard = '### ' . $GLOBALS['TL_LANG']['CTE']['form'][0] . ' ###';
  72.             $objTemplate->id = $this->id;
  73.             $objTemplate->link = $this->title;
  74.             $objTemplate->href = StringUtil::specialcharsUrl(System::getContainer()->get('router')->generate('contao_backend', array('do'=>'form', 'table'=>'tl_form_field', 'id'=>$this->id)));
  76.             return $objTemplate->parse();
  77.         }
  79.         if ($this->customTpl)
  80.         {
  81.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  83.             // Use the custom template unless it is a back end request
  84.             if (!$request || !System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  85.             {
  86.                 $this->strTemplate = $this->customTpl;
  87.             }
  88.         }
  90.         return parent::generate();
  91.     }
  93.     /**
  94.      * Generate the form
  95.      */
  96.     protected function compile()
  97.     {
  98.         $hasUpload = false;
  99.         $doNotSubmit = false;
  100.         $arrSubmitted = array();
  102.         $this->loadDataContainer('tl_form_field');
  103.         $formId = $this->formID ? 'auto_' . $this->formID : 'auto_form_' . $this->id;
  105.         $this->Template->fields = '';
  106.         $this->Template->hidden = '';
  107.         $this->Template->formSubmit = $formId;
  108.         $this->Template->method = ($this->method == 'GET') ? 'get' : 'post';
  109.         $this->Template->requestToken = System::getContainer()->get('contao.csrf.token_manager')->getDefaultTokenValue();
  111.         $this->initializeSession($formId);
  112.         $arrLabels = array();
  114.         // Get all form fields
  115.         $arrFields = array();
  116.         $objFields = FormFieldModel::findPublishedByPid($this->id);
  118.         if ($objFields !== null)
  119.         {
  120.             while ($objFields->next())
  121.             {
  122.                 // Ignore the name of form fields which do not use a name (see #1268)
  123.                 if ($objFields->name && isset($GLOBALS['TL_DCA']['tl_form_field']['palettes'][$objFields->type]) && preg_match('/[,;]name[,;]/', $GLOBALS['TL_DCA']['tl_form_field']['palettes'][$objFields->type]))
  124.                 {
  125.                     $arrFields[$objFields->name] = $objFields->current();
  126.                 }
  127.                 else
  128.                 {
  129.                     $arrFields[] = $objFields->current();
  130.                 }
  131.             }
  132.         }
  134.         // HOOK: compile form fields
  135.         if (isset($GLOBALS['TL_HOOKS']['compileFormFields']) && \is_array($GLOBALS['TL_HOOKS']['compileFormFields']))
  136.         {
  137.             foreach ($GLOBALS['TL_HOOKS']['compileFormFields'] as $callback)
  138.             {
  139.                 $this->import($callback[0]);
  140.                 $arrFields = $this->{$callback[0]}->{$callback[1]}($arrFields, $formId, $this);
  141.             }
  142.         }
  144.         // Process the fields
  145.         if (!empty($arrFields) && \is_array($arrFields))
  146.         {
  147.             $row = 0;
  148.             $max_row = \count($arrFields);
  150.             foreach ($arrFields as $objField)
  151.             {
  152.                 /** @var FormFieldModel $objField */
  153.                 $strClass = $GLOBALS['TL_FFL'][$objField->type] ?? null;
  155.                 // Continue if the class is not defined
  156.                 if (!class_exists($strClass))
  157.                 {
  158.                     continue;
  159.                 }
  161.                 $arrData = $objField->row();
  163.                 $arrData['decodeEntities'] = true;
  164.                 $arrData['allowHtml'] = $this->allowTags;
  165.                 $arrData['rowClass'] = 'row_' . $row . (($row == 0) ? ' row_first' : (($row == ($max_row - 1)) ? ' row_last' : '')) . ((($row % 2) == 0) ? ' even' : ' odd');
  167.                 // Increase the row count if it's a password field
  168.                 if ($objField->type == 'password')
  169.                 {
  170.                     ++$row;
  171.                     ++$max_row;
  173.                     $arrData['rowClassConfirm'] = 'row_' . $row . (($row == ($max_row - 1)) ? ' row_last' : '') . ((($row % 2) == 0) ? ' even' : ' odd');
  174.                 }
  176.                 // Submit buttons do not use the name attribute
  177.                 if ($objField->type == 'submit')
  178.                 {
  179.                     $arrData['name'] = '';
  180.                 }
  182.                 // Unset the default value depending on the field type (see #4722)
  183.                 if (!empty($arrData['value']) && !\in_array('value', StringUtil::trimsplit('[,;]', $GLOBALS['TL_DCA']['tl_form_field']['palettes'][$objField->type] ?? '')))
  184.                 {
  185.                     $arrData['value'] = '';
  186.                 }
  188.                 /** @var Widget $objWidget */
  189.                 $objWidget = new $strClass($arrData);
  190.                 $objWidget->required = $objField->mandatory ? true : false;
  192.                 // HOOK: load form field callback
  193.                 if (isset($GLOBALS['TL_HOOKS']['loadFormField']) && \is_array($GLOBALS['TL_HOOKS']['loadFormField']))
  194.                 {
  195.                     foreach ($GLOBALS['TL_HOOKS']['loadFormField'] as $callback)
  196.                     {
  197.                         $this->import($callback[0]);
  198.                         $objWidget = $this->{$callback[0]}->{$callback[1]}($objWidget, $formId, $this->arrData, $this);
  199.                     }
  200.                 }
  202.                 // Validate the input
  203.                 if (Input::post('FORM_SUBMIT') == $formId)
  204.                 {
  205.                     $objWidget->validate();
  207.                     // HOOK: validate form field callback
  208.                     if (isset($GLOBALS['TL_HOOKS']['validateFormField']) && \is_array($GLOBALS['TL_HOOKS']['validateFormField']))
  209.                     {
  210.                         foreach ($GLOBALS['TL_HOOKS']['validateFormField'] as $callback)
  211.                         {
  212.                             $this->import($callback[0]);
  213.                             $objWidget = $this->{$callback[0]}->{$callback[1]}($objWidget, $formId, $this->arrData, $this);
  214.                         }
  215.                     }
  217.                     if ($objWidget->hasErrors())
  218.                     {
  219.                         $doNotSubmit = true;
  220.                     }
  222.                     // Store current value in the session
  223.                     elseif ($objWidget->submitInput())
  224.                     {
  225.                         $arrSubmitted[$objField->name] = $objWidget->value;
  226.                         $_SESSION['FORM_DATA'][$objField->name] = $objWidget->value;
  227.                         unset($_POST[$objField->name]); // see #5474
  228.                     }
  229.                 }
  231.                 if ($objWidget instanceof UploadableWidgetInterface)
  232.                 {
  233.                     $hasUpload = true;
  234.                 }
  236.                 if ($objWidget instanceof FormHidden)
  237.                 {
  238.                     $this->Template->hidden .= $objWidget->parse();
  239.                     --$max_row;
  240.                     continue;
  241.                 }
  243.                 if ($objWidget->name && $objWidget->label)
  244.                 {
  245.                     $arrLabels[$objWidget->name] = System::getContainer()->get('contao.insert_tag.parser')->replaceInline($objWidget->label); // see #4268
  246.                 }
  248.                 $this->Template->fields .= $objWidget->parse();
  249.                 ++$row;
  250.             }
  251.         }
  253.         // Process the form data
  254.         if (!$doNotSubmit && Input::post('FORM_SUBMIT') == $formId)
  255.         {
  256.             $this->processFormData($arrSubmitted, $arrLabels, $arrFields);
  257.         }
  259.         // Remove any uploads, if form did not validate (#1185)
  260.         if ($doNotSubmit && $hasUpload && !empty($_SESSION['FILES']))
  261.         {
  262.             foreach ($_SESSION['FILES'] as $field => $upload)
  263.             {
  264.                 if (empty($arrFields[$field]))
  265.                 {
  266.                     continue;
  267.                 }
  269.                 if (!empty($upload['uuid']) && null !== ($file = FilesModel::findById($upload['uuid'])))
  270.                 {
  271.                     $file->delete();
  272.                 }
  274.                 if (is_file($upload['tmp_name']))
  275.                 {
  276.                     unlink($upload['tmp_name']);
  277.                 }
  279.                 unset($_SESSION['FILES'][$field]);
  280.             }
  281.         }
  283.         // Add a warning to the page title
  284.         if ($doNotSubmit && !Environment::get('isAjaxRequest'))
  285.         {
  286.             /** @var PageModel $objPage */
  287.             global $objPage;
  289.             $title = $objPage->pageTitle ?: $objPage->title;
  290.             $objPage->pageTitle = $GLOBALS['TL_LANG']['ERR']['form'] . ' - ' . $title;
  291.         }
  293.         $strAttributes = '';
  294.         $arrAttributes = StringUtil::deserialize($this->attributes, true);
  296.         if (!empty($arrAttributes[0]))
  297.         {
  298.             $strAttributes .= ' id="' . $arrAttributes[0] . '"';
  299.         }
  301.         if (!empty($arrAttributes[1]))
  302.         {
  303.             $strAttributes .= ' class="' . $arrAttributes[1] . '"';
  304.         }
  306.         $this->Template->hasError = $doNotSubmit;
  307.         $this->Template->attributes = $strAttributes;
  308.         $this->Template->enctype = $hasUpload ? 'multipart/form-data' : 'application/x-www-form-urlencoded';
  309.         $this->Template->maxFileSize = $hasUpload ? $this->objModel->getMaxUploadFileSize() : false;
  310.         $this->Template->novalidate = $this->novalidate ? ' novalidate' : '';
  312.         // Get the target URL
  313.         if ($this->method == 'GET' && ($objTarget = $this->objModel->getRelated('jumpTo')) instanceof PageModel)
  314.         {
  315.             /** @var PageModel $objTarget */
  316.             $this->Template->action = $objTarget->getFrontendUrl();
  317.         }
  318.     }
  320.     /**
  321.      * Process form data, store it in the session and redirect to the jumpTo page
  322.      *
  323.      * @param array $arrSubmitted
  324.      * @param array $arrLabels
  325.      * @param array $arrFields
  326.      */
  327.     protected function processFormData($arrSubmitted, $arrLabels, $arrFields)
  328.     {
  329.         // HOOK: prepare form data callback
  330.         if (isset($GLOBALS['TL_HOOKS']['prepareFormData']) && \is_array($GLOBALS['TL_HOOKS']['prepareFormData']))
  331.         {
  332.             foreach ($GLOBALS['TL_HOOKS']['prepareFormData'] as $callback)
  333.             {
  334.                 $this->import($callback[0]);
  335.                 $this->{$callback[0]}->{$callback[1]}($arrSubmitted, $arrLabels, $arrFields, $this);
  336.             }
  337.         }
  339.         // Send form data via e-mail
  340.         if ($this->sendViaEmail)
  341.         {
  342.             $keys = array();
  343.             $values = array();
  344.             $fields = array();
  345.             $message = '';
  347.             foreach ($arrSubmitted as $k=>$v)
  348.             {
  349.                 if ($k == 'cc')
  350.                 {
  351.                     continue;
  352.                 }
  354.                 $v = StringUtil::deserialize($v);
  356.                 // Skip empty fields
  357.                 if ($this->skipEmpty && !\is_array($v) && !\strlen($v))
  358.                 {
  359.                     continue;
  360.                 }
  362.                 // Add field to message
  363.                 $message .= ($arrLabels[$k] ?? ucfirst($k)) . ': ' . (\is_array($v) ? implode(', ', $v) : $v) . "\n";
  365.                 // Prepare XML file
  366.                 if ($this->format == 'xml')
  367.                 {
  368.                     $fields[] = array
  369.                     (
  370.                         'name' => $k,
  371.                         'values' => (\is_array($v) ? $v : array($v))
  372.                     );
  373.                 }
  375.                 // Prepare CSV file
  376.                 if ($this->format == 'csv' || $this->format == 'csv_excel')
  377.                 {
  378.                     $keys[] = $k;
  379.                     $values[] = (\is_array($v) ? implode(',', $v) : $v);
  380.                 }
  381.             }
  383.             $recipients = StringUtil::splitCsv($this->recipient);
  385.             // Format recipients
  386.             foreach ($recipients as $k=>$v)
  387.             {
  388.                 $recipients[$k] = str_replace(array('[', ']', '"'), array('<', '>', ''), $v);
  389.             }
  391.             $email = new Email();
  393.             // Get subject and message
  394.             if ($this->format == 'email')
  395.             {
  396.                 $message = $arrSubmitted['message'];
  397.                 $email->subject = $arrSubmitted['subject'];
  398.             }
  400.             // Set the admin e-mail as "from" address
  401.             $email->from = $GLOBALS['TL_ADMIN_EMAIL'];
  402.             $email->fromName = $GLOBALS['TL_ADMIN_NAME'];
  404.             // Get the "reply to" address
  405.             if (!empty(Input::post('email', true)))
  406.             {
  407.                 $replyTo = Input::post('email', true);
  409.                 // Add the name
  410.                 if (!empty(Input::post('name')))
  411.                 {
  412.                     $replyTo = '"' . Input::post('name') . '" <' . $replyTo . '>';
  413.                 }
  414.                 elseif (!empty(Input::post('firstname')) && !empty(Input::post('lastname')))
  415.                 {
  416.                     $replyTo = '"' . Input::post('firstname') . ' ' . Input::post('lastname') . '" <' . $replyTo . '>';
  417.                 }
  419.                 $email->replyTo($replyTo);
  420.             }
  422.             // Fallback to default subject
  423.             if (!$email->subject)
  424.             {
  425.                 $email->subject = html_entity_decode(System::getContainer()->get('contao.insert_tag.parser')->replaceInline($this->subject), ENT_QUOTES, 'UTF-8');
  426.             }
  428.             // Send copy to sender
  429.             if (!empty($arrSubmitted['cc']))
  430.             {
  431.                 $email->sendCc(Input::post('email', true));
  432.                 unset($_SESSION['FORM_DATA']['cc']);
  433.             }
  435.             // Attach XML file
  436.             if ($this->format == 'xml')
  437.             {
  438.                 $objTemplate = new FrontendTemplate('form_xml');
  439.                 $objTemplate->fields = $fields;
  440.                 $objTemplate->charset = System::getContainer()->getParameter('kernel.charset');
  442.                 $email->attachFileFromString($objTemplate->parse(), 'form.xml', 'application/xml');
  443.             }
  445.             // Attach CSV file
  446.             if ($this->format == 'csv')
  447.             {
  448.                 $email->attachFileFromString(StringUtil::decodeEntities('"' . implode('";"', $keys) . '"' . "\n" . '"' . implode('";"', $values) . '"'), 'form.csv', 'text/comma-separated-values');
  449.             }
  450.             elseif ($this->format == 'csv_excel')
  451.             {
  452.                 $email->attachFileFromString(mb_convert_encoding("\u{FEFF}sep=;\n" . StringUtil::decodeEntities('"' . implode('";"', $keys) . '"' . "\n" . '"' . implode('";"', $values) . '"'), 'UTF-16LE', 'UTF-8'), 'form.csv', 'text/comma-separated-values');
  453.             }
  455.             $uploaded = '';
  457.             // Attach uploaded files
  458.             if (!empty($_SESSION['FILES']))
  459.             {
  460.                 foreach ($_SESSION['FILES'] as $file)
  461.                 {
  462.                     // Add a link to the uploaded file
  463.                     if ($file['uploaded'])
  464.                     {
  465.                         $uploaded .= "\n" . Environment::get('base') . StringUtil::stripRootDir(\dirname($file['tmp_name'])) . '/' . rawurlencode($file['name']);
  466.                         continue;
  467.                     }
  469.                     $email->attachFileFromString(file_get_contents($file['tmp_name']), $file['name'], $file['type']);
  470.                 }
  471.             }
  473.             $uploaded = trim($uploaded) ? "\n\n---\n" . $uploaded : '';
  474.             $email->text = StringUtil::decodeEntities(trim($message)) . $uploaded . "\n\n";
  476.             // Set the transport
  477.             if (!empty($this->mailerTransport))
  478.             {
  479.                 $email->addHeader('X-Transport', $this->mailerTransport);
  480.             }
  482.             // Send the e-mail
  483.             $email->sendTo($recipients);
  484.         }
  486.         // Store the values in the database
  487.         if ($this->storeValues && $this->targetTable)
  488.         {
  489.             $arrSet = array();
  491.             // Add the timestamp
  492.             if ($this->Database->fieldExists('tstamp', $this->targetTable))
  493.             {
  494.                 $arrSet['tstamp'] = time();
  495.             }
  497.             // Fields
  498.             foreach ($arrSubmitted as $k=>$v)
  499.             {
  500.                 if ($k != 'cc' && $k != 'id')
  501.                 {
  502.                     $arrSet[$k] = $v;
  504.                     // Convert date formats into timestamps (see #6827)
  505.                     if ($arrSet[$k] && \in_array($arrFields[$k]->rgxp, array('date', 'time', 'datim')))
  506.                     {
  507.                         $objDate = new Date($arrSet[$k], Date::getFormatFromRgxp($arrFields[$k]->rgxp));
  508.                         $arrSet[$k] = $objDate->tstamp;
  509.                     }
  510.                 }
  511.             }
  513.             // Files
  514.             if (!empty($_SESSION['FILES']))
  515.             {
  516.                 foreach ($_SESSION['FILES'] as $k=>$v)
  517.                 {
  518.                     if ($v['uploaded'] ?? null)
  519.                     {
  520.                         $arrSet[$k] = StringUtil::stripRootDir($v['tmp_name']);
  521.                     }
  522.                 }
  523.             }
  525.             // HOOK: store form data callback
  526.             if (isset($GLOBALS['TL_HOOKS']['storeFormData']) && \is_array($GLOBALS['TL_HOOKS']['storeFormData']))
  527.             {
  528.                 foreach ($GLOBALS['TL_HOOKS']['storeFormData'] as $callback)
  529.                 {
  530.                     $this->import($callback[0]);
  531.                     $arrSet = $this->{$callback[0]}->{$callback[1]}($arrSet, $this);
  532.                 }
  533.             }
  535.             // Load DataContainer of target table before trying to determine empty value (see #3499)
  536.             Controller::loadDataContainer($this->targetTable);
  538.             // Set the correct empty value (see #6284, #6373)
  539.             foreach ($arrSet as $k=>$v)
  540.             {
  541.                 if ($v === '')
  542.                 {
  543.                     $arrSet[$k] = Widget::getEmptyValueByFieldType($GLOBALS['TL_DCA'][$this->targetTable]['fields'][$k]['sql'] ?? array());
  544.                 }
  545.             }
  547.             // Do not use Models here (backwards compatibility)
  548.             $this->Database->prepare("INSERT INTO " . $this->targetTable . " %s")->set($arrSet)->execute();
  549.         }
  551.         // Store all values in the session
  552.         foreach (array_keys($_POST) as $key)
  553.         {
  554.             $_SESSION['FORM_DATA'][$key] = $this->allowTags ? Input::postHtml($key, true) : Input::post($key, true);
  555.         }
  557.         // Store the submission time to invalidate the session later on
  558.         $_SESSION['FORM_DATA']['SUBMITTED_AT'] = time();
  560.         $arrFiles = $_SESSION['FILES'] ?? null;
  562.         // HOOK: process form data callback
  563.         if (isset($GLOBALS['TL_HOOKS']['processFormData']) && \is_array($GLOBALS['TL_HOOKS']['processFormData']))
  564.         {
  565.             foreach ($GLOBALS['TL_HOOKS']['processFormData'] as $callback)
  566.             {
  567.                 $this->import($callback[0]);
  568.                 $this->{$callback[0]}->{$callback[1]}($arrSubmitted, $this->arrData, $arrFiles, $arrLabels, $this);
  569.             }
  570.         }
  572.         $_SESSION['FILES'] = array(); // DO NOT CHANGE
  574.         // Add a log entry
  575.         if (System::getContainer()->get('contao.security.token_checker')->hasFrontendUser())
  576.         {
  577.             $this->import(FrontendUser::class, 'User');
  579.             System::getContainer()->get('monolog.logger.contao.forms')->info('Form "' . $this->title . '" has been submitted by "' . $this->User->username . '".');
  580.         }
  581.         else
  582.         {
  583.             System::getContainer()->get('monolog.logger.contao.forms')->info('Form "' . $this->title . '" has been submitted by a guest.');
  584.         }
  586.         // Check whether there is a jumpTo page
  587.         if (($objJumpTo = $this->objModel->getRelated('jumpTo')) instanceof PageModel)
  588.         {
  589.             $this->jumpToOrReload($objJumpTo->row());
  590.         }
  592.         $this->reload();
  593.     }
  595.     /**
  596.      * Get the maximum file size that is allowed for file uploads
  597.      *
  598.      * @return integer
  599.      *
  600.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  601.      *             Use $this->objModel->getMaxUploadFileSize() instead.
  602.      */
  603.     protected function getMaxFileSize()
  604.     {
  605.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Form::getMaxFileSize()" has been deprecated and will no longer work in Contao 5.0. Use "$this->objModel->getMaxUploadFileSize()" instead.');
  607.         return $this->objModel->getMaxUploadFileSize();
  608.     }
  610.     /**
  611.      * Initialize the form in the current session
  612.      *
  613.      * @param string $formId
  614.      */
  615.     protected function initializeSession($formId)
  616.     {
  617.         if (Input::post('FORM_SUBMIT') != $formId)
  618.         {
  619.             return;
  620.         }
  622.         $arrMessageBox = array('TL_ERROR', 'TL_CONFIRM', 'TL_INFO');
  623.         $_SESSION['FORM_DATA'] = \is_array($_SESSION['FORM_DATA'] ?? null) ? $_SESSION['FORM_DATA'] : array();
  625.         foreach ($arrMessageBox as $tl)
  626.         {
  627.             if (\is_array($_SESSION[$formId][$tl] ?? null))
  628.             {
  629.                 $_SESSION[$formId][$tl] = array_unique($_SESSION[$formId][$tl]);
  631.                 foreach ($_SESSION[$formId][$tl] as $message)
  632.                 {
  633.                     $objTemplate = new FrontendTemplate('form_message');
  634.                     $objTemplate->message = $message;
  635.                     $objTemplate->class = strtolower($tl);
  637.                     $this->Template->fields .= $objTemplate->parse() . "\n";
  638.                 }
  640.                 $_SESSION[$formId][$tl] = array();
  641.             }
  642.         }
  643.     }
  644. }
  646. class_alias(Form::class, 'Form');