MES / haiNeng · Files

using Hh.Mes.Common.log;
using Hh.Mes.Common.Request;
using Hh.Mes.Pojo.System;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.ViewModel;
using Hh.Mes.POJO.Response;
using Hh.Mes.Service.Repository;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Hh.Mes.Service.Distribution
{
    /// <summary>
    /// 装料数据
    /// </summary>
    public class MaterialDistributeLoadDataService : RepositorySqlSugar<bus_material_distribute_load_head>
    {
        #region 头
        /// <summary>
        /// //获取列表
        /// </summary>
        public Response Load(PageReq pageReq, bus_material_distribute_load_head model)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                string orderBy = (pageReq == null || string.IsNullOrEmpty(pageReq.field)) ? " id desc" : $"{pageReq.field} {pageReq.order} ";
                string sqlWhere = SqlWhere(model);
                var stringBuilder = new StringBuilder();
                //页码，页数
                //Exel ture 不分页
                if (!model.Exel && pageReq != null)
                {
                    stringBuilder.Append("declare @pageIndex int,@pageSize int,@offset int");
                    stringBuilder.AppendLine($"  select @pageIndex={pageReq.page}, @pageSize={pageReq.limit}, @offset=(@pageIndex - 1) * @pageSize");
                }

                stringBuilder.AppendLine($@" select  * 
                                         from bus_material_distribute_load_head  with(nolock)
                                         where {sqlWhere}
                                         order by {orderBy} ");

                //Exel ture 不分页
                if (!model.Exel)
                {
                    stringBuilder.AppendLine("  offset @offset row fetch next @pageSize row only ");
                    stringBuilder.Append($" select rowTotal= count(*) from bus_material_distribute_load_head    with(nolock) where {sqlWhere}");
                }
                var ds = base.Context.Ado.GetDataSetAll(stringBuilder.ToString(), new List<SugarParameter>(){
                                                        new SugarParameter("@productCode",model.productCode),
                                                        new SugarParameter("@status", model.status)});
                result.Result = ds.Tables[0];
                result.Count = model.Exel ? (int)result.Result.Rows.Count : (int)ds.Tables[1].Rows[0]["rowTotal"];
                return result;
            });
        }

        public string SqlWhere(bus_material_distribute_load_head model)
        {
            var stringBuilder = new StringBuilder();
            stringBuilder.Append("1=1");
            if (!string.IsNullOrWhiteSpace(model.productCode)) stringBuilder.Append(" and  t1.productCode like @productCode ");
            if (model.status != null) stringBuilder.Append(" and  t1.status = @status ");

            return stringBuilder.ToString();
        }

        /// <summary>
        /// 新增
        /// </summary>
        public dynamic Ins(bus_material_distribute_load_head model)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region 校验数据
                if (string.IsNullOrWhiteSpace(model.endPosition))
                {
                    if (SystemVariable.noneGoodsLocationCodes.Item2.Count == 0)
                    {
                        return response.ResponseError($"组队上料点是空，暂无可上料料点，请确认PLC料点信号是否正常!");
                    }
                    var resultLocation = GetLoadMaterialLocation(model.productCode, model.containerCode, model.startPosition);
                    model.endPosition = resultLocation.Result[0].locationCode;
                }


                var container = base.Context.Queryable<base_container>().First(x => x.containerCode == model.containerCode);
                if (container == null) return response.ResponseError($"料框条码(容器编码)【{model.containerCode}】不存在【容器管理】基础数据中!");

                var zhuangLiao = (int)EnumLocationZoneCode.装料点;
                var shangLiao = (int)EnumLocationZoneCode.上料点;
                var locationList = base.Context.Queryable<base_location>()
                                               .Where(x => x.locationCode == model.startPosition || x.locationCode == model.endPosition)
                                               .ToList();
                var startLocation = locationList.FirstOrDefault(t => t.zoneCode == zhuangLiao && t.locationCode == model.startPosition);
                if (startLocation == null)
                {
                    return response.ResponseError($"【库位管理】中【人工装料区】不存在库位【{model.startPosition}】!");
                }
                if (string.IsNullOrEmpty(startLocation.containerCode))
                {
                    return response.ResponseError($"【库位管理】中库位【{startLocation.locationCode}】不存在容器【{startLocation.containerCode}】不能装料！");
                }
                if (startLocation.locationType != container.containerType)
                {
                    return response.ResponseError($"库位【{startLocation.locationCode}】的类型是【{startLocation.locationType}】，托盘【{container.containerCode}】的类型是【{container.containerType}】，不能装料！");
                }
                if (startLocation.locationStatus == (int)EnumLocationStatus.锁定)
                {
                    return response.ResponseError($"【库位管理】中库位【{startLocation.locationCode}】有任务锁定，不能装料！");
                }
                var endLocation = locationList.FirstOrDefault(t => t.zoneCode == shangLiao && t.locationCode == model.endPosition);
                if (endLocation == null)
                {
                    return response.ResponseError($"【库位管理】中【组队上料区】不存在库位【{model.endPosition}】!");
                }
                if (!string.IsNullOrEmpty(endLocation.containerCode))
                {
                    return response.ResponseError($"【库位管理】中库位【{endLocation.locationCode}】存在容器【{endLocation.containerCode}】不能装料！");
                }
                if (endLocation.locationType != container.containerType)
                {
                    return response.ResponseError($"库位【{endLocation.locationCode}】的类型是【{endLocation.locationType}】，托盘【{container.containerCode}】的类型是【{container.containerType}】，不能上料！");
                }
                if (endLocation.locationStatus == (int)EnumLocationStatus.锁定)
                {
                    return response.ResponseError($"【库位管理】中库位【{endLocation.locationCode}】有任务锁定，不能装料！");
                }

                //检查同一组装料区域的配送，是否都是往同一个组队上料区域，（例如装料点A1去了组队1的区域1，装料点B1只能去组队1的区域1，否则机器人无法抓料）
                var otherDistributeHead = base.Context.Queryable<bus_material_distribute_load_head>()
                                                      .First(x => x.startStationCode == startLocation.stationCode && x.startArea == startLocation.fitupArea && x.status < (int)EnumLoadData.配送完成);
                if (otherDistributeHead != null)
                {
                    if (otherDistributeHead.productCode != model.productCode)
                    {
                        return response.ResponseError($"本组装料中已经有一个框料装的产品【{otherDistributeHead.productCode}】，本料框也只能装相同产品的物料！");
                    }
                    if (otherDistributeHead.loadQty != model.loadQty)
                    {
                        return response.ResponseError($"本组装料中已经有一个框料装了【{otherDistributeHead.loadQty}】套产品的物料，本料框也只能装相同套数！");
                    }
                    if (otherDistributeHead.endStationCode != endLocation.stationCode || otherDistributeHead.endArea != endLocation.fitupArea)
                    {
                        return response.ResponseError($"本组装料中已经有一个框料去工位【{otherDistributeHead.endStationCode}】上料区域【{otherDistributeHead.endArea}】，本料框也只能去相同工位和上料区域，请重新设置！");
                    }
                }

                #endregion

                #region 生成实体

                //生成【装料配送头】实体
                model.keys = Guid.NewGuid();
                model.containerType = container.containerType;
                model.startStationCode = startLocation.stationCode;
                model.startArea = startLocation.fitupArea;
                model.endStationCode = endLocation.stationCode;
                model.endArea = endLocation.fitupArea;
                model.status = (int)EnumLoadData.已装料;
                model.createBy = base.sysWebUser.Account;
                model.createTime = DateTime.Now;

                //生成【配送任务】明细实体
                var distributeDetail = new List<bus_material_distribute_load_detail>();
                for (int i = 0; i < model.table.Count; i++)
                {
                    if (model.table[i].sequence > 0 && model.table[i].row >= 0 && model.table[i].line >= 0 && model.table[i].layer >= 0)
                    {
                        distributeDetail.Add(new bus_material_distribute_load_detail()
                        {
                            headKeys = model.keys,
                            bodyKeys = Guid.NewGuid(),

                            loadDataBodyKeys = model.table[i].bodyKeys,
                            sequence = model.table[i].sequence.Value,

                            row = model.table[i].row.Value,
                            line = model.table[i].line.Value,
                            qty = model.table[i].qty.Value,
                            layer = model.table[i].layer.Value,

                            createBy = sysWebUser.Account,
                            createTime = DateTime.Now
                        });
                    }
                }
                if (distributeDetail.Count == 0)
                {
                    response.ResponseError("没有装料明细，无法保存！");
                }


                //生成【AGV任务】实体
                var busAgvTask = new bus_agv_task()
                {
                    keys = Guid.NewGuid(),
                    taskCode = Guid.NewGuid().ToString(),
                    agvCode = "",
                    agvTaskType = (int)EnumAgvTaskType.Feeding,

                    materialFrameCode = model.containerCode,
                    materialDistributeLoadCode = model.keys.ToString(),
                    workOrderCode = "",
                    productHeaderCode = model.productCode,

                    startPosition = model.startPosition,
                    endPosition = model.endPosition,
                    state = (int)EnumAGVState.任务创建,
                    createTime = DateTime.Now,
                    createBy = sysWebUser.Account,
                };
                //修改【库位】实体
                startLocation.locationStatus = (int)EnumLocationStatus.锁定;
                endLocation.locationStatus = (int)EnumLocationStatus.锁定;

                #endregion

                #region 执行数据库操作
                //添加实体到执行队列
                base.Context.Insertable(model).AddQueue();
                base.Context.Insertable(distributeDetail).AddQueue();
                base.Context.Insertable(busAgvTask).AddQueue();
                base.Context.Updateable(startLocation).UpdateColumns(t => t.locationStatus).AddQueue();
                base.Context.Updateable(endLocation).UpdateColumns(t => t.locationStatus).AddQueue();
                //保存数据
                var result = base.Context.SaveQueues() > 0;
                if (!result)
                {
                    response.ResponseError("更新数据库失败！");
                }
                return response;
                #endregion
            });
        }


        /// <summary>
        /// 更新
        /// </summary>
        public dynamic Upd(bus_material_distribute_load_head model)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region before

                //if (string.IsNullOrEmpty(model.endPosition))
                //    return response.ResponseError($"组队上料点是空，请输入!");

                //var container = base.Context.Queryable<base_container>().First(x => x.containerCode == model.containerCode);
                //if (container == null) return response.ResponseError($"料框条码(容器编码)【{model.containerCode}】不存在【容器管理】基础数据中!");
                if (model.table.Count == 0)
                {
                    response.ResponseError("没有装料明细，无法保存！");
                }

                var yizhuangliao = (int)EnumLoadData.使用中;
                var distributeHead = base.Context.Queryable<bus_material_distribute_load_head>().First(x => x.id == model.id);
                if (distributeHead.status < yizhuangliao) return response.ResponseError("装料数据状态是小于【使用中】才能编辑!");

                //model.containerType = container.containerType;
                model.updateBy = base.sysWebUser.Account;
                model.updateTime = DateTime.Now;

                #endregion

                #region detail
                for (int i = 0; i < model.table.Count; i++)
                {
                    if (model.table[i].sequence > 0 && model.table[i].row >= 0 && model.table[i].line >= 0 && model.table[i].layer >= 0)
                    {
                        var key = model.table[i].bodyKeys;
                        var detail = new bus_material_distribute_load_detail()
                        {
                            row = model.table[i].row.Value,
                            line = model.table[i].line.Value,
                            qty = model.table[i].qty.Value,
                            layer = model.table[i].layer.Value,

                            updateBy = sysWebUser.Account,
                            updateTime = DateTime.Now
                        };
                        base.Context.Updateable(detail).Where(x => x.bodyKeys == key).UpdateColumns(x => new
                        {
                            x.row,
                            x.line,
                            x.qty,
                            x.layer,
                            x.updateBy,
                            x.updateTime
                        }).AddQueue();
                    }
                }

                #endregion

                #region head
                base.Context.Updateable(model).UpdateColumns(x => new
                {
                    //x.containerCode,
                    //x.productCode,
                    x.loadQty,
                    //x.startPosition,
                    //x.endPosition,
                    //x.containerType,

                    x.updateBy,
                    x.updateTime
                }).Where(x => x.id == model.id).AddQueue();
                #endregion

                var result = base.Context.SaveQueues() > 0;
                if (!result) response.ResponseError("更新数据库失败！");
                return response;
            });

        }

        /// <summary>
        /// 删除
        /// </summary>
        public dynamic DelByIds(Guid[] ids)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                Context.Deleteable<bus_material_distribute_load_head>().In(x => x.keys, ids).AddQueue();
                foreach (var id in ids)
                {
                    Context.Deleteable<bus_material_distribute_load_detail>().Where(it => it.headKeys == id).AddQueue();
                }
                var result = Context.SaveQueues();
                if (result < 0) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        /// <summary>
        /// 导出方法
        /// </summary>
        /// <returns></returns>
        public Task<dynamic> Export(bus_material_distribute_load_head entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var dataTable = Load(null, entity);
                if (dataTable.Count == 0)
                {
                    result.Result = null;
                    result.Message = "没有查询到数据！";
                    result.Code = -1;
                    return result;
                }
                var guids = new List<Guid>();
                foreach (var item in dataTable.Result)
                {
                    guids.Add((Guid)item.keys);
                }
                var data = LoadDesc(null, new bus_material_distribute_load_detail { headKeyList = guids });
                result.Result = new
                {
                    head = dataTable.Result,
                    body = data.Result
                };
                return result;
            });
        }

        /// <summary>
        /// 产品代码查询装料模板数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public Response GetLoadDataTemplateByProductCode(bus_material_distribute_load_head entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                //新增第一个无法清空数据，只能默认发送一次数据请求
                if (entity.productCode == "-1") return response.ResponseError("先扫人工装料点、料框条码(容器编码、在选产品编码!");

                //通过容器编码（料框编码）和产品编码过滤 装料数据模板类型【A、或者B】
                var container = base.Context.Queryable<base_container>().First(x => x.containerCode == entity.containerCode);
                if (container == null) return response.ResponseError($"料框条码(容器编码)【{entity.containerCode}】不存在【容器管理】基础数据中!");

                var heardTemplate = base.Context.Queryable<bus_material_distribute_load_template_head>().First(x => x.productCode == entity.productCode);
                if (heardTemplate == null) return response.ResponseError($"产品【{entity.productCode}】没有配置装料模板头表数据!");

                dynamic data = null;
                if (entity.flag != "edit")
                {
                    data = base.Context.Queryable<bus_material_distribute_load_template_detail>().Where(x => x.headKeys == heardTemplate.keys && x.containerType == container.containerType).ToList();
                    if (data.Count == 0) return response.ResponseError($"产品【{entity.productCode}】没有配置装料模板明细数据!");
                    response.Count = data.Count;
                }
                else
                {
                    var sql = $@" select t1.*, t2.materialCode,t2.containerType 
                                  from bus_material_distribute_load_detail t1
                                  left join  bus_material_distribute_load_template_detail t2 on t1.loadDataBodyKeys = t2.bodyKeys
                                  where t1.headKeys='{entity.keys}' ";
                    data = base.Context.Ado.GetDataTable(sql);
                    if (data.Rows.Count == 0) return response.ResponseError($"产品{entity.productCode}没有配置装料模板明细数据!");
                    response.Count = data.Rows.Count;
                }
                response.Result = data;
                return response;
            });
        }

        /// <summary>
        /// 获取PLC无货的组队上料点
        /// </summary>
        /// <param name="productCode">产品编码</param>
        /// <param name="containerCode">托盘编码</param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public Response GetLoadMaterialLocation(string productCode, string containerCode, string startPosition = "")
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                if (SystemVariable.noneGoodsLocationCodes.Item1.AddSeconds(30) < DateTime.Now)
                    return response.ResponseError($"ECS已经超过30秒没向中控接口【distribution/MaterialDistributeLoadData/SetLoadMaterialLocation】发送可去的料点信息，请先检查ECS!");
                var locationCodes = SystemVariable.noneGoodsLocationCodes.Item2;

                //通过容器编码（料框编码）和产品编码过滤 装料数据模板类型【A、或者B】
                var container = base.Context.Queryable<base_container>().First(x => x.containerCode == containerCode);
                if (container == null) return response.ResponseError($"料框条码(容器编码)【{containerCode}】不存在【容器管理】基础数据中，请配置!");

                //查询产品的工艺路线
                var processRouteHead = base.Context.Queryable<base_process_route_head>().First(x => x.productHeaderCode == productCode);
                if (processRouteHead == null) return response.ResponseError($"产品编码【{productCode}】不存在【工艺路线头表】基础数据中，请配置!");

                //查询产品的工艺路线明细（暂时简单认为第一道工艺路线就是组队，后续要加上工序类型）
                var ProcessRouteDetail = base.Context.Queryable<base_process_route_detail>().First(x => x.headkeys == processRouteHead.keys && x.oprSequence == 1);
                if (ProcessRouteDetail == null) return response.ResponseError($"产品编码【{productCode}】不存在工序顺序为1的【工艺路线明细表】基础数据中，请配置!");

                //查询产品的工序工位，获取产品组队能去的所有工位
                var ProcessRouteStationList = base.Context.Queryable<base_process_route_station>().Where(x => x.bodyKeys == ProcessRouteDetail.bodyKeys).ToList();
                if (ProcessRouteStationList == null) return response.ResponseError($"产品编码【{productCode}】的工序【{ProcessRouteDetail.oprSequenceName}】不存在【工序工位表】基础数据中，请配置!");
                //产品组队能去的所有工位
                var workStationCodeList = ProcessRouteStationList.Select(x => x.workStationCode).ToList();

                var fitup = (int)EnumLocationZoneCode.上料点;
                //能去的料点的条件：1.料点类型和料框类型一致、2.产品能去的组队工位、3.料点无料框、4.ECS确认无货
                var locationList = base.Context.Queryable<base_location>()
                                               .Where(x => x.locationType == container.containerType && x.zoneCode == fitup && string.IsNullOrEmpty(x.containerCode)).ToList();
                locationList = locationList.Where(x => workStationCodeList.Contains(x.stationCode) && locationCodes.Contains(x.locationCode)).ToList();
                if (startPosition != "")
                {
                    var location = base.Context.Queryable<base_location>()
                                                      .First(u => u.locationCode == startPosition);
                    var otherDistributeHead = base.Context.Queryable<bus_material_distribute_load_head>()
                                                      .Where(x => x.startStationCode == location.stationCode && x.startArea == location.fitupArea.ToString() && x.status < (int)EnumLoadData.配送完成).ToList();
                    if (otherDistributeHead.Count() == 1)
                    {
                        var shangLiao = (int)EnumLocationZoneCode.上料点;
                        locationList = base.Context.Queryable<base_location>()
                                                      .Where(u => u.zoneCode == shangLiao && u.fitupArea.ToString() == otherDistributeHead[0].endArea && u.stationCode == otherDistributeHead[0].endStationCode && u.locationCode != otherDistributeHead[0].endPosition).ToList();
                    }
                }
                if (locationList.Count == 0) return response.ResponseError("根据产品编码、产品编码查询无组队上料点数据!");
                response.Result = locationList;
                return response;
            });
        }

        /// <summary>
        /// 强制完成装料数据
        /// </summary>
        public Response HandlerMaterialDistributeLoadEnd(Guid keys)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region before
                var material_Distribute_Load_Head = Context.Queryable<bus_material_distribute_load_head>().First(x => x.keys == keys);
                if (material_Distribute_Load_Head == null) return response.ResponseError("找不到对应的装料数据任务信息");
                if (material_Distribute_Load_Head.status == (int)EnumLoadData.完成) return response.ResponseError("装料任务已经完成，不能重复操作");


                #endregion

                #region save
                var kongXian = (int)EnumLocationStatus.空闲;
                var end = (int)EnumLoadData.完成;
                //更新配送任务状态
                Context.Updateable<bus_material_distribute_load_head>()
                       .SetColumns(x => x.status == end)
                       .Where(x => x.keys == keys)
                       .AddQueue();

                var firstLocation = Context.Queryable<base_location>().First(x => x.locationCode == material_Distribute_Load_Head.endPosition);
                var lastLocation = Context.Queryable<base_location>().First(x => x.stationCode == firstLocation.stationCode && x.fitupArea == firstLocation.fitupArea && x.locationType != firstLocation.locationType);
                if (lastLocation != null)
                {
                    var lastMaterialDistributeLoad = Context.Queryable<bus_material_distribute_load_head>().First(x => x.endPosition == lastLocation.locationCode && x.productCode == material_Distribute_Load_Head.productCode && x.status < (int)EnumLoadData.完成);
                    if (lastMaterialDistributeLoad != null)
                    {
                        Context.Updateable<bus_material_distribute_load_head>()
                       .SetColumns(x => x.status == end)
                       .Where(x => x.keys == lastMaterialDistributeLoad.keys)
                       .AddQueue();
                    }
                    var lastagvTask = Context.Queryable<bus_agv_task>().First(x => x.materialDistributeLoadCode == lastMaterialDistributeLoad.keys.ToString());
                    if (lastagvTask != null && lastagvTask.state != (int)EnumAGVState.任务完成)
                    {

                        lastagvTask.state = (int)EnumAGVState.任务完成;
                        Context.Updateable(lastagvTask).UpdateColumns(x => new { x.state }).AddQueue();
                        Context.Updateable<base_location>()
                           .SetColumns(x => x.containerCode == "")
                           .SetColumns(x => x.locationStatus == kongXian)
                           .Where(x => x.locationCode == lastagvTask.startPosition)
                           .AddQueue();
                        Context.Updateable<base_location>()
                               .SetColumns(x => x.containerCode == lastagvTask.materialFrameCode)
                               .SetColumns(x => x.locationStatus == kongXian)
                               .Where(x => x.locationCode == lastagvTask.endPosition)
                               .AddQueue();
                    }
                }
                //设置任务状态为完成
                var agvTask = Context.Queryable<bus_agv_task>().First(x => x.materialDistributeLoadCode == keys.ToString());
                if (agvTask != null && agvTask.state != (int)EnumAGVState.任务完成)
                {
                    agvTask.state = (int)EnumAGVState.任务完成;
                    Context.Updateable(agvTask).UpdateColumns(x => new { x.state }).AddQueue();
                    Context.Updateable<base_location>()
                          .SetColumns(x => x.containerCode == "")
                          .SetColumns(x => x.locationStatus == kongXian)
                          .Where(x => x.locationCode == agvTask.startPosition)
                          .AddQueue();
                    Context.Updateable<base_location>()
                           .SetColumns(x => x.containerCode == agvTask.materialFrameCode)
                           .SetColumns(x => x.locationStatus == kongXian)
                           .Where(x => x.locationCode == agvTask.endPosition)
                           .AddQueue();
                }



                if (ExecuteQueues(base.Context) > 0)
                {
                    #region 通知agv结束任务
                    // 
                    #endregion
                }
                else
                {
                    response.Message = "结束装料任务，更新数据库失败！";
                }
                #endregion

                return response;
            });
        }

        #endregion

        #region 明细

        /// <summary>
        /// //获取列表
        /// </summary>
        public Response LoadDesc(PageReq pageReq, bus_material_distribute_load_detail model)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var sql = $@" select t1.*, t2.materialCode,t2.containerType 
                              from bus_material_distribute_load_detail t1
                              left join  bus_material_distribute_load_template_detail t2 on t1.loadDataBodyKeys = t2.bodyKeys
                              where t1.headKeys='{model.headKeys}'";
                var data = base.Context.Ado.GetDataTable(sql);

                var result = new Response
                {
                    Code = 200,
                    Result = data,
                    Count = data.Rows.Count
                };
                return result;
            });
        }

        /// <summary>
        /// 新增
        /// </summary>
        public dynamic InsDesc(bus_material_distribute_load_detail model)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                model.createBy = base.sysWebUser.Account;
                model.createTime = DateTime.Now;
                response.Status = Context.Insertable(model).ExecuteCommand() > 0;
                if (!response.Status)
                {
                    response.Message = SystemVariable.dataActionError;
                }
                return response;
            });
        }

        /// <summary>
        /// 更新
        /// </summary>
        public dynamic UpdDesc(bus_material_distribute_load_detail model)
        {

            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                Context.Updateable(model).IgnoreColumns(x => new { x.createTime, x.createBy }).AddQueue();
                var result = Context.SaveQueues();
                if (result <= 0) return response.ResponseError();
                return response;

            });

        }



        /// <summary>
        /// 删除
        /// </summary>
        public dynamic DelByIdsDesc(int[] ids)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                response.Status = Context.Deleteable<bus_material_distribute_load_detail>().In(ids).ExecuteCommand() > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }
        #endregion

        #region 料点相关

        #region 全局静态变量相关

        private static readonly object lockObj = new object();

        /// <summary>
        /// 初始化叫料点状态全局静态变量
        /// </summary>
        /// <param name="isIni">是否初始化</param>
        public void IniLocationVm(bool isIni = false)
        {
            ExceptionsHelp.Instance.ExecuteVoidFunc(() =>
            {
                //这里必须加锁，不然并发后，库位信息就会重叠
                lock (lockObj)
                {
                    #region ini

                    ////是否已经初始化
                    //if (SystemVariable.locationList.Count > 0 && !isIni)
                    //    return;

                    ////装料数据
                    List<bus_material_distribute_load> materialDistributeList = null;

                    //叫料点位
                    var locationList = base.Context.Queryable<base_location>().ToList();

                    //删除料点表没有的料点
                    for (var i = SystemVariable.locationList.Count - 1; i >= 0; i--)
                    {
                        if (!locationList.Exists(t => t.locationCode == SystemVariable.locationList[i].locationCode))
                        {
                            SystemVariable.locationList.RemoveAt(i);
                        }
                    }
                    //找出静态变量中没有的料点信息
                    var tempList = locationList.Where(t => !SystemVariable.locationList.Exists(x => x.locationCode == t.locationCode)).ToList();
                    if (tempList.Count > 0)
                    {
                        materialDistributeList = base.Context.Queryable<bus_material_distribute_load>().Where(x => x.status < (int)EnumLoadData.配送完成).ToList();
                        var bus_agv_task = base.Context.Queryable<bus_agv_task>().Where(x => x.state < (int)EnumAGVState.AGV搬运完成).ToList();
                        //增加静态缓存中没有的料点
                        foreach (var locationItem in tempList)
                        {
                            locationItem.askingStatus = (int)EnumLocationAskingStatus.未叫料;
                            //判断是否有装料数据
                            var loads = materialDistributeList.Where(x => x.endPosition == locationItem.locationCode).ToList();
                            if (loads.Count() >= 1)
                            {
                                locationItem.askingStatus = (int)EnumLocationAskingStatus.已装料;
                                var keys = loads.Select(t => t.keys.ToString()).ToList();
                                var agv_Tasks = bus_agv_task.Where(t => keys.Contains(t.materialDistributeLoadCode));
                                if (agv_Tasks.Any())
                                {
                                    locationItem.askingStatus = (int)EnumLocationAskingStatus.已送料;
                                }

                            }
                            locationItem.updateTime = DateTime.Now;
                            SystemVariable.locationList.Add(locationItem);
                        }
                    }
                    ////找出状态为已叫料点位的修改时间小于当前时间30秒则取消叫料 ，和状态为已装料，但是没有装料数据小于完成 修改为未叫料
                    //var callLocations = SystemVariable.locationList.Where(t => t.askingStatus == (int)EnumLocationAskingStatus.已叫料).ToList();
                    //if (callLocations.Any())
                    //{
                    //    foreach (var item in callLocations)
                    //    {
                    //        if (item.updateTime.AddSeconds(30) < DateTime.Now)
                    //        {
                    //            item.askingStatus = (int)EnumLocationAskingStatus.未叫料;
                    //        }

                    //    }
                    //}
                    var loadLocations = SystemVariable.locationList.Where(t => t.askingStatus == (int)EnumLocationAskingStatus.已送料).ToList();
                    if (loadLocations.Any())
                    {
                        var locationCodes = loadLocations.Select(t => t.locationCode).ToList();
                        var loadDistributeLists = base.Context.Queryable<bus_material_distribute_load>().Where(x => x.status == (int)EnumLoadData.已装料 && locationCodes.Contains(x.endPosition)).ToList();
                        foreach (var item in loadLocations)
                        {
                            var loadDistributeList = loadDistributeLists.Where(x => x.endPosition == item.locationCode).ToList();
                            if (!loadDistributeList.Any())
                            {
                                item.askingStatus = (int)EnumLocationAskingStatus.未叫料;
                            }

                        }
                    }

                    #endregion
                }
            });
        }

        /// <summary>
        /// 更新叫料点状态全局静态变量
        /// </summary>
        /// <param name="locationCode">料点编码</param>
        /// <param name="locationStatus">叫料状态</param>
        public void UpLocationVm(string locationCode, EnumLocationAskingStatus locationStatus)
        {
            ExceptionsHelp.Instance.ExecuteVoidFunc(() =>
            {
                #region update

                if (string.IsNullOrEmpty(locationCode))
                    return;

                var locationItem = SystemVariable.locationList.Where(x => x.locationCode == locationCode).FirstOrDefault();
                //找到对应料点 更新状态与时间
                if (locationItem != null)
                {
                    locationItem.askingStatus = (int)locationStatus;
                    locationItem.updateTime = DateTime.Now;
                }

                #endregion
            });
        }

        /// <summary>
        /// 生成第二次装料agv任务
        /// </summary>
        /// <param name="locationCode">料点编码</param>
        /// <param name="locationStatus">叫料状态</param>
        public void InsAgvTask(string locationCode)
        {
            ExceptionsHelp.Instance.ExecuteVoidFunc(() =>
            {
                #region update
                var bus_Material_Distribute_s = base.Context.Queryable<bus_material_distribute_load>().Where(x => x.status == (int)EnumLoadData.已装料 && x.endPosition == locationCode).ToList();
                if (!bus_Material_Distribute_s.Any())
                {
                    return;
                }
                var bus_Agv_Tasks = base.Context.Queryable<bus_agv_task>().Where(x => x.materialDistributeLoadCode == $"{bus_Material_Distribute_s[0].keys}").ToList();
                if (bus_Agv_Tasks.Any())
                {
                    return;
                }

                //生成2个agv任务 完成agv料框对换
                //第一个去缓存去空料框去起点
                //第二个去起点送满料框去终点
                bus_agv_task agvTask1 = new bus_agv_task();
                agvTask1.keys = Guid.NewGuid();
                agvTask1.taskCode = Guid.NewGuid().ToString();
                agvTask1.agvCode = "";
                agvTask1.agvTaskType = (int)EnumAgvTaskType.Take;
                agvTask1.materialFrameCode = bus_Material_Distribute_s[0].containerCode;
                agvTask1.materialDistributeLoadCode = bus_Material_Distribute_s[0].keys.ToString();
                agvTask1.workOrderCode = bus_Material_Distribute_s[0].workOrderCode;
                agvTask1.productHeaderCode = bus_Material_Distribute_s[0].productCode;
                agvTask1.startPosition = bus_Material_Distribute_s[0].endPosition;
                agvTask1.endPosition = bus_Material_Distribute_s[0].startPosition;
                agvTask1.state = (int)EnumAGVState.任务创建;
                agvTask1.createTime = DateTime.Now;
                agvTask1.createBy = base.sysWebUser;

                bus_agv_task agvTask2 = new bus_agv_task();
                agvTask2.keys = Guid.NewGuid();
                agvTask2.taskCode = Guid.NewGuid().ToString();
                agvTask2.agvCode = "";
                agvTask2.agvTaskType = (int)EnumAgvTaskType.Feeding; ;
                agvTask2.materialFrameCode = bus_Material_Distribute_s[0].containerCode;
                agvTask2.materialDistributeLoadCode = bus_Material_Distribute_s[0].keys.ToString();
                agvTask2.workOrderCode = bus_Material_Distribute_s[0].workOrderCode;
                agvTask2.productHeaderCode = bus_Material_Distribute_s[0].productCode;
                agvTask2.startPosition = bus_Material_Distribute_s[0].startPosition;
                agvTask2.endPosition = bus_Material_Distribute_s[0].endPosition;
                agvTask2.state = (int)EnumAGVState.任务创建;
                agvTask2.createTime = DateTime.Now;
                agvTask2.createBy = base.sysWebUser;

                //添加agv上料配送任务
                base.Context.Insertable(agvTask1).AddQueue();
                base.Context.Insertable(agvTask2).AddQueue();
                base.Context.SaveQueues();


                #endregion
            });
        }


        #endregion

        /// <summary>
        /// 上料装料区域查询
        /// </summary>
        /// <param name="groupType">分组类型</param>
        /// <returns></returns>
        public Response GteChargeAreaData(string groupType)
        {
            var response = new Response();
            //初始化字典
            IniLocationVm();

            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region select

                //上料装料区域
                var dictData = base.Context.Queryable<sys_dict_data>().Where(x => x.dictType == groupType).ToList();

                var loadingAreaTypeList = dictData.Select(x => new LoadingAreaTypeVm
                {
                    key = x.dictValue,
                    value = x.dictLabel
                }).ToList();

                if (loadingAreaTypeList.Count == 0) return response.ResponseError("无装料区域数据！");
                response.Result = loadingAreaTypeList;
                return response;

                #endregion
            });
        }

        /// <summary>
        /// 叫料点查询（叫料页面）
        /// </summary>
        /// <param name="loadingAreaType">上料点区域类型</param>
        /// <returns></returns>
        public Response GteLoadingData(string feedGroupCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                IniLocationVm();
                #region select
                //叫料点位
                var locationList = SystemVariable.locationList.Where(x => x.feedGroupCode == feedGroupCode && x.zoneCode == (int)EnumLocationZoneCode.上料点).ToList();
                if (locationList.Count == 0) return response.ResponseError("无叫料点数据！");

                response.Result = locationList;
                return response;

                #endregion
            });
        }

        /// <summary>
        /// 叫料操作
        /// </summary>
        /// <param name="locationCode">料点编码</param>
        /// <param name="iScheck">是否验证时间（1分钟）</param>
        /// <returns></returns>
        public Response LoadingAsking(string locationCode, bool iScheck)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region 叫料点数据
                var locationModel = SystemVariable.locationList.Where(x => x.locationCode == locationCode).First();
                if (locationModel == null) return response.ResponseError("未查询到料点信息！");

                if (locationModel.updateTime.AddSeconds(60) < DateTime.Now && iScheck)
                    return response.ResponseError("1分钟之前已经叫料过了，是否确认用完？");

                if (locationModel.isWorkClothes == (int)EnumtIsWorkClothes.是 && string.IsNullOrEmpty(locationModel.containerCode))
                    return response.ResponseError("工装叫料必须要有料框，请检查！");

                #endregion

                #region 如果存在【使用中】的装料配送，就把状态改为【使用完】
                //找出所有小于等于【未使用】的配送，等于【使用中】的配送修改为【使用完】，小于【使用中】的配送在下面用于是否还要叫料的判断
                var distributeLoadHeadList = base.Context.Queryable<bus_material_distribute_load>()
                                                         .Where(t => t.endPosition == locationCode && t.status <= (int)EnumLoadData.使用中).ToList();

                if (distributeLoadHeadList.Any(t => t.status == (int)EnumLoadData.使用中))
                {
                    var distributeLoadTemp = distributeLoadHeadList.Where(t => t.status == (int)EnumLoadData.使用中).ToList();
                    foreach (var item in distributeLoadTemp)
                    {
                        item.status = (int)EnumLoadData.完成;
                    }
                    base.Context.Updateable(distributeLoadHeadList).AddQueue();
                }
                #endregion

                #region 如果有料框 并且不是工装，就生成回收料框的AGV任务
                if (!string.IsNullOrEmpty(locationModel.containerCode) && locationModel.isWorkClothes == (int)EnumtIsWorkClothes.否)
                {
                    //料点还有未使用的配送
                    if (distributeLoadHeadList.Any(t => t.status < (int)EnumLoadData.使用中))
                        return response.ResponseError("料点还有未使用的配送，是否确认用完？");


                    //是否存在agv回收料框任务，如果有就不再生成回收空料框任务
                    var agvTaskExist = base.Context.Queryable<bus_agv_task>()
                                                   .Where(t => t.startPosition == locationCode && t.state < (int)EnumAGVState.任务完成 && t.agvTaskType == (int)EnumAgvTaskType.Take)
                                                   .Any();

                    //有就生成agv回收料框任务
                    if (!agvTaskExist)
                    {

                        //找到当前上料点对应的多个装料点
                        var endLocation = base.Context.Queryable<base_location_rel>()
                                                      .Where(t => t.endPositionCode == locationCode).ToList()
                                                      .Select(x => x.startPositionCode).ToList();

                        //从多个装料点中选择一个能去的料点
                        var manualLoadLocation = base.Context.Queryable<base_location>()
                                                             .Where(t => t.locationType == locationModel.locationType &&
                                                                         t.zoneCode == (int)EnumLocationZoneCode.装料点 &&
                                                                         t.locationStatus == (int)EnumLocationStatus.空闲 &&
                                                                         //string.IsNullOrEmpty(t.containerCode) &&
                                                                         endLocation.Contains(t.locationCode))
                                                             .First();

                        if (manualLoadLocation == null)
                            return response.ResponseError("找不到空闲、无货的【人工装料点】！");


                        ////agv任务新增
                        //bus_agv_task agvTask = new bus_agv_task();

                        //agvTask.keys = Guid.NewGuid();
                        //agvTask.taskCode = Guid.NewGuid().ToString();
                        //agvTask.agvCode = "";
                        //agvTask.agvTaskType = (int)EnumAgvTaskType.Take;
                        //agvTask.materialFrameCode = locationModel.containerCode;
                        ////任务起点编号
                        //agvTask.startPosition = locationCode;
                        //// 任务终点编号
                        //agvTask.endPosition = manualLoadLocation.locationCode;
                        //agvTask.state = (int)EnumAGVState.任务创建;
                        //agvTask.workOrderCode = "";
                        //agvTask.productHeaderCode = "";
                        //agvTask.createTime = DateTime.Now;
                        //agvTask.createBy = base.sysWebUser.Account;

                        ////新增agv回收料框任务
                        //base.Context.Insertable(agvTask).AddQueue();

                        ////更新上料点的状态为锁定
                        //locationModel.locationStatus = (int)EnumLocationStatus.锁定;
                        //base.Context.Updateable(locationModel).UpdateColumns(t => t.locationStatus).AddQueue();

                        ////更新装料点的状态为锁定
                        //manualLoadLocation.locationStatus = (int)EnumLocationStatus.锁定;
                        //base.Context.Updateable(manualLoadLocation).UpdateColumns(t => t.locationStatus).AddQueue();
                    }
                }
                #endregion

                #region 执行数据库操作
                base.Context.SaveQueues();
                #endregion

                UpLocationVm(locationCode, EnumLocationAskingStatus.已叫料);
                return response;
            });
        }

        /// <summary>
        /// 取消叫料
        /// </summary>
        /// <returns></returns>
        public Response EscLoadingAsking(string locationCode)
        {
            var response = new Response();

            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                // 叫料点数据
                var locationModel = SystemVariable.locationList.Where(x => x.locationCode == locationCode).FirstOrDefault();
                if (locationModel == null) return response.ResponseError("未查询到料点信息！");
                if (locationModel.askingStatus >= (int)EnumLocationAskingStatus.已装料) return response.ResponseError("已装料不能取消！");

                UpLocationVm(locationCode, EnumLocationAskingStatus.未叫料);
                return response;
            });
        }

        /// <summary>
        /// 叫料点查询（装料页面）
        /// </summary>
        /// <param name="loadingAreaType">区域类型</param>
        /// <returns></returns>
        public Response GetChargeData(string loadGroupCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                IniLocationVm();
                #region get

                //上料点
                var locationList = SystemVariable.locationList.Where(x => x.loadGroupCode == loadGroupCode && x.zoneCode == (int)EnumLocationZoneCode.上料点).ToList();
                if (locationList.Count == 0) return response.ResponseError("无叫料点数据！");

                response.Result = locationList;
                return response;

                #endregion
            });
        }

        /// <summary>
        /// 叫料点对应装料点查询
        /// </summary>
        /// <param name="locationCode">料点编码</param>
        /// <returns></returns>
        public Response GetLocationRelData(string locationCode)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region get

                if (string.IsNullOrEmpty(locationCode))
                    return response;

                //查询有料框的装料点
                var locationList = base.Context.Queryable<base_location_rel, base_location>((x, y) =>
                                                       new JoinQueryInfos(JoinType.Right, x.startPositionCode == y.locationCode))
                                                .Where((x, y) => x.endPositionCode == locationCode && !string.IsNullOrEmpty(y.containerCode))
                                                .Select((x, y) => new LoadingAreaTypeVm
                                                {
                                                    value = y.locationCode,
                                                    key = y.locationName
                                                }).ToList();

                if (locationList.Count == 0) return response.ResponseError("无装料点数据或装料点无料框！");

                response.Result = locationList;
                return response;

                #endregion
            });
        }

        /// <summary>
        /// 装料操作
        /// </summary>
        /// <returns></returns>
        public Response LoadingCharge(bus_material_distribute_load model, int askingStatus)
        {
            var response = new Response();
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                #region 判断
                var locationItem = SystemVariable.locationList.Where(x => x.locationCode == model.endPosition).FirstOrDefault();
                if (locationItem == null) return response.ResponseError("");
                var distribute = base.Context.Queryable<bus_material_distribute_load>()
                                                  .Where(x => x.startPosition == model.startPosition && x.endPosition == model.endPosition && x.status == (int)EnumLoadData.已装料)
                                                  .ToList();
                if (distribute.Any()) return response.ResponseError("已经存在该点位的装料数据，请检查装料数据");


                if (string.IsNullOrEmpty(model.startPosition)) return response.ResponseError("请选择装料点！");

                if (locationItem != null && locationItem.askingStatus == (int)EnumLocationAskingStatus.已装料) return response.ResponseError("料点已经取消叫料！");
                if (askingStatus != locationItem.askingStatus) return response.ResponseError("终止！");

                //当前装料点
                var startLocationModel = base.Context.Queryable<base_location>()
                                                     .Where(x => x.locationCode == model.startPosition && x.locationStatus == (int)EnumLocationStatus.空闲)
                                                     .First();

                if (startLocationModel == null) return response.ResponseError("装料点被锁定！");
                if (string.IsNullOrEmpty(startLocationModel.containerCode)) return response.ResponseError("装料点无料框！");

                //要去的叫料点
                var endLocationModel = base.Context.Queryable<base_location>()
                                                   .Where(x => x.locationCode == model.endPosition && x.locationStatus == (int)EnumLocationStatus.空闲)
                                                   .First();

                if (endLocationModel == null) return response.ResponseError("叫料点被锁定！");

                if (string.IsNullOrEmpty(endLocationModel.containerCode) && endLocationModel.isWorkClothes == (int)EnumtIsWorkClothes.是)
                {
                    return response.ResponseError("工装装料 叫料点需要有料框，请检查！");
                }

                var agvTaskType = (int)EnumAgvTaskType.Feeding;
                //如果是工装装料就改配送类型
                if (endLocationModel.isWorkClothes == (int)EnumtIsWorkClothes.是)
                    agvTaskType = (int)EnumAgvTaskType.Displace;


                #endregion

                #region 记录装料数据

                var Code = Guid.NewGuid();
                model.keys = Code;
                model.needStation = endLocationModel.stationCode;
                model.containerCode = startLocationModel.containerCode;

                model.createBy = base.sysWebUser.Account;
                model.createTime = DateTime.Now;
                model.status = (int)EnumLoadData.已装料;

                base.Context.Insertable(model).AddQueue();

                #endregion


                #region 执行数据库操作

                //保存数据
                base.Context.SaveQueues();

                #endregion
                UpLocationVm(model.endPosition, EnumLocationAskingStatus.已装料);


                var otherEndLocation = base.Context.Queryable<base_location>().Where(x => x.stationCode == endLocationModel.stationCode && x.locationCode != endLocationModel.locationCode).First();
                var otherStartLocation = GetLocationRelData(otherEndLocation.locationCode).Result;
                var bus_Material_Distribute_Load = new bus_material_distribute_load();
                bus_Material_Distribute_Load.keys = Guid.NewGuid();
                bus_Material_Distribute_Load.needStation = otherEndLocation.stationCode;
                bus_Material_Distribute_Load.containerCode = otherEndLocation.containerCode;

                bus_Material_Distribute_Load.loadQty = model.loadQty;
                bus_Material_Distribute_Load.productCode = model.productCode;
                bus_Material_Distribute_Load.workpieceNo = model.workpieceNo;
                bus_Material_Distribute_Load.endPosition = otherEndLocation.locationCode;
                bus_Material_Distribute_Load.startPosition = otherStartLocation[0].value;
                bus_Material_Distribute_Load.createBy = base.sysWebUser.Account;
                bus_Material_Distribute_Load.createTime = DateTime.Now;
                bus_Material_Distribute_Load.status = (int)EnumLoadData.已装料;
                var distributeTemp = base.Context.Queryable<bus_material_distribute_load>()
                                                  .Where(x => x.startPosition == bus_Material_Distribute_Load.startPosition && x.endPosition == bus_Material_Distribute_Load.endPosition && x.status == (int)EnumLoadData.已装料)
                                                  .ToList();
                if (distributeTemp.Any())
                {
                    return response;
                }
                base.Context.Insertable(bus_Material_Distribute_Load).ExecuteCommand();
                UpLocationVm(bus_Material_Distribute_Load.endPosition, EnumLocationAskingStatus.已装料);

                return response;
            });
        }

        #endregion
    }
}