(non-PHPdoc)
@see \Asf\ApplicationBundle\Application\Form\FormHandlerModel::processForm()
@throw \Exception
510621
public function processForm($model)
	{
		try {
			$configManager = $this->container->get('asf_website.config.manager');
			
			// Check configuration alias (internal use)
			$isExists = $configManager->getRepository()->findOneBy(array('alias' => $model->getAlias()));
			if ( $isExists !== null ) {
				throw new \Exception($this->container->get('asf_layout.flash_message')->danger($this->container->get('translator')->trans('A website configuration already exists with alias "%name%".', array('%name%' => $model->getAlias()), 'asf_website')));
			}
			
			// Check default configuration
			$defaultExists = $configManager->getRepository()->findOneBy(array('isDefault' => true));
			if ( $defaultExists === null ) {
				$model->setIsDefault(true);
			} elseif ($model->getIsDefault() == true && $model->getId() != $defaultExists->getId() ) {
				throw new \Exception($this->container->get('asf_layout.flash_message')->danger($this->container->get('translator')->trans('A default website configuration already exists ("%name%").', array('%name%' => $defaultExists->getName()), 'asf_website')));
			}
			
			$model instanceof Config;
			foreach($model->getParameters() as $parameter ) {
				$parameter->setConfig($model);
			}
			
			$db_parameters = $this->container->get('asf_website.parameter.manager')->getRepository()->findBy(array('config' => $model));
			foreach($db_parameters as $db_parameter) {
				if ( !$model->getParameters()->contains($db_parameter) ) {
					$model->removeParameter($db_parameter);
					$this->container->get('asf_website.parameter.manager')->getEntityManager()->remove($db_parameter);
				}
			}
			
			return true;
			
		} catch (\Exception $e) {
			throw new \Exception(sprintf('An error occured : %s', $e->getMessage()));
		}
		
		return false;
	}
765775
function process_form($form, &$preferences){
        global $CFG;

        if (isset($form->email_email)) {
            $preferences['message_processor_email_email'] = clean_param($form->email_email, PARAM_EMAIL);
        }
        if (isset($form->preference_mailcharset)) {
            $preferences['mailcharset'] = $form->preference_mailcharset;
            if (!array_key_exists($preferences['mailcharset'], get_list_of_charsets())) {
                $preferences['mailcharset'] = '0';
            }
        }
        if (isset($form->mailformat) && isset($form->userid)) {
            require_once($CFG->dirroot.'/user/lib.php');

            $user = core_user::get_user($form->userid, '*', MUST_EXIST);
            $user->mailformat = clean_param($form->mailformat, PARAM_INT);
            user_update_user($user, false, false);
        }
    }
871656
public function process($value)
        {

            if ($this->isMandatory() && !$value)
            {
                throw new Exception($this->getMessage(self::IS_MISSING, ['param', $this->reference]));
            }

            $dataProcessor = $this->getDataProcessor();

            if ($dataProcessor instanceof ApplicationAwareInterface)
            {
                $dataProcessor->setApplication($this->getApplication());
            }

            $processedValue = $dataProcessor->process($value);

            if($this->isMandatory() && is_null($processedValue))
            {
                throw new Exception($this->getMessage(self::IS_MISSING, ['param', $this->reference]));
            }

            return $processedValue;
        }
821225
protected function buildForm()
    {
        if ($this->form) {
            return;
        }

        // append parent object if any
        // todo : clean the way the Admin class can retrieve set the object
        if ($this->isChild() && $this->getParentAssociationMapping()) {
            $parent = $this->getParent()->getObject($this->request->get($this->getParent()->getIdParameter()));

            $propertyAccessor = $this->getConfigurationPool()->getPropertyAccessor();
            $propertyPath = new PropertyPath($this->getParentAssociationMapping());

            $object = $this->getSubject();

            $value = $propertyAccessor->getValue($object, $propertyPath);

            if (\is_array($value) || ($value instanceof \Traversable && $value instanceof \ArrayAccess)) {
                $value[] = $parent;
                $propertyAccessor->setValue($object, $propertyPath, $value);
            } else {
                $propertyAccessor->setValue($object, $propertyPath, $parent);
            }
        }

        $formBuilder = $this->getFormBuilder();
        $formBuilder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) {
            $this->preValidate($event->getData());
        }, 100);

        $this->form = $formBuilder->getForm();
    }
