peis/src/Shentun.Peis.Application/ColumnReferences/ColumnReferenceAppService.cs

using AutoMapper.Internal.Mappers;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp;
using Shentun.Peis.Models;
using Microsoft.AspNetCore.Authorization;
using NPOI.SS.UserModel;
using System.Reflection;
using NUglify.JavaScript.Syntax;
using System.Collections;
using System.Linq.Dynamic.Core;
using SqlSugar;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Users;
using Volo.Abp.ObjectMapping;
using Microsoft.Extensions.Configuration;
using System.IO;
using Shentun.Peis.HelperDto;
using Shentun.Peis.PlugIns;
using Volo.Abp.Threading;
using Shentun.Peis.ColumnReferenceCodes;
using Shentun.Peis.ColumnReferenceInterfaces;
using Volo.Abp.Domain.Entities;

namespace Shentun.Peis.ColumnReferences
{
    /// <summary>
    /// 字段对照主表
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class ColumnReferenceAppService : ApplicationService
    {
        private readonly IRepository<ColumnReference, Guid> _repository;
        private readonly IRepository<ColumnReferenceCode, Guid> _columnReferenceCodeRepository;
        private readonly IRepository<ColumnReferenceInterface, Guid> _columnReferenceInterfaceRepository;
        private readonly ColumnReferenceManager _manager;
        private readonly ColumnReferenceCodeManager _columnReferenceCodeManager;
        private readonly ColumnReferenceInterfaceManager _columnReferenceInterfaceManager;
        private readonly CacheService _cacheService;
        private readonly IRepository<IdentityUser, Guid> _userRepository;

        public ColumnReferenceAppService(
            IRepository<ColumnReference, Guid> repository,
            ColumnReferenceManager manager,
            CacheService cacheService,
            IRepository<IdentityUser, Guid> userRepository,
            IRepository<ColumnReferenceCode, Guid> columnReferenceCodeRepository,
            IRepository<ColumnReferenceInterface, Guid> columnReferenceInterfaceRepository,
            ColumnReferenceCodeManager columnReferenceCodeManager,
            ColumnReferenceInterfaceManager columnReferenceInterfaceManager
              )
        {
            _repository = repository;
            _manager = manager;
            _cacheService = cacheService;
            _userRepository = userRepository;
            _columnReferenceCodeRepository = columnReferenceCodeRepository;
            _columnReferenceInterfaceRepository = columnReferenceInterfaceRepository;
            _columnReferenceCodeManager = columnReferenceCodeManager;
            _columnReferenceInterfaceManager = columnReferenceInterfaceManager;

        }

        /// <summary>
        /// 根据ID查实体内容
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/Get")]
        public async Task<ColumnReferenceDto> GetAsync(Guid id)
        {
            var entity = await _repository.GetAsync(id);
            var entityDto = ObjectMapper.Map<ColumnReference, ColumnReferenceDto>(entity);
            entityDto.CreatorName = _cacheService.GetUserNameAsync(entityDto.CreatorId).Result;
            entityDto.LastModifierName = _cacheService.GetUserNameAsync(entityDto.LastModifierId).Result;

            return entityDto;
        }



        /// <summary>
        /// 查询列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetList")]
        public async Task<List<ColumnReferenceDto>> GetListAsync()
        {
            var userQueryable = await _userRepository.GetQueryableAsync();

            var entlist = (from a in await _repository.GetQueryableAsync()
                           join b in userQueryable on a.CreatorId equals b.Id into bb
                           from ab in bb.DefaultIfEmpty()
                           join c in userQueryable on a.LastModifierId equals c.Id into cc
                           from ac in cc.DefaultIfEmpty()
                           select new
                           {
                               a,
                               CreatorName = ab != null ? ab.UserName : "",
                               LastModifierName = ac != null ? ac.UserName : ""

                           })
                           .Select(s => new ColumnReferenceDto
                           {
                               CreationTime = s.a.CreationTime,
                               CreatorId = s.a.CreatorId,
                               LastModifierId = s.a.LastModifierId,
                               Id = s.a.Id,
                               DisplayOrder = s.a.DisplayOrder,
                               DisplayName = s.a.DisplayName,
                               ParmValue = s.a.ParmValue,
                               LastModificationTime = s.a.LastModificationTime,
                               CreatorName = s.CreatorName,
                               LastModifierName = s.LastModifierName
                           }).OrderBy(o => o.DisplayOrder).ToList();

            return entlist;
        }

        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/Create")]
        public async Task<ColumnReferenceDto> CreateAsync(CreateColumnReferenceDto input)
        {
            var createEntity = ObjectMapper.Map<CreateColumnReferenceDto, ColumnReference>(input);
            var entity = await _manager.CreateAsync(createEntity);
            entity = await _repository.InsertAsync(entity);
            var dto = ObjectMapper.Map<ColumnReference, ColumnReferenceDto>(entity);
            return dto;
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/Update")]
        public async Task<ColumnReferenceDto> UpdateAsync(UpdateColumnReferenceDto input)
        {
            var entity = await _repository.GetAsync(input.Id);
            var sourceEntity = ObjectMapper.Map<UpdateColumnReferenceDto, ColumnReference>(input);
            await _manager.UpdateAsync(sourceEntity, entity);
            entity = await _repository.UpdateAsync(entity);
            return ObjectMapper.Map<ColumnReference, ColumnReferenceDto>(entity);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/Delete")]
        public async Task DeleteAsync(Guid id)
        {
            var entity = await _repository.GetAsync(id);
            await _manager.CheckAndDeleteAsync(entity);
        }


        /// <summary>
        /// 修改排序  置顶，置底
        /// </summary>
        /// <param name="id">需要修改的ID</param>
        /// <param name="SortType">修改方式：1 置顶   2 置底</param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/UpdateManySort")]
        public async Task UpdateManySortAsync(Guid id, int SortType)
        {
            await _manager.UpdateManySortAsync(id, SortType);
        }

        /// <summary>
        ///  修改排序  拖拽
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/UpdateSortMany")]
        public async Task UpdateSortManyAsync(UpdateSortManyDto input)
        {
            await _manager.UpdateSortManyAsync(input);
        }
        /// <summary>
        /// 更新字段对照
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/UpdateInterfaceCodeValues")]
        public async Task UpdateInterfaceCodeValuesAsync(UpdateColumnReferenceInterfaceDto input)
        {
            var columnReferenceCode = await _columnReferenceCodeRepository.FindAsync(o => o.ColumnReferenceId == input.ColumnReferenceId &&
            o.CodeValue == input.AppCode.CodeValue);
            
            if (columnReferenceCode == null)
            {
                //新建
               columnReferenceCode = await _columnReferenceCodeManager.CreateAsync(new ColumnReferenceCode()
                {
                    ColumnReferenceId = input.ColumnReferenceId,
                    CodeValue = input.AppCode.CodeValue
                });
                columnReferenceCode = await _columnReferenceCodeRepository.InsertAsync(columnReferenceCode);
                
            }
            else
            {
                //更新
                //先删除所有接口编码
                var columnReferenceInterfacs = await _columnReferenceInterfaceRepository.GetListAsync(o => o.ColumnReferenceCodeId == columnReferenceCode.Id);
                await _columnReferenceInterfaceRepository.DeleteManyAsync(columnReferenceInterfacs);
               

            }
            //插入接口表数据
            foreach (var columnReferenceInterfaceDto in input.InterfaceCodes)
            {
                var columnReferenceInterface = await _columnReferenceInterfaceManager.CreateAsync(new ColumnReferenceInterface()
                {
                    ColumnReferenceCodeId = columnReferenceCode.Id,
                    InterfaceCodeValue = columnReferenceInterfaceDto.CodeValue
                });
                await _columnReferenceInterfaceRepository.InsertAsync(columnReferenceInterface);
            }
        }
        /// <summary>
        ///获取字段对照本系统所有列名
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetAppColumns")]
        public async Task<List<ColumnReferenceColumn>> GetAppColumnsAsync(ColumnReferenceIdInputDto input)
        {
            var entity = await _repository.GetAsync(input.Id);
            var parmValue = entity.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
            var className = config.GetSection("Interface").GetSection("ClassName").Value;
            var list = await InvokeColumnsAsync(assemblyName, className, parmValue, "GetAppColumns");
           

            return list;
        }
        public async Task<string> GetAppFilterColumnName(ColumnReferenceIdInputDto input)
        {
            return null;
        }
        /// <summary>
        ///获取字段对照第三方系统所有列名
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetInterfaceColumns")]
        public async Task<List<ColumnReferenceColumn>> GetInterfaceColumnsAsync(ColumnReferenceIdInputDto input)
        {
            var entity = await _repository.GetAsync(input.Id);
            var parmValue = entity.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
            var className = config.GetSection("Interface").GetSection("ClassName").Value;
            var list = await InvokeColumnsAsync(assemblyName, className, parmValue, "GetInterfaceColumns");
            
            return list;
        }
        /// <summary>
        ///获取字段对照本系统所有数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetAppCodeValues")]
        public async Task<List<ColumnReferenceCodeValue>> GetAppCodeValuesAsync(ColumnReferenceIdInputDto input)
        {
            //var columnReferenceCodes = await _columnReferenceCodeRepository.GetListAsync(o => o.CodeValue == input.Id.ToString());

            var entity = await _repository.GetAsync(input.Id);
            var parmValue = entity.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
            var className = config.GetSection("Interface").GetSection("ClassName").Value;
            var list = await InvokeListAsync(assemblyName, className, parmValue, "GetAppCodeValuesAsync");
            
            return list;
        }

        public async Task<List<ColumnReferenceFilterCodeValue>> GetAppFilterCodeValues(ColumnReferenceIdInputDto input)
        {
            return null;
        }
        /// <summary>
        ///获取字段对照第三方系统所有数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetInterfaceCodeValues")]
        public async Task<List<ColumnReferenceCodeValue>> GetInterfaceCodeValuesAsync(ColumnReferenceIdInputDto input)
        {
            var entity = await _repository.GetAsync(input.Id);
            var parmValue = entity.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
            var className = config.GetSection("Interface").GetSection("ClassName").Value;
            var list = await InvokeListAsync(assemblyName, className, parmValue, "GetInterfaceCodeValuesAsync");
           


            return list;
        }
        /// <summary>
        /// 通过本系统编码获取第三方系统编码
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ColumnReference/GetInterfaceCodeValuesByAppCode")]
        public async Task<List<ColumnReferenceInterfaceCodeValueDto>> GetInterfaceCodeValuesByAppCode(ColumnReferenceInterfaceCodeValuesInputDto input)
        {
            var columnReferenceCode = await _columnReferenceCodeRepository.FirstOrDefaultAsync(o => o.CodeValue == input.CodeValue);
            if(columnReferenceCode == null)
            {
                return null;
            }
            var items = await _columnReferenceInterfaceRepository.GetListAsync(o => o.ColumnReferenceCodeId == columnReferenceCode.Id);
           
            var entity = await _repository.GetAsync(input.ColumnReferenceId);
            var parmValue = entity.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
            var className = config.GetSection("Interface").GetSection("ClassName").Value;
            var list = await InvokeListAsync(assemblyName, className, parmValue, "GetInterfaceCodeValuesAsync");
            var result = new List<ColumnReferenceInterfaceCodeValueDto>();
            foreach ( var item in items)
            {
                var columnReferenceInterfaceCodeValueDto = new ColumnReferenceInterfaceCodeValueDto()
                {
                    CodeValue = item.InterfaceCodeValue,
                };
                var interfaceItem = list.Where(o => o.CodeValue == item.InterfaceCodeValue).FirstOrDefault();
                if(interfaceItem != null)
                {
                    columnReferenceInterfaceCodeValueDto.DisplayName = interfaceItem.DisplayName;
                }
                result.Add(columnReferenceInterfaceCodeValueDto);
            }
            return result;
        }
        public async Task<List<ColumnReferenceCodeValue>> GetColumnReferenceInterfaceCodeValues(ColumnReferenceIdInputDto input)
        {
            return null;
        }

        public async Task CreateColumnReferenceValue(CreateColumnReferenceValue input)
        {

        }

        private async Task<object> InvokeAsync(string assemblyName, string className,string classConstructorArg, string methodName, object[] args = null)
        {
            Assembly assembly = Assembly.Load(assemblyName);
            Type type = assembly.GetType(className);
            // 创建类的实例
            object instance = Activator.CreateInstance(type, classConstructorArg);
            // 获取方法信息
            MethodInfo method = type.GetMethod(methodName);
            // 调用方法,如果方法需要参数，可以传入对应的参数数组，例如: new object[] { arg1, arg2 }
            object returnValue;
            var isAsync = (method.ReturnType == typeof(Task) ||
                (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)));
            if (isAsync)
            {
                // 使用反射调用方法

                //object returnValue = method.Invoke(instance, args);
                returnValue = await(Task<object>)method.Invoke(instance, args);
            }
            else
            {
                returnValue = method.Invoke(instance, args);

            }
            return returnValue;
        }
        private async Task<List<ColumnReferenceCodeValue>> InvokeListAsync(string assemblyName, string className, string classConstructorArg, string methodName, object[] args = null)
        {
            Assembly assembly = Assembly.Load(assemblyName);
            Type type = assembly.GetType(className);
            // 创建类的实例
            object instance = Activator.CreateInstance(type, classConstructorArg);
            // 获取方法信息
            MethodInfo method = type.GetMethod(methodName);
            // 调用方法,如果方法需要参数，可以传入对应的参数数组，例如: new object[] { arg1, arg2 }
            List<ColumnReferenceCodeValue> returnValue;
            var isAsync = (method.ReturnType == typeof(Task) ||
                (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)));
            if (isAsync)
            {
                // 使用反射调用方法

                //object returnValue = method.Invoke(instance, args);
                returnValue = await (Task<List<ColumnReferenceCodeValue>>)method.Invoke(instance, args);
            }
            else
            {
                returnValue = (List<ColumnReferenceCodeValue>)method.Invoke(instance, args);

            }
            return returnValue;
        }

        private async Task<List<ColumnReferenceColumn>> InvokeColumnsAsync(string assemblyName, string className, string classConstructorArg, string methodName, object[] args = null)
        {
            Assembly assembly = Assembly.Load(assemblyName);
            Type type = assembly.GetType(className);
            // 创建类的实例
            object instance = Activator.CreateInstance(type, classConstructorArg);
            // 获取方法信息
            MethodInfo method = type.GetMethod(methodName);
            // 调用方法,如果方法需要参数，可以传入对应的参数数组，例如: new object[] { arg1, arg2 }
            List<ColumnReferenceColumn> returnValue;
            var isAsync = (method.ReturnType == typeof(Task) ||
                (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)));
            if (isAsync)
            {
                // 使用反射调用方法

                //object returnValue = method.Invoke(instance, args);
                returnValue = await (Task<List<ColumnReferenceColumn>>)method.Invoke(instance, args);
            }
            else
            {
                returnValue = (List<ColumnReferenceColumn>)method.Invoke(instance, args);

            }
            return returnValue;
        }

    }
}