luticate2-api/Luticate2.Auth/Business/PartialObjectCopier/LuPartialObjectCopier.cs

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using Luticate2.Auth.Business.Fields;
using Luticate2.Auth.Dbo;
using Luticate2.Auth.Dbo.Fields;
using Luticate2.Auth.Dbo.PartialObjectCopier;
using Luticate2.Auth.Dbo.Result;
using Luticate2.Auth.Interfaces;
using Microsoft.Extensions.DependencyInjection;

namespace Luticate2.Auth.Business.PartialObjectCopier
{
    public abstract class LuPartialObjectCopier<TTypeFrom, TTypeTo> : ILuPartialObjectCopier<TTypeFrom, TTypeTo>
    {
        protected IServiceProvider ServiceProvider { get; }

        protected LuPartialObjectCopier(IServiceProvider serviceProvider)
        {
            ServiceProvider = serviceProvider;
        }

        protected LuResult<TPropertyTo> MayCopySubProperty<TPropertyFrom, TPropertyTo>(LuFieldDbo path,
            LuPartialFieldsDbo fields, TTypeFrom modelFrom, TTypeTo dboTo,
            Expression<Func<TTypeFrom, TPropertyFrom>> propFrom, Expression<Func<TTypeTo, TPropertyTo>> propTo,
            LuPartialObjectCopierOptions options) where TPropertyTo : new()
        {
            var member = LuExpressionUtils.GetSingleMemberFromExpression(propTo);
            var subpath = LuFieldDbo.Make(path).Add(member.Name);
            if (fields.Fields.IsIncluded(subpath))
            {
                var propToValue = LuExpressionUtils.GetValueFromExpression(propTo, dboTo);
                if (!propToValue)
                {
                    return propToValue.To<TPropertyTo>();
                }
                if (propToValue.Data == null)
                {
                    propToValue.Data = new TPropertyTo();
                    var res = LuExpressionUtils.SetValueFromExpression(propTo, dboTo, propToValue.Data);
                    if (!res)
                    {
                        return res.To<TPropertyTo>();
                    }
                }
                var propFromValue = LuExpressionUtils.GetValueFromExpression(propFrom, modelFrom);
                if (!propFromValue)
                {
                    return propFromValue.To<TPropertyTo>();
                }

                var service = ServiceProvider.GetService<ILuPartialObjectCopier<TPropertyFrom, TPropertyTo>>();
                var result = service.Copy(subpath, fields, propFromValue.Data, propToValue.Data, options);
                return result;
            }
            return LuResult<TPropertyTo>.Ok(default(TPropertyTo));
        }

        protected LuResult<IList<TPropertyTo>> MayCopySubPropertyList<TPropertyFrom, TPropertyTo>(
            LuFieldDbo path, LuPartialFieldsDbo fields, IEnumerable<TPropertyFrom> modelFrom,
            TTypeTo dboTo, Expression<Func<TTypeTo, IEnumerable<TPropertyTo>>> propTo,
            LuPartialObjectCopierOptions options) where TPropertyTo : new()
        {
            var member = LuExpressionUtils.GetSingleMemberFromExpression(propTo);
            var subpath = LuFieldDbo.Make(path).Add(member.Name);
            if (fields.Fields.IsIncluded(subpath))
            {
                var list = new List<TPropertyTo>();
                var res = LuExpressionUtils.SetValueFromExpression(propTo, dboTo, list);
                if (!res)
                {
                    return res.To<IList<TPropertyTo>>();
                }

                foreach (var subDboFrom in modelFrom)
                {
                    var subDboTo = new TPropertyTo();

                    var service = ServiceProvider.GetService<ILuPartialObjectCopier<TPropertyFrom, TPropertyTo>>();
                    var result = service.Copy(subpath, fields, subDboFrom, subDboTo, options);

                    list.Add(subDboTo);
                }
            }
            return LuResult<IList<TPropertyTo>>.Ok(null);
        }

        protected LuResult<TProperty> MayCopy<TProperty, TTypeTo2>(LuFieldDbo path, LuPartialFieldsDbo fields,
            TTypeTo2 dboTo, Expression<Func<TTypeTo2, TProperty>> property, Func<TProperty> getValue)
        {
            var memberInfo = LuExpressionUtils.GetSingleMemberFromExpression(property);
            if (memberInfo != null)
            {
                if (fields.Fields.IsIncluded(LuFieldDbo.Make(path).Add(memberInfo.Name)))
                {
                    var value = getValue();
                    var result = LuExpressionUtils.SetValueFromExpression(property, dboTo, value);
                    return result;
                }

                return LuResult<TProperty>.Ok(default(TProperty));
            }

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

        public abstract LuResult<TTypeTo> Copy(LuFieldDbo path, LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options);

        public LuResult<TTypeTo> Copy(LuPartialFieldsDbo fields, TTypeFrom dboFrom, TTypeTo dboTo, LuPartialObjectCopierOptions options)
        {
            return Copy(new LuFieldDbo(), fields, dboFrom, dboTo, options);
        }
    }
}