606319
protected function processToken(): void
    {
        $prevStatement = null;

        foreach ($this->useStatements as $useStatement) {
            if ($prevStatement && ($this->compareUseStatements($prevStatement, $useStatement) > 0)) {
                $exception = new CodeError(
                    static::CODE_INCORRECT_ORDER,
                    'Use statements should be sorted alphabetically. The first wrong one is %s.',
                    $useStatement->getPointer()
                );

                $exception
                    ->setPayload([$useStatement->getFullyQualifiedTypeName()])
                    ->isFixable(true);

                throw $exception;
            }

            $prevStatement = $useStatement;
        }
    }
257657
public function parse()
    {
        // Get input
        $input = $this->getInput();

        // So empty buffer is not an error its an exception
        if ($input === null) {
            throw new Exception(
                'Please provide HTML to parse information from first!'
            );
        }

        // Initial template is 1:1 copy
        $this->setTemplate($input);

        // Extract form(s) HTML
        $this->setForms($this->parseFormsFromHtml($input));

        // Build configuration from extracted form(s) HTML
        $configuration = $this->getConfiguration();

        // forms
        $forms = $this->parseConfigurations($this->getForms());

        foreach ($forms as $form) {
            $temp = clone $configuration;
            $temp->parseFromArray($form);
            $this->addConfiguration($temp);
        }

        // return instance for chaining
        return $this;
    }
599395
public function processForm( $form, $formModel ) {

		$formSubmit = $formModel->processFormSubmit( $form );

		$this->triggerNotification( $form );

		return $formSubmit;
    }
1141740
def process(self, formdata=None, obj=None, data=None, **kwargs):
        ''''''
        self._obj = obj
        super(CommonFormMixin, self).process(formdata, obj, data, **kwargs)
1147248
public function processAction()
    {
        try {
            /** @var \OxidEsales\PayPalModule\Core\Request $request */
            $request = oxNew(\OxidEsales\PayPalModule\Core\Request::class);
            $action = $request->getRequestParameter('action');

            $order = $this->getEditObject();

            /** @var \OxidEsales\PayPalModule\Model\Action\OrderActionFactory $actionFactory */
            $actionFactory = oxNew(\OxidEsales\PayPalModule\Model\Action\OrderActionFactory::class, $request, $order);
            $action = $actionFactory->createAction($action);

            $action->process();
        } catch (\OxidEsales\Eshop\Core\Exception\StandardException $exception) {
            $this->_aViewData["error"] = $exception->getMessage();
        }
    }
935544
public function process()
    {
        // {{{ defines the xhtml template

        static $xhtml_template = '';

        if ($xhtml_template == '') {
            $doctype =
                '<!DOCTYPE html PUBLIC ' .
                '"-//W3C//DTD XHTML 1.0 Strict//EN" ' .
                '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' .
                "\n";

            $xhtml_template =
                $doctype .
                <<<XHTML
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
	<head>
		<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
		<title>SwatXHTMLTextarea Content</title>
	</head>
	<body>
		<div>
		%s
		</div>
	</body>
</html>

XHTML;
        }

        // }}}

        parent::process();

        $ignore_validation_errors =
            $this->allow_ignore_validation_errors &&
            $this->ignore_errors_checkbox->value;

        $xhtml_content = sprintf($xhtml_template, $this->getXHTMLContent());

        $errors = libxml_use_internal_errors(true);

        $document = new DOMDocument();
        $document->loadXML(
            $xhtml_content,
            LIBXML_DTDLOAD | LIBXML_DTDATTR | LIBXML_DTDVALID
        );

        $xml_errors = libxml_get_errors();
        libxml_clear_errors();
        libxml_use_internal_errors($errors);

        if (count($xml_errors) > 0 && !$ignore_validation_errors) {
            $this->addMessage($this->getValidationErrorMessage($xml_errors));
            $this->has_validation_errors = true;
        }
    }
