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

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

    /// <summary>
    /// 服务包数据库服务
    /// </summary>
    public partial class VitalDatabaseService : IVitalServicePackDBService
    {

        /// <summary>
        /// 创建服务包
        /// </summary>
        /// <param name="request">create request</param>
        /// <returns></returns>
        public async Task<string> CreateServicePackAsync(CreateServicePackDBRequest request)
        {
            var entity = request.MappingTo<ServicePackEntity>();
            return await _servicePackDBRepository.InsertOneAsync(entity);
        }

        /// <summary>
        ///获取服务包详情
        /// </summary>
        /// <param name="request">get request</param>
        /// <returns></returns>
        public async Task<ServicePackDTO> GetServicePackDetailAsync(GetServicePackDBRequest request)
        {
            var filter = Builders<ServicePackEntity>.Filter.Eq(x => x.Code, request.Code);
            var result = await _servicePackDBRepository.FindOneAsync(filter);
            return result.MappingTo<ServicePackDTO>();
        }


        /// <summary>
        /// 获取服务包分页查询
        /// </summary>
        /// <param name="request">Get page request</param>
        /// <returns></returns>
        public async Task<PageCollection<ServicePackDTO>> GetServicePackPageAsync(GetServicePackPageDBRequest request)
        {
            var filter = await _servicePackDBRepository.GetPageFilter(request);
            if (request.ServicePackType != null)
            {
                filter = filter & Builders<ServicePackEntity>.Filter.Where(x => x.ServicePackType == request.ServicePackType);
            }
            if (!string.IsNullOrWhiteSpace(request.OrganizationCode))
            {
                filter = filter & Builders<ServicePackEntity>.Filter.Where(x => x.OrganizationCode == null || x.OrganizationCode == "" || x.OrganizationCode == request.OrganizationCode);
            }
            var pageFilter = new DBPageRequest<ServicePackEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<ServicePackEntity>.Sort.Descending(x => x.CreateTime)
            };
            var pagedResult = await _servicePackDBRepository.GetPages(pageFilter);
            var result = pagedResult.MappingTo<PageCollection<ServicePackDTO>>();
            if (result != null && result.PageData != null && result.PageData.Any() && result.PageData.Any(x => !string.IsNullOrWhiteSpace(x.OrganizationCode)))
            {
                var orgCodes = result.PageData.Select(x => x.OrganizationCode).Distinct();
                var filterOrgs = Builders<OrganizationEntity>.Filter.In(f => f.Code, orgCodes);
                var orgList = await _organizationDBRepository.FindAllAsync(filterOrgs);
                foreach (var item in result.PageData)
                {
                    item.OrganizationName = orgList.FirstOrDefault(x => x.Code == item.OrganizationCode)?.OrganizationName ?? string.Empty;
                }
            }
            return result;
        }


        /// <summary>
        ///删除服务包
        /// </summary>
        /// <param name="request">remove request</param>
        /// <returns></returns>
        public async Task<bool> RemovetServicePackAsync(RemovetServicePackDBRequest request)
        {
            return await _servicePackDBRepository.DeleteOneAsync("Code", request.Code);
        }

        /// <summary>
        ///获取所有服务包列表
        /// </summary>
        /// <param name="request">get list request</param>
        /// <returns></returns>
        public async Task<List<ServicePackDTO>> GetServicePackListAsync(GetServicePackListDBRequest request)
        {
            var filter = Builders<ServicePackEntity>.Filter.In(f => f.Code, request.Codes);
            var result = await _servicePackDBRepository.FindAllAsync(filter);
            return result.MappingTo<List<ServicePackDTO>>();
        }

        /// <summary>
        /// 更新服务包
        /// </summary>
        /// <param name="request">update request</param>
        /// <returns></returns>
        public async Task<bool> UpdateServicePackAsync(UpdateServicePackDBRequest request)
        {
            var filter = Builders<ServicePackEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<ServicePackEntity>.Update
           .Set(f => f.Name, request.Name)
           .Set(f => f.ServicePackType, request.ServicePackType)
           .Set(f => f.Content, request.Content)
           .Set(f => f.OrganizationCode, request.OrganizationCode);
            return await _servicePackDBRepository.UpdateOneAsync(filter, update) > 0;
        }

        /// <summary>
        ///设服务包上设置服务项目
        /// </summary>
        /// <param name="request">update request</param>
        /// <returns></returns>
        public async Task<bool> UpdateServicePackForItemsAsync(UpdateServicePackForItemsDBRequest request)
        {
            var filter = Builders<ServicePackEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<ServicePackEntity>.Update
           .Set(f => f.Items, request.Items)
           .Set(f => f.UpdateTime, DateTime.UtcNow);
            return await _servicePackDBRepository.UpdateOneAsync(filter, update) > 0;
        }
        /// <summary>
        /// 创建项目包
        /// </summary>
        /// <param name="request">create request</param>
        /// <returns></returns>
        public async Task<string> CreateServiceItemAsync(CreateServiceItemDBRequest request)
        {
            var entity = request.MappingTo<ServiceItemEntity>();
            return await _serviceItemDBRepository.InsertOneAsync(entity);
        }

        /// <summary>
        ///获取项目详情
        /// </summary>
        /// <param name="request">get request</param>
        /// <returns></returns>
        public async Task<ServiceItemDTO> GetServiceItemDetailAsync(GetServiceItemDBRequest request)
        {
            var filter = Builders<ServiceItemEntity>.Filter.Eq(x => x.Code, request.Code);
            var result = await _serviceItemDBRepository.FindOneAsync(filter);
            return result.MappingTo<ServiceItemDTO>();
        }


        /// <summary>
        /// 获取服务项目分页查询
        /// </summary>
        /// <param name="request">Get page request</param>
        /// <returns></returns>
        public async Task<PageCollection<ServiceItemDTO>> GetServiceItemPageAsync(GetServiceItemPageDBRequest request)
        {
            var filter = await _serviceItemDBRepository.GetPageFilter(request);
            if (!string.IsNullOrWhiteSpace(request.OrganizationCode))
            {
                filter = filter & Builders<ServiceItemEntity>.Filter.Where(x => x.OrganizationCode == null || x.OrganizationCode == "" || x.OrganizationCode == request.OrganizationCode);
            }
            else
            {
                var userFilter = Builders<UserEntity>.Filter.Eq(f => f.Code, request.OperationDoctor);
                var userEntity = await _userDBRepository.FindOneAsync(userFilter);
                if (userEntity != null && userEntity.RoleCode == "Role_SystemAdministrator")
                {
                    if (request.FilterDefaultItems)
                    {
                        filter = filter & Builders<ServiceItemEntity>.Filter.Where(x => x.OrganizationCode == null || x.OrganizationCode == "");
                    }
                }
                else
                {                    
                    filter = filter & Builders<ServiceItemEntity>.Filter.Where(x => x.OrganizationCode == null || x.OrganizationCode == "");
                }
            }
            var pageFilter = new DBPageRequest<ServiceItemEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<ServiceItemEntity>.Sort.Descending(x => x.CreateTime)
            };
            var pagedResult = await _serviceItemDBRepository.GetPages(pageFilter);
            var result = pagedResult.MappingTo<PageCollection<ServiceItemDTO>>();
            if (result != null && result.PageData != null && result.PageData.Any() && result.PageData.Any(x => !string.IsNullOrWhiteSpace(x.OrganizationCode)))
            {
                var orgCodes = result.PageData.Select(x => x.OrganizationCode).Distinct();
                var filterOrgs = Builders<OrganizationEntity>.Filter.In(f => f.Code, orgCodes);
                var orgList = await _organizationDBRepository.FindAllAsync(filterOrgs);
                foreach (var item in result.PageData)
                {
                    item.OrganizationName = orgList.FirstOrDefault(x => x.Code == item.OrganizationCode)?.OrganizationName ?? string.Empty;
                }
            }
            return result;
        }


        /// <summary>
        ///删除服务项
        /// </summary>
        /// <param name="request">remove request</param>
        /// <returns></returns>
        public async Task<bool> RemovetServiceItemAsync(RemovetServiceItemDBRequest request)
        {
            return await _serviceItemDBRepository.DeleteOneAsync("Code", request.Code);
        }

        /// <summary>
        ///获取所有服务项集合
        /// </summary>
        /// <param name="request">get list request</param>
        /// <returns></returns>
        public async Task<List<ServiceItemDTO>> GetServiceItemListAsync(GetServiceItemListDBRequest request)
        {
            var filter = Builders<ServiceItemEntity>.Filter.In(f => f.Code, request.Codes);
            var result = await _serviceItemDBRepository.FindAllAsync(filter);
            return result.MappingTo<List<ServiceItemDTO>>();
        }

        /// <summary>
        /// 更新服务项目
        /// </summary>
        /// <param name="request">update request</param>
        /// <returns></returns>
        public async Task<bool> UpdateServiceItemAsync(UpdateServiceItemDBRequest request)
        {
            var filter = Builders<ServiceItemEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<ServiceItemEntity>.Update
           .Set(f => f.Name, request.Name)
           .Set(f => f.Content, request.Content)
           .Set(f => f.ServiceItemType, request.ServiceItemType)
           .Set(f => f.ServiceNumber, request.ServiceNumber)
           .Set(f => f.Department, request.Department)
           .Set(f => f.GuidancePrice, request.GuidancePrice)
           .Set(f => f.AdjustedPrice, request.AdjustedPrice)
           .Set(f => f.TotalPrice, request.TotalPrice)
           .Set(f => f.PriceExplanation, request.PriceExplanation)
           .Set(f => f.OrganizationCode, request.OrganizationCode)
           .Set(f => f.UpdateTime, DateTime.UtcNow);
            return await _serviceItemDBRepository.UpdateOneAsync(filter, update) > 0;
        }

        /// <summary>
        /// 服务包设定人群分标签
        /// </summary>
        /// <param name="request">update request</param>
        /// <returns></returns>
        public async Task<bool> UpdateServicePackForLabelsAsync(UpdateServicePackForLabelsDBRequest request)
        {
            var filter = Builders<ServicePackEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<ServicePackEntity>.Update
           .Set(f => f.Labels, request.Labels)
           .Set(f => f.UpdateTime, DateTime.UtcNow);
            return await _servicePackDBRepository.UpdateOneAsync(filter, update) > 0;
        }
    }
}