using ApkInfo;
using Hh.Mes.Common;
using Hh.Mes.Common.config;
using Hh.Mes.Common.Json;
using Hh.Mes.Common.log;
using Hh.Mes.Common.Redis;
using Hh.Mes.Pojo.System;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.Response;
using Hh.Mes.POJO.ViewModel;
using Hh.Mes.POJO.WebEntity;
using Hh.Mes.Service.Repository;
using Hh.Mes.Service.SystemAuth;
using MySqlX.XDevAPI.Common;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using static Microsoft.AspNetCore.Hosting.Internal.HostingApplication;

namespace Hh.Mes.Service
{
    public class PDAService : RepositorySqlSugar<sys_user>
    {
        AuthContextFactory authContextFactory;
        public PDAService(AuthContextFactory authContextFactory)
        {
            this.authContextFactory = authContextFactory;
        }

        /// <summary>
        /// PDA物料追溯查询
        /// (扫码查询物料追溯码，查看物料的批次，物料名称，壁厚等物料信息)
        /// </summary>
        /// <param name="barCode"></param>
        /// <returns></returns>
        public dynamic GetMaterialInfoByBarCode(dynamic requestData)
        {
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                var reqData = DynamicJson.Parse(requestData.ToString());
                var response = new Response();
                if (reqData == null || !reqData.IsDefined("barCode"))
                {
                    return response.ResponseError($"barCode:参数字段不正确，请核对！");
                }

                string barCode = reqData.barCode;
                if (string.IsNullOrEmpty(barCode)) return response.ResponseError($"barCode:值不能为空，请核对！");
                //1：扫码 BarCode 查询bus_workOrder_detail 表确认BarCode是否存在。
                var bwdInfo = Context.Queryable<bus_workOrder_detail>().First(x => x.barCode == barCode);
                if (bwdInfo == null || string.IsNullOrEmpty(bwdInfo.barCode))
                {
                    return response.ResponseError($"barCode:【{barCode}】不存在工序任务明细表中，请核对！");
                }
                if (string.IsNullOrEmpty(bwdInfo.cutMaterCode))
                {
                    return response.ResponseError($"根据barCode:【{barCode}】未查询到工序任务明细表中的物料编码信息，请核对！");
                }
                //2：根据BarCode 查询到当前行的 materialCode，在去物料表查询 返回物料表的基础信息。
                var materialInfo = Context.Queryable<base_material>().First(x => x.materialCode == bwdInfo.cutMaterCode);
                if (materialInfo == null) return response.ResponseError($"未查询到{bwdInfo.cutMaterCode}的物料基础信息，请检查！");

                //查询套料信息得到管材长度
                var cutplandetail = Context.Queryable<bus_cutplan_detail>().First(x => x.barCode == barCode);
                if (cutplandetail == null) return response.ResponseError($"{barCode}追踪码无效，请检查！");
                materialInfo.barCode = barCode;
                materialInfo.cuttingLength = cutplandetail.cuttingLength;

                //查询套料头得到物料使用的批次
                var buscutplanhead = Context.Queryable<bus_cutplan_head>().First(x => x.keys == cutplandetail.headKeys);
                if (cutplandetail == null) return response.ResponseError($"{barCode}追踪码无效，请检查！");
                materialInfo.lotNo = buscutplanhead.lotNo;

                materialInfo.extend1 = bwdInfo.batchNo;//批次号
                response.Result = materialInfo;
                return response;
            });
        }


        #region 组对、焊接
        /// <summary>
        /// 获取匹配的组对信息
        /// </summary>
        /// <param name="pipe">管段码</param>
        /// <param name="batch">批次码</param>
        /// <returns></returns>
        public dynamic GetMatchTeamList(string pipe, string batch)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                if (string.IsNullOrWhiteSpace(pipe))
                {
                    response.ResponseErr($"管段码【{pipe}】是空，请重新扫描管段码！");
                    return response;
                }
                if (string.IsNullOrWhiteSpace(batch))
                {
                    response.ResponseErr($"批次码【{batch}】是空，请重新扫描批次码！");
                    return response;
                }

                var materialCode = batch;//todo:批次需要调用接口获取物料码

                var resultDetail = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    x.barCode.Equals(pipe) &&
                    x.state == (int)EnumOrderBodyStatus.运输中 &&
                    x.weldMaterCode.Equals(materialCode) &&
                    x.workCenterCode == EnumoprSequenceCode.组对).ToList();

                bus_workOrder_head result = null;
                if (resultDetail.Count > 0)
                {
                    var material = Context.Queryable<base_material>().Where(x =>
                    x.materialCode.Equals(resultDetail[0].cutMaterCode)).First();

                    result = Context.Queryable<bus_workOrder_head>().Where(x => x.keys == resultDetail[0].headKeys).First();
                    if (material != null)
                    {
                        result.types = material.types;
                        result.diameter = material.diameter;
                        result.thickness = material.thickness;
                    }
                    result.teamList = resultDetail;
                }
                response.Result = result;
                return response;
            });
        }

        /// <summary>
        /// 获取组对开始列表
        /// </summary>
        /// <returns></returns>
        public dynamic GetTeamStartList()
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                var resultDetail = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    (x.state > (int)EnumOrderBodyStatus.运输中 && x.state < (int)EnumOrderBodyStatus.已完成) &&
                    x.workCenterCode == EnumoprSequenceCode.组对).ToList();

                var headKeyList = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    (x.state > (int)EnumOrderBodyStatus.运输中 && x.state < (int)EnumOrderBodyStatus.已完成) &&
                    x.workCenterCode == EnumoprSequenceCode.组对).GroupBy(x => x.headKeys).Select(x => x.headKeys).ToList();

                List<bus_workOrder_head> result = new List<bus_workOrder_head>();
                foreach (var key in headKeyList)
                {
                    var item = Context.Queryable<bus_workOrder_head>().Where(x => x.keys == key).First();
                    item.teamList = new List<bus_workOrder_detail>();
                    foreach (var detail in resultDetail)
                    {
                        if (detail.headKeys == key)
                        {
                            item.teamList.Add(detail);
                        }
                    }
                    result.Add(item);
                }
                response.Result = result;
                return response;
            });
        }

        /// <summary>
        /// 保存组对开始列表
        /// </summary>
        /// <returns></returns>
        public dynamic SaveTeamStartList(List<bus_workOrder_detail> details)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                foreach (var item in details)
                {
                    var resultItem = Context.Queryable<bus_workOrder_detail>().Where(x => x.bodyKeys == item.bodyKeys).First();
                    if (resultItem != null)
                    {
                        resultItem.stationCode = item.stationCode;
                        resultItem.actualEndTime = DateTime.Now;
                        resultItem.batchNo = item.batchNo;
                        resultItem.state = (int)EnumOrderBodyStatus.生产中;
                        resultItem.updateBy = sysWebUser?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();
                    }
                }

                var resultCount = Context.SaveQueues();
                return resultCount > 0 ? response.ResponseSuccess() : response.ResponseError();
            });
        }

        /// <summary>
        /// 保存组对结束列表
        /// </summary>
        /// <returns></returns>
        public dynamic SaveTeamEndList(List<bus_workOrder_detail> details)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                CutWeldService cutWeldService = new CutWeldService();

                foreach (var item in details)
                {
                    var resultItem = Context.Queryable<bus_workOrder_detail>().Where(x => x.bodyKeys == item.bodyKeys).First();
                    if (resultItem != null)
                    {
                        resultItem.state = (int)EnumOrderBodyStatus.已完成;
                        resultItem.actualEndTime = DateTime.Now;
                        resultItem.updateBy = sysWebUser?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();

                        var result = Context.Queryable<bus_workOrder_detail>().Where(x =>
                            x.barCode == resultItem.barCode &&
                            x.weldNo == resultItem.weldNo &&
                            x.workCenterCode == EnumoprSequenceCode.焊接).First();
                        if (result != null)
                        {
                            result.state = (int)EnumOrderBodyStatus.运输中;
                            result.batchNo = resultItem.batchNo;
                            result.updateBy = sysWebUser?.Account;
                            result.updateTime = DateTime.Now;
                            Context.Updateable(result).AddQueue();
                        }
                    }
                    //工序完工反馈
                    cutWeldService.SendIWPTechnologylineProcess(resultItem.barCode, (int)EnumCutHeadState.组对完成);
                }

                var resultCount = Context.SaveQueues();
                return resultCount > 0 ? response.ResponseSuccess() : response.ResponseError();
            });
        }






        /// <summary>
        /// 获取匹配的焊接信息
        /// </summary>
        /// <param name="pipe">管段码</param>
        /// <param name="batch">批次码</param>
        /// <returns></returns>
        public dynamic GetMatchWeldList(string pipe)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                if (string.IsNullOrWhiteSpace(pipe))
                {
                    response.ResponseErr($"管段码【{pipe}】是空，请重新扫描管段码！");
                    return response;
                }

                var resultDetail = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    x.barCode.Equals(pipe) &&
                    x.state == (int)EnumOrderBodyStatus.初始化 &&
                    x.workCenterCode == EnumoprSequenceCode.焊接 &&
                    !string.IsNullOrEmpty(x.batchNo)).ToList();

                bus_workOrder_head result = null;
                if (resultDetail.Count > 0)
                {
                    var material = Context.Queryable<base_material>().Where(x =>
                    x.materialCode.Equals(resultDetail[0].cutMaterCode)).First();

                    result = Context.Queryable<bus_workOrder_head>().Where(x => x.keys == resultDetail[0].headKeys).First();
                    if (material != null)
                    {
                        result.types = material.types;
                        result.diameter = material.diameter;
                        result.thickness = material.thickness;
                    }
                    result.teamList = resultDetail;
                }
                response.Result = result;
                return response;
            });
        }

        /// <summary>
        /// 获取焊接开始列表
        /// </summary>
        /// <returns></returns>
        public dynamic GetWeldStartList()
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                var resultDetail = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    (x.state > (int)EnumOrderBodyStatus.初始化 && x.state < (int)EnumOrderBodyStatus.已完成) &&
                    x.workCenterCode == EnumoprSequenceCode.焊接).ToList();

                var headKeyList = Context.Queryable<bus_workOrder_detail>().Where(x =>
                    (x.state > (int)EnumOrderBodyStatus.初始化 && x.state < (int)EnumOrderBodyStatus.已完成) &&
                    x.workCenterCode == EnumoprSequenceCode.焊接).GroupBy(x => x.headKeys).Select(x => x.headKeys).ToList();

                List<bus_workOrder_head> result = new List<bus_workOrder_head>();
                foreach (var key in headKeyList)
                {
                    var item = Context.Queryable<bus_workOrder_head>().Where(x => x.keys == key).First();
                    item.teamList = new List<bus_workOrder_detail>();
                    foreach (var detail in resultDetail)
                    {
                        if (detail.headKeys == key)
                        {
                            item.teamList.Add(detail);
                        }
                    }
                    result.Add(item);
                }
                response.Result = result;
                return response;
            });
        }

        /// <summary>
        /// 保存焊接开始列表
        /// </summary>
        /// <returns></returns>
        public dynamic SaveWeldStartList(List<bus_workOrder_detail> details)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                foreach (var item in details)
                {
                    var resultItem = Context.Queryable<bus_workOrder_detail>().Where(x => x.bodyKeys == item.bodyKeys).First();
                    if (resultItem != null)
                    {
                        resultItem.stationCode = item.stationCode;
                        resultItem.actualStartTime = DateTime.Now;
                        resultItem.state = (int)EnumOrderBodyStatus.生产中;
                        resultItem.updateBy = sysWebUser?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();
                    }
                }

                var resultCount = Context.SaveQueues();
                return resultCount > 0 ? response.ResponseSuccess() : response.ResponseError();
            });
        }

        /// <summary>
        /// 保存焊接结束列表
        /// </summary>
        /// <returns></returns>
        public dynamic SaveWeldEndList(List<bus_workOrder_detail> details)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                CutWeldService cutWeldService = new CutWeldService();
                foreach (var item in details)
                {
                    var resultItem = Context.Queryable<bus_workOrder_detail>().Where(x => x.bodyKeys == item.bodyKeys).First();
                    if (resultItem != null)
                    {
                        resultItem.state = (int)EnumOrderBodyStatus.已完成;
                        resultItem.actualEndTime = DateTime.Now;
                        resultItem.updateBy = sysWebUser?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();
                    }
                    //工序完工反馈
                    cutWeldService.SendIWPTechnologylineProcess(resultItem.barCode, (int)EnumCutHeadState.焊接完成);
                }

                var resultCount = Context.SaveQueues();
                return resultCount > 0 ? response.ResponseSuccess() : response.ResponseError();
            });
        }

        /// <summary>
        /// 焊接工艺下发保存
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <param name="barCode">管段码</param>
        /// <returns></returns>
        public dynamic SaveWeldTechnology(string equipmentCode, string barCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode) || string.IsNullOrWhiteSpace(barCode))
                {
                    return response.ResponseError($"设备编码或管段码为空，请重新扫描！");
                }

                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"设备编码{equipmentCode}在设备表中没有找到！");
                }

                //工序任务明细
                var resultItem = base.Context.Queryable<bus_workOrder_detail>().Where(x => x.barCode == barCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"barCode:【{barCode}】不存在工序任务明细表中，请核对！");
                }

                //物料信息
                var material = base.Context.Queryable<base_material>().Where(x => x.materialCode == resultItem.cutMaterCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"barCode:【{barCode}】对应物料没有信息，请核对！");
                }

                //焊接工艺参数
                var Equipment = new base_weld_technology_equipment()
                {
                    technologyHeadId = 0,
                    equipmentCode = equipmentCode,
                    createBy = sysWebUser?.Account,
                    createTime = DateTime.Now.ToString(),
                    sendStatus = 0,
                    minDiameter = material.diameter,
                    minThickness = material.thickness,
                    minWeldingSeam = "0",
                    material = material.types
                };

                switch (Equipment.material)
                {
                    case "碳钢": Equipment.material = "1"; break;
                    case "不锈钢": Equipment.material = "2"; break;
                    case "合金钢": Equipment.material = "3"; break;
                    case "多重钢": Equipment.material = "4"; break;
                    default: Equipment.material = "0"; break;
                }

                response.Status = Add(Equipment);
                response.Message = $"设备({equipment.name})焊接参数下发成功！";
                return response;
            });
        }

        /// <summary>
        /// 批次码获取物料信息
        /// </summary>
        /// <param name="lotNo">批次码</param>
        /// <returns></returns>
        public dynamic GetMaterialBylotNo(string lotNo)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(lotNo))
                {
                    return response.ResponseError($"批次码为空，请重新扫描！");
                }

                //调用上游接口查询批次码对应的物料码

                //物料信息
                var material = base.Context.Queryable<base_material>().Where(x => x.materialCode == lotNo).First();
                if (material == null)
                {
                    return response.ResponseError($"批次码{lotNo}在系统表中没有找到对应的物料信息！");
                }

                response.Result = material;
                return response;
            });
        }


        /// <summary>
        /// 设备编码获取设备信息
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <returns></returns>
        public dynamic GetEquipmentByCode(string equipmentCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode))
                {
                    return response.ResponseError($"设备编码为空，请重新扫描！");
                }

                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"设备编码{equipmentCode}没有找到对应的设备信息！");
                }

                //获取焊接类型ID
                var equipmentType = base.Context.Queryable<base_equipment_type>().Where(x => x.code == EnumoprSequenceCode.焊接).First();
                if (equipmentType == null)
                {
                    return response.ResponseError($"焊接类型在系统中未配置！");
                }

                //判断设备是否为焊机，只有焊机可以呼叫AGV
                if (equipment.equipmentTypeId != equipmentType.id)
                {
                    return response.ResponseError($"只有焊机工位可以呼叫AGV！");
                }

                //AGV呼叫记录
                var agvCalllog = base.Context.Queryable<bus_agvCall_log>().Where(x => x.callState == (int)EnumAgvCallState.接料中).First();
                if (agvCalllog != null)
                {
                    equipment.callState = (int)EnumAgvCallState.接料中;
                    equipment.equipmentNmae = agvCalllog.equipmentNmae;
                }
                else
                {
                    equipment.callState = (int)EnumAgvCallState.初始;
                    equipment.equipmentNmae = "无";
                }

                response.Result = equipment;
                return response;
            });
        }

        /// <summary>
        /// Agv接料完成
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <returns></returns>
        public dynamic AgvCollectingEnd(string equipmentCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode))
                {
                    return response.ResponseError($"设备编码为空，请重新扫描！");
                }

                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"设备编码{equipmentCode}没有找到对应的设备信息！");
                }

                //获取焊接类型ID
                var equipmentType = base.Context.Queryable<base_equipment_type>().Where(x => x.code == EnumoprSequenceCode.焊接).First();
                if (equipmentType == null)
                {
                    return response.ResponseError($"焊接类型在系统中未配置！");
                }

                //判断设备是否为焊机，只有焊机可以呼叫AGV
                if (equipment.equipmentTypeId != equipmentType.id)
                {

                    return response.ResponseError($"只有焊机工位可以呼叫AGV！");
                }

                //AGV呼叫记录
                var agvCalllog = base.Context.Queryable<bus_agvCall_log>().Where(x => x.callState == (int)EnumAgvCallState.接料中).First();
                if (agvCalllog == null)
                {
                    return response.ResponseError($"AGV没有在接料，不能进行此操作！");
                }

                if (agvCalllog.equipmentCode != equipmentCode)
                {
                    return response.ResponseError($"确保误操作与安全，请扫描正在接料的工位，再操作接料完成！");
                }

                agvCalllog.callState = (int)EnumAgvCallState.接料完成;
                agvCalllog.updateTime = DateTime.Now;

                base.Context.Updateable(agvCalllog).ExecuteCommand();

                response.Result = "";
                response.Message = "AGV接料完成操作成功！";

                return response;
            });
        }


        /// <summary>
        /// 呼叫Agv接料
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <returns></returns>
        public dynamic AgvCollectingStart(string equipmentCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode))
                {
                    return response.ResponseError($"设备编码为空，请重新扫描！");
                }

                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"设备编码{equipmentCode}没有找到对应的设备信息！");
                }

                //获取焊接类型ID
                var equipmentType = base.Context.Queryable<base_equipment_type>().Where(x => x.code == EnumoprSequenceCode.焊接).First();
                if (equipmentType == null)
                {
                    return response.ResponseError($"焊接类型在系统中未配置！");
                }

                //判断设备是否为焊机，只有焊机可以呼叫AGV
                if (equipment.equipmentTypeId != equipmentType.id)
                {
                    return response.ResponseError($"只有焊机工位可以呼叫AGV！");
                }

                //AGV呼叫记录
                var agvCalllog = base.Context.Queryable<bus_agvCall_log>().Where(x => x.callState == (int)EnumAgvCallState.接料中).First();
                if (agvCalllog != null)
                {
                    return response.ResponseError($"AGV正在{agvCalllog.equipmentNmae}接料，不能呼叫！");
                }

                var requestData = new
                {
                    stationCode = equipmentCode,
                    userCode = ""
                };

                //发送WMS-AGV接料 url = "http://172.16.29.881:9100/api/WMS/CallEmptyContainer";
                var url = GetDictionaryDictValue("UrlWCSCallEmptyContainer", "GetUrl");
                var WCSresponse = HttpManWCS(url, requestData, EnumLog.WCS接口调用.ToString(), method: "post");
                if (WCSresponse.Code == 200)
                {
                    var busAgvCalllog = new bus_agvCall_log();
                    busAgvCalllog.equipmentNmae = equipment.name;
                    busAgvCalllog.equipmentCode = equipment.code;
                    busAgvCalllog.callState = (int)EnumAgvCallState.接料中;
                    busAgvCalllog.createTime = DateTime.Now;
                    base.Context.Insertable(busAgvCalllog).ExecuteCommand();

                    response.Result = "";
                    response.Message = "呼叫AGV接料成功！";
                    return response;
                }
                else
                {
                    //var WcsResult = DynamicJson.Parse(WCSresponse.Result);
                    return response.ResponseError($"呼叫AGV接料失败！{WCSresponse.Result}");
                }
            });
        }

        /// <summary>
        /// 托盘入库
        /// </summary>
        /// <param name="containerCode">托盘码</param>
        /// <returns></returns>
        public dynamic ContainerTransfer(string containerCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(containerCode))
                {
                    return response.ResponseError($"托盘码为空，请重新扫描！");
                }

                //AGV呼叫记录
                var agvCalllog = base.Context.Queryable<bus_agvCall_log>().Where(x => x.callState == (int)EnumAgvCallState.接料中).First();
                if (agvCalllog != null)
                {
                    return response.ResponseError($"AGV正在{agvCalllog.equipmentNmae}接料，不能回库，需要先完成agv接料状态！");
                }

                var requestData = new
                {
                    containerCode = containerCode,
                    inLocationCode = ""
                };

                //发送WMS-托盘入库 url = "http://10.193.244.156:8066/api/WMS/ContainerTransfer";
                var url = GetDictionaryDictValue("UrlWCSContainerTransfer", "GetUrl");
                var WCSresponse = HttpManWCS(url, requestData, EnumLog.WCS接口调用.ToString(), method: "post");
                if (WCSresponse.Code == 200)
                {
                    response.Result = "";
                    response.Message = "托盘入库成功！";
                    return response;
                }
                else
                {
                    return response.ResponseError($"托盘入库失败！{WCSresponse.Result}");
                }
            });
        }

        /// <summary>
        /// 设备任务下发
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <param name="taskNumber">管段码</param>
        /// <returns></returns>
        public dynamic EquipmentTaskDistribute(string equipmentCode, string taskNumber)
        {
            var response = new Response(true);
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode) || string.IsNullOrWhiteSpace(taskNumber))
                {
                    return response.ResponseError($"设备编码或任务号为空，请重新扫描！");
                }

                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                {
                    return response.ResponseError($"设备编码{equipmentCode}在设备表中没有找到！");
                }

                var oprSequenceCode = "";
                var orderType = 0;
                if (equipmentCode == EquipmentCode.锯床)
                {
                    oprSequenceCode = EnumoprSequenceCode.切割;
                    orderType = (int)EnumOrderType.锯床切割;
                }
                if (equipmentCode == EquipmentCode.端面坡口机)
                {
                    oprSequenceCode = EnumoprSequenceCode.坡口;
                    orderType = (int)EnumOrderType.端面坡口;
                }
                if (equipmentCode == EquipmentCode.机器人打磨)

                {
                    oprSequenceCode = EnumoprSequenceCode.打磨;
                    orderType = (int)EnumOrderType.机器人打磨;
                }
                if (equipmentCode == EquipmentCode.机器人XY焊接)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.机器人XY轴;
                }
                if (equipmentCode == EquipmentCode.组焊一体机)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.组焊一体机;
                }
                if (equipmentCode == EquipmentCode.组焊平台)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.组焊平台;
                }

                //工序任务明细
                var resultItem = base.Context.Queryable<bus_workOrder_detail>().Where(x => x.barCode == taskNumber&&x.oprSequenceCode== oprSequenceCode).First();
                if (resultItem == null)
                {
                    return response.ResponseError($"taskNumber:【{taskNumber}】不存在工序任务明细表中，请核对！");
                }

                if (resultItem.state >= (int)EnumOrderHeadStatus.生产中)
                {
                    return response.ResponseError($"taskNumber:【{taskNumber}】任务已经下发，请勿重复操作！");
                }

                //更新工单明细
                resultItem.state = (int)EnumOrderHeadStatus.生产中;
                resultItem.actualStartTime = DateTime.Now;
                resultItem.updateBy = sysWebUser?.Account;
                resultItem.updateTime = DateTime.Now;
                Context.Updateable(resultItem).UpdateColumns(t => new { t.state,t.actualStartTime, t.updateBy, t.updateTime }).AddQueue();

                //更新工单
                Context.Updateable<bus_workOrder_head>()
                    .SetColumns(x => x.state == (int)EnumOrderHeadStatus.生产中)
                    .SetColumns(x => x.actualStartTime == DateTime.Now)
                    .Where(x => x.keys == resultItem.headKeys).AddQueue();

                //设备任务表
                var Equipment = new base_task_equipment()
                {
                    equipmentCode = equipmentCode,
                    taskCode = taskNumber,
                    sendStatus = (int)EnumWeldTechnologyEquipmentStatus.初始,
                    createBy = sysWebUser?.Account,
                    createTime = DateTime.Now
                };

                Context.Insertable(Equipment).AddQueue();

                var inContext = Context.SaveQueues();

                if (inContext > 0)
                {
                    response.Message = $"设备({equipment.name})任务下发成功！";
                }
                else
                {
                    return response.ResponseError($"设备({equipment.name})任务下发失败！");
                }
                return response;
            });
        }


        /// <summary>
        /// 设备任务列表查询
        /// </summary>
        /// <param name="equipmentCode">设备编码</param>
        /// <param name="state">查询状态：0未完成，30进行中，100已经完成</param>
        /// <returns></returns>
        public dynamic GetEquipmentTaskList(string equipmentCode, int state)
        {
            var response = new Response(true);
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode) || state < 0)
                    return response.ResponseError($"设备编码或查询状态为空！");
                //设备信息
                var equipment = base.Context.Queryable<base_equipment>().Where(x => x.code == equipmentCode).First();
                if (equipment == null)
                    return response.ResponseError($"设备编码{equipmentCode}在设备表中没有找到！");

                var oprSequenceCode = "";
                var orderType = 0;
                if (equipmentCode == EquipmentCode.锯床)
                {
                    oprSequenceCode = EnumoprSequenceCode.切割;
                    orderType = (int)EnumOrderType.锯床切割;
                }
                if (equipmentCode == EquipmentCode.端面坡口机)
                {
                    oprSequenceCode = EnumoprSequenceCode.坡口;
                    orderType = (int)EnumOrderType.端面坡口;
                }
                if (equipmentCode == EquipmentCode.机器人打磨)

                {
                    oprSequenceCode = EnumoprSequenceCode.打磨;
                    orderType = (int)EnumOrderType.机器人打磨;
                }
                if (equipmentCode == EquipmentCode.机器人XY焊接)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.机器人XY轴;
                }
                if (equipmentCode == EquipmentCode.组焊一体机)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.组焊一体机;
                }
                if (equipmentCode == EquipmentCode.组焊平台)
                {
                    oprSequenceCode = EnumoprSequenceCode.组焊;
                    orderType = (int)EnumOrderType.组焊平台;
                }

                if (oprSequenceCode == "")
                    return response.ResponseError($"设备编码错误！");

                //获取列表
                var taskList = Context.Queryable<bus_workOrder_head, bus_workOrder_detail, base_material>((a, b,c) => new JoinQueryInfos(
                                       JoinType.Left, a.keys == b.headKeys , JoinType.Left,b.cutMaterCode == c.materialCode))
                                       .Where((a,b,c) => a.orderType == orderType.ToString() && b.oprSequenceCode == oprSequenceCode && b.state == state)
                                      .Select((a, b, c) =>new
                                      {
                                          a.orderType,
                                          a.planStartTime,
                                          a.planEndTime,
                                          b.oprSequenceName,
                                          b.oprSequenceCode,
                                          b.state,
                                          b.cutMaterCode,
                                          b.cuttingLength,
                                          b.designUrl,
                                          b.weldNo,
                                          b.barCode,
                                          c.materialName
                                      }).ToList();

                response.Result = taskList;
                return response;
            });
        }


        #endregion
    }
}