tnb.server/EquipMgr/Tnb.EquipMgr/ToolMoldRequisitionService.cs

using System.Dynamic;
using JNPF.Common.Dtos.VisualDev;
using JNPF.Common.Enums;
using JNPF.Common.Extension;
using JNPF.Common.Filter;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.Systems.Entitys.Permission;
using JNPF.VisualDev;
using JNPF.VisualDev.Entitys;
using JNPF.VisualDev.Entitys.Dto.VisualDevModelData;
using JNPF.VisualDev.Interfaces;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using Tnb.EquipMgr.Entities;
using Tnb.EquipMgr.Entities.Dto;
using Tnb.EquipMgr.Interfaces;
using Tnb.ProductionMgr.Entities;

namespace Tnb.EquipMgr
{
    /// <summary>
    /// 模具领用接口
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    [OverideVisualDev(ModuleId)]
    public class ToolMoldRequisitionService : IOverideVisualDevService, IToolMoldRequisitionService,
        IDynamicApiController, ITransient
    {
        private const string ModuleId = "27254745336853";
        private readonly ISqlSugarClient _db;
        private readonly IRunService _runService;
        private readonly IVisualDevService _visualDevService;
        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();

        public ToolMoldRequisitionService(
            ISqlSugarRepository<ToolMoldRequisition> repository,
            IRunService runService,
            IVisualDevService visualDevService
        )
        {
            _db = repository.AsSugarClient();
            _runService = runService;
            _visualDevService = visualDevService;
            OverideFuncs.GetListAsync = GetList;
            OverideFuncs.CreateAsync = Create;
        }

        private async Task<dynamic> GetList(VisualDevModelListQueryInput input)
        {
            Dictionary<string, object>? queryJson = new Dictionary<string, object>();
            string? requisitionCode = "";
            DateTime[] requisitionTimeArr = null;
            DateTime[] estimatedReturnArr = null;
            if (input!=null && !string.IsNullOrEmpty(input.queryJson))
            {
                queryJson = JsonConvert.DeserializeObject<Dictionary<string, object>>(input?.queryJson ?? "");
            }
        
            if (queryJson!.TryGetValue("requisition_code", out var value))
            {
                requisitionCode = value.ToString();
            }
            if (queryJson!.TryGetValue("requisition_time", out var value1))
            {
                requisitionTimeArr = value1.ToObject<long[]>().Select(x=>DateTimeOffset.FromUnixTimeSeconds(x/1000).ToLocalTime().DateTime).ToArray();
            }
            if (queryJson!.TryGetValue("estimated_return_time", out var value2))
            {
                estimatedReturnArr = value2.ToObject<long[]>().Select(x=>DateTimeOffset.FromUnixTimeSeconds(x/1000).ToLocalTime().DateTime).ToArray();
            }

            var result = await _db.Queryable<ToolMoldRequisition>()
                .LeftJoin<PrdMoTask>((a, b) => a.mo_task_id == b.id)
                .LeftJoin<EqpEquipment>((a, b, c) => a.equip_id == c.id)
                .LeftJoin<UserEntity>((a, b, c, d) => a.recipient_id == d.Id)
                .LeftJoin<ToolMolds>((a,b,c,d,e)=>a.mold_id==e.id)
                .WhereIF(!string.IsNullOrEmpty(requisitionCode), (a, b, c, d) => a.code.Contains(requisitionCode))
                .WhereIF(requisitionTimeArr!=null, (a, b, c, d) => a.requisition_time>=requisitionTimeArr[0] && a.requisition_time<=requisitionTimeArr[1])
                .WhereIF(estimatedReturnArr!=null, (a, b, c, d) => a.estimated_return_time>=estimatedReturnArr[0] && a.estimated_return_time<=estimatedReturnArr[1])
                .Select((a, b, c, d,e) => new ToolMoldRequisitionListOutput
                {
                    id = a.id,
                    code = a.code,
                    mold_id = e.mold_code,
                    mo_task_id = b.mo_task_code,
                    equip_id = c.code+"/"+c.name,
                    recipient_id = d.RealName,
                    estimated_return_time = a.estimated_return_time==null ? "" : a.estimated_return_time.Value.ToString("yyyy-MM-dd"),
                    requisition_time = a.requisition_time==null ? "" : a.requisition_time.Value.ToString("yyyy-MM-dd"),
                    remark = a.remark
                }).ToPagedListAsync(input.currentPage, input.pageSize);

            return PageResult<ToolMoldRequisitionListOutput>.SqlSugarPageResult(result);
        }

        private async Task<dynamic> Create(VisualDevModelDataCrInput input)
        {
            DbResult<bool> result = await _db.Ado.UseTranAsync(async () =>
            {
                VisualDevEntity? templateEntity = await _visualDevService.GetInfoById(ModuleId, true);
                await _runService.Create(templateEntity, input);


                await _db.Updateable<ToolMolds>().SetColumns(x => x.mold_status == Tnb.BasicData.DictConst.SCTypeId)
                    .Where(X => X.id == input.data["mold_id"]).ExecuteCommandAsync();
            });

            if (!result.IsSuccess) throw Oops.Oh(ErrorCode.COM1008);
            return result.IsSuccess ? "保存成功" : result.ErrorMessage;
        }
        [HttpPost]
        public async Task<dynamic> GetTools(ToolInput toolinput)
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            dic.Add("26149307089941", "在库");
            dic.Add("26149309121045", "生产");
            dic.Add("26149311082005", "保养");
            dic.Add("26149314425877", "报废");
            dic.Add("26149312750101", "外协");
            dic.Add("26149320818965", "维修");
            List<dynamic> result = new();
            var ToolMolds = await _db.Queryable<ToolMolds>()
              .WhereIF(!string.IsNullOrEmpty(toolinput.keyword),p=>p.mold_code!.Contains(toolinput.keyword!)|| p.mold_name!.Contains(toolinput.keyword!))
              .WhereIF(!string.IsNullOrEmpty(toolinput.status), p => p.mold_status== dic.Where(p=>p.Value== toolinput.status).First().Key)
              .ToListAsync();
            if (string.IsNullOrEmpty(toolinput.sort))
            { 
              if(toolinput.sort== "mold_code")
                    ToolMolds= ToolMolds.OrderByDescending(p=>p.mold_code).ToList();
            }
            foreach (var tool in ToolMolds)
            {
                dynamic info = new ExpandoObject();
                info.mold_code=tool.mold_code;
                info.mold_name = tool.mold_name;
                info.mold_status= dic.Where(p=>p.Key==tool.mold_status).Any()? dic.Where(p => p.Key == tool.mold_status).First().Value:"";
                info.warehosue_id=tool.warehosue_id;
                info.location_id=tool.location_id;
                result.Add(info);
            }
          
            return ToolMolds;
        }
    }
}