Merge branch 'feature/新二次分配' into release/v20210707Develop新二次分配合并

# Conflicts:
#	performance/Performance.Api/wwwroot/Performance.DtoModels.xml
#	performance/Performance.DtoModels/PerExcel/ExcelEnum.cs

performance/Performance.Api/Controllers/SecondAllotController.cs

@@ -10,6 +10,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Performance.Infrastructure;
+using Performance.DtoModels.Second;
+using Microsoft.Extensions.Logging;
 
 namespace Performance.Api.Controllers
 {
@@ -19,22 +22,31 @@ namespace Performance.Api.Controllers
     [ApiController]
     public class SecondAllotController : ControllerBase
     {
+        private readonly ILogger<SecondAllotController> _logger;
         private readonly ClaimService claimService;
+        private readonly AllotService _allotService;
         private readonly SecondAllotService secondAllotService;
         private readonly ResultComputeService resultComputeService;
         private readonly SecondAllotDetails secondAllotDetails;
+        private readonly RedistributionService _redistributionService;
 
         public SecondAllotController(
+            ILogger<SecondAllotController> logger,
             ClaimService claimService,
+            AllotService allotService,
             SecondAllotService secondAllotService,
             ResultComputeService resultComputeService,
-            SecondAllotDetails secondAllotDetails
+            SecondAllotDetails secondAllotDetails,
+            RedistributionService redistributionService
             )
         {
+            _logger = logger;
             this.claimService = claimService;
+            _allotService = allotService;
             this.secondAllotService = secondAllotService;
             this.resultComputeService = resultComputeService;
             this.secondAllotDetails = secondAllotDetails;
+            _redistributionService = redistributionService;
         }
 
         #region 二次绩效列表、录入数据展示，保存数据
@@ -286,6 +298,18 @@ public ApiResponse WorkTypeList([FromBody] WorkloadRequest request, int secondId
         }
 
         /// <summary>
+        /// 获取二次分配 提取工作量带出字典
+        /// </summary>
+        /// <returns></returns>
+        [Route("api/second/worktype/map/{secondId}")]
+        [HttpPost]
+        public ApiResponse WorkloadMap(int secondId)
+        {
+            var result = secondAllotService.WorkloadMap(secondId);
+            return new ApiResponse(ResponseType.OK, result);
+        }
+
+        /// <summary>
         /// 保存二次绩效工作量类型
         /// </summary>
         /// <returns></returns>
@@ -327,7 +351,7 @@ public ApiResponse SingleDelete([CustomizeValidator(RuleSet = "Delete"), FromBod
         [Route("/api/second/audit/submit")]
         public ApiResponse SubmitAudit(SubmitAuditRequest request)
         {
-            var second = secondAllotService.GetSecondallot(request.SecondId);
+            var second = secondAllotService.GetSecondAllot(request.SecondId);
             if (second == null)
                 return new ApiResponse(ResponseType.ParameterError, "二次绩效Id无效");
             if (second.Status == 3)
@@ -530,5 +554,304 @@ public ApiResponse AutoCompleteBodyData([FromRoute] int secondId, SecondEmployee
             var result = secondAllotService.AutoComplete(secondId, request);
             return new ApiResponse(ResponseType.OK, result);
         }
+
+        #region 二次分配后台计算
+        /// <summary>
+        /// 二次绩效录入页面
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/load")]
+        [HttpPost]
+        public ApiResponse RedistributionLoad([FromBody] SecondLoadDto request)
+        {
+            try
+            {
+                if (!Enum.IsDefined(typeof(ComputeMode), request.ComputeMode))
+                    throw new PerformanceException("暂不支持当前计算方式！");
+
+                var overrideMode = EmployeeSource.Initial;
+                if (Enum.IsDefined(typeof(EmployeeSource), request.OverrideMode))
+                    overrideMode = (EmployeeSource)request.OverrideMode;
+
+                var result = _redistributionService.Load(request.SecondId, (ComputeMode)request.ComputeMode, overrideMode);
+                return new ApiResponse(ResponseType.OK, result);
+            }
+            catch (PerformanceException ex)
+            {
+                throw ex;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"二次绩效录入页面:{ex}");
+                return new ApiResponse(ResponseType.Fail, "数据加载失败");
+            }
+        }
+
+
+        /// <summary>
+        /// 提交数据正确性检验
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/check")]
+        [HttpPost]
+        public ApiResponse RedistributionCheck([FromBody] SecondComputeDto request)
+        {
+            try
+            {
+                if (request?.Body == null)
+                    throw new PerformanceException("提交空参数，无法查看计算结果！");
+
+                var second = secondAllotService.GetSecondAllot(request.SecondId);
+                if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+                var allot = _allotService.GetAllot(second.AllotId.Value);
+                if (allot == null)
+                    throw new PerformanceException("绩效记录不存在！");
+                // 年资职称绩效占比与工作量绩效占比 校验
+                var loads = _redistributionService.GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+                if ((ComputeMode)request.ComputeMode != ComputeMode.NotCalculate)
+                {
+                    var workloadGroups = _redistributionService.GetTopWorkloadBodyGroups(loads);
+                    var workloadRatio = workloadGroups.Select(w => request.Head.GetValue($"Workload_Ratio_{w.Name}", 0m));
+                    if (workloadRatio.Any(w => w > 1 || w < 0))
+                        throw new PerformanceException("工作量绩效占比存在异常值！");
+
+                    var seniorityTitlesAccountedPerformance = request.Head.GetValue(nameof(ag_headsource.SeniorityTitlesAccountedPerformance), 0m);
+                    if (seniorityTitlesAccountedPerformance > 1 || seniorityTitlesAccountedPerformance < 0)
+                        throw new PerformanceException("年资职称绩效占比值异常！");
+
+                    if (seniorityTitlesAccountedPerformance + workloadRatio.Sum() > 1)
+                        throw new PerformanceException("年资职称绩效占比与工作量绩效占比总和，超过100%！");
+                    else if (seniorityTitlesAccountedPerformance + workloadRatio.Sum() < 1)
+                        throw new PerformanceException("年资职称绩效占比与工作量绩效占比总和，不足100%！");
+                }
+                // 二次分配人员信息 校验
+                var result = _redistributionService.CheckData(second, (ComputeMode)request.ComputeMode, request.Body, loads);
+                return new ApiResponse(ResponseType.OK, result);
+            }
+            catch (PerformanceException ex)
+            {
+                throw ex;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"提交数据正确性检验:{ex}");
+                return new ApiResponse(ResponseType.Fail, "数据验证失败");
+            }
+        }
+
+        /// <summary>
+        /// 二次绩效结果计算
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/compute")]
+        [HttpPost]
+        public ApiResponse RedistributionCompute([FromBody] SecondComputeDto request)
+        {
+            try
+            {
+                if (!Enum.IsDefined(typeof(ComputeMode), request.ComputeMode))
+                    throw new PerformanceException("暂不支持当前计算方式！");
+
+                if (request?.Body == null)
+                    throw new PerformanceException("提交空参数，无法查看计算结果！");
+
+                var second = secondAllotService.GetSecondAllot(request.SecondId);
+                if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+                var allot = _allotService.GetAllot(second.AllotId.Value);
+                if (allot == null)
+                    throw new PerformanceException("绩效记录不存在！");
+                // 年资职称绩效占比与工作量绩效占比 校验
+                var loads = _redistributionService.GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+                var workloadGroups = _redistributionService.GetTopWorkloadBodyGroups(loads);
+
+                if ((ComputeMode)request.ComputeMode != ComputeMode.NotCalculate)
+                {
+                    var workloadRatio = workloadGroups.Select(w => request.Head.GetValue($"Workload_Ratio_{w.Name}", 0m));
+                    if (workloadRatio.Any(w => w > 1 || w < 0))
+                        throw new PerformanceException("工作量绩效占比存在异常值！");
+
+                    var seniorityTitlesAccountedPerformance = request.Head.GetValue(nameof(ag_headsource.SeniorityTitlesAccountedPerformance), 0m);
+                    if (seniorityTitlesAccountedPerformance > 1 || seniorityTitlesAccountedPerformance < 0)
+                        throw new PerformanceException("年资职称绩效占比值异常！");
+
+                    if (seniorityTitlesAccountedPerformance + workloadRatio.Sum() > 1)
+                        throw new PerformanceException("年资职称绩效占比与工作量绩效占比总和，超过100%！");
+                    else if (seniorityTitlesAccountedPerformance + workloadRatio.Sum() < 1)
+                        throw new PerformanceException("年资职称绩效占比与工作量绩效占比总和，不足100%！");
+                }
+
+                // 二次分配人员信息 校验
+                var checkDatas = _redistributionService.CheckData(second, (ComputeMode)request.ComputeMode, request.Body, loads);
+                if (checkDatas != null && checkDatas.Any(w => w.Level == ResponseType.Error.ToString()))
+                    return new ApiResponse(ResponseType.Fail, "数据验证未通过，请修复后查看计算结果！", checkDatas.Where(w => w.Level == ResponseType.Error.ToString()));
+
+                // 清理无效数据 没有Tab标签的数据才是要计算的数据
+                var cleanDatas = request.Body.Where(w => w.Count > 0 && w.GetValue(nameof(ResponseType), "") == ResponseType.OK.ToString()).ToList();
+                if (cleanDatas == null || cleanDatas.Count == 0)
+                    throw new PerformanceException("提交参数都是无效数据，请重新填写数据后查看计算结果！");
+
+                // 计算提交数据结果
+                _redistributionService.ResultCompute((ComputeMode)request.ComputeMode, request.Head, cleanDatas, loads, workloadGroups);
+                // 补充医院其他绩效
+                _redistributionService.SupplementOtherPerfor(second, cleanDatas);
+                // 重算部分数据
+                _redistributionService.RedistributionCompute((ComputeMode)request.ComputeMode, request.Head, cleanDatas);
+
+                var dic = _redistributionService.GetTableHeaderDictionary((ComputeMode)request.ComputeMode, allot, second, loads, workloadGroups);
+                return new ApiResponse(ResponseType.OK, new { Head = request.Head, Body = cleanDatas, Dic = dic });
+            }
+            catch (PerformanceException ex)
+            {
+                throw ex;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"二次绩效结果计算:{ex}");
+                return new ApiResponse(ResponseType.Fail, "计算失败");
+            }
+        }
+        /// <summary>
+        /// 二次绩效保存
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/save")]
+        [HttpPost]
+        public ApiResponse RedistributionSave([FromBody] SecondComputeDto request)
+        {
+            try
+            {
+                var second = secondAllotService.GetSecondAllot(request.SecondId);
+                if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+                var allot = _allotService.GetAllot(second.AllotId.Value);
+                if (allot == null)
+                    throw new PerformanceException("绩效记录不存在！");
+
+                var loads = _redistributionService.GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+                // 二次分配人员信息 校验
+                var checkDatas = _redistributionService.CheckData(second, (ComputeMode)request.ComputeMode, request.Body, loads);
+                if (checkDatas != null && checkDatas.Any(w => w.Level == ResponseType.Error.ToString()))
+                    return new ApiResponse(ResponseType.Fail, "数据验证未通过，请修复后查看计算结果！", checkDatas.Where(w => w.Level == ResponseType.Error.ToString()));
+
+                // 清理无效数据 没有Tab标签的数据才是要计算的数据
+                var cleanDatas = request.Body.Where(w => w.Count > 0 && w.GetValue(nameof(ResponseType), "") == ResponseType.OK.ToString()).ToList();
+                if (cleanDatas == null || cleanDatas.Count == 0)
+                    throw new PerformanceException("提交参数都是无效数据，请重新填写数据后保存！");
+
+                var result = secondAllotService.RedistributionSave(allot, second, request.Head, cleanDatas);
+                return result ? new ApiResponse(ResponseType.OK) : new ApiResponse(ResponseType.Fail, "保存失败");
+            }
+            catch (PerformanceException ex)
+            {
+                throw ex;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"二次绩效保存:{ex}");
+                return new ApiResponse(ResponseType.Fail, "保存失败");
+            }
+        }
+
+        /// <summary>
+        /// 二次绩效提交
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/submit")]
+        [HttpPost]
+        public ApiResponse RedistributionSubmit([FromBody] SecondComputeDto request)
+        {
+            try
+            {
+                var second = secondAllotService.GetSecondAllot(request.SecondId);
+                if (second == null)
+                    return new ApiResponse(ResponseType.ParameterError, "二次绩效Id无效");
+                if (second.Status == 3)
+                    return new ApiResponse(ResponseType.Fail, "该绩效已\"审核通过\",无需再次提交");
+
+                var allot = _allotService.GetAllot(second.AllotId.Value);
+                if (allot == null)
+                    throw new PerformanceException("绩效记录不存在！");
+
+                var loads = _redistributionService.GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+                // 二次分配人员信息 校验
+                var checkDatas = _redistributionService.CheckData(second, (ComputeMode)request.ComputeMode, request.Body, loads);
+                if (checkDatas != null && checkDatas.Any(w => w.Level == ResponseType.Error.ToString()))
+                    return new ApiResponse(ResponseType.Fail, "数据验证未通过，请修复后查看计算结果！", checkDatas.Where(w => w.Level == ResponseType.Error.ToString()));
+
+                // 清理无效数据 没有Tab标签的数据才是要计算的数据
+                var cleanDatas = request.Body.Where(w => w.Count > 0 && w.GetValue(nameof(ResponseType), "") == ResponseType.OK.ToString()).ToList();
+                if (cleanDatas == null || cleanDatas.Count == 0)
+                    throw new PerformanceException("提交参数都是无效数据，请重新填写数据后查看计算结果！");
+
+                var saveResult = secondAllotService.RedistributionSave(allot, second, request.Head, cleanDatas);
+                if (saveResult)
+                {
+                    var userid = claimService.GetUserId();
+                    var result = secondAllotService.AuditSubmit(second, userid);
+                    if (result)
+                        return new ApiResponse(ResponseType.OK, "提交成功");
+                }
+                return new ApiResponse(ResponseType.Fail, "提交失败");
+            }
+            catch (PerformanceException ex)
+            {
+                throw ex;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"二次绩效提交:{ex}");
+                return new ApiResponse(ResponseType.Fail, "提交失败");
+            }
+        }
+        /// <summary>
+        /// 二次分配人员字典带出
+        /// </summary> 
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/employee")]
+        [HttpPost]
+        public ApiResponse RedistributionEmployee([FromBody] SecondEmployeeDto request)
+        {
+            // 返回信息 
+            var employees = _redistributionService.RedistributionEmployee(request);
+            return new ApiResponse(ResponseType.OK, employees);
+        }
+
+        /// <summary>
+        /// 二次分配审核后查看详情
+        /// </summary> 
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("api/second/redistribution/detail")]
+        [HttpPost]
+        public ApiResponse RedistributionDetail([FromBody] SecondBaseDto request)
+        {
+            if (!Enum.IsDefined(typeof(ComputeMode), request.ComputeMode))
+                throw new PerformanceException("暂不支持当前计算方式！");
+
+            var second = secondAllotService.GetSecondAllot(request.SecondId);
+            if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+            var allot = _allotService.GetAllot(second.AllotId.Value);
+            if (allot == null)
+                throw new PerformanceException("绩效记录不存在！");
+            // 年资职称绩效占比与工作量绩效占比 校验
+            var loads = _redistributionService.GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+            var workloadGroups = _redistributionService.GetTopWorkloadBodyGroups(loads);
+
+            // 返回信息 
+            var (head, rows) = _redistributionService.RedistributionDetail((ComputeMode)request.ComputeMode, allot, second, workloadGroups);
+
+            var dic = _redistributionService.GetTableHeaderDictionary((ComputeMode)request.ComputeMode, allot, second, loads, workloadGroups);
+            return new ApiResponse(ResponseType.OK, new { Head = head, Body = rows, Dic = dic });
+        }
+        #endregion
     }
 }

performance/Performance.Api/Filters/RequestRateLimitingMiddleware.cs

@@ -73,7 +73,7 @@ public class RequestRateLimitingMiddleware
                         var response = new ApiResponse
                         {
                             State = ResponseType.TooManyRequests,
-                            Message = "访问过于频繁，请稍后重试"
+                            Message = "您的操作正在处理，请稍等片刻！"
                         };
                         await context.Response.WriteAsync(JsonHelper.Serialize(response));
                     }

performance/Performance.Api/appsettings.Localhost.json

@@ -38,7 +38,13 @@
     "HttpPost": "http://localhost:50997/api/"
   },
   "RateLimitingConfig": {
-    "Endpoints": [ "/api/second/savevalue", "/api/second/savedata", "/api/second/other/save" ],
+    "Endpoints": [
+      "/api/second/savevalue",
+      "/api/second/savedata",
+      "/api/second/other/save",
+      "/api/second/redistribution/save",
+      "/api/second/redistribution/submit"
+    ],
     "Period": "1", // 单位为秒
     "Limit": 1
   }

performance/Performance.Api/wwwroot/Performance.Api.xml

@@ -1536,6 +1536,12 @@
             </summary>
             <returns></returns>
         </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.WorkloadMap(System.Int32)">
+            <summary>
+            获取二次分配 提取工作量带出字典
+            </summary>
+            <returns></returns>
+        </member>
         <member name="M:Performance.Api.Controllers.SecondAllotController.SingleSave(Performance.EntityModels.ag_workload_type,System.Int32)">
             <summary>
             保存二次绩效工作量类型
