WingCloudServer/src/VitalMixtureService/DBService/Service/UserFeatureDBService.cs

using System.Threading.Tasks;
using System.Collections.Generic;
using MongoDB.Driver;
using VitalService.Entities;
using WingServerCommon.Mapper;
using VitalService.Request;
using WingInterfaceLibrary.Interface.DBVitalInterface;
using WingInterfaceLibrary.Request.DBVitalRequest;
using WingInterfaceLibrary.DTO.Vital;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Enum.VitalEnum;

namespace VitalService.Service
{
    /// <summary>
    /// 用户权限数据服务
    /// </summary>
    public partial class VitalDatabaseService : IVitalUserFeatureDBService
    {
        /// <summary>
        /// 创建用户权限数据
        /// </summary>
        /// <param name="request">创建请求</param>
        /// <returns></returns>
        public async Task<string> CreateUserFeatureAsync(CreateUserFeatureDBRequest request)
        {
            var entity = request.MappingTo<UserFeatureEntity>();
            return await _userFeatureDBRepository.InsertOneAsync(entity);
        }

        /// <summary>
        /// 根据编码获取用户权限数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<UserFeatureDTO> GetUserFeatureDetailAsync(GetUserFeatureDBRequest request)
        {
            var filter = Builders<UserFeatureEntity>.Filter.Eq(x => x.Code, request.Code);
            var result = await _userFeatureDBRepository.FindOneAsync(filter);
            return result.MappingTo<UserFeatureDTO>();
        }

        /// <summary>
        /// 根据关键字段获取用户权限数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<UserFeatureDTO> GetUserFeatureDetailByKeyAsync(GetUserFeatureByKeyDBRequest request)
        {
            var filter = Builders<UserFeatureEntity>.Filter.Eq(request.Key, request.Value);
            var result = await _userFeatureDBRepository.FindOneAsync(filter);
            return result.MappingTo<UserFeatureDTO>();
        }

        /// <summary>
        /// 获取用户权限数据分页
        /// </summary>
        /// <param name="request">分页请求</param>
        /// <returns></returns>
        public async Task<PageCollection<UserFeatureDTO>> GetUserFeaturePageAsync(DBPageRequest request)
        {
            var filter = await _userFeatureDBRepository.GetPageFilter(request);
            var pageFilter = new DBPageRequest<UserFeatureEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<UserFeatureEntity>.Sort.Descending(x => x.CreateTime).Ascending(x => x.Code)
            };
            var result = await _userFeatureDBRepository.GetPages(pageFilter);
            return result.MappingTo<PageCollection<UserFeatureDTO>>();
        }


        /// <summary>
        /// 删除用户权限数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<bool> RemoveUserFeatureAsync(RemoveUserFeatureDBRequest request)
        {
            return await _userFeatureDBRepository.DeleteOneAsync("Code", request.Code);
        }

        /// <summary>
        /// 删除多个用户权限数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<long> RemoveUserFeatureListAsync(RemoveUserFeatureListDBRequest request)
        {
            var filter = new List<(string key, string val)>();
            foreach (var code in request.Codes)
            {
                filter.Add(("Code", code));
            }
            return await _userFeatureDBRepository.DeleteAllAsync(filter);
        }

        /// <summary>
        /// 获取用户权限数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<UserFeatureDTO>> GetUserFeatureListAsync(GetUserFeatureListDBRequest request)
        {
            var filter = Builders<UserFeatureEntity>.Filter.In(f => f.Code, request.Codes);
            var result = await _userFeatureDBRepository.FindAllAsync(filter);
            return result.MappingTo<List<UserFeatureDTO>>();
        }

        /// <summary>
        /// 根据关键字段获取用户权限数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<UserFeatureDTO>> GetUserFeatureListByKeyAsync(GetUserFeatureListByKeyDBRequest request)
        {
            var filter = Builders<UserFeatureEntity>.Filter.Eq(request.Key, request.Value);
            var result = await _userFeatureDBRepository.FindAllAsync(filter);
            return result.MappingTo<List<UserFeatureDTO>>();
        }

        /// <summary>
        /// 更新用户权限数据
        /// </summary>
        /// <param name="request">更新请求</param>
        /// <returns></returns>
        public async Task<bool> UpdateUserFeatureAsync(UpdateUserFeatureDBRequest request)
        {
            var filter = Builders<UserFeatureEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<UserFeatureEntity>.Update
                .Set(f => f.FeatureName, request.FeatureName)
                .Set(f => f.FeatureShowName, request.FeatureShowName)
                .Set(f => f.Description, request.Description)
                .Set(f => f.FatherCode, request.FatherCode)
                .Set(f => f.Sort, request.Sort)
                .Set(f => f.AppType, request.AppType)
                .Set(f => f.FeatureType, request.FeatureType);

            return await _userFeatureDBRepository.UpdateOneAsync(filter, update) > 0;
        }

        private async Task<UserFeatureDTO> ConvertToDTO(UserFeatureEntity entity)
        {
            if (entity == null) return null;
            var dto = entity.MappingTo<UserFeatureDTO>();
            return dto;
        }

        private async Task<List<UserFeatureDTO>> ConvertToDTOList(List<UserFeatureEntity> entitys)
        {
            if (entitys == null || entitys.Count == 0) return new List<UserFeatureDTO>();
            var resultList = new List<UserFeatureDTO>();
            foreach (var entity in entitys)
            {
                if (entity == null)
                {
                    continue;
                }
                var record = entity.MappingTo<UserFeatureDTO>();
                resultList.Add(record);
            }
            return resultList;
        }

        private async Task<PageCollection<UserFeatureDTO>> ConvertToDTOPage(PageCollection<UserFeatureEntity> entitys)
        {
            var resultPage = new PageCollection<UserFeatureDTO>
            {
                DataCount = entitys.DataCount,
                CurrentPage = entitys.CurrentPage,
                PageSize = entitys.PageSize,
                PageData = await ConvertToDTOList(entitys.PageData)
            };
            return resultPage;
        }
    }
}