public FilterConventionTypeDefinition CreateDefinition()
        {
            var operationDescriptions = new Dictionary <FilterOperationKind, string>();
            var operationsNames       = new Dictionary <FilterOperationKind, CreateFieldName>();
            var allowedOperations     = new HashSet <FilterOperationKind>();

            foreach (FilterConventionOperationDescriptor descriptor in _operations.Values)
            {
                FilterConventionOperationDefinition definition = descriptor.CreateDefinition();
                if (!definition.Ignore)
                {
                    if (definition.Description != null)
                    {
                        operationDescriptions[definition.OperationKind] = definition.Description;
                    }

                    if (definition.Name != null)
                    {
                        operationsNames[definition.OperationKind] = definition.Name;
                    }
                    allowedOperations.Add(definition.OperationKind);
                }
            }

            Definition.AllowedOperations     = allowedOperations;
            Definition.OperationDescriptions = operationDescriptions;
            Definition.OperationNames        = operationsNames;
            return(Definition);
        }
Beispiel #2
0
        public FilterConventionDefinition CreateDefinition()
        {
            if (_visitorDescriptor == null)
            {
                throw new SchemaException(
                          SchemaErrorBuilder.New()
                          .SetMessage("No visitor was defined for FilterConvention")
                          .Build());
            }

            var allowedOperations =
                new Dictionary <FilterKind, IReadOnlyCollection <FilterOperationKind> >();
            var typeDefinitions              = new Dictionary <FilterKind, FilterConventionTypeDefinition>();
            var defaultOperationNames        = new Dictionary <FilterOperationKind, CreateFieldName>();
            var defaultOperationDescriptions = new Dictionary <FilterOperationKind, string>();

            foreach (FilterConventionTypeDescriptor descriptor in _configurations.Values)
            {
                FilterConventionTypeDefinition definition = descriptor.CreateDefinition();
                if (!definition.Ignore)
                {
                    typeDefinitions[definition.FilterKind]   = definition;
                    allowedOperations[definition.FilterKind] = definition.AllowedOperations;
                }
            }

            foreach (FilterConventionDefaultOperationDescriptor descriptor
                     in _defaultOperations.Values)
            {
                FilterConventionOperationDefinition definition = descriptor.CreateDefinition();

                if (!definition.Ignore)
                {
                    if (definition.Description != null)
                    {
                        defaultOperationDescriptions[definition.OperationKind]
                            = definition.Description;
                    }

                    if (definition.Name != null)
                    {
                        defaultOperationNames[definition.OperationKind]
                            = definition.Name;
                    }
                }
            }

            Definition.DefaultOperationDescriptions = defaultOperationDescriptions;
            Definition.DefaultOperationNames        = defaultOperationNames;
            Definition.AllowedOperations            = allowedOperations;
            Definition.TypeDefinitions   = typeDefinitions;
            Definition.ImplicitFilters   = _implicitFilters.ToArray();
            Definition.VisitorDefinition = _visitorDescriptor.CreateDefinition();

            return(Definition);
        }