@@ -1647,6 +1653,55 @@
             </summary>
             <returns></returns>
         </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionLoad(Performance.DtoModels.SecondLoadDto)">
+            <summary>
+            二次绩效录入页面
+            </summary>
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionCheck(Performance.DtoModels.SecondComputeDto)">
+            <summary>
+            提交数据正确性检验
+            </summary>
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionCompute(Performance.DtoModels.SecondComputeDto)">
+            <summary>
+            二次绩效结果计算
+            </summary>
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionSave(Performance.DtoModels.SecondComputeDto)">
+            <summary>
+            二次绩效保存
+            </summary>
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionSubmit(Performance.DtoModels.SecondComputeDto)">
+            <summary>
+            二次绩效提交
+            </summary>
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionEmployee(Performance.DtoModels.SecondEmployeeDto)">
+            <summary>
+            二次分配人员字典带出
+            </summary> 
+            <param name="request"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Performance.Api.Controllers.SecondAllotController.RedistributionDetail(Performance.DtoModels.SecondBaseDto)">
+            <summary>
+            二次分配审核后查看详情
+            </summary> 
+            <param name="request"></param>
+            <returns></returns>
+        </member>
         <member name="M:Performance.Api.Controllers.SheetController.SheetList(Performance.DtoModels.SheetRequest)">
             <summary>
             sheet 列表

performance/Performance.Api/wwwroot/Performance.DtoModels.xml

@@ -149,7 +149,7 @@
             <summary> 正在生成绩效 </summary>
         </member>
         <member name="F:Performance.DtoModels.AllotStates.GenerateSucceed">
-            <summary> 绩效结果通过审核，允许下发 </summary>
+            <summary> 绩效下发 </summary>
         </member>
         <member name="F:Performance.DtoModels.AllotStates.GenerateFail">
             <summary> 绩效解析失败 </summary>
@@ -848,6 +848,9 @@
         <member name="F:Performance.DtoModels.SheetType.Custom">
             <summary> 自定义抽取模板 </summary>
         </member>
+        <member name="F:Performance.DtoModels.SheetType.OnlyExtract">
+            <summary> 抽取数据，不写入 </summary>
+        </member>
         <member name="T:Performance.DtoModels.AccountUnitType">
             <summary>
             核算单元类型
@@ -2531,6 +2534,11 @@
             是否是单项奖励
             </summary>
         </member>
+        <member name="P:Performance.DtoModels.WorkloadRequest.SourceCategory">
+            <summary>
+            工作量带出HIS来源
+            </summary>
+        </member>
         <member name="P:Performance.DtoModels.WorkyearRequest.MaxRange">
             <summary>
             最大工龄范围（小于）
@@ -3787,6 +3795,81 @@
             绩效系数
             </summary>
         </member>
+        <member name="T:Performance.DtoModels.Second.ComputeMode">
+            <summary>
+            二次分配计算方式
+            </summary>
+        </member>
+        <member name="F:Performance.DtoModels.Second.ComputeMode.NotCalculate">
+            <summary>
+            填报(不计算)
+            </summary>
+        </member>
+        <member name="F:Performance.DtoModels.Second.ComputeMode.Horizontal">
+            <summary>
+            横向计算
+            </summary>
+        </member>
+        <member name="F:Performance.DtoModels.Second.ComputeMode.Vertical">
+            <summary>
+            纵向计算
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondBaseDto.ComputeMode">
+            <summary>
+            计算方式：11 不计算 12 横向计算 13 纵向计算
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Label">
+            <summary>
+            描述
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Key">
+            <summary>
+            主键
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.IsTrue">
+            <summary>
+            是否显示 true显示
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Width">
+            <summary>
+            宽度
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Sort">
+            <summary>
+            排序
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Site">
+            <summary>
+            位置 Top、Table
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Type">
+            <summary>
+            类型 单项奖励：SingleAwards，工作量：Workload
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondColumnDictionary.Color">
+            <summary>
+            颜色class名称
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondEmployeeDto.ComputeMode">
+            <summary>
+            计算方式：11 不计算 12 横向计算 13 纵向计算
+            </summary>
+        </member>
+        <member name="P:Performance.DtoModels.SecondLoadDto.OverrideMode">
+            <summary>
+            数据加载方式：0 保存，1 上次，2 字典
+            </summary>
+        </member>
         <member name="P:Performance.DtoModels.SelectionOptions.SelectionID">
             <summary>
             ID
@@ -3842,24 +3925,29 @@
             数据集合
             </summary>
         </member>
-        <member name="T:Performance.DtoModels.TitleValue`1">
+        <member name="T:Performance.DtoModels.TitleValue`2">
             <summary>
             title value
             </summary>
         </member>
-        <member name="P:Performance.DtoModels.TitleValue`1.Title">
+        <member name="P:Performance.DtoModels.TitleValue`2.Title">
             <summary>
             Title
             </summary>
         </member>
-        <member name="P:Performance.DtoModels.TitleValue`1.Value">
+        <member name="P:Performance.DtoModels.TitleValue`2.Value">
             <summary>
             Value
             </summary>
         </member>
-        <member name="P:Performance.DtoModels.TitleValue`1.State">
+        <member name="P:Performance.DtoModels.TitleValue`2.State">
             <summary>
-            1、已选，2、未选，3、已被选择
+            存储数据
+            </summary>
+        </member>
+        <member name="T:Performance.DtoModels.TitleValue`1">
+            <summary>
+            title value
             </summary>
         </member>
         <member name="T:Performance.DtoModels.TitleValue">

performance/Performance.Api/wwwroot/Performance.EntityModels.xml

@@ -472,24 +472,19 @@
             职称系数
             </summary>
         </member>
-        <member name="P:Performance.EntityModels.ag_bodysource.TitlePerformance">
+        <member name="P:Performance.EntityModels.ag_bodysource.TitlePerformanceScore">
             <summary>
-            职称绩效
+            职称绩效得分
             </summary>
         </member>
-        <member name="P:Performance.EntityModels.ag_bodysource.ManagementAllowance">
-            <summary>
-            管理津贴
-            </summary>
-        </member>
-        <member name="P:Performance.EntityModels.ag_bodysource.IndividualReward">
+        <member name="P:Performance.EntityModels.ag_bodysource.TitlePerformance">
             <summary>
-            单项奖励
+            职称绩效
             </summary>
         </member>
-        <member name="P:Performance.EntityModels.ag_bodysource.AllocationOfKeySpecialty">
+        <member name="P:Performance.EntityModels.ag_bodysource.WorkPerformance">
             <summary>
-            重点专科分配
+            工作量绩效
             </summary>
         </member>
         <member name="P:Performance.EntityModels.ag_bodysource.DeptReward">
@@ -519,7 +514,7 @@
         </member>
         <member name="P:Performance.EntityModels.ag_bodysource.RealAmount">
             <summary>
-            实发绩效工资金额
+            实发绩效(不含医院其他绩效)
             </summary>
         </member>
         <member name="P:Performance.EntityModels.ag_bodysource.Signature">
@@ -537,6 +532,11 @@
             预留金额
             </summary>
         </member>
+        <member name="P:Performance.EntityModels.ag_bodysource.ReferToRealAmount">
+            <summary>
+            实发绩效(参考，含医院其他绩效)
+            </summary>
+        </member>
         <member name="T:Performance.EntityModels.ag_compute">
             <summary>
             二次绩效结果表
@@ -939,12 +939,12 @@
         </member>
         <member name="P:Performance.EntityModels.ag_headsource.TheTotalAllocationOfPerformanceResults">
             <summary>
-            科室单项奖励
+            业绩分配绩效总额
             </summary>
         </member>
-        <member name="P:Performance.EntityModels.ag_headsource.BasisPerformance">
+        <member name="P:Performance.EntityModels.ag_headsource.TotalDeptReward">
             <summary>
-            业绩分配绩效总额
+            科室单项奖励
             </summary>
         </member>
         <member name="P:Performance.EntityModels.ag_headsource.SeniorityTitlesAccountedPerformance">
@@ -1387,6 +1387,11 @@
             1、单项奖励 2、工作量占比 ..（自定义占比）
             </summary>
         </member>
+        <member name="P:Performance.EntityModels.ag_workload.SourceCategory">
+            <summary>
+            工作量来源类型
+            </summary>
+        </member>
         <member name="T:Performance.EntityModels.ag_workload_source">
             <summary>
             
@@ -7487,5 +7492,20 @@
             是否被使用 默认false
             </summary>
         </member>
+        <member name="P:Performance.EntityModels.view_second_workload_result.UnitType">
+            <summary>
+            核算单元组别
+            </summary>
+        </member>
+        <member name="P:Performance.EntityModels.view_second_workload_result.AccountingUnit">
+            <summary>
+            核算单元
+            </summary>
+        </member>
+        <member name="P:Performance.EntityModels.view_second_workload_result.HISDeptName">
+            <summary>
+            统计的HIS的原始科室名称
+            </summary>
+        </member>
     </members>
 </doc>

performance/Performance.DtoModels/Enum.cs

@@ -65,8 +65,8 @@ public enum AllotStates
         /// <summary> 正在生成绩效 </summary>
         [Description("正在生成绩效")]
         InGenerate = 5,
-        /// <summary> 绩效结果通过审核，允许下发 </summary>
-        [Description("数据验证通过")]
+        /// <summary> 绩效下发 </summary>
+        [Description("绩效下发")]
         GenerateSucceed = 6,
         /// <summary> 绩效解析失败 </summary>
         [Description("绩效解析失败")]

performance/Performance.DtoModels/PerExcel/ExcelEnum.cs

@@ -195,6 +195,10 @@ public enum SheetType
         /// <summary> 自定义抽取模板 </summary>
         [Description("自定义抽取模板")]
         Custom = 101,
+
+        /// <summary> 抽取数据，不写入 </summary>
+        [Description("抽取数据，不写入")]
+        OnlyExtract = 102,
     }
 
     /// <summary>

performance/Performance.DtoModels/Request/WorkloadRequest.cs

@@ -51,6 +51,11 @@ public class WorkloadRequest
         /// 是否是单项奖励
         /// </summary>
         public bool IsSingleAwards { get; set; }
+
+        /// <summary>
+        /// 工作量带出HIS来源
+        /// </summary>
+        public string SourceCategory { get; set; }
     }
     public class WorkloadRequestValidator : AbstractValidator<WorkloadRequest>
     {

performance/Performance.DtoModels/ResponseType.cs

@@ -14,5 +14,6 @@ public enum ResponseType
         ParameterError = 6,
         Disable = 7,
         TooManyRequests = 8,
+        Warning = 9,
     }
 }

performance/Performance.DtoModels/Second/Constant.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace Performance.DtoModels.Second
+{
+    /// <summary>
+    /// 二次分配计算方式
+    /// </summary>
+    public enum ComputeMode
+    {
+        /// <summary>
+        /// 填报(不计算)
+        /// </summary>
+        [Description("填报")]
+        NotCalculate = 11,
+        /// <summary>
+        /// 横向计算
+        /// </summary>
+        [Description("横向计算")]
+        Horizontal = 12,
+        /// <summary>
+        /// 纵向计算
+        /// </summary>
+        [Description("纵向计算")]
+        Vertical = 13,
+    }
+}

performance/Performance.DtoModels/Second/SecondBaseDto.cs

