src/Service/JsonFormManager.php line 28

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\MasterForm;
  8. use App\Form\CollectionJsonType;
  9. use App\Validator\UniqueLeadDataBy;
  10. use DateTime;
  11. use Exception;
  12. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  13. use Symfony\Component\Filesystem\Exception\FileNotFoundException;
  14. use Symfony\Component\Filesystem\Filesystem;
  15. use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  16. use Symfony\Component\Form\Extension\Core\Type\CollectionType;
  17. use Symfony\Component\Form\Extension\Core\Type\DateTimeType;
  18. use Symfony\Component\Form\Extension\Core\Type\DateType;
  19. use Symfony\Component\Form\Extension\Core\Type\EmailType;
  20. use Symfony\Component\Form\Extension\Core\Type\FormType;
  21. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  22. use Symfony\Component\Form\Extension\Core\Type\NumberType;
  23. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  24. use Symfony\Component\Form\Extension\Core\Type\TextareaType;
  25. use Symfony\Component\Form\Extension\Core\Type\TextType;
  26. use Symfony\Component\Validator\Validator\ValidatorInterface;
  28. class JsonFormManager
  29. {
  30.     /** @var Filesystem $filesystem */
  31.     private $filesystem;
  32.     /** @var array $formDefinition */
  33.     private $formDefinition;
  34.     /** @var ParameterBagInterface $params */
  35.     private $params;
  36.     /** @var ValidatorInterface $validator */
  37.     private $validator;
  38.     /** @var Form $form */
  39.     private $form;
  40.     /** @var array $queryParams */
  41.     private $queryParams = [];
  43.     public const FOLDER_NAME = 'forms';
  44.     public const GROUP_TYPE = 'group';
  45.     public const TEXT_TYPE = 'text';
  46.     public const TEXTAREA_TYPE = 'textarea';
  47.     public const EMAIL_TYPE = 'email';
  48.     public const NUMBER_TYPE = 'number';
  49.     public const SELECT_TYPE = 'select';
  50.     public const CHECKBOX_TYPE = 'checkbox';
  51.     public const RADIO_TYPE = 'radio';
  52.     public const DATE_TYPE = 'date';
  53.     public const DATETIME_TYPE = 'datetime';
  54.     public const HIDDEN_TYPE = 'hidden';
  55.     public const COLLECTION_TYPE = 'collection';
  56.     public const SUBMIT_TYPE = 'submit';
  58.     public const SUPPORTED_TYPES = [
  59.         self::GROUP_TYPE,
  60.         self::TEXT_TYPE,
  61.         self::TEXTAREA_TYPE,
  62.         self::EMAIL_TYPE,
  63.         self::NUMBER_TYPE,
  64.         self::SELECT_TYPE,
  65.         self::CHECKBOX_TYPE,
  66.         self::RADIO_TYPE,
  67.         self::DATE_TYPE,
  68.         self::DATETIME_TYPE,
  69.         self::HIDDEN_TYPE,
  70.         self::COLLECTION_TYPE,
  71.         self::SUBMIT_TYPE
  72.     ];
  74.     public const SELECTABLE_TYPES = [
  75.         self::SELECT_TYPE,
  76.         self::CHECKBOX_TYPE,
  77.         self::RADIO_TYPE
  78.     ];
  80.     public const ADDABLE_TYPES = [
  81.         self::TEXT_TYPE => self::TEXT_TYPE,
  82.         self::TEXTAREA_TYPE => self::TEXTAREA_TYPE,
  83.         self::EMAIL_TYPE => self::EMAIL_TYPE,
  84.         self::NUMBER_TYPE => self::NUMBER_TYPE,
  85.         // TODO
  86.         // self::SELECT_TYPE => self::SELECT_TYPE,
  87.         // self::CHECKBOX_TYPE => self::CHECKBOX_TYPE,
  88.         // self::RADIO_TYPE => self::RADIO_TYPE,
  89.         self::DATE_TYPE => self::DATE_TYPE,
  90.         self::DATETIME_TYPE => self::DATETIME_TYPE,
  91.         self::HIDDEN_TYPE => self::HIDDEN_TYPE
  92.     ];
  94.     public const VALUABLE_TYPES = [
  95.         self::TEXT_TYPE => self::TEXT_TYPE,
  96.         self::TEXTAREA_TYPE => self::TEXTAREA_TYPE,
  97.         self::EMAIL_TYPE => self::EMAIL_TYPE,
  98.         self::NUMBER_TYPE => self::NUMBER_TYPE,
  99.         self::SELECT_TYPE => self::SELECT_TYPE,
  100.         self::CHECKBOX_TYPE => self::CHECKBOX_TYPE,
  101.         self::RADIO_TYPE => self::RADIO_TYPE,
  102.         self::DATE_TYPE => self::DATE_TYPE,
  103.         self::DATETIME_TYPE => self::DATETIME_TYPE,
  104.         self::HIDDEN_TYPE => self::HIDDEN_TYPE
  105.     ];
  107.     // Delimiters
  108.     public const FIELDNAME_DELIMITER = '_';
  109.     public const CHECKBOX_VIEW_DELIMITER = ' | ';
  110.     public const INCOMPATIBLE_FIELD_DELIMITER = '__';
  112.     /**
  113.      * @param Filesystem $filesystem
  114.      * @param ParameterBagInterface $params
  115.      * @param ValidatorInterface $validator
  116.      */
  117.     public function __construct(Filesystem $filesystem, ParameterBagInterface $params, ValidatorInterface $validator)
  118.     {
  119.         $this->filesystem = $filesystem;
  120.         $this->params = $params;
  121.         $this->validator = $validator;
  122.     }
  124.     /**
  125.      * @return FormInterface|null
  126.      */
  127.     public function getForm(): ?FormInterface
  128.     {
  129.         return $this->form;
  130.     }
  132.     /**
  133.      * @param FormInterface $form
  134.      * @return self
  135.      */
  136.     public function setForm(FormInterface $form): self
  137.     {
  138.         $this->form = $form;
  140.         return $this;
  141.     }
  143.     /**
  144.      * @param array $queryParams
  145.      * @return $this
  146.      */
  147.     public function setQueryParams(array $queryParams): self
  148.     {
  149.         $this->queryParams = $queryParams;
  151.         return $this;
  152.     }
  154.     /**
  155.      * @param string $filePath
  156.      * @return $this
  157.      */
  158.     public function loadFromFilePath(string $filePath): JsonFormManager
  159.     {
  160.         $filePath = $this->getBasePath() . "/" . $filePath;
  162.         if (!$this->filesystem->exists($filePath)) {
  163.             throw new FileNotFoundException();
  164.         }
  166.         $this->formDefinition = json_decode(file_get_contents($filePath), true);
  168.         if ($this->form instanceof MasterForm) {
  169.             return $this;
  170.         }
  172.         if ($formFieldAddings = $this->form->getFormFieldAddings()) {
  173.             foreach ($formFieldAddings as $adding) {
  174.                 // TODO group 0 only
  175.                 $this->formDefinition[0]['fields'][] = [
  176.                     'type' => $adding->getType(),
  177.                     'common' => [
  178.                         'name' => $adding->getName(),
  179.                         'label' => $adding->getLabel()
  180.                     ],
  181.                     'attr' => [],
  182.                     'constraints' => []
  183.                 ];
  184.             }
  185.         }
  187.         $this->addFieldToDefinition();
  189.         return $this;
  190.     }
  192.     public function getFromFormLead(Type $var = null)
  193.     {
  194.         # code...
  195.     }
  197.     /**
  198.      * @return array|array[]
  199.      * @throws Exception
  200.      */
  201.     public function getFormDefinition(): array
  202.     {
  203.         if (!$this->formDefinition) {
  204.             throw new Exception('No se puede obtener la definición del formulario sin cargar antes el archvo de definición');
  205.         }
  207.         return array_map(function($value) {
  208.             return $this->buildFormItem($value);
  209.         }, $this->formDefinition);
  210.     }
  212.     /**
  213.      * @param array $formItem
  214.      * @return array
  215.      * @throws Exception
  216.      */
  217.     private function buildFormItem(array $formItem): array
  218.     {
  219.         if (!$this->formTypeIsSupported($formItem['type'])) {
  220.             throw new Exception(sprintf('El tipo %s no está soportado', $formItem['type']));
  221.         }
  223.         if ($formItem['type'] == self::GROUP_TYPE) {
  224.             $nativeFields = [];
  225.             foreach ($formItem['fields'] as $formSubItem) {
  226.                 $nativeFields[] = $this->buildFormItem($formSubItem);
  227.             }
  228.             return [
  229.                 'name' =>  $formItem['name'],
  230.                 'class' => FormType::class,
  231.                 'options' => [
  232.                     'label' => $formItem['title'],
  233.                     'inherit_data' => true
  234.                 ],
  235.                 'fields' => $nativeFields,
  236.                 'attr' => isset($formItem['attr']) ? $formItem['attr'] : []
  237.             ];
  238.         }
  240.         return $this->configureNativeFormItemByType($this->buildNativeFormItem($formItem), $formItem);
  241.     }
  243.     /**
  244.      * @param array $formItem
  245.      * @return array
  246.      * @throws Exception
  247.      */
  248.     private function buildNativeFormItem(array $formItem): array
  249.     {
  250.         $nativeFormItem = [
  251.             'name' =>  self::buildFieldName($formItem['common']['name'], $formItem['type']),
  252.             'options' => [
  253.                 'label' => $formItem['common']['label'],
  254.                 'attr' => $formItem['attr'],
  255.                 'label_html' => true
  256.             ]
  257.         ];
  259.         if (isset($formItem['common']['help'])) {
  260.             $nativeFormItem['options']['help'] = $formItem['common']['help'];
  261.         }
  263.         if (isset($formItem['attr']['disabled'])) {
  264.             $nativeFormItem['options']['disabled'] = $formItem['attr']['disabled'];
  265.         }
  267.         if (isset($formItem['constraints']['required'])) {
  268.             $nativeFormItem['options']['required'] = $formItem['constraints']['required'];
  269.         }
  271.         // Check if persist field
  272.         if (isset($formItem['bind'])) {
  273.             $nativeFormItem['options']['attr']['bind'] = $formItem['bind'];
  274.         }
  276.         // Check if unique
  277.         if (isset($formItem['constraints']['unique'])) {
  278.             $nativeFormItem['options']['attr']['unique'] = $formItem['constraints']['unique'];
  279.         }
  281.         if (self::COLLECTION_TYPE === $formItem['type']) {
  282.             $nativeFormItem = $this->buildNativeCollection($nativeFormItem, $formItem);
  283.         }
  285.         // Constraints
  286.         $nativeFormItem = $this->buildConstraints($nativeFormItem, $formItem);
  288.         // Conditioned fields
  290.         return $this->getConditionedFields($nativeFormItem, $formItem);
  291.     }
  293.     /**
  294.      * @param array $nativeFormItem
  295.      * @param array $formItem
  296.      * @return array
  297.      * @throws Exception
  298.      */
  299.     private function buildNativeCollection(array $nativeFormItem, array $formItem): array
  300.     {
  301.         // Min number of elements (for type collections)
  302.         if (isset($formItem['constraints']['min_items'])) {
  303.             if (!is_numeric($formItem['constraints']['min_items'])) {
  304.                 throw new Exception($formItem['constraints']['min_items'] . ' debe ser un número entero');
  305.             }
  306.             $nativeFormItem['options']['attr']['min_items'] = $formItem['constraints']['min_items'];
  307.         }
  309.         // Max number of elements (for type collections)
  310.         if (isset($formItem['constraints']['max_items'])) {
  311.             if (!is_numeric($formItem['constraints']['max_items'])) {
  312.                 throw new Exception($formItem['constraints']['max_items'] . ' debe ser un número entero');
  313.             }
  314.             $nativeFormItem['options']['attr']['max_items'] = $formItem['constraints']['max_items'];
  315.         }
  317.         // Add label text (for type collections)
  318.         if (isset($formItem['constraints']['add_label'])) {
  319.             if (!is_string($formItem['constraints']['add_label'])) {
  320.                 throw new Exception($formItem['constraints']['add_label'] . ' debe ser texto');
  321.             }
  322.             $nativeFormItem['options']['attr']['add_label'] = $formItem['constraints']['add_label'];
  323.         }
  325.         // Remove label text (for type collections)
  326.         if (isset($formItem['constraints']['remove_label'])) {
  327.             if (!is_string($formItem['constraints']['remove_label'])) {
  328.                 throw new Exception($formItem['constraints']['remove_label'] . ' debe ser texto');
  329.             }
  330.             $nativeFormItem['options']['attr']['remove_label'] = $formItem['constraints']['remove_label'];
  331.         }
  333.         return $nativeFormItem;
  334.     }
  336.     /**
  337.      * @param array $nativeFormItem
  338.      * @param array $formItem
  339.      * @return array
  340.      * @throws Exception
  341.      */
  342.     private function configureNativeFormItemByType(array $nativeFormItem, array $formItem): array
  343.     {
  344.         switch ($formItem['type']) {
  345.             case self::TEXT_TYPE:
  346.                 $nativeFormItem['class'] = TextType::class;
  347.                 break;
  348.             case self::TEXTAREA_TYPE:
  349.                 $nativeFormItem['class'] = TextareaType::class;
  350.                 break;
  351.             case self::EMAIL_TYPE:
  352.                 $nativeFormItem['class'] = EmailType::class;
  353.                 break;
  354.             case self::NUMBER_TYPE:
  355.                 $nativeFormItem['options']['html5'] = true;
  356.                 $nativeFormItem['class'] = NumberType::class;
  357.                 break;
  358.             case self::SELECT_TYPE:
  359.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  360.                 if (isset($formItem['attr']['value'])) {
  361.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  362.                 }
  363.                 $nativeFormItem['class'] = ChoiceType::class;
  364.                 break;
  365.             case self::CHECKBOX_TYPE:
  366.                 $nativeFormItem['options']['expanded'] = true;
  367.                 $nativeFormItem['options']['multiple'] = true;
  368.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  369.                 $data = [];
  370.                 foreach ($formItem['choices'] as $choice) {
  371.                     if (isset($choice['checked']) && $choice['checked']) {
  372.                         $data[$choice['label']] = $choice['value'];
  373.                     }
  374.                 }
  375.                 if (!empty($data)) {
  376.                     $nativeFormItem['options']['data'] = $data;
  377.                 }
  378.                 $nativeFormItem['class'] = ChoiceType::class;
  379.                 break;
  380.             case self::RADIO_TYPE:
  381.                 $nativeFormItem['options']['expanded'] = true;
  382.                 $nativeFormItem['options']['multiple'] = false;
  383.                 $nativeFormItem['options']['choices'] = $this->buildFieldOptions($formItem['choices']);
  384.                 if (isset($formItem['attr']['value'])) {
  385.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  386.                 }
  387.                 $nativeFormItem['class'] = ChoiceType::class;
  388.                 break;
  389.             case self::DATE_TYPE:
  390.                 $nativeFormItem['options']['widget'] = 'single_text';
  391.                 $nativeFormItem['options']['html5'] = true;
  392.                 $nativeFormItem['class'] = DateType::class;
  393.                 break;
  394.             case self::DATETIME_TYPE:
  395.                 $nativeFormItem['options']['widget'] = 'single_text';
  396.                 $nativeFormItem['options']['html5'] = true;
  397.                 $nativeFormItem['class'] = DateTimeType::class;
  398.                 break;
  399.             case self::HIDDEN_TYPE:
  400.                 $nativeFormItem['class'] = HiddenType::class;
  401.                 if (isset($formItem['attr']['value'])) {
  402.                     $nativeFormItem['options']['data'] = $formItem['attr']['value'];
  403.                 }
  404.                 break;
  405.             case self::COLLECTION_TYPE:
  406.                 $items = [];
  407.                 foreach ($formItem['items'] as $item) {
  408.                     $items[] = $this->buildFormItem($item);
  409.                 }
  410.                 $nativeFormItem['class'] = CollectionType::class;
  411.                 $nativeFormItem['options']['entry_type'] = CollectionJsonType::class;
  412.                 $nativeFormItem['options']['entry_options'] = ['collection' => $items];
  413.                 $nativeFormItem['options']['allow_add'] = true;
  414.                 $nativeFormItem['options']['allow_delete'] = true;
  415.                 break;
  416.             case self::SUBMIT_TYPE:
  417.                 $nativeFormItem['class'] = SubmitType::class;
  418.                 break;
  419.             default:
  420.                 break;
  421.         }
  423.         return $nativeFormItem;
  424.     }
  426.     /**
  427.      * @param string $type
  428.      * @return bool
  429.      */
  430.     public static function formTypeIsSupported(string $type): bool
  431.     {
  432.         return in_array($type, self::SUPPORTED_TYPES);
  433.     }
  435.     /**
  436.      * @param array $choices
  437.      * @param bool $fieldIsRequired
  438.      * @return array
  439.      */
  440.     private function buildFieldOptions(array $choices, bool $fieldIsRequired = false): array
  441.     {
  442.         $nativeChoices = [];
  444.         foreach ($choices as $choice) {
  445.             $nativeChoices[$choice['label']] = $choice['value'];
  446.         }
  448.         return $nativeChoices;
  449.     }
  451.     /**
  452.      * @param string $fieldName
  453.      * @param $fieldValue
  454.      * @return string
  455.      * @throws Exception
  456.      */
  457.     public static function formFieldResponseToDb(string $fieldName, $fieldValue): string
  458.     {
  459.         $type = self::getTypeFromFieldName($fieldName);
  461.         if (!self::formTypeIsSupported($type)) {
  462.             throw new Exception(sprintf('El tipo %s no está soportado', $type));
  463.         }
  465.         switch ($type) {
  466.             case self::TEXT_TYPE:
  467.             case self::TEXTAREA_TYPE:
  468.             case self::EMAIL_TYPE:
  469.             case self::SELECT_TYPE:
  470.             case self::RADIO_TYPE:
  471.                 return $fieldValue;
  472.             case self::NUMBER_TYPE:
  473.                 return (str_replace(',', '.', $fieldValue));
  474.             case self::CHECKBOX_TYPE:
  475.                 return serialize($fieldValue);
  476.             case self::DATE_TYPE:
  477.                 return $fieldValue->format('Y-m-d');
  478.             case self::DATETIME_TYPE:
  479.                 return $fieldValue->format('Y-m-d H:i:s');
  480.             default:
  481.                 break;
  482.         }
  484.         return $fieldValue;
  485.     }
  487.     /**
  488.      * @param $field
  489.      * @param $type
  490.      * @return string
  491.      * @throws Exception
  492.      */
  493.     public static function formFieldDbItemToPrint($field, $type): string
  494.     {
  495.         if (!self::formTypeIsSupported($type)) {
  496.             throw new Exception(sprintf('El tipo %s no está soportado', $type));
  497.         }
  499.         switch ($type) {
  500.             case self::TEXT_TYPE:
  501.             case self::TEXTAREA_TYPE:
  502.             case self::EMAIL_TYPE:
  503.             case self::SELECT_TYPE:
  504.             case self::RADIO_TYPE:
  505.                 return $field;
  506.             case self::NUMBER_TYPE:
  507.                 return str_replace(".", ",", $field);
  508.             case self::CHECKBOX_TYPE:
  509.                 $unserialize = unserialize($field);
  510.                 if (is_string($unserialize) || $field === "") {
  511.                     return $unserialize;
  512.                 }
  514.                 return implode(self::CHECKBOX_VIEW_DELIMITER, $unserialize);
  515.             case self::DATE_TYPE:
  516.                 return (new DateTime($field))->format('d-m-Y');
  517.             case self::DATETIME_TYPE:
  518.                 return (new DateTime($field))->format('d-m-Y H:i');
  519.             default:
  520.                 break;
  521.         }
  523.         return $field;
  524.     }
  526.     /**
  527.      * @param string $fieldName
  528.      * @return string
  529.      */
  530.     public static function getNameFromFieldName(string $fieldName): string
  531.     {
  532.         return self::explodeFieldName($fieldName, 0);
  533.     }
  535.     /**
  536.      * @param string $fieldName
  537.      * @return string
  538.      */
  539.     public static function getTypeFromFieldName(string $fieldName): string
  540.     {
  541.         return self::explodeFieldName($fieldName, 1);
  542.     }
  544.     /**
  545.      * @return array
  546.      * @throws Exception
  547.      */
  548.     public function getFormDefinitionFields(): array
  549.     {
  550.         $result = [];
  551.         foreach ($this->getFormDefinition() as $item) {
  552.             if (!$this->formItemIsGroup($item)) {
  553.                 // Is field
  554.                 $result[] = $item;
  555.                 continue;
  556.             }
  558.             foreach ($item['fields'] as $field) {
  559.                 $result[] = $field;
  560.             }
  561.         }
  563.         return $result;
  564.     }
  566.     /**
  567.      * @param array $formData
  568.      * @param array $formDefinitionFields
  569.      * @return array
  570.      */
  571.     public function getFormDataInFormDefinitionFields(array $formData, array $formDefinitionFields): array
  572.     {
  573.         foreach ($formData as $key => $value) {
  574.             foreach ($formDefinitionFields as $field) {
  575.                 if ($field['name'] !== $key) {
  576.                     continue;
  577.                 }
  579.                 // TODO: hardcoded
  580.                 $formData = $this->processPayment($formData, $field, $key, $value);
  582.                 // Check not binding fields
  583.                 if (isset($field['options']['attr']['bind']) && !$field['options']['attr']['bind']) {
  584.                     unset($formData[$key]);
  585.                 }
  586.             }
  587.         }
  589.         return $formData;
  590.     }
  592.     /**
  593.      * @param string $incompatibleValueString
  594.      * @return mixed|string
  595.      */
  596.     public function getIncompatibleGroup(string $incompatibleValueString)
  597.     {
  598.         return $this->getExplodedIncompatibleField($incompatibleValueString)[0];
  599.     }
  601.     /**
  602.      * @param string $incompatibleValueString
  603.      * @return false|string[]
  604.      */
  605.     public function getExplodedIncompatibleField(string $incompatibleValueString)
  606.     {
  607.         return explode(self::INCOMPATIBLE_FIELD_DELIMITER, $incompatibleValueString);
  608.     }
  610.     /**
  611.      * @param string $value
  612.      * @return string
  613.      */
  614.     public static function unFormattedHtml(string $value): string
  615.     {
  616.         return $value != strip_tags($value) ? strip_tags($value) : $value;
  617.     }
  619.     /**
  620.      * @param array $formItem
  621.      * @return bool
  622.      */
  623.     private function formItemIsGroup(array $formItem): bool
  624.     {
  625.         return isset($formItem['fields']);
  626.     }
  628.     /**
  629.      * @param array $nativeFormItem
  630.      * @param array $formItem
  631.      * @return array
  632.      * @throws Exception
  633.      */
  634.     private function buildConstraints(array $nativeFormItem, array $formItem): array
  635.     {
  636.         if (
  637.             !isset($formItem['constraints']['validators']) &&
  638.             !isset($formItem['constraints']['unique_by']) &&
  639.             !isset($formItem['constraints']['incompatible_with'])
  640.         ) {
  641.             return $nativeFormItem;
  642.         }
  644.         if (isset($formItem['constraints']['unique_by'])) {
  645.             $nativeFormItem = $this->buildConstraintUniqueBy($nativeFormItem, $formItem);
  646.         }
  648.         if (isset($formItem['constraints']['incompatible_with'])) {
  649.             $nativeFormItem = $this->buildIncompatibleField($nativeFormItem, $formItem);
  650.         }
  652.         if (isset($formItem['constraints']['validators'])) {
  653.             $nativeFormItem = $this->buildConstraintValidators($nativeFormItem, $formItem);
  654.         }
  656.         return $nativeFormItem;
  657.     }
  659.     /**
  660.      * @param array $nativeFormItem
  661.      * @param array $formItem
  662.      * @return array
  663.      */
  664.     private function buildConstraintUniqueBy(array $nativeFormItem, array $formItem): array
  665.     {
  666.         $entity = null;
  667.         $campaign = $this->getForm()->getCampaign();
  668.         $company = $campaign->getCompany();
  669.         switch ($formItem['constraints']['unique_by']) {
  670.             case $this->getForm()->getCampaign()->getClass():
  671.                 $entity = $campaign;
  672.                 break;
  673.             case $this->getForm()->getCampaign()->getCompany()->getClass():
  674.                 $entity = $company;
  675.         }
  677.         $nativeFormItem['options']['constraints'][] = new UniqueLeadDataBy(['entity' => $entity]);
  679.         return $nativeFormItem;
  680.     }
  682.     /**
  683.      * @param array $nativeFormItem
  684.      * @param array $formItem
  685.      * @return array
  686.      */
  687.     private function buildIncompatibleField(array $nativeFormItem, array $formItem): array
  688.     {
  689.         $indexes = ['group', 'name', 'type'];
  690.         foreach ($formItem['constraints']['incompatible_with'] as $key => $value) {
  691.             $value = '';
  692.             foreach ($indexes as $index) {
  693.                 $value .= $formItem['constraints']['incompatible_with'][$key][$index] . self::INCOMPATIBLE_FIELD_DELIMITER;
  694.             }
  695.             $nativeFormItem['options']['attr']["incompatible-with-$key"] = substr(
  696.                 $value,
  697.                 0,
  698.                 -strlen(self::INCOMPATIBLE_FIELD_DELIMITER)
  699.             );
  700.         }
  702.         return $nativeFormItem;
  703.     }
  705.     /**
  706.      * @param array $nativeFormItem
  707.      * @param array $formItem
  708.      * @return array
  709.      * @throws Exception
  710.      */
  711.     private function buildConstraintValidators(array $nativeFormItem, array $formItem): array
  712.     {
  713.         foreach ($formItem['constraints']['validators'] as $validator => $params) {
  714.             $validatorNamespaces = [
  715.                 'App\Validator',
  716.                 '\Symfony\Component\Validator\Constraints'
  717.             ];
  719.             $className = null;
  720.             foreach ($validatorNamespaces as $validatorNamespace) {
  721.                 $className = $validatorNamespace . '\\' . $validator;
  722.                 if ($this->validator->hasMetadataFor($className)) {
  723.                     break;
  724.                 }
  725.             }
  726.             if (!$className) {
  727.                 throw new Exception();
  728.             }
  730.             if (!empty($params)) {
  731.                 $nativeFormItem['options']['constraints'][] = new $className($params);
  732.             } else {
  733.                 $nativeFormItem['options']['constraints'][] = new $className();
  734.             }
  735.         }
  737.         return $nativeFormItem;
  738.     }
  740.     /**
  741.      * @param string $fieldName
  742.      * @param int $index
  743.      * @return string
  744.      */
  745.     private static function explodeFieldName(string $fieldName, int $index): string
  746.     {
  747.         return explode(self::FIELDNAME_DELIMITER, $fieldName)[$index];
  748.     }
  750.     /**
  751.      * @param string $name
  752.      * @param string $type
  753.      * @return string
  754.      */
  755.     public static function buildFieldName(string $name, string $type): string
  756.     {
  757.         return $name . self::FIELDNAME_DELIMITER . $type;
  758.     }
  760.     /**
  761.      * @param string $name
  762.      * @param string $type
  763.      * @param string $label
  764.      * @param string $groupLabel
  765.      * @return string
  766.      */
  767.     public static function buildFieldIndexLabel(string $name, string $type, string $label, string $groupLabel): string
  768.     {
  769.         return
  770.             $name . self::FIELDNAME_DELIMITER .
  771.             $type . self::FIELDNAME_DELIMITER .
  772.             self::unFormattedHtml($label) . self::FIELDNAME_DELIMITER .
  773.             self::unFormattedHtml($groupLabel);
  774.     }
  776.     /**
  777.      * @return array
  778.      * @throws Exception
  779.      */
  780.     public function buildCsvHeader(): array
  781.     {
  782.         $result = [];
  783.         foreach ($this->getFormDefinition() as $item) {
  784.             if (!$this->formItemIsGroup($item)) {
  785.                 // Is field
  786.                 continue;
  787.             }
  788.             $groupLabel = $item['options']['label'] ?? '';
  789.             foreach ($item['fields'] as $field) {
  790.                 $index = $field['name'];
  791.                 $result[$index]['label'] = $field['options']['label'];
  792.                 $result[$index]['group_label'] = $groupLabel;
  793.             }
  794.         }
  796.         return $result;
  797.     }
  799.     /**
  800.      * @return string
  801.      */
  802.     public function getBasePath(): string
  803.     {
  804.         return $this->params->get('kernel.project_dir') . "/" . self::FOLDER_NAME;
  805.     }
  807.     public function getOrderedJsonFields() 
  808.     {
  809.         $path = $this->getBasePath() . '/order.json';
  811.         $jsonContent = file_get_contents($path);
  813.         $data = json_decode($jsonContent, true);
  815.         return $data;
  816.     }
  818.     /**
  819.      * @param array $nativeFormItem
  820.      * @param array $formItem
  821.      * @return array
  822.      */
  823.     private function getConditionedFields(array $nativeFormItem, array $formItem): array
  824.     {
  825.         if (!in_array($formItem['type'], self::SELECTABLE_TYPES)) {
  826.             return $nativeFormItem;
  827.         }
  828.         if (!isset($formItem['choices'])) {
  829.             return $nativeFormItem;
  830.         }
  832.         $conditionedFields = [];
  833.         foreach ($formItem['choices'] as $keyChoice => $choice) {
  834.             if (!isset($choice['conditional_on']) || !$choice['conditional_on']) {
  835.                 continue;
  836.             }
  838.             $conditionedFields[$keyChoice]['parent_value'] = $choice['value'];
  839.             foreach ($choice['conditional_on'] as $key => $item) {
  840.                 $conditionedFields[$keyChoice]['conditioned_fields'][$key] = $item;
  841.                 $conditionedFields[$keyChoice]['conditioned_fields'][$key]['field_name'] = self::buildNativeFieldName(
  842.                     isset($this->findFieldGroup($formItem)['name']) ? $this->findFieldGroup($formItem)['name'] : '',
  843.                     $item['field']['name'],
  844.                     $item['field']['type']
  845.                 );
  846.                 unset($conditionedFields[$keyChoice]['conditioned_fields'][$key]['field']);
  847.             }
  848.         }
  849.         if (!empty($conditionedFields)) {
  850.             $nativeFormItem['options']['attr']['data-conditioned-fields'] = json_encode($conditionedFields, true);
  851.         }
  853.         return $nativeFormItem;
  854.     }
  856.     /**
  857.      * @param array $formItem
  858.      * @return array|mixed|void
  859.      */
  860.     private function findFieldGroup(array $formItem)
  861.     {
  862.         foreach ($this->formDefinition as $group) {
  863.             if (!$this->formItemIsGroup($group)) {
  864.                 continue;
  865.             }
  866.             foreach ($group['fields'] as $field) {
  867.                 if ($field['type'] === $formItem['type'] && $field['common']['name'] === $formItem['common']['name']) {
  868.                     return $group;
  869.                 }
  870.             }
  871.         }
  873.         return [];
  874.     }
  876.     /**
  877.      * @param string $groupName
  878.      * @param string $name
  879.      * @param string $type
  880.      * @return string
  881.      */
  882.     private function buildNativeFieldName(string $groupName, string $name, string $type): string
  883.     {
  884.         return 'json_' . $groupName . self::FIELDNAME_DELIMITER . self::buildFieldName($name, $type);
  885.     }
  887.     /**
  888.      * @return void
  889.      */
  890.     private function addFieldToDefinition()
  891.     {
  892.         if (!$this->queryParams) {
  893.             return;
  894.         }
  896.         foreach ($this->queryParams as $key => $param) {
  897.             foreach ($this->formDefinition as $keyGroup => $group) {
  898.                 if (!$this->formItemIsGroup($group)) {
  899.                     continue;
  900.                 }
  901.                 foreach ($group['fields'] as $keyField => $field) {
  902.                     if ($key !== $field['common']['name']) {
  903.                         continue;
  904.                     }
  906.                     $value = null;
  907.                     $readOnly = false;
  908.                     switch ($field['type']) {
  909.                         case self::EMAIL_TYPE:
  910.                         case self::TEXT_TYPE:
  911.                         case self::NUMBER_TYPE:
  912.                             $value = $param;
  913.                             $readOnly = true;
  914.                         break;
  915.                         case self::HIDDEN_TYPE:
  916.                             $value = $param;
  917.                             break;
  918.                         case self::DATE_TYPE:
  919.                             if (DateTimeService::isDate($param)) {
  920.                                 $value = $param;
  921.                                 $readOnly = true;
  922.                             }
  923.                             break;
  924.                         case self::DATETIME_TYPE:
  925.                             if (DateTimeService::isDateTime($param)) {
  926.                                 $value = $param;
  927.                                 $readOnly = true;
  928.                             }
  929.                             break;
  930.                         case self::RADIO_TYPE:
  931.                         case self::SELECT_TYPE:
  932.                             if (!isset($field['choices'])) {
  933.                                 break;
  934.                             }
  935.                             foreach ($field['choices'] as $choice) {
  936.                                 if ($choice['value'] !== $param) {
  937.                                     continue;
  938.                                 }
  939.                                 $value = $param;
  940.                                 $readOnly = true;
  941.                                 break;
  942.                             }
  944.                             break;
  945.                         case self::CHECKBOX_TYPE:
  946.                             $value = $param;
  947.                             $readOnly = true;
  948.                             $this->formDefinition[$keyGroup]['fields'][$keyField]['choices'][0]['label'] = $param;
  949.                             break;
  950.                     }
  951.                     if (!$value) {
  952.                         continue;
  953.                     }
  955.                     $this->formDefinition[$keyGroup]['fields'][$keyField]['attr']['value'] = $value;
  956.                     if ($readOnly) {
  957.                         $this->formDefinition[$keyGroup]['fields'][$keyField]['attr']['readonly'] = true;
  958.                     }
  959.                 }
  960.             }
  961.         }
  962.     }
  964.     /**
  965.      * @TODO: hardcoded
  966.      * @param array $formData
  967.      * @param array $field
  968.      * @param string $key
  969.      * @param $value
  970.      * @return array
  971.      */
  972.     private function processPayment(array $formData, array $field, string $key, $value): array
  973.     {
  974.         $paymentExentionKey = 'aportacion-economica-exenciones_checkbox';
  975.         if ($paymentExentionKey === $field['name'] && !$value) {
  976.             $formData[$key] = ['Ninguno'];
  978.             return $formData;
  979.         }
  981.         if ($paymentExentionKey === $field['name'] && $value) {
  982.             $formData['preferencia-pago-aportacion-economica_radio'] = '-';
  983.             $formData['preferencia-domiciliar-pago-aportacion-economica_radio'] = '-';
  984.         }
  986.         return $formData;
  987.     }
  988. }