DF22001YiQi.git

using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.Extensions;
using Furion.FriendlyException;
using iWare.Wms.Core;
using iWare.Wms.Core.Util;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Web;
 
namespace iWare.Wms.Application
{
    /// <summary>
    /// 设备基础信息管理服务
    /// </summary>
    [ApiDescriptionSettings("基础数据管理", Name = "EquipmentBaseInfo", Order = 100)]
    [Route("api/[Controller]")]
    public class EquipmentBaseInfoService : IEquipmentBaseInfoService, IDynamicApiController, ITransient
    {
        private readonly IRepository<EquipmentBaseInfo, MasterDbContextLocator> _equipmentBaseInfoRep;
        private readonly IRepository<Equipmentbaseinfolog, MasterDbContextLocator> _equipmentbaseinfologRep;
        private readonly IRepository<V_GetEquipmentAlert, MasterDbContextLocator> _v_GetEquipmentAlertRep;
        private readonly IRepository<SysDictType, MasterDbContextLocator> _sysDictTypeRep;
        private readonly IRepository<SysDictData, MasterDbContextLocator> _sysDictDataRep;
        private readonly IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> _equipmentCurrentMonitorRep;
 
        /// <summary>
        /// 设备基础信息构造
        /// </summary>
        /// <param name="equipmentBaseInfoRep"></param>
        /// <param name="v_GetEquipmentAlert"></param>
        /// <param name="sysDictTypeRep"></param>
        /// <param name="sysDictDataRep"></param>
        /// <param name="equipmentCurrentMonitorRep"></param>
        public EquipmentBaseInfoService(
            IRepository<Equipmentbaseinfolog, MasterDbContextLocator> equipmentbaseinfologRep,
            IRepository<EquipmentBaseInfo, MasterDbContextLocator> equipmentBaseInfoRep,
            IRepository<V_GetEquipmentAlert, MasterDbContextLocator> v_GetEquipmentAlert,
            IRepository<SysDictType, MasterDbContextLocator> sysDictTypeRep,
            IRepository<SysDictData, MasterDbContextLocator> sysDictDataRep,
            IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> equipmentCurrentMonitorRep
        )
        {
            _equipmentbaseinfologRep = equipmentbaseinfologRep;
            _equipmentBaseInfoRep = equipmentBaseInfoRep;
            _v_GetEquipmentAlertRep = v_GetEquipmentAlert;
            _sysDictTypeRep = sysDictTypeRep;
            _sysDictDataRep = sysDictDataRep;
            _equipmentCurrentMonitorRep = equipmentCurrentMonitorRep;
        }
 
 
 
