Merge branch 'newcollect&extracr' into v2020morge

# Conflicts:
#	performance/Performance.EntityModels/Entity/ex_script.cs

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

@@ -1435,6 +1435,11 @@
             数据开始行
             </summary>
         </member>
+        <member name="P:Performance.DtoModels.PerSheetPoint.DataFirstCellNum">
+            <summary>
+            数据开始列
+            </summary>
+        </member>
         <member name="P:Performance.DtoModels.PerSheetPoint.TotalCellNum">
             <summary>
             汇总列

performance/Performance.DtoModels/PerExcel/PerSheetPoint.cs

@@ -25,6 +25,10 @@ public class PerSheetPoint
         /// 数据开始行
         /// </summary>
         public int? DataFirstRowNum { get; set; }
+        /// <summary>
+        /// 数据开始列
+        /// </summary>
+        public int? DataFirstCellNum { get; set; }
 
         public List<AccountingUnit> AccountingUnit { get; set; }
         /// <summary>

performance/Performance.Extract.Api/Controllers/ExtractController.cs

@@ -10,6 +10,7 @@
 using Performance.DtoModels.AppSettings;
 using Performance.Infrastructure;
 using Performance.Services;
+using Performance.Services.ExtractExcelService;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -23,17 +24,20 @@ public class ExtractController : Controller
     {
         private readonly DFExtractService extractService;
         private readonly HospitalService hospitalService;
+        private readonly ExtractService extractService1;
         private readonly WebapiUrl url;
         private readonly ILogger<ExtractController> logger;
         private readonly IHostingEnvironment evn;
         public ExtractController(DFExtractService extractService,
             HospitalService hospitalService,
+            ExtractService extractService1,
             IOptions<WebapiUrl> url,
             ILogger<ExtractController> logger,
             IHostingEnvironment evn)
         {
             this.extractService = extractService;
             this.hospitalService = hospitalService;
+            this.extractService1 = extractService1;
             this.url = url.Value;
             this.logger = logger;
             this.evn = evn;
@@ -149,7 +153,8 @@ public void ExtractData([FromForm] IFormCollection form, int allotId, int hospit
             #endregion
 
             //string filePath = newExtractService.ExtractData(allotId, request.Email, hospitalId);
-            string filePath = extractService.ExtractData(allotId, email, hospitalId, "User" + userId, path); //抽取
+            //string filePath = extractService.ExtractData(allotId, email, hospitalId, "User" + userId, path); //抽取
+            string filePath = extractService1.Main(allotId, hospitalId, email, "User" + userId, path);
 
             #region 保存文件到网站下
 

performance/Performance.Services/ExtractExcelService/ExtractDtos/ExcelHeader.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class ExcelHeader
+    {
+        /// <summary>
+        /// Excel 列名
+        /// </summary>
+        public string ColumnName { get; set; }
+
+        /// <summary>
+        /// 护理组系数
+        /// </summary>
+        public decimal NurseFactor { get; set; }
+
+        /// <summary>
+        /// 医生组系数
+        /// </summary>
+        public decimal DoctorFactor { get; set; }
+
+        /// <summary>
+        /// 医技组系数
+        /// </summary>
+        public decimal TechnicianFactor { get; set; }
+
+        /// <summary>
+        /// 工作量系数
+        /// </summary>
+        public decimal WorkloadFactor { get; set; }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractDtos/ExtractTransDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    /// <summary>
+    /// 抽取结果（转换核算单元后）
+    /// </summary>
+    public class ExtractTransDto
+    {
+        /// <summary>
+        /// 医生姓名
+        /// </summary>
+        public string DoctorName { get; set; }
+
+        /// <summary>
+        /// 医生工号
+        /// </summary>
+        public string PersonnelNumber { get; set; }
+
+        /// <summary>
+        /// 科室
+        /// </summary>
+        public string Department { get; set; }
+
+        /// <summary>
+        /// 费用类别
+        /// </summary>
+        public string Category { get; set; }
+
+        /// <summary>
+        /// 费用
+        /// </summary>
+        public decimal? Value { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string SheetName { get; set; }
+
+        /// <summary>
+        /// 核算单元（门诊医生）
+        /// </summary>
+        public string OutDoctorAccounting { get; set; }
+
+        /// <summary>
+        /// 核算单元（门诊护理）
+        /// </summary>
+        public string OutNurseAccounting { get; set; }
+
+        /// <summary>
+        /// 核算单元（门诊医技）
+        /// </summary>
+        public string OutTechnicAccounting { get; set; }
+
+        /// <summary>
+        /// 核算单元（住院医生）
+        /// </summary>
+        public string InpatDoctorAccounting { get; set; }
+
+        /// <summary>
+        /// 核算单元（住院护理）
+        /// </summary>
+        public string InpatNurseAccounting { get; set; }
+
+        /// <summary>
+        /// 核算单元（住院医技）
+        /// </summary>
+        public string InpatTechnicAccounting { get; set; }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractDtos/SpecialCellRange.cs

+using NPOI.SS.Util;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class SpecialCellRange : CellRangeAddress
+    {
+        public SpecialCellRange(CellRangeAddress address)
+            : base(address.FirstRow, address.LastRow, address.FirstColumn, address.LastColumn)
+        {
+
+        }
+
+        public string Single { get; set; }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractDtos/SpecialDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class SpecialDto
+    {
+        /// <summary>
+        /// 科室
+        /// </summary>
+        public string Department { get; set; }
+
+        /// <summary>
+        /// 量化指标
+        /// </summary>
+        public string Target { get; set; }
+
+        /// <summary>
+        /// 量化指标绩效分值
+        /// </summary>
+        public decimal? TargetFactor { get; set; }
+
+        /// <summary>
+        /// 调节系数
+        /// </summary>
+        public decimal? AdjustFactor { get; set; }
+
+        /// <summary>
+        /// 数量
+        /// </summary>
+        public decimal? Quantity { get; set; }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractDtos/SpecialUnitColumns.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class SpecialUnitColumns
+    {
+        public const string Department = "科室";
+
+        public const string PeopleNumber = "人数";
+
+        public const string Target = "量化指标";
+
+        public const string Quantity = "数量";
+
+        public const string TargetFactor = "量化指标绩效分值";
+
+        public const string AdjustFactor = "调节系数";
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractHelper/ExcelHelper.cs

+using NPOI.HSSF.UserModel;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
+using Performance.DtoModels;
+using Performance.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public static class ExcelHelper
+    {
+        public static IRow GetOrCreate(this ISheet sheet, int index)
+        {
+            var row = sheet.GetRow(index);
+            if (row == null)
+                row = sheet.CreateRow(index);
+
+            return row;
+        }
+
+        public static ICell GetOrCreate(this IRow row, int index)
+        {
+            var cell = row.GetCell(index);
+            if (cell == null)
+                cell = row.CreateCell(index);
+
+            return cell;
+        }
+
+        public static void SetRowStyle(this IRow row, ICellStyle cellStyle)
+        {
+            List<ICell> cells = row.Cells;
+            foreach (var cell in cells)
+            {
+                cell.CellStyle = cellStyle;
+            }
+        }
+
+        public static void SetCellValue<T>(this ICell cell, object value, T defaultValue = default)
+        {
+            if (cell == null) return;
+
+            try
+            {
+                switch (typeof(T).ToString())
+                {
+                    #region SetValue
+
+                    case "System.String"://字符串类型   
+                        cell.SetCellValue(ConvertHelper.To<string>(value));
+                        break;
+                    case "System.DateTime"://日期类型   
+                        cell.SetCellValue(ConvertHelper.To<DateTime>(value).ToString("yyyy/M/d"));
+                        break;
+                    case "System.Boolean"://布尔型   
+                        cell.SetCellValue(ConvertHelper.To<bool>(value));
+                        break;
+                    case "System.Int16"://整型   
+                    case "System.Int32":
+                    case "System.Int64":
+                    case "System.Byte":
+                        cell.SetCellValue(ConvertHelper.To<int>(value));
+                        break;
+                    case "System.Decimal"://浮点型   
+                    case "System.Double":
+                        cell.SetCellValue(ConvertHelper.To<double>(value));
+                        break;
+                    case "System.DBNull"://空值处理  
+                    default:
+                        cell.SetCellValue("");
+                        break;
+
+                        #endregion
+                }
+            }
+            catch
+            {
+                cell.SetCellValue("");
+            }
+        }
+
+        public static void SetCellOValue(this ICell cell, object value)
+        {
+            if (cell == null) return;
+
+            if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
+            {
+                cell.SetCellValue("");
+                return;
+            }
+
+            try
+            {
+                string stringV = value.ToString().Trim();
+                var type = value.GetType();
+                switch (type.ToString())
+                {
+                    #region SetValue
+
+                    case "System.String"://字符串类型   
+                        cell.SetCellValue(stringV);
+                        break;
+                    case "System.DateTime"://日期类型   
+                        DateTime dateV;
+                        DateTime.TryParse(stringV, out dateV);
+                        cell.SetCellValue(dateV.ToString("yyyy/M/d"));
+                        break;
+                    case "System.Boolean"://布尔型   
+                        bool boolV = false;
+                        bool.TryParse(stringV, out boolV);
+                        cell.SetCellValue(boolV);
+                        break;
+                    case "System.Int16"://整型   
+                    case "System.Int32":
+                    case "System.Int64":
+                    case "System.Byte":
+                        int intV = 0;
+                        int.TryParse(stringV, out intV);
+                        cell.SetCellValue(intV);
+                        break;
+                    case "System.Decimal"://浮点型   
+                    case "System.Double":
+                        double doubV = 0;
+                        double.TryParse(stringV, out doubV);
+                        cell.SetCellValue(doubV);
+                        break;
+                    case "System.DBNull"://空值处理   
+                        cell.SetCellValue("");
+                        break;
+                    default:
+                        cell.SetCellValue("");
+                        break;
+
+                        #endregion
+                }
+            }
+            catch
+            {
+                cell.SetCellValue("");
+            }
+        }
+
+        public static T GetCellValue<T>(this ICell cell)
+        {
+            try
+            {
+                cell.SetCellType(CellType.String);
+                string value = cell.StringCellValue;
+                return ConvertHelper.To<T>(value);
+            }
+            catch
+            {
+                return default;
+            }
+        }
+
+        /// <summary>
+        /// 获取去除转义后的字符
+        /// </summary>
+        /// <param name="cell"></param>
+        /// <returns></returns>
+        public static string GetDecodeEscapes(this ICell cell)
+        {
+            try
+            {
+                if (cell == null) return "";
+
+                cell.SetCellType(CellType.String);
+                string value = cell.StringCellValue;
+                if (!string.IsNullOrEmpty(value))
+                    value = value.Replace("\n", "").Replace(" ", "").Trim();
+
+                return value;
+            }
+            catch
+            {
+                return "";
+            }
+        }
+
+        public static string NoBlank(this string @string)
+        {
+            if (string.IsNullOrEmpty(@string))
+                return "";
+            return @string.Replace("\n", "").Replace(" ", "").Trim();
+        }
+
+        public static IWorkbook GetWorkbook(string filePath)
+        {
+            IWorkbook workbook = null;
+
+            if (string.IsNullOrEmpty(filePath)) return workbook;
+
+            var version = FileHelper.GetExtension(filePath) == ".xlsx" ? ExcelVersion.xlsx : ExcelVersion.xls;
+
+            using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate))
+            {
+                workbook = (version == ExcelVersion.xlsx)
+                    ? (IWorkbook)(new XSSFWorkbook(fs))
+                    : (IWorkbook)(new HSSFWorkbook(fs));
+            }
+
+            return workbook;
+        }
+
+        public static List<string> GetCellValues(this IRow row)
+        {
+            List<string> list = new List<string>();
+
+            if (row == null || row.Cells == null || !row.Cells.Any()) return list;
+
+            list = row.Cells.Select(t => t.GetDecodeEscapes()).ToList();
+
+            return list;
+        }
+
+        public static Dictionary<string, int> GetCellIndex(this IRow row, params string[] list)
+        {
+            Dictionary<string, int> pairs = new Dictionary<string, int>();
+
+            if (row == null || row.Cells == null || !row.Cells.Any()) return pairs;
+
+            if (list == null || !list.Any()) return pairs;
+
+            var columns = row.Cells.Select(t => t.GetDecodeEscapes()).Distinct().ToList();
+            foreach (string key in list)
+            {
+                if (!pairs.ContainsKey(key) && columns.Contains(key))
+                {
+                    pairs.Add(key, columns.IndexOf(key));
+                }
+            }
+
+            return pairs;
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractHelper/ExcelStyle.cs

+using NPOI.HSSF.Util;
+using NPOI.SS.UserModel;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class ExcelStyle
+    {
+        private readonly IWorkbook workbook;
+
+        public ExcelStyle(IWorkbook workbook)
+        {
+            this.workbook = workbook ?? throw new ArgumentNullException(nameof(IWorkbook));
+        }
+
+        public ICellStyle GetEmptyCellStyle()
+        {
+            return workbook.CreateCellStyle();
+        }
+
+        public ICellStyle GetCellStyle()
+        {
+            ICellStyle cellStyle = workbook.CreateCellStyle();
+            SetFont(cellStyle);
+            SetBorder(cellStyle);
+            SetAlignment(cellStyle);
+            return cellStyle;
+        }
+
+        public void SetFont(ICellStyle cellStyle, short fontSize = 11, string fontName = "微软雅黑", short fontColor = HSSFColor.Black.Index)
+        {
+            //字体
+            IFont font = workbook.CreateFont();
+            font.FontHeightInPoints = fontSize;
+            font.FontName = fontName;
+            font.Color = fontColor;
+            cellStyle.SetFont(font);
+        }
+
+        public void SetBorder(ICellStyle cellStyle, BorderStyle borderStyle = BorderStyle.Thin, short borderColor = HSSFColor.Black.Index)
+        {
+            //边框
+            cellStyle.BorderBottom = borderStyle;
+            cellStyle.BorderLeft = borderStyle;
+            cellStyle.BorderRight = borderStyle;
+            cellStyle.BorderTop = borderStyle;
+
+            //边框颜色  
+            cellStyle.BottomBorderColor = borderColor;
+            cellStyle.TopBorderColor = borderColor;
+            cellStyle.LeftBorderColor = borderColor;
+            cellStyle.RightBorderColor = borderColor;
+        }
+
+        public void SetAlignment(ICellStyle cellStyle, HorizontalAlignment horizontal = HorizontalAlignment.Center, VerticalAlignment vertical = VerticalAlignment.Center)
+        {
+            //水平居中
+            cellStyle.Alignment = horizontal;
+            //垂直居中
+            cellStyle.VerticalAlignment = vertical;
+        }
+
+        public void SetBackgroundColor(ICellStyle cellStyle, short foregroundColor)
+        {
+            cellStyle.FillForegroundColor = foregroundColor;
+            cellStyle.FillPattern = FillPattern.SolidForeground;
+        }
+
+        public ICellStyle SetBgkColorAndFormat(ICellStyle cellStyle, StyleType type = StyleType.默认, CellFormat format = CellFormat.默认)
+        {
+            SetBackgroundColor(cellStyle, type);
+            if (format != CellFormat.默认) SetDataFormat(cellStyle, format);
+            return cellStyle;
+        }
+
+        private void SetBackgroundColor(ICellStyle cellStyle, StyleType type)
+        {
+            switch (type)
+            {
+                case StyleType.列头:
+                    cellStyle.FillForegroundColor = HSSFColor.Gold.Index;
+                    cellStyle.FillPattern = FillPattern.SolidForeground;
+                    break;
+                case StyleType.系数:
+                    cellStyle.FillForegroundColor = HSSFColor.Green.Index;
+                    cellStyle.FillPattern = FillPattern.SolidForeground;
+                    break;
+                case StyleType.数据:
+                    cellStyle.FillForegroundColor = HSSFColor.SkyBlue.Index;
+                    cellStyle.FillPattern = FillPattern.SolidForeground;
+                    break;
+                case StyleType.Remove:
+                    cellStyle.FillForegroundColor = HSSFColor.Orange.Index;
+                    cellStyle.FillPattern = FillPattern.SolidForeground;
+                    break;
+                case StyleType.默认:
+                default:
+                    cellStyle.FillForegroundColor = HSSFColor.White.Index;
+                    cellStyle.FillPattern = FillPattern.SolidForeground;
+                    break;
+            }
+        }
+
+        private void SetDataFormat(ICellStyle cellStyle, CellFormat format)
+        {
+            IDataFormat datastyle = workbook.CreateDataFormat();
+            switch (format)
+            {
+                case CellFormat.时间:
+                    cellStyle.DataFormat = datastyle.GetFormat("yyyy/mm/dd");
+                    break;
+                case CellFormat.数字:
+                    cellStyle.DataFormat = datastyle.GetFormat("0");
+                    break;
+                case CellFormat.数字2:
+                    cellStyle.DataFormat = datastyle.GetFormat("0.00");
+                    break;
+                case CellFormat.百分比:
+                    cellStyle.DataFormat = datastyle.GetFormat("0%");
+                    break;
+                case CellFormat.百分比2:
+                    cellStyle.DataFormat = datastyle.GetFormat("0.00%");
+                    break;
+                case CellFormat.默认:
+                default:
+                    break;
+            }
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/ExtractHelper/ExtractHelper.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using Performance.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class ExtractHelper
+    {
+        public static string GetExtractFile(int hospitalId, ref string newFilePath, string allotFilePath = "")
+        {
+            string originalPath = string.IsNullOrEmpty(allotFilePath)
+                ? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Template", "医院绩效模板.xls")
+                : allotFilePath;
+            var (tempPath, filePath) = CopyOriginalFile(hospitalId, originalPath);
+            newFilePath = filePath;
+            return tempPath;
+        }
+
+        private static (string TempPath, string FilePath) CopyOriginalFile(int hospitalId, string originalPath)
+        {
+            var ext = FileHelper.GetExtension(originalPath);
+            var dpath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Files", $"{hospitalId}", "autoextract");
+            FileHelper.CreateDirectory(dpath);
+            string tempPath = Path.Combine(dpath, $"Template{DateTime.Now.ToString("yyyyMMddHHmmssfff")}{ext}");
+            FileHelper.Copy(originalPath, tempPath);
+            string filePath = Path.Combine(dpath, $"绩效提取数据{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.xls");
+            return (tempPath, filePath);
+        }
+
+        public static void CreateNotExistSheet(List<ex_module> modulesList, IWorkbook workbook)
+        {
+            SortedDictionary<string, int> pairs = new SortedDictionary<string, int>();
+            for (int i = 0; i < workbook.NumberOfSheets; i++)
+            {
+                var sheetname = workbook.GetSheetAt(i).SheetName;
+                if (!pairs.Keys.Contains(sheetname))
+                    pairs.Add(workbook.GetSheetAt(i).SheetName, i);
+            }
+
+            int sheetIndex = 0;
+            int newSheetCount = 0;
+            foreach (var module in modulesList.Where(t => t.SheetType == (int)SheetType.Income)?.OrderBy(t => t.ModuleName))
+            {
+                var sheet = workbook.GetSheet(module.ModuleName);
+                if (sheet == null)
+                {
+                    string[] keyArray = new string[] { "开单", "执行" };
+                    if (keyArray.Any(key => module.ModuleName.Contains(key)))
+                    {
+                        var item = pairs.Where(t => t.Key.StartsWith("1.")).OrderByDescending(t => t.Key).First();
+                        if (sheetIndex == 0)
+                            sheetIndex = item.Value + 1;
+                        var copysheet = workbook.GetSheet(item.Key);
+                        var newSheet = copysheet.CopySheet(module.ModuleName, true);
+                        workbook.SetSheetOrder(newSheet.SheetName, sheetIndex);
+                        sheetIndex++; newSheetCount++;
+                    }
+                }
+            }
+
+            sheetIndex = 0;
+            foreach (var module in modulesList.Where(t => t.SheetType == (int)SheetType.Workload)?.OrderBy(t => t.ModuleName))
+            {
+                var sheet = workbook.GetSheet(module.ModuleName);
+                if (sheet == null)
+                {
+                    string key = "工作量";
+                    if (module.ModuleName.Contains(key))
+                    {
+                        var item = pairs.Where(t => t.Key.StartsWith("3.")).OrderByDescending(t => t.Key).First();
+                        if (sheetIndex == 0)
+                            sheetIndex = item.Value + newSheetCount + 1;
+                        var copysheet = workbook.GetSheet(item.Key);
+                        var newSheet = copysheet.CopySheet(module.ModuleName, true);
+                        workbook.SetSheetOrder(newSheet.SheetName, sheetIndex);
+                        sheetIndex++;
+                    }
+                }
+            }
+        }
+
+        public static void ClearSheetPartialData(ISheet sheet, PerSheetPoint point, SheetType sheetType)
+        {
+            if (sheet == null)
+                return;
+
+            for (int i = point.DataFirstRowNum.Value; i < sheet.LastRowNum + 1; i++)
+            {
+                var row = sheet.GetRow(i);
+                if (row != null)
+                {
+                    int dataFirstCellRowNum = point.DataFirstCellNum.Value;
+                    //跳过核算单元和科室
+                    for (int j = dataFirstCellRowNum; j < row.LastCellNum; j++)
+                    {
+                        var cell = row.GetCell(j);
+                        if (cell != null && (cell.CellType != CellType.Formula || sheetType == SheetType.Income))
+                        {
+                            cell.RemoveCellComment();
+                            row.RemoveCell(cell);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/AccountBasicDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    class AccountBasicDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null)
+        {
+
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/ClinicEmployeeDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    class ClinicEmployeeDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null)
+        {
+
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/EmployeeDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    public class EmployeeDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict)
+        {
+            if (data is List<per_employee> employees && employees.Any(t => accountingUnits.Contains(t.UnitType)))
+            {
+                int dataFirstRowNum = point.DataFirstRowNum.Value;
+
+                var columns = sheet.CreateRow(point.HeaderFirstRowNum.Value).GetCellValues();
+
+                ClearSheetPartialData(sheet, employees, columns, ref dataFirstRowNum);
+
+                foreach (var employee in employees)
+                {
+                    var row = sheet.GetOrCreate(dataFirstRowNum);
+                    for (int cellIndex = 0; cellIndex < columns.Count(); cellIndex++)
+                    {
+                        var column = columns[cellIndex];
+                        if (string.IsNullOrEmpty(column) || !employeeDict.ContainsKey(column)) continue;
+
+                        var cell = row.GetOrCreate(cellIndex);
+                        cell.SetCellOValue(employeeDict[column].Invoke(employee));
+                    }
+                    dataFirstRowNum++;
+                }
+            }
+        }
+
+        private void ClearSheetPartialData(ISheet sheet, List<per_employee> employees, List<string> columns, ref int dataFirstRowNum)
+        {
+            var pairs = new Dictionary<string, int>();
+            foreach (var key in new string[] { "核算单元", "人员工号", "医生姓名" })
+            {
+                if (!pairs.ContainsKey(key) && columns.Contains(key))
+                    pairs.Add(key, columns.IndexOf(key));
+            }
+
+            var clearDict = new Dictionary<string, int>();
+            foreach (var key in new string[] { "出勤率" })
+            {
+                if (!clearDict.ContainsKey(key) && columns.Contains(key))
+                    clearDict.Add(key, columns.IndexOf(key));
+            }
+
+            for (int rowIndex = dataFirstRowNum; rowIndex < sheet.LastRowNum; rowIndex++)
+            {
+                var row = sheet.GetRow(dataFirstRowNum);
+
+                string accountingUnit = row.GetOrCreate(pairs["核算单元"]).GetDecodeEscapes();
+                string personnel = row.GetOrCreate(pairs["人员工号"]).GetDecodeEscapes();
+                string doctorName = row.GetOrCreate(pairs["医生姓名"]).GetDecodeEscapes();
+
+                var employee = employees.FirstOrDefault(t => t.AccountingUnit == accountingUnit && t.PersonnelNumber == personnel && t.DoctorName == doctorName);
+                if (employee == null)
+                {
+
+                }
+                else
+                {
+                    foreach (var clear in clearDict)
+                    {
+                        if (clear.Value < 0) return;
+                        var cell = row.GetOrCreate(clear.Value);
+                        if (cell.CellType != CellType.Formula) cell.SetCellValue("");
+                    }
+                    employees.Remove(employee);
+                }
+                if (rowIndex > dataFirstRowNum) dataFirstRowNum = rowIndex + 1;
+            }
+        }
+
+        private readonly string[] accountingUnits = new string[] { AccountUnitType.行政高层.ToString(), AccountUnitType.行政中层.ToString(), AccountUnitType.行政工勤.ToString() };
+
+        private readonly Dictionary<string, Func<per_employee, object>> employeeDict = new Dictionary<string, Func<per_employee, object>>
+        {
+            {  "人员分类", (t) => t.UnitType },
+            {  "核算单元", (t) => t.AccountingUnit },
+            {  "人员工号", (t) => t.PersonnelNumber },
+            {  "医生姓名", (t) => t.DoctorName },
+            {  "参加工作时间", (t) => t.WorkTime },
+            {  "出勤率", (t) => t.Attendance },
+        };
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/ISheetDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    public interface ISheetDataWrite
+    {
+        void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects);
+
+        void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null);
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/IncomeDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    public class IncomeDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+            if (collects == null || !collects.Any(t => !string.IsNullOrEmpty(t.TypeName))) return;
+
+            var columns = collects.Where(t => !string.IsNullOrEmpty(t.TypeName)).Select(t => t.TypeName).Distinct().OrderBy(t => t).ToList();
+
+            var headers = columns.Select(t => new ExcelHeader
+            {
+                ColumnName = t.Trim(),
+                DoctorFactor = 0,
+                NurseFactor = 0,
+                TechnicianFactor = 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            WriteDataHelper.WriteCollectData(sheet, point, sheetType, style, columns, collects);
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null)
+        {
+            var modules = exdict[ExDataDict.ExModule] as List<ex_module>;
+            var module = modules?.FirstOrDefault(t => t.SheetType == (int)sheetType && t.ModuleName.NoBlank() == sheet.SheetName.NoBlank());
+            if (module == null) return;
+
+            var items = exdict[ExDataDict.ExItem] as List<ex_item>;
+            var modelItems = items?.Where(t => t.ModuleId == module.Id);
+            if (modelItems == null || !modelItems.Any()) return;
+
+            var headers = modelItems.Select(t => new ExcelHeader
+            {
+                ColumnName = t.ItemName.Trim(),
+                DoctorFactor = t.FactorValue1 ?? 0,
+                NurseFactor = t.FactorValue2 ?? 0,
+                TechnicianFactor = t.FactorValue3 ?? 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            if (data is List<ExtractTransDto> extractDto && extractDto.Any())
+            {
+                var columns = headers.Select(t => t.ColumnName).ToList();
+                WriteDataHelper.WriteSheetData(sheet, point, sheetType, style, columns, extractDto);
+            }
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/OtherIncomeDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    public class OtherIncomeDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+            if (collects == null || !collects.Any(t => !string.IsNullOrEmpty(t.TypeName))) return;
+
+            var columns = collects.Where(t => !string.IsNullOrEmpty(t.TypeName)).Select(t => t.TypeName).Distinct().OrderBy(t => t).ToList();
+
+            var headers = columns.Select(t => new ExcelHeader
+            {
+                ColumnName = t.Trim(),
+                DoctorFactor = 0,
+                NurseFactor = 0,
+                TechnicianFactor = 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            WriteDataHelper.WriteCollectData(sheet, point, sheetType, style, columns, collects);
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null)
+        {
+            var modules = exdict[ExDataDict.ExModule] as List<ex_module>;
+            var module = modules?.FirstOrDefault(t => t.SheetType == (int)sheetType && t.ModuleName.NoBlank() == sheet.SheetName.NoBlank());
+            if (module == null) return;
+
+            var items = exdict[ExDataDict.ExItem] as List<ex_item>;
+            var modelItems = items?.Where(t => t.ModuleId == module.Id);
+            if (modelItems == null || !modelItems.Any()) return;
+
+            var headers = modelItems.Select(t => new ExcelHeader
+            {
+                ColumnName = t.ItemName,
+                DoctorFactor = t.FactorValue1 ?? 0,
+                NurseFactor = t.FactorValue2 ?? 0,
+                TechnicianFactor = t.FactorValue3 ?? 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            if (data is List<ExtractTransDto> extractDto && extractDto.Any())
+            {
+                var columns = headers.Select(t => t.ColumnName).ToList();
+                WriteDataHelper.WriteSheetData(sheet, point, sheetType, style, columns, extractDto);
+            }
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/SheetDataWrite/WorkloadDataWrite.cs

+using NPOI.SS.UserModel;
+using Performance.DtoModels;
+using Performance.EntityModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService.SheetDataWrite
+{
+    public class WorkloadDataWrite : ISheetDataWrite
+    {
+        public void WriteCollectData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, List<collect_data> collects)
+        {
+            if (collects == null || !collects.Any(t => !string.IsNullOrEmpty(t.TypeName))) return;
+
+            var columns = collects.Where(t => !string.IsNullOrEmpty(t.TypeName)).Select(t => t.TypeName).Distinct().OrderBy(t => t).ToList();
+
+            var headers = columns.Select(t => new ExcelHeader
+            {
+                ColumnName = t.Trim(),
+                DoctorFactor = 0,
+                NurseFactor = 0,
+                TechnicianFactor = 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            WriteDataHelper.WriteCollectData(sheet, point, sheetType, style, columns, collects);
+        }
+
+        public void WriteSheetData(ISheet sheet, PerSheetPoint point, SheetType sheetType, ExcelStyle style, object data, Dictionary<ExDataDict, object> exdict = null)
+        {
+            var modules = exdict[ExDataDict.ExModule] as List<ex_module>;
+            var module = modules?.FirstOrDefault(t => t.SheetType == (int)sheetType && t.ModuleName.NoBlank() == sheet.SheetName.NoBlank());
+            if (module == null) return;
+
+            var items = exdict[ExDataDict.ExItem] as List<ex_item>;
+            var modelItems = items?.Where(t => t.ModuleId == module.Id);
+            if (modelItems == null || !modelItems.Any()) return;
+
+            var headers = modelItems.Select(t => new ExcelHeader
+            {
+                ColumnName = t.ItemName,
+                WorkloadFactor = t.FactorValue1 ?? 0
+            }).ToList();
+
+            WriteDataHelper.WriteSheetHeader(sheet, point, sheetType, style, headers);
+            if (data is List<ExtractTransDto> extractDto && extractDto.Any())
+            {
+                var columns = headers.Select(t => t.ColumnName).Intersect(extractDto.Select(t => t.Category))?.ToList();
+                WriteDataHelper.WriteSheetData(sheet, point, sheetType, style, columns, extractDto);
+            }
+        }
+    }
+}

performance/Performance.Services/ExtractExcelService/WriteDataFactory.cs

+using Performance.DtoModels;
+using Performance.Services.ExtractExcelService.SheetDataWrite;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Performance.Services.ExtractExcelService
+{
+    public class WriteDataFactory
+    {
+        public ISheetDataWrite GetWriteData(SheetType sheetType)
+        {
+            ISheetDataWrite factory;
+            switch (sheetType)
+            {
+                //case SheetType.Employee:
+                //    factory = new EmployeeDataWrite();
+                //    break;
+                //case SheetType.ClinicEmployee:
+                //    factory = new ClinicEmployeeDataWrite();
+                //    break;
+                case SheetType.OtherIncome:
+                case SheetType.Expend:
+                    factory = new OtherIncomeDataWrite();
+                    break;
+                case SheetType.Income:
+                    factory = new IncomeDataWrite();
+                    break;
+                case SheetType.Workload:
+                    factory = new WorkloadDataWrite();
+                    break;
+                //case SheetType.AccountBasic:
+                //    factory = new AccountBasicDataWrite();
+                //    break;
+                case SheetType.SpecialUnit:
+                    factory = new SpecialUnitDataWrite();
+                    break;
+                default:
+                    return null;
+            }
+            return factory;
+        }
+    }
+}

performance/Performance.Services/PerExcelService/SheetDataRead/PerSheetDataReadExpend.cs

@@ -19,6 +19,7 @@ public class PerSheetDataReadExpend : IPerSheetDataRead
             HeaderLastRowNum = 4,
             HeaderFirstCellNum = 3,
             DataFirstRowNum = 5,
+            DataFirstCellNum = 7,
             AccountingUnit = new List<AccountingUnit>
             {
                  new AccountingUnit

performance/Performance.Services/PerExcelService/SheetDataRead/PerSheetDataReadIncome.cs

@@ -19,6 +19,7 @@ public class PerSheetDataReadIncome : IPerSheetDataRead
             HeaderLastRowNum = 4,
             HeaderFirstCellNum = 3,
             DataFirstRowNum = 5,
+            DataFirstCellNum = 7,
             AccountingUnit = new List<AccountingUnit>
             {
                 //核算单元（医技组）

performance/Performance.Services/PerExcelService/SheetDataRead/PerSheetDataReadOtherIncome.cs

@@ -19,6 +19,7 @@ public class PerSheetDataReadOtherIncome : IPerSheetDataRead
             HeaderLastRowNum = 4,
             HeaderFirstCellNum = 3,
             DataFirstRowNum = 5,
+            DataFirstCellNum = 7,
             AccountingUnit = new List<AccountingUnit>
             {
                 //核算单元（医技组）

performance/Performance.Services/PerExcelService/SheetDataRead/PerSheetDataReadWorkload.cs

@@ -19,6 +19,7 @@ public class PerSheetDataReadWorkload : IPerSheetDataRead
             HeaderLastRowNum = 1,
             HeaderFirstCellNum = 1,
             DataFirstRowNum = 3,
+            DataFirstCellNum = 3,
             AccountingUnit = new List<AccountingUnit>
             {
                new AccountingUnit