MES / MES-BaseMes10.0 · Files

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.ApiEntity;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.Request;
using Hh.Mes.POJO.Response;
using Hh.Mes.POJO.ViewModel;
using Hh.Mes.POJO.WebEntity;
using Hh.Mes.POJO.WebEntity.api;
using Hh.Mes.Service.Repository;
using Hh.Mes.Service.SystemAuth;
using Microsoft.VisualBasic;
using MySqlX.XDevAPI.Common;
using NPOI.SS.Formula.Functions;
using NPOI.Util;
using Org.BouncyCastle.Crypto;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
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 POJO.Response.Response();
                if (reqData == null || !reqData.IsDefined("barCode"))
                {
                    return response.ResponseError($"工件编码参数字段不正确，请核对！");
                }

                string barCode = reqData.barCode;
                if (string.IsNullOrEmpty(barCode)) return response.ResponseError($"工件编码不能为空，请核对！");
                //1：扫码工件编码 查询base_work_order_head表
                var bwdInfo = Context.Queryable<base_work_order_head>().First(x => x.workPieceNo == barCode);

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


        #region 组对、焊接

        /// <summary>
        /// 获取匹配的组对信息
        /// </summary>
        /// <param name="station">工位码</param>
        /// <param name="pipe">管段码</param>
        /// <returns></returns>
        public dynamic GetMatchTeamList(string station, string pipe)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                if (string.IsNullOrWhiteSpace(station))
                {
                    response.ResponseErr($"工位码为空，请扫描工位码！");
                    return response;
                }

                //工位信息
                var equipment = base.Context.Queryable<base_work_station>().Where(x => x.workStationCode == station).First();
                if (equipment == null)
                {
                    return response.ResponseError($"工位码【{station}】未找到工位信息，请配置！");
                }

                if (string.IsNullOrWhiteSpace(pipe))
                {
                    response.ResponseErr($"管段码为空，请扫描管段码！");
                    return response;
                }

                //查询出管段码对应的多焊口列表
                var detList = Context.Queryable<bus_workOrder_detail, base_material>((b, c) => new
                                       JoinQueryInfos(JoinType.Left, b.weldMaterCode == c.materialCode))
                                       .Where((b, c) => b.barCode == pipe
                                                        && b.workCenterCode == EnumoprSequenceCode.组对
                                                        && b.state == (int)EnumOrderBodyStatus.初始化
                                                        && !string.IsNullOrEmpty(b.weldMaterCode)
                                                        && c.isDelete == (int)EnumtIsValid.是)
                                      .Select((b, c) => new workOrderDet
                                      {
                                          id = b.id,
                                          headKeys = b.headKeys.ToString(),
                                          bodyKeys = b.bodyKeys.ToString(),
                                          extendComp1 = b.extendComp1,
                                          materialName = c.materialName,
                                          cutMaterCode = b.cutMaterCode,
                                          weldMaterCode = b.weldMaterCode,
                                          pipelength = b.cuttingLength.ToString()
                                      }
                                      ).ToList();

                var weldMaterCodeList = detList.Where(x => string.IsNullOrEmpty(x.materialName)).Select(x => x.weldMaterCode).ToList();
                if (weldMaterCodeList.Count != 0)
                {
                    response.ResponseErr($"物料数据缺少，物料码【{weldMaterCodeList.ToJson(",")}】！");
                    return response;
                }

                if (detList.Count == 0)
                {
                    response.ResponseErr($"管段码【{pipe}】未查询到组对数据！");
                    return response;
                }

                workOrderHead wHead = new workOrderHead();

                if (detList.Count > 0)
                {
                    var material = Context.Queryable<base_material>()
                        .Where(x => x.materialCode == detList[0].cutMaterCode && x.isDelete == (int)EnumtIsValid.是).First();

                    if (material == null)
                    {
                        response.ResponseErr($"物料码【{detList[0].cutMaterCode}】未查询到物料数据！");
                        return response;
                    }

                    var result = Context.Queryable<bus_workOrder_head>().Where(x => x.keys.ToString() == detList[0].headKeys).First();

                    if (result == null)
                    {
                        response.ResponseErr($"未查询到工单主数据！");
                        return response;
                    }

                    if (material != null)
                    {
                        wHead.barCode = pipe;
                        wHead.materialName = material.materialName;
                        wHead.pipelength = detList[0].pipelength;

                    }
                    wHead.teamList = detList;
                }

                response.Result = wHead;

                return response;
            });
        }

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

                if (string.IsNullOrWhiteSpace(station))
                {
                    response.ResponseErr($"工位码为空，请扫描工位码！");
                    return response;
                }

                //工位信息
                var equipment = base.Context.Queryable<base_work_station>().Where(x => x.workStationCode == station).First();
                if (equipment == null)
                {
                    return response.ResponseError($"工位码【{station}】未找到工位信息，请配置！");
                }

                //查询出组对生产中的工序任务
                var detList = Context.Queryable<bus_workOrder_detail, base_material>((b, c) => new
                                       JoinQueryInfos(JoinType.Left, b.weldMaterCode == c.materialCode))
                                       .Where((b, c) => b.workCenterCode == EnumoprSequenceCode.组对
                                                       && b.state == (int)EnumOrderBodyStatus.生产中
                                                       && c.isDelete == (int)EnumtIsValid.是
                                                       && b.stationCode == station)
                                      .Select((b, c) => new workOrderDet
                                      {
                                          id = b.id,
                                          headKeys = b.headKeys.ToString(),
                                          bodyKeys = b.bodyKeys.ToString(),
                                          extendComp1 = b.extendComp1,
                                          materialName = c.materialName,
                                          cutMaterCode = b.cutMaterCode,
                                          stationCode = b.stationCode,
                                          barCode = b.barCode,
                                          pipelength = b.cuttingLength.ToString()
                                      }
                                      ).ToList();

                var headKeyList = detList.GroupBy(x => x.headKeys).ToList();

                List<workOrderHead> wHeadList = new List<workOrderHead>();

                foreach (var headKey in headKeyList)
                {
                    workOrderHead workH = new workOrderHead();
                    workH.teamList = new List<workOrderDet>();

                    var item = Context.Queryable<bus_workOrder_head>().Where(x => x.keys.ToString() == headKey.Key).First();

                    foreach (var detail in detList)
                    {
                        if (detail.headKeys == headKey.Key)
                        {
                            workH.teamList.Add(detail);
                            workH.barCode = detail.barCode;
                        }
                    }

                    var material = Context.Queryable<base_material>()
                        .Where(x => x.materialCode == workH.teamList[0].cutMaterCode && x.isDelete == (int)EnumtIsValid.是).First();

                    if (material != null)
                    {
                        workH.materialName = material.materialName;
                        workH.pipelength = detList[0].pipelength;
                    }
                    wHeadList.Add(workH);
                }
                response.Result = wHeadList;
                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 = sysUserApi?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();
                    }
                    else
                    {
                        response.ResponseErr($"未查询到工序组对任务信息！");
                        return response;
                    }
                }

                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 = sysUserApi?.Account;
                        resultItem.updateTime = DateTime.Now;
                        resultItem.workReportStatus = (int)EnumWorkReportStatus.完工已报工;
                        Context.Updateable(resultItem).AddQueue();
                    }
                    else
                    {
                        response.ResponseErr($"未查询到工序组对任务信息！");
                        return response;
                    }

                    //工序完工反馈
                    cutWeldService.SendIWPTechnologylineProcess(resultItem.barCode, (int)EnumCutHeadState.组对完成);
                }

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

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

                if (string.IsNullOrWhiteSpace(station))
                {
                    response.ResponseErr($"工位码【{station}】是空，请扫描工位码！");
                    return response;
                }

                //工位信息
                var equipment = base.Context.Queryable<base_work_station>().Where(x => x.workStationCode == station).First();
                if (equipment == null)
                {
                    return response.ResponseError($"工位码【{station}】没有找到对应的工位信息！");
                }

                //查询出管段码对应的多焊口列表
                var detList = Context.Queryable<bus_workOrder_detail, base_material>((b, c) => new
                                       JoinQueryInfos(JoinType.Left, b.weldMaterCode == c.materialCode))
                                       .Where((b, c) => b.barCode == pipe
                                                        && b.workCenterCode == EnumoprSequenceCode.焊接
                                                        && b.state == (int)EnumOrderBodyStatus.初始化
                                                        && !string.IsNullOrEmpty(b.weldMaterCode)
                                                        && c.isDelete == (int)EnumtIsValid.是)
                                      .Select((b, c) => new workOrderDet
                                      {
                                          id = b.id,
                                          headKeys = b.headKeys.ToString(),
                                          bodyKeys = b.bodyKeys.ToString(),
                                          extendComp1 = b.extendComp1,
                                          materialName = c.materialName,
                                          weldMaterCode = b.weldMaterCode,
                                          cutMaterCode = b.cutMaterCode,
                                          pipelength = b.cuttingLength.ToString()
                                      }
                                      ).ToList();

                var weldMaterCodeList = detList.Where(x => string.IsNullOrEmpty(x.materialName)).Select(x => x.weldMaterCode).ToList();
                if (weldMaterCodeList.Count != 0)
                {
                    response.ResponseErr($"物料数据缺少，物料码【{weldMaterCodeList.ToJson(",")}】！");
                    return response;
                }

                if (detList.Count == 0)
                {
                    response.ResponseErr($"管段码【{pipe}】未查询到焊接数据！");
                    return response;
                }

                workOrderHead wHead = new workOrderHead();

                if (detList.Count > 0)
                {
                    var material = Context.Queryable<base_material>()
                        .Where(x => x.materialCode == detList[0].cutMaterCode && x.isDelete == (int)EnumtIsValid.是).First();

                    if (material == null)
                    {
                        response.ResponseErr($"物料码【{detList[0].cutMaterCode}】未查询到物料数据！");
                        return response;
                    }

                    var result = Context.Queryable<bus_workOrder_head>().Where(x => x.keys.ToString() == detList[0].headKeys).First();

                    if (result == null)
                    {
                        response.ResponseErr($"未查询到工单主数据！");
                        return response;
                    }

                    if (material != null)
                    {
                        wHead.barCode = pipe;
                        wHead.materialName = material.materialName;
                        wHead.pipelength = detList[0].pipelength;

                    }
                    wHead.teamList = detList;
                }
                response.Result = wHead;
                return response;
            });
        }

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

                if (string.IsNullOrWhiteSpace(station))
                {
                    response.ResponseErr($"工位码为空，请扫描工位码！");
                    return response;
                }

                //工位信息
                var equipment = base.Context.Queryable<base_work_station>().Where(x => x.workStationCode == station).First();
                if (equipment == null)
                {
                    return response.ResponseError($"工位码【{station}】未找到工位信息，请配置！");
                }

                //查询出焊接生产中的工序任务
                var detList = Context.Queryable<bus_workOrder_detail, base_material>((b, c) => new
                                       JoinQueryInfos(JoinType.Left, b.weldMaterCode == c.materialCode))
                                       .Where((b, c) => b.workCenterCode == EnumoprSequenceCode.焊接
                                                       && b.state == (int)EnumOrderBodyStatus.生产中
                                                       && c.isDelete == (int)EnumtIsValid.是)
                                      .Select((b, c) => new workOrderDet
                                      {
                                          id = b.id,
                                          headKeys = b.headKeys.ToString(),
                                          bodyKeys = b.bodyKeys.ToString(),
                                          extendComp1 = b.extendComp1,
                                          materialName = c.materialName,
                                          cutMaterCode = b.cutMaterCode,
                                          stationCode = b.stationCode,
                                          barCode = b.barCode,
                                          pipelength = b.cuttingLength.ToString()
                                      }
                                      ).ToList();

                var headKeyList = detList.GroupBy(x => x.headKeys).ToList();

                List<workOrderHead> wHeadList = new List<workOrderHead>();

                foreach (var headKey in headKeyList)
                {
                    workOrderHead workH = new workOrderHead();
                    workH.teamList = new List<workOrderDet>();

                    var item = Context.Queryable<bus_workOrder_head>().Where(x => x.keys.ToString() == headKey.Key).First();

                    foreach (var detail in detList)
                    {
                        if (detail.headKeys == headKey.Key)
                        {
                            workH.teamList.Add(detail);
                            workH.barCode = detail.barCode;
                        }
                    }

                    var material = Context.Queryable<base_material>()
                        .Where(x => x.materialCode == workH.teamList[0].cutMaterCode && x.isDelete == (int)EnumtIsValid.是).First();

                    if (material != null)
                    {
                        workH.materialName = material.materialName;
                        workH.pipelength = detList[0].pipelength;
                    }
                    wHeadList.Add(workH);
                }
                response.Result = wHeadList;

                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 = sysUserApi?.Account;
                        resultItem.updateTime = DateTime.Now;
                        Context.Updateable(resultItem).AddQueue();
                    }
                    else
                    {
                        response.ResponseErr($"未查询到工序焊接任务信息！");
                        return response;
                    }
                }

                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 = sysUserApi?.Account;
                        resultItem.updateTime = DateTime.Now;
                        resultItem.workReportStatus = (int)EnumWorkReportStatus.完工已报工;
                        Context.Updateable(resultItem).AddQueue();
                    }
                    else
                    {
                        response.ResponseErr($"未查询到工序焊接任务信息！");
                        return response;
                    }

                    //工序完工反馈
                    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_work_station>().Where(x => x.workStationCode == 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 && x.isDelete == (int)EnumtIsValid.是).First();
                if (equipment == null)
                {
                    return response.ResponseError($"barCode:【{barCode}】对应物料没有信息，请核对！");
                }

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

                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 = "1"; break;
                }

                response.Status = Add(Equipment);
                response.Message = $"设备({equipment.workStationName})参数下发成功！";
                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 && x.isDelete == (int)EnumtIsValid.是).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($"设备编码或任务号为空，请重新扫描！");

                if (equipmentCode == EquipmentCode.组焊平台)
                    return response.ResponseError($"3D组焊平台没有在线设备，不能下发任务，只能直接完成！");

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

                var oprSequenceCode = "";
                if (equipmentCode == EquipmentCode.锯床)
                    oprSequenceCode = EnumoprSequenceCode.切割;
                if (equipmentCode == EquipmentCode.端面坡口机)
                    oprSequenceCode = EnumoprSequenceCode.坡口;
                if (equipmentCode == EquipmentCode.机器人打磨)
                    oprSequenceCode = EnumoprSequenceCode.打磨;
                if (equipmentCode == EquipmentCode.机器人XY焊接)
                    oprSequenceCode = EnumoprSequenceCode.焊接;
                if (equipmentCode == EquipmentCode.组焊一体机)
                    oprSequenceCode = EnumoprSequenceCode.焊接;
                if (equipmentCode == EquipmentCode.组焊平台)
                    oprSequenceCode = EnumoprSequenceCode.组对;

                //工序任务明细
                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}】任务已经下发，请勿重复操作！");

                if (equipmentCode == EquipmentCode.机器人打磨)
                {
                    //机器人打磨需要交互
                    if (!robotDeviceStatus())
                    {
                        return response.ResponseError($"机器人运行中或未开机！");
                    }
                    //参数下发
                    else
                    {
                        var pipe = PipeInfo(resultItem.cutMaterCode);
                        if (!string.IsNullOrEmpty(pipe) && pipe != "Success")
                        {
                            return response.ResponseError($"{pipe}");
                        }
                    }
                }

                //更新工单明细
                resultItem.state = (int)EnumOrderHeadStatus.生产中;
                resultItem.actualStartTime = DateTime.Now;
                resultItem.updateBy = sysUserApi?.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 = sysUserApi?.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;
            });
        }

        //机器人状态判断
        public bool robotDeviceStatus()
        {
            var url = GetDictionaryDictValue("DeviceStatus", "robotURL");
            var response = HttpManPipe(url);
            if (response != "" && response == "False")
            {
                return true;
            }

            return false;
        }

        //机器人打磨参数下发
        public string PipeInfo(string materialCode)
        {
            var item = base.Context.Queryable<base_material>().Where(x => x.materialCode == materialCode && x.isDelete == (int)EnumtIsValid.是).First();
            if (string.IsNullOrEmpty(item.diameter) || item.diameter == "0" || string.IsNullOrEmpty(item.thickness) || item.thickness == "0")
            {
                return "管径与壁厚数据缺少，需要上游维护下发！";
            }

            //默认为管
            var currentPipeType = "SMLS";
            if (item.materialName.IndexOf("三通") > -1 || item.specifications.IndexOf("三通") > -1)
            {
                currentPipeType = "Tee";
            }
            else if (item.materialName.IndexOf("法兰") > -1 || item.specifications.IndexOf("法兰") > -1)
            {
                currentPipeType = "Flange";
            }
            else if (item.materialName.IndexOf("弯头") > -1 || item.specifications.IndexOf("弯头") > -1)
            {
                currentPipeType = "Elbow";
            }

            var url = GetDictionaryDictValue("PipeInfo", "robotURL");
            url = $"{url}?currentPipeType={currentPipeType}&currentPipeThick={item.diameter}&currentPipeDiameter={item.thickness}";
            var response = HttpManPipe(url);

            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 POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(equipmentCode) || state < 0)
                    return response.ResponseError($"设备编码或查询状态为空！");
                //设备信息
                if (equipmentCode != EquipmentCode.组焊平台)
                {
                    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.成品件生产订单;
                }
                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
                                                && a.isScrap == false
                                                && SqlFunc.Between(DateTime.Now, a.planStartTime, a.planEndTime)
                                                && c.isDelete == (int)EnumtIsValid.是)
                                      .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

        #region 工位任务

        /// <summary>
        /// 工位任务列表查询（自动线，组对与焊接）
        /// </summary>
        /// <param name="workCenterCode">工作中心</param>
        /// <returns></returns>
        public dynamic GetTaskList(string workCenterCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(workCenterCode))
                {
                    return response.ResponseError($"工作中心编码不能为空！");
                }

                //获取列表
                var taskList = Context.Queryable<bus_workOrder_detail, bus_workOrder_head, base_material>((a, b, c) => new JoinQueryInfos(
                        JoinType.Left, a.headKeys == b.keys, JoinType.Left, a.cutMaterCode == c.materialCode
                       )).Where((a, b, c) =>
                        a.oprSequenceCode == workCenterCode
                        && a.state == (int)EnumOrderBodyStatus.运输中
                        && b.orderType == ((int)EnumProOrderType.正常订单).ToString()
                        && c.isDelete == (int)EnumtIsValid.是
                       ).Select((a, b, c) => new
                       {
                           b.orderType,
                           b.planStartTime,
                           b.planEndTime,
                           a.oprSequenceName,
                           a.oprSequenceCode,
                           a.state,
                           a.cutMaterCode,
                           a.cuttingLength,
                           a.designUrl,
                           a.weldNo,
                           a.barCode,
                           c.materialName
                       }).ToList();

                var barCodeList = taskList.Select(x => x.barCode).Distinct().ToList();

                var workOrderDetailList = Context.Queryable<bus_workOrder_detail>()
                    .Where(x => x.oprSequenceCode == EnumoprSequenceCode.套料 && barCodeList.Contains(x.barCode))
                    .Select(x => new { x.barCode, x.cuttingLength }).ToList();

                taskList = taskList.Join(workOrderDetailList, task => task.barCode, detail => detail.barCode,
                    (task, detail) => new
                    {
                        task.orderType,
                        task.planStartTime,
                        task.planEndTime,
                        task.oprSequenceName,
                        task.oprSequenceCode,
                        task.state,
                        task.cutMaterCode,
                        detail.cuttingLength,
                        task.designUrl,
                        task.weldNo,
                        task.barCode,
                        task.materialName
                    }).ToList();

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

        /// <summary>
        /// 新增扫码记录
        /// </summary>
        /// <param name="stationCode">工位码</param>
        /// <param name="barCode">管段码</param>
        public void scanRecord(string stationCode, string barCode)
        {

            var station = base.Context.Queryable<base_work_station>().Where(x => x.workStationCode == stationCode).First();
            if (station == null)
            {
                return;
            }

            //先把当前工位的扫码记录改为过期，超过10分的扫码记录也设置为过期
            Context.Updateable<base_scan_record>()
                .SetColumns(x => x.state == 1)
                .Where(x => x.stationCode == station.workCenterCode)
                .AddQueue();

            var scanRecord = new base_scan_record();
            scanRecord.stationCode = station.workCenterCode;
            scanRecord.barCode = barCode;
            scanRecord.state = 0;
            scanRecord.createTime = DateTime.Now;
            scanRecord.createBy = sysUserApi?.Account;

            Context.Insertable(scanRecord).AddQueue();

            Context.SaveQueues();
        }

        /// <summary>
        /// 获取扫码记录
        /// </summary>
        /// <param name="workCenterCode">工作中心</param>
        /// <returns></returns>
        public dynamic GetScanRecord(string workCenterCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (string.IsNullOrWhiteSpace(workCenterCode))
                {
                    return response.ResponseError($"工位编码为空！");
                }

                //先把当前工位的扫码记录改为过期，超过10分的扫码记录也设置为过期
                var time = DateTime.Now.AddMinutes(-10);

                Context.Updateable<base_scan_record>()
                    .SetColumns(x => x.state == 1)
                    .Where(x => x.stationCode == workCenterCode && time > x.createTime)
                    .ExecuteCommand();

                var scanRecord = base.Context.Queryable<base_scan_record>().Where(x => x.stationCode == workCenterCode && x.state == 0).First();

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

        #endregion

        /// <summary>
        /// 工序问题记录
        /// </summary>
        /// <returns></returns>
        public dynamic SetProblem(dynamic requestData)
        {
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                var reqData = DynamicJson.Parse(requestData.ToString());
                var response = new POJO.Response.Response();
                if (reqData == null || !reqData.IsDefined("barCode"))
                {
                    return response.ResponseError($"barCode:参数字段不正确，请核对！");
                }

                string barCode = reqData.barCode;
                string problem = reqData.problem;
                string oprSequenceCode = reqData.oprSequenceCode;

                if (string.IsNullOrEmpty(barCode)) return response.ResponseError($"管段码不能为空，请核对！");
                if (string.IsNullOrEmpty(problem)) return response.ResponseError($"问题原因不能为空，请核对！");
                if (string.IsNullOrEmpty(oprSequenceCode)) return response.ResponseError($"工序不能为空，请核对！");

                //1：扫码 BarCode 查询bus_workOrder_detail 表确认BarCode是否存在。
                var bwdInfo = Context.Queryable<bus_workOrder_detail>().First(x => x.barCode == barCode && x.oprSequenceCode == oprSequenceCode);
                if (bwdInfo == null || string.IsNullOrEmpty(bwdInfo.barCode))
                {
                    return response.ResponseError($"barCode:【{barCode}】不存在工序任务明细表中，请核对！");
                }

                //2：根据BarCode 查询到当前行的 materialCode，在去物料表查询 返回物料表的基础信息。
                var materialInfo = Context.Queryable<base_material>().First(x => x.materialCode == bwdInfo.cutMaterCode && x.isDelete == (int)EnumtIsValid.是);

                var workOrderDetail = Context.Queryable<bus_workOrder_detail>()
                    .Where(x => x.oprSequenceCode == EnumoprSequenceCode.套料 && x.barCode == barCode).First();

                var procedureProblem = new base_procedure_problem();
                procedureProblem.barCode = barCode;
                procedureProblem.problem = problem;
                procedureProblem.oprSequenceCode = oprSequenceCode;
                procedureProblem.createTime = DateTime.Now;
                procedureProblem.createBy = sysUserApi?.Account;
                procedureProblem.materialCode = bwdInfo.cutMaterCode;
                procedureProblem.oprSequenceName = bwdInfo.oprSequenceName;
                procedureProblem.cuttingLength = workOrderDetail.cuttingLength;
                procedureProblem.materialName = materialInfo.materialName;
                procedureProblem.types = materialInfo.types;
                procedureProblem.thickness = materialInfo.thickness;
                procedureProblem.diameter = materialInfo.diameter;
                procedureProblem.specifications = materialInfo.specifications;
                procedureProblem.designUrl = bwdInfo.designUrl;

                Context.Insertable(procedureProblem).ExecuteCommand();

                return response;
            });
        }


        #region 物料到达

        /// <summary>
        /// PDA扫码物料到达
        /// </summary>
        /// <param name="workStationCode">工位码</param>
        /// <param name="pipeSN">管材SN</param>
        public dynamic MaterialReach(string workStationCode, string pipeSN)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
             {
                 if (string.IsNullOrEmpty(workStationCode)) { return response.ResponseError($"工位码不能为空，请核对！"); }
                 if (string.IsNullOrEmpty(pipeSN)) { return response.ResponseError($"管材SN不能为空，请核对！"); }

                 var station = Context.Queryable<base_work_station>().Where(x => x.workStationCode == workStationCode).First();
                 if (station == null) { return response.ResponseError($"【{workStationCode}】工位码不存在，请核对！"); }

                 var inventory = Context.Queryable<base_inventory>().Where(x => x.pipeSN == pipeSN).First();
                 if (inventory == null) { return response.ResponseError($"【{pipeSN}】查询不到库存，请核对！"); }

                 if (inventory.useState != (int)InventoryUseState.已套料) { return response.ResponseError($"【{pipeSN}】未套料，请核对！"); }

                 var cutplanHead = Context.Queryable<bus_cutplan_head>().Where(x =>
                                                        x.lotNo == pipeSN
                                                        && x.state == (int)EnumCutPlanHeadStatus.初始
                                                        && x.workCenterCode == station.workCenterCode).First();

                 if (cutplanHead == null) { return response.ResponseError($"【{pipeSN}】未查询到匹配的切割方案！"); }

                 inventory.useState = (int)InventoryUseState.使用完毕;
                 inventory.updateBy = sysUserApi?.Account;
                 inventory.updateTime = DateTime.Now;
                 Context.Updateable(inventory).AddQueue();

                 cutplanHead.state = (int)EnumCutPlanHeadStatus.下料开始;
                 cutplanHead.updateBy = sysUserApi?.Account;
                 cutplanHead.updateTime = DateTime.Now.ToString();
                 Context.Updateable(cutplanHead).AddQueue();

                 response.Status = Context.SaveQueues() > 0;
                 if (response.Status)
                 {
                     response.Code = 200;
                     response.Message = $"【{pipeSN}】物料到达操作成功，到达工位【{station.workStationName}】";
                     return response;
                 }
                 else
                 {
                     return response.ResponseError($"数据库操作失败！");
                 }
             });
        }

        /// <summary>
        /// 查询库存物料
        /// </summary>
        /// <param name="pipeSN">管材SN</param>
        public dynamic GetInventoryByPipeSN(string pipeSN)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {

                if (string.IsNullOrEmpty(pipeSN)) { return response.ResponseError($"管材SN不能为空，请核对！"); }

                var inventory = Context.Queryable<base_inventory>().Where(x => x.pipeSN == pipeSN).First();
                if (inventory == null) { return response.ResponseError($"【{pipeSN}】查询不到库存，请核对！"); }

                var inventoryNew = Context.Queryable<base_inventory, base_material>((a, b) => new JoinQueryInfos(
                        JoinType.Left, a.materialCode == b.materialCode))
                        .Where((a, b) => a.pipeSN == pipeSN && b.isDelete == (int)EnumtIsValid.是)
                        .Select((a, b) => new
                        {
                            a.pipeSN,
                            a.materialCode,
                            a.pipeLength,
                            b.materialName,
                            b.diameter,
                            b.thickness
                        }).First();


                response.Result = inventoryNew;
                return response;

            });
        }

        #endregion

        #region 质检

        /// <summary>
        /// 质检任务查询
        /// </summary>
        /// <param name="workCenterCode">工序code</param>
        /// <param name="barCode">管段码</param>
        /// <returns></returns>
        public dynamic GetqualityStencilList(string workCenterCode, string barCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {

                if (string.IsNullOrEmpty(workCenterCode)) { return response.ResponseError($"工序Code不能为空，请核对！"); }

                //获取列表
                var list = Context.Queryable<base_qualityStencil_Execute, bus_workOrder_detail, base_qualityStencil_detail>((a, b, c) => new JoinQueryInfos(
                         JoinType.Left, a.workOrderDetailKey == b.bodyKeys, JoinType.Left, a.qualityDetailKey == c.keys))
                         .Where((a, b, c) =>
                             a.isExecute == (int)EnumQualityisExecute.是
                             && a.state == (int)EnumQuality.启用
                             && b.workCenterCode == workCenterCode
                             && a.executeResult == (int)EnumQualityExecute.未执行
                         ).Select((a, b, c) => new
                         {
                             a.keys,
                             b.oprSequenceName,
                             b.barCode,
                             c.describe
                         }
                         ).ToList();

                if (!string.IsNullOrEmpty(barCode))
                {
                    list = list.Where(x => x.barCode == barCode).ToList();
                }

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

        /// <summary>
        /// 质检执行
        /// </summary>
        /// <param name="keys">keys 多个用逗号隔开</param>
        /// <param name="executeResult">执行结果 10合格，20不合格</param>
        /// <param name="executeUser">执行人</param>
        /// <returns></returns>
        public dynamic QualityStencilExecute(QualityExecute qualityExecute)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {

                if (string.IsNullOrEmpty(qualityExecute.keys)) { return response.ResponseError($"keys不能为空，请核对！"); }

                var keysStr = qualityExecute.keys.Split(",");

                //更新
                var upCount = Context.Updateable<base_qualityStencil_Execute>()
                    .SetColumns(x => x.isExecute == (int)EnumQualityisExecute.否)
                    .SetColumns(x => x.executeResult == qualityExecute.executeResult)
                    .SetColumns(x => x.executeUser == qualityExecute.executeUser)
                    .SetColumns(x => x.executeTime == DateTime.Now)
                    .SetColumns(x => x.updateTime == DateTime.Now)
                    .Where(x => keysStr.Contains(x.keys.ToString())).ExecuteCommand();

                if (upCount <= 0)
                {
                    return response.ResponseError($"操作失败！");
                }

                return response;
            });
        }

        #endregion

        #region 上料

        /// <summary>
        /// 上料任务查询(只返回20条数据)
        /// </summary>
        /// <param name="equipmentCode">工位编码</param>
        /// <returns></returns>
        public dynamic GetLoaderTaskList(string equipmentCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }

                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                //获取列表
                var list = Context.Queryable<base_loader_task, base_material>((a, b) => new JoinQueryInfos(
                                       JoinType.Left, a.materialCode == b.materialCode))
                                       .Where((a, b) => a.equipmentCode == equipmentCode && a.loaderStatus != (int)EnumLoaderTask.过期 && b.isDelete == (int)EnumtIsValid.是)
                                      .Select((a, b) => new
                                      {
                                          a.id,
                                          a.equipmentCode,
                                          a.taskCode,
                                          a.materialCode,
                                          a.loaderNum,
                                          a.feedbackNum,
                                          a.loaderStatus,
                                          a.consumeNum,
                                          b.materialName,
                                          a.createTime
                                      }).OrderBy((a) => a.createTime, OrderByType.Desc).Take(20).ToList();

                response.Result = list;
                response.Count = list.Count;

                return response;
            });
        }

        /// <summary>
        /// 物料查询(只返回20条数据)
        /// </summary>
        /// <param name="Code">code</param>
        /// <returns></returns>
        public dynamic GetMaterialList(string Code)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                var loaderTask = Context.Queryable<base_material>()
                    .Where(x => x.isDelete == (int)EnumtIsValid.是)
                    .WhereIF(!string.IsNullOrEmpty(Code), x => x.materialCode.Contains(Code) || x.materialName.Contains(Code) || x.specifications.Contains(Code))
                    .Take(20).ToList();

                response.Result = loaderTask;
                response.Count = loaderTask.Count;

                return response;
            });
        }

        /// <summary>
        /// 上料任务新增
        /// </summary>
        /// <param name="equipmentCode">工位编码</param>
        /// <param name="materialCode">物料码</param>
        /// <param name="Num">数量</param>
        /// <returns></returns>
        public dynamic InLoaderTask(string equipmentCode, string materialCode, int Num)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }
                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                if (string.IsNullOrEmpty(materialCode))
                {
                    return response.ResponseError($"物料编码不能为空，请核对！");
                }
                var material = Context.Queryable<base_material>().First(x => x.materialCode == materialCode && x.isDelete == (int)EnumtIsValid.是);
                if (material == null)
                {
                    return response.ResponseError($"物料编码未查询到物料数据，请核对！");
                }

                if (Num <= 0)
                {
                    return response.ResponseError($"上料数量为0，请核对！");
                }

                var loaderTaskList = Context.Queryable<base_loader_task>()
                   .Where(x => x.equipmentCode == equipmentCode && x.loaderStatus < (int)EnumLoaderTask.成功 && x.extend1 == ((int)EnumLoaderTaskType.原料上架).ToString()).ToList();

                if (loaderTaskList.Count > 0)
                {
                    return response.ResponseError($"有上料任务未完成，请稍后新增任务！");
                }

                var cutList = Context.Queryable<bus_cutplan_detail>().First(x => x.extend4.ToUpper() == equipment.lineCode.ToUpper() &&  x.cutState < 30  && string.IsNullOrEmpty(x.measureEndTime));
                if (cutList != null)
                {
                    return response.ResponseError($"除锈喷码未完成，请稍后新增任务！");
                }

                DateTime now = DateTime.Now;
                string taskCode = now.ToString("yyyyMMddHHmmss");

                var loaderTask = new base_loader_task();
                loaderTask.equipmentCode = equipmentCode;
                loaderTask.taskCode = taskCode;
                loaderTask.materialCode = materialCode;
                loaderTask.loaderNum = Num;
                loaderTask.feedbackNum = 0;
                loaderTask.consumeNum = 0;
                loaderTask.loaderStatus = 0;
                loaderTask.extend1 = ((int)EnumLoaderTaskType.原料上架).ToString();
                if (!string.IsNullOrEmpty(sysUserApi?.Account))
                {
                    loaderTask.createBy = sysUserApi?.Account;
                }
                else
                {
                    loaderTask.createBy = "system";
                }

                loaderTask.createTime = now;
                loaderTask.updateTime = now;

                var inSuccess = Context.Insertable(loaderTask).ExecuteCommand();
                if (inSuccess > 0)
                {
                    return response;
                }
                else
                {
                    return response.ResponseError($"新增任务失败，请稍后新增任务！");
                }
            });
        }

        /// <summary>
        /// 上料任务取消
        /// </summary>
        /// <param name="id">id</param>
        /// <returns></returns>
        public dynamic EscLoaderTask(int id)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (id <= 0)
                {
                    return response.ResponseError($"任务号错误，请核对！");
                }

                var loaderTask = Context.Queryable<base_loader_task>().Where(x => x.id == id).First();

                if (loaderTask.loaderStatus != 0)
                {
                    return response.ResponseError($"上料任务不是初始状态不能取消！");
                }

                loaderTask.loaderStatus = (int)EnumLoaderTask.过期;
                loaderTask.updateTime = DateTime.Now;
                if (!string.IsNullOrEmpty(sysUserApi?.Account))
                {
                    loaderTask.createBy = sysUserApi?.Account;
                }


                var upSuccess = Context.Updateable(loaderTask).ExecuteCommand();
                if (upSuccess > 0)
                {
                    return response;
                }
                else
                {
                    return response.ResponseError($"上料任务取消失败，请稍后再试！");
                }
            });
        }

        /// <summary>
        /// 余料上架任务新增
        /// </summary>
        /// <param name="equipmentCode">工位编码</param>
        /// <param name="oddCode">余料码，多个余料用竖杆“|”隔开</param>
        /// <returns></returns>
        public dynamic InLoaderOddTask(string equipmentCode, string oddCodes)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }
                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                if (string.IsNullOrEmpty(oddCodes))
                {
                    return response.ResponseError($"余料编码不能为空，请核对！");
                }

                var loaderTaskList = Context.Queryable<base_loader_task>()
                    .Where(x => x.equipmentCode == equipmentCode && x.loaderStatus < (int)EnumLoaderTask.成功 && x.extend1 == ((int)EnumLoaderTaskType.余料上架).ToString()).ToList();

                if (loaderTaskList.Count > 0)
                {
                    return response.ResponseError($"有余料上料任务未完成，请稍后新增任务！");
                }

                var oddCodeList = oddCodes.Split("|");
                foreach (var code in oddCodeList)
                {
                    var cutplanHead = Context.Queryable<bus_cutplan_head>().First(x => x.oddmentsCode == code);

                    if (cutplanHead == null)
                    {
                        return response.ResponseError($"余料编码【{code}】未查询到数据，请核对！");
                    }

                    var material = Context.Queryable<base_material>().First(x => x.materialCode == cutplanHead.materialCode && x.isDelete == (int)EnumtIsValid.是);
                    if (material == null)
                    {
                        return response.ResponseError($"物料编码【{cutplanHead.materialCode}】未查询到物料数据，请核对！");
                    }

                    var loaderTask = new base_loader_task();
                    loaderTask.equipmentCode = equipmentCode;
                    loaderTask.taskCode = code;
                    loaderTask.materialCode = cutplanHead.materialCode;
                    loaderTask.loaderNum = 1;
                    loaderTask.feedbackNum = 0;
                    loaderTask.consumeNum = 0;
                    loaderTask.loaderStatus = 0;
                    loaderTask.extend1 = ((int)EnumLoaderTaskType.余料上架).ToString();
                    if (!string.IsNullOrEmpty(sysUserApi?.Account))
                    {
                        loaderTask.createBy = sysUserApi?.Account;
                    }
                    else
                    {
                        loaderTask.createBy = "system";
                    }

                    loaderTask.createTime = DateTime.Now;
                    loaderTask.updateTime = DateTime.Now;

                    Context.Insertable(loaderTask).AddQueue();
                }

                var inSuccess = Context.SaveQueues();
                if (inSuccess > 0)
                {
                    return response;
                }
                else
                {
                    return response.ResponseError($"新增余料上架任务失败，请稍后新增任务！");
                }
            });
        }

        /// <summary>
        /// 余料信息查询
        /// </summary>
        /// <param name="oddCode">余料码</param>
        /// <returns></returns>
        public dynamic GetOddDetails(string oddCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(oddCode))
                {
                    return response.ResponseError($"余料编码不能为空，请核对！");
                }

                var cutplanHead = Context.Queryable<bus_cutplan_head>().First(x => x.oddmentsCode == oddCode);

                if (cutplanHead == null)
                {
                    return response.ResponseError($"余料编码【{oddCode}】未查询到数据，请核对！");
                }

                var material = Context.Queryable<base_material>().First(x => x.materialCode == cutplanHead.materialCode && x.isDelete == (int)EnumtIsValid.是);
                if (material == null)
                {
                    return response.ResponseError($"物料编码【{cutplanHead.materialCode}】未查询到物料数据，请核对！");
                }

                var oddDetails = new OddDetails();
                oddDetails.oddCode = oddCode;
                oddDetails.materialCode = material.materialCode;
                oddDetails.materialName = material.materialName;
                oddDetails.types = material.types;
                oddDetails.diameter = material.diameter;
                oddDetails.thickness = material.thickness;

                response.Result = oddDetails;
                return response;

            });
        }
        #endregion

        #region 气动打标任务

        /// <summary>
        /// 打标任务查询(只返回50条数据)-工位打标
        /// </summary>
        /// <param name="equipmentCode">工位编码</param>
        /// <param name="Status">打标状态  初始 = 0,待下发=5,已下发=10</param>
        /// <returns></returns>
        public dynamic GetImprintTaskList(string equipmentCode, int Status)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }

                if (Status < 0)
                {
                    return response.ResponseError($"打标状态错误，请核对！");
                }

                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                var irwstate = "初始";
                if (Status == 5)
                {
                    irwstate = "待下发";
                }
                else if (Status == 10)
                {
                    irwstate = "已下发";
                }

                //获取列表
                var list = Context.Queryable<base_imprint_task, bus_workOrder_detail, base_material, base_material>((a, b, c, d) =>
                                    new JoinQueryInfos(
                                       JoinType.Left, a.procedureID == b.id,
                                       JoinType.Left, b.weldMaterCode == c.materialCode,
                                       JoinType.Left, b.cutMaterCode == d.materialCode
                                       )).Where((a, b, c, d) => a.equipmentCode == equipmentCode && a.status == Status && c.isDelete == (int)EnumtIsValid.是 && d.isDelete == (int)EnumtIsValid.是)
                                      .Select((a, b, c, d) => new
                                      {
                                          a.id,
                                          a.equipmentCode,
                                          a.barCode,
                                          a.content,
                                          a.status,
                                          b.cuttingLength,
                                          materialName1 = d.materialName,
                                          c.materialName,
                                          a.createTime,
                                          rwstate = irwstate
                                      }).OrderBy((a) => a.createTime, OrderByType.Asc).Take(50).ToList();

                response.Result = list;
                response.Count = list.Count;

                return response;
            });
        }

        /// <summary>
        /// 打标任务下发-工位打标
        /// </summary>
        /// <param name="ID">任务ID</param>
        /// <param name="equipmentCode">工位编码</param>
        /// <param name="Status">操作状态：0新增，1取消</param>
        /// <returns></returns>
        public dynamic ImprintTaskIssued(int ID, string equipmentCode, int Status)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (ID < 0)
                {
                    return response.ResponseError($"任务ID错误，请核对！");
                }

                if (Status < 0)
                {
                    return response.ResponseError($"操作状态错误，请核对！");
                }

                var imprint = Context.Queryable<base_imprint_task>().First(x => x.id == ID);
                if (imprint == null)
                {
                    return response.ResponseError($"任务ID未查询到信息，请核对！");
                }

                if (string.IsNullOrEmpty(imprint.equipmentCode) && string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"请扫描设备码！");
                }

                if (!string.IsNullOrEmpty(equipmentCode))
                {
                    imprint.equipmentCode = equipmentCode;
                }

                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == imprint.equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                //新增验证
                if (Status == (int)EnumEscOrAdd.新增)
                {
                    var imprintList = Context.Queryable<base_imprint_task>()
                        .Where(x => x.status == (int)EnumImprintTaskType.待下发 && x.equipmentCode == imprint.equipmentCode).ToList();
                    if (imprintList.Count > 0)
                    {
                        return response.ResponseError($"该设备存在待下发任务，不能重复下发！");
                    }
                }

                //判断该物料另一个口是否已经打码，如果打码提示去同一设备打码
                var imprint1 = Context.Queryable<base_imprint_task>().First(x => x.barCode == imprint.barCode && x.id != imprint.id);
                if (Status == (int)EnumEscOrAdd.新增 && imprint1 != null && !string.IsNullOrEmpty(imprint1.equipmentCode) && imprint1.equipmentCode != imprint.equipmentCode)
                {
                    return response.ResponseError($"该管件另一焊口物料已经在【{imprint1.equipmentCode}】设备打码，请去该设备打码！");
                }


                imprint.status = (int)EnumImprintTaskType.待下发;
                if (Status == (int)EnumEscOrAdd.取消)
                {
                    imprint.status = (int)EnumImprintTaskType.初始;

                    //判断是否已经分配过去向，去向有可能是切割完分配的，就不能清空工位码与工位编号
                    var orderDetail = Context.Queryable<bus_workOrder_detail>()
                        .Where(x => x.barCode == imprint.barCode && x.oprSequenceCode == EnumoprSequenceCode.切割).First();

                    if (orderDetail != null && string.IsNullOrEmpty(orderDetail.stationCode))
                    {
                        imprint.equipmentCode = "";
                        imprint.equipmentNo = "";
                    }
                }

                imprint.updateTime = DateTime.Now;
                imprint.createBy = sysUserApi?.Account;

                Context.Updateable(imprint).ExecuteCommand();

                return response;
            });
        }

        /// <summary>
        /// 产前打标任务查询(只返回50条数据)
        /// </summary>
        /// <param name="lineCode">产线</param>
        /// <param name="equipmentCode">工位编码</param>
        /// <param name="Status">打标状态  初始 = 0,待下发=5,已下发=10</param>
        /// <param name="barCode">管段号（模糊搜索）</param>
        /// <param name="flowOrientation">流向：L=长管，S=短管</param>
        /// <returns></returns>
        public dynamic GetPreproductionTaskList(string lineCode, string equipmentCode, int Status, string barCode, string flowOrientation)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                //兼容PDA没更新的情况
                if (string.IsNullOrEmpty(flowOrientation))
                {
                    flowOrientation = EnumFlowOrientation.长管装配;
                }

                if (string.IsNullOrEmpty(lineCode))
                {
                    return response.ResponseError($"请选择产线！");
                }

                if (Status < 0)
                {
                    return response.ResponseError($"打标状态错误，请核对！");
                }
                else if (Status > 0)
                {
                    if (string.IsNullOrEmpty(equipmentCode))
                    {
                        return response.ResponseError($"查询待下发与已下发的任务需要扫码工位码！");
                    }
                }

                if (!string.IsNullOrEmpty(equipmentCode))
                {
                    var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                    if (equipment == null)
                    {
                        return response.ResponseError($"工位编码未查询到设备，请配置！");
                    }
                }


                var irwstate = "初始";
                if (Status == (int)EnumImprintTaskType.待下发)
                {
                    irwstate = "待下发";
                }
                else if (Status == (int)EnumImprintTaskType.已下发)
                {
                    irwstate = "已下发";
                }

                //获取列表
                var list = Context.Queryable<base_imprint_task, bus_workOrder_detail, base_work_order_head>((a, b, f) =>
                                    new JoinQueryInfos(
                                       JoinType.Left, a.procedureID == b.id,
                                       JoinType.Left, b.headKeys == f.keys
                                       )).Where((a, b, f) => a.lineCode.ToUpper() == lineCode.ToUpper() && a.status == Status && f.flowOrientation1 == flowOrientation)
                                      .Select((a, b, f) => new RMaterial
                                      {
                                          id = a.id,
                                          equipmentCode = a.equipmentCode,
                                          barCode = a.barCode,
                                          content = a.content,
                                          status = a.status,
                                          cuttingLength = b.cuttingLength,
                                          createTime = a.createTime,
                                          rwstate = irwstate,
                                          weldMaterCode = b.weldMaterCode,
                                          cutMaterCode = b.cutMaterCode

                                      }).OrderBy((a) => a.createTime, OrderByType.Asc).ToList();

                if (Status == (int)EnumImprintTaskType.初始)
                {
                    list = list.Where(x => string.IsNullOrEmpty(x.equipmentCode)).ToList();
                }

                if (!string.IsNullOrEmpty(equipmentCode) && Status != (int)EnumImprintTaskType.初始)
                {
                    list = list.Where(x => x.equipmentCode == equipmentCode).ToList();
                }
                if (!string.IsNullOrEmpty(barCode))
                {
                    list = list.Where(x => x.barCode.Contains(barCode)).ToList();
                }

                var rList = list.Take(50).ToList();

                rList.ForEach(x =>
                {
                    var material1 = Context.Queryable<base_material>().Where(d => d.materialCode == x.weldMaterCode).First();
                    if (material1 != null)
                    {
                        x.materialName1 = material1.materialName;
                    }

                    var material2 = Context.Queryable<base_material>().Where(d => d.materialCode == x.cutMaterCode).First();
                    if (material2 != null)
                    {
                        x.materialName = material2.materialName;
                    }
                });

                response.Result = rList;
                response.Count = list.Count;

                return response;
            });
        }


        #endregion

        #region 坡口任务

        /// <summary>
        /// 管段坡口信息查询
        /// </summary>
        /// <param name="barCode">管段码</param>
        /// <returns></returns>
        public dynamic GetBevelDet(string barCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(barCode))
                {
                    return response.ResponseError($"管段码不能为空，请核对！");
                }

                var orderDetailList = Context.Queryable<bus_workOrder_detail>()
                    .Where(x => x.barCode == barCode && x.oprSequenceCode == EnumoprSequenceCode.坡口).ToList();

                if (orderDetailList.Count == 0)
                {
                    return response.ResponseError($"管段码【{barCode}】未查询到坡口信息！");
                }

                var material = Context.Queryable<base_material>().First(x => x.materialCode == orderDetailList[0].cutMaterCode && x.isDelete == (int)EnumtIsValid.是);

                if (material == null)
                {
                    return response.ResponseError($"管段码【{barCode}】物料信息未配置，物料码【{orderDetailList[0].cutMaterCode}】！");
                }

                var bevelDet = new BevelDetModel();
                bevelDet.length = orderDetailList[0].cuttingLength;
                bevelDet.materialName = material.materialName;
                bevelDet.bevels1 = orderDetailList[0].extendComp2;
                bevelDet.bevels2 = orderDetailList[0].extendComp3;
                bevelDet.content = "单端坡口";
                if (orderDetailList.Count > 1)
                {
                    bevelDet.content = "双端坡口";
                }

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

        /// <summary>
        /// 管段坡口任务新增
        /// </summary>
        /// <param name="barCode">管段码</param>
        /// <param name="equipmentCode">工位编码</param>
        /// <returns></returns>
        public dynamic InBevelTask(string barCode, string equipmentCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(barCode))
                {
                    return response.ResponseError($"管段码不能为空，请核对！");
                }

                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }
                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                var orderDetail = Context.Queryable<bus_workOrder_detail>()
                    .Where(x => x.barCode == barCode && x.oprSequenceCode == EnumoprSequenceCode.坡口).First();

                if (orderDetail == null)
                {
                    return response.ResponseError($"管段码【{barCode}】未查询到坡口信息！");
                }

                var material = Context.Queryable<base_material>().First(x => x.materialCode == orderDetail.cutMaterCode && x.isDelete == (int)EnumtIsValid.是);

                if (material == null)
                {
                    return response.ResponseError($"管段码【{barCode}】物料信息未配置，物料码【{orderDetail.cutMaterCode}】！");
                }

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

                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 = "1"; break;
                }

                Context.Insertable(Equipment).ExecuteCommand();

                return response;
            });
        }

        #endregion

        #region 弯管任务

        /// <summary>
        /// 弯管信息查询
        /// </summary>
        /// <param name="barCode">管段码</param>
        /// <param name="selType">查询状态：0=未下发，10=已经下发</param>
        /// <returns></returns>
        public dynamic GetBentPipeDet(string barCode, int selType)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {

                //获取列表
                var orderDetailList = Context.Queryable<bus_workOrder_detail, base_material>((a, b) =>
                                    new JoinQueryInfos(JoinType.Left, a.cutMaterCode == b.materialCode))
                                      .Where((a, b) => a.oprSequenceCode == EnumoprSequenceCode.弯管 && b.isDelete == (int)EnumtIsValid.是)
                                      .WhereIF(!string.IsNullOrEmpty(barCode), (a, b) => a.barCode.Contains(barCode))
                                      .WhereIF(selType == 0, (a, b) => a.state == (int)EnumOrderBodyStatus.初始化)
                                      .WhereIF(selType > 0, (a, b) => a.state > (int)EnumOrderBodyStatus.初始化)
                                      .Select((a, b) => new
                                      {
                                          a.id,
                                          a.barCode,
                                          a.cuttingLength,
                                          b.materialName,
                                          a.createTime
                                      }).OrderBy((a) => a.createTime, OrderByType.Asc)
                                      .Take(50).ToList();

                if (orderDetailList.Count == 0)
                {
                    return response.ResponseError($"未查询到弯管任务！");
                }

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


        /// <summary>
        /// 弯管任务新增
        /// </summary>
        /// <param name="barCode">管段码</param>
        /// <param name="equipmentCode">工位编码</param>
        /// <returns></returns>
        public dynamic InBentPipeTask(string barCode, string equipmentCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(barCode))
                {
                    return response.ResponseError($"管段码不能为空，请核对！");
                }

                var orderDetail = Context.Queryable<bus_workOrder_detail>()
                    .Where(x => x.barCode == barCode && x.oprSequenceCode == EnumoprSequenceCode.弯管).First();

                if (orderDetail == null)
                {
                    return response.ResponseError($"管段码【{barCode}】未查询到弯管工序信息！");
                }

                if (string.IsNullOrEmpty(equipmentCode))
                {
                    return response.ResponseError($"工位编码不能为空，请核对！");
                }

                var equipment = Context.Queryable<base_work_station>().First(x => x.workStationCode == equipmentCode);
                if (equipment == null)
                {
                    return response.ResponseError($"工位编码未查询到设备，请配置！");
                }

                if (string.IsNullOrEmpty(equipment.monitorIP))
                {
                    return response.ResponseError($"工位【{equipment.workStationName}】未配置IP，请配置！");
                }

                var orderBend = Context.Queryable<base_work_order_bends>().Where(x => x.workPieceNo == barCode).First();
                if (orderBend == null)
                {
                    return response.ResponseError($"管段没有弯管信息，请核对！");
                }

                BentPipeModel bentPipeModel = new BentPipeModel();

                bentPipeModel.batchCode = orderBend.workPieceNo;
                bentPipeModel.mCode = equipmentCode;
                bentPipeModel.bendList = new List<Bend>();

                Bend bend = new Bend();
                bend.project = orderBend.shipNo;
                bend.number = orderBend.pipePartsNo;
                bend.pno = orderBend.workPieceNo;
                bend.material = "碳钢";
                bend.pipeDia = orderBend.externalDiameter;
                bend.thickness = orderBend.thickness;
                bend.beforeBendLength = orderBend.length;
                bend.bendMoldRadius = orderBend.radius;
                bend.head = orderBend.file1;
                bend.bottom = orderBend.file2;
                bend.flangeIncludedAngle = orderBend.mountingCorner;
                bend.fistBendAngle = orderBend.cornerOne;
                bend.yBCList = new List<YBC>();

                if (string.IsNullOrEmpty(orderBend.straightSegment) ||
                    string.IsNullOrEmpty(orderBend.corner) ||
                    string.IsNullOrEmpty(orderBend.curve))
                {
                    return response.ResponseError($"直段,转角,弯角数据为空，请核对！");
                }

                var YList = orderBend.straightSegment.Split("/");
                var BList = orderBend.corner.Split("/");
                var CList = orderBend.curve.Split("/");

                if (YList.Length == BList.Length && YList.Length == CList.Length)
                {
                    for (int i = 0; i < YList.Length; i++)
                    {
                        YBC yBC = new YBC();
                        yBC.bendDataY = YList[i];
                        yBC.bendDataB = BList[i];
                        yBC.bendDataC = CList[i];
                        bend.yBCList.Add(yBC);
                    }
                }
                else
                {
                    return response.ResponseError($"直段,转角,弯角数据错误，请核对！");
                }

                bentPipeModel.bendList.Add(bend);


                //发送弯管机数据 url = "/bendApi/PushBendData";
                var url = GetDictionaryDictValue("UrlPushBendData", "GetUrl");
                if (string.IsNullOrEmpty(url))
                {
                    return response.ResponseError($"字典未配置请求地址，请配置！");
                }

                url = $"{equipment.monitorIP}{url}";

                var WCSresponse = HttpManWCSByBends(url, bentPipeModel, EnumLog.弯管机接口.ToString(), method: "post");
                if (WCSresponse.Code == 200)
                {
                    orderDetail.actualStartTime = DateTime.Now;
                    orderDetail.updateTime = DateTime.Now;
                    orderDetail.state = (int)EnumOrderBodyStatus.生产中;
                    orderDetail.updateBy = sysUserApi?.Account;
                    orderDetail.equipmentCode = equipmentCode;

                    Context.Updateable(orderDetail).ExecuteCommand();

                    return response;
                }
                else
                {
                    //{WCSresponse.Result}
                    return response.ResponseError($"发送数据失败,与弯管机通讯失败！");
                }
            });
        }

        #endregion

        #region 火焰切割任务

        /// <summary>
        /// 火焰切割查询
        /// </summary>
        /// <param name="barCode">管段码</param>
        /// <returns></returns>
        public dynamic GetFlameCutDet(string barCode)
        {
            var response = new POJO.Response.Response();
            return ExceptionsHelp.Instance.ExecuteT<dynamic>(() =>
            {
                if (string.IsNullOrEmpty(barCode))
                {
                    return response.ResponseError($"管段码不能为空，请核对！");
                }

                var work_order = Context.Queryable<base_work_order_head>().First(x => x.workPieceNo == barCode);
                if (work_order == null)
                {
                    return response.ResponseError("未获取到对应的工单数据");
                }

                var cuts = Context.Queryable<base_work_order_flameCut>().First(x => x.headKeys.Equals(work_order.keys));
                if (cuts == null)
                {
                    return response.ResponseError("未获取到对应的切割数据");
                }


                var material = Context.Queryable<base_material>().First(x => x.materialCode == work_order.materielCode && x.isDelete == (int)EnumtIsValid.是);

                if (material == null)
                {
                    return response.ResponseError($"管段码【{barCode}】物料信息未配置，物料码【{work_order.materielCode}】！");
                }

                var bevelDet = new BevelDetModel();
                bevelDet.length = work_order.cutLength;
                bevelDet.materialName = material.materialName;

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

        #endregion
    }
}