        /// <summary>
        /// 查询设备告警信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("getAlert")]
        public async Task<List<EquipmentAlertInfoOutput>> Page([FromQuery] EquipmentAlertSearch input)
        {
            var equipmentAlertInfos = await _v_GetEquipmentAlertRep.DetachedEntities
                                     .Where(!string.IsNullOrEmpty(input.EquipmentId), u => u.EquipmentId == input.EquipmentId)
                                     .Where(!string.IsNullOrEmpty(input.EquipmentName), u => EF.Functions.Like(u.EquipmentName, $"%{input.EquipmentName.Trim()}%"))
                                     .Where(!string.IsNullOrEmpty(input.WorkingProcedure), u => u.WorkingProcedure.Equals(input.WorkingProcedure))
                                     .Where(!string.IsNullOrEmpty(input.AlertType), u => (input.AlertType.Equals("1") && u.IsAlertDetergent)
                                     || (input.AlertType.Equals("2") && u.IsAlertKnifeTool)
                                     || (input.AlertType.Equals("3") && u.IsAlertCuttingFluid)
                                     || (input.AlertType.Equals("4") && u.IsAlert))
                                     .OrderBy(PageInputOrder.OrderBuilder<EquipmentAlertSearch>(input))
                                     .ProjectToType<EquipmentAlertInfoOutput>().ToListAsync();
            return equipmentAlertInfos;
        }
        /// <summary>
        /// 分页查询设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("page")]
        public async Task<PageResult<EquipmentBaseInfoOutput>> Page([FromQuery] EquipmentBaseInfoSearch input)
        {
            var equipmentBaseInfos = await _equipmentBaseInfoRep.DetachedEntities
                                     .Where(!string.IsNullOrEmpty(input.EquipmentId), u => u.EquipmentId == input.EquipmentId)
                                     .Where(!string.IsNullOrEmpty(input.EquipmentName), u => u.EquipmentName == input.EquipmentName)
                                     .Where(!string.IsNullOrEmpty(input.WorkingProcedure), u => EF.Functions.Like(u.WorkingProcedure, $"%{input.WorkingProcedure.Trim()}%"))
                                     .Where(!string.IsNullOrEmpty(input.EquipmentModel), u => EF.Functions.Like(u.EquipmentModel, $"%{input.EquipmentModel.Trim()}%"))
                                     .Select(s => new EquipmentBaseInfoOutput
                                     {
                                         Id = s.Id,
                                         EquipmentId = s.EquipmentId,
                                         EquipmentName = s.EquipmentName,
                                         WorkingProcedure = s.WorkingProcedure,
                                         EquipmentModel = s.EquipmentModel,
                                         EquipmentIP = s.EquipmentIP,
                                         EquipmentFunction = s.EquipmentFunction,
                                         EquipmentBrand = s.EquipmentBrand,
                                         EquipmentManufacturer = s.EquipmentManufacturer,
                                         Detergentchangetime = s.Detergentchangetime,
                                         DetergentChangeAlertThreshold = s.DetergentChangeAlertThreshold,
                                         DetergentChangeCycle = s.DetergentChangeCycle,
                                         KnifeToolChangeTime = s.KnifeToolChangeTime,
                                         KnifeToolChangeAlertThreshold = s.KnifeToolChangeAlertThreshold,
                                         CuttingFluidChangeAlertThreshold = s.CuttingFluidChangeAlertThreshold,
                                         CuttingFluidChangeTime = s.CuttingFluidChangeTime,
                                         Remarks = s.Remarks,
                                         CreatedTime = s.CreatedTime,
                                         TactTime = s.TactTime,
                                         DetergentAddtime = s.DetergentAddtime,
                                         CuttingFluidAddTime = s.CuttingFluidAddTime,
                                     })
                                     .Distinct()
                                     .OrderBy(PageInputOrder.OrderBuilder<EquipmentBaseInfoSearch>(input))
                                     .ProjectToType<EquipmentBaseInfoOutput>()
                                     .ToADPagedListAsync(input.PageNo, input.PageSize);
            return equipmentBaseInfos;
 
        }
 
