VberTech/SourceCode/VberTech/VberTech.Application/VberTechAsyncCrudAppService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Domain.Entities;
using Abp.Domain.Repositories;
using Abp.Extensions;
using Abp.Linq;
using Abp.ObjectMapping;
using VberTech.Lambda;
using IwbZero;
using IwbZero.AppServiceBase;
using IwbZero.Authorization.Permissions;
using IwbZero.Authorization.Users;
using IwbZero.IdentityFramework;
using Microsoft.AspNet.Identity;
using Abp.Authorization;
using VberTech.Authorization.Permissions;

namespace VberTech
{
    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput, TDeleteInput>
      : IwbCrudAppServiceBase<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput>
          where TEntity : class, IEntity<TPrimaryKey>
          where TEntityDto : IEntityDto<TPrimaryKey>
          where TUpdateInput : IEntityDto<TPrimaryKey>
          where TGetInput : IEntityDto<TPrimaryKey>
          where TDeleteInput : IEntityDto<TPrimaryKey>
          where TGetAllInput : IPagedRequest
    {
        public IAsyncQueryableExecuter AsyncQueryableExecuter { get; set; }

        protected string KeyFiledName { get; set; }
        protected string DataPermissionName { get; set; }
        protected virtual bool KeyIsAuto { get; set; } = true;
        protected virtual string ExistMessage { get; set; } = "编号已存在，请检查后再操作！";
        protected virtual string NotExistMessage { get; set; } = "编号不存在，请检查后再操作！";
        public new VberTechPermissionChecker PermissionChecker { protected get; set; }

        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null,string dataPermissionName = null)
            : base(repository)
        {
            AsyncQueryableExecuter = NullAsyncQueryableExecuter.Instance;
            LocalizationSourceName = IwbZeroConsts.IwbZeroLocalizationSourceName;
            ObjectMapper = NullObjectMapper.Instance;
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
        [DisableAuditing]
        public virtual async Task<TEntityDto> Get(TGetInput input)
        {
            CheckGetPermission();
            if (!KeyFiledName.IsNullOrEmpty() && input.Id == null)
            {
                return await GetDtoByNo(input.GetFiledValue<string>(KeyFiledName));
            }
            var entity = await GetEntityById(input.Id);
            return MapToEntityDto(entity);
        }
        [DisableAuditing]
        public virtual async Task<PagedResultDto<TEntityDto>> GetAll(TGetAllInput input)
        {
            CheckGetAllPermission();
            var query = CreateFilteredQuery(input);
            query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = new PagedResultDto<TEntityDto>(
                totalCount,
                entities.Select(MapToEntityDto).ToList()
            );
            return dtoList;
        }

        public virtual async Task<TEntityDto> Create(TCreateInput input)
        {
            CheckCreatePermission();
            return await CreateEntity(input);
        }
        public virtual async Task<TEntityDto> Update(TUpdateInput input)
        {
            CheckCreatePermission();
            return await UpdateEntity(input);
        }
        public virtual Task Delete(TDeleteInput input)
        {
            CheckDeletePermission();

            return Repository.DeleteAsync(input.Id);
        }

        protected virtual IQueryable<T> ApplyFilterEx<T>(IQueryable<T> query, TGetAllInput input)
        {
            if (!input.KeyWords.IsNullOrEmpty())
            {
                object keyWords = input.KeyWords;
                LambdaObject obj = new LambdaObject()
                {
                    FieldType = (LambdaFieldType)input.FieldType,
                    FieldName = input.KeyField,
                    FieldValue = keyWords,
                    ExpType = (LambdaExpType)input.ExpType
                };
                var exp = obj.GetExp<T>();
                query = query.Where(exp);
            }
            if (input.SearchList != null && input.SearchList.Count > 0)
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in input.SearchList)
                {
                    if (o.KeyWords.IsNullOrEmpty())
                        continue;
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<T>();
                query = query.Where(exp);
            }

            return query;
        }
        protected virtual IQueryable<TEntity> ApplyFilter(IQueryable<TEntity> query, TGetAllInput input)
        {
            if (!input.KeyWords.IsNullOrEmpty())
            {
                object keyWords = input.KeyWords;
                LambdaObject obj = new LambdaObject()
                {
                    FieldType = (LambdaFieldType)input.FieldType,
                    FieldName = input.KeyField,
                    FieldValue = keyWords,
                    ExpType = (LambdaExpType)input.ExpType
                };
                var exp = obj.GetExp<TEntity>();
                query = query.Where(exp);
            }
            if (input.SearchList != null && input.SearchList.Count > 0)
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in input.SearchList)
                {
                    if (o.KeyWords.IsNullOrEmpty())
                        continue;
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<TEntity>();
                query = query.Where(exp);
            }

