1
pulg
2025-06-26 06a54c7ac91fed8ece7dd6bedf724539af3c38ff
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
using HH.WCS.Hexafluo.util;
using HH.WCS.Hexafluo.wms;
using HH.WCS.SJML.Bll;
using HH.WCS.SJML.Dto;
using HH.WCS.SJML.Entitys;
using HH.WCS.ZCQTJ.Dto;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace HH.WCS.Hexafluo.core
{
    /// <summary>
    /// 定时轮询任务
    /// </summary>
    public class MesKtTask
    {
        private static object locko9 = new object();
        /// <summary>
        /// 检查是否有自管任务,自动子任务
        /// </summary>
        public static void MesKtTaskIssued()
        {
            try
            {
                lock (locko9)
                {
                    var chi = new SqlHelper<object>().GetInstance();
                    var newDb2 = chi.CopyNew();
                    DateTime currentTime = DateTime.Now;
                    TimeSpan fiveMinutes = TimeSpan.FromMinutes(5);
                    DateTime newTime = currentTime - fiveMinutes;
                    var transportTask1 = newDb2.Queryable<MesKtTaskDto>().Where(e => e.NeedTrig == "Y").ToList();
                    if (transportTask1.Any())
                    {
 
                        //超时的全部处理
                        //foreach (var item in transportTask1.ToArray())
                        //{
                        //    if (item.T_CREATE < currentTime.AddDays(-1))
                        //    {
                        //        try
                        //        {
                        //            newDb2.BeginTran();
                        //            var I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                        //            {
                        //                NeedTrig = "N"
                        //            }).Where(x => x.S_ID == item.S_ID).ExecuteCommand();
                        //            LogHelper.DanInfo("任务下发", $"空托缓存任务{item.task_no} 超时1天没处理 系统自动处理");
                        //            newDb2.CommitTran();
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            newDb2.RollbackTran();
                        //        }
                        //    }
                        //}
 
 
                        var transportTask = transportTask1.FindAll(e => e.Task_State == "智能空桶").ToList();
                        if (transportTask.Any())
                        {
                            transportTask = transportTask.OrderBy(e => e.T_CREATE).ToList();
                            foreach (var task in transportTask)
                            {
                                var gg = task.CreateDate;
                                DateTime cfff = gg + fiveMinutes;
                                if (currentTime > cfff)
                                {
                                    BLLCreator.Create<ZCBLL>().MesKtTaskIssued(transportTask);
                                }
                            }
                        }
                        var transportTask2 = transportTask1.FindAll(e => e.Task_State == "接驳位至线边点对点").ToList();
                        if (transportTask2.Any())
                        {
                            var transportTask4 = transportTask2.GroupBy(e => e.Location_To).Select(d => d.First()).ToList();
                            transportTask4 = transportTask4.OrderBy(e => e.T_CREATE).ToList();
                            foreach (var sendTaskEntity in transportTask4)
                            {
                                LogHelper.DanInfo("MES", "接驳位至线边点对点 开始执行 任务号:" + JsonConvert.SerializeObject(sendTaskEntity.task_no));
                                var Kklock = newDb2.Queryable<FunctionEntitys>().Where(e => e.Autoindex == "空托自动出库到接驳位")?.First();
                                if (Kklock != null && Kklock.TransportLock == "Y")
                                {
                                    var Stabit = newDb2.Queryable<JbTrayNumberEntitys>().Where(e => e.S_IS_USE == "N").ToList();
                                    //去除有任务的托盘
                                    if (Stabit.Count() > 0)
                                    {
                                        var State = new List<string> { "完成", "取消" };
                                        var tasks = newDb2.Queryable<WMSTask>().Where(e => Stabit.Select(c => c.S_CNTR_CODE).ToList().Contains(e.S_CNTRS) && !State.Contains(e.S_B_STATE) && e.S_NOTE == "agv任务").ToList();
                                        if (tasks.Count() > 0)
                                        {
                                            foreach (var item in tasks)
                                            {
                                                Stabit.RemoveAll(e => e.S_CNTR_CODE == item.S_CNTRS);
                                            }
                                        }
                                    }
                                    if (Stabit.Count > 0)
                                    {
                                        var fiff = Stabit.FirstOrDefault();
                                        Stabit = Stabit.OrderBy(e => e.T_CREATE).ToList();
                                        //走点对点
                                        List<OutWorkAreaEntity> outWorkAreas = new List<OutWorkAreaEntity>
                                {
                               new OutWorkAreaEntity() {
                        taskNo=sendTaskEntity.task_no,
                        startBit = fiff.S_LOC_CODE,
                        endBit = sendTaskEntity.Location_To,
                        priority = sendTaskEntity.Priority,
                        trayCode= fiff.S_CNTR_CODE,
                        TaskOrderType = "MES点对点",
                        NoAssist = "Y",
                        S_TransAgv = "Y"
                               }
                            };
                                        var transport = newDb2.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex == "点对点任务管控")?.First();
                                        List<string> ListString = new List<string>();
                                        if (transport != null)
                                        {
                                            ListString = JsonConvert.DeserializeObject<List<string>>(transport.TypeJson);
                                        }
                                        if (ListString.Contains(sendTaskEntity.Location_To))
                                        {
                                            List<string> state = new List<string> { "完成", "取消" };
                                            var tasks = newDb2.Queryable<WMSTask>().Where(e => e.S_END_LOC == sendTaskEntity.Location_To && !(state.Contains(e.S_B_STATE))).ToList();
                                            if (tasks.Count > 0)
                                            {
                                                LogHelper.DanInfo("MES", "终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务 任务" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                                throw new Exception("终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务!" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                            }
                                        }
                                        var resulte = BLLCreator.CreateSingleton<OutWorkAreaBll>().OutWorkArea(outWorkAreas);
                                        if (resulte.Success)
                                        {
                                            try
                                            {
                                                newDb2.BeginTran();
                                                var I = newDb2.Updateable<JbTrayNumberEntitys>().SetColumns(it => new JbTrayNumberEntitys()
                                                {
                                                    S_IS_USE = "Y"
                                                }).Where(x => x.S_ID == fiff.S_ID).ExecuteCommand();
                                                I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                                                {
                                                    NeedTrig = "N"
                                                }).Where(x => x.S_ID == sendTaskEntity.S_ID).ExecuteCommand();
 
                                                newDb2.CommitTran();
                                            }
                                            catch (Exception ex)
                                            {
                                                LogHelper.DanInfo("MES", "点对点任务管控" + ex.Message);
                                                newDb2.RollbackTran();
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        //胎圈出库缓存
                        var transportTask3 = transportTask1.FindAll(e => e.Task_State == "胎圈空托出库缓存").ToList();
                        if (transportTask3.Any())
                        {
                            var transportTask4 = transportTask3.GroupBy(e => e.Location_To).Select(d => d.First()).ToList();
                            foreach (var receuveTask in transportTask4)
                            {
                                MesTaskDto req = new MesTaskDto()
                                {
                                    task_no = receuveTask.task_no,
                                    Task_type = receuveTask.Task_type,
                                    TurnCardNum = receuveTask.TurnCardNum,
                                    PROD_NO = receuveTask.PROD_NO,
                                    PROD_TECH = receuveTask.PROD_TECH,
                                    PROD_SPEC = receuveTask.PROD_SPEC,
                                    PROD_BOM = receuveTask.PROD_BOM,
                                    PROD_Feature = receuveTask.PROD_Feature,
                                    TOOLS_NO = receuveTask.TOOLS_NO,
                                    ST_AMOUNT = receuveTask.ST_AMOUNT,
                                    CURRENT_AMOUNT = receuveTask.CURRENT_AMOUNT,
                                    Location_From = receuveTask.Location_From,
                                    Location_To = receuveTask.Location_To,
                                    PRODUCE_TIME = receuveTask.PRODUCE_TIME,
                                    SHELF_LIFE_TIME = receuveTask.SHELF_LIFE_TIME,
                                    EXPIRED_TIME = receuveTask.EXPIRED_TIME,
                                    SHELF_REP = receuveTask.SHELF_REP,
                                    EXPIRED_REP = receuveTask.EXPIRED_REP,
                                    CHECK_CODE = receuveTask.CHECK_CODE,
                                    CHECK_INFO = receuveTask.CHECK_INFO,
                                    Priority = receuveTask.Priority,
                                    Data_status = receuveTask.Data_status,
                                    NeedTrig = "Y",
                                    CreateDate = DateTime.Now,
                                    standardWeight = receuveTask.standardWeight,
                                    BUSI_TYPE = receuveTask.BUSI_TYPE,
                                    TOOLS_TPYE = receuveTask.TOOLS_TPYE,
                                    Givewayto = receuveTask.Task_PDA,
                                    applyProdSpecList = receuveTask.applyProdSpecList,
                                    frequency = 0
                                };
                                var resulte = BLLCreator.Create<ZCBLL>().ExecTransferTask(req);
                                if (resulte.Success)
                                {
                                    try
                                    {
                                        newDb2.BeginTran();
                                        var I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                                        {
                                            NeedTrig = "N"
                                        }).Where(x => x.S_ID == receuveTask.S_ID).ExecuteCommand();
                                        newDb2.CommitTran();
                                    }
                                    catch (Exception ex)
                                    {
                                        LogHelper.DanInfo("MES", "点对点任务管控" + ex.Message);
                                        newDb2.RollbackTran();
                                    }
                                }
                            }
                        }
 
                    }
                }
            }
            catch (System.Exception ex)
            {
                LogHelper.DanInfo("MES", ex.Message);
            }
        }
    }
}