        /// <summary>
        /// 根据设备基础信息管理导出Excel
        /// </summary>
        /// <param name="input">设备基础信息管理</param>
        /// <returns>导出的Excel文件</returns>
        [HttpGet("toExcel")]
        public async Task<IActionResult> ToExcelAsync([FromQuery] EquipmentBaseInfoSearch input)
        {
            var equipmentBaseInfos = await _equipmentBaseInfoRep.DetachedEntities
                                     .Where(!string.IsNullOrEmpty(input.EquipmentId), u => u.EquipmentId == input.EquipmentId)
                                     .Where(!string.IsNullOrEmpty(input.EquipmentName), u => u.EquipmentName == input.EquipmentName)
                                     .Where(!string.IsNullOrEmpty(input.WorkingProcedure), u => EF.Functions.Like(u.WorkingProcedure, $"%{input.WorkingProcedure.Trim()}%"))
                                     .Where(!string.IsNullOrEmpty(input.EquipmentModel), u => EF.Functions.Like(u.EquipmentModel, $"%{input.EquipmentModel.Trim()}%"))
                                     .Select(s => new EquipmentBaseInfoExcelOutput
                                     {
                                         Id = s.Id,
                                         EquipmentId = s.EquipmentId,
                                         EquipmentName = s.EquipmentName,
                                         WorkingProcedure = s.WorkingProcedure,
                                         EquipmentModel = s.EquipmentModel,
                                         EquipmentIP = s.EquipmentIP,
                                         EquipmentFunction = s.EquipmentFunction,
                                         //EquipmentBrand = s.EquipmentBrand,
                                         EquipmentManufacturer = s.EquipmentManufacturer,
                                         Detergentchangetime = s.Detergentchangetime,
                                         DetergentChangeAlertThreshold = s.DetergentChangeAlertThreshold,
                                         //DetergentChangeCycle = s.DetergentChangeCycle,
                                         CuttingFluidChangeTime = s.CuttingFluidChangeTime,
                                         CuttingFluidChangeAlertThreshold = s.CuttingFluidChangeAlertThreshold,
                                         CreatedTime = s.CreatedTime.ConvertToDateTime(),
                                         UpdatedTime = s.UpdatedTime.ConvertToDateTime(),
                                         TactTime = s.TactTime,
                                     })
                                     .Distinct()
                                     .OrderBy(PageInputOrder.OrderBuilder<EquipmentBaseInfoSearch>(input))
                                     .ProjectToType<EquipmentBaseInfoExcelOutput>().ToListAsync();
 
            //foreach (EquipmentBaseInfoExcelOutput item in equipmentBaseInfos)
            //{
            //    item.CreatedTime = !item.CreatedTime.HasValue ? null : Convert.ToDateTime(item.CreatedTime).ToString("yyyy-MM-dd hh:mm");
            //}
 
            MemoryStream ms = new();
            DataConvertUtil.ToExcelData(equipmentBaseInfos, _sysDictTypeRep, _sysDictDataRep, out List<string> headers,
                out List<List<object>> data, out string sheetName);
 
            ExcelUtil.ToExcel(headers, data, sheetName, ms);
            ms.Position = 0;
            var fileName = HttpUtility.UrlEncode($"{sheetName}[{DateTimeOffset.Now:yyyy-MM-dd}].xlsx", Encoding.GetEncoding("UTF-8"));
            return new FileStreamResult(ms, "application/octet-stream") { FileDownloadName = fileName };
        }
 
        /// <summary>
        /// 增加设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("add")]
        [UnitOfWork]
        public async Task Add(AddEquipmentBaseInfoInput input)
        {
            var isExist = await _equipmentBaseInfoRep.AnyAsync(u => u.EquipmentId == input.EquipmentId, false);
            if (isExist) throw Oops.Oh($"当前设备编号已存在，新增失败！");
 
            var equipmentBaseInfo = input.Adapt<EquipmentBaseInfo>();
            equipmentBaseInfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            await _equipmentBaseInfoRep.InsertAsync(equipmentBaseInfo);
 
            //新增维护日志
            var log = new Equipmentbaseinfolog()
            {
                EquipmentBaseInfoId = equipmentBaseInfo.Id,
                EquipmentID = equipmentBaseInfo.EquipmentId,
                OperatorType = EquipmentbaseinfoOperatorTypeEnum.新增设备,
                OperatorTypeName = (EquipmentbaseinfoOperatorTypeEnum.新增设备).ToString(),
                OperatorContent = "新增设备:" + equipmentBaseInfo.EquipmentName,
            };
            await _equipmentbaseinfologRep.InsertAsync(log);
        }
 