            return query;
        }

        protected virtual IQueryable<T> ApplySortingEx<T>(IQueryable<T> query, TGetAllInput input) 
        {
            //Try to sort query if available
            // ReSharper disable once SuspiciousTypeConversion.Global
            if (input is ISortedResultRequest sortInput)
            {
                if (!sortInput.Sorting.IsNullOrWhiteSpace())
                {
                    return query.OrderBy(sortInput.Sorting);
                }
            }

            //IQueryable.Task requires sorting, so we should sort if Take will be used.
            // ReSharper disable once IsExpressionAlwaysTrue
            if (input is ILimitedResultRequest)
            {
                if (!input.Sorting.IsNullOrWhiteSpace())
                {
                    return query.OrderBy(input.Sorting);
                }
                //return query.OrderByDescending(e => e.Id);
            }

            //No sorting
            return query;
        }
        /// <summary>
        /// Should apply sorting if needed.
        /// </summary>
        /// <param name="query">The query.</param>
        /// <param name="input">The input.</param>
        protected new virtual IQueryable<TEntity> ApplySorting(IQueryable<TEntity> query, TGetAllInput input)
        {
            //Try to sort query if available
            // ReSharper disable once SuspiciousTypeConversion.Global
            if (input is ISortedResultRequest sortInput)
            {
                if (!sortInput.Sorting.IsNullOrWhiteSpace())
                {
                    return query.OrderBy(sortInput.Sorting);
                }
            }

            //IQueryable.Task requires sorting, so we should sort if Take will be used.
            // ReSharper disable once IsExpressionAlwaysTrue
            if (input is ILimitedResultRequest)
            {
                if (!input.Sorting.IsNullOrWhiteSpace())
                {
                    return query.OrderBy(input.Sorting);
                }
                return query.OrderByDescending(e => e.Id);
            }

            //No sorting
            return query;
        }

        /// <summary>
        /// Should apply paging if needed.
        /// </summary>
        /// <param name="query">The query.</param>
        /// <param name="input">The input.</param>
        protected new virtual IQueryable<TEntity> ApplyPaging(IQueryable<TEntity> query, TGetAllInput input)
        {
            //Try to use paging if available
            if (input is IPagedResultRequest pagedInput)
            {
                return query.Skip(pagedInput.SkipCount).Take(pagedInput.MaxResultCount);
            }

            //No paging
            return query;
        }

        public virtual Task<TEntity> GetEntityById(TPrimaryKey id)
        {
            return Repository.GetAsync(id);
        }
        public virtual Task<TEntity> GetEntityByNo(string no)
        {
            if (KeyFiledName.IsNullOrEmpty())
            {
                CheckErrors(IwbIdentityResult.Failed("编码/编号字段不明确，请检查后再操作！"));
            }
            LambdaObject obj = new LambdaObject()
            {
                FieldType = LambdaFieldType.S,
                FieldName = KeyFiledName,
                FieldValue = no,
                ExpType = LambdaExpType.Equal
            };
            var exp = obj.GetExp<TEntity>();
            return Repository.FirstOrDefaultAsync(exp);
        }
        public virtual async Task<TEntityDto> GetDtoById(TPrimaryKey id)
        {
            var entity = await GetEntityById(id);
            return MapToEntityDto(entity);
        }
        public virtual async Task<TEntityDto> GetDtoByNo(string no)
        {
            var entity = await GetEntityByNo(no);
            return MapToEntityDto(entity);
        }

        protected async Task<TEntityDto> CreateEntity(TCreateInput input)
        {
            if (!KeyFiledName.IsNullOrEmpty())
            {
                if (KeyIsAuto)
                {
                    input.SetFiledValue(KeyFiledName, Guid.NewGuid().ToString("N"));
                }
                else
                {
                    LambdaObject obj = new LambdaObject()
                    {
                        FieldType = LambdaFieldType.S,
                        FieldName = KeyFiledName,
                        FieldValue = input.GetFiledValue<string>(KeyFiledName),
                        ExpType = LambdaExpType.Equal
                    };
                    var exp = obj.GetExp<TEntity>();
                    if (await Repository.FirstOrDefaultAsync(exp) != null)
                    {
                        CheckErrors(IwbIdentityResult.Failed(ExistMessage));
                    }
                }

            }
            var entity = MapToEntity(input);
            await Repository.InsertAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();

            return MapToEntityDto(entity);
        }
        protected async Task<TEntityDto> UpdateEntity(TUpdateInput input)
        {

            if (!KeyIsAuto && !KeyFiledName.IsNullOrEmpty())
            {
                LambdaObject obj = new LambdaObject()
                {
                    FieldType = LambdaFieldType.S,
                    FieldName = KeyFiledName,
                    FieldValue = input.GetFiledValue<string>(KeyFiledName),
                    ExpType = LambdaExpType.Equal
                };
                var exp = obj.GetExp<TEntity>();
                if (await Repository.FirstOrDefaultAsync(exp) == null)
                {
                    CheckErrors(IwbIdentityResult.Failed(NotExistMessage));
                }
            }
            var entity = await GetEntityById(input.Id);

            MapToEntity(input, entity);
            await CurrentUnitOfWork.SaveChangesAsync();

            return MapToEntityDto(entity);
        }
        protected virtual void CheckErrors(params string[] error)
        {
            var identityResult = IwbIdentityResult.Failed(error);
            identityResult.CheckErrors(LocalizationManager);
        }
        protected virtual void CheckErrors(IdentityResult identityResult)
        {
            identityResult.CheckErrors(LocalizationManager);
        }

        protected virtual int CheckGuid(int? guid)
        {
            if (guid == null || guid == 0)
            {
                CheckErrors(IwbIdentityResult.Failed("获取Guid编号失败！"));
                return 0;
            }
            return (int)guid;
        }
        protected virtual void CheckDataPermission(string permissionName, string key, int operType)
        {
            if (AbpSession.UserName != UserBase.AdminUserName && AbpSession.UserName != UserBase.SystemUserName && !string.IsNullOrEmpty(permissionName))
                PermissionChecker.Authorize(permissionName, key, operType);
        }

        protected virtual void CheckDataQueryPermission(string permissionName, string key)
        {
            CheckDataPermission(permissionName, key, (int)OperType.Query);
        }
        protected virtual void CheckDataUpdatePermission(string permissionName, string key)
        {
            CheckDataPermission(permissionName, key, (int)OperType.Update);
        }

        protected virtual void CheckDataDeletePermission(string permissionName, string key)
        {
            CheckDataPermission(permissionName, key, (int)OperType.Delete);
        }
    }

    #region AppService

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto>
        : VberTechAsyncCrudAppService<TEntity, TEntityDto, int>
        where TEntity : class, IEntity<int>
        where TEntityDto : IEntityDto<int>
    {
        protected VberTechAsyncCrudAppService(IRepository<TEntity, int> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
    }

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey>
        : VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, IPagedRequest>
        where TEntity : class, IEntity<TPrimaryKey>
        where TEntityDto : IEntityDto<TPrimaryKey>
    {
        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
    }

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput>
        : VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TEntityDto, TEntityDto>
        where TEntity : class, IEntity<TPrimaryKey>
        where TEntityDto : IEntityDto<TPrimaryKey>
        where TGetAllInput : IPagedRequest
    {
        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
    }

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput>
        : VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TCreateInput>
        where TGetAllInput : IPagedRequest
        where TEntity : class, IEntity<TPrimaryKey>
        where TEntityDto : IEntityDto<TPrimaryKey>
        where TCreateInput : IEntityDto<TPrimaryKey>
    {
        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
    }

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput>
        : VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, EntityDto<TPrimaryKey>>
        where TEntity : class, IEntity<TPrimaryKey>
        where TEntityDto : IEntityDto<TPrimaryKey>
        where TUpdateInput : IEntityDto<TPrimaryKey>
        where TGetAllInput : IPagedRequest
    {
        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            KeyFiledName = keyFiledName;
            DataPermissionName = dataPermissionName;
        }
    }

    public abstract class VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput>
    : VberTechAsyncCrudAppService<TEntity, TEntityDto, TPrimaryKey, TGetAllInput, TCreateInput, TUpdateInput, TGetInput, EntityDto<TPrimaryKey>>
        where TEntity : class, IEntity<TPrimaryKey>
        where TEntityDto : IEntityDto<TPrimaryKey>
        where TUpdateInput : IEntityDto<TPrimaryKey>
        where TGetInput : IEntityDto<TPrimaryKey>
        where TGetAllInput : IPagedRequest
    {

        protected VberTechAsyncCrudAppService(IRepository<TEntity, TPrimaryKey> repository, string keyFiledName = null, string dataPermissionName = null)
            : base(repository)
        {
            DataPermissionName = dataPermissionName;
            KeyFiledName = keyFiledName;
        }
    }

    #endregion
}