mirror of
https://gitlab.com/Chill-Projet/chill-bundles.git
synced 2025-06-12 13:24:25 +00:00
407 lines
14 KiB
PHP
407 lines
14 KiB
PHP
<?php
|
|
|
|
/*
|
|
* Chill is a software for social workers
|
|
* Copyright (C) 2014, Champs Libres Cooperative SCRLFS, <http://www.champs-libres.coop>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace Chill\CustomFieldsBundle\CustomFields;
|
|
|
|
use Chill\CustomFieldsBundle\Form\Type\ChoicesListType;
|
|
use Chill\CustomFieldsBundle\Form\Type\ChoicesType;
|
|
use Chill\CustomFieldsBundle\Form\Type\ChoiceWithOtherType;
|
|
use Chill\CustomFieldsBundle\CustomFields\CustomFieldInterface;
|
|
use Symfony\Component\Form\FormBuilderInterface;
|
|
use Chill\CustomFieldsBundle\Entity\CustomField;
|
|
use Symfony\Component\HttpFoundation\RequestStack;
|
|
use Chill\CustomFieldsBundle\Form\DataTransformer\CustomFieldDataTransformer;
|
|
use Symfony\Bridge\Twig\TwigEngine;
|
|
use Chill\MainBundle\Templating\TranslatableStringHelper;
|
|
use Symfony\Component\Translation\Translator;
|
|
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
|
|
use Chill\MainBundle\Form\Type\TranslatableStringFormType;
|
|
|
|
/**
|
|
*
|
|
*
|
|
* @author Julien Fastré <julien.fastre@champs-libres.coop>
|
|
* @author Marc Ducobu <marc@champs-libes.coop>
|
|
*/
|
|
class CustomFieldChoice extends AbstractCustomField
|
|
{
|
|
const ALLOW_OTHER = 'other';
|
|
const OTHER_VALUE_LABEL = 'otherValueLabel';
|
|
const MULTIPLE = 'multiple';
|
|
const EXPANDED = 'expanded';
|
|
const CHOICES = 'choices';
|
|
|
|
private $defaultLocales;
|
|
|
|
/**
|
|
*
|
|
* @var TwigEngine
|
|
*/
|
|
private $templating;
|
|
|
|
/**
|
|
* @var TranslatableStringHelper Helper that find the string in current locale from an array of translation
|
|
*/
|
|
private $translatableStringHelper;
|
|
|
|
public function __construct(
|
|
Translator $translator,
|
|
TwigEngine $templating,
|
|
TranslatableStringHelper $translatableStringHelper)
|
|
{
|
|
$this->defaultLocales = $translator->getFallbackLocales();
|
|
$this->templating = $templating;
|
|
$this->translatableStringHelper = $translatableStringHelper;
|
|
}
|
|
|
|
public function buildForm(FormBuilderInterface $builder, CustomField $customField)
|
|
{
|
|
//prepare choices
|
|
$choices = array();
|
|
$customFieldOptions = $customField->getOptions();
|
|
|
|
foreach($customFieldOptions[self::CHOICES] as $persistedChoices) {
|
|
if ($persistedChoices['active']){
|
|
$choices[$persistedChoices['slug']] = $this->translatableStringHelper->localize($persistedChoices['name']);
|
|
}
|
|
}
|
|
|
|
//prepare $options
|
|
$options = array(
|
|
'multiple' => $customFieldOptions[self::MULTIPLE],
|
|
'choices' => array_combine(array_values($choices),array_keys($choices)),
|
|
'required' => $customField->isRequired(),
|
|
'label' => $this->translatableStringHelper->localize($customField->getName())
|
|
);
|
|
|
|
//if allow_other = true
|
|
if ($customFieldOptions[self::ALLOW_OTHER] == true) {
|
|
$otherValueLabel = null;
|
|
if(array_key_exists(self::OTHER_VALUE_LABEL, $customFieldOptions)) {
|
|
$otherValueLabel = $this->translatableStringHelper->localize(
|
|
$customFieldOptions[self::OTHER_VALUE_LABEL]
|
|
);
|
|
}
|
|
|
|
$builder->add(
|
|
$builder
|
|
->create(
|
|
$customField->getSlug(),
|
|
ChoiceWithOtherType::class,
|
|
$options,
|
|
array('other_value_label'=> $otherValueLabel)
|
|
)
|
|
->addModelTransformer(new CustomFieldDataTransformer($this, $customField)));
|
|
|
|
} else { //if allow_other = false
|
|
//we add the 'expanded' to options
|
|
$options['expanded'] = $customFieldOptions[self::EXPANDED];
|
|
|
|
$builder->add(
|
|
$builder->create($customField->getSlug(), ChoiceType::class, $options)
|
|
->addModelTransformer(new CustomFieldDataTransformer($this, $customField))
|
|
);
|
|
}
|
|
}
|
|
|
|
public function buildOptionsForm(FormBuilderInterface $builder)
|
|
{
|
|
$builder
|
|
->add(self::MULTIPLE, ChoiceType::class, array(
|
|
'expanded' => true,
|
|
'multiple' => false,
|
|
'choices' => array(
|
|
'Multiple' => '1',
|
|
'Unique' => '0'),
|
|
'empty_data' => '0',
|
|
'label' => 'Multiplicity'
|
|
))
|
|
->add(self::EXPANDED, ChoiceType::class, array(
|
|
'expanded' => true,
|
|
'multiple' => false,
|
|
'choices' => array(
|
|
'Expanded' => '1',
|
|
'Non expanded' => '0'),
|
|
'empty_data' => '0',
|
|
'label' => 'Choice display'
|
|
))
|
|
->add(self::ALLOW_OTHER, ChoiceType::class, array(
|
|
'label' => 'Allow other',
|
|
'choices' => array(
|
|
'No' => '0',
|
|
'Yes' => '1'),
|
|
'empty_data' => '0',
|
|
'expanded' => true,
|
|
'multiple' => false
|
|
))
|
|
->add(self::OTHER_VALUE_LABEL, TranslatableStringFormType::class, array(
|
|
'label' => 'Other value label (empty if use by default)'))
|
|
->add(self::CHOICES, ChoicesType::class, array(
|
|
'entry_type' => ChoicesListType::class,
|
|
'allow_add' => true
|
|
));
|
|
|
|
return $builder;
|
|
}
|
|
|
|
public function deserialize($serialized, CustomField $customField)
|
|
{
|
|
// we always have to adapt to what the current data should be
|
|
$options = $customField->getOptions();
|
|
|
|
if ($options[self::MULTIPLE]) {
|
|
return $this->deserializeToMultiple($serialized, $options[self::ALLOW_OTHER]);
|
|
} else {
|
|
return $this->deserializeToUnique($serialized, $options[self::ALLOW_OTHER]);
|
|
}
|
|
return $serialized;
|
|
}
|
|
|
|
private function deserializeToUnique($serialized, $allowOther)
|
|
{
|
|
$value = $this->guessValue($serialized);
|
|
|
|
// set in a single value. We must have a single string
|
|
$fixedValue = is_array($value) ?
|
|
// check if the array has an element, if not replace by empty string
|
|
count($value) > 0 ? end($value) : ''
|
|
:
|
|
$value;
|
|
|
|
if ($allowOther) {
|
|
return $this->deserializeWithAllowOther($serialized, $fixedValue);
|
|
} else {
|
|
return $fixedValue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* deserialized the data from the database to a multiple
|
|
* field
|
|
*
|
|
* @param mixed $serialized
|
|
* @param boolean $allowOther
|
|
*/
|
|
private function deserializeToMultiple($serialized, $allowOther)
|
|
{
|
|
$value = $this->guessValue($serialized);
|
|
|
|
// set in an array : we want a multiple
|
|
$fixedValue = is_array($value) ? $value : array($value);
|
|
|
|
if ($allowOther) {
|
|
return $this->deserializeWithAllowOther($serialized, $fixedValue);
|
|
} else {
|
|
return $fixedValue;
|
|
}
|
|
}
|
|
|
|
private function deserializeWithAllowOther($serialized, $value)
|
|
{
|
|
$existingOther = isset($serialized['_other']) ? $serialized['_other'] : '';
|
|
|
|
return array(
|
|
'_other' => $existingOther,
|
|
'_choices' => $value
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Guess the value from the representation of it.
|
|
*
|
|
* If the value had an 'allow_other' = true option, the returned value
|
|
* **is not** the content of the _other field, but the `_other` string.
|
|
*
|
|
* @param array|string $value
|
|
* @return mixed
|
|
* @throws \LogicException if the case is not covered by this
|
|
*/
|
|
private function guessValue($value)
|
|
{
|
|
if ($value === NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!is_array($value)) {
|
|
return $value;
|
|
} else {
|
|
// we have a field with "allow other"
|
|
if (array_key_exists('_choices', $value)) {
|
|
return $value['_choices'];
|
|
} else {
|
|
// we have a field with "multiple"
|
|
return $value;
|
|
}
|
|
}
|
|
|
|
throw \LogicException("This case is not expected.");
|
|
}
|
|
|
|
public function getName()
|
|
{
|
|
return 'Choices';
|
|
}
|
|
|
|
public function isEmptyValue($value, CustomField $customField)
|
|
{
|
|
if ($value === NULL) {
|
|
return true;
|
|
}
|
|
|
|
// if multiple choice OR multiple/single choice with other
|
|
if (is_array($value))
|
|
{
|
|
// if allow other
|
|
if (array_key_exists('_choices', $value)) {
|
|
if ($value['_choices'] === NULL) {
|
|
return true;
|
|
}
|
|
return empty($value['_choices']);
|
|
} else { // we do not have 'allow other'
|
|
if (count($value) === 1){
|
|
return empty($value[0]);
|
|
} else {
|
|
return empty($value);
|
|
}
|
|
}
|
|
} else {
|
|
return empty($value);
|
|
}
|
|
|
|
throw \LogicException("This case is not expected.");
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @internal this function is able to receive data whichever is the value of "other", "multiple"
|
|
* @param mixed $value
|
|
* @param CustomField $customField
|
|
* @return string html representation
|
|
*/
|
|
public function render($value, CustomField $customField, $documentType = 'html')
|
|
{
|
|
//extract the data. They are under a _choice key if they are stored with allow_other
|
|
$data = (isset($value['_choices'])) ? $value['_choices'] : $value;
|
|
$selected = (is_array($data)) ? $data : array($data);
|
|
$choices = $customField->getOptions()[self::CHOICES];
|
|
|
|
if (in_array('_other', $selected)){
|
|
$choices[] = array('name' => $value['_other'], 'slug' => '_other');
|
|
}
|
|
|
|
$template = 'ChillCustomFieldsBundle:CustomFieldsRendering:choice.html.twig';
|
|
if($documentType == 'csv') {
|
|
$template = 'ChillCustomFieldsBundle:CustomFieldsRendering:choice.csv.twig';
|
|
}
|
|
|
|
return $this->templating
|
|
->render($template,
|
|
array(
|
|
'choices' => $choices,
|
|
'selected' => $selected,
|
|
'multiple' => $customField->getOptions()[self::MULTIPLE],
|
|
'expanded' => $customField->getOptions()[self::EXPANDED],
|
|
'locales' => $this->defaultLocales
|
|
)
|
|
);
|
|
}
|
|
|
|
public function serialize($value, CustomField $customField)
|
|
{
|
|
return $value;
|
|
}
|
|
|
|
public function getChoices(CustomField $cf)
|
|
{
|
|
if ($cf->getOptions()[self::MULTIPLE]) {
|
|
$choices = array();
|
|
|
|
foreach ($cf->getOptions()[self::CHOICES] as $choice) {
|
|
if ($choices['active'] === false) {
|
|
continue;
|
|
}
|
|
$choices[$choice["slug"]] = $this->translatableStringHelper
|
|
->localize($choice["name"]);
|
|
}
|
|
|
|
if ($this->allowOtherChoice($cf)) {
|
|
$labels = $cf->getOptions()[self::OTHER_VALUE_LABEL];
|
|
if (!is_array($labels) or count($labels) === 0) {
|
|
$labels['back'] = 'other value';
|
|
}
|
|
$choices['_other'] = $this->translatableStringHelper
|
|
->localize($labels);
|
|
}
|
|
|
|
return $choices;
|
|
} else {
|
|
return [
|
|
$cf->getSlug() => $this->translatableStringHelper->localize($cf->getName())
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the choice given in $choiceSlug is checked inside $data.
|
|
*
|
|
* Used in list exports.
|
|
*
|
|
* @param CustomField $cf
|
|
* @param string $choiceSlug the slug of the choice we want to know if it was checked
|
|
* @param array|string $data the data of the field
|
|
* @return boolean
|
|
*/
|
|
public function isChecked(CustomField $cf, $choiceSlug, $data)
|
|
{
|
|
if ($data === null) {
|
|
return false;
|
|
}
|
|
|
|
if ($cf->getOptions()[self::MULTIPLE]) {
|
|
if ($cf->getOptions()[self::ALLOW_OTHER]) {
|
|
return \in_array($choiceSlug, $this->deserialize($data, $cf)['_choices']);
|
|
} else {
|
|
return \in_array($choiceSlug, $this->deserialize($data, $cf));
|
|
}
|
|
} else {
|
|
if ($cf->getOptions()[self::ALLOW_OTHER]) {
|
|
return $this->deserialize($data, $cf)['_choices'] === $choiceSlug;
|
|
} else {
|
|
return $this->deserialize($data, $cf) === $choiceSlug;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function isMultiple(CustomField $cf)
|
|
{
|
|
return $cf->getOptions()[self::MULTIPLE];
|
|
}
|
|
|
|
public function allowOtherChoice(CustomField $cf)
|
|
{
|
|
return $cf->getOptions()[self::ALLOW_OTHER];
|
|
}
|
|
|
|
public function extractOtherValue(CustomField $cf, array $data = null)
|
|
{
|
|
return $data['_other'];
|
|
}
|
|
}
|