/** * {@inheritDoc} */ protected function traverseInputs(InputFilterInterface $inputFilter, $values, $callback) { $returnValues = null; foreach ($values as $name => $value) { if (!$inputFilter->has($name)) { continue; } $input = $inputFilter->get($name); if ($input instanceof InputFilterInterface && is_array($value)) { if ($input instanceof CollectionInputFilter) { $filter = $input->getInputFilter(); foreach ($value as $key => $subValue) { $filter->setData($subValue); $returnValues[$name][$key] = (array) $this->traverseInputs($filter, $subValue, $callback); } $filter->setData([]); continue; } $retVal = $this->traverseInputs($input, $value, $callback); if (null !== $retVal) { $returnValues[$name] = $retVal; } continue; } $retVal = $callback($input, $value); if (null !== $retVal) { $returnValues[$name] = $retVal; } } return $returnValues; }
/** * Validates the attributes according to the configuration and throws an exception in case of invalid input. * * @param array $attributes * @throws Exception\InvalidInputException */ public function filterValues(array $attributes) { $this->inputFilter->setData($attributes); if (!$this->inputFilter->isValid()) { throw new Exception\InvalidInputException($this->inputFilter->getMessages()); } return $this->inputFilter->getValues(); }
/** * build * * @param InputFilterInterface $inputFilter * @param array $params * * @return void */ public function build(InputFilterInterface $inputFilter, $params = []) { if ($inputFilter instanceof MessageParamInterface) { $params = array_merge($inputFilter->getMessageParams(), $params); } $primaryApiMessage = new ApiMessage($this->primaryType, $this->primaryMessage, $this->primarySource, $this->primaryCode, true, $params); $this->add($primaryApiMessage); $this->parseInputs($inputFilter); }
public function login(InputFilterInterface $filter) { if (!$filter->isValid()) { throw new \LogicException('Form is not valid'); } $this->authAdapter->setIdentity($filter->getValue('login')); $this->authAdapter->setCredential($filter->getValue('password')); $result = $this->authenticationService->authenticate($this->authAdapter); return $result->isValid(); }
/** * @param BookEntity $bookEntity * @param InputFilterInterface $filter * * @throws \LogicException * @return BookEntity */ public function update(BookEntity $bookEntity, InputFilterInterface $filter) { if (!$filter->isValid()) { throw new \LogicException('Form is not valid!'); } $data = $filter->getValues(); $bookEntity = $this->bookRepository->hydrate($bookEntity, $data); $this->bookRepository->save($bookEntity); return $bookEntity; }
/** * Initialize instance * * @param InputFilterInterface $inputFilter * @param string $variables * @param string $options */ public function __construct(InputFilterInterface $inputFilter, $variables = null, $options = null) { parent::__construct($variables, $options); $this->setVariable('isValid', $inputFilter->isValid()); $messages = $inputFilter->getMessages(); $inputs = array(); foreach ($inputFilter->getValues() as $name => $value) { $inputs[$name] = array('value' => $value, 'messages' => array_key_exists($name, $messages) ? $messages[$name] : array()); } $this->setVariable('inputs', $inputs); }
/** * @param InputFilterInterface $inputFilter * @return array */ private function extractErrorMessages(InputFilterInterface $inputFilter) { $errorMessages = $inputFilter->getMessages(); array_walk($errorMessages, function (&$value, $key) use($inputFilter) { if ($inputFilter->has($key) && $inputFilter->get($key) instanceof InputFilterInterface) { $value = $this->extractErrorMessages($inputFilter->get($key)); } else { $value = array_values($value); } }); return $errorMessages; }
/** * Get all validators for a given element * * @param InputFilterInterface $inputFilter * @param ElementInterface $element * @return mixed */ static function getValidatorsForElement(InputFilterInterface $inputFilter, ElementInterface $element) { // Check if we are dealing with a fieldset element if (preg_match('/^.*\\[(.*)\\]$/', $element->getName(), $matches)) { $elementName = $matches[1]; } else { $elementName = $element->getName(); } if (!$inputFilter->has($elementName)) { return; } $input = $inputFilter->get($elementName); // Make sure NotEmpty validator is added when input is required // $input->isValid(); $chain = $input->getValidatorChain(); return $chain->getValidators(); }
public function __invoke(Request $req, Response $res) { $school = $req->getAttribute('school'); if ($req->isPost()) { $this->appFormInputFilter->setData(array_merge($req->getParams(), ['school_id' => $school->id, 'submitted_by' => $this->authService->getIdentity()->mail])); $isValid = $this->appFormInputFilter->isValid(); if ($isValid) { $data = $this->appFormInputFilter->getValues(); $appForm = $this->appFormService->submit($data); $_SESSION['applicationForm']['appForm'] = $appForm; $res = $res->withRedirect($this->successUrl); return $res; } $this->view['form'] = ['is_valid' => $isValid, 'values' => $this->appFormInputFilter->getValues(), 'raw_values' => $this->appFormInputFilter->getRawValues(), 'messages' => $this->appFormInputFilter->getMessages()]; } $loadForm = (bool) $req->getParam('load', false); $this->view['choose'] = !$loadForm && !$req->isPost(); if (!$req->isPost() && $loadForm) { if (null !== ($appForm = $this->appFormService->findSchoolApplicationForm($school->id))) { $this->view['form'] = ['values' => $appForm]; } } $labs = $this->labService->getLabsBySchoolId($school->id); $res = $this->view->render($res, 'application_form/form.twig', ['lab_choices' => array_map(function ($lab) { return ['value' => $lab['id'], 'label' => $lab['name']]; }, $labs), 'type_choices' => array_map(function ($category) { return ['value' => $category['id'], 'label' => $category['name']]; }, $this->assetsService->getAllItemCategories())]); return $res; }
/** * {@inheritdoc} */ public function isValid($values, $context = null) { if (!is_array($values)) { $this->error(static::ERROR_NOT_ARRAY); return false; } $this->inputFilter->setData($values); if (!$this->inputFilter->isValid()) { $i = 0; foreach ($this->inputFilter->getMessages() as $field => $errors) { foreach ($errors as $key => $string) { $this->messages[$i][$field][$key] = $string; $i++; } } return false; } return true; }
/** * Add an input to the input filter * * @param array|Traversable|InputInterface|InputFilterInterface $input * @param null|string $name * @param $disablePurifier * @return InputFilter */ public function add($input, $name = null, $disablePurifier = false) { /** * By Default all Inputs will filter against XSS and invalid HTML, attributes and scripts */ $purifier = $this->getHtmlPurifier(); $input->getFilterChain()->attach(function ($value) use($purifier, $disablePurifier) { if ($purifier instanceof HTMLPurifier && !$disablePurifier) { if (is_array($value)) { foreach ($value as $key => $v) { $value[$key] = $purifier->purify($v); } return $value; } else { return $purifier->purify($value); } } return $value; }); return parent::add($input, $name); }
/** * @return $this * @throws \LogicException * @throws \InvalidArgumentException */ protected function extractUserMailFromFormular() { if (!isset($this->filter)) { throw new \InvalidArgumentException('No Form set'); } if (!$this->filter->isValid()) { throw new \LogicException('Form is not valid'); } $registerFilter = $this->filter->get('register'); $this->setName($registerFilter->getValue('name')); $this->setEmail($registerFilter->getValue('email')); return $this; }
/** * Execute the request * * @param MvcEvent $e * @return ListViewModelInterface */ public function onDispatch(MvcEvent $e) { if ($this->inputFilter) { $this->inputFilter->setData($this->query); if ($this->inputFilter->isValid()) { $validData = $this->inputFilter->getValues(); $criteria = $this->repository->createCriteria($validData); $collection = $this->repository->findMany($criteria); $this->viewModel->setCollection($collection); $this->viewModel->setInputData($validData); } else { $this->viewModel->setErrors($this->inputFilter->getMessages()); $this->viewModel->setInputData($this->query); } } else { $criteria = $this->repository->createCriteria($this->query); $collection = $this->repository->findMany($criteria); $this->viewModel->setCollection($collection); $this->viewModel->setInputData($this->query); } $e->setResult($this->viewModel); return $this->viewModel; }
/** * Attach defaults provided by the elements to the input filter * * @param InputFilterInterface $inputFilter * @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs * @return void */ public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset) { $formFactory = $this->getFormFactory(); $inputFactory = $formFactory->getInputFilterFactory(); if ($fieldset instanceof Collection && $fieldset->getTargetElement() instanceof FieldsetInterface) { $elements = $fieldset->getTargetElement()->getElements(); } else { $elements = $fieldset->getElements(); } if (!$fieldset instanceof Collection || !$fieldset->getTargetElement() instanceof FieldsetInterface || $inputFilter instanceof CollectionInputFilter) { foreach ($elements as $name => $element) { if ($this->preferFormInputFilter && $inputFilter->has($name)) { continue; } if (!$element instanceof InputProviderInterface) { if ($inputFilter->has($name)) { continue; } // Create a new empty default input for this element $spec = array('name' => $name, 'required' => false); $input = $inputFactory->createInput($spec); } else { // Create an input based on the specification returned from the element $spec = $element->getInputSpecification(); $input = $inputFactory->createInput($spec); if ($inputFilter->has($name) && $inputFilter instanceof ReplaceableInputInterface) { $input->merge($inputFilter->get($name)); $inputFilter->replace($input, $name); continue; } } // Add element input filter to CollectionInputFilter if ($inputFilter instanceof CollectionInputFilter && !$inputFilter->getInputFilter()->has($name)) { $inputFilter->getInputFilter()->add($input, $name); } else { $inputFilter->add($input, $name); } } if ($fieldset === $this && $fieldset instanceof InputFilterProviderInterface) { foreach ($fieldset->getInputFilterSpecification() as $name => $spec) { $input = $inputFactory->createInput($spec); $inputFilter->add($input, $name); } } } foreach ($fieldset->getFieldsets() as $name => $childFieldset) { if (!$childFieldset instanceof InputFilterProviderInterface) { if (!$inputFilter->has($name)) { // Add a new empty input filter if it does not exist (or the fieldset's object input filter), // so that elements of nested fieldsets can be recursively added if ($childFieldset->getObject() instanceof InputFilterAwareInterface) { $inputFilter->add($childFieldset->getObject()->getInputFilter(), $name); } else { // Add input filter for collections via getInputFilterSpecification() if ($childFieldset instanceof Collection && $childFieldset->getTargetElement() instanceof InputFilterProviderInterface && $childFieldset->getTargetElement()->getInputFilterSpecification()) { $collectionContainerFilter = new CollectionInputFilter(); $spec = $childFieldset->getTargetElement()->getInputFilterSpecification(); $filter = $inputFactory->createInputFilter($spec); $collectionContainerFilter->setInputFilter($filter); $inputFilter->add($collectionContainerFilter, $name); // We need to copy the inputs to the collection input filter if ($inputFilter instanceof CollectionInputFilter) { $inputFilter = $this->addInputsToCollectionInputFilter($inputFilter); } // Add child elements from target element $childFieldset = $childFieldset->getTargetElement(); } else { $inputFilter->add(new InputFilter(), $name); } } } $fieldsetFilter = $inputFilter->get($name); if (!$fieldsetFilter instanceof InputFilterInterface) { // Input attached for fieldset, not input filter; nothing more to do. continue; } // Traverse the elements of the fieldset, and attach any // defaults to the fieldset's input filter $this->attachInputFilterDefaults($fieldsetFilter, $childFieldset); continue; } if ($inputFilter->has($name)) { // if we already have an input/filter by this name, use it continue; } // Create an input filter based on the specification returned from the fieldset $spec = $childFieldset->getInputFilterSpecification(); $filter = $inputFactory->createInputFilter($spec); $inputFilter->add($filter, $name); // Recursively attach sub filters $this->attachInputFilterDefaults($filter, $childFieldset); // We need to copy the inputs to the collection input filter to ensure that all sub filters are added if ($inputFilter instanceof CollectionInputFilter) { $inputFilter = $this->addInputsToCollectionInputFilter($inputFilter); } } }
public function getValues() { return $this->inputFilter->getValues(); }
/** * Attach defaults provided by the elements to the input filter * * @param InputFilterInterface $inputFilter * @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs * @return void */ public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset) { $formFactory = $this->getFormFactory(); $inputFactory = $formFactory->getInputFilterFactory(); foreach ($fieldset->getElements() as $element) { if (!$element instanceof InputProviderInterface) { // only interested in the element if it provides input information continue; } $name = $element->getName(); if ($inputFilter->has($name)) { // if we already have an input by this name, use it continue; } // Create an input based on the specification returned from the element $spec = $element->getInputSpecification(); $input = $inputFactory->createInput($spec); $inputFilter->add($input, $name); } foreach ($fieldset->getFieldsets() as $fieldset) { $name = $fieldset->getName(); if (!$fieldset instanceof InputFilterProviderInterface) { if (!$inputFilter->has($name)) { // Not an input filter provider, and no matching input for this fieldset. // Nothing more to do for this one. continue; } $fieldsetFilter = $inputFilter->get($name); if (!$fieldsetFilter instanceof InputFilterInterface) { // Input attached for fieldset, not input filter; nothing more to do. continue; } // Traverse the elements of the fieldset, and attach any // defaults to the fieldset's input filter $this->attachInputFilterDefaults($fieldsetFilter, $fieldset); continue; } if ($inputFilter->has($name)) { // if we already have an input/filter by this name, use it continue; } // Create an inputfilter based on the specification returned from the fieldset $spec = $fieldset->getInputFilterSpecification(); $filter = $inputFactory->createInputFilter($spec); $inputFilter->add($filter, $name); } }
/** * Build the InputFilter, validators and filters from form fields * * @param InputFilterInterface $inputFilter */ private function buildInputFilterFromForm(InputFilterInterface $inputFilter) { foreach ($this->getNodeList() as $name => $node) { if ($inputFilter->has($name)) { continue; } // Detect element type $type = $node->getAttribute('type'); if ($node->tagName === 'textarea') { $type = 'textarea'; } elseif ($node->tagName === 'select') { $type = 'select'; } // Add validation if (array_key_exists($type, $this->formElements)) { $elementClass = $this->formElements[$type]; } else { // Create a default validator $elementClass = $this->formElements['text']; } /** @var \Zend\InputFilter\InputProviderInterface $element */ $element = new $elementClass($node, $this->document); $input = $this->factory->createInput($element); $inputFilter->add($input, $name); } }
/** * Attach defaults provided by the elements to the input filter * * @param InputFilterInterface $inputFilter * @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs * @return void */ public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset) { $formFactory = $this->getFormFactory(); $inputFactory = $formFactory->getInputFilterFactory(); foreach ($fieldset->getElements() as $element) { if (!$element instanceof InputProviderInterface) { // only interested in the element if it provides input information continue; } $name = $element->getName(); // Create an input based on the specification returned from the element $spec = $element->getInputSpecification(); $input = $inputFactory->createInput($spec); $inputFilter->add($input, $name); } foreach ($fieldset->getFieldsets() as $fieldset) { $name = $fieldset->getName(); if (!$fieldset instanceof InputFilterProviderInterface) { if (!$inputFilter->has($name)) { // Add a new empty input filter if it does not exist, so that elements of nested fieldsets can be // recursively added $inputFilter->add(new InputFilter(), $name); } $fieldsetFilter = $inputFilter->get($name); if (!$fieldsetFilter instanceof InputFilterInterface) { // Input attached for fieldset, not input filter; nothing more to do. continue; } // Traverse the elements of the fieldset, and attach any // defaults to the fieldset's input filter $this->attachInputFilterDefaults($fieldsetFilter, $fieldset); continue; } if ($inputFilter->has($name)) { // if we already have an input/filter by this name, use it continue; } // Create an input filter based on the specification returned from the fieldset $spec = $fieldset->getInputFilterSpecification(); $filter = $inputFactory->createInputFilter($spec); $inputFilter->add($filter, $name); // Recursively attach sub filters $this->attachInputFilterDefaults($filter, $fieldset); } }
/** * */ protected function addMessageFilter() { $this->inputFilter->add($this->getFactory()->createInput(array('name' => 'message', 'required' => true, 'filters' => array(array('name' => 'StripTags'), array('name' => 'StringTrim')), 'validators' => array(array('name' => 'StringLength', 'options' => array('encoding' => 'UTF-8', 'min' => 1)))))); }
public function updateInputFilter(InputFilterInterface $addInputFilter, $fieldsetName) { $inputFilter = $this->getInputFilter(); if (!in_array($fieldsetName, array_keys($inputFilter->getInputs()))) { throw new \Exception("Sorry, {$fieldsetName} is invalid fieldset name", null, null); } foreach ($addInputFilter->getValues() as $key => $value) { $this->addInput($addInputFilter->get($key), $fieldsetName); } }
public function testGetValue() { $name = uniqid('name'); $this->adapterMock->expects($this->once())->method('getValue')->with($name); $this->testedObject->getValue($name); }
/** * @param string $name * @return mixed */ public function getValue($name) { return $this->inputFilter->getValue($name); }
/** * Attach defaults provided by the elements to the input filter * * @param InputFilterInterface $inputFilter * @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs * @return void */ public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset) { $formFactory = $this->getFormFactory(); $inputFactory = $formFactory->getInputFilterFactory(); if ($this instanceof InputFilterProviderInterface) { foreach ($this->getInputFilterSpecification() as $name => $spec) { $input = $inputFactory->createInput($spec); $inputFilter->add($input, $name); } } foreach ($fieldset->getElements() as $element) { $name = $element->getName(); if ($this->preferFormInputFilter && $inputFilter->has($name)) { continue; } if (!$element instanceof InputProviderInterface) { if ($inputFilter->has($name)) { continue; } // Create a new empty default input for this element $spec = array('name' => $name, 'required' => false); } else { // Create an input based on the specification returned from the element $spec = $element->getInputSpecification(); } $input = $inputFactory->createInput($spec); $inputFilter->add($input, $name); } foreach ($fieldset->getFieldsets() as $fieldset) { $name = $fieldset->getName(); if (!$fieldset instanceof InputFilterProviderInterface) { if (!$inputFilter->has($name)) { // Add a new empty input filter if it does not exist (or the fieldset's object input filter), // so that elements of nested fieldsets can be recursively added if ($fieldset->getObject() instanceof InputFilterAwareInterface) { $inputFilter->add($fieldset->getObject()->getInputFilter(), $name); } else { $inputFilter->add(new InputFilter(), $name); } } $fieldsetFilter = $inputFilter->get($name); if (!$fieldsetFilter instanceof InputFilterInterface) { // Input attached for fieldset, not input filter; nothing more to do. continue; } // Traverse the elements of the fieldset, and attach any // defaults to the fieldset's input filter $this->attachInputFilterDefaults($fieldsetFilter, $fieldset); continue; } if ($inputFilter->has($name)) { // if we already have an input/filter by this name, use it continue; } // Create an input filter based on the specification returned from the fieldset $spec = $fieldset->getInputFilterSpecification(); $filter = $inputFactory->createInputFilter($spec); $inputFilter->add($filter, $name); // Recursively attach sub filters $this->attachInputFilterDefaults($filter, $fieldset); } }
/** * @todo remove unused $mailer parameter an fix tests * * @param InputFilterInterface $filter * @param Plugin\Mailer $mailer * @param Url $url * @throws \LogicException * @throws UserDoesNotHaveAnEmailException * @throws UserNotFoundException */ public function proceed(InputFilterInterface $filter, Plugin\Mailer $mailer, Url $url) { if (!$filter->isValid()) { throw new \LogicException('Form is not valid'); } $identity = $filter->getValue('identity'); $suffix = $this->loginFilter->filter(); if (!($user = $this->userRepository->findByLoginOrEmail($identity, $suffix))) { throw new UserNotFoundException('User is not found'); } if (!($email = $user->getInfo()->getEmail())) { throw new UserDoesNotHaveAnEmailException('User does not have an email'); } $tokenHash = $this->tokenGenerator->generate($user); $resetLink = $url->fromRoute('lang/goto-reset-password', array('token' => $tokenHash, 'userId' => $user->getId()), array('force_canonical' => true)); $e = new AuthEvent(); $e->setResetLink($resetLink); $e->setUser($user); $this->eventManager->trigger(AuthEvent::EVENT_AUTH_NEWPASSWORD, $e); }
/** * @param InputFilterInterface $inputFilter * @return string */ protected function getInputFilterMessage(InputFilterInterface $inputFilter) { $message = 'Invalid parameters. '; foreach ($inputFilter->getMessages() as $element => $error) { $message .= $element . ' '; foreach ($error as $k => $v) { $message .= $v . '. '; } } return $message; }
/** * @param $association * @param $inputFilter * * @return InputFilterInterface */ protected function getAssociatedEntityInputFilter($association, InputFilterInterface $inputFilter) { // Skip handling associations that aren't in the data // Ensure the collection value has an input filter if (!$inputFilter->has($association)) { /* * Value must not have been in the inputFilter and wasn't stripped out. * Treat as hostile and stop execution. */ throw new InvalidArgumentException('Non-validated input detected: ' . $association); } $childInputFilter = $inputFilter->get($association); if ($childInputFilter instanceof CollectionInputFilter) { return $childInputFilter->getInputFilter(); } else { return $childInputFilter; } }
/** * validateUser * * @param User $requestUser requestUser * @param InputFilterInterface $inputFilter inputFilter * * @return Result */ public function validateUser(User $requestUser, InputFilterInterface $inputFilter) { $validUser = new User(); $validUser->populate($requestUser); $inputFilter->setData($validUser); if ($inputFilter->isValid()) { $validUser->populate($inputFilter->getValues()); return new Result($validUser); } else { $result = new Result($validUser, Result::CODE_FAIL, 'User input not valid'); foreach ($inputFilter->getInvalidInput() as $error) { $msg = $error->getName() . ': '; $errs = $error->getMessages(); foreach ($errs as $key => $val) { $result->setMessage($msg .= "{$val} ({$key})"); } } return $result; } }
/** * Validate a PATCH request * * @param InputFilterInterface $inputFilter * @param array|object $data * @param bool $isCollection * @return bool|ApiProblemResponse */ protected function validatePatch(InputFilterInterface $inputFilter, $data, $isCollection) { if ($isCollection) { $validationGroup = $data; foreach ($validationGroup as &$subData) { $subData = array_keys($subData); } } else { $validationGroup = array_keys($data); } try { $inputFilter->setValidationGroup($validationGroup); return $inputFilter->isValid(); } catch (InputFilterInvalidArgumentException $ex) { $pattern = '/expects a list of valid input names; "(?P<field>[^"]+)" was not found/'; $matched = preg_match($pattern, $ex->getMessage(), $matches); if (! $matched) { return new ApiProblemResponse( new ApiProblem(400, $ex) ); } return new ApiProblemResponse( new ApiProblem(400, 'Unrecognized field "' . $matches['field'] . '"') ); } }
/** * Traverse the InputFilter and run a callback against each Input and associated value * * @param InputFilterInterface $inputFilter * @param array $values * @param callable $callback * @return array|null */ protected function traverseInputs(InputFilterInterface $inputFilter, $values, $callback) { $returnValues = null; foreach ($values as $name => $value) { if (!$inputFilter->has($name)) { continue; } $input = $inputFilter->get($name); if ($input instanceof InputFilterInterface && is_array($value)) { $retVal = $this->traverseInputs($input, $value, $callback); if (null !== $retVal) { $returnValues[$name] = $retVal; } continue; } $retVal = $callback($input, $value); if (null !== $retVal) { $returnValues[$name] = $retVal; } } return $returnValues; }
public function __invoke(Request $req, Response $res) { $school = $req->getAttribute('school'); if ($req->isPost()) { $reqParams = $req->getParams(); array_splice($reqParams['items'], 0, 0); $this->appFormInputFilter->setData(array_merge($reqParams, ['school_id' => $school->id, 'submitted_by' => $this->authService->getIdentity()->mail])); $isValid = $this->appFormInputFilter->isValid(); if ($isValid) { $data = $this->appFormInputFilter->getValues(); $appForm = $this->appFormService->submit($data); $_SESSION['applicationForm']['appForm'] = $appForm; $res = $res->withRedirect($this->successUrl); return $res; } $this->view['form'] = ['is_valid' => $isValid, 'values' => $this->appFormInputFilter->getValues(), 'raw_values' => $this->appFormInputFilter->getRawValues(), 'messages' => $this->appFormInputFilter->getMessages()]; } $loadForm = (bool) $req->getParam('load', false); $this->view['choose'] = !$loadForm && !$req->isPost(); if (!$req->isPost() && $loadForm) { // take care of new options in applications and migrate existing ones if (null !== ($appForm = $this->appFormService->findSchoolApplicationForm($school->id))) { /** * Do mapping of old items to new only if items do exist (old form) * and the map is available at the app settings. * TODO: Only one version migrations are supported. If the old items are * two or more versions older, they will not be handled. */ // get the existing (db) application form version $items_version = $this->version; if (isset($appForm['items']) && \count($appForm['items']) > 0) { $items_version = array_values($appForm['items'])[0]['version']; } if ($this->version != $items_version && isset($appForm['items']) && isset($this->container['settings']['application_form']['itemcategory']['map']) && $this->container['settings']['application_form']['itemcategory']['map']['fromversion'] == $items_version && $this->container['settings']['application_form']['itemcategory']['map']['toversion'] == $this->version && isset($this->container['settings']['application_form']['itemcategory']['map']['items'])) { // if map exists for this version, use it $items_map = $this->container['settings']['application_form']['itemcategory']['map']['items']; $appForm['items'] = array_map(function ($item) use($items_map) { $migrate_values = []; if (isset($items_map[$item['itemcategory_id']]) && intval($items_map[$item['itemcategory_id']]) > 0) { $migrate_values = ['itemcategory_prev' => $item['itemcategory_id'], 'itemcategory_id_prev' => $item['itemcategory_id'], 'itemcategory_id' => intval($items_map[$item['itemcategory_id']])]; } else { $migrate_values = ['itemcategory_prev' => '', 'itemcategory_id_prev' => -1]; } $migrate_values['prev_form_load'] = true; return array_merge($item, $migrate_values); }, $appForm['items']); } elseif ($this->version != $items_version && isset($appForm['items']) && isset($this->container['settings']['application_form']['itemcategory']['map']) && ($this->container['settings']['application_form']['itemcategory']['map']['fromversion'] != $items_version || $this->container['settings']['application_form']['itemcategory']['map']['toversion'] != $this->version)) { // if map does not exist for this version, notify user $items_map = $this->container['settings']['application_form']['itemcategory']['map']['items']; $appForm['items'] = array_map(function ($item) use($items_map) { $migrate_values = ['itemcategory_prev' => '', 'itemcategory_id_prev' => -2, 'prev_form_load' => true]; return array_merge($item, $migrate_values); }, $appForm['items']); } $this->view['form'] = ['values' => $appForm]; } } $labs = $this->labService->getLabsBySchoolId($school->id); $res = $this->view->render($res, 'application_form/form.twig', ['lab_choices' => array_map(function ($lab) { return ['value' => $lab['id'], 'label' => $lab['name']]; }, $labs), 'type_choices' => array_map(function ($category) { return ['value' => $category['id'], 'label' => $category['name']]; }, $this->assetsService->getAllItemCategories($this->version))]); return $res; }