luticate2-api/Luticate2.Auth/Utils/Business/Utils/LuExpressionUtils.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Luticate2.Auth.Utils.Dbo;
using Luticate2.Auth.Utils.Dbo.Result;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Scripting;

namespace Luticate2.Auth.Utils.Business.Utils
{
    public static class LuExpressionUtils
    {
        public class LuExpressionParserOptions
        {
            public ScriptOptions ScriptOptions { get; set; }
        }

        public static Expression GetFromConvert(Expression exp)
        {
            if (exp is LambdaExpression lambdaExpression)
            {
                return GetFromConvert(lambdaExpression);
            }

            if ((exp.NodeType == ExpressionType.Convert ||
                 exp.NodeType == ExpressionType.ConvertChecked)
                && exp is UnaryExpression)
            {
                return ((UnaryExpression) exp).Operand;
            }
            else
            {
                return exp;
            }
        }

        public static LambdaExpression GetFromConvert(LambdaExpression exp)
        {
            var body = GetFromConvert(exp.Body);
            var lambda = Expression.Lambda(body, exp.Parameters);

            return lambda;
        }

        public static Expression<Func<TType1, TType3>> AddConvert<TType1, TType2, TType3>(Expression<Func<TType1, TType2>> exp)
        {
            var converted = Expression.Convert(exp.Body, typeof(TType3));
            var expLambda = Expression.Lambda<Func<TType1, TType3>>(converted, exp.Parameters);
            return expLambda;
        }

        public static LuResult<TProperty> SetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
            TDbo dstObj, TProperty value)
        {
            var memberInfo = GetSingleMemberFromExpression(property);
            if (memberInfo != null)
            {
                return SetValueFromMember(memberInfo, dstObj, value);
            }

            return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
        }

        public static LuResult<TProperty> SetValueFromMember<TDbo, TProperty>(MemberInfo memberInfo,
            TDbo dstObj, TProperty value)
        {
            switch (memberInfo.MemberType)
            {
                case MemberTypes.Field:
                    ((FieldInfo) memberInfo).SetValue(dstObj, value);
                    return LuResult<TProperty>.Ok(value);
                case MemberTypes.Property:
                    ((PropertyInfo) memberInfo).SetValue(dstObj, value);
                    return LuResult<TProperty>.Ok(value);
                default:
                    return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
                        $"Bad MemberType: {memberInfo.MemberType}");
            }
        }

        public static LuResult<TProperty> GetValueFromExpression<TDbo, TProperty>(Expression<Func<TDbo, TProperty>> property,
            TDbo dboTo)
        {
            var memberInfo = GetSingleMemberFromExpression(property);
            if (memberInfo != null)
            {
                TProperty value;
                switch (memberInfo.MemberType)
                {
                    case MemberTypes.Field:
                        value = (TProperty) ((FieldInfo) memberInfo).GetValue(dboTo);
                        return LuResult<TProperty>.Ok(value);
                    case MemberTypes.Property:
                        value = (TProperty) ((PropertyInfo) memberInfo).GetValue(dboTo);
                        return LuResult<TProperty>.Ok(value);
                    default:
                        return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(),
                            $"Bad MemberType: {memberInfo.MemberType}");
                }
            }

            return LuResult<TProperty>.Error(LuStatus.InternalError.ToInt(), "Bad member expression");
        }

        public static MemberInfo GetSingleMemberFromExpression(LambdaExpression property)
        {
            if (GetFromConvert(property.Body) is MemberExpression memberExpression &&
                (memberExpression.Expression == property.Parameters.First() ||
                 (memberExpression.Expression == null && memberExpression.Member.DeclaringType == property.Parameters.First().Type)))
            {
                return memberExpression.Member;
            }
            return null;
        }

        public static MethodInfo GetSingleMethodFromExpression(LambdaExpression method)
        {
            // TODO check if something like methodCallExpression.Method.DeclaringType == method.Parameters.First().Type is usefull/required (static/extension methods)
            if (GetFromConvert(method.Body) is MethodCallExpression methodCallExpression &&
                (methodCallExpression.Object == method.Parameters.First() || methodCallExpression.Object == null))
            {
                return methodCallExpression.Method;
            }
            return null;
        }

        private static bool GetMembersFromExpression<TTypeTo, TProperty>(
            Expression<Func<TTypeTo, TProperty>> property, IList<MemberInfo> memberInfos)
        {
            MemberExpression memberExpression;
            if ((property.Body.NodeType == ExpressionType.Convert ||
                 property.Body.NodeType == ExpressionType.ConvertChecked)
                && property.Body is UnaryExpression)
            {
                memberExpression = ((UnaryExpression) property.Body).Operand as MemberExpression;
            }
            else
            {
                memberExpression = property.Body as MemberExpression;
            }

            if (memberExpression != null)
            {
                if (memberExpression.Expression == property.Parameters.First())
                {
                    memberInfos.Add(memberExpression.Member);
                    return true;
                }
                else if (memberExpression.Expression is MemberExpression)
                {
                    var exp = Expression.Lambda<Func<TTypeTo, object>>(memberExpression.Expression, property.Parameters);
                    var res = GetMembersFromExpression(exp, memberInfos);
                    if (res)
                    {
                        memberInfos.Add(memberExpression.Member);
                    }

                    return res;
                }
            }
            return false;
        }

        public static IList<MemberInfo> GetMembersFromExpression<TTypeTo, TProperty>(Expression<Func<TTypeTo, TProperty>> property)
        {
            var list = new List<MemberInfo>();
            if (GetMembersFromExpression(property, list))
            {
                return list;
            }

            return null;
        }

        public static LuResult<Expression<Func<TArg, TResult>>> Parse<TArg, TResult>(string data, LuExpressionParserOptions options)
        {
            try
            {
//                var options = ScriptOptions.Default.AddReferences(typeof(LuFilterParser).Assembly, typeof(Expression<>).Assembly);
                var expr = CSharpScript.EvaluateAsync<Expression<Func<TArg, TResult>>>(data, options.ScriptOptions).Result;
                return LuResult<Expression<Func<TArg, TResult>>>.Ok(expr);
            }
            catch (Exception e)
            {
                return LuResult<Expression<Func<TArg, TResult>>>.Error(LuStatus.InputError.ToInt(), e, "Failed to parse expression");
            }
        }
    }
}