Build ConditionInterface from request

@return ConditionInterface
348756
protected function buildConditionFromRequest()
    {
        $request = $this->getRequest();
        $post = $request->request->getIterator();
        $serviceId = $request->request->get('categoryCondition');
        $operators = [];
        $values = [];
        foreach ($post as $key => $input) {
            if (isset($input['operator']) && isset($input['value'])) {
                $operators[$key] = $input['operator'];
                $values[$key] = $input['value'];
            }
        }

        /** @var ConditionFactory $conditionFactory */
        $conditionFactory = $this->container->get('thelia.condition.factory');
        $conditionToSave = $conditionFactory->build($serviceId, $operators, $values);

        return $conditionToSave;
    }
650469
protected function createPaletteConditionChain()
    {
        if (!$this->condition instanceof PaletteConditionChain) {
            $previousCondition = $this->condition;

            $condition = $this->paletteConditionChainClass->newInstance();
            $event     = new CreatePaletteConditionChainEvent($condition, $this);
            $this->dispatchEvent($event);
            $condition = $event->getPaletteConditionChain();

            $event = new CreateConditionEvent($condition, $this);
            $this->dispatchEvent($event);
            $condition = $event->getCondition();
            /** @var ConditionChainInterface $condition */
            $condition->addCondition($previousCondition);

            $this->condition = $condition;
        }

        return $this;
    }
791779
public function build(): GetSearchResultsRequest
	{
		$instance = new GetSearchResultsRequest();
		if ($this->searchId === null) {
			throw new BuilderException('Property [searchId] is required.');
		}
		$instance->searchId = $this->searchId;
		if ($this->fromIndex === null) {
			throw new BuilderException('Property [fromIndex] is required.');
		}
		$instance->fromIndex = $this->fromIndex;
		if ($this->toIndex === null) {
			throw new BuilderException('Property [toIndex] is required.');
		}
		$instance->toIndex = $this->toIndex;
		return $instance;
	}
393663
public function set(): PageInterface
    {
        $hook = $this->isNetwork() ? 'network_admin_menu' : 'admin_menu';

        // Action for page display.
        $this->action->add($hook, [$this, 'build']);
        // Action for page settings.
        $this->action->add('admin_init', [$this, 'configureSettings']);

        return $this;
    }
302435
public function build(): GetCurrentTimeRequest
	{
		$instance = new GetCurrentTimeRequest();
		if ($this->id === null) {
			throw new BuilderException('Property [id] is required.');
		}
		$instance->id = $this->id;
		return $instance;
	}
831161
public function getConditions()
    {
        $conditionList = $this->withFirstParent(
            Form::class,
            function (Form $formConfiguration) {
                return $formConfiguration->getConditionList();
            }
        );

        $conditionList = ($conditionList) ?: [];
        ArrayUtility::mergeRecursiveWithOverrule($conditionList, $this->conditions);

        return $conditionList;
    }
644620
public function build(): RequestDataRequest
	{
		$instance = new RequestDataRequest();
		if ($this->securityOrigin === null) {
			throw new BuilderException('Property [securityOrigin] is required.');
		}
		$instance->securityOrigin = $this->securityOrigin;
		if ($this->databaseName === null) {
			throw new BuilderException('Property [databaseName] is required.');
		}
		$instance->databaseName = $this->databaseName;
		if ($this->objectStoreName === null) {
			throw new BuilderException('Property [objectStoreName] is required.');
		}
		$instance->objectStoreName = $this->objectStoreName;
		if ($this->indexName === null) {
			throw new BuilderException('Property [indexName] is required.');
		}
		$instance->indexName = $this->indexName;
		if ($this->skipCount === null) {
			throw new BuilderException('Property [skipCount] is required.');
		}
		$instance->skipCount = $this->skipCount;
		if ($this->pageSize === null) {
			throw new BuilderException('Property [pageSize] is required.');
		}
		$instance->pageSize = $this->pageSize;
		$instance->keyRange = $this->keyRange;
		return $instance;
	}
1043118
protected function buildCondition()
    {
        $column = explode('.', $this->column);

        if (count($column) == 1) {
            return [$this->query => func_get_args()];
        }

        return $this->buildRelationQuery(...func_get_args());
    }
473814
public function getInterceptedRequest()
    {
        if ($this->initialized === false) {
            $this->initialize();
        }

        $sessionDataContainer = $this->objectManager->get(SessionDataContainer::class);
        return $sessionDataContainer->getInterceptedRequest();
    }
694949
public function build(): GetResponseBodyRequest
	{
		$instance = new GetResponseBodyRequest();
		if ($this->requestId === null) {
			throw new BuilderException('Property [requestId] is required.');
		}
		$instance->requestId = $this->requestId;
		return $instance;
	}
297487
public function build(): SetCookieRequest
	{
		$instance = new SetCookieRequest();
		if ($this->name === null) {
			throw new BuilderException('Property [name] is required.');
		}
		$instance->name = $this->name;
		if ($this->value === null) {
			throw new BuilderException('Property [value] is required.');
		}
		$instance->value = $this->value;
		$instance->url = $this->url;
		$instance->domain = $this->domain;
		$instance->path = $this->path;
		$instance->secure = $this->secure;
		$instance->httpOnly = $this->httpOnly;
		$instance->sameSite = $this->sameSite;
		$instance->expires = $this->expires;
		return $instance;
	}
690038
protected function createRequest(): RequestInterface
    {
        $url = sprintf('%s/%s', $this->baseUrl, $this->getUrl($this->options));

        return new Request($this->getMethod(), $url, $this->getHeaders());
    }
20940
protected function createActivationForm(): FormInterface
    {
        return $this->createFormBuilder(null, ['translation_domain' => 'ngsite_user'])
            ->add(
                'email',
                EmailType::class,
                [
                    'constraints' => [
                        new Constraints\Email(),
                        new Constraints\NotBlank(),
                    ],
                ]
            )->getForm();
    }
499426
public function build(): BindRequest
	{
		$instance = new BindRequest();
		if ($this->port === null) {
			throw new BuilderException('Property [port] is required.');
		}
		$instance->port = $this->port;
		return $instance;
	}
1020955
public function build(): StartViolationsReportRequest
	{
		$instance = new StartViolationsReportRequest();
		if ($this->config === null) {
			throw new BuilderException('Property [config] is required.');
		}
		$instance->config = $this->config;
		return $instance;
	}
668934
public function build(): GetRelayoutBoundaryRequest
	{
		$instance = new GetRelayoutBoundaryRequest();
		if ($this->nodeId === null) {
			throw new BuilderException('Property [nodeId] is required.');
		}
		$instance->nodeId = $this->nodeId;
		return $instance;
	}
965815
public function build(): StopWorkerRequest
	{
		$instance = new StopWorkerRequest();
		if ($this->versionId === null) {
			throw new BuilderException('Property [versionId] is required.');
		}
		$instance->versionId = $this->versionId;
		return $instance;
	}