DF22001YiQi.git

using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using iWare.Wms.Core;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System.Linq.Dynamic.Core;
 
namespace iWare.Wms.Application
{
    /// <summary>
    /// 设备刀具详情表服务
    /// </summary>
    [ApiDescriptionSettings("刀具相关", Name = "KnifeToolEquipmentInfo", Order = 101)]
    [Route("api/[Controller]")]
    public class KnifeToolEquipmentInfoService : IKnifeToolEquipmentInfoService, IDynamicApiController, ITransient
    {
        private readonly IRepository<KnifeToolEquipmentInfo,MasterDbContextLocator> _knifeToolEquipmentInfoRep;
        private readonly IRepository<KnifeToolEquipmentUpdateLog, MasterDbContextLocator> _knifeToolEquipmentUpdateLogRep;
        private readonly IRepository<KnifeToolEquipmentInfoLog, MasterDbContextLocator> _knifeToolEquipmentInfoLogRep;
        private readonly IRepository<EquipmentBaseInfo, MasterDbContextLocator> _equipmentBaseInfoRep;
        private readonly IRepository<KnifeToolBaseInfo, MasterDbContextLocator> _knifeToolBaseInfoRep;
 
 
        public KnifeToolEquipmentInfoService(
            IRepository<KnifeToolEquipmentInfo,MasterDbContextLocator> knifeToolEquipmentInfoRep
            , IRepository<KnifeToolEquipmentUpdateLog, MasterDbContextLocator> knifeToolEquipmentUpdateLogRep
            , IRepository<KnifeToolEquipmentInfoLog, MasterDbContextLocator> knifeToolEquipmentInfoLogRep
            , IRepository<EquipmentBaseInfo, MasterDbContextLocator> equipmentBaseInfoRep,
IRepository<KnifeToolBaseInfo, MasterDbContextLocator> knifeToolBaseInfoRep)
        {
            _knifeToolEquipmentInfoRep = knifeToolEquipmentInfoRep;
            _knifeToolEquipmentUpdateLogRep = knifeToolEquipmentUpdateLogRep;
            _knifeToolEquipmentInfoLogRep = knifeToolEquipmentInfoLogRep;
            _equipmentBaseInfoRep = equipmentBaseInfoRep;
            _knifeToolBaseInfoRep = knifeToolBaseInfoRep;
        }
 
