PHP FormInterface::has方法代码示例

 /**
  * Process form
  *
  * @param  Task $entity
  *
  * @return bool  True on successful processing, false otherwise
  */
 public function process(Task $entity)
 {
     $action = $this->entityRoutingHelper->getAction($this->request);
     $targetEntityClass = $this->entityRoutingHelper->getEntityClassName($this->request);
     $targetEntityId = $this->entityRoutingHelper->getEntityId($this->request);
     if ($targetEntityClass && !$entity->getId() && $this->request->getMethod() === 'GET' && $action === 'assign' && is_a($targetEntityClass, 'Oro\\Bundle\\UserBundle\\Entity\\User', true)) {
         $entity->setOwner($this->entityRoutingHelper->getEntity($targetEntityClass, $targetEntityId));
         FormUtils::replaceField($this->form, 'owner', ['read_only' => true]);
     }
     $this->form->setData($entity);
     if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
         $this->form->submit($this->request);
         if ($this->form->isValid()) {
             // TODO: should be refactored after finishing BAP-8722
             // Contexts handling should be moved to common for activities form handler
             if ($this->form->has('contexts')) {
                 $contexts = $this->form->get('contexts')->getData();
                 $this->activityManager->setActivityTargets($entity, $contexts);
             } elseif ($targetEntityClass && $action === 'activity') {
                 // if we don't have "contexts" form field
                 // we should save association between activity and target manually
                 $this->activityManager->addActivityTarget($entity, $this->entityRoutingHelper->getEntityReference($targetEntityClass, $targetEntityId));
             }
             $this->onSuccess($entity);
             return true;
         }
     }
     return false;
 }

 public function testFields()
 {
     $this->assertCount(2, $this->form);
     $this->assertTrue($this->form->has('_operation'));
     $view = $this->form->createView();
     $this->assertCount(1, $view['_operation']);
     $this->assertArrayHasKey('confirm', $view['_operation']);
 }

 /**
  * @param Account $entity
  */
 protected function handleContacts($entity)
 {
     if ($this->form->has('contacts')) {
         $contacts = $this->form->get('contacts');
         $this->appendContacts($entity, $contacts->get('added')->getData());
         $this->removeContacts($entity, $contacts->get('removed')->getData());
     }
 }

 protected function validateFields(FormInterface $form, $data)
 {
     if (!in_array($data->getType(), OneTimeContribution::getTypeChoices())) {
         $form->get('type')->addError(new FormError('Choose an option.'));
     } else {
         if ($data->getType() == OneTimeContribution::TYPE_FUNDING_BANK) {
             $bankInformationValidator = new BankInformationFormValidator($form->get('bankInformation'), $data->getBankInformation());
             $bankInformationValidator->validate();
             if (!$data->getStartTransferDate() instanceof \DateTime) {
                 $form->get('start_transfer_date_month')->addError(new FormError('Enter correct date.'));
             } else {
                 $minDate = new \DateTime('+5 days');
                 if ($data->getStartTransferDate() < $minDate) {
                     $form->get('start_transfer_date_month')->addError(new FormError("The start of your transfer should be at least 5 days after today’s date."));
                 }
             }
             if (!$data->getAmount()) {
                 $form->get('amount')->addError(new FormError('Required.'));
             }
             if ($form->has('transaction_frequency')) {
                 $frequency = $form->get('transaction_frequency')->getData();
                 if (null === $frequency || !is_numeric($frequency)) {
                     $form->get('transaction_frequency')->addError(new FormError('Choose an option.'));
                 }
             }
             if ($form->has('contribution_year')) {
                 $contributionYear = $data->getContributionYear();
                 if (null === $contributionYear || !is_numeric($contributionYear)) {
                     $form->get('contribution_year')->addError(new FormError('Enter valid year.'));
                 } else {
                     $currDate = new \DateTime();
                     $currYear = $currDate->format('Y');
                     $minDate = new \DateTime($currYear . '-01-01');
                     $maxDate = new \DateTime($currYear . '-04-15');
                     $startTransferDate = $data->getStartTransferDate();
                     if ($startTransferDate < $minDate || $startTransferDate > $maxDate) {
                         if ($contributionYear !== $currYear) {
                             $form->get('contribution_year')->addError(new FormError(sprintf('Value should be equal %s', $currYear)));
                         }
                     } else {
                         $prevYear = $currDate->add(\DateInterval::createFromDateString('-1 year'))->format('Y');
                         if ($contributionYear !== $currYear && $contributionYear !== $prevYear) {
                             $form->get('contribution_year')->addError(new FormError(sprintf('Value should be equal %s or %s', $prevYear, $currYear)));
                         }
                     }
                 }
             }
         }
     }
 }

 /**
  * @param FormInterface $form
  * @param FormException $formException
  */
 private static function addFormError(FormInterface $form, FormException $formException)
 {
     $fieldName = $formException->getFieldName();
     if ($form->has($fieldName)) {
         $form->get($fieldName)->addError(new FormError($formException->getMessage()));
     }
 }

 /**
  * Extracted POSTed data from JSON request
  *
  * @return array
  * @throws \Symfony\Component\HttpKernel\Exception\HttpException
  */
 protected function getPostJsonData()
 {
     $return = array();
     $body = $this->request->getContent();
     if (!empty($body) && !is_null($body) && $body != 'null') {
         $return = json_decode($body, true);
         if (null === $return || !is_array($return)) {
             throw new HttpException(400, "Bad JSON format of request body");
         }
     }
     // fix array type
     foreach ($return as $name => $value) {
         if (!$this->form->has($name)) {
             continue;
         }
         $formElement = $this->form->get($name);
         if ($formElement->getConfig()->getType()->getName() != 'collection') {
             continue;
         }
         if (!is_array($value) && !empty($value)) {
             $return[$name] = array($value);
         } elseif (!is_array($value) && empty($value)) {
             $return[$name] = array();
         }
     }
     // ignoring additional fields
     foreach ($return as $name => $value) {
         if (!$this->form->has($name)) {
             unset($return[$name]);
         }
     }
     return $return;
 }

 /**
  * @param B2bCustomer $entity
  */
 protected function handleOpportunities(B2bCustomer $entity)
 {
     if ($this->form->has('opportunities')) {
         $opportunities = $this->form->get('opportunities');
         $this->appendOpportunities($entity, $opportunities->get('added')->getData());
         $this->removeOpportunities($entity, $opportunities->get('removed')->getData());
     }
 }

 /**
  * Recurse over nested errors
  *
  * @param FormInterface $form
  * @param array $errors
  */
 private function recurseErrors(FormInterface $form, array $errors)
 {
     foreach ($errors as $field => $error) {
         if (is_array($error)) {
             $this->recurseErrors($form->has($field) ? $form->get($field) : $form, $error);
         } else {
             // todo: this fix should not be in here - needs lifting out into mapping
             if ('addressLine1' == $field) {
                 $field = 'street';
             }
             if ($form->has($field)) {
                 $form->get($field)->addError(new FormError($error));
                 unset($errors[$field]);
             }
         }
     }
 }

 /**
  * Process form
  *
  * @param CalendarEvent $entity
  *
  * @return bool True on successful processing, false otherwise
  */
 public function process(CalendarEvent $entity)
 {
     $this->form->setData($entity);
     if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
         $this->form->submit($this->request);
         if ($this->form->isValid()) {
             // TODO: should be refactored after finishing BAP-8722
             // Contexts handling should be moved to common for activities form handler
             if ($this->form->has('contexts')) {
                 $contexts = $this->form->get('contexts')->getData();
                 $this->activityManager->setActivityTargets($entity, $contexts);
             }
             $this->onSuccess($entity);
             return true;
         }
     }
     return false;
 }

 /**
  * @param GridView $entity
  *
  * @return boolean
  */
 public function process(GridView $entity)
 {
     $entity->setFiltersData();
     $entity->setSortersData();
     $this->form->setData($entity);
     if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
         $data = $this->request->request->all();
         unset($data['name']);
         if ($this->form->has('owner')) {
             $data['owner'] = $entity->getOwner();
         }
         $this->form->submit($data);
         if ($this->form->isValid()) {
             $this->onSuccess($entity);
             return true;
         }
     }
     return false;
 }

 /**
  * @param FormInterface $form
  *
  * @return mixed
  */
 private static function password(FormInterface $form)
 {
     if ($form->has('credentials_group')) {
         $credentialsGroup = $form->get('credentials_group');
         if ($credentialsGroup->has('plainPassword')) {
             $plainPasswordElement = $credentialsGroup->get('plainPassword');
             if (!empty($plainPasswordElement->getData())) {
                 return 'CsrPassword';
             }
         }
     }
 }

 /**
  * Process form
  *
  * @param  CalendarEvent $entity
  * @return bool  True on successful processing, false otherwise
  */
 public function process(CalendarEvent $entity)
 {
     $this->form->setData($entity);
     if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
         $originalChildren = new ArrayCollection();
         foreach ($entity->getChildEvents() as $childEvent) {
             $originalChildren->add($childEvent);
         }
         $this->form->submit($this->request);
         if ($this->form->isValid()) {
             // TODO: should be refactored after finishing BAP-8722
             // Contexts handling should be moved to common for activities form handler
             if ($this->form->has('contexts')) {
                 $contexts = $this->form->get('contexts')->getData();
                 $this->activityManager->setActivityTargets($entity, $contexts);
             }
             $this->onSuccess($entity, $originalChildren, $this->form->get('notifyInvitedUsers')->getData());
             return true;
         }
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function buildValuesForm(FormInterface $form, FamilyInterface $family, DataInterface $data = null, array $options = [])
 {
     foreach ($family->getAttributes() as $attribute) {
         if ($attribute->getGroup()) {
             $groupName = $attribute->getGroup();
             if (!$form->has($groupName)) {
                 $form->add($groupName, 'form', ['inherit_data' => true]);
             }
             $this->addAttribute($form->get($groupName), $attribute, $family, $data, $options);
         } else {
             $this->addAttribute($form, $attribute, $family, $data, $options);
         }
     }
 }

 /**
  * Process form
  *
  * @param  CalendarEvent $entity
  *
  * @throws \LogicException
  *
  * @return bool  True on successful processing, false otherwise
  */
 public function process(CalendarEvent $entity)
 {
     $this->form->setData($entity);
     if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
         $originalChildren = new ArrayCollection();
         foreach ($entity->getChildEvents() as $childEvent) {
             $originalChildren->add($childEvent);
         }
         $this->form->submit($this->request);
         if ($this->form->isValid()) {
             $this->ensureCalendarSet($entity);
             // TODO: should be refactored after finishing BAP-8722
             // Contexts handling should be moved to common for activities form handler
             if ($this->form->has('contexts')) {
                 $contexts = $this->form->get('contexts')->getData();
                 $this->activityManager->setActivityTargets($entity, $contexts);
             }
             $targetEntityClass = $this->entityRoutingHelper->getEntityClassName($this->request);
             if ($targetEntityClass) {
                 $targetEntityId = $this->entityRoutingHelper->getEntityId($this->request);
                 $targetEntity = $this->entityRoutingHelper->getEntityReference($targetEntityClass, $targetEntityId);
                 $action = $this->entityRoutingHelper->getAction($this->request);
                 if ($action === 'activity') {
                     $this->activityManager->addActivityTarget($entity, $targetEntity);
                 }
                 if ($action === 'assign' && $targetEntity instanceof User && $targetEntityId !== $this->securityFacade->getLoggedUserId()) {
                     /** @var Calendar $defaultCalendar */
                     $defaultCalendar = $this->manager->getRepository('OroCalendarBundle:Calendar')->findDefaultCalendar($targetEntity->getId(), $targetEntity->getOrganization()->getId());
                     $entity->setCalendar($defaultCalendar);
                 }
             }
             $this->onSuccess($entity, $originalChildren, $this->form->get('notifyInvitedUsers')->getData());
             return true;
         }
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function chooseGroups(FormInterface $form)
 {
     // All other fields are validated through the Default validation group
     $validation_groups = array('Default');
     if ($form->has('phone') && $form->has('mobile')) {
         $phoneData = $form->get('phone')->getData();
         $mobileData = $form->get('mobile')->getData();
         // If both or neither phone and mobile fields are given,
         // validate both fields
         if (empty($phoneData) && empty($mobileData)) {
             $validation_groups[] = 'phone';
             $validation_groups[] = 'mobile';
         } else {
             // If only phone field alone is given, validate, but
             // not mobile. Only 1 is required.
             if (!empty($phoneData)) {
                 $validation_groups[] = 'phone';
             }
             // If only mobile field alone is given, validate, but
             // not phone. Only 1 is required.
             if (!empty($mobileData)) {
                 $validation_groups[] = 'mobile';
             }
         }
     }
     if ($form->has('bankAccount') && $form->get('bankAccount')) {
         $sortCodeData = $form->get('bankAccount')->get('accountSortcode');
         $accountNumberData = $form->get('bankAccount')->get('accountNumber');
         // If either the sort code or account no are given,
         // validate both fields
         if (!empty($sortCodeData) || !empty($accountNumberData)) {
             $validation_groups[] = 'bankaccount';
         }
     }
     return $validation_groups;
 }