irc-netcore-api/IRaCIS.Core.Application/Service/Allocation/TaskAllocationRuleService.cs

//--------------------------------------------------------------------
//     此代码由T4模板自动生成  byzhouhang 20210918
//	   生成时间 2022-06-07 13:14:38 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Domain.Share;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 分配规则
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Trial")]
    public class TaskAllocationRuleService : BaseService, ITaskAllocationRuleService
    {

        private readonly IRepository<TaskAllocationRule> _taskAllocationRuleRepository;
        private readonly IRepository<User> _userRepository;

        private readonly IRepository<Trial> _trialRepository;



        public TaskAllocationRuleService(IRepository<TaskAllocationRule> taskAllocationRuleRepository, IRepository<User> userRepository, IRepository<Trial> trialRepository)
        {
            _taskAllocationRuleRepository = taskAllocationRuleRepository;
            _userRepository = userRepository;
            _trialRepository = trialRepository;
        }




        /// <summary>
        /// 获取计划列表  医生带阅片类型
        /// </summary>
        /// <param name="trialId"></param>
        /// <returns></returns>
        public async Task<List<TaskAllocationRuleDTO> > GetDoctorPlanAllocationRuleList(Guid trialId)
        {

            var list = await _taskAllocationRuleRepository.Where(t => t.TrialId == trialId).ProjectTo<TaskAllocationRuleDTO>(_mapper.ConfigurationProvider).ToListAsync();

            return list;
        }





        public async Task<IResponseOutput> AddOrUpdateTaskAllocationRule(TaskAllocationRuleAddOrEdit addOrEditTaskAllocationRule)
        {
            var verifyExp1 = new EntityVerifyExp<TaskAllocationRule>()
            {
                VerifyExp = t => t.EnrollId == addOrEditTaskAllocationRule.EnrollId && t.TrialId == addOrEditTaskAllocationRule.TrialId,
                VerifyMsg = "已有该医生配置，不允许继续增加"
            };

            var entity = await _taskAllocationRuleRepository.InsertOrUpdateAsync(addOrEditTaskAllocationRule, true, verifyExp1);

            return ResponseOutput.Ok(entity.Id.ToString());

        }


        [HttpDelete("{taskAllocationRuleId:guid}")]
        public async Task<IResponseOutput> DeleteTaskAllocationRule(Guid taskAllocationRuleId)
        {
            if (await _taskAllocationRuleRepository.Where(t => t.Id == taskAllocationRuleId).AnyAsync(t => t.Enroll.DoctorTrialVisitTaskList.Any()))
            {
                return ResponseOutput.NotOk("已分配任务给该医生，不允许删除");
            }

            var success = await _taskAllocationRuleRepository.DeleteFromQueryAsync(t => t.Id == taskAllocationRuleId, true);


            return ResponseOutput.Ok();
        }


        /// <summary>
        /// 获取访视任务   应用Subject后  医生比率情况
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<DoctorVisitTaskStatView>> GetSubjectApplyDoctorTaskStatList(ApplySubjectCommand assignConfirmCommand)
        {
            var taskAllocationRuleQueryable = _taskAllocationRuleRepository.Where(t => t.TrialId == assignConfirmCommand.TrialId && t.IsJudgeDoctor == assignConfirmCommand.IsJudgeDoctor)
            .ProjectTo<DoctorVisitTaskStatView>(_mapper.ConfigurationProvider, new { subjectIdList = assignConfirmCommand.SubjectIdList, isJudgeDoctor = assignConfirmCommand.IsJudgeDoctor });

            return await taskAllocationRuleQueryable.ToListAsync();
        }



        [HttpPost]
        public async Task<(List<DoctorVisitTaskStatView>, object)> GetTaskAllocationRuleList(TaskAllocationRuleQuery queryTaskAllocationRule)
        {
            var taskAllocationRuleQueryable = _taskAllocationRuleRepository.Where(t => t.TrialId == queryTaskAllocationRule.TrialId /*&& t.IsJudgeDoctor == queryTaskAllocationRule.IsJudgeDoctor*/)
             .ProjectTo<DoctorVisitTaskStatView>(_mapper.ConfigurationProvider);


            var trialTaskConfig = _trialRepository.Where(t => t.Id == queryTaskAllocationRule.TrialId).ProjectTo<TrialTaskConfigView>(_mapper.ConfigurationProvider, new { isJudgeDoctor = queryTaskAllocationRule.IsJudgeDoctor }).FirstOrDefault();

            return (await taskAllocationRuleQueryable.ToListAsync(), trialTaskConfig);
        }


        /// <summary>
        /// 获取项目下 医生账户信息下拉
        /// </summary>
        /// <param name="trialId"></param>
        /// <param name="_enrollRepository"></param>
        /// <returns></returns>
        [HttpGet("{trialId:guid}")]
        public async Task<List<TrialDoctorUserSelectView>> GetDoctorUserSelectList(Guid trialId, [FromServices] IRepository<Enroll> _enrollRepository)
        {
            var query = from enroll in _enrollRepository.Where(t => t.TrialId == trialId && t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup)
                        join user in _userRepository.AsQueryable() on enroll.DoctorId equals user.DoctorId
                        select new TrialDoctorUserSelectView()
                        {
                            TrialId = enroll.TrialId,
                            ReadingType = enroll.Trial.ReadingType,
                            EnrollId =enroll.Id,
                            DoctorUserId = user.Id,
                            FullName = user.FullName,
                            UserCode = user.UserCode,
                            UserName = user.UserName,
                            UserTypeEnum = user.UserTypeRole.UserTypeEnum
                        };

            return query.ToList();
        }


        [HttpPost]
        public async Task<List<TrialDoctorUserSelectView>> GetDoctorSelectList(DoctorSelectQuery selectQuery, [FromServices] IRepository<Enroll> _enrollRepository)
        {
            var query = from enroll in _enrollRepository.Where(t => t.TrialId == selectQuery.TrialId  && t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup && t.DoctorUserId !=null)
                        .WhereIf(selectQuery.ReadingCategory !=null,t=>t.EnrollReadingCategoryList.Any(u=>u.ReadingCategory==selectQuery.ReadingCategory))
                        join user in _userRepository.AsQueryable() on enroll.DoctorId equals user.DoctorId
                        select new TrialDoctorUserSelectView()
                        {
                            TrialId = enroll.TrialId,
                            ReadingType = enroll.Trial.ReadingType,
                            EnrollId = enroll.Id,
                            DoctorUserId = user.Id,
                            FullName = user.FullName,
                            UserCode = user.UserCode,
                            UserName = user.UserName,
                            UserTypeEnum = user.UserTypeRole.UserTypeEnum
                        };

            return  await query.ToListAsync();
        }


    }
}