How to turn off using non existing property of OpenTypes in OData

user_8825020 0
Viewed 198

I am using Open Types:

public class Student
    {
        public Guid Id { get; set; }

        public string Name { get; set; }

        public IBackpack Backpack
        {
            get
            {
                return new Backpack() { Id = Guid.NewGuid() };
            }
            set
            {

            }
        }

        Dictionary<string, object> interfaces;
        public Dictionary<string, object> Interfaces
        {
            get
            {
                if (interfaces == null)
                {
                    interfaces = new Dictionary<string, object>
                    {
                        { "Backpack", this.Backpack as Backpack }
                    };
                }
                return interfaces;
            }
            set
            {
            }
        }
    }

My model:

 static IEdmModel GetEdmModel(ODataConventionModelBuilder builder)
        {
            builder.EntityType<IEntity>().Abstract().HasKey(s => s.Id);
            var entity = builder.EntityType<Student>();
            entity.Ignore(s => s.Backpack);
            builder.EntityType<Backpack>();
            builder.EntitySet<Student>("Student");
            var model = builder.GetEdmModel();
            return model;
        }

When I do query like https://localhost:44383/odata/Student?$select=XYZ it is returning empty value:

{
    "@odata.context": "https://localhost:44383/OData/$metadata#Student/ODataCoreTest.EntityBase(XYZ)",
    "value": [
        {}
    ]
}

How to return error when property does not exists on open types dictionary?

odata c#
1 Answers

So, the issue was created in Github: https://github.com/OData/WebApi/issues/2392 However, they are saying that it is expected. I found a workarround for solving this problem:

I added custom resource serializer and validate existing properties in CreateResource method:

public class CustomODataResourceSerializer : ODataResourceSerializer
{
    public CustomODataResourceSerializer(ODataSerializerProvider serializerProvider) : base(serializerProvider)
    {

    }

    public override ODataResource CreateResource(SelectExpandNode selectExpandNode, ResourceContext resourceContext)
    {
        var resource = base.CreateResource(selectExpandNode, resourceContext);

        if (selectExpandNode.SelectedDynamicProperties?.Any() == true)
        {
            foreach (var dynamicProperty in selectExpandNode.SelectedDynamicProperties)
            {
                if (!resource.Properties.Any(s => s.Name == dynamicProperty) && resourceContext.DynamicComplexProperties?.Any(s => s.Key == dynamicProperty) != true)
                {
                    throw new InvalidOperationException($"Cannot find property '{dynamicProperty}' on '{resource.TypeName}' entity");
                }
            }
        }

        return resource;
    }

    public override void AppendDynamicProperties(ODataResource resource, SelectExpandNode selectExpandNode, ResourceContext resourceContext)
    {
        if (selectExpandNode.SelectedDynamicProperties?.Any() == true)
        {
            base.AppendDynamicProperties(resource, selectExpandNode, resourceContext);
        }
    }
}

It was working fine, but in filter queries I had this kind of problems. So, I added validation method:

 void ValidateOpenType(QueryNode expression)
        {
            if (expression is BinaryOperatorNode operatorNode)
            {
                ValidateOpenType(operatorNode.Left);
                ValidateOpenType(operatorNode.Right);
            }
            else if (expression is ConvertNode convertNode)
            {
                ValidateOpenType(convertNode.Source);
            }
            else if (expression is SingleValueFunctionCallNode functionCallNode)
            {
                foreach (var queryNode in functionCallNode.Parameters)
                {
                    ValidateOpenType(queryNode);
                }
            }
            else if (expression is SingleValuePropertyAccessNode singleValueProperty && !string.IsNullOrEmpty(singleValueProperty.Property?.Name))
            {
                if (singleValueProperty.Source is SingleNavigationNode navigationNode)
                {
                    ThrowExceptionWhenPropertyDoesNotExists(singleValueProperty.Property.Name, navigationNode.NavigationSource.Name);
                }
                else
                {
                    ThrowExceptionWhenPropertyDoesNotExists(singleValueProperty.Property.Name, typeof(TEntity).Name);
                }
            }
            else if (expression is SingleValueOpenPropertyAccessNode valueOpenPropertyAccessNode)
            {
                if (valueOpenPropertyAccessNode.Source is SingleNavigationNode navigationNode)
                {
                    ThrowExceptionWhenPropertyDoesNotExists(valueOpenPropertyAccessNode.Name, navigationNode.NavigationSource.Name);
                }
                else
                {
                    ThrowExceptionWhenPropertyDoesNotExists(valueOpenPropertyAccessNode.Name, typeof(TEntity).Name);
                }
            }
        }

        void ThrowExceptionWhenPropertyDoesNotExists(string propertyName, string entityName)
        {
            if (ModelClasses.Any(t => t.Name == entityName && t.GetProperty(propertyName) == null))
            {
                throw new InvalidOperationException($"Could not find a property named '{propertyName}' on '{entityName}' entity");
            }
        }

Getting classes:

List<Type> modelClasses;
        public List<Type> ModelClasses
        {
            get
            {
                if (modelClasses == null)
                {
                    modelClasses = GetClasses("ODataCoreTest");
                }
                return modelClasses;
            }
        }

        static List<Type> GetClasses(string nameSpace)
        {
            Assembly asm = Assembly.GetExecutingAssembly();

            List<Type> namespacelist = new List<Type>();
            List<Type> classlist = new List<Type>();

            foreach (Type type in asm.GetTypes())
            {
                if (type.Namespace == nameSpace)
                    namespacelist.Add(type);
            }

            foreach (Type classType in namespacelist)
                classlist.Add(classType);

            return classlist;
        }

Usage:

[HttpGet]
        public IActionResult Get(ODataQueryOptions<TEntity> queryOptions, CancellationToken cancellationToken)
        {
            if (queryOptions.Filter?.FilterClause != null)
            {
                ValidateOpenType(queryOptions.Filter.FilterClause.Expression);
            }
            var res = new List<Student>() { CreateNewStudent() };

            return Ok(res);
        }
user_88250200
Related