        /// <summary>
        /// 删除设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task Delete(DeleteEquipmentBaseInfoInput input)
        {
            string[] EquiArr = new string[] { "EOP10", "EOP20", "EOP30", "EOP35", "EOP40", "EOP50", "EOP60", "EOP70", "EOP80" };
 
            var equipmentBaseInfo = await _equipmentBaseInfoRep.FirstOrDefaultAsync(u => u.Id == input.Id);
 
            if (EquiArr.Contains(equipmentBaseInfo.EquipmentId)) throw Oops.Oh($"系统默认的设备不能进行删除！");
 
            await _equipmentBaseInfoRep.DeleteAsync(equipmentBaseInfo);
        }
 
        /// <summary>
        /// 批量删除设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("selectDelete")]
        public async Task SelectDelete(List<EquipmentBaseInfoInput> input)
        {
            StringBuilder builder = new StringBuilder();
            string[] EquiArr = new string[] { "EOP10", "EOP20", "EOP30", "EOP35", "EOP40", "EOP50", "EOP60", "EOP70", "EOP80" };
            foreach (EquipmentBaseInfoInput item in input)
            {
                if (EquiArr.Contains(item.EquipmentId))
                {
 
                    if (string.IsNullOrEmpty(builder.ToString()))
                    {
                        builder.Append(item.EquipmentId);
                    }
                    else
                    {
                        builder.Append("," + item.EquipmentId);
                    }
                }
            }
 
            if (!string.IsNullOrEmpty(builder.ToString()))
            {
                throw Oops.Oh($"系统默认的设备【" + builder.ToString() + "】不能进行删除！");
            }
 
            foreach (var item in input)
            {
                var equipmentBaseInfo = await _equipmentBaseInfoRep.FirstOrDefaultAsync(u => u.Id == item.Id);
                await _equipmentBaseInfoRep.DeleteAsync(equipmentBaseInfo);
            }
        }
 
        /// <summary>
        /// 更新设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("edit")]
        [UnitOfWork]
        public async Task Update(UpdateEquipmentBaseInfoInput input)
        {
            var isExistObj = await _equipmentBaseInfoRep.Where(u => u.Id == input.Id && u.EquipmentId == input.EquipmentId, false).FirstOrDefaultAsync();
            if (isExistObj == null) throw Oops.Oh($"设备编号不能进行变更，修改失败！");
 
            var equipmentBaseInfo = input.Adapt<EquipmentBaseInfo>();
            await _equipmentBaseInfoRep.UpdateAsync(equipmentBaseInfo, ignoreNullValues: false);
 
            if (isExistObj.CuttingFluidChangeTime?.ToString("yyyy-MM-dd") != equipmentBaseInfo.CuttingFluidChangeTime?.ToString("yyyy-MM-dd"))
            {
                //新增维护日志
                var log = new Equipmentbaseinfolog()
                {
                    EquipmentBaseInfoId = equipmentBaseInfo.Id,
                    EquipmentID = equipmentBaseInfo.EquipmentId,
                    OperatorType = EquipmentbaseinfoOperatorTypeEnum.切削液更换,
                    OperatorTypeName = (EquipmentbaseinfoOperatorTypeEnum.切削液更换).ToString(),
                    OperatorContent = "更换时间:" + equipmentBaseInfo.CuttingFluidChangeTime?.ToString("yyyy-MM-dd"),
                };
                await _equipmentbaseinfologRep.InsertAsync(log);
            }
            if (isExistObj.Detergentchangetime?.ToString("yyyy-MM-dd") != equipmentBaseInfo.Detergentchangetime?.ToString("yyyy-MM-dd"))
            {
                //新增维护日志
                var log = new Equipmentbaseinfolog()
                {
                    EquipmentBaseInfoId = equipmentBaseInfo.Id,
                    EquipmentID = equipmentBaseInfo.EquipmentId,
                    OperatorType = EquipmentbaseinfoOperatorTypeEnum.清洗液更换,
                    OperatorTypeName = (EquipmentbaseinfoOperatorTypeEnum.清洗液更换).ToString(),
                    OperatorContent = "更换时间:" + equipmentBaseInfo.Detergentchangetime?.ToString("yyyy-MM-dd"),
                };
                await _equipmentbaseinfologRep.InsertAsync(log);
            }
            if (isExistObj.DetergentAddtime?.ToString("yyyy-MM-dd") != equipmentBaseInfo.DetergentAddtime?.ToString("yyyy-MM-dd"))
            {
                //新增维护日志
                var log = new Equipmentbaseinfolog()
                {
                    EquipmentBaseInfoId = equipmentBaseInfo.Id,
                    EquipmentID = equipmentBaseInfo.EquipmentId,
                    OperatorType = EquipmentbaseinfoOperatorTypeEnum.清洗液添加,
                    OperatorTypeName = (EquipmentbaseinfoOperatorTypeEnum.清洗液添加).ToString(),
                    OperatorContent = "清洗液添加时间:" + equipmentBaseInfo.DetergentAddtime?.ToString("yyyy-MM-dd"),
                };
                await _equipmentbaseinfologRep.InsertAsync(log);
            }
            if (isExistObj.CuttingFluidAddTime?.ToString("yyyy-MM-dd") != equipmentBaseInfo.CuttingFluidAddTime?.ToString("yyyy-MM-dd"))
            {
                //新增维护日志
                var log = new Equipmentbaseinfolog()
                {
                    EquipmentBaseInfoId = equipmentBaseInfo.Id,
                    EquipmentID = equipmentBaseInfo.EquipmentId,
                    OperatorType = EquipmentbaseinfoOperatorTypeEnum.切削液添加,
                    OperatorTypeName = (EquipmentbaseinfoOperatorTypeEnum.切削液添加).ToString(),
                    OperatorContent = "切削液添加时间:" + equipmentBaseInfo.CuttingFluidAddTime?.ToString("yyyy-MM-dd"),
                };
                await _equipmentbaseinfologRep.InsertAsync(log);
            }
 
        }
 