        /// <summary>
        /// 分页查询设备刀具详情表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("page")]
        public async Task<PageResult<KnifeToolEquipmentInfoOutput>> Page([FromQuery] KnifeToolEquipmentInfoSearch input)
        {
            var knifeToolEquipmentInfos = await (from knife in _knifeToolEquipmentInfoRep.DetachedEntities
                                                 join toolbaseinfo in _knifeToolBaseInfoRep.DetachedEntities on knife.KnifeToolID equals toolbaseinfo.KnifeToolID into tooljoinEmpty
                                                 from toolbaseinfo2 in tooljoinEmpty.DefaultIfEmpty()
                                                 join eqbaseinfo in _equipmentBaseInfoRep.DetachedEntities on knife.EquipmentID equals eqbaseinfo.EquipmentId into eqjoinEmpty
                                                 from eqbaseinfo2 in eqjoinEmpty.DefaultIfEmpty()
                                                 where knife.EquipmentID == (string.IsNullOrEmpty(input.EquipmentID) ? knife.EquipmentID : input.EquipmentID)
                                                 where knife.KnifeToolID.Contains( (string.IsNullOrEmpty(input.KnifeToolID) ? knife.KnifeToolID : input.KnifeToolID))
                                                 select new KnifeToolEquipmentInfoOutput
                                                 {
                                                     EquipmentID = knife.EquipmentID,
                                                     EquipmentName= eqbaseinfo2.EquipmentName,
                                                     WorkingProcedure = knife.WorkingProcedure,
                                                     Station = knife.Station,
                                                     KnifeToolID = knife.KnifeToolID,
                                                     KnifeToolName = knife.KnifeToolName,
                                                     StartLife = knife.StartLife,
                                                     CurrentLife = knife.CurrentLife,
                                                     ChangeStartTime = knife.ChangeStartTime,
                                                     Remarks1 = knife.Remarks1,
                                                     Remarks2 = knife.Remarks2,
                                                     Remarks3 = knife.Remarks3,
                                                     Id = knife.Id,
                                                     KnifeToolLife= toolbaseinfo2.KnifeToolLife,
                                                     KnifeToolChangeAlertThreshold= toolbaseinfo2.KnifeToolChangeAlertThreshold,
                                                 })
                                     .OrderBy(PageInputOrder.OrderBuilder<KnifeToolEquipmentInfoSearch>(input))
                                     .ProjectToType<KnifeToolEquipmentInfoOutput>()
                                     .ToADPagedListAsync(input.PageNo, input.PageSize);
            return knifeToolEquipmentInfos;
        }
 
 
        /// <summary>
        /// 旧刀查询
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("OldKnifeQuery")]
        public async Task<PageResult<KnifeToolBaseInfoOutput>> OldKnifeQuery([FromQuery] KnifeToolBaseInfoSearch input)
        {
            var knifeToolBaseInfos = await (from knife in _knifeToolEquipmentInfoLogRep.DetachedEntities
                                            join eqbaseinfo in _equipmentBaseInfoRep.DetachedEntities on knife.EquipmentID equals eqbaseinfo.EquipmentId into eqjoinEmpty
                                            from eqbaseinfo2 in eqjoinEmpty.DefaultIfEmpty()
                                            join baseinfo in _knifeToolBaseInfoRep.DetachedEntities on knife.EquipmentID equals baseinfo.EquipmentID into joinEmpty
                                            from baseinfo2 in joinEmpty.DefaultIfEmpty()
                                            where knife.EquipmentID == input.EquipmentID
                                            where knife.WorkingProcedure == input.WorkingProcedure
                                            select new KnifeToolBaseInfoOutput
                                            {
 
                                                Id = knife.Id,
                                                KnifeToolID = knife.KnifeToolID,
                                                KnifeToolModel = baseinfo2.KnifeToolModel,
                                                KnifeEdgeNumber = baseinfo2.KnifeEdgeNumber,
                                                KnifeToolLife = baseinfo2.KnifeToolLife,
                                                KnifeLength = baseinfo2.KnifeLength,
                                                EquipmentID = knife.EquipmentID,
                                                EquipmentName = eqbaseinfo2.EquipmentName,
                                                CurrentLife=knife.CurrentLife,
                                                KnifeToolName=knife.KnifeToolName,
                                                KnifeToolChangeAlertThreshold = baseinfo2.KnifeToolChangeAlertThreshold,
                                                CreatedTime = knife.CreatedTime,
                                                Remarks = knife.Remarks1,
                                            })
                                            .GroupBy(x => new { x.KnifeToolName })
                                            .Select(o=>o.First())
                                     .ProjectToType<KnifeToolBaseInfoOutput>()
                                     .OrderBy(PageInputOrder.OrderBuilder<KnifeToolBaseInfoSearch>(input))
                                     .ToADPagedListAsync(input.PageNo, input.PageSize);
 
            return knifeToolBaseInfos;
        }
        /// <summary>
        /// 设备上刀
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("UpperKnife")]
        public async Task UpperKnife(UpperKnifeInput input)
        {
            if(string.IsNullOrEmpty(input.Station)|| string.IsNullOrEmpty(input.EquipmentID))
            {
                throw Oops.Oh("设备与工位信息必须输入！");
            }
            var isExist = await _knifeToolEquipmentInfoRep.AnyAsync(u => u.EquipmentID == input.EquipmentID&&u.Station==input.Station, false);
            if (isExist) throw Oops.Oh($"设备【{input.EquipmentID}】工位【{input.Station}】已有刀具！");
            if(input.Type==1)
            {//新刀
                input.KnifeToolName = DateTime.Now.ToString("yyyyMMddHHmmss");
            }
            else if(input.Type == 2)
            {//旧刀
                if (string.IsNullOrEmpty(input.KnifeToolName))
                {
                    throw Oops.Oh("刀具名称没有值！");
                }
            }
            else
            {
                throw Oops.Oh("请输入刀具新旧（新|旧）！");
            }
 
            var knifeToolEquipmentInfo = input.Adapt<KnifeToolEquipmentInfo>();
            knifeToolEquipmentInfo.StartLife = (int)input.CurrentLife;
            knifeToolEquipmentInfo.ChangeStartTime = DateTime.Now;
            await _knifeToolEquipmentInfoRep.InsertAsync(knifeToolEquipmentInfo);
 
 
            var log = knifeToolEquipmentInfo.Adapt<KnifeToolEquipmentUpdateLog>();
            log.OperateType = "上刀";
            log.OperateDesc = $"设备[{input.EquipmentID}]工序[{input.WorkingProcedure}]工位[{input.Station}] {input.TypeName}上刀，刀具名称为{input.KnifeToolName}";
            await _knifeToolEquipmentUpdateLogRep.InsertAsync(log);
        }
        /// <summary>
        /// 设备换刀
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("ChangeKnife")]
        public async Task ChangeKnife(UpperKnifeInput input)
        {
            if (input.oldId == null || input.oldId < 1)
            {
                throw Oops.Oh("请传入下刀的主键id！");
            }
            if (string.IsNullOrEmpty(input.Station) || string.IsNullOrEmpty(input.EquipmentID))
            {
                throw Oops.Oh("设备与工位信息必须输入！");
            }
            //上刀
            var isExist = await _knifeToolEquipmentInfoRep.AnyAsync(u => u.EquipmentID == input.EquipmentID && u.Station == input.Station, false);
            if (!isExist) throw Oops.Oh($"设备【{input.EquipmentID}】工位【{input.Station}】已有刀具！");
            if (input.Type == 1)
            {//新刀
                input.KnifeToolName = DateTime.Now.ToString("yyyyMMddHHmmss");
            }
            else if (input.Type == 2)
            {//旧刀
                if (string.IsNullOrEmpty(input.KnifeToolName))
                {
                    throw Oops.Oh("刀具名称没有值！");
                }
            }
            else
            {
                throw Oops.Oh("请输入刀具新旧（新|旧）！");
            }
            //下刀
            var isExistdown = await _knifeToolEquipmentInfoRep.AnyAsync(u => u.Id == input.oldId, false);
            if (!isExistdown) throw Oops.Oh($"当前刀具主键{input.oldId}没有找到刀具！");
 
 
 
            //下刀
            var knifeToolEquipmentInfo = await _knifeToolEquipmentInfoRep.FirstOrDefaultAsync(u => u.Id == input.oldId);
            await _knifeToolEquipmentInfoRep.DeleteAsync(knifeToolEquipmentInfo);
 
            var knifeToolEquipmentInfolog = knifeToolEquipmentInfo.Adapt<KnifeToolEquipmentInfoLog>();
            knifeToolEquipmentInfolog.ChangeEndTime = DateTime.Now;
            //knifeToolEquipmentInfolog.ResidueLife = input.ResidueLife;//剩余寿命
            knifeToolEquipmentInfolog.CurrentLife = input.oldCurrentLife;
            await _knifeToolEquipmentInfoLogRep.InsertAsync(knifeToolEquipmentInfolog);
 
            var log = knifeToolEquipmentInfolog.Adapt<KnifeToolEquipmentUpdateLog>();
            log.OperateType = "换刀";
            log.OperateDesc = $"设备[{knifeToolEquipmentInfolog.EquipmentID}]工序[{knifeToolEquipmentInfolog.WorkingProcedure}]工位[{knifeToolEquipmentInfolog.Station}] {input.TypeName}换刀下刀，刀具名称为{knifeToolEquipmentInfolog.KnifeToolName}";
            await _knifeToolEquipmentUpdateLogRep.InsertAsync(log);
 
 
            //上刀
            var knifeToolEquipmentInfoadd = input.Adapt<KnifeToolEquipmentInfo>();
            knifeToolEquipmentInfoadd.ChangeStartTime = DateTime.Now;
            knifeToolEquipmentInfoadd.StartLife = (int)input.CurrentLife;
            await _knifeToolEquipmentInfoRep.InsertAsync(knifeToolEquipmentInfoadd);
 
            var log2 = knifeToolEquipmentInfoadd.Adapt<KnifeToolEquipmentUpdateLog>();
            log2.OperateType = "换刀";
            log2.OperateDesc = $"设备[{knifeToolEquipmentInfoadd.EquipmentID}]工序[{knifeToolEquipmentInfoadd.WorkingProcedure}]工位[{knifeToolEquipmentInfoadd.Station}] {input.TypeName}换刀上刀，刀具名称为{knifeToolEquipmentInfoadd.KnifeToolName}";
            await _knifeToolEquipmentUpdateLogRep.InsertAsync(log2);
        }
 
        /// <summary>
        /// 设备下刀
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("DownKnife")]
        public async Task DownKnife(UpperKnifeInput input)
        {
            if (input.oldId == null || input.oldId <1)
            {
                throw Oops.Oh("请传入下刀的主键id！");
            }
            var isExist = await _knifeToolEquipmentInfoRep.AnyAsync(u => u.Id == input.oldId, false);
            if (!isExist) throw Oops.Oh($"当前刀具主键{input.oldId}没有找到刀具！");
 
            var knifeToolEquipmentInfo = await _knifeToolEquipmentInfoRep.FirstOrDefaultAsync(u => u.Id == input.oldId);
            await _knifeToolEquipmentInfoRep.DeleteAsync(knifeToolEquipmentInfo);
 
            var knifeToolEquipmentInfolog = knifeToolEquipmentInfo.Adapt<KnifeToolEquipmentInfoLog>();
            //knifeToolEquipmentInfolog.ResidueLife = input.ResidueLife;//剩余寿命
            knifeToolEquipmentInfolog.ChangeEndTime = DateTime.Now;
            knifeToolEquipmentInfolog.CurrentLife = input.CurrentLife;//下刀后当前寿命
            await _knifeToolEquipmentInfoLogRep.InsertAsync(knifeToolEquipmentInfolog);
 
            var log = knifeToolEquipmentInfolog.Adapt<KnifeToolEquipmentUpdateLog>();
            log.OperateType = "下刀";
            log.OperateDesc = $"设备[{knifeToolEquipmentInfolog.EquipmentID}]工序[{knifeToolEquipmentInfolog.WorkingProcedure}]工位[{knifeToolEquipmentInfolog.Station}] {input.TypeName}下刀，刀具名称为{knifeToolEquipmentInfolog.KnifeToolName}";
            await _knifeToolEquipmentUpdateLogRep.InsertAsync(log);
        }
 
        /// <summary>
        /// 增加设备刀具详情表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("add")]
        public async Task Add(AddKnifeToolEquipmentInfoInput input)
        {
            var knifeToolEquipmentInfo = input.Adapt<KnifeToolEquipmentInfo>();
            await _knifeToolEquipmentInfoRep.InsertAsync(knifeToolEquipmentInfo);
        }
 
        /// <summary>
        /// 删除设备刀具详情表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task Delete(DeleteKnifeToolEquipmentInfoInput input)
        {
            var knifeToolEquipmentInfo = await _knifeToolEquipmentInfoRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            await _knifeToolEquipmentInfoRep.DeleteAsync(knifeToolEquipmentInfo);
        }
 
        /// <summary>
        /// 更新设备刀具详情表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("edit")]
        public async Task Update(UpdateKnifeToolEquipmentInfoInput input)
        {
            var isExist = await _knifeToolEquipmentInfoRep.AnyAsync(u => u.Id == input.Id, false);
            if (!isExist) throw Oops.Oh(ErrorCode.D3000);
 
            var knifeToolEquipmentInfo = input.Adapt<KnifeToolEquipmentInfo>();
            await _knifeToolEquipmentInfoRep.UpdateAsync(knifeToolEquipmentInfo,ignoreNullValues:true);
        }
 
        /// <summary>
        /// 获取设备刀具详情表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("detail")]
        public async Task<KnifeToolEquipmentInfoOutput> Get([FromQuery] QueryeKnifeToolEquipmentInfoInput input)
        {
            return (await _knifeToolEquipmentInfoRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id)).Adapt<KnifeToolEquipmentInfoOutput>();
        }
 
        /// <summary>
        /// 获取设备刀具详情表列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("list")]
        public async Task<List<KnifeToolEquipmentInfoOutput>> List([FromQuery] KnifeToolEquipmentInfoInput input)
        {
            return await _knifeToolEquipmentInfoRep.DetachedEntities.ProjectToType<KnifeToolEquipmentInfoOutput>().ToListAsync();
        }    
 
    }
}