@deprecated This method is now internal to the AttributeSearchAction action/service

@param Request            $request
@param AttributeInterface $attribute

@throws \BadMethodCallException
556041
protected function getQueryBuilderByAttribute(Request $request, AttributeInterface $attribute)
    {
        $m = __METHOD__.' is deprecated and now internal to the '.AttributeSearchAction::class.' action/service';

        throw new \BadMethodCallException($m);
    }
1091291
@Override
    public void removeAttribute(String name) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Removing attribute: " + name);
        }
        this.attributes.remove(name);
    }
1337419
protected function checkAttributeAssignable($attribute): void
    {
        if (empty($this->assignable)) {
            return;
        }

        if (is_array($attribute)) {

            foreach ($attribute as $singleAttribute) {
                $this->checkAttributeAssignable($singleAttribute);
            }

            return;
        }

        if ( ! in_array($attribute, $this->assignable)) {
            throw new UnassignableAttributeException("Not allowed to assign value for '{$attribute}'");
        }
    }
763772
public function getAction(Request $request, $attributeId, $attributeValueId)
    {
        $locale = $this->getLocale($request);
        try {
            $this->getAttributeManager()->findByIdAndLocale($attributeId, $locale);
        } catch (AttributeNotFoundException $exc) {
            $exception = new EntityNotFoundException($exc->getEntityName(), $exc->getId());
            $view = $this->view($exception->toArray(), 404);

            return $this->handleView($view);
        }

        try {
            $attributeValue = $this->getManager()->findByIdAndLocale($attributeValueId, $locale);
            $view = $this->view($attributeValue, 200);
        } catch (AttributeValueNotFoundException $exc) {
            $exception = new EntityNotFoundException($exc->getEntityName(), $exc->getId());
            $view = $this->view($exception->toArray(), 404);
        }

        return $this->handleView($view);
    }
969037
@Override
    public Object getAttribute(String name, ServletRequest request) {
        if (this.isServletContainerManagedAttribute(name)) {
            return request.getAttribute(name);
        }
        return null;
    }
451901
protected function parseResult(DataInterface $data, AttributeInterface $attribute = null)
    {
        $m = __METHOD__.' is deprecated, use the '.ResponseRendererInterface::class.' service instead';

        throw new \BadMethodCallException($m);
    }
368692
public function store(AttributeRequest $request)
    {
        $attribute = $this->attributeRepository->create($request->all());
        $this->saveDropdownOptions($attribute, $request);

        return redirect()->route('admin.attribute.index');
    }
818726
private function _saveDropdownOptions($attribute, $request)
    {
        if (null !== $request->get('dropdown-options')) {
            if (null != $attribute->attributeDropdownOptions()->get() &&
                $attribute->attributeDropdownOptions()->get()->count() >= 0
                ) {
                $attribute->attributeDropdownOptions()->delete();
            }

            foreach ($request->get('dropdown-options') as $key => $val) {
                if ($key == '__RANDOM_STRING__') {
                    continue;
                }

                $attribute->attributeDropdownOptions()->create($val);
            }
        }
    }
1042647
@Override
    public Object getAttribute(String arg0) {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getAttribute(arg0);
        } finally {
            collaborator.postInvoke();
        }
    }
1326667
public function deleteAction(Request $request, $attributeId, $attributeValueId)
    {
        try {
            $this->getManager()->delete($attributeValueId, $this->getUser()->getId());
            $view = $this->view($attributeValueId, 204);
        } catch (AttributeValueNotFoundException $exc) {
            $exception = new EntityNotFoundException($exc->getEntityName(), $exc->getId());
            $view = $this->view($exception->toArray(), 404);
        }

        return $this->handleView($view);
    }
37680
private function parseRequest($request)
    {
        if (empty($request)) {
            return;
        }

        $this->request = $request;

        // Models used in this request.
        $models_used = [];

        // Review each request.
        foreach ($this->request as $name => $filters) {
            // This name is not present in available attributes.
            if (!Arr::has($this->attributes, $name)) {
                continue;
            }

            // Get the settings for the given attribute.
            $settings = Arr::get($this->attributes, $name);

            // Settings is empty.
            if (empty($settings)) {
                continue;
            }

            // Check and validate each of the filters.
            $filters = self::validateFilters($filters, $settings);

            // Search against current model.
            if (($model_name = Arr::get($settings, 'model_name')) === 'self') {
                $this->search_models['self'][$name] = $filters;
                continue;
            }

            // Search against an model via relationship.
            $models_used[$model_name] = true;
            $this->search_models[$model_name][$name] = $filters;
        }

        // Join the models to this query.
        if (count($models_used)) {
            $this->modelJoin($models_used);
        }
    }
545251
public function process(ServerRequestInterface $request)
    {
        if (null === $this->dispatcher) {
            throw new \BadMethodCallException("Middleware stack must first be provided via the init() method.");
        }
        return $this->dispatcher->dispatch($request);
    }
819828
public function process(ServerRequestInterface $request, DelegateInterface $delegate)
    {
        if (null !== ($data = $request->getAttribute(CommandDispatcher::ATTRIBUTE))) {
            $operation = $this->getOperation($request);
            $schema    = $operation
                ->getResponse($this->okStatusResolver->resolve($data, $operation))
                ->getSchema();

            $request = $request->withAttribute(
                CommandDispatcher::ATTRIBUTE,
                $this->processorBuilder->build($schema)->dehydrate($data)
            );
        }

        return $delegate->process($request);
    }
1179721
protected function doResolveParametersForAttribute($attribute, $parameters)
    {
        $this->attributes[$attribute] = $this->getValueForParameters(
            $parameters,
            $this->attributes[$attribute],
            $this->attributes
        );
    }
564679
public function validate(MethodInterface $method)
    {
        $constraints = $method->getValidationConstraints();
        if (empty($constraints)) {
            return;
        }

        $violations = $this->validator->validate(
            $method->getAttributes(),
            $constraints
        );

        $countable = is_array($violations) || $violations instanceof \Countable;

        if ($countable && count($violations) !== 0) {
            throw new Exception\InvalidAttributeValue(
                'Your method contains invalid attribute value',
                $violations
            );
        }
    }
628734
protected function fillAttributeFromRequest(NovaRequest $request, $requestAttribute, $model, $attribute)
    {
        $this->fields->each(function ($field) use ($request, $model, $attribute) {
            $field->fillInto($request, $model, $attribute.'->'.$field->attribute, $attribute.'.'.$field->attribute);
        });
    }
134989
public function familySearchAction(Request $request, FamilyInterface $family)
    {
        $m = __METHOD__.' is deprecated, consider using the '.FamilySearchAction::class.' action/service instead';
        @trigger_error($m, E_USER_DEPRECATED);

        return $this->familySearchAction->__invoke($request, $family);
    }