MongoDbSCIMExpressionLinqExtensions.cs

// Copyright (c) SimpleIdServer. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
using MongoDB.Driver.Linq;
using SimpleIdServer.Scim.Domains;
using SimpleIdServer.Scim.Parser;
using SimpleIdServer.Scim.Parser.Expressions;
using SimpleIdServer.Scim.Parser.Operators;
using SimpleIdServer.Scim.Persistence.MongoDB.Models;
using System;
using System.Linq;
using System.Linq.Expressions;

namespace SimpleIdServer.Scim.Persistence.MongoDB.Extensions
{
    public static class MongoDbSCIMExpressionLinqExtensions
    {
        #region Filter Metadata

        public static IMongoQueryable<SCIMRepresentationModel> EvaluateMongoDbRepresentations(this SCIMExpression expression, IMongoQueryable<SCIMRepresentationModel> representations)
        {
            var treeNodeParameter = Expression.Parameter(typeof(SCIMRepresentationModel), "tn");
            var anyWhereExpression = expression.EvaluateRepresentations(treeNodeParameter);
            if (anyWhereExpression == null) return null;
            var enumarableType = typeof(Queryable);
            var whereMethod = enumarableType.GetMethods()
                 .Where(m => m.Name == "Where" && m.IsGenericMethodDefinition)
                 .Where(m => m.GetParameters().Count() == 2).First().MakeGenericMethod(typeof(SCIMRepresentationModel));
            var equalLambda = Expression.Lambda<Func<SCIMRepresentationModel, bool>>(anyWhereExpression, treeNodeParameter);
            var whereExpr = Expression.Call(whereMethod, Expression.Constant(representations), equalLambda);
            var finalSelectArg = Expression.Parameter(typeof(IQueryable<SCIMRepresentationModel>), "f");
            var finalSelectRequestBody = Expression.Lambda(whereExpr, new ParameterExpression[] { finalSelectArg });
            var result = (IMongoQueryable<SCIMRepresentationModel>)finalSelectRequestBody.Compile().DynamicInvoke(representations);
            return result;
        }

        public static Expression EvaluateRepresentations(this SCIMExpression expression, ParameterExpression parameterExpression)
        {
            var logicalExpression = expression as SCIMLogicalExpression;
            var comparisonExpression = expression as SCIMComparisonExpression;
            if (logicalExpression != null) return logicalExpression.EvaluateRepresentations(parameterExpression);
            if (comparisonExpression != null) return comparisonExpression.EvaluateRepresentations(parameterExpression);
            return null;
        }

        public static Expression EvaluateRepresentations(this SCIMLogicalExpression expression, ParameterExpression parameterExpression)
        {
            var leftExpression = expression.LeftExpression.EvaluateRepresentations(parameterExpression);
            var rightExpression = expression.RightExpression.EvaluateRepresentations(parameterExpression);
            if (leftExpression == null && rightExpression == null) return null;
            if (leftExpression != null && rightExpression == null) return leftExpression;
            if (leftExpression == null && rightExpression != null) return rightExpression;
            switch (expression.LogicalOperator)
            {
                case SCIMLogicalOperators.AND:
                    return Expression.AndAlso(leftExpression, rightExpression);
                default:
                    return Expression.OrElse(leftExpression, rightExpression);
            }
        }

        public static Expression EvaluateRepresentations(this SCIMComparisonExpression expression, ParameterExpression parameterExpression)
        {
            var lastChild = expression.LeftExpression.GetLastChild();
            var fullPath = lastChild.GetFullPath();
            if (!ParserConstants.MappingStandardAttributePathToProperty.ContainsKey(fullPath)) return null;
            var propertyName = ParserConstants.MappingStandardAttributePathToProperty[fullPath];
            var type = ParserConstants.MappingStandardAttributeTypeToType[fullPath];
            MemberExpression propertyValueString = null,
                propertyValueInteger = null,
                propertyValueDatetime = null;
            var schemaAttr = lastChild.SchemaAttribute;
            switch (type)
            {
                case SCIMSchemaAttributeTypes.STRING:
                    propertyValueString = Expression.Property(parameterExpression, propertyName);
                    schemaAttr = new SCIMSchemaAttribute(Guid.NewGuid().ToString())
                    {
                        Type = SCIMSchemaAttributeTypes.STRING
                    };
                    break;
                case SCIMSchemaAttributeTypes.INTEGER:
                    propertyValueInteger = Expression.Property(parameterExpression, propertyName);
                    schemaAttr = new SCIMSchemaAttribute(Guid.NewGuid().ToString())
                    {
                        Type = SCIMSchemaAttributeTypes.INTEGER
                    };
                    break;
                case SCIMSchemaAttributeTypes.DATETIME:
                    propertyValueDatetime = Expression.Property(parameterExpression, propertyName);
                    schemaAttr = new SCIMSchemaAttribute(Guid.NewGuid().ToString())
                    {
                        Type = SCIMSchemaAttributeTypes.DATETIME
                    };
                    break;
            }

            return SCIMExpressionLinqExtensions.BuildComparisonExpression(
                expression,
                schemaAttr,
                propertyValueString,
                propertyValueInteger,
                propertyValueDatetime,
                representationParameter: Expression.Parameter(typeof(SCIMRepresentationAttribute), "tn"),
                useRegex: true);
        }