        /// <summary>
        /// 获取设备基础信息管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("detail")]
        public async Task<EquipmentBaseInfoOutput> Get([FromQuery] QueryeEquipmentBaseInfoInput input)
        {
            return (await _equipmentBaseInfoRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id)).Adapt<EquipmentBaseInfoOutput>();
        }
 
        /// <summary>
        /// 获取设备基础信息管理列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("list")]
        public async Task<List<EquipmentBaseInfoOutput>> List([FromQuery] EquipmentBaseInfoInput input)
        {
            return await _equipmentBaseInfoRep.DetachedEntities.ProjectToType<EquipmentBaseInfoOutput>().ToListAsync();
        }
 
        /// <summary>
        /// 查询设备基础信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetSelectEquipmentName")]
        public async Task<List<EquipmentBaseInfoOutput>> GetSelectEquipmentName([FromQuery] string Type)
        {
            List<string> names = new List<string>();//有测量信息的设备
            names.Add("EOP10");
            names.Add("EOP20");
            names.Add("EOP30");
            names.Add("EOP35");
            names.Add("EOP40");
            names.Add("EOP60");
            names.Add("EOP80");
            List<string> KnifeToolnames = new List<string>();//有刀具的设备
            KnifeToolnames.Add("EOP10");
            KnifeToolnames.Add("EOP20");
            KnifeToolnames.Add("EOP35");
            KnifeToolnames.Add("EOP50");
            KnifeToolnames.Add("EOP60");
            var equipmentBaseInfos = await _equipmentBaseInfoRep.DetachedEntities
                    .Where(!string.IsNullOrEmpty(Type), u => (Type.ToUpper().Equals("QUALITY") ? names.Contains(u.EquipmentId) : false) || (Type.ToUpper().Equals("KNIFETOOL") ? KnifeToolnames.Contains(u.EquipmentId) : false))
                                     .ProjectToType<EquipmentBaseInfoOutput>()
                                     .OrderBy(o => o.EquipmentId)
                                     .ToListAsync();
            return equipmentBaseInfos;
        }
 
    }
}