+namespace Performance.DtoModels
+{
+    public class SecondBaseDto
+    {
+        public int SecondId { get; set; }
+        /// <summary>
+        /// 计算方式：11 不计算 12 横向计算 13 纵向计算
+        /// </summary>
+        public int ComputeMode { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondColumnDictionary.cs

+namespace Performance.DtoModels
+{
+    public class SecondColumnDictionary
+    {
+        /// <summary>
+        /// 描述
+        /// </summary>
+        public string Label { get; set; }
+        /// <summary>
+        /// 主键
+        /// </summary>
+        public string Key { get; set; }
+        /// <summary>
+        /// 是否显示 true显示
+        /// </summary>
+        public bool IsTrue { get; set; }
+        /// <summary>
+        /// 宽度
+        /// </summary>
+        public string Width { get; set; }
+        /// <summary>
+        /// 排序
+        /// </summary>
+        public int Sort { get; set; }
+        /// <summary>
+        /// 位置 Top、Table
+        /// </summary>
+        public string Site { get; set; }
+        /// <summary>
+        /// 类型 单项奖励：SingleAwards，工作量：Workload
+        /// </summary>
+        public string Type { get; set; }
+        /// <summary>
+        /// 颜色class名称
+        /// </summary>
+        public string Color { get; set; }
+
+        public SecondColumnDictionary()
+        {
+        }
+
+        public SecondColumnDictionary(string label, string key, bool isTrue, int sort, string site = "Table", string type = "", string color = "")
+        {
+            Label = label;
+            Key = key;
+            IsTrue = isTrue;
+            Sort = sort;
+            Site = site;
+            Type = type;
+            Color = color;
+            Width = ((label ?? "").Length * 20 + 10).ToString();
+        }
+    }
+}

performance/Performance.DtoModels/Second/SecondComputeCheckResultDto.cs

+namespace Performance.DtoModels
+{
+    public class SecondComputeCheckResultDto
+    {
+        public SecondComputeCheckResultDto(string level, string personnelNumber, string personnelName, string message)
+        {
+            Level = level;
+            PersonnelNumber = personnelNumber;
+            PersonnelName = personnelName;
+            Message = message;
+        }
+
+        public string Level { get; set; }
+        public string PersonnelNumber { get; set; }
+        public string PersonnelName { get; set; }
+        public string Message { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondComputeDto.cs

+using System.Collections.Generic;
+
+namespace Performance.DtoModels
+{
+    public class SecondComputeDto : SecondLoadDto
+    {
+        public Dictionary<string, object> Head { get; set; }
+        public List<Dictionary<string, object>> Body { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondDetailDto.cs

+using System.Collections.Generic;
+
+namespace Performance.DtoModels
+{
+    public class SecondDetailDto
+    {
+        public object Head { get; set; }
+        public HandsonTableBase Body { get; set; }
+        public List<SecondColumnDictionary> Dic { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondEmployeeDto.cs

+namespace Performance.DtoModels
+{
+    public class SecondEmployeeDto : PersonParamsRequest
+    {
+        public int SecondId { get; set; }
+        /// <summary>
+        /// 计算方式：11 不计算 12 横向计算 13 纵向计算
+        /// </summary>
+        public int ComputeMode { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondLoadDto.cs

+namespace Performance.DtoModels
+{
+    public class SecondLoadDto : SecondBaseDto
+    {
+        /// <summary>
+        /// 数据加载方式：0 保存，1 上次，2 字典
+        /// </summary>
+        public int OverrideMode { get; set; }
+    }
+}

performance/Performance.DtoModels/Second/SecondWorkLoadDto.cs

+using System;
+using System.Collections.Generic;
+
+namespace Performance.DtoModels
+{
+    public class SecondWorkLoadDto
+    {
+        public SecondWorkLoadDto(string name)
+        {
+            Name = name;
+            Unit_Price = 0m;
+            Items = new List<string>();
+
+            AssessmentScore = $"AssessmentScore_{Name}";
+            WorkPerformance = $"WorkPerformance_{Name}";
+            WorkloadScore = $"WorkloadScore_{Name}";
+        }
+
+        public string AssessmentScore { get; set; }
+        public string WorkPerformance { get; set; }
+        public string WorkloadScore { get; set; }
+        public decimal Unit_Price { get; set; }
+        public List<string> Items { get; set; }
+        public string Name { get; set; }
+
+        public void AddItem(string name)
+        {
+            if (!Items.Contains(name))
+                Items.Add(name);
+        }
+    }
+}

performance/Performance.DtoModels/TitleValue.cs

@@ -7,7 +7,7 @@ namespace Performance.DtoModels
     /// <summary>
     /// title value
     /// </summary>
-    public class TitleValue<T>
+    public class TitleValue<TV, TS>
     {
         /// <summary>
         /// Title
@@ -16,11 +16,17 @@ public class TitleValue<T>
         /// <summary>
         /// Value
         /// </summary>
-        public T Value { get; set; }
+        public TV Value { get; set; }
         /// <summary>
-        /// 1、已选，2、未选，3、已被选择
+        /// 存储数据
         /// </summary>
-        public int State { get; set; }
+        public TS State { get; set; }
+    }
+    /// <summary>
+    /// title value
+    /// </summary>
+    public class TitleValue<T> : TitleValue<T, int>
+    {
     }
     /// <summary>
     /// title value

performance/Performance.EntityModels/Entity/ag_bodysource.cs

@@ -72,24 +72,34 @@ public class ag_bodysource
         public Nullable<decimal> TitleCoefficient { get; set; }
 
         /// <summary>
-        /// 职称绩效
+        /// 职称绩效得分
         /// </summary>
-        public Nullable<decimal> TitlePerformance { get; set; }
+        public Nullable<decimal> TitlePerformanceScore { get; set; }
 
         /// <summary>
-        /// 管理津贴
+        /// 职称绩效
         /// </summary>
-        public Nullable<decimal> ManagementAllowance { get; set; }
+        public Nullable<decimal> TitlePerformance { get; set; }
 
         /// <summary>
-        /// 单项奖励
+        /// 工作量绩效
         /// </summary>
-        public Nullable<decimal> IndividualReward { get; set; }
+        public Nullable<decimal> WorkPerformance { get; set; }
 
-        /// <summary>
-        /// 重点专科分配
-        /// </summary>
-        public Nullable<decimal> AllocationOfKeySpecialty { get; set; }
+        ///// <summary>
+        ///// 管理津贴
+        ///// </summary>
+        //public Nullable<decimal> ManagementAllowance { get; set; }
+
+        ///// <summary>
+        ///// 单项奖励
+        ///// </summary>
+        //public Nullable<decimal> IndividualReward { get; set; }
+
+        ///// <summary>
+        ///// 重点专科分配
+        ///// </summary>
+        //public Nullable<decimal> AllocationOfKeySpecialty { get; set; }
 
         /// <summary>
         /// 科室单项奖励
@@ -117,7 +127,7 @@ public class ag_bodysource
         public Nullable<decimal> NightWorkPerformance { get; set; }
 
         /// <summary>
-        /// 实发绩效工资金额
+        /// 实发绩效(不含医院其他绩效)
         /// </summary>
         public Nullable<decimal> RealAmount { get; set; }
 
@@ -135,5 +145,10 @@ public class ag_bodysource
         /// 预留金额
         /// </summary>
         public Nullable<decimal> ReservedAmount { get; set; }
+
+        /// <summary>
+        /// 实发绩效(参考，含医院其他绩效)
+        /// </summary>
+        public Nullable<decimal> ReferToRealAmount { get; set; }
     }
 }

performance/Performance.EntityModels/Entity/ag_headsource.cs

@@ -52,14 +52,19 @@ public class ag_headsource
         public Nullable<decimal> DirectorBasisPerformance { get; set; }
 
         /// <summary>
-        /// 科室单项奖励
+        /// 业绩分配绩效总额
         /// </summary>
         public Nullable<decimal> TheTotalAllocationOfPerformanceResults { get; set; }
 
         /// <summary>
-        /// 业绩分配绩效总额
+        /// 科室单项奖励
         /// </summary>
-        public Nullable<decimal> BasisPerformance { get; set; }
+        public Nullable<decimal> TotalDeptReward { get; set; }
+
+        ///// <summary>
+        ///// 业绩分配绩效总额
+        ///// </summary>
+        //public Nullable<decimal> BasisPerformance { get; set; }
 
         /// <summary>
         /// 年资职称绩效占比

performance/Performance.EntityModels/Entity/ag_workload.cs

@@ -60,5 +60,10 @@ public class ag_workload
         /// 1、单项奖励 2、工作量占比 ..（自定义占比）
         /// </summary>
         public int WorkTypeId { get; set; }
+
+        /// <summary>
+        /// 工作量来源类型
+        /// </summary>
+        public string SourceCategory { get; set; }
     }
 }

performance/Performance.EntityModels/Other/view_second_workload_result.cs

+namespace Performance.EntityModels
+{
+    public class view_second_workload_result
+    {
+        public int HospitalId { get; set; }
+        public int AllotId { get; set; }
+        /// <summary>
+        /// 核算单元组别
+        /// </summary>
+        public string UnitType { get; set; }
+        /// <summary>
+        /// 核算单元
+        /// </summary>
+        public string AccountingUnit { get; set; }
+        /// <summary>
+        /// 统计的HIS的原始科室名称
+        /// </summary>
+        public string HISDeptName { get; set; }
+        public string ItemId { get; set; }
+        public string ItemName { get; set; }
+        public decimal? FactorValue { get; set; }
+        public string PersonnelNumber { get; set; }
+        public string DoctorName { get; set; }
+        public string Category { get; set; }
+        public decimal Value { get; set; }
+    }
+}

performance/Performance.Infrastructure/Extensions/Extensions.Color.cs

+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Text;
+
+namespace Performance.Infrastructure
+{
+    public static partial class UtilExtensions
+    {
+        public static string ToRGB(this Color color)
+        {
+            return $"{color.R},{color.G},{color.B}";
+        }
+    }
+}

performance/Performance.Infrastructure/Extensions/Extensions.Dictionary.cs

@@ -18,8 +18,9 @@ public static partial class UtilExtensions
         /// <returns></returns>
         public static T GetValue<T>(this Dictionary<string, object> keyValues, string key, T defaultValue = default(T))
         {
-            object value;
-            if (keyValues.TryGetValue(key, out value))
+            if (keyValues.TryGetValue(key, out object value))
+                return ConvertHelper.To<T>(value, defaultValue);
+            else if (keyValues.TryGetValue(key.ToLower(), out value))
                 return ConvertHelper.To<T>(value, defaultValue);
             return defaultValue;
         }
@@ -33,13 +34,62 @@ public static T GetValue<T>(this Dictionary<string, object> keyValues, string ke
         /// <returns></returns>
         public static T GetValue<T>(this SortedDictionary<string, object> keyValues, string key, T defaultValue = default(T))
         {
-            object value;
-            if (keyValues.TryGetValue(key, out value))
+            if (keyValues.TryGetValue(key, out object value))
+                return ConvertHelper.To<T>(value, defaultValue);
+            else if (keyValues.TryGetValue(key.ToLower(), out value))
                 return ConvertHelper.To<T>(value, defaultValue);
             return defaultValue;
         }
 
         /// <summary>
+        /// 添加或修改
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="keyValues"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static void AddOrUpdate(this Dictionary<string, object> keyValues, string key, object value)
+        {
+            var pair = keyValues.FirstOrDefault(w => w.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            if (default(KeyValuePair<string, object>).Equals(pair))
+                keyValues.Add(key, value);
+            else
+                keyValues[key] = value;
+        }
+
+        /// <summary>
+        /// 为了快速读取，忽略大小写，默认：0
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="keyValues"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static decimal GetDecimal(this Dictionary<string, object> keyValues, string key)
+        {
+            if (keyValues.TryGetValue(key, out object value))
+                return value == null || string.IsNullOrEmpty(value.ToString().Trim()) ? 0m : decimal.Parse(value.ToString());
+            else if (keyValues.TryGetValue(key.ToLower(), out value))
+                return value == null || string.IsNullOrEmpty(value.ToString().Trim()) ? 0m : decimal.Parse(value.ToString());
+            return 0m;
+        }
+
+        /// <summary>
+        /// 为了快速读取，忽略大小写，默认：空值
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="keyValues"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetString(this Dictionary<string, object> keyValues, string key)
+        {
+            if (keyValues.TryGetValue(key, out object value))
+                return value?.ToString() ?? "";
+            else if (keyValues.TryGetValue(key.ToLower(), out value))
+                return value?.ToString() ?? "";
+            return "";
+        }
+
+        /// <summary>
         /// form 转换 键值对
         /// </summary>
         /// <param name="pairs"></param>

performance/Performance.Infrastructure/Extensions/Extensions.String.cs

@@ -26,5 +26,27 @@ public static string[] SplitRemoveEmpty(this string text, params string[] separa
         {
             return text.Split(separator, StringSplitOptions.RemoveEmptyEntries);
         }
+
+        /// <summary>
+        /// 确定此字符串实例的开头是否与指定的匹配 忽略字母的大小写
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool StartsWithIgnoreCase(this string text, string value)
+        {
+            return text.StartsWith(value, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// 确定此字符串是否与指定的字符串对象具有相同的值 忽略字母的大小写
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool EqualsIgnoreCase(this string text, string value)
+        {
+            return text.Equals(value, StringComparison.OrdinalIgnoreCase);
+        }
     }
 }

performance/Performance.Infrastructure/Helper/RandomHelper.cs

 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Text;
+using System.Text.RegularExpressions;
 
 namespace Performance.Infrastructure
 {
@@ -17,5 +19,26 @@ public static string GetSmsCode()
 
             return code.ToString().PadLeft(4, '0');
         }
+
+        public static List<Color> Color(Color sColor, Color eColor, int number)
+        {
+            int sr = sColor.R;
+            int sg = sColor.G;
+            int sb = sColor.B;
+
+            int er = eColor.R;
+            int eg = eColor.G;
+            int eb = eColor.B;
+
+            var colorList = new List<Color>();
+            for (int i = 0; i < number; i++)
+            {
+                var rAverage = sr + (int)((er - sr) * i / number);
+                var gAverage = sg + (int)((eg - sg) * i / number);
+                var bAverage = sb + (int)((eb - sb) * i / number);
+                colorList.Add(System.Drawing.Color.FromArgb(rAverage, gAverage, bAverage));
+            }
+            return colorList;
+        }
     }
 }

performance/Performance.Repository/PerforPerAllotRepository.cs

@@ -188,7 +188,7 @@ public IEnumerable<report_original_workload> QueryWorkloadData(int allotid, stri
 WHERE t1.allotid = @allotid
 	AND t3.unittype in @unittypes
 	AND t3.accountingunit = @accountingunit
-	AND t1.Source LIKE CONCAT('%',@unittype,'工作量%')
+	AND (t1.Source LIKE CONCAT('%',@unittype,'工作量%') OR t1.Source = '通用工作量')
 	AND T1.IsDelete = 0
 GROUP BY ifnull(t1.DoctorName, '未知'),t1.PersonnelNumber,t1.Category
 ORDER BY t1.doctorname,t1.Category;";
@@ -229,5 +229,58 @@ public IEnumerable<ex_result> QueryIncomeData(int allotid, string source, string
                 }
             }
         }
+
+        /// <summary>
+        /// 二次分配按工号带出带出工作量
+        /// </summary>
+        /// <param name="allotid"></param>
+        /// <param name="unittype"></param>
+        /// <param name="accountingunit"></param>
+        /// <returns></returns>
+        public IEnumerable<view_second_workload_result> GetSecondWorkload(int allotid, string unittype, string accountingunit)
+        {
+            using (var connection = context.Database.GetDbConnection())
+            {
+                if (connection.State != ConnectionState.Open) connection.Open();
+                try
+                {
+                    string query = $@"SELECT * FROM view_second_workload_result WHERE AllotId = @allotid AND UnitType = @unittype AND AccountingUnit = @accountingunit";
+                    return connection.Query<view_second_workload_result>(query, new { allotid, unittype, accountingunit }, commandTimeout: 60 * 60);
+                }
+                catch (Exception ex)
+                {
+                    throw ex;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 查询HIS提取数据，工作量字典
+        /// </summary>
+        /// <param name="allotid"></param>
+        /// <param name="unittype"></param>
+        /// <param name="accountingunit"></param>
+        /// <returns></returns>
+        public IEnumerable<string> GetSecondWorkloadMaps(int hospitalId)
+        {
+            using (var connection = context.Database.GetDbConnection())
+            {
+                if (connection.State != ConnectionState.Open) connection.Open();
+                try
+                {
+                    string query = $@"SELECT DISTINCT Category FROM (
+	SELECT IF(Source = 102,EName,ItemName) Category FROM ex_type t1
+	LEFT JOIN ex_item t2 ON t1.Id = t2.TypeId 
+	WHERE Source IN (102,7) AND HospitalId = @hospitalId
+)TAB
+WHERE IFNULL(Category,'')<>''";
+                    return connection.Query<string>(query, new { hospitalId }, commandTimeout: 60 * 60);
+                }
+                catch (Exception ex)
+                {
+                    throw ex;
+                }
+            }
+        }
     }
 }
\ No newline at end of file

performance/Performance.Repository/PerforPerapramounthideRepository.cs

@@ -12,7 +12,7 @@
 namespace Performance.Repository
 {
     /// <summary>
-    /// per_apr_amount Repository
+    /// per_apr_amount_hide Repository
     /// </summary>
     public partial class PerforPerapramounthideRepository : PerforRepository<per_apr_amount_hide>
     {

performance/Performance.Services/ExtractExcelService/DictionaryService.cs

@@ -20,6 +20,7 @@ public class DictionaryService : IAutoInjection
         private readonly PerforHospitalconfigRepository hospitalconfigRepository;
         private readonly PerforExtypeRepository extypeRepository;
         private readonly PerforExscriptRepository exscriptRepository;
+        private readonly PerforExresultRepository exresultRepository;
         private readonly PerforHisdataRepository hisdataRepository;
         private readonly PerforHisscriptRepository hisscriptRepository;
 
@@ -31,6 +32,7 @@ public class DictionaryService : IAutoInjection
             PerforHospitalconfigRepository hospitalconfigRepository,
             PerforExtypeRepository extypeRepository,
             PerforExscriptRepository exscriptRepository,
+            PerforExresultRepository exresultRepository,
             PerforHisdataRepository hisdataRepository,
             PerforHisscriptRepository hisscriptRepository
             )
@@ -42,6 +44,7 @@ PerforHisscriptRepository hisscriptRepository
             this.hospitalconfigRepository = hospitalconfigRepository;
             this.extypeRepository = extypeRepository;
             this.exscriptRepository = exscriptRepository;
+            this.exresultRepository = exresultRepository;
             this.hisdataRepository = hisdataRepository;
             this.hisscriptRepository = hisscriptRepository;
         }
@@ -53,7 +56,7 @@ public void Handler(int hospitalId, per_allot allot, string groupName, bool isSi
                 var configs = hospitalconfigRepository.GetEntities(t => t.HospitalId == hospitalId);
                 if (configs == null || !configs.Any()) throw new Exception("医院未配置绩效抽取信息");
 
-                var types = extypeRepository.GetEntities(t => t.HospitalId == hospitalId && new int[] { 2 }.Contains(t.Source));
+                var types = extypeRepository.GetEntities(t => t.HospitalId == hospitalId && new int[] { (int)SheetType.Employee, (int)SheetType.OnlyExtract }.Contains(t.Source));
                 if (types != null && types.Any())
                 {
                     logService.ReturnTheLog(allot.ID, groupName, 2, "提取数据", $"提取人员信息数据", isSingle: isSingle);
@@ -67,6 +70,19 @@ public void Handler(int hospitalId, per_allot allot, string groupName, bool isSi
                             if (script != null)
                                 Employee(allot, configs.FirstOrDefault(t => t.Id == script.ConfigId), script.ExecScript);
                         }
+                        if (types.Any(t => t.Source == (int)SheetType.OnlyExtract))    //不写入Excel的提取数据
+                        {
+                            foreach (var type in types.Where(t => t.Source == (int)SheetType.OnlyExtract))
+                            {
+                                var thisTypeScripts = scripts.Where(t => t.TypeId == type.Id);
+                                if (thisTypeScripts == null || !thisTypeScripts.Any()) continue;
+
+                                foreach (var script in thisTypeScripts)
+                                {
+                                    ExResult(allot, configs.FirstOrDefault(t => t.Id == script.ConfigId), script.ExecScript, type.EName);
+                                }
+                            }
+                        }
                     }
                 }
 
@@ -154,6 +170,37 @@ private void Department()
         {
         }
 
+        private void ExResult(per_allot allot, sys_hospitalconfig config, string sql, string enmae)
+        {
+            try
+            {
+                if (config == null || string.IsNullOrEmpty(sql)) return;
+
+                var data = queryService.QueryData(config, allot, sql);
+                if (data == null || !data.Any()) return;
+
+                var createTime = DateTime.Now;
+                var result = data.Select(t => new ex_result
+                {
+                    Department = t.Department,
+                    Category = enmae,
+                    Fee = t.Value,
+                    DoctorName = t.DoctorName,
+                    PersonnelNumber = t.PersonnelNumber,
+                    Source = "通用工作量",
+                    DatabaseType = config.DataBaseType,
+                    ConfigId = config.Id,
+                    AllotId = allot.ID,
+                    CreateTime = createTime,
+                }).ToList();
+                exresultRepository.AddRange(result.ToArray());
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("获取不写入Excel数据时发生异常：" + ex.ToString());
+            }
+        }
+
         private string GetSaveValue(params string[] arr)
         {
             string value = string.Empty;

performance/Performance.Services/ExtractExcelService/ExtractService.cs

@@ -80,6 +80,9 @@ public string Main(int allotId, int hospitalId, string email, string groupName,
                 var dict = new Dictionary<ExDataDict, object>();
 
                 logService.ReturnTheLog(allotId, groupName, 3, "", 5, 1, isSingle);
+
+                queryService.ClearHistoryData(allot.ID, groupName, isSingle);
+
                 dictionaryService.Handler(hospitalId, allot, groupName, isSingle);
                 var data = queryService.Handler(hospitalId, allot, groupName, isSingle, ref dict);
                 var standData = StandDataFormat(hospitalId, data);

performance/Performance.Services/ExtractExcelService/QueryService.cs

@@ -77,8 +77,6 @@ public List<ex_result> Handler(int hospitalId, per_allot allot, string groupName
                 };
                 var extypeIds = GetQueryScriptIds(hospitalId, ref dict);
 
-                ClearHistoryData(allot.ID, groupName, isSingle);
-
                 var data = new List<ex_result>();
 
                 logService.ReturnTheLog(allot.ID, groupName, 2, "提取数据", $"开始提取数据", isSingle: isSingle);
@@ -157,7 +155,7 @@ private List<int> GetQueryScriptIds(int hospitalId, ref Dictionary<ExDataDict, o
         /// 清除历史抽取数据
         /// </summary>
         /// <param name="allotId"></param>
-        private void ClearHistoryData(int allotId, string groupName, bool isSingle)
+        public void ClearHistoryData(int allotId, string groupName, bool isSingle)
         {
             logService.ReturnTheLog(allotId, groupName, 2, "清除数据", $"开始清除历史提取数据", 1, isSingle);
             perallotRepository.ClearResultData(allotId);

performance/Performance.Services/PersonService.cs

@@ -208,7 +208,7 @@ public PageList<per_employee> GetPersons(int allotId, int userId, PersonParamsRe
 
             if (request != null && !string.IsNullOrEmpty(request.SearchQuery))
             {
-                exp = exp.And(t => true && (t.AccountingUnit.Contains(request.SearchQuery) || t.DoctorName.Contains(request.SearchQuery) || t.Department.Contains(request.SearchQuery)));
+                exp = exp.And(t => true && (t.AccountingUnit.Contains(request.SearchQuery) || t.PersonnelNumber.Contains(request.SearchQuery) || t.DoctorName.Contains(request.SearchQuery) || t.Department.Contains(request.SearchQuery)));
             }
 
             var result = new List<per_employee>();

performance/Performance.Services/RedistributionService.cs

+using AutoMapper;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using Performance.Repository;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Performance.Infrastructure;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
+using Performance.DtoModels.Second;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.Drawing;
+using System.Linq.Expressions;
+
+namespace Performance.Services
+{
+    public class RedistributionService : IAutoInjection
+    {
+        #region 构造函数
+
+        private readonly ILogger<RedistributionService> _logger;
+        private readonly SecondAllotDetails _secondAllotDetails;
+        private readonly PerforPerallotRepository _perallotRepository;
+        private readonly PerforPeremployeeRepository _peremployeeRepository;
+        private readonly PerforRescomputeRepository _rescomputeRepository;
+        private readonly PerforAgsecondallotRepository _secondallotRepository;
+        private readonly PerforPerapramountRepository _perapramountRepository;
+        private readonly PerforAgothersourceRepository _agothersourceRepository;
+        private readonly PerforAgfixatitemRepository _agfixatitemRepository;
+        private readonly PerforAgheadsourceRepository _agheadsourceRepository;
+        private readonly PerforAgbodysourceRepository _agbodysourceRepository;
+        private readonly PerforAgworktypesourceRepository _agworktypesourceRepository;
+        private readonly PerforAgworkloadRepository _agworkloadRepository;
+        private readonly PerforAgworkloadsourceRepository _agworkloadsourceRepository;
+        private readonly PerforAgworkloadtypeRepository _agworkloadtypeRepository;
+        private readonly PerforImemployeelogisticsRepository _imemployeelogisticsRepository;
+
+        public RedistributionService(
+            ILogger<RedistributionService> logger,
+            SecondAllotDetails secondAllotDetails,
+            PerforPerallotRepository perallotRepository,
+            PerforPeremployeeRepository peremployeeRepository,
+            PerforRescomputeRepository rescomputeRepository,
+            PerforAgsecondallotRepository secondallotRepository,
+            PerforPerapramountRepository perapramountRepository,
+            PerforAgothersourceRepository agothersourceRepository,
+            PerforAgfixatitemRepository agfixatitemRepository,
+            PerforAgheadsourceRepository agheadsourceRepository,
+            PerforAgbodysourceRepository agbodysourceRepository,
+            PerforAgworktypesourceRepository agworktypesourceRepository,
+            PerforAgworkloadRepository agworkloadRepository,
+            PerforAgworkloadsourceRepository agworkloadsourceRepository,
+            PerforAgworkloadtypeRepository agworkloadtypeRepository,
+            PerforImemployeelogisticsRepository imemployeelogisticsRepository)
+        {
+            _logger = logger;
+            _secondAllotDetails = secondAllotDetails;
+            _perallotRepository = perallotRepository;
+            _peremployeeRepository = peremployeeRepository;
+            _rescomputeRepository = rescomputeRepository;
+            _secondallotRepository = secondallotRepository;
+            _perapramountRepository = perapramountRepository;
+            _agothersourceRepository = agothersourceRepository;
+            _agfixatitemRepository = agfixatitemRepository;
+            _agheadsourceRepository = agheadsourceRepository;
+            _agbodysourceRepository = agbodysourceRepository;
+            _agworktypesourceRepository = agworktypesourceRepository;
+            _agworkloadRepository = agworkloadRepository;
+            _agworkloadsourceRepository = agworkloadsourceRepository;
+            _agworkloadtypeRepository = agworkloadtypeRepository;
+            _imemployeelogisticsRepository = imemployeelogisticsRepository;
+        }
+        #endregion
+
+        #region 加载
+        /// <summary>
+        /// 加载
+        /// </summary>
+        /// <param name="secondId"></param>
+        /// <param name="computeMode">计算方式：11 不计算 12 横向计算 13 纵向计算</param>
+        /// <param name="overrideMode">数据加载方式：0 保存，1 上次，2 字典，3 测算表</param>
+        /// <returns></returns>
+        public SecondDetailDto Load(int secondId, ComputeMode computeMode, EmployeeSource overrideMode)
+        {
+            var second = _secondallotRepository.GetEntity(t => t.Id == secondId);
+            if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+            var allot = _perallotRepository.GetEntity(t => t.ID == second.AllotId);
+            if (allot == null) throw new PerformanceException("绩效记录不存在！");
+
+            var loads = GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+
+            HandsonTableBase handson = GetHandsonTable(computeMode, loads);
+            // 先占位，更加选择加载指定范围数据
+            // 加载方式分 保存，上次，字典，测算表
+            var loadEmployees = LoadEmployees(allot, second, overrideMode, out bool isSave);
+            // 设置固定信息默认值
+            foreach (var item in loadEmployees)
+            {
+                item.StaffCoefficient = item.StaffCoefficient ?? 1;  // 人员系数
+                item.ActualAttendance = item.ActualAttendance ?? DateTime.DaysInMonth(allot.Year, allot.Month);  // 出勤
+                item.TitleCoefficient = item.TitleCoefficient ?? 1;  // 职称系数
+            }
+
+            // 加载已保存工作量数据
+            handson.Data = LoadWorkload(allot, second, loadEmployees, isSave);
+
+            // 设置工作量考核等分默认值
+            foreach (var item in handson.Data)
+            {
+                foreach (var score in item.Where(w => w.Key.StartsWithIgnoreCase("AssessmentScore_")).ToList())
+                {
+                    if (score.Value == null)
+                        item.AddOrUpdate(score.Key, 100);
+                }
+            }
+
+            var head = LoadHead(computeMode, allot, second);
+            var dic = GetTableHeaderDictionary(computeMode, allot, second, loads);
+            return new SecondDetailDto { Head = head, Body = handson, Dic = dic };
+        }
+
+        /// <summary>
+        /// 获取HandonTable内容配置信息
+        /// </summary>
+        /// <param name="computeMode"></param>
+        /// <param name="loads"></param>
+        /// <returns></returns>
+        public HandsonTableBase GetHandsonTable(ComputeMode computeMode, List<TitleValue<string, decimal?>> loads)
+        {
+            var (colHeaderCustoms, columnCustoms) = GetCustomColumns(computeMode, loads);
+            HandsonTableBase handson = new HandsonTableBase();
+            switch (computeMode)
+            {
+                case ComputeMode.NotCalculate:
+                    handson = ComputeMode_Format1(colHeaderCustoms, columnCustoms);
+                    break;
+                case ComputeMode.Horizontal:
+                    handson = ComputeMode_Format2(colHeaderCustoms, columnCustoms);
+                    break;
+                case ComputeMode.Vertical:
+                    handson = ComputeMode_Format3(colHeaderCustoms, columnCustoms, loads);
+                    break;
+            }
+
+            return handson;
+        }
+
+
+        /// <summary>
+        /// 表格及列头 字典信息
+        /// </summary>
+        /// <param name="second"></param>
+        /// <param name="loads"></param>
+        /// <returns></returns>
+        public List<SecondColumnDictionary> GetTableHeaderDictionary(ComputeMode computeMode, per_allot allot, ag_secondallot second, List<TitleValue<string, decimal?>> loads, List<SecondWorkLoadDto> workloadGroups = null)
+        {
+            /*
+             此处数据需要额外注意，前端显示规则：通过isTrue=true显示，显示名称为label
+             */
+            var maps = new List<SecondColumnDictionary>()
+            {
+                new SecondColumnDictionary("人员工号",nameof(ag_bodysource.WorkNumber),true,100),
+                new SecondColumnDictionary("姓名",nameof(ag_bodysource.Name),true,100),
+                new SecondColumnDictionary("科室",nameof(ag_bodysource.Department),true,100),
+                new SecondColumnDictionary("领取平均绩效",nameof(ag_bodysource.Post),true,100 ),
+
+                new SecondColumnDictionary("人员系数",nameof(ag_bodysource.StaffCoefficient),false,200, color: "title_color" ),
+                new SecondColumnDictionary("出勤",nameof(ag_bodysource.ActualAttendance),false,201, color: "title_color" ),
+                new SecondColumnDictionary("职称",nameof(ag_bodysource.JobTitle),false,202, color: "title_color" ),
+                new SecondColumnDictionary("职称系数",nameof(ag_bodysource.TitleCoefficient),false,203, color: "title_color" ),
+                new SecondColumnDictionary("职称绩效得分",nameof(ag_bodysource.TitlePerformanceScore),false,204, color: "title_color" ),
+                new SecondColumnDictionary("职称绩效",nameof(ag_bodysource.TitlePerformance),true,299 ),
+
+                new SecondColumnDictionary("工作量绩效合计",nameof(ag_bodysource.WorkPerformance),true,399 ),
+                new SecondColumnDictionary("单项奖励合计",nameof(ag_bodysource.DeptReward),true,499 ),
+
+                new SecondColumnDictionary("可分配绩效",nameof(ag_bodysource.DistPerformance),true,500 ),
+                new SecondColumnDictionary("医院发放夜班绩效",nameof(ag_bodysource.NightWorkPerformance),true,502 ),
+
+                //new SecondColumnDictionary("预留比例",nameof(ag_bodysource.ReservedRatio),false,601 ),
+                //new SecondColumnDictionary("预留金额",nameof(ag_bodysource.ReservedAmount),false,602 ),
+
+                new SecondColumnDictionary("绩效分配合计",nameof(ag_bodysource.RealAmount),true,700 ),
+
+                new SecondColumnDictionary("医院其他绩效",nameof(ag_bodysource.OtherPerformance),false,801, color: "referto_color" ),
+                new SecondColumnDictionary("实发绩效",nameof(ag_bodysource.ReferToRealAmount),false,802, color: "referto_color"),
+            };
+
+            // 工作量 
+            if (computeMode != ComputeMode.NotCalculate)
+            {
+                if (workloadGroups == null)
+                    workloadGroups = GetTopWorkloadBodyGroups(loads);
+
+                int workloadSort = 300;
+                var index = 0;
+                foreach (var item in loads.Where(w => !w.Title.StartsWithIgnoreCase("SingleAwards_")))
+                {
+                    if (workloadGroups.Any(w => w.Items != null && w.Items.Any(im => im.EqualsIgnoreCase(item.Title))))
+                        index = workloadGroups.FindIndex(w => w.Items != null && w.Items.Any(im => im.EqualsIgnoreCase(item.Title)));
+                    // 没有明确的工作量项目，则不显示
+                    var isExist = workloadGroups
+                        .Where(w => w.Items == null || w.Items.Count == 0)
+                        .Any(w => item.Title.EqualsIgnoreCase(w.WorkloadScore) || item.Title.EqualsIgnoreCase(w.AssessmentScore) || item.Title.EqualsIgnoreCase(w.WorkPerformance));
+                    if (!isExist)
+                        maps.Add(new SecondColumnDictionary(item.Value, item.Title, false, ++workloadSort, type: "Workload", color: $"workload_color{index}"));
+                }
+
+                // 多工作量加载 
+                var headDynamic = _agworktypesourceRepository.GetEntities(t => t.SecondId == second.Id) ?? new List<ag_worktype_source>();
+                foreach (var item in headDynamic.OrderBy(t => t.Id))
+                {
+                    maps.Add(new SecondColumnDictionary(item.FieldName, item.FieldId, true, 1, "Top"));
+                }
+            }
+            // 单项奖励 
+            int singleAwardsSort = 400;
+            foreach (var item in loads.Where(w => w.Title.StartsWithIgnoreCase("SingleAwards_")))
+            {
+                maps.Add(new SecondColumnDictionary(item.Value, item.Title, false, ++singleAwardsSort, type: "SingleAwards", color: "singleawards_color"));
+            }
+            return maps.OrderBy(w => w.Sort).ToList();
+        }
+
+        /// <summary>
+        /// 加载已保存工作量数据，加载时区分：已提交和未提交
+        /// </summary>
+        /// <param name="allot"></param>
+        /// <param name="second"></param>
+        /// <param name="loadEmployees"></param>
+        /// <param name="isSave">True 加载已保存数据 False 加载工作量自动带出</param>
+        /// <returns></returns>
+        private List<Dictionary<string, object>> LoadWorkload(per_allot allot, ag_secondallot second, List<ag_bodysource> loadEmployees, bool isSave = true)
+        {
+            List<Dictionary<string, object>> result = new List<Dictionary<string, object>>();
+            var status = (new int[] { (int)SecondAllotStatus.WaitReview, (int)SecondAllotStatus.PassAudit });
+            // 已提交
+            if (second.Status.HasValue && status.Contains(second.Status.Value))
+            {
+                var bodyDynamic = _agworkloadsourceRepository.GetEntities(t => loadEmployees.Select(w => w.Id).Contains(t.BodyId));
+
+                foreach (var employee in loadEmployees)
+                {
+                    var dict = JsonHelper.Deserialize<Dictionary<string, object>>(JsonHelper.Serialize(employee));
+                    if (bodyDynamic != null && bodyDynamic.Any(t => t.BodyId == employee.Id))
+                    {
+                        foreach (var col in bodyDynamic.Where(t => t.BodyId == employee.Id))
+                        {
+                            dict.AddOrUpdate(col.ItemId, col.Value);
+                        }
+                    }
+                    result.Add(dict);
+                }
+            }
+            // 未提交
+            else
+            {
+                var bodyDynamic = _agworkloadsourceRepository.GetEntities(t => loadEmployees.Select(w => w.Id).Contains(t.BodyId));
+                var workloads = _agworkloadRepository.GetEntities(t => t.HospitalId == allot.HospitalId && t.Department == second.Department && t.UnitType == second.UnitType);
+
+                if (workloads != null && workloads.Any())
+                {
+                    /* isSave 为True时，没必要查询数据 */
+                    var secondWorkload = isSave
+                        ? new List<view_second_workload_result>()
+                        : GetSecondWorkloadByValue(second.AllotId.Value, second.UnitType, second.Department);
+
+                    foreach (var employee in loadEmployees)
+                    {
+                        var dict = JsonHelper.Deserialize<Dictionary<string, object>>(JsonHelper.Serialize(employee));
+                        foreach (var workitem in workloads)
+                        {
+                            /* 如果是已保存数据，则加载原始数据，否则加载工作量自动带出 */
+                            var value = isSave
+                                ? bodyDynamic?.FirstOrDefault(w => w.BodyId == employee.Id && w.WorkloadId == workitem.Id)?.Value
+                                : secondWorkload.FirstOrDefault(w => w.PersonnelNumber == employee.WorkNumber && w.DoctorName == employee.Name && workitem.ItemId.EqualsIgnoreCase(w.ItemId))?.Value;
+
+                            dict.AddOrUpdate(workitem.ItemId, value);
+                        }
+                        result.Add(dict);
+                    }
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// 顶部信息加载
+        /// </summary>
+        /// <param name="computeMode"></param>
+        /// <param name="second"></param>
+        /// <param name="allot"></param>
+        /// <returns></returns>
+        private Dictionary<string, object> LoadHead(ComputeMode computeMode, per_allot allot, ag_secondallot second)
+        {
+            /*
+             此处数据需要额外注意，前端显示规则：接口返回则显示
+             避免额外返回造成前端错误显示
+             */
+            var head = new Dictionary<string, object>();
+            // 公共顶部信息
+            head.AddOrUpdate(nameof(second.Department), second.Department);
+            head.AddOrUpdate(nameof(second.UnitType), second.UnitType);
+            head.AddOrUpdate(nameof(ComputeMode), computeMode);
+            head.AddOrUpdate("ComputeModeDescription", EnumHelper.GetDescription(computeMode));
+
+            head.AddOrUpdate(nameof(ag_headsource.SecondId), second.Id);
+            head.AddOrUpdate(nameof(ag_headsource.PaymentOfTheMonth), $"{allot.Year}年{allot.Month.ToString().PadLeft(2, '0')}月");
+            head.AddOrUpdate(nameof(ag_headsource.TotalDistPerformance), (allot.States == (int)AllotStates.GenerateSucceed) ? (second.RealGiveFee ?? 0) : 1000);
+            head.AddOrUpdate(nameof(ag_headsource.NightShiftWorkPerforTotal), (allot.States == (int)AllotStates.GenerateSucceed) ? (second.NightShiftWorkPerforFee ?? 0) : 0);
+            head.AddOrUpdate(nameof(ag_headsource.TotalPerformance), head.GetDecimal(nameof(ag_headsource.TotalDistPerformance)) - head.GetDecimal(nameof(ag_headsource.NightShiftWorkPerforTotal)));
+            head.AddOrUpdate("Remark", (allot.States == (int)AllotStates.GenerateSucceed) ? "" : "(非正式)");
+            // 横向 纵向 特有顶部信息
+            if (computeMode != ComputeMode.NotCalculate)
+            {
+                var history = _agheadsourceRepository.GetEntity(t => t.SecondId == second.Id);
+
+                head.AddOrUpdate(nameof(ag_headsource.SeniorityTitlesAccountedPerformance), history?.SeniorityTitlesAccountedPerformance ?? 0.2m);
+                head.AddOrUpdate(nameof(ag_headsource.Workload_Ratio_Default), history?.Workload_Ratio_Default ?? 0.8m);
+                head.AddOrUpdate(nameof(ag_headsource.DaysFullAttendance), history?.DaysFullAttendance ?? DateTime.DaysInMonth(allot.Year, allot.Month));
+
+                // 多工作量加载
+                var status = (new int[] { (int)SecondAllotStatus.WaitReview, (int)SecondAllotStatus.PassAudit });
+                var headDynamic = _agworktypesourceRepository.GetEntities(t => t.SecondId == second.Id) ?? new List<ag_worktype_source>();
+                // 已提交
+                if (second.Status.HasValue && status.Contains(second.Status.Value))
+                {
+                    foreach (var item in headDynamic.Where(w => w.FieldId.StartsWithIgnoreCase("Workload_Ratio_")).OrderBy(t => t.Id))
+                    {
+                        head.AddOrUpdate(item.FieldId, item.Value ?? 0);
+                    }
+                }
+                // 未提交
+                else
+                {
+                    List<decimal> ratios = new List<decimal>();
+                    var workloadTypes = _agworkloadtypeRepository
+                        .GetEntities(t => t.HospitalId == allot.HospitalId && t.Department == second.Department && t.UnitType == second.UnitType) ?? new List<ag_workload_type>();
+                    foreach (var workitem in workloadTypes)
+                    {
+                        var name = $"Workload_Ratio_{workitem.Id}";
+                        var ratio = headDynamic.FirstOrDefault(w => w.FieldId.EqualsIgnoreCase(name))?.Value ?? 0m;
+                        ratios.Add(ratio);
+                        head.AddOrUpdate(name, ratio);
+                    }
+                    // 强制年资系数及工作量系数合计 等于 1
+                    var seniorityTitlesAccountedPerformance = head.GetDecimal(nameof(ag_headsource.SeniorityTitlesAccountedPerformance));
+                    var defaultWorkload = 1 - seniorityTitlesAccountedPerformance - ratios.Sum();
+                    head.AddOrUpdate(nameof(ag_headsource.Workload_Ratio_Default), defaultWorkload);
+                }
+            }
+            return head;
+        }
+
+        /// <summary>
+        /// 按指定方式加载人员数据
+        /// </summary>
+        /// <param name="secondId"></param>
+        /// <param name="mode"></param>
+        /// <returns></returns>
+        private List<ag_bodysource> LoadEmployees(per_allot allot, ag_secondallot second, EmployeeSource mode, out bool isSave)
+        {
+            var employees = _peremployeeRepository.GetEntities(w => w.AllotId == second.AllotId);
+            isSave = false;
+            // 默认流程
+            if (mode == EmployeeSource.Initial)
+            {
+                var saveDatas = _agbodysourceRepository.GetEntities(w => w.SecondId == second.Id);
+                isSave = (saveDatas != null && saveDatas.Count > 0);
+                // 数据带出顺序 1 已保存 2 上次 3 科室字典(或EXCEL行政工勤)
+                if (isSave) return saveDatas;
+
+                var prevSecond = LoadEmployees_PrevSecondAllot(allot, second);
+                List<string> numbers = prevSecond?.Where(w => !string.IsNullOrEmpty(w.WorkNumber)).Select(w => w.WorkNumber).ToList() ?? new List<string>();
+
+                // 如果行政工勤科室没有保存数据，则默认从EXCEL中带出数据
+                if (UnitTypeUtil.IsOffice(second.UnitType) && (numbers == null || numbers.Count == 0))
+                    numbers = LoadEmployees_OfficeExcel(second);
+
+                if (numbers == null || numbers.Count == 0)
+                    numbers = LoadEmployees_EmployeeDict(second, employees);
+
+                return LoadEmployeeByDictionary(second, employees, numbers, prevSecond);
+            }
+            // 用户指定加载
+            else
+            {
+                var prevSecond = LoadEmployees_PrevSecondAllot(allot, second);
+
+                List<string> numbers = new List<string>();
+                if (mode == EmployeeSource.PrevSecondAllot)
+                    numbers = prevSecond?.Where(w => !string.IsNullOrEmpty(w.WorkNumber)).Select(w => w.WorkNumber).ToList() ?? new List<string>();
+                // 如果行政工勤科室则默认从EXCEL中带出数据 
+                else if (mode == EmployeeSource.EmployeeDict && UnitTypeUtil.IsOffice(second.UnitType))
+                    numbers = LoadEmployees_OfficeExcel(second);
+                else if (mode == EmployeeSource.EmployeeDict)
+                    numbers = LoadEmployees_EmployeeDict(second, employees);
+
+                if (numbers == null || numbers.Count == 0)
+                    return new List<ag_bodysource>();
+
+                return LoadEmployeeByDictionary(second, employees, numbers, prevSecond);
+            }
+        }
+
+        /// <summary>
+        /// 补全信息，带出上次系数
+        /// </summary>
+        /// <param name="second"></param>
+        /// <param name="employees"></param>
+        /// <param name="numbers"></param>
+        /// <param name="prevSecond"></param>
+        /// <returns></returns>
+        List<ag_bodysource> LoadEmployeeByDictionary(ag_secondallot second, List<per_employee> employees, List<string> numbers, List<ag_bodysource> prevSecond = null)
+        {
+            List<ag_bodysource> loadDatas = new List<ag_bodysource>();
+            foreach (var personnelNumber in numbers)
+            {
+                var existEmp = employees.FirstOrDefault(w => w.PersonnelNumber?.Trim() == personnelNumber?.Trim());
+                if (existEmp == null)
+                    continue;
+
+                var data = new ag_bodysource
+                {
+                    SecondId = second.Id,
+                    Department = existEmp.AccountingUnit,
+                    WorkNumber = existEmp.PersonnelNumber,
+                    Name = existEmp.DoctorName,
+                    JobTitle = existEmp.JobTitle,
+                    ReservedRatio = existEmp.ReservedRatio,
+                    Post = "",
+                };
+                // 带出上次 人员系数、职称系数
+                if (prevSecond != null)
+                {
+                    data.StaffCoefficient = prevSecond.FirstOrDefault(w => w.WorkNumber == data.WorkNumber)?.StaffCoefficient ?? data.StaffCoefficient;
+                    data.TitleCoefficient = prevSecond.FirstOrDefault(w => w.WorkNumber == data.WorkNumber)?.TitleCoefficient ?? data.TitleCoefficient;
+                }
+
+                loadDatas.Add(data);
+            }
+            return loadDatas;
+        }
+
+        /// <summary>
+        /// 上次绩效数据
+        /// </summary>
+        /// <param name="allot"></param>
+        /// <param name="second"></param>
+        /// <returns></returns>
+        private List<ag_bodysource> LoadEmployees_PrevSecondAllot(per_allot allot, ag_secondallot second)
+        {
+            List<ag_bodysource> numbers = new List<ag_bodysource>();
+            // 上次二次分配分三种情况，1.其他来源 2.单工作量 3.多工作量
+            var prevSecondAllot = _secondAllotDetails.GetPreviousSecondAllot(allot.HospitalId, second);
+            var status = new int[] { (int)SecondAllotStatus.WaitReview, (int)SecondAllotStatus.PassAudit };
+            if (prevSecondAllot != null && status.Contains(prevSecondAllot.Status ?? (int)SecondAllotStatus.Uncommitted))
+            {
+                if (prevSecondAllot.UseTempId == 6)
+                {
+                    var prevDatas = _agothersourceRepository.GetEntities(w => w.SecondId == prevSecondAllot.Id);
+                    numbers = prevDatas
+                        ?.Where(pre => !string.IsNullOrEmpty(pre.WorkNumber?.Trim()))
+                        .Select(pre => new ag_bodysource { WorkNumber = pre.WorkNumber?.Trim() })
+                        .Distinct().ToList() ?? new List<ag_bodysource>();
+                }
+                else if (prevSecondAllot.UseTempId == 7 || prevSecondAllot.UseTempId == 8)
+                {
+                    var prevDatas = _agfixatitemRepository
+                        .GetEntities(w => w.SecondId == prevSecondAllot.Id && w.RowNumber.HasValue && w.RowNumber > -1 && w.Type == (int)TempColumnType.TableFixedColumns);
+
+                    numbers = prevDatas
+                        ?.GroupBy(w => w.RowNumber.Value)
+                        .Select(row =>
+                            new ag_bodysource
+                            {
+                                WorkNumber = row.FirstOrDefault(w => w.ItemName == "人员工号")?.ItemValue,
+                                TitleCoefficient = ConvertHelper.To<decimal?>(row.FirstOrDefault(w => w.ItemName == "职称系数")?.ItemValue),
+                                StaffCoefficient = ConvertHelper.To<decimal?>(row.FirstOrDefault(w => w.ItemName == "人员系数")?.ItemValue),
+                            })
+                        .Distinct().ToList() ?? new List<ag_bodysource>();
+
+                }
+                else
+                {
+                    var prevDatas = _agbodysourceRepository.GetEntities(w => w.SecondId == prevSecondAllot.Id);
+                    numbers = prevDatas
+                        ?.Where(pre => !string.IsNullOrEmpty(pre.WorkNumber?.Trim()))
+                        .Select(pre =>
+                            new ag_bodysource
+                            {
+                                WorkNumber = pre.WorkNumber,
+                                TitleCoefficient = pre.TitleCoefficient,
+                                StaffCoefficient = pre.StaffCoefficient
+                            })
+                        .Distinct().ToList() ?? new List<ag_bodysource>();
+                }
+            }
+            return numbers;
+        }
+
+        /// <summary>
+        /// 从人员字典带出
+        /// </summary>
+        /// <param name="second"></param>
+        /// <param name="dicEmployees"></param>
+        /// <returns></returns>
+        private List<string> LoadEmployees_EmployeeDict(ag_secondallot second, List<per_employee> dicEmployees)
+        {
+            var employees = dicEmployees
+                ?.Where(w => w.UnitType == second.UnitType && w.AccountingUnit == second.Department)
+                .Select(emp => emp.PersonnelNumber?.Trim())
+                .Distinct().ToList() ?? new List<string>();
+            return employees;
+        }
+
+        /// <summary>
+        /// 从测算表带出
+        /// </summary>
+        /// <param name="second"></param>
+        /// <returns></returns>
+        private List<string> LoadEmployees_OfficeExcel(ag_secondallot second)
+        {
+            List<string> numbers = new List<string>();
+
+            var employees = _imemployeelogisticsRepository.GetEntities(w => w.AllotID == second.AllotId && w.AccountingUnit == second.Department);
+            if (employees != null)
+                numbers = employees.Select(w => w.PersonnelNumber).ToList();
+
+            return numbers;
+        }
+
+        #region 动态生成列头信息
+        /// <summary>
+        /// 动态生成列头信息
+        /// </summary>
+        /// <param name="computeMode"></param>
+        /// <param name="loads"></param>
+        /// <returns></returns>
+        private (List<string> colHeaderCustoms, List<HandsonColumn> columnCustoms) GetCustomColumns(ComputeMode computeMode, List<TitleValue<string, decimal?>> loads)
+        {
+            var colHeaderCustoms = new List<string>();
+            var columnCustoms = new List<HandsonColumn>();
+            // 工作量
+            if (computeMode == ComputeMode.Horizontal || computeMode == ComputeMode.Vertical)
+            {
+                var keys = loads.Where(w => w.Title.StartsWithIgnoreCase("AssessmentScore_")).Select(w => w.Title.Replace("AssessmentScore_", "")).Distinct();
+                foreach (var key in keys)
+                {
+                    if (loads.Any(w => w.Title.StartsWithIgnoreCase($"Workload_{key}_")))
+                    {
+                        foreach (var item in loads.Where(w => w.Title.EqualsIgnoreCase($"AssessmentScore_{key}") || w.Title.StartsWithIgnoreCase($"Workload_{key}_")))
+                        {
+                            colHeaderCustoms.Add(item.Value);
+                            columnCustoms.Add(new HandsonColumn(item.Title.ToLower(), format: DataFormat.小数));
+                        }
+                    }
+                }
+            }
+            // 单项奖励 
+            foreach (var awards in loads.Where(w => w.Title.StartsWithIgnoreCase("SingleAwards_")))
+            {
+                colHeaderCustoms.Add(awards.Value);
+                columnCustoms.Add(new HandsonColumn(awards.Title.ToLower(), format: DataFormat.小数));
+            }
+
+            return (colHeaderCustoms, columnCustoms);
+        }
+        #endregion
+
+        #region 获取工作量及单项奖励
+        /// <summary>
+        /// 获取工作量及单项奖励
+        /// </summary> 
+        /// <param name="hospitalId"></param>
+        /// <param name="unitType"></param>
+        /// <param name="accountingUnit"></param> 
+        /// <returns></returns>
+        public List<TitleValue<string, decimal?>> GetWorkLoads(int hospitalId, string unitType, string accountingUnit)
+        {
+            var workloads = _agworkloadRepository.GetEntities(t => t.HospitalId == hospitalId && t.Department == accountingUnit && t.UnitType == unitType) ?? new List<ag_workload>();
+            var loads = workloads
+                .OrderBy(t => t.WorkTypeId).ThenBy(t => t.Sort)
+                .Select(t => new TitleValue<string, decimal?> { Title = t.ItemId, Value = t.ItemName, State = t.FactorValue })
+                .ToList();
+
+            return loads;
+        }
+        #endregion
+
+        #region 三种计算对应的格式
+        /// <summary>
+        /// 格式生成，不计算，手动录入
+        /// </summary>
+        /// <param name="colHeaders"></param>
+        /// <param name="columns"></param>
+        /// <returns></returns>
+        private HandsonTableBase ComputeMode_Format1(List<string> colHeaders, List<HandsonColumn> columns)
+        {
+            HandsonTableBase handson = new HandsonTableBase();
+            handson.ColHeaders.AddRange(new string[] { "工号", "姓名",/* "核算单元", "领取平均绩效",*/ "职称绩效", "工作量绩效工资", });
+            handson.Columns.AddRange(
+                new HandsonColumn[]
+                {
+                    new HandsonColumn(nameof(ag_bodysource.WorkNumber).ToLower()),
+                    new HandsonColumn(nameof(ag_bodysource.Name).ToLower()),
+                    //new HandsonColumn(nameof(ag_bodysource.Department).ToLower()),
+                    new HandsonColumn(nameof(ag_bodysource.TitlePerformance).ToLower(), format: DataFormat.小数),
+                    new HandsonColumn(nameof(ag_bodysource.WorkPerformance).ToLower(), format: DataFormat.小数),
+                });
+
+            handson.ColHeaders.AddRange(colHeaders);
+            handson.Columns.AddRange(columns);
+
+            handson.ColHeaders.AddRange(new string[] { "夜班绩效", });
+            handson.Columns.AddRange(new HandsonColumn[] { new HandsonColumn(nameof(ag_bodysource.NightWorkPerformance).ToLower(), format: DataFormat.小数), });
+
+            return handson;
+        }
+        /// <summary>
+        /// 格式生成，横向计算，不使用系数
+        /// </summary>
+        /// <param name="colHeaders"></param>
+        /// <param name="columns"></param>
+        /// <returns></returns>
+        private HandsonTableBase ComputeMode_Format2(List<string> colHeaders, List<HandsonColumn> columns)
+        {
+            HandsonTableBase handson = new HandsonTableBase();
+            handson.ColHeaders.AddRange(new string[] { "工号", "姓名", /*"核算单元",*/ "领取平均绩效", "人员系数", "出勤", "职称", "职称系数", });
+            handson.Columns.AddRange(
+                new HandsonColumn[]
+                {
+                    new HandsonColumn(nameof(ag_bodysource.WorkNumber).ToLower()),
+                    new HandsonColumn(nameof(ag_bodysource.Name).ToLower()),
+                    //new HandsonColumn(nameof(ag_bodysource.Department).ToLower()),
+                    new HandsonColumn(nameof(ag_bodysource.Post).ToLower()){ Type = "autocomplete", Strict = true, Source = new string[] { "是", "否"} },
+                    new HandsonColumn(nameof(ag_bodysource.StaffCoefficient).ToLower(), format: DataFormat.小数),
+                    new HandsonColumn(nameof(ag_bodysource.ActualAttendance).ToLower(), format: DataFormat.小数1),
+                    new HandsonColumn(nameof(ag_bodysource.JobTitle).ToLower()),
+                    new HandsonColumn(nameof(ag_bodysource.TitleCoefficient).ToLower(), format: DataFormat.小数),
+                });
+
+            handson.ColHeaders.AddRange(colHeaders);
+            handson.Columns.AddRange(columns);
+
+            handson.ColHeaders.AddRange(new string[] { "夜班绩效", });
+            handson.Columns.AddRange(new HandsonColumn[] { new HandsonColumn(nameof(ag_bodysource.NightWorkPerformance).ToLower(), format: DataFormat.小数), });
+
+            return handson;
+        }
+
+        /// <summary>
+        /// 格式生成，纵向计算，使用系数计算
+        /// </summary>
+        /// <param name="colHeaders"></param>
+        /// <param name="columns"></param>
+        /// <param name="loads"></param>
+        /// <returns></returns>
+        private HandsonTableBase ComputeMode_Format3(List<string> colHeaders, List<HandsonColumn> columns, IEnumerable<TitleValue<string, decimal?>> loads)
+        {
+            HandsonTableBase handson = ComputeMode_Format2(colHeaders, columns);
+
+            var fs = handson.Columns.Select(col =>
+            {
+                var f = loads.FirstOrDefault(w => w.Title.StartsWithIgnoreCase($"Workload_") && w.Title.EqualsIgnoreCase(col.Data));
+                return f == null ? "" : (f.State ?? 0).ToString("0.####"); ;
+            });
+
+            handson.NestedHeadersArray.Add(handson.ColHeaders);
+            handson.NestedHeadersArray.Add(fs.ToList());
+
+            return handson;
+        }
+        #endregion
+
+        #endregion
+
+        #region 补充医院其他绩效
+
+        /// <summary>
+        /// 补充医院其他绩效
+        /// </summary>
+        /// <param name="second"></param>
+        /// <param name="rows"></param>
+        public void SupplementOtherPerfor(ag_secondallot second, List<Dictionary<string, object>> rows)
+        {
+            if (rows == null || rows.Count == 0)
+                return;
+
+            var perapramounts = _perapramountRepository
+                .GetFullAmount(t => t.AllotId == second.AllotId && t.Status == 3);
+
+            if (perapramounts == null || !perapramounts.Any())
+                return;
+
+            foreach (var row in rows)
+            {
+                var personnelNumber = row.GetString(nameof(ag_bodysource.WorkNumber));
+                var amounts = perapramounts.Where(w => w.PersonnelNumber?.Trim() == personnelNumber?.Trim());
+                row.AddOrUpdate(nameof(ag_bodysource.OtherPerformance), amounts.Sum(w => w.Amount ?? 0));
+            }
+
+            // 补充字典中该科室不存在，但有其它绩效的人员信息
+            var groupDatas = perapramounts
+                .Where(t => t.UnitType == second.UnitType && t.AccountingUnit == second.Department)
+                .GroupBy(w => new { PersonnelNumber = w.PersonnelNumber, DoctorName = w.DoctorName, AccountingUnit = w.AccountingUnit, UnitType = w.UnitType, });
+            foreach (var item in groupDatas)
+            {
+                if (!rows.Any(row => row.GetString(nameof(ag_bodysource.WorkNumber)) == item.Key.PersonnelNumber))
+                {
+                    rows.Add(new Dictionary<string, object>
+                    {
+                        { nameof(ag_bodysource.SecondId), second.Id },
+                        { nameof(ag_bodysource.WorkNumber), item.Key.PersonnelNumber },
+                        { nameof(ag_bodysource.Name), item.Key.DoctorName },
+                        { nameof(ag_bodysource.Department), item.Key.AccountingUnit },
+                        { nameof(ag_bodysource.OtherPerformance), item.Sum(w => w.Amount )},
+                    });
+                }
+            }
+        }
+        #endregion
+
+        #region 重算顶部医院其他绩效
+        /// <summary>
+        /// 计算顶部相关总和>>医院其他绩效(比较特殊，仅用作展示，所以需要重新计算一次)
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        private void otherPerformance(Dictionary<string, object> head, List<Dictionary<string, object>> rows)
+        {
+            //医院其他绩效总和
+            var otherPerformance = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.OtherPerformance)));
+            head.AddOrUpdate(nameof(ag_headsource.HosOtherPerformance), otherPerformance);
+        }
+        #endregion
+
+        #region 计算
+        /// <summary>
+        /// 分配结果结果计算
+        /// </summary>
+        /// <param name="computeMode"></param>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="loads"></param>
+        /// <param name="workloadGroups"></param>
+        public void ResultCompute(ComputeMode computeMode, Dictionary<string, object> head, List<Dictionary<string, object>> rows, List<TitleValue<string, decimal?>> loads, List<SecondWorkLoadDto> workloadGroups)
+        {
+            var specialPostName = new string[] { "科主任/护士长", "主任", "是", };
+
+            if (computeMode == ComputeMode.NotCalculate)
+            {
+                // 清空无效数据
+                clearPerformanceWorkload(rows, workloadGroups);
+                // 行内可分配绩效
+                distPerformanceCalculate(rows);
+                // 行内实发绩效
+                realAmountCalculate(rows);
+            }
+            else if (computeMode == ComputeMode.Horizontal || computeMode == ComputeMode.Vertical)
+            {
+                // 行内计算单项奖励
+                deptRewardCalculate(rows);
+                // 计算顶部相关总和
+                overviewCalculate(head, rows);
+                // 行内主任基础绩效
+                basisPerformanceCalculate(head, rows, specialPostName);
+                // 计算顶部相关总和(重算一遍，为了保证减去 主任基础绩效)
+                overviewCalculate(head, rows);
+                // 计算顶部工作量
+                topWorkloadCalculate(head, workloadGroups);
+                // 计算顶部年资系数
+                topSeniorityCalculate(head);
+                // 行内职称绩效计算
+                titleCoefficientCalculate(head, rows, specialPostName);
+                // 行内工作量分组计算
+                workloadCalculate(head, rows, computeMode, loads, workloadGroups, specialPostName);
+                // 行内可分配绩效
+                distPerformanceCalculate(rows);
+                // 差额从主任或第一个人身上扣除
+                balanceTotalDistPerformance(head, rows, specialPostName);
+                // 行内实发绩效
+                realAmountCalculate(rows);
+            }
+        }
+
+        /// <summary>
+        /// 重算顶部医院其他绩效、重算行内实发绩效、重算顶部工作量
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        public void RedistributionCompute(ComputeMode computeMode, Dictionary<string, object> head, List<Dictionary<string, object>> rows)
+        {
+            // 重算顶部医院其他绩效
+            otherPerformance(head, rows);
+            // 重算行内实发绩效
+            realAmountCalculate(rows);
+        }
+
+        /// <summary>
+        /// ComputeMode.NotCalculate 不计算时，清空无效数据
+        /// </summary>
+        /// <param name="rows"></param>
+        /// <param name="workloadGroups"></param>
+        private void clearPerformanceWorkload(List<Dictionary<string, object>> rows, List<SecondWorkLoadDto> workloadGroups)
+        {
+            foreach (var row in rows)
+            {
+                foreach (var workload in workloadGroups)
+                {
+                    row.AddOrUpdate(workload.WorkloadScore, 0m);
+                    row.AddOrUpdate(workload.AssessmentScore, 0m);
+                    row.AddOrUpdate(workload.WorkPerformance, 0m);
+
+                    foreach (var item in workload.Items)
+                    {
+                        row.AddOrUpdate(item, 0m);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// 行内计算单项奖励
+        /// </summary>
+        /// <param name="rows"></param>
+        private void deptRewardCalculate(List<Dictionary<string, object>> rows)
+        {
+            foreach (var row in rows)
+            {
+                decimal total_deptReward = row.Where(w => w.Key.StartsWithIgnoreCase("SingleAwards_")).Sum(r => GetDecimal2(row, r.Key));
+                row.AddOrUpdate(nameof(ag_bodysource.DeptReward), total_deptReward);
+            }
+        }
+        /// <summary>
+        /// 计算顶部工作量
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="workloadGroups"></param>
+        private void topWorkloadCalculate(Dictionary<string, object> head, List<SecondWorkLoadDto> workloadGroups)
+        {
+            foreach (var workload in workloadGroups)
+            {
+                var amount = GetDecimal2(head.GetDecimal(nameof(ag_headsource.TheTotalAllocationOfPerformanceResults)) * head.GetDecimal($"Workload_Ratio_{workload.Name}"));
+                head.AddOrUpdate($"Workload_Amount_{workload.Name}", amount);
+            }
+        }
+        /// <summary>
+        /// 计算顶部年资系数
+        /// </summary>
+        /// <param name="head"></param>
+        private void topSeniorityCalculate(Dictionary<string, object> head)
+        {
+            var amount = GetDecimal2(head.GetDecimal(nameof(ag_headsource.SeniorityTitlesAccountedPerformance)) * head.GetDecimal(nameof(ag_headsource.TheTotalAllocationOfPerformanceResults)));
+            head.AddOrUpdate(nameof(ag_headsource.SeniorityTitlesPerformance), amount);
+        }
+
+        /// <summary>
+        /// 计算顶部相关总和
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        private void overviewCalculate(Dictionary<string, object> head, List<Dictionary<string, object>> rows)
+        {
+            //// 夜班工作量绩效总和
+            //var nightShiftWorkPerforTotal = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.NightWorkPerformance)));
+            //head.AddOrUpdate(nameof(ag_headsource.NightShiftWorkPerforTotal), nightShiftWorkPerforTotal);
+            // 可分配绩效（顶栏） = 科室总绩效  - 夜班绩效（顶栏）
+            var totalPerformance = GetDecimal2(head, nameof(ag_headsource.TotalDistPerformance)) - GetDecimal2(head, nameof(ag_headsource.NightShiftWorkPerforTotal));
+            head.AddOrUpdate(nameof(ag_headsource.TotalPerformance), totalPerformance);
+            //// 医院其他绩效总和
+            //var otherPerformance = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.OtherPerformance)));
+            //head.AddOrUpdate(nameof(ag_headsource.HosOtherPerformance), otherPerformance);
+            //科室核算人数 = 人员系数 * 实际出勤
+            var daysFullAttendance = GetDecimal2(head, nameof(ag_headsource.DaysFullAttendance));
+            var theNumberOfAccountingDepartment = daysFullAttendance == 0 ? 0m : rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.StaffCoefficient)) * GetDecimal2(row, nameof(ag_bodysource.ActualAttendance)) / daysFullAttendance);
+            head.AddOrUpdate(nameof(ag_headsource.TheNumberOfAccountingDepartment), theNumberOfAccountingDepartment);
+            // 科室人均 = 可分配绩效 / 科室核算人数
+            var departmentsPerCapita = theNumberOfAccountingDepartment == 0 ? 0m : GetDecimal2(totalPerformance / theNumberOfAccountingDepartment);
+            head.AddOrUpdate(nameof(ag_headsource.DepartmentsPerCapita), departmentsPerCapita);
+            // 科室单项奖励
+            var totalDeptReward = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.DeptReward)));
+            head.AddOrUpdate(nameof(ag_headsource.TotalDeptReward), totalDeptReward);
+            // 主任基础绩效(顶部) =  行内主任基础绩效总和
+            var directorBasisPerformance = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.BasisPerformance)));
+            head.AddOrUpdate(nameof(ag_headsource.DirectorBasisPerformance), directorBasisPerformance);
+            // 业绩分配绩效总额 = 可分配绩效 - 科主任或护士长基础绩效 - 科室单项奖励
+            var theTotalAllocationOfPerformanceResults = totalPerformance - directorBasisPerformance - totalDeptReward;
+            head.AddOrUpdate(nameof(ag_headsource.TheTotalAllocationOfPerformanceResults), theTotalAllocationOfPerformanceResults);
+        }
+
+        /// <summary>
+        /// 行内主任基础绩效
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="specialPostName"></param>
+        private void basisPerformanceCalculate(Dictionary<string, object> head, List<Dictionary<string, object>> rows, string[] specialPostName)
+        {
+            foreach (var row in rows)
+            {
+                // 除 科主任/护士长 以外人员没有 主任基础绩效
+                // 当前行主任基础绩效  =  科室人均 * 当前行人员系数 * 当前行人员出勤/满勤天数
+                var post = row.GetString(nameof(ag_bodysource.Post));
+                if (specialPostName.Contains(post))
+                {
+                    var daysFullAttendance = GetDecimal2(head, nameof(ag_headsource.DaysFullAttendance));
+                    var departmentsPerCapita = GetDecimal2(head, nameof(ag_headsource.DepartmentsPerCapita));
+                    var staffCoefficient = GetDecimal2(row, nameof(ag_bodysource.StaffCoefficient));
+                    var actualAttendance = GetDecimal2(row, nameof(ag_bodysource.ActualAttendance));
+
+                    var basisPerformance = daysFullAttendance == 0 ? 0 : departmentsPerCapita * staffCoefficient * actualAttendance / daysFullAttendance;
+                    row.AddOrUpdate(nameof(ag_bodysource.BasisPerformance), basisPerformance);
+                }
+                else
+                {
+                    row.AddOrUpdate(nameof(ag_bodysource.BasisPerformance), 0m);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 行内职称绩效计算
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="specialPostName"></param>
+        private void titleCoefficientCalculate(Dictionary<string, object> head, List<Dictionary<string, object>> rows, string[] specialPostName)
+        {
+            var total_titleCoefficient = 0m;
+            foreach (var row in rows)
+            {
+                var post = row.GetString(nameof(ag_bodysource.Post));
+                if (!specialPostName.Contains(post))
+                    total_titleCoefficient += GetDecimal2(row, nameof(ag_bodysource.ActualAttendance)) * GetDecimal2(row, nameof(ag_bodysource.TitleCoefficient));
+            }
+
+            var seniorityTitlesPerformance = GetDecimal2(head, nameof(ag_headsource.SeniorityTitlesPerformance));
+            foreach (var row in rows)
+            {
+                var post = row.GetString(nameof(ag_bodysource.Post));
+                // 科主任/护士长 不参与职称绩效考核
+                if (specialPostName.Contains(post))
+                    row.AddOrUpdate(nameof(ag_bodysource.TitleCoefficient), 0m);
+                // 职称得分 = 当前行实际出勤 * 当前行职称系数
+                var titlePerformanceScore = GetDecimal2(row, nameof(ag_bodysource.ActualAttendance)) * GetDecimal2(row, nameof(ag_bodysource.TitleCoefficient));
+                row.AddOrUpdate(nameof(ag_bodysource.TitlePerformanceScore), GetDecimal2(titlePerformanceScore));
+                //个人职称绩效 =  ( 当前行实际出勤 * 当前行职称系数 ) / 职称系数总和* 年资职称绩效总和
+                var titlePerformance = total_titleCoefficient == 0 ? 0 : titlePerformanceScore / total_titleCoefficient * seniorityTitlesPerformance;
+                row.AddOrUpdate(nameof(ag_bodysource.TitlePerformance), GetDecimal2(titlePerformance));
+            }
+        }
+        /// <summary>
+        /// 行内工作量分组计算
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="computeMode"></param>
+        /// <param name="loads"></param>
+        /// <param name="workloadGroups"></param>
+        /// <param name="specialPostName"></param>
+        private void workloadCalculate(Dictionary<string, object> head, List<Dictionary<string, object>> rows, ComputeMode computeMode,
+            List<TitleValue<string, decimal?>> loads, List<SecondWorkLoadDto> workloadGroups, string[] specialPostName)
+        {
+            // 计算方式：1 不计算 2 横向计算 3 纵向计算
+            foreach (var row in rows)
+            {
+                foreach (var gp in workloadGroups)
+                {
+                    var workload_score = 0m;
+
+                    // 计算方式：1 不计算 2 横向计算 3 纵向计算 
+                    switch (computeMode)
+                    {
+                        case ComputeMode.Horizontal:
+                            workload_score = ComputeMode_2(row, gp, specialPostName);
+                            break;
+                        case ComputeMode.Vertical:
+                            workload_score = ComputeMode_3(row, loads, gp, specialPostName);
+                            break;
+                    }
+                    // 工作量得分
+                    row.AddOrUpdate(gp.WorkloadScore, GetDecimal2(workload_score));
+                }
+            }
+            // 工作量每分价格计算
+            foreach (var gp in workloadGroups)
+            {
+                // 汇总行内工作量总得分
+                var total_score = rows.Sum(row => GetDecimal2(row, gp.WorkloadScore) * GetDecimal2(row, gp.AssessmentScore));
+                // 计算每分价格
+                gp.Unit_Price = total_score == 0 ? 0 : head.GetDecimal($"Workload_Amount_{gp.Name}") / total_score;
+            }
+            // 行内工作量绩效计算
+            foreach (var row in rows)
+            {
+                var workPerformance = 0m;
+                var post = row.GetString(nameof(ag_bodysource.Post));
+                foreach (var gp in workloadGroups)
+                {
+                    // 科主任/护士长 不参与工作量考核
+                    if (specialPostName.Contains(post))
+                    {
+                        row.AddOrUpdate(gp.WorkloadScore, 0m);
+                        row.AddOrUpdate(gp.AssessmentScore, 0m);
+                    }
+                    // 工作量绩效 = 工作量得分 * 每分价格 * 考核得分
+                    var workload_fee = GetDecimal2(row.GetDecimal(gp.WorkloadScore) * gp.Unit_Price * row.GetDecimal(gp.AssessmentScore));
+                    row.AddOrUpdate(gp.WorkPerformance, workload_fee);
+                    workPerformance += workload_fee;
+                }
+                // 行内工作量汇总到一起
+                row.AddOrUpdate(nameof(ag_bodysource.WorkPerformance), workPerformance);
+            }
+        }
+
+        #region 行内工作量 辅助计算
+        /// <summary>
+        /// 获取系数
+        /// </summary>
+        /// <param name="workloads"></param>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        decimal getFactorValue(List<TitleValue<string, decimal?>> workloads, string item) => workloads.FirstOrDefault((w) => w.Title == item)?.State ?? 0m;
+
+        /// <summary>
+        /// 3 纵向计算 
+        /// </summary>
+        /// <param name="row"></param>
+        /// <param name="loads"></param>
+        /// <param name="gp"></param>
+        /// <param name="specialPostName"></param>
+        /// <returns></returns>
+        decimal ComputeMode_3(Dictionary<string, object> row, List<TitleValue<string, decimal?>> loads, SecondWorkLoadDto gp, string[] specialPostName)
+        {
+            var post = row.GetString(nameof(ag_bodysource.Post));
+            var workload_score = gp.Items.Sum((item) =>
+            {
+                // 科主任/护士长 不参与工作量考核
+                if (specialPostName.Contains(post))
+                    row.AddOrUpdate(item.ToLower(), 0);
+                return GetDecimal2(row.GetDecimal(item.ToLower()) * getFactorValue(loads, item));
+            });
+            return workload_score;
+        }
+
+        /// <summary>
+        /// 2 横向计算
+        /// </summary>
+        /// <param name="row"></param>
+        /// <param name="gp"></param>
+        /// <param name="specialPostName"></param>
+        /// <returns></returns>
+        decimal ComputeMode_2(Dictionary<string, object> row, SecondWorkLoadDto gp, string[] specialPostName)
+        {
+            var post = row.GetString(nameof(ag_bodysource.Post));
+            var workload_score = 0m;
+            if (gp.Items.Count % 2 == 0)
+            {
+                for (int i = 0; i < gp.Items.Count; i = i + 2)
+                {
+                    // 科主任/护士长 不参与工作量考核
+                    if (specialPostName.Contains(post))
+                    {
+                        row.AddOrUpdate(gp.Items[i], 0m);
+                        row.AddOrUpdate(gp.Items[i + 1], 0m);
+                    }
+                    var amount = row.GetDecimal(gp.Items[i]) * row.GetDecimal(gp.Items[i + 1]);
+                    workload_score += GetDecimal2(amount);
+                }
+            }
+            return workload_score;
+        }
+        #endregion
+
+        /// <summary>
+        /// 行内可分配绩效
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="workloadGroups"></param>
+        private void distPerformanceCalculate(List<Dictionary<string, object>> rows)
+        {
+            foreach (var row in rows)
+            {
+                var workPerformance = GetDecimal2(row, nameof(ag_bodysource.WorkPerformance));
+                var titlePerformance = GetDecimal2(row, nameof(ag_bodysource.TitlePerformance));
+                var deptReward = GetDecimal2(row, nameof(ag_bodysource.DeptReward));
+                var basisPerformance = GetDecimal2(row, nameof(ag_bodysource.BasisPerformance));
+                // 可分配绩效 =   当前行职称绩效 + 工作量绩效工资 + 当前行单项奖励 + 当前行主任基础绩效 （科主任护士长）
+                var distPerformance = titlePerformance + workPerformance + deptReward + basisPerformance;
+                row.AddOrUpdate(nameof(ag_bodysource.DistPerformance), distPerformance);
+            }
+        }
+        /// <summary>
+        /// 差额从主任或第一个人身上扣除（小于等于1元）
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="specialPostName"></param>
+        private void balanceTotalDistPerformance(Dictionary<string, object> head, List<Dictionary<string, object>> rows, string[] specialPostName)
+        {
+            var totalPerformance = GetDecimal2(head, nameof(ag_headsource.TotalPerformance));
+            var total_distPerformance = rows.Sum(row => GetDecimal2(row, nameof(ag_bodysource.DistPerformance)));
+            var difference = total_distPerformance - totalPerformance;
+
+            if (Math.Abs(difference) <= 1)
+            {
+                var atRow = rows.Where(row => specialPostName.Contains(row.GetString(nameof(ag_bodysource.Post))));
+                if (atRow == null || atRow.Count() == 0)
+                    atRow = rows;
+
+                if (atRow != null && atRow.Count() > 0)
+                {
+                    var distPerformance = GetDecimal2(atRow.ElementAt(0), nameof(ag_bodysource.DistPerformance));
+                    atRow.ElementAt(0).AddOrUpdate(nameof(ag_bodysource.DistPerformance), distPerformance - difference);
+                }
+            }
+        }
+        /// <summary>
+        /// 行内实发绩效
+        /// </summary>
+        /// <param name="head"></param>
+        /// <param name="rows"></param>
+        /// <param name="specialPostName"></param>
+        private void realAmountCalculate(List<Dictionary<string, object>> rows)
+        {
+            foreach (var row in rows)
+            {
+                // ReservedAmount 年度考核发放金额     DistPerformance   可分配绩效
+                var reservedAmount = GetDecimal2(row, nameof(ag_bodysource.DistPerformance)) * GetDecimal2(row, nameof(ag_bodysource.ReservedRatio));
+                row.AddOrUpdate(nameof(ag_bodysource.ReservedAmount), reservedAmount);
+
+                // 实发绩效 = 可分配绩效 - 预留绩效 + 夜班工作量绩效 
+                var realAmount = GetDecimal2(row, nameof(ag_bodysource.DistPerformance)) - GetDecimal2(row, nameof(ag_bodysource.ReservedAmount)) + GetDecimal2(row, nameof(ag_bodysource.NightWorkPerformance));
+                row.AddOrUpdate(nameof(ag_bodysource.RealAmount), realAmount);
+
+                // 参考(实发绩效 = 实发绩效 + 医院其他绩效)
+                var referToRealAmount = realAmount + GetDecimal2(row, nameof(ag_bodysource.OtherPerformance));
+                row.AddOrUpdate(nameof(ag_bodysource.ReferToRealAmount), referToRealAmount);
+            }
+        }
+
+        #region 四射五入 辅助方式
+        /// <summary>
+        /// 从键值对中获取decimal，默认：0，保留2位小数
+        /// </summary>
+        /// <param name="pairs"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        private decimal GetDecimal2(Dictionary<string, object> pairs, string key) => GetDecimal2(pairs.GetDecimal(key));
+
+        /// <summary>
+        /// decimal?类型转换decimal 默认：0，保留2位小数
+        /// </summary>
+        /// <param name="pairs"></param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        private decimal GetDecimal2(decimal? value) => value.HasValue ? Math.Round(value.Value, 2, MidpointRounding.AwayFromZero) : 0m;
+
+        #endregion
+
+        #endregion
+
+        #region 获取行内工作量分组数
+        /// <summary>
+        /// 获取行内工作量分组数
+        /// </summary>
+        /// <param name="loads"></param>
+        /// <returns></returns>
+        public List<SecondWorkLoadDto> GetTopWorkloadBodyGroups(List<TitleValue<string, decimal?>> loads)
+        {
+            List<SecondWorkLoadDto> result = new List<SecondWorkLoadDto>();
+            if (loads != null)
+            {
+                var keys = loads
+                    .Where(w => w.Title.StartsWithIgnoreCase("AssessmentScore_"))
+                    .Select(w => w.Title.Replace("AssessmentScore_", ""))
+                    .Distinct();
+
+                foreach (var key in keys)
+                {
+                    SecondWorkLoadDto dto = new SecondWorkLoadDto(key);
+                    foreach (var item in loads.Where(w => w.Title.StartsWithIgnoreCase($"Workload_{key}_")))
+                    {
+                        dto.AddItem(item.Title);
+                    }
+                    result.Add(dto);
+                }
+            }
+            return result;
+        }
+        #endregion
+
+        #region 检查工号和姓名是否匹配
+        /// <summary>
+        /// 检查工号和姓名是否匹配
+        /// </summary>
+        /// <param name="second"></param>
+        /// <param name="body"></param>
+        /// <returns></returns>
+        public List<SecondComputeCheckResultDto> CheckData(ag_secondallot second, ComputeMode computeMode, List<Dictionary<string, object>> body, List<TitleValue<string, decimal?>> loads)
+        {
+            if (body == null || body.Count == 0)
+                throw new PerformanceException("分配人员信息不存在！");
+
+            List<SecondComputeCheckResultDto> result = new List<SecondComputeCheckResultDto>();
+
+            var employees = _peremployeeRepository.GetEntities(w => w.AllotId == second.AllotId)
+                .Select(w => new { w.PersonnelNumber, w.DoctorName, w.AccountingUnit, w.UnitType, w.ReservedRatio });
+
+            var handsonTable = GetHandsonTable(computeMode, loads);
+            var fixat = new string[] { nameof(ag_bodysource.Id).ToLower(), nameof(ag_bodysource.SecondId).ToLower(), nameof(ag_bodysource.Department).ToLower() };
+            for (int i = 0; i < body.Count; i++)
+            {
+                var item = body[i];
+                if (item.Where(w => handsonTable.Columns.Any(col => col.Data.EqualsIgnoreCase(w.Key)) && w.Value != null && !string.IsNullOrEmpty(w.Value.ToString())).Count() > 0)
+                {
+                    var number = item.GetString(nameof(ag_bodysource.WorkNumber));
+                    var name = item.GetString(nameof(ag_bodysource.Name));
+
+                    if (string.IsNullOrEmpty(number) || string.IsNullOrEmpty(name))
+                    {
+                        item.AddOrUpdate(nameof(ResponseType), ResponseType.Warning);
+                        result.Add(new SecondComputeCheckResultDto(nameof(ResponseType.Error), "空", "空", $"第{(i + 1)}行，工号或姓名无效；请删除！"));
+                    }
+                    else if (!employees.Any(w => w.PersonnelNumber == number && w.DoctorName == name))
+                    {
+                        item.AddOrUpdate(nameof(ResponseType), ResponseType.Error);
+                        result.Add(new SecondComputeCheckResultDto(nameof(ResponseType.Error), number, name, $"第{(i + 1)}行，工号和姓名在字典中不存在，请修复！"));
+                    }
+                    else
+                    {
+                        var emp = employees.FirstOrDefault(w => w.PersonnelNumber == number && w.DoctorName == name);
+                        item.AddOrUpdate(nameof(ResponseType), ResponseType.OK);
+                        item.AddOrUpdate(nameof(ag_bodysource.Department), emp.AccountingUnit);
+                        item.AddOrUpdate(nameof(ag_bodysource.ReservedRatio), emp.ReservedRatio);
+                    }
+                }
+            }
+
+            return result;
+        }
+        #endregion
+
+        #region 二次分配审核后查看详情
+        /// <summary>
+        /// 二次分配审核后查看详情
+        /// </summary>
+        /// <param name="computeMode"></param>
+        /// <param name="allot"></param>
+        /// <param name="second"></param>
+        /// <returns></returns>
+        public (Dictionary<string, object> head, List<Dictionary<string, object>> rows) RedistributionDetail(ComputeMode computeMode, per_allot allot, ag_secondallot second, List<SecondWorkLoadDto> workloadGroups)
+        {
+            var loadEmployees = _agbodysourceRepository.GetEntities(w => w.SecondId == second.Id);
+            var rows = LoadWorkload(allot, second, loadEmployees);
+            var head = LoadHead(computeMode, allot, second);
+            if (computeMode != ComputeMode.NotCalculate)
+            {
+                overviewCalculate(head, rows);
+                // 计算顶部工作量
+                topWorkloadCalculate(head, workloadGroups);
+                // 计算顶部年资系数
+                topSeniorityCalculate(head);
+            }
+
+            return (head, rows);
+        }
+        #endregion
+
+        #region 科室查询人员字典
+        /// <summary>
+        /// 科室查询人员字典
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public object RedistributionEmployee(SecondEmployeeDto request)
+        {
+            List<Dictionary<string, object>> result = new List<Dictionary<string, object>>();
+
+            var second = _secondallotRepository.GetEntity(t => t.Id == request.SecondId);
+            if (second == null) throw new PerformanceException("参数SecondId无效！");
+
+            var allot = _perallotRepository.GetEntity(t => t.ID == second.AllotId);
+            if (allot == null)
+                throw new PerformanceException("绩效记录不存在！");
+            // 当前二次分配配置工作量
+            var loads = GetWorkLoads(allot.HospitalId, second.UnitType, second.Department);
+
+            Expression<Func<per_employee, bool>> exp = t => t.AllotId == second.AllotId;
+
+            if (request != null && !string.IsNullOrEmpty(request.SearchQuery))
+            {
+                exp = exp.And(t => true && (t.AccountingUnit.Contains(request.SearchQuery) || t.PersonnelNumber.Contains(request.SearchQuery) || t.DoctorName.Contains(request.SearchQuery) || t.Department.Contains(request.SearchQuery)));
+            }
+            // 分页查询
+            var employees = _peremployeeRepository.GetEntitiesForPaging(request.PageNumber, request.PageSize, exp);
+            if (employees != null)
+            {
+                Func<per_employee, decimal?> getDistPerformance = (emp) => 0;
+                // 不计算模板时，带出工作量绩效（一次分配中的应发绩效）
+                if (request.ComputeMode == (int)ComputeMode.NotCalculate)
+                {
+                    if (UnitTypeUtil.IsOffice(second.UnitType))
+                    {
+                        var distPerformance = _rescomputeRepository.GetEntities(t => t.AllotID == second.AllotId && employees.Select(s => s.PersonnelNumber).Contains(t.JobNumber));
+                        getDistPerformance = (emp) =>
+                        {
+                            if (second.Department == emp.AccountingUnit)
+                                return distPerformance?.Where(w => w.JobNumber?.Trim() == emp.PersonnelNumber?.Trim())?.Sum(w => w.GiveFee);
+                            return 0;
+                        };
+                    }
+                }
+                var secondWorkload = GetSecondWorkloadByValue(second.AllotId.Value, second.UnitType, second.Department);
+                var monthDays = DateTime.DaysInMonth(allot.Year, allot.Month);
+                foreach (var employee in employees)
+                {
+                    Dictionary<string, object> item = new Dictionary<string, object>();
+
+                    // 不计算模板时，带出工作量绩效（一次分配中的应发绩效）
+                    if (request.ComputeMode == (int)ComputeMode.NotCalculate)
+                    {
+                        item.Add(nameof(ag_bodysource.WorkPerformance), getDistPerformance(employee));
+                    }
+
+                    item.Add(nameof(per_employee.UnitType), employee.UnitType);
+                    item.Add(nameof(ag_bodysource.SecondId), request.SecondId);
+                    item.Add(nameof(ag_bodysource.Department), employee.AccountingUnit);
+                    item.Add(nameof(ag_bodysource.Name), employee.DoctorName);
+                    item.Add(nameof(ag_bodysource.WorkNumber), employee.PersonnelNumber);
+                    item.Add(nameof(ag_bodysource.JobTitle), employee.JobTitle);
+                    item.Add(nameof(ag_bodysource.Post), "");
+                    item.Add(nameof(ag_bodysource.TitleCoefficient), 1);
+                    item.Add(nameof(ag_bodysource.ActualAttendance), employee.AttendanceDay > monthDays ? monthDays : employee.AttendanceDay);
+                    item.Add(nameof(ag_bodysource.StaffCoefficient), 1);
+                    if (loads != null)
+                    {
+                        foreach (var score in loads.Where(w => w.Title.StartsWithIgnoreCase("AssessmentScore_")).ToList())
+                        {
+                            item.AddOrUpdate(score.Title, 100);
+                        }
+                        // 工作量带出
+                        if (secondWorkload != null && secondWorkload.Any())
+                        {
+                            var workload = secondWorkload.Where(w => w.DoctorName == employee.DoctorName && w.PersonnelNumber == employee.PersonnelNumber && loads.Select(score => score.Title).Contains(w.ItemId));
+                            foreach (var wl in workload)
+                            {
+                                item.AddOrUpdate(wl.ItemId, wl.Value);
+                            }
+                        }
+                    }
+
+                    result.Add(item);
+                }
+            }
+
+            return new { employees.CurrentPage, employees.TotalPages, employees.PageSize, employees.TotalCount, list = result };
+        }
+        #endregion
+
+        private IEnumerable<view_second_workload_result> GetSecondWorkloadByValue(int allotid, string unittype, string accountingunit)
+        {
+            return _perallotRepository.GetSecondWorkload(allotid, unittype, accountingunit);
+        }
+    }
+}

performance/Performance.Services/SecondAllot/SecondAllotDetails.cs

@@ -530,10 +530,11 @@ private void SupplementOtherPerfor(ag_secondallot secondAllot, List<BodyItem> bo
                     new Tuple<string, string, Func<per_employee, object>>("人员系数", "StaffCoefficient", (t) => 1),
                     new Tuple<string, string, Func<per_employee, object>>("职称", "JobTitle", (t) => t.JobTitle),
                     new Tuple<string, string, Func<per_employee, object>>("预留年度考核比例", "ReservedRatio", (t) => t.ReservedRatio),
-                    new Tuple<string, string, Func<per_employee, object>>("医院其他绩效", "OtherPerformance", (t) => 0)
+                    new Tuple<string, string, Func<per_employee, object>>("医院其他绩效", "OtherPerformance", (t) => 0),
+                    new Tuple<string, string, Func<per_employee, object>>("实发绩效工资金额", "ShifaAmountOfPerformancePay", (t) => 0)
                 };
 
-                var specialColumns = new string[] { "FullName", "OtherPerformance" };
+                var specialColumns = new string[] { "FullName", "OtherPerformance", "ShifaAmountOfPerformancePay" };
 
                 foreach (var item in groupData)
                 {
@@ -548,10 +549,12 @@ private void SupplementOtherPerfor(ag_secondallot secondAllot, List<BodyItem> bo
 
                             var data = new BodyItem(headItem);
                             data.RowNumber = lastNumber;
-                            if (specialColumns.Contains(column.Item2))
-                            {
-                                data.Value = column.Item2 == "OtherPerformance" ? item.Amount : item.DoctorName;
-                            }
+                            if (column.Item2 == "FullName")
+                                data.Value = item.DoctorName;
+                            else if (column.Item2 == "OtherPerformance")
+                                data.Value = item.Amount;
+                            else if (column.Item2 == "ShifaAmountOfPerformancePay")
+                                data.Value = item.Amount;
                             else
                             {
                                 var value = column.Item3.Invoke(employee);
@@ -923,7 +926,7 @@ private void SupplementSecondDetail(ag_secondallot second, List<per_employee> em
         /// <param name="hospitalId"></param>
         /// <param name="secondAllot"></param>
         /// <returns></returns>
-        private ag_secondallot GetPreviousSecondAllot(int hospitalId, ag_secondallot secondAllot)
+        public ag_secondallot GetPreviousSecondAllot(int hospitalId, ag_secondallot secondAllot)
         {
             // 历史删除绩效时，未删除对应的二次绩效记录
             var allotList = perallotRepository.GetEntities(w => w.HospitalId == hospitalId)?.OrderBy(s => s.Year).ThenBy(s => s.Month).ToList();

performance/Performance.Services/SecondAllot/SecondAllotService.cs

@@ -484,26 +484,23 @@ public void SaveSecondAllotData(int secondId, dynamic saveData)
         /// </summary>
         /// <param name="secondId"></param>
         /// <param name="json"></param>
-        private void SaveSecondAllotHeadData(int secondId, string json)
+        public void SaveSecondAllotHeadData(int secondId, string json)
         {
             if (string.IsNullOrEmpty(json)) return;
 
             ag_headsource headsource = JsonHelper.Deserialize<ag_headsource>(json);
             if (headsource == null) return;
 
+            var exist = agheadsourceRepository.GetEntity(w => w.SecondId == secondId);
+            if (exist != null)
+                agheadsourceRepository.Remove(exist);
+
             headsource.SecondId = secondId;
-            if (headsource.Id == 0)
-            {
-                agheadsourceRepository.Add(headsource);
-            }
-            else
-            {
-                agheadsourceRepository.UpdateByState(headsource);
-            }
+            agheadsourceRepository.Add(headsource);
 
             string[] prefix = new string[] { "Workload_Ratio_", "Workload_Amount_" };
             Dictionary<string, object> dict = JsonHelper.Deserialize<Dictionary<string, object>>(json);
-            var keys = dict.Keys.Where(t => t.StartsWith(prefix[0]) || t.StartsWith(prefix[1]));
+            var keys = dict.Keys.Where(t => t.StartsWithIgnoreCase(prefix[0]) || t.StartsWithIgnoreCase(prefix[1]));
             if (keys == null || !keys.Any())
                 return;
 
@@ -514,7 +511,7 @@ private void SaveSecondAllotHeadData(int secondId, string json)
 
             foreach (var key in keys)
             {
-                var update = worktypeSources.FirstOrDefault(t => t.FieldId == key);
+                var update = worktypeSources.FirstOrDefault(t => t.FieldId.EqualsIgnoreCase(key));
                 if (update != null)
                 {
                     update.Value = ConvertHelper.To<decimal>(dict[key]);
@@ -529,7 +526,7 @@ private void SaveSecondAllotHeadData(int secondId, string json)
         /// <param name="hospitalId"></param>
         /// <param name="second"></param>
         /// <param name="body"></param>
-        private void SaveSecondAllotBodyData(int hospitalId, ag_secondallot second, dynamic body)
+        public void SaveSecondAllotBodyData(int hospitalId, ag_secondallot second, dynamic body)
         {
             // 允许空行数据提交，删除数据库存数数据
             var bodyEntities = agbodysourceRepository.GetEntities(t => t.SecondId == second.Id);
@@ -558,12 +555,12 @@ private void SaveSecondAllotBodyData(int hospitalId, ag_secondallot second, dyna
                 if (!result) continue;
 
                 Dictionary<string, object> dict = JsonHelper.Deserialize<Dictionary<string, object>>(JsonHelper.Serialize(rowitem));
-                var keys = dict.Keys.Where(t => t.StartsWith(prefix[0]) || t.StartsWith(prefix[1]) || t.StartsWith(prefix[2]) || t.StartsWith(prefix[3]) || t.StartsWith(prefix[4]));
+                var keys = dict.Keys.Where(t => t.StartsWithIgnoreCase(prefix[0]) || t.StartsWithIgnoreCase(prefix[1]) || t.StartsWithIgnoreCase(prefix[2]) || t.StartsWithIgnoreCase(prefix[3]) || t.StartsWithIgnoreCase(prefix[4]));
                 if (keys == null || !keys.Any()) continue;
 
                 foreach (var key in keys)
                 {
-                    var workload = workloads.FirstOrDefault(t => t.ItemId == key);
+                    var workload = workloads.FirstOrDefault(t => t.ItemId.EqualsIgnoreCase(key));
                     if (workload == null) continue;
 
                     workloadSources.Add(new ag_workload_source
@@ -583,6 +580,23 @@ private void SaveSecondAllotBodyData(int hospitalId, ag_secondallot second, dyna
                 agworkloadsourceRepository.AddRange(workloadSources.ToArray());
         }
 
+        public bool RedistributionSave(per_allot allot, ag_secondallot second, Dictionary<string, object> head, List<Dictionary<string, object>> rows)
+        {
+            try
+            {
+                SaveSecondAllotHeadData(second.Id, JsonHelper.Serialize(head));
+
+                SaveSecondAllotBodyData(allot.HospitalId, second, rows);
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex.ToString());
+            }
+            return false;
+        }
+
         #endregion
     }
 }

performance/Performance.Services/SecondAllotService.cs

@@ -1054,6 +1054,23 @@ public List<TitleValue<int>> WorkTypeList(WorkloadRequest request, int secondId)
         }
 
         /// <summary>
+        /// 获取二次分配 提取工作量带出字典
+        /// </summary>
+        /// <param name="secondId"></param>
+        /// <returns></returns>
+        public List<string> WorkloadMap(int secondId)
+        {
+            var second = agsecondallotRepository.GetEntity(t => t.Id == secondId);
+            if (second == null) throw new PerformanceException("参数错误");
+
+            var allot = perallotRepository.GetEntity(t => t.ID == second.AllotId);
+            if (allot == null) throw new PerformanceException("参数错误");
+
+            var worktypes = perallotRepository.GetSecondWorkloadMaps(allot.HospitalId);
+            return (worktypes != null && worktypes.Any()) ? worktypes.ToList() : new List<string>();
+        }
+
+        /// <summary>
         /// 保存工作量类型
         /// </summary>
         /// <param name="secondId"></param>
@@ -1072,6 +1089,7 @@ public ag_workload_type SaveWorkType(ag_workload_type request, int secondId)
                     entity = agworkloadtypeRepository.GetEntity(t => t.Id == request.Id);
                     entity.HospitalId = request.HospitalId;
                     entity.TypeName = request.TypeName;
+                    entity.TypeName = request.TypeName;
 
                     agworkloadtypeRepository.Update(entity);
                 }
@@ -1342,7 +1360,16 @@ public List<ag_workload> GetWorkloadList(WorkloadRequest request)
         /// <returns></returns>
         public bool WorkloadAdd(WorkloadRequest request)
         {
-            var workloadList = agworkloadRepository.GetEntities(t => t.HospitalId == request.HospitalId && t.Department == request.Department && t.UnitType == request.UnitType);
+            Expression<Func<ag_workload, bool>> exp = (t) => t.HospitalId == request.HospitalId && t.Department == request.Department && t.UnitType == request.UnitType;
+            if (request.IsSingleAwards)
+            {
+                exp = exp.And(t => t.ItemId.StartsWith(AgWorkloadType.SingleAwards.ToString()));                
+            }
+            else
+            {
+                exp = exp.And(t => t.ItemId.StartsWith($"{AgWorkloadType.Workload}_"));
+            }
+            var workloadList = agworkloadRepository.GetEntities(exp);
             if (workloadList != null && workloadList.Any(t => t.ItemName == request.ItemName))
                 throw new PerformanceException("项目名称重复");
             ag_workload workload = new ag_workload
@@ -1353,6 +1380,7 @@ public bool WorkloadAdd(WorkloadRequest request)
                 FactorValue = request.FactorValue ?? 1,
                 ItemName = request.ItemName,
                 Sort = request.Sort ?? 1,
+                SourceCategory = request.SourceCategory,
                 WorkTypeId = request.IsSingleAwards ? (int)AgWorkloadType.SingleAwards : request.WorkTypeId
             };
             var result = agworkloadRepository.Add(workload);
@@ -1372,7 +1400,16 @@ public bool WorkloadAdd(WorkloadRequest request)
         /// <returns></returns>
         public bool WorkloadUpdate(WorkloadRequest request)
         {
-            var workloadList = agworkloadRepository.GetEntities(t => t.HospitalId == request.HospitalId && t.Department == request.Department && t.UnitType == request.UnitType);
+            Expression<Func<ag_workload, bool>> exp = (t) => t.HospitalId == request.HospitalId && t.Department == request.Department && t.UnitType == request.UnitType;
+            if (request.IsSingleAwards)
+            {
+                exp = exp.And(t => t.ItemId.StartsWith(AgWorkloadType.SingleAwards.ToString()));
+            }
+            else
+            {
+                exp = exp.And(t => t.ItemId.StartsWith($"{AgWorkloadType.Workload}_"));
+            }
+            var workloadList = agworkloadRepository.GetEntities(exp);
             if (workloadList != null && workloadList.Any(t => t.Id != request.Id && t.ItemName == request.ItemName))
                 throw new PerformanceException("项目名称重复");
 
@@ -1382,6 +1419,7 @@ public bool WorkloadUpdate(WorkloadRequest request)
             workload.UnitType = request.UnitType;
             workload.FactorValue = request.FactorValue;
             workload.ItemName = request.ItemName;
+            workload.SourceCategory = request.SourceCategory;
             workload.Sort = request.Sort;
             workload.ItemId = getWorkloadItemId.Invoke(request.IsSingleAwards, request.WorkTypeId, workload.Id); ;
             workload.WorkTypeId = request.IsSingleAwards ? (int)AgWorkloadType.SingleAwards : request.WorkTypeId;
@@ -1420,7 +1458,7 @@ private List<ag_secondallot> GetNotAuditSeconds(int hospitalId, ag_workload_type
             /**
              * 添加数据时注意避免给已经提交过的数据添加，否则会造成提交时的数据和显示数据不一致 
              */
-            return agsecondallotRepository.GetEntities(t => allots.Select(w => w.ID).Contains(t.AllotId.Value) && t.Department == type.Department && t.UnitType == type.UnitType && IsAudit(t.Status)) ?? seconds;
+            return agsecondallotRepository.GetEntities(t => allots.Select(w => w.ID).Contains(t.AllotId.Value) && t.Department == type.Department && t.UnitType == type.UnitType && !IsAudit(t.Status)) ?? seconds;
         }
 
         /// <summary>
@@ -1605,15 +1643,19 @@ bool VerifySubmissioAmount(decimal? submitDataAmount, decimal? realGiveFee)
                 if (!VerifySubmissioAmount(total, second.RealGiveFee))
                     throw new PerformanceException($"总金额与考核后金额不一致！可分配金额：{second.RealGiveFee}，提交金额：{total}");
             }
-            else if (new int[] { 9, 10 }.Contains(temp.UseTempId.Value))
+            else /*if (new int[] { 9, 10 }.Contains(temp.UseTempId.Value))*/
             {
                 var data = agbodysourceRepository.GetEntities(t => t.SecondId == second.Id);
                 if (data == null || !data.Any())
                     throw new PerformanceException("提交时未检测到数据!");
 
+                var nightShiftWorkPerforFee = data.Sum(w => w.NightWorkPerformance ?? 0);
+                if (!VerifySubmissioAmount(nightShiftWorkPerforFee, second.NightShiftWorkPerforFee))
+                    throw new PerformanceException($"夜班绩效金额不一致！夜班绩效金额：{second.NightShiftWorkPerforFee ?? 0:0.####}，提交金额：{nightShiftWorkPerforFee:0.####}");
+
                 var total = data.Sum(t => (t.DistPerformance ?? 0) + (t.NightWorkPerformance ?? 0));
                 if (!VerifySubmissioAmount(total, second.RealGiveFee))
-                    throw new PerformanceException($"总金额与考核后金额不一致！可分配金额：{second.RealGiveFee}，提交金额：{total}");
+                    throw new PerformanceException($"总金额与考核后金额不一致！可分配金额：{second.RealGiveFee:0.####}，提交金额：{total:0.####}");
             }
             second.UseTempId = temp.UseTempId;
             second.Status = 2;
@@ -1803,7 +1845,7 @@ public bool NursingDeptAudit(int userId, SecondAuditRequest request)
         /// </summary>
         /// <param name="secondId">二次绩效Id</param>
         /// <returns></returns>
-        public ag_secondallot GetSecondallot(int secondId)
+        public ag_secondallot GetSecondAllot(int secondId)
         {
             return agsecondallotRepository.GetEntity(t => t.Id == secondId);
         }
@@ -2097,30 +2139,7 @@ public List<SecPrintResponse> Print(int secondId)
 
                 result = Mapper.Map<List<SecPrintResponse>>(data);
             }
-            else if (second.UseTempId.HasValue && (new int[] { 9, 10 }).Contains(second.UseTempId.Value))
-            {
-                var data = agbodysourceRepository.GetEntities(t => t.SecondId == secondId);
-                if (data == null || !data.Any()) return new List<SecPrintResponse>();
-
-                var bodyDynamic = agworkloadsourceRepository.GetEntities(t => data.Select(w => w.Id).Contains(t.BodyId));
-                if (data == null || !data.Any()) return new List<SecPrintResponse>();
-
-                result = data.Select(w => new SecPrintResponse
-                {
-                    JobNumber = w.WorkNumber,
-                    PersonName = w.Name,
-                    Department = w.Department,
-                    RealAmount = w.RealAmount,
-                    WorkPost = w.Post,
-                    TitlePerfor = w.TitlePerformance,
-                    WorkPerformance = bodyDynamic?.Where(b => b.BodyId == w.Id && b.ItemId.StartsWith("WorkPerformance_")).Sum(b => b.Value) ?? 0,
-                    DeptReward = w.DeptReward,
-                    DistPerformance = w.DistPerformance,
-                    OtherPerformance = w.OtherPerformance,
-                    NightWorkPerformance = w.NightWorkPerformance,
-                }).ToList();
-            }
-            else
+            else if (second.UseTempId.HasValue && (new int[] { 7, 8 }).Contains(second.UseTempId.Value))
             {
                 var itemname = new List<string> { "人员工号", "姓名", "职称", "职称绩效", "工作量绩效工资", "单项奖励小计", "可分配绩效", "医院其他绩效", "夜班工作量绩效" };
                 var fixaitems = agfixatitemRepository.GetEntities(t => t.SecondId == secondId && itemname.Contains(t.ItemName));
@@ -2150,6 +2169,29 @@ public List<SecPrintResponse> Print(int secondId)
                     result.Add(sec);
                 }
             }
+            else
+            {
+                var data = agbodysourceRepository.GetEntities(t => t.SecondId == secondId);
+                if (data == null || !data.Any()) return new List<SecPrintResponse>();
+
+                var bodyDynamic = agworkloadsourceRepository.GetEntities(t => data.Select(w => w.Id).Contains(t.BodyId));
+                if (data == null || !data.Any()) return new List<SecPrintResponse>();
+
+                result = data.Select(w => new SecPrintResponse
+                {
+                    JobNumber = w.WorkNumber,
+                    PersonName = w.Name,
+                    Department = w.Department,
+                    RealAmount = w.RealAmount,
+                    WorkPost = w.Post,
+                    TitlePerfor = w.TitlePerformance,
+                    WorkPerformance = bodyDynamic?.Where(b => b.BodyId == w.Id && b.ItemId.StartsWith("WorkPerformance_")).Sum(b => b.Value) ?? 0,
+                    DeptReward = w.DeptReward,
+                    DistPerformance = w.DistPerformance,
+                    OtherPerformance = w.OtherPerformance,
+                    NightWorkPerformance = w.NightWorkPerformance,
+                }).ToList();
+            }
 
             // 补充医院其他绩效  及  预留比例
             var perapramounts = perapramountRepository.GetFullAmount(t => t.AllotId == second.AllotId && t.Status == 3);

performance/Performance.Services/UnitTypeUtil.cs

@@ -25,5 +25,15 @@ public static bool IsOffice(string unit)
         {
             return !string.IsNullOrEmpty(unit) && (unit == "行政后勤" || unit == "行政工勤");
         }
+
+        /// <summary>
+        /// 核算单元类型是否相同
+        /// </summary>
+        /// <param name="left"></param>
+        /// <returns></returns>
+        public static bool IsEqualsUnitType(string left, string right)
+        {
+            return left?.Replace("行政后勤", "行政工勤") == right?.Replace("行政后勤", "行政工勤");
+        }
     }
 }