        #endregion

        #region Filter attributes

        public static IMongoQueryable<SCIMRepresentationAttribute> EvaluateMongoDbAttributesDirect(this SCIMExpression expression, IMongoQueryable<SCIMRepresentationAttribute> attributes)
        {
            var treeNodeParameter = Expression.Parameter(typeof(SCIMRepresentationAttribute), "attr");
            var anyWhereExpression = expression.EvaluateAttributesDirect(treeNodeParameter);
            if (anyWhereExpression == null) return null;
            var enumarableType = typeof(Queryable);
            var whereMethod = enumarableType.GetMethods()
                 .Where(m => m.Name == "Where" && m.IsGenericMethodDefinition)
                 .Where(m => m.GetParameters().Count() == 2).First().MakeGenericMethod(typeof(SCIMRepresentationAttribute));
            var equalLambda = Expression.Lambda<Func<SCIMRepresentationAttribute, bool>>(anyWhereExpression, treeNodeParameter);
            var whereExpr = Expression.Call(whereMethod, Expression.Constant(attributes), equalLambda);
            var finalSelectArg = Expression.Parameter(typeof(IQueryable<SCIMRepresentationAttribute>), "f");
            var finalSelectRequestBody = Expression.Lambda(whereExpr, new ParameterExpression[] { finalSelectArg });
            var result = (IMongoQueryable<SCIMRepresentationAttribute>)finalSelectRequestBody.Compile().DynamicInvoke(attributes);
            return result;
        }

        public static IMongoQueryable<EnrichedAttribute> EvaluateMongoDbAttributes(this SCIMExpression expression, IMongoQueryable<EnrichedAttribute> attributes)
        {
            var treeNodeParameter = Expression.Parameter(typeof(EnrichedAttribute), "tn");
            var anyWhereExpression = expression.EvaluateAttributes(treeNodeParameter);
            if (anyWhereExpression == null) return null;
            var enumarableType = typeof(Queryable);
            var whereMethod = enumarableType.GetMethods()
                 .Where(m => m.Name == "Where" && m.IsGenericMethodDefinition)
                 .Where(m => m.GetParameters().Count() == 2).First().MakeGenericMethod(typeof(EnrichedAttribute));
            var equalLambda = Expression.Lambda<Func<EnrichedAttribute, bool>>(anyWhereExpression, treeNodeParameter);
            var whereExpr = Expression.Call(whereMethod, Expression.Constant(attributes), equalLambda);
            var finalSelectArg = Expression.Parameter(typeof(IQueryable<EnrichedAttribute>), "f");
            var finalSelectRequestBody = Expression.Lambda(whereExpr, new ParameterExpression[] { finalSelectArg });
            var result = (IMongoQueryable<EnrichedAttribute>)finalSelectRequestBody.Compile().DynamicInvoke(attributes);
            return result;
        }

        public static Expression EvaluateAttributesDirect(this SCIMExpression expression, ParameterExpression parameterExpression)
        {
            var attrExpression = expression as SCIMAttributeExpression;
            var logicalExpression = expression as SCIMLogicalExpression;
            var comparisonExpression = expression as SCIMComparisonExpression;
            if (attrExpression != null) return attrExpression.EvaluateAttributesDirect(parameterExpression);
            if (logicalExpression != null) return logicalExpression.EvaluateAttributesDirect(parameterExpression);
            if (comparisonExpression != null) return comparisonExpression.EvaluateAttributesDirect(parameterExpression);
            return null;
        }

        public static Expression EvaluateAttributes(this SCIMExpression expression, ParameterExpression parameterExpression)
        {
            var attrExpression = expression as SCIMAttributeExpression;
            var logicalExpression = expression as SCIMLogicalExpression;
            var comparisonExpression = expression as SCIMComparisonExpression;
            if (attrExpression != null) return attrExpression.EvaluateAttributes(parameterExpression);
            if (logicalExpression != null) return logicalExpression.EvaluateAttributes(parameterExpression);
            if (comparisonExpression != null) return comparisonExpression.EvaluateAttributes(parameterExpression);
            return null;
        }

        public static Expression EvaluateAttributesDirect(this SCIMAttributeExpression expression, ParameterExpression parameterExpression)
        {
            var schemaAttributeIdProperty = Expression.Property(parameterExpression, "SchemaAttributeId");
            var equal = Expression.Equal(schemaAttributeIdProperty, Expression.Constant(expression.SchemaAttribute.Id));
            var complex = expression as SCIMComplexAttributeExpression;
            if (complex != null)
            {
                return complex.GroupingFilter.EvaluateAttributesDirect(parameterExpression);
            }

            return equal;
        }

