src/Service/JsonFormManager.php line 32

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use App\Entity\Contracts\FormInterface;
  6. use App\Entity\Form;
  7. use App\Entity\FormLeadData;
  8. use App\Entity\MasterForm;
  9. use App\Form\CollectionJsonType;
  10. use App\Validator\ExclusiveChoices;
  11. use App\Validator\UniqueLeadDataBy;
  12. use DateTime;
  13. use Exception;
  14. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  15. use Symfony\Component\Filesystem\Exception\FileNotFoundException;
  16. use Symfony\Component\Filesystem\Filesystem;
  17. use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  18. use Symfony\Component\Form\Extension\Core\Type\CollectionType;
  19. use Symfony\Component\Form\Extension\Core\Type\DateTimeType;
  20. use Symfony\Component\Form\Extension\Core\Type\DateType;
  21. use Symfony\Component\Form\Extension\Core\Type\EmailType;
  22. use Symfony\Component\Form\Extension\Core\Type\FormType;
  23. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  24. use Symfony\Component\Form\Extension\Core\Type\NumberType;
  25. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  26. use Symfony\Component\Form\Extension\Core\Type\TextareaType;
  27. use Symfony\Component\Form\Extension\Core\Type\TextType;
  28. use Symfony\Component\Validator\Constraints\Email;
  29. use Symfony\Component\Validator\Constraints\NotBlank;
  30. use Symfony\Component\Validator\Validator\ValidatorInterface;
  32. class JsonFormManager
  33. {
  34.     /** @var Filesystem $filesystem */
  35.     private $filesystem;
  36.     /** @var array $formDefinition */
  37.     private $formDefinition;
  38.     /** @var array|null Definición ya construida; se invalida al cambiar form, query params o fichero */
  39.     private $builtFormDefinition;
  40.     /** @var ParameterBagInterface $params */
  41.     private $params;
  42.     /** @var ValidatorInterface $validator */
  43.     private $validator;
  44.     /** @var Form $form */
  45.     private $form;
  46.     /** @var array $queryParams */
  47.     private $queryParams = [];
  49.     public const FOLDER_NAME = 'forms';
  50.     public const GROUP_TYPE = 'group';
  51.     public const TEXT_TYPE = 'text';
  52.     public const TEXTAREA_TYPE = 'textarea';
  53.     public const EMAIL_TYPE = 'email';
  54.     public const NUMBER_TYPE = 'number';
  55.     public const SELECT_TYPE = 'select';
  56.     public const CHECKBOX_TYPE = 'checkbox';
  57.     public const RADIO_TYPE = 'radio';
  58.     public const DATE_TYPE = 'date';
  59.     public const DATETIME_TYPE = 'datetime';
  60.     public const HIDDEN_TYPE = 'hidden';
  61.     public const COLLECTION_TYPE = 'collection';
  62.     public const SUBMIT_TYPE = 'submit';
  64.     public const SUPPORTED_TYPES = [
  65.         self::GROUP_TYPE,
  66.         self::TEXT_TYPE,
  67.         self::TEXTAREA_TYPE,
  68.         self::EMAIL_TYPE,
  69.         self::NUMBER_TYPE,
  70.         self::SELECT_TYPE,
  71.         self::CHECKBOX_TYPE,
  72.         self::RADIO_TYPE,
  73.         self::DATE_TYPE,
  74.         self::DATETIME_TYPE,
  75.         self::HIDDEN_TYPE,
  76.         self::COLLECTION_TYPE,
  77.         self::SUBMIT_TYPE
  78.     ];
  80.     public const SELECTABLE_TYPES = [
  81.         self::SELECT_TYPE,
  82.         self::CHECKBOX_TYPE,
  83.         self::RADIO_TYPE
  84.     ];
  86.     public const ADDABLE_TYPES = [
  87.         self::TEXT_TYPE => self::TEXT_TYPE,
  88.         self::TEXTAREA_TYPE => self::TEXTAREA_TYPE,
  89.         self::EMAIL_TYPE => self::EMAIL_TYPE,
  90.         self::NUMBER_TYPE => self::NUMBER_TYPE,
  91.         // TODO
  92.         // self::SELECT_TYPE => self::SELECT_TYPE,
  93.         // self::CHECKBOX_TYPE => self::CHECKBOX_TYPE,
  94.         // self::RADIO_TYPE => self::RADIO_TYPE,
  95.         self::DATE_TYPE => self::DATE_TYPE,
  96.         self::DATETIME_TYPE => self::DATETIME_TYPE,
  97.         self::HIDDEN_TYPE => self::HIDDEN_TYPE
  98.     ];
  100.     public const VALUABLE_TYPES = [
  101.         self::TEXT_TYPE => self::TEXT_TYPE,
  102.         self::TEXTAREA_TYPE => self::TEXTAREA_TYPE,
  103.         self::EMAIL_TYPE => self::EMAIL_TYPE,
  104.         self::NUMBER_TYPE => self::NUMBER_TYPE,
  105.         self::SELECT_TYPE => self::SELECT_TYPE,
  106.         self::CHECKBOX_TYPE => self::CHECKBOX_TYPE,
  107.         self::RADIO_TYPE => self::RADIO_TYPE,
  108.         self::DATE_TYPE => self::DATE_TYPE,
  109.         self::DATETIME_TYPE => self::DATETIME_TYPE,
  110.         self::HIDDEN_TYPE => self::HIDDEN_TYPE
  111.     ];
  113.     // Delimiters
  114.     public const FIELDNAME_DELIMITER = '_';
  115.     public const CHECKBOX_VIEW_DELIMITER = ' | ';
  116.     public const INCOMPATIBLE_FIELD_DELIMITER = '__';
  117.     public const COLLECTION_INDEX_DELIMITER = '#';
  119.     /** Tope defensivo de elementos por apartado repetible al expandir columnas y celdas */
  120.     public const MAX_COLLECTION_ITEMS = 50;
  122.     /**
  123.      * @param Filesystem $filesystem
  124.      * @param ParameterBagInterface $params
  125.      * @param ValidatorInterface $validator
  126.      */
  127.     public function __construct(Filesystem $filesystem, ParameterBagInterface $params, ValidatorInterface $validator)
  128.     {
  129.         $this->filesystem = $filesystem;
  130.         $this->params = $params;
  131.         $this->validator = $validator;
  132.     }
  134.     /**
  135.      * @return FormInterface|null
  136.      */
  137.     public function getForm(): ?FormInterface
  138.     {
  139.         return $this->form;
  140.     }
  142.     /**
  143.      * @param FormInterface $form
  144.      * @return self
  145.      */
  146.     public function setForm(FormInterface $form): self
  147.     {
  148.         $this->form = $form;
  149.         $this->builtFormDefinition = null;
  151.         return $this;
  152.     }
  154.     /**
  155.      * @param array $queryParams
  156.      * @return $this
  157.      */
  158.     public function setQueryParams(array $queryParams): self
  159.     {
  160.         $this->queryParams = $queryParams;
  161.         $this->builtFormDefinition = null;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @param string $filePath
  168.      * @return $this
  169.      */
  170.     public function loadFromFilePath(string $filePath): JsonFormManager
  171.     {
  172.         $this->builtFormDefinition = null;
  173.         $filePath = $this->getBasePath() . "/" . $filePath;
  175.         if (!$this->filesystem->exists($filePath)) {
  176.             throw new FileNotFoundException();
  177.         }
  179.         $this->formDefinition = json_decode(file_get_contents($filePath), true);
  181.         if ($this->form instanceof MasterForm) {
  182.             return $this;
  183.         }
  185.         if ($formFieldAddings = $this->form->getFormFieldAddings()) {
  186.             foreach ($formFieldAddings as $adding) {
  187.                 // TODO group 0 only
  188.                 $this->formDefinition[0]['fields'][] = [
  189.                     'type' => $adding->getType(),
  190.                     'common' => [
  191.                         'name' => $adding->getName(),
  192.                         'label' => $adding->getLabel()
  193.                     ],
  194.                     'attr' => [],
  195.                     'constraints' => []
  196.                 ];
  197.             }
  198.         }
  200.         $this->addFieldToDefinition();
  202.         return $this;
  203.     }
  205.     public function getFromFormLead(Type $var = null)
  206.     {
  207.         # code...
  208.     }
  210.     /**
  211.      * @return array|array[]
  212.      * @throws Exception
  213.      */
  214.     public function getFormDefinition(): array
  215.     {
  216.         if (!$this->formDefinition) {
  217.             throw new Exception('No se puede obtener la definición del formulario sin cargar antes el archvo de definición');
  218.         }
  220.         if (null !== $this->builtFormDefinition) {
  221.             return $this->builtFormDefinition;
  222.         }
  224.         return $this->builtFormDefinition = array_map(function($value) {
  225.             return $this->buildFormItem($value);
  226.         }, $this->formDefinition);
  227.     }
  229.     /**
  230.      * @param array $formItem
  231.      * @return array
  232.      * @throws Exception
  233.      */
  234.     private function buildFormItem(array $formItem): array
  235.     {
  236.         if (!$this->formTypeIsSupported($formItem['type'])) {
  237.             throw new Exception(sprintf('El tipo %s no está soportado', $formItem['type']));
  238.         }
  240.         if ($formItem['type'] == self::GROUP_TYPE) {
  241.             $nativeFields = [];
  242.             foreach ($formItem['fields'] as $formSubItem) {
  243.                 $nativeFields[] = $this->buildFormItem($formSubItem);
  244.             }
  245.             return [
  246.                 'name' =>  $formItem['name'],
  247.                 'class' => FormType::class,
  248.                 'options' => [
  249.                     'label' => $formItem['title'],
  250.                     'inherit_data' => true
  251.                 ],
  252.                 'fields' => $nativeFields,
  253.                 'attr' => isset($formItem['attr']) ? $formItem['attr'] : []
  254.             ];
  255.         }
  257.         return $this->configureNativeFormItemByType($this->buildNativeFormItem($formItem), $formItem);
  258.     }
  260.     /**
  261.      * @param array $formItem
  262.      * @return array
  263.      * @throws Exception
  264.      */
  265.     private function buildNativeFormItem(array $formItem): array
  266.     {
  267.         $nativeFormItem = [
  268.             'name' =>  self::buildFieldName($formItem['common']['name'], $formItem['type']),
  269.             'options' => [
  270.                 'label' => $formItem['common']['label'],
  271.                 'attr' => $formItem['attr'],
  272.                 'label_html' => true
  273.             ]
  274.         ];
  276.         if (isset($formItem['common']['help'])) {
  277.             $nativeFormItem['options']['help'] = $formItem['common']['help'];
  278.         }
  280.         if (isset($formItem['attr']['disabled'])) {
  281.             $nativeFormItem['options']['disabled'] = $formItem['attr']['disabled'];
  282.         }
  284.         if (isset($formItem['constraints']['required'])) {
  285.             $nativeFormItem['options']['required'] = $formItem['constraints']['required'];
  286.         }
  288.         // Check if persist field
  289.         if (isset($formItem['bind'])) {
  290.             $nativeFormItem['options']['attr']['bind'] = $formItem['bind'];
  291.         }
  293.         // Check if unique
  294.         if (isset($formItem['constraints']['unique'])) {
  295.             $nativeFormItem['options']['attr']['unique'] = $formItem['constraints']['unique'];
  296.         }
  298.         if (self::COLLECTION_TYPE === $formItem['type']) {
  299.             $nativeFormItem = $this->buildNativeCollection($nativeFormItem, $formItem);
  300.         }
  302.         // Constraints
  303.         $nativeFormItem = $this->buildConstraints($nativeFormItem, $formItem);
  305.         // Opciones exclusivas: además del JS, se valida en servidor que no vengan con otras
  306.         if (!empty($formItem['attr']['clean-choices-value'])) {
  307.             $nativeFormItem['options']['constraints'][] = new ExclusiveChoices(
  308.                 explode('|', (string) $formItem['attr']['clean-choices-value'])
  309.             );
  310.         }
  312.         // Conditioned fields
  314.         return $this->getConditionedFields($nativeFormItem, $formItem);
  315.     }
  317.     /**
  318.      * @param array $nativeFormItem
  319.      * @param array $formItem
  320.      * @return array
  321.      * @throws Exception
  322.      */
  323.     private function buildNativeCollection(array $nativeFormItem, array $formItem): array
  324.     {
  325.         // Min number of elements (for type collections)
  326.         if (isset($formItem['constraints']['min_items'])) {
  327.             if (!is_numeric($formItem['constraints']['min_items'])) {
  328.                 throw new Exception($formItem['constraints']['min_items'] . ' debe ser un número entero');
  329.             }
  330.             $nativeFormItem['options']['attr']['min_items'] = $formItem['constraints']['min_items'];
  331.         }
  333.         // Max number of elements (for type collections)
  334.         if (isset($formItem['constraints']['max_items'])) {
  335.             if (!is_numeric($formItem['constraints']['max_items'])) {
  336.                 throw new Exception($formItem['constraints']['max_items'] . ' debe ser un número entero');
  337.             }
  338.             $nativeFormItem['options']['attr']['max_items'] = $formItem['constraints']['max_items'];
  339.         }
  341.         // Add label text (for type collections)
  342.         if (isset($formItem['constraints']['add_label'])) {
  343.             if (!is_string($formItem['constraints']['add_label'])) {
  344.                 throw new Exception($formItem['constraints']['add_label'] . ' debe ser texto');
  345.             }
  346.             $nativeFormItem['options']['attr']['add_label'] = $formItem['constraints']['add_label'];
  347.         }
  349.         // Remove label text (for type collections)
  350.         if (isset($formItem['constraints']['remove_label'])) {
  351.             if (!is_string($formItem['constraints']['remove_label'])) {
  352.                 throw new Exception($formItem['constraints']['remove_label'] . ' debe ser texto');
  353.             }
  354.             $nativeFormItem['options']['attr']['remove_label'] = $formItem['constraints']['remove_label'];
  355.         }
  357.         return $nativeFormItem;
  358.     }
  360.     /**
  361.      * @param array $nativeFormItem
  362.      * @param array $formItem
  363.      * @return array
  364.      * @throws Exception
  365.      */
  366.     private function configureNativeFormItemByType(array $nativeFormItem, array $formItem): array
  367.     {
  368.         switch ($formItem['type']) {
  369.             case self::TEXT_TYPE:
  370.                 $nativeFormItem['class'] = TextType::class;
  371.                 break;
  372.             case self::TEXTAREA_TYPE:
  373.                 $nativeFormItem['class'] = TextareaType::class;
  374.                 break;
  375.             case self::EMAIL_TYPE:
  376.                 $nativeFormItem['class'] = EmailType::class;
  377.                 $nativeFormItem['options']['constraints'][] = new Email(['mode' => 'strict']);
  378.                 break;
  379.             case self::NUMBER_TYPE:
  380.                 $nativeFormItem['options']['html5'] = true;
  381.                 $nativeFormItem['class'] = NumberType::class;
  382.                 break;
  383.             case self::SELECT_TYPE:
  384.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  385.                 // Los catálogos de respuesta tienen que desplegarse en blanco: sin un
  386.                 // placeholder explícito, un <select> obligatorio renderiza preseleccionada
  387.                 // su primera opción y el usuario puede enviarla sin haberla elegido.
  388.                 $nativeFormItem['options']['placeholder'] = $formItem['attr']['placeholder'] ?? '';
  389.                 if (!empty($formItem['constraints']['required'])) {
  390.                     // `required` en Symfony es solo presentación, y el formulario se renderiza
  391.                     // con novalidate (la validación de navegador la lleva el JS), así que la
  392.                     // obligatoriedad de un select en blanco hay que comprobarla en servidor.
  393.                     $nativeFormItem['options']['constraints'][] = new NotBlank();
  394.                 }
  395.                 if (isset($formItem['attr']['value'])) {
  396.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  397.                 }
  398.                 $nativeFormItem['class'] = ChoiceType::class;
  399.                 break;
  400.             case self::CHECKBOX_TYPE:
  401.                 $nativeFormItem['options']['expanded'] = true;
  402.                 $nativeFormItem['options']['multiple'] = true;
  403.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  404.                 $data = [];
  405.                 foreach ($formItem['choices'] as $choice) {
  406.                     if (isset($choice['checked']) && $choice['checked']) {
  407.                         $data[$choice['label']] = $choice['value'];
  408.                     }
  409.                 }
  410.                 if (!empty($data)) {
  411.                     $nativeFormItem['options']['data'] = $data;
  412.                 }
  413.                 $nativeFormItem['class'] = ChoiceType::class;
  414.                 break;
  415.             case self::RADIO_TYPE:
  416.                 $nativeFormItem['options']['expanded'] = true;
  417.                 $nativeFormItem['options']['multiple'] = false;
  418.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  419.                 if (isset($formItem['attr']['value'])) {
  420.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  421.                 }
  422.                 $nativeFormItem['class'] = ChoiceType::class;
  423.                 break;
  424.             case self::DATE_TYPE:
  425.                 $nativeFormItem['options']['widget'] = 'single_text';
  426.                 $nativeFormItem['options']['html5'] = true;
  427.                 $nativeFormItem['class'] = DateType::class;
  428.                 break;
  429.             case self::DATETIME_TYPE:
  430.                 $nativeFormItem['options']['widget'] = 'single_text';
  431.                 $nativeFormItem['options']['html5'] = true;
  432.                 $nativeFormItem['class'] = DateTimeType::class;
  433.                 break;
  434.             case self::HIDDEN_TYPE:
  435.                 $nativeFormItem['class'] = HiddenType::class;
  436.                 if (isset($formItem['attr']['value'])) {
  437.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  438.                 }
  439.                 break;
  440.             case self::COLLECTION_TYPE:
  441.                 $items = [];
  442.                 foreach ($formItem['items'] as $item) {
  443.                     $items[] = $this->buildFormItem($item);
  444.                 }
  445.                 $nativeFormItem['class'] = CollectionType::class;
  446.                 $nativeFormItem['options']['entry_type'] = CollectionJsonType::class;
  447.                 $nativeFormItem['options']['entry_options'] = ['collection' => $items];
  448.                 $nativeFormItem['options']['allow_add'] = true;
  449.                 $nativeFormItem['options']['allow_delete'] = true;
  450.                 break;
  451.             case self::SUBMIT_TYPE:
  452.                 $nativeFormItem['class'] = SubmitType::class;
  453.                 break;
  454.             default:
  455.                 break;
  456.         }
  458.         return $nativeFormItem;
  459.     }
  461.     /**
  462.      * @param string $type
  463.      * @return bool
  464.      */
  465.     public static function formTypeIsSupported(string $type): bool
  466.     {
  467.         return in_array($type, self::SUPPORTED_TYPES);
  468.     }
  470.     /**
  471.      * @param array $choices
  472.      * @param bool $fieldIsRequired
  473.      * @return array
  474.      */
  475.     private function buildFieldOptions(array $choices, bool $fieldIsRequired = false): array
  476.     {
  477.         $nativeChoices = [];
  479.         foreach ($choices as $choice) {
  480.             $nativeChoices[$choice['label']] = $choice['value'];
  481.         }
  483.         return $nativeChoices;
  484.     }
  486.     /**
  487.      * @param string $fieldName
  488.      * @param $fieldValue
  489.      * @return string
  490.      * @throws Exception
  491.      */
  492.     public static function formFieldResponseToDb(string $fieldName, $fieldValue): string
  493.     {
  494.         $type = self::getTypeFromFieldName($fieldName);
  496.         if (!self::formTypeIsSupported($type)) {
  497.             throw new Exception(sprintf('El tipo %s no está soportado', $type));
  498.         }
  500.         switch ($type) {
  501.             case self::TEXT_TYPE:
  502.             case self::TEXTAREA_TYPE:
  503.             case self::EMAIL_TYPE:
  504.             case self::SELECT_TYPE:
  505.             case self::RADIO_TYPE:
  506.                 return $fieldValue;
  507.             case self::NUMBER_TYPE:
  508.                 return (str_replace(',', '.', $fieldValue));
  509.             case self::CHECKBOX_TYPE:
  510.                 return serialize($fieldValue);
  511.             case self::DATE_TYPE:
  512.                 return $fieldValue->format('Y-m-d');
  513.             case self::DATETIME_TYPE:
  514.                 return $fieldValue->format('Y-m-d H:i:s');
  515.             default:
  516.                 break;
  517.         }
  519.         return $fieldValue;
  520.     }
  522.     /**
  523.      * @param $field
  524.      * @param $type
  525.      * @return string
  526.      * @throws Exception
  527.      */
  528.     public static function formFieldDbItemToPrint($field, $type): string
  529.     {
  530.         if (!self::formTypeIsSupported($type)) {
  531.             throw new Exception(sprintf('El tipo %s no está soportado', $type));
  532.         }
  534.         switch ($type) {
  535.             case self::TEXT_TYPE:
  536.             case self::TEXTAREA_TYPE:
  537.             case self::EMAIL_TYPE:
  538.             case self::SELECT_TYPE:
  539.             case self::RADIO_TYPE:
  540.                 return $field;
  541.             case self::NUMBER_TYPE:
  542.                 return str_replace(".", ",", $field);
  543.             case self::CHECKBOX_TYPE:
  544.                 $unserialize = unserialize($field);
  545.                 if (is_string($unserialize) || $field === "") {
  546.                     return $unserialize;
  547.                 }
  549.                 return implode(self::CHECKBOX_VIEW_DELIMITER, $unserialize);
  550.             case self::DATE_TYPE:
  551.                 return (new DateTime($field))->format('d-m-Y');
  552.             case self::DATETIME_TYPE:
  553.                 return (new DateTime($field))->format('d-m-Y H:i');
  554.             default:
  555.                 break;
  556.         }
  558.         return $field;
  559.     }
  561.     /**
  562.      * @param string $fieldName
  563.      * @return string
  564.      */
  565.     public static function getNameFromFieldName(string $fieldName): string
  566.     {
  567.         return self::explodeFieldName($fieldName, 0);
  568.     }
  570.     /**
  571.      * @param string $fieldName
  572.      * @return string
  573.      */
  574.     public static function getTypeFromFieldName(string $fieldName): string
  575.     {
  576.         return self::explodeFieldName($fieldName, 1);
  577.     }
  579.     /**
  580.      * @return array
  581.      * @throws Exception
  582.      */
  583.     public function getFormDefinitionFields(): array
  584.     {
  585.         $result = [];
  586.         foreach ($this->getFormDefinition() as $item) {
  587.             if (!$this->formItemIsGroup($item)) {
  588.                 // Is field
  589.                 $result[] = $item;
  590.                 continue;
  591.             }
  593.             foreach ($item['fields'] as $field) {
  594.                 $result[] = $field;
  595.             }
  596.         }
  598.         return $result;
  599.     }
  601.     /**
  602.      * @param array $formData
  603.      * @param array $formDefinitionFields
  604.      * @return array
  605.      */
  606.     public function getFormDataInFormDefinitionFields(array $formData, array $formDefinitionFields): array
  607.     {
  608.         foreach ($formData as $key => $value) {
  609.             foreach ($formDefinitionFields as $field) {
  610.                 if ($field['name'] !== $key) {
  611.                     continue;
  612.                 }
  614.                 // TODO: hardcoded
  615.                 $formData = $this->processPayment($formData, $field, $key, $value);
  617.                 // Check not binding fields
  618.                 if (isset($field['options']['attr']['bind']) && !$field['options']['attr']['bind']) {
  619.                     unset($formData[$key]);
  620.                 }
  621.             }
  622.         }
  624.         return $formData;
  625.     }
  627.     /**
  628.      * @param string $incompatibleValueString
  629.      * @return mixed|string
  630.      */
  631.     public function getIncompatibleGroup(string $incompatibleValueString)
  632.     {
  633.         return $this->getExplodedIncompatibleField($incompatibleValueString)[0];
  634.     }
  636.     /**
  637.      * @param string $incompatibleValueString
  638.      * @return false|string[]
  639.      */
  640.     public function getExplodedIncompatibleField(string $incompatibleValueString)
  641.     {
  642.         return explode(self::INCOMPATIBLE_FIELD_DELIMITER, $incompatibleValueString);
  643.     }
  645.     /**
  646.      * @param string $value
  647.      * @return string
  648.      */
  649.     public static function unFormattedHtml(string $value): string
  650.     {
  651.         return $value != strip_tags($value) ? strip_tags($value) : $value;
  652.     }
  654.     /**
  655.      * @param array $formItem
  656.      * @return bool
  657.      */
  658.     private function formItemIsGroup(array $formItem): bool
  659.     {
  660.         return isset($formItem['fields']);
  661.     }
  663.     /**
  664.      * @param array $nativeFormItem
  665.      * @param array $formItem
  666.      * @return array
  667.      * @throws Exception
  668.      */
  669.     private function buildConstraints(array $nativeFormItem, array $formItem): array
  670.     {
  671.         if (
  672.             !isset($formItem['constraints']['validators']) &&
  673.             !isset($formItem['constraints']['unique_by']) &&
  674.             !isset($formItem['constraints']['incompatible_with'])
  675.         ) {
  676.             return $nativeFormItem;
  677.         }
  679.         if (isset($formItem['constraints']['unique_by'])) {
  680.             $nativeFormItem = $this->buildConstraintUniqueBy($nativeFormItem, $formItem);
  681.         }
  683.         if (isset($formItem['constraints']['incompatible_with'])) {
  684.             $nativeFormItem = $this->buildIncompatibleField($nativeFormItem, $formItem);
  685.         }
  687.         if (isset($formItem['constraints']['validators'])) {
  688.             $nativeFormItem = $this->buildConstraintValidators($nativeFormItem, $formItem);
  689.         }
  691.         return $nativeFormItem;
  692.     }
  694.     /**
  695.      * @param array $nativeFormItem
  696.      * @param array $formItem
  697.      * @return array
  698.      */
  699.     private function buildConstraintUniqueBy(array $nativeFormItem, array $formItem): array
  700.     {
  701.         $entity = null;
  702.         $campaign = $this->getForm()->getCampaign();
  703.         $company = $campaign->getCompany();
  704.         switch ($formItem['constraints']['unique_by']) {
  705.             case $this->getForm()->getCampaign()->getClass():
  706.                 $entity = $campaign;
  707.                 break;
  708.             case $this->getForm()->getCampaign()->getCompany()->getClass():
  709.                 $entity = $company;
  710.         }
  712.         $nativeFormItem['options']['constraints'][] = new UniqueLeadDataBy(['entity' => $entity]);
  714.         return $nativeFormItem;
  715.     }
  717.     /**
  718.      * @param array $nativeFormItem
  719.      * @param array $formItem
  720.      * @return array
  721.      */
  722.     private function buildIncompatibleField(array $nativeFormItem, array $formItem): array
  723.     {
  724.         $indexes = ['group', 'name', 'type'];
  725.         foreach ($formItem['constraints']['incompatible_with'] as $key => $value) {
  726.             $value = '';
  727.             foreach ($indexes as $index) {
  728.                 $value .= $formItem['constraints']['incompatible_with'][$key][$index] . self::INCOMPATIBLE_FIELD_DELIMITER;
  729.             }
  730.             $nativeFormItem['options']['attr']["incompatible-with-$key"] = substr(
  731.                 $value,
  732.                 0,
  733.                 -strlen(self::INCOMPATIBLE_FIELD_DELIMITER)
  734.             );
  735.         }
  737.         return $nativeFormItem;
  738.     }
  740.     /**
  741.      * @param array $nativeFormItem
  742.      * @param array $formItem
  743.      * @return array
  744.      * @throws Exception
  745.      */
  746.     private function buildConstraintValidators(array $nativeFormItem, array $formItem): array
  747.     {
  748.         foreach ($formItem['constraints']['validators'] as $validator => $params) {
  749.             $validatorNamespaces = [
  750.                 'App\Validator',
  751.                 '\Symfony\Component\Validator\Constraints'
  752.             ];
  754.             $className = null;
  755.             foreach ($validatorNamespaces as $validatorNamespace) {
  756.                 $className = $validatorNamespace . '\\' . $validator;
  757.                 if ($this->validator->hasMetadataFor($className)) {
  758.                     break;
  759.                 }
  760.             }
  761.             if (!$className) {
  762.                 throw new Exception();
  763.             }
  765.             if (!empty($params)) {
  766.                 $nativeFormItem['options']['constraints'][] = new $className($params);
  767.             } else {
  768.                 $nativeFormItem['options']['constraints'][] = new $className();
  769.             }
  770.         }
  772.         return $nativeFormItem;
  773.     }
  775.     /**
  776.      * @param string $fieldName
  777.      * @param int $index
  778.      * @return string
  779.      */
  780.     private static function explodeFieldName(string $fieldName, int $index): string
  781.     {
  782.         return explode(self::FIELDNAME_DELIMITER, $fieldName)[$index];
  783.     }
  785.     /**
  786.      * @param string $name
  787.      * @param string $type
  788.      * @return string
  789.      */
  790.     public static function buildFieldName(string $name, string $type): string
  791.     {
  792.         return $name . self::FIELDNAME_DELIMITER . $type;
  793.     }
  795.     /**
  796.      * Clave de agrupación de FormLeadData: name_type, y name_type#N para el elemento N de un
  797.      * apartado repetible.
  798.      *
  799.      * Los elementos de una colección comparten field y type, así que agrupar solo por
  800.      * name_type los interpretaba como versiones sucesivas del mismo campo y se quedaba
  801.      * únicamente con el último.
  802.      *
  803.      * @param string $name
  804.      * @param string $type
  805.      * @param int|null $collectionIndex
  806.      * @return string
  807.      */
  808.     public static function buildLeadDataKey(string $name, string $type, ?int $collectionIndex = null): string
  809.     {
  810.         $fieldName = self::buildFieldName($name, $type);
  812.         return null === $collectionIndex
  813.             ? $fieldName
  814.             : $fieldName . self::COLLECTION_INDEX_DELIMITER . $collectionIndex;
  815.     }
  817.     /**
  818.      * name_type de una clave de buildLeadDataKey(), sin el índice de colección.
  819.      *
  820.      * @param string $key
  821.      * @return string
  822.      */
  823.     public static function getFieldNameFromLeadDataKey(string $key): string
  824.     {
  825.         return explode(self::COLLECTION_INDEX_DELIMITER, $key)[0];
  826.     }
  828.     /**
  829.      * Índices presentes por subcampo de colección, a partir del valor vigente de cada clave.
  830.      *
  831.      * Un elemento vaciado al editar (se reduce el número de elementos) deja como vigente un
  832.      * valor '' y no cuenta como presente.
  833.      *
  834.      * @param iterable<string, FormLeadData> $latestByKey Vigente por buildLeadDataKey()
  835.      * @return array<string, int[]> name_type => índices
  836.      */
  837.     public static function collectCollectionIndexes(iterable $latestByKey): array
  838.     {
  839.         $result = [];
  840.         foreach ($latestByKey as $data) {
  841.             if (null === $data->getCollectionIndex() || '' === (string) $data->getValue()) {
  842.                 continue;
  843.             }
  844.             $result[self::buildFieldName($data->getField(), $data->getType())][] = $data->getCollectionIndex();
  845.         }
  847.         return $result;
  848.     }
  850.     /**
  851.      * Sustituye en el esquema cada apartado repetible por una entrada por elemento y subcampo.
  852.      *
  853.      * buildFieldsSchema() aporta una sola entrada por subcampo de colección, pero cuántos
  854.      * elementos hay lo decide cada registro. El orden resultante es por elemento ("Nombre 1",
  855.      * "Edad 1", "Nombre 2"...), igual que se guardan, con el ordinal en la etiqueta como hace
  856.      * el alta. Las entradas expandidas se indexan con buildLeadDataKey() y llevan
  857.      * 'collectionIndex'; el resto del esquema pasa tal cual.
  858.      *
  859.      * @param array<string, array> $schema
  860.      * @param array<string, int[]> $indexesByField name_type => índices presentes
  861.      * @param int $cap
  862.      * @return array<string, array>
  863.      */
  864.     public static function expandCollectionSchema(array $schema, array $indexesByField, int $cap = self::MAX_COLLECTION_ITEMS): array
  865.     {
  866.         // Subcampos de cada colección, en el orden del esquema
  867.         $collections = [];
  868.         foreach ($schema as $fieldName => $meta) {
  869.             if (!empty($meta['collection'])) {
  870.                 $collections[$meta['collection']][$fieldName] = $meta;
  871.             }
  872.         }
  874.         $result = [];
  875.         $expanded = [];
  876.         foreach ($schema as $fieldName => $meta) {
  877.             $collection = $meta['collection'] ?? null;
  878.             if (!$collection) {
  879.                 $result[$fieldName] = $meta;
  880.                 continue;
  881.             }
  882.             if (isset($expanded[$collection])) {
  883.                 continue;
  884.             }
  885.             $expanded[$collection] = true;
  887.             $indexes = [];
  888.             foreach (array_keys($collections[$collection]) as $subFieldName) {
  889.                 foreach ($indexesByField[$subFieldName] ?? [] as $index) {
  890.                     $indexes[$index] = $index;
  891.                 }
  892.             }
  893.             sort($indexes);
  895.             foreach (array_slice($indexes, 0, $cap) as $index) {
  896.                 foreach ($collections[$collection] as $subFieldName => $subMeta) {
  897.                     $key = self::buildLeadDataKey($subMeta['field'], $subMeta['type'], $index);
  898.                     $result[$key] = array_merge($subMeta, [
  899.                         'label' => $subMeta['label'] . ' ' . $index,
  900.                         'collectionIndex' => $index,
  901.                     ]);
  902.                 }
  903.             }
  904.         }
  906.         return $result;
  907.     }
  909.     /**
  910.      * @param string $name
  911.      * @param string $type
  912.      * @param string $label
  913.      * @param string $groupLabel
  914.      * @return string
  915.      */
  916.     public static function buildFieldIndexLabel(string $name, string $type, string $label, string $groupLabel): string
  917.     {
  918.         return
  919.             $name . self::FIELDNAME_DELIMITER .
  920.             $type . self::FIELDNAME_DELIMITER .
  921.             self::unFormattedHtml($label) . self::FIELDNAME_DELIMITER .
  922.             self::unFormattedHtml($groupLabel);
  923.     }
  925.     /**
  926.      * @return array
  927.      * @throws Exception
  928.      */
  929.     public function buildCsvHeader(): array
  930.     {
  931.         $result = [];
  932.         foreach ($this->buildFieldsSchema() as $index => $item) {
  933.             $result[$index]['label'] = $item['label'];
  934.             $result[$index]['group_label'] = $item['groupLabel'];
  935.         }
  937.         return $result;
  938.     }
  940.     /**
  941.      * Campos persistibles de la definición vigente, en el orden en que aparecen en el JSON.
  942.      *
  943.      * Es la fuente única de verdad para saber qué campos tiene el formulario ahora mismo,
  944.      * frente a las etiquetas que quedaron guardadas en FormLeadData al enviarlo.
  945.      *
  946.      * La clave es buildFieldName() ("empresa_text"), que es la clave natural de FormLeadData
  947.      * y la única estable: hay grupos con varios campos que comparten etiqueta (cinco "Otros"
  948.      * en PRINCIPIO 6), así que indexar por label los colapsaría en uno.
  949.      *
  950.      * Los subcampos de un apartado repetible aportan una sola entrada, marcada con el nombre
  951.      * de su colección en 'collection'; expandCollectionSchema() la desdobla por elemento.
  952.      *
  953.      * @return array<string, array{field: string, type: string, label: string, groupLabel: string, groupName: string, collection: string|null}>
  954.      * @throws Exception
  955.      */
  956.     public function buildFieldsSchema(): array
  957.     {
  958.         $result = [];
  959.         foreach ($this->getFormDefinition() as $item) {
  960.             if (!$this->formItemIsGroup($item)) {
  961.                 // Campo suelto, fuera de grupo
  962.                 $this->appendFieldToSchema($result, $item, '', '');
  963.                 continue;
  964.             }
  966.             $groupLabel = self::unFormattedHtml((string) ($item['options']['label'] ?? ''));
  967.             foreach ($item['fields'] as $field) {
  968.                 $this->appendFieldToSchema($result, $field, $groupLabel, (string) ($item['name'] ?? ''));
  969.             }
  970.         }
  972.         return $result;
  973.     }
  975.     /**
  976.      * @param array $result
  977.      * @param array $field
  978.      * @param string $groupLabel
  979.      * @param string $groupName
  980.      * @param string|null $collection Colección a la que pertenece el campo, si es un subcampo
  981.      * @return void
  982.      */
  983.     private function appendFieldToSchema(
  984.         array &$result,
  985.         array $field,
  986.         string $groupLabel,
  987.         string $groupName,
  988.         ?string $collection = null
  989.     ): void {
  990.         $fieldName = $field['name'];
  991.         $type = self::getTypeFromFieldName($fieldName);
  993.         // Las colecciones aportan una entrada por cada campo de su item
  994.         if (self::COLLECTION_TYPE === $type) {
  995.             foreach ($field['options']['entry_options']['collection'] ?? [] as $entry) {
  996.                 $this->appendFieldToSchema($result, $entry, $groupLabel, $groupName, $fieldName);
  997.             }
  999.             return;
  1000.         }
  1002.         // Fuera lo que no llega a BD: submit, tipos no persistibles y campos con bind = false
  1003.         if (!isset(self::VALUABLE_TYPES[$type])) {
  1004.             return;
  1005.         }
  1006.         if (isset($field['options']['attr']['bind']) && !$field['options']['attr']['bind']) {
  1007.             return;
  1008.         }
  1010.         $result[$fieldName] = [
  1011.             'field' => self::getNameFromFieldName($fieldName),
  1012.             'type' => $type,
  1013.             'label' => $this->resolveSchemaLabel($field, $groupLabel),
  1014.             'groupLabel' => $groupLabel,
  1015.             'groupName' => $groupName,
  1016.             'collection' => $collection,
  1017.         ];
  1018.     }
  1020.     /**
  1021.      * common.label puede venir vacío o a false en el JSON; se cae al placeholder y, en último
  1022.      * término, al propio nombre del campo, para que nunca quede una columna sin cabecera.
  1023.      *
  1024.      * @param array $field
  1025.      * @return string
  1026.      */
  1027.     private function resolveSchemaLabel(array $field, string $groupLabel = ''): string
  1028.     {
  1029.         // Un campo con "label": false (el título ya lo da su grupo) se etiqueta con el del grupo
  1030.         $label = ($field['options']['label'] ?? null)
  1031.             ?: ($field['options']['attr']['placeholder'] ?? null)
  1032.             ?: $groupLabel;
  1034.         return self::unFormattedHtml((string) ($label ?: self::getNameFromFieldName($field['name'])));
  1035.     }
  1037.     /**
  1038.      * @return string
  1039.      */
  1040.     public function getBasePath(): string
  1041.     {
  1042.         return $this->params->get('kernel.project_dir') . "/" . self::FOLDER_NAME;
  1043.     }
  1045.     /**
  1046.      * @param array $nativeFormItem
  1047.      * @param array $formItem
  1048.      * @return array
  1049.      */
  1050.     private function getConditionedFields(array $nativeFormItem, array $formItem): array
  1051.     {
  1052.         if (!in_array($formItem['type'], self::SELECTABLE_TYPES)) {
  1053.             return $nativeFormItem;
  1054.         }
  1055.         if (!isset($formItem['choices'])) {
  1056.             return $nativeFormItem;
  1057.         }
  1059.         $conditionedFields = [];
  1060.         foreach ($formItem['choices'] as $keyChoice => $choice) {
  1061.             if (!isset($choice['conditional_on']) || !$choice['conditional_on']) {
  1062.                 continue;
  1063.             }
  1065.             $conditionedFields[$keyChoice]['parent_value'] = $choice['value'];
  1066.             foreach ($choice['conditional_on'] as $key => $item) {
  1067.                 $conditionedFields[$keyChoice]['conditioned_fields'][$key] = $item;
  1068.                 $conditionedFields[$keyChoice]['conditioned_fields'][$key]['field_name'] = self::buildNativeFieldName(
  1069.                     isset($this->findFieldGroup($formItem)['name']) ? $this->findFieldGroup($formItem)['name'] : '',
  1070.                     $item['field']['name'],
  1071.                     $item['field']['type']
  1072.                 );
  1073.                 unset($conditionedFields[$keyChoice]['conditioned_fields'][$key]['field']);
  1074.             }
  1075.         }
  1076.         if (!empty($conditionedFields)) {
  1077.             $nativeFormItem['options']['attr']['data-conditioned-fields'] = json_encode($conditionedFields, true);
  1078.         }
  1080.         return $nativeFormItem;
  1081.     }
  1083.     /**
  1084.      * @param array $formItem
  1085.      * @return array|mixed|void
  1086.      */
  1087.     private function findFieldGroup(array $formItem)
  1088.     {
  1089.         foreach ($this->formDefinition as $group) {
  1090.             if (!$this->formItemIsGroup($group)) {
  1091.                 continue;
  1092.             }
  1093.             foreach ($group['fields'] as $field) {
  1094.                 if ($field['type'] === $formItem['type'] && $field['common']['name'] === $formItem['common']['name']) {
  1095.                     return $group;
  1096.                 }
  1097.             }
  1098.         }
  1100.         return [];
  1101.     }
  1103.     /**
  1104.      * @param string $groupName
  1105.      * @param string $name
  1106.      * @param string $type
  1107.      * @return string
  1108.      */
  1109.     private function buildNativeFieldName(string $groupName, string $name, string $type): string
  1110.     {
  1111.         return 'json_' . $groupName . self::FIELDNAME_DELIMITER . self::buildFieldName($name, $type);
  1112.     }
  1114.     /**
  1115.      * @return void
  1116.      */
  1117.     private function addFieldToDefinition()
  1118.     {
  1119.         if (!$this->queryParams) {
  1120.             return;
  1121.         }
  1123.         foreach ($this->queryParams as $key => $param) {
  1124.             foreach ($this->formDefinition as $keyGroup => $group) {
  1125.                 if (!$this->formItemIsGroup($group)) {
  1126.                     continue;
  1127.                 }
  1128.                 foreach ($group['fields'] as $keyField => $field) {
  1129.                     if ($key !== $field['common']['name']) {
  1130.                         continue;
  1131.                     }
  1133.                     $value = null;
  1134.                     $readOnly = false;
  1135.                     switch ($field['type']) {
  1136.                         case self::EMAIL_TYPE:
  1137.                         case self::TEXT_TYPE:
  1138.                         case self::NUMBER_TYPE:
  1139.                             $value = $param;
  1140.                             $readOnly = true;
  1141.                         break;
  1142.                         case self::HIDDEN_TYPE:
  1143.                             $value = $param;
  1144.                             break;
  1145.                         case self::DATE_TYPE:
  1146.                             if (DateTimeService::isDate($param)) {
  1147.                                 $value = $param;
  1148.                                 $readOnly = true;
  1149.                             }
  1150.                             break;
  1151.                         case self::DATETIME_TYPE:
  1152.                             if (DateTimeService::isDateTime($param)) {
  1153.                                 $value = $param;
  1154.                                 $readOnly = true;
  1155.                             }
  1156.                             break;
  1157.                         case self::RADIO_TYPE:
  1158.                         case self::SELECT_TYPE:
  1159.                             if (!isset($field['choices'])) {
  1160.                                 break;
  1161.                             }
  1162.                             foreach ($field['choices'] as $choice) {
  1163.                                 if ($choice['value'] !== $param) {
  1164.                                     continue;
  1165.                                 }
  1166.                                 $value = $param;
  1167.                                 $readOnly = true;
  1168.                                 break;
  1169.                             }
  1171.                             break;
  1172.                         case self::CHECKBOX_TYPE:
  1173.                             $value = $param;
  1174.                             $readOnly = true;
  1175.                             $this->formDefinition[$keyGroup]['fields'][$keyField]['choices'][0]['label'] = $param;
  1176.                             break;
  1177.                     }
  1178.                     if (!$value) {
  1179.                         continue;
  1180.                     }
  1182.                     $this->formDefinition[$keyGroup]['fields'][$keyField]['attr']['value'] = $value;
  1183.                     if ($readOnly) {
  1184.                         $this->formDefinition[$keyGroup]['fields'][$keyField]['attr']['readonly'] = true;
  1185.                     }
  1186.                 }
  1187.             }
  1188.         }
  1189.     }
  1191.     /**
  1192.      * @TODO: hardcoded
  1193.      * @param array $formData
  1194.      * @param array $field
  1195.      * @param string $key
  1196.      * @param $value
  1197.      * @return array
  1198.      */
  1199.     private function processPayment(array $formData, array $field, string $key, $value): array
  1200.     {
  1201.         $paymentExentionKey = 'aportacion-economica-exenciones_checkbox';
  1202.         if ($paymentExentionKey === $field['name'] && !$value) {
  1203.             $formData[$key] = ['Ninguno'];
  1205.             return $formData;
  1206.         }
  1208.         if ($paymentExentionKey === $field['name'] && $value) {
  1209.             $formData['preferencia-pago-aportacion-economica_radio'] = '-';
  1210.             $formData['preferencia-domiciliar-pago-aportacion-economica_radio'] = '-';
  1211.         }
  1213.         return $formData;
  1214.     }
  1215. }