Zxd.Core/code/Zxd.Crm.Domain/FieldDomain.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Zxd.Entity.Zxd;

namespace Zxd.Crm.Domain
{
    internal class FieldDomain : IFieldDomain
    {
        private readonly IBaseRepository<ZxdDbContext> _zxdRepository;
        private readonly IMapper _mapper;

        public FieldDomain(IBaseRepository<ZxdDbContext> zxdRepository,
            IMapper mapper)
        {
            _zxdRepository = zxdRepository;
            _mapper = mapper;
        }

        public async Task<List<TableFieldSettingDto>> GetTableFieldSettings(string? module, decimal? eid)
        {
            var data = new List<TableFieldSettingDto>();
            if (!await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .AnyAsync(x => x.Eid == eid && x.TableField.Module == module))
            {
                data = await _zxdRepository.GetRepository<TableField>().Query()
                .OrderBy(x => x.Fixed == "right")
                .ThenBy(x => x.Order)
                .Where(x => x.Module == module)
                .Select(x => new TableFieldSettingDto
                {
                    Type = x.Type,
                    Field = x.Field,
                    Fixed = x.Fixed,
                    Templet = x.Templet,
                    Hide = x.Hide,
                    Width = x.Width,
                    Sort = x.Sort,
                    Title = x.Title,
                    Checkbox = x.Checkbox
                }).ToListAsync();

                return data;
            }

            data = await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .Where(x => x.Eid == eid && x.TableField.Module == module)
                .OrderBy(x => x.Fixed == "right")
                .ThenBy(x => x.Order)
                .Select(x => new TableFieldSettingDto
                {
                    Type = x.TableField.Type,
                    Field = x.TableField.Field,
                    Fixed = x.Fixed ?? x.TableField.Fixed,
                    Templet = x.TableField.Templet,
                    Hide = x.TableField.Hide != x.Hide || x.Hide,
                    Width = x.TableField.Width,
                    Sort = x.TableField.Sort,
                    Title = x.TableField.Title,
                    Checkbox = x.TableField.Checkbox
                }).ToListAsync();
            return data;
        }

        public async Task CreateTableField(CreateTableFieldDto createTable)
        {
            var tableFields = _mapper.Map<CreateFieldDto, TableField>(createTable.Fields);
            var i = 0;
            tableFields.ForEach(x =>
            {
                x.Module = createTable.Module;
                x.CreateTime = DateTime.Now;
                x.Order = i;
                i++;
            });
            await _zxdRepository.GetRepository<TableField>().BatchInsertAsync(tableFields);
        } 

        public async Task<List<UserTableFieldSettingDto>> GetUserTableFieldSettings(string? module, decimal? eid)
        {
            var data = new List<UserTableFieldSettingDto>();
            if (!await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .AnyAsync(x => x.Eid == eid && x.TableField.Module == module))
            {
                data = await _zxdRepository.GetRepository<TableField>().Query()
                .OrderBy(x => x.Order)
                .Where(x => x.Module == module && x.Hide == false)
                .Select(x => new UserTableFieldSettingDto
                {
                    Id = x.Id,
                    Field = x.Field,
                    Checkbox = true,
                    Fixed = x.Fixed,
                    Order = x.Order,
                    Title = x.Title,
                    IsSetting = false
                }).ToListAsync();

                return data;
            }
            data = await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .Where(x => x.Eid == eid && x.TableField.Module == module && x.TableField.Hide == false)
                .OrderBy(x => x.Order)
                .Select(x => new UserTableFieldSettingDto
                {
                    Id = x.Id,
                    Field = x.TableField.Field,
                    Checkbox = !x.Hide,
                    Fixed = x.Fixed,
                    Order = x.Order,
                    Title = x.TableField.Title,
                    IsSetting = true
                }).ToListAsync();

            return data;
        }

        public async Task CreateOrUpdateUserSetting(CreateOrUpdateUserSettingDto dto)
        {
            if (string.IsNullOrEmpty(dto.Module)) throw new ApiException("请输入模块");
            if (dto.Eid == null) throw new ApiException("请输入员工id");
            if (dto.Data == null || !dto.Data.Any()) throw new ApiException("请输入字段内容");
            var ids = dto.Data.Select(x => x.Id).ToList();
            var userSettings = await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .Where(x => x.Eid == dto.Eid)
                .Where(x => x.TableField.Module == dto.Module)
                .ToListAsync();
            var addUserSettings = new List<FieldSetting>();
            foreach (var item in dto.Data)
            {
                var userSetting = userSettings?.FirstOrDefault(x => x.Id == item.Id);
                if (userSetting == null)
                {
                    var setting = new FieldSetting
                    {
                        Eid = dto.Eid.Value,
                        FieldId = item.Id,
                        Fixed = item.Fixed,
                        Hide = !item.Checkbox,
                        Order = item.Order
                    };
                    addUserSettings.Add(setting);
                }
                else
                {
                    userSetting.Order = item.Order;
                    userSetting.Fixed = item.Fixed;
                    userSetting.Hide = !item.Checkbox;
                }
            }

            var transaction = await _zxdRepository.BeginTransactionAsync();
            try
            {
                if (addUserSettings.Any())
                {
                    await _zxdRepository.GetRepository<FieldSetting>().BatchInsertAsync(addUserSettings);
                }
                if (userSettings.Any())
                {
                    await _zxdRepository.GetRepository<FieldSetting>().BatchUpdateAsync(userSettings, x => new
                    {
                        x.Order,
                        x.Fixed,
                        x.Hide
                    });
                }
                await transaction.CommitAsync();
            }
            catch
            {
                await transaction.RollbackAsync();
                await transaction.DisposeAsync();
                throw;
            }
        }


        public async Task ResetUserTableFieldSettings(string? module, decimal? eid)
        {
            var fieldSettings = await _zxdRepository.GetRepository<FieldSetting>().Query()
                .Include(x => x.TableField)
                .Where(x => x.Eid == eid && x.TableField.Module == module).ToListAsync();

            if (fieldSettings.Any())
            {
                await _zxdRepository.GetRepository<FieldSetting>().BatchDeleteAsync(fieldSettings);
            }
        }

    }
}