        public static Expression EvaluateAttributes(this SCIMAttributeExpression expression, ParameterExpression parameterExpression)
        {
            var schemaAttributeIdProperty = Expression.Property(Expression.Property(parameterExpression, "Attribute"), "SchemaAttributeId");
            var equal = Expression.Equal(schemaAttributeIdProperty, Expression.Constant(expression.SchemaAttribute.Id));
            var complex = expression as SCIMComplexAttributeExpression;
            if (complex != null)
            {
                return complex.GroupingFilter.EvaluateAttributes(parameterExpression);
            }

            return equal;
        }

        public static Expression EvaluateAttributesDirect(this SCIMLogicalExpression expression, ParameterExpression parameterExpression)
        {
            var leftExpression = expression.LeftExpression.EvaluateAttributesDirect(parameterExpression);
            var rightExpression = expression.RightExpression.EvaluateAttributesDirect(parameterExpression);
            if (leftExpression == null && rightExpression == null) return null;
            if (leftExpression != null && rightExpression == null) return leftExpression;
            if (leftExpression == null && rightExpression != null) return rightExpression;
            switch (expression.LogicalOperator)
            {
                case SCIMLogicalOperators.AND:
                    return Expression.AndAlso(leftExpression, rightExpression);
                default:
                    return Expression.OrElse(leftExpression, rightExpression);
            }
        }

        public static Expression EvaluateAttributes(this SCIMLogicalExpression expression, ParameterExpression parameterExpression)
        {
            var leftExpression = expression.LeftExpression.EvaluateAttributes(parameterExpression);
            var rightExpression = expression.RightExpression.EvaluateAttributes(parameterExpression);
            if (leftExpression == null && rightExpression == null) return null;
            if (leftExpression != null && rightExpression == null) return leftExpression;
            if (leftExpression == null && rightExpression != null) return rightExpression;
            switch (expression.LogicalOperator)
            {
                case SCIMLogicalOperators.AND:
                    return Expression.AndAlso(leftExpression, rightExpression);
                default:
                    return Expression.OrElse(leftExpression, rightExpression);
            }
        }

        public static Expression EvaluateAttributesDirect(this SCIMComparisonExpression expression, ParameterExpression parameterExpression)
        {
            var lastChild = expression.LeftExpression.GetLastChild();
            if (ParserConstants.MappingStandardAttributePathToProperty.ContainsKey(lastChild.GetFullPath())) return null;
            var schemaAttributeId = Expression.Property(parameterExpression, "SchemaAttributeId");
            var propertyValueString = Expression.Property(parameterExpression, "ValueString");
            var propertyValueInteger = Expression.Property(parameterExpression, "ValueInteger");
            var propertyValueDatetime = Expression.Property(parameterExpression, "ValueDateTime");
            var propertyValueBoolean = Expression.Property(parameterExpression, "ValueBoolean");
            var propertyValueDecimal = Expression.Property(parameterExpression, "ValueDecimal");
            var propertyValueBinary = Expression.Property(parameterExpression, "ValueBinary");
            var comparison = SCIMExpressionLinqExtensions.BuildComparisonExpression(expression, lastChild.SchemaAttribute,
                propertyValueString,
                propertyValueInteger,
                propertyValueDatetime,
                propertyValueBoolean,
                propertyValueDecimal,
                propertyValueBinary,
                parameterExpression,
                true);
            return Expression.And(Expression.Equal(schemaAttributeId, Expression.Constant(lastChild.SchemaAttribute.Id)), comparison);
        }

        public static Expression EvaluateAttributes(this SCIMComparisonExpression expression, ParameterExpression parameterExpression)
        {
            var lastChild = expression.LeftExpression.GetLastChild();
            if (ParserConstants.MappingStandardAttributePathToProperty.ContainsKey(lastChild.GetFullPath())) return null;
            var attr = Expression.Property(parameterExpression, "Attribute");
            var schemaAttributeId = Expression.Property(attr, "SchemaAttributeId");
            var propertyValueString = Expression.Property(attr, "ValueString");
            var propertyValueInteger = Expression.Property(attr, "ValueInteger");
            var propertyValueDatetime = Expression.Property(attr, "ValueDateTime");
            var propertyValueBoolean = Expression.Property(attr, "ValueBoolean");
            var propertyValueDecimal = Expression.Property(attr, "ValueDecimal");
            var propertyValueBinary = Expression.Property(attr, "ValueBinary");
            var comparison = SCIMExpressionLinqExtensions.BuildComparisonExpression(expression, lastChild.SchemaAttribute,
                propertyValueString,
                propertyValueInteger,
                propertyValueDatetime,
                propertyValueBoolean,
                propertyValueDecimal,
                propertyValueBinary,
                parameterExpression,
                true);
            return Expression.And(Expression.Equal(schemaAttributeId, Expression.Constant(lastChild.SchemaAttribute.Id)), comparison);
        }

        #endregion
    }
}