287318
public function processForm(array $input = null, $validator = null, $csv_handler = null)
	{
		if($input)
		{
			$this->form_input = $input;
		}
		else
		{
			$this->fillFormInput();
		}

		$validator = ($validator) ? $validator : new ValidatorFormInputModel($this);
		$csv_handler = ($csv_handler) ? $csv_handler : new CsvFileHandler();

		if ( $validator->validateInput() && $this->checkColumns() )
		{
			// process form
			$csv_file = $csv_handler->getTemporary();
			if($csv_file)
			{
				try
				{
					$csv_handler->updateHeaders($csv_file, $this->form_input["columns"], $this->form_input["table_name"]);
				}
				catch(UnalignedArrayException $e)
				{
					$this->appendError("No_temporary", "Invalid Column names." );
					return $this->getIsExecuted();
				}

				try
				{
					$csv_handler->saveToDb($this->form_input['types']);
					$this->is_executed = true;
				}
				catch( HeadersNotSetException $e)
				{
					$this->appendError("Save_err", "Cannot save data: check if dmbs support transaction.");
				}
				catch( PDOException $e)
				{
					$this->appendError("Save_err", $e->getMessage() );
				}
				catch( Exception $e)
				{
					$this->appendError("Save_err", $e->getMessage() );
				}
			}
			else
			{
				$this->appendError("No_temporary","No data available to save");
			}
		}
		return $this->getIsExecuted();
	}
1048398
private function processForm($values)
    {
        $form = $this->getForm($this->record);
        $form->bind($values, $this->record);

        if ($form->isValid()) {
            return $this->record->save();
        }

        $this->form = $form;
        throw new InvalidFormException();
    }
271721
public function createAction()
    {
        if ($form = $this->processForm()) {
            $this->setPageTitle(sprintf($this->_('New %s...'), $this->getTopic()));
            $this->html[] = $form;
        }
    }
920879
private function processSelect()
    {
        $this->processTableDefinition();
        $this->processFieldDefinition();
        $this->processFilterDefinition();
        $this->processParamsDefinition();
        $this->processGroupByDefinition();
        $this->processHavingDefinition();
        $this->processJoinDefinition();
        $this->processOrderDefinition();
        $this->processLimitDefinition();
    }
1072743
public function transpile()
    {
        // Form
        /**
 * @var Form form
*/
        $this->form = $this->transpiler->instantiateFormObject();

        // Fields
        $fields = $this->transpiler->findFields();
        if (!is_array($fields)) {
            throw new \Exception("No fields found");
        }


        $this->form->addFields($fields);

        // Populate
        $this->form->populateFields();

        // Validate
        $this->form->validate();

        return $this->form;
    }
1087731
public function process(): void
    {
        /** @var \Closure|object $closure */
        $closure = include $this->file;

        if (!\is_callable($closure)) {
            throw new ComponentException("There is no callable structure in file `{$this->file}`");
        }

        $reflection = new \ReflectionFunction($closure);

        // check and normalize params by doc comment
        $docComment = $reflection->getDocComment();

        // get all options by one regular expression
        if (preg_match_all('/\s*\*\s*\@([a-z0-9-_]+)\s+(.*).*\s+/i', $docComment, $matches)) {
            foreach ($matches[1] as $i => $key) {
                $this->setOption($key, trim($matches[2][$i]));
            }
        }

        // init routes
        $this->initRoute();

        // get params and convert it to simple array
        $reflectionParams = $reflection->getParameters();
        // setup params and optional params
        foreach ($reflectionParams as $param) {
            $name = $param->getName();
            // if some function params is missed in description
            if (!isset($this->params[$name])) {
                $this->params[$name] = null;
            }
            if ($param->isOptional()) {
                $this->values[$name] = $param->getDefaultValue();
            }
        }
    }
766251
public function validateForm()
    {
        $validator = $this->getValidationFactory()->make(
            $this->requestData(),
            $this->rules()
        );

        if ($validator->fails())
            throw new \Exception($this->formatErrors($validator->errors()));
    }