Update the filer planning associated with the given filter id
@param \alphayax\freebox\api\v3\models\ParentalControl\FilterPlanning $filterPlanning
@param int $filterId
@return \alphayax\freebox\api\v3\models\ParentalControl\FilterPlanning
506929
public function setFromFilterId( models\ParentalControl\FilterPlanning $filterPlanning, $filterId) {
        $service = sprintf( self::API_PARENTAL_FILTER_PLANNING, $filterId);
        $rest = $this->getService( $service);
        $rest->PUT( $filterPlanning);

        return $rest->getResult( models\ParentalControl\FilterPlanning::class);
    }
382772
private function addNamespaceFilter(ProjectDescriptorBuilder $builder, Filter $filterManager)
    {
        $filter = new LegacyNamespaceFilter($builder);

        // parse parameters
        foreach ($this->plugin->getParameters() as $param) {
            if ($param->getKey() == 'NamespacePrefix') {
                $filter->setNamespacePrefix($param->getValue());
            }
        }

        $filterManager->attach('phpDocumentor\Descriptor\ConstantDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\FunctionDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\InterfaceDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\TraitDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\PropertyDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\FileDescriptor', $filter);
        $filterManager->attach('phpDocumentor\Descriptor\ClassDescriptor', $filter);
    }
245904
public OperationFuture<List<FirewallPolicy>> update(
            FirewallPolicyFilter firewallPolicyFilter,
            FirewallPolicyConfig config
    ) {
        checkNotNull(firewallPolicyFilter, "Firewall policy filter must be not null");

        List<FirewallPolicy> firewallPolicyList = findLazy(firewallPolicyFilter)
            .map(metadata -> FirewallPolicy.refById(
                metadata.getId(),
                DataCenter.refById(metadata.getDataCenterId())
            ))
            .collect(toList());

        return update(firewallPolicyList, config);
    }
759176
public function addFilter(FilterConfig $filter)
    {
        $this->getFilters()->push($filter);
        $filter->attach($this);
        return $this;
    }
348644
private function findFilter($filterId) {
        foreach(filter_list() as $filterName) {
            if(filter_id($filterName)===$filterId) {
                return $filterName;
            }
        }
        
        throw new \Exception('Could not find filter '.$filterId);
    }
1065180
public static base_response update(nitro_service client, filteraction resource) throws Exception {
		filteraction updateresource = new filteraction();
		updateresource.name = resource.name;
		updateresource.servicename = resource.servicename;
		updateresource.value = resource.value;
		updateresource.respcode = resource.respcode;
		updateresource.page = resource.page;
		return updateresource.update_resource(client);
	}
387897
protected function convertAnnouncementsFilter($mappingConfiguration, string $filter = null)
    {
        $this->updateMappingConfigurationForAllowedPoperties($mappingConfiguration, $this->settings['filterAnnouncements']['allowedProperty']);

        // Adjust configuration to allow mapping of sub property 'usergroup'
        $mappingConfiguration->forProperty('startDate')->setTypeConverterOption(
        \TYPO3\CMS\Extbase\Property\TypeConverter\DateTimeConverter::class,
        \TYPO3\CMS\Extbase\Property\TypeConverter\DateTimeConverter::CONFIGURATION_DATE_FORMAT,
        'd.m.Y'
      );

        $mappingConfiguration->forProperty('endDate')->setTypeConverterOption(
        \TYPO3\CMS\Extbase\Property\TypeConverter\DateTimeConverter::class,
        \TYPO3\CMS\Extbase\Property\TypeConverter\DateTimeConverter::CONFIGURATION_DATE_FORMAT,
        'd.m.Y'
      );

        return $this->objectManager->get(PropertyMapper::class)->convert($this->filtertextToArray($filter), AnnouncementsFilter::class, $mappingConfiguration);
    }
1249914
private function buildOwnerFilter(GetFilterEvent $event, $filter)
    {
        $class = $event->getTargetEntity()->getName();
        $interfaces = class_implements($class);

        if (\in_array(OwnerableInterface::class, $interfaces, true)) {
            $filter = $this->buildRequiredOwnerFilter($event, $filter);
        } elseif (\in_array(OwnerableOptionalInterface::class, $interfaces, true)) {
            $filter = $this->buildOptionalOwnerFilter($event, $filter);
        }

        return $filter;
    }
920970
public function setFilterImpact($filterId, $impact) {
        $filter = $this->getFilterData($filterId);

        if($filter === null) {
            return;
        }
        $filter->setImpact($impact);
    }
1035141
public function update( models\ParentalControl\Filter $filter){
        $rest = $this->getService( self::API_PARENTAL_FILTER . $filter->getId());
        $rest->PUT( $filter);

        return $rest->getResult( models\ParentalControl\Filter::class);
    }
736082
public function saveFilter($categoryId, $filterId, $type)
    {
        $filterModel = CategoryFilter::whereCategoryId($categoryId)
                                        ->whereFilterId($filterId)
                                        ->whereType('PROPERTY')->first();
        if (null === $filterModel) {
            CategoryFilter::create([
                'category_id' => $categoryId,
                'filter_id' => $filterId,
                'type' => 'PROPERTY'
            ]);
        }
    }
864221
public function updateMany(array $filter, $update, array $options = [])
    {
        list($bulkOptions, $options) = self::extractBulkWriteOptions($options);
        $model = new UpdateMany($filter, $update, $options);

        $bulkWriteResult = $this->bulkWrite([$model], $bulkOptions);

        return new UpdateResult($bulkWriteResult);
    }
1183417
protected static function filter(
        int $filterId,
        $options = null,
        int $errorCode = ErrorCodes::INVALID_VALUE,
        string $messageTemplate = Messages::INVALID_VALUE,
        RuleInterface $next = null
    ): RuleInterface {
        $filterRule = new Filter($filterId, $options, $errorCode, $messageTemplate);

        return $next === null ? $filterRule : new AndOperator($filterRule, $next);
    }
499090
public function addFilter($filterName, $options = [])
    {
        // Create the filter hash so we can run multiple versions of the same filter
        $filterHash = sprintf('%s_%s', strtolower($filterName), md5(json_encode($options)));

        // Add the filter
        $this->options['filters'][$filterHash] = [
            'filter'  => strtolower($filterName),
            'options' => $options,
        ];

        unset($filterHash);

        return $this;
    }
802080
public function replaceOne(array $filter, $replacement, array $options = [])
    {
        list($bulkOptions, $options) = self::extractBulkWriteOptions($options);
        $model = new ReplaceOne($filter, $replacement, $options);

        $bulkWriteResult = $this->bulkWrite([$model], $bulkOptions);

        return new UpdateResult($bulkWriteResult);
    }
1245367
protected function addFilter(AbstractFilter $filter)
    {
        $this->layout->addFilter($filter);

        $filter->setParent($this);

        if ($this->thisFilterLayoutOnly) {
            $this->thisFilterLayoutOnly = false;
            $this->layoutOnlyFilterColumns[] = $filter->getColumn();
        }

        return $this->filters[] = $filter;
    }
510667
public function addFilter(FilterInterface $filter, $priority = 0)
	{
		if ( ! $filter instanceof FrameFilterInterface && ! $filter instanceof AudioFilterInterface)
		{
			throw new InvalidFilterException('Filter type is not supported.');
		}
		
		if ($priority > 99)
		{
			throw new \RangeException('Priority should be in the range from 0 to 99.');
		}
		
		$this->filters->insert($filter, $priority);
		
		return $this;
	}