海波 张
2025-05-30 62c5a7fad29fa380874f6cf81bb4074ce5f488e7
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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
using HH.WCS.Mobox3.ZhongCeJinTan.dispatch;
using HH.WCS.ZhongCeJinTan.api;
using HH.WCS.ZhongCeJinTan.dispatch;
using HH.WCS.ZhongCeJinTan.process;
using HH.WCS.ZhongCeJinTan.util;
using HH.WCS.ZhongCeJinTan.wms;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Services.Description;
using static HH.WCS.ZhongCeJinTan.api.ApiModel;
 
namespace HH.WCS.ZhongCeJinTan.core
{
    /// <summary>
    /// 定时轮询任务
    /// </summary>
    internal class Monitor
    {
        /// <summary>
        /// 根据作业创建对应任务
        /// </summary>
        public static void CreateTask()
        {
            var db = new SqlHelper<object>().GetInstance();
 
            // 获取所有等待中的作业
            var operations = db.Queryable<WmsWork>().Where(p => p.N_B_STATE == 0).ToList();
            foreach (var operation in operations)
            {
                TaskHelper.CreateTask(operation);
            }
        }
 
 
        /// <summary>
        /// 根据任务状态更新作业状态
        /// </summary>
        public static void UpdateWorkState() {
 
            var db = new SqlHelper<object>().GetInstance();
 
            var operations = db.Queryable<WmsWork>().Where(p => p.N_B_STATE == 1).ToList();
 
            foreach (var operation in operations)
            {
                // 判断该任务是否全部完成
                var tasks = db.Queryable<WMSTask>().Where(p => p.S_OP_CODE == operation.S_CODE).ToList();
 
 
 
                if (tasks.Count > 1 && tasks.Count(p => p.N_B_STATE == 3) == 1)
                {
                    operation.S_B_STATE = "完成一半";
                    operation.T_MODIFY = DateTime.Now;
                    db.Updateable(operation).UpdateColumns(it => new { it.S_B_STATE, it.T_MODIFY }).ExecuteCommand();
                }
 
                if (tasks.Count == tasks.Count(p => p.N_B_STATE == 3))
                {
                    operation.N_B_STATE = 2;
                    operation.S_B_STATE = "完成";
                    operation.T_MODIFY = DateTime.Now;
                    operation.T_END_TIME = DateTime.Now;
                    db.Updateable(operation).UpdateColumns(it => new { it.N_B_STATE, it.S_B_STATE, it.T_MODIFY, it.T_END_TIME }).ExecuteCommand();
 
                }
                else if (tasks.Count(p => p.N_B_STATE == 5) > 0)
                {
                    operation.N_B_STATE = 7;
                    operation.S_B_STATE = "取消";
                    operation.T_MODIFY = DateTime.Now;
                    operation.T_END_TIME = DateTime.Now;
 
                    db.Updateable(operation).UpdateColumns(it => new { it.N_B_STATE, it.S_B_STATE, it.T_MODIFY, it.T_END_TIME }).ExecuteCommand();
                }
            }
        }
 
        //出库任务 动作码有1无3 每隔一段时间提高一次优先级
 
        public static void UpdateOutTaskPriority()
        {
            var db = new SqlHelper<object>().GetInstance();
            var st = Settings.outMinutePriority;
            var list = TaskHelper.GetWcsTaskListByState("执行", "agv", "出库");
 
            foreach (var item in list)
            {
                var action = db.Queryable<WmsTaskAction>().Where(p => p.S_TASK_CODE==item.S_CODE && p.N_ACTION_CODE == 1).First();
                if (action != null)
                {
                    var action3 = db.Queryable<WmsTaskAction>().Where(p => p.S_TASK_CODE == item.S_CODE && p.N_ACTION_CODE == 3).First();
                    if (action3 == null)
                    {
                        if (DateTime.Now.Subtract(action.T_CREATE).TotalMinutes > st.Minute)
                        {
                            item.N_PRIORITY += st.Priority;
                            db.Updateable(item).UpdateColumns(it => new { it.N_PRIORITY }).ExecuteCommand();
                            NDCApi.ChangeOrderPri(item.S_CODE, item.N_PRIORITY);
 
                        }
                    }
                }
            }
            int sp = st.Minute * 60000;
            Thread.Sleep(sp);
        }
 
 
 
        private static object locker = new object();
        /// <summary>
        /// 自动出库空托
        /// </summary>
        public static void ktAuto() {
            var db = new SqlHelper<object>().GetInstance();
 
            try
            {
                lock (locker)
                {
                    var ktTaskList = db.Queryable<MesKtTask>().Where(a => a.Status == "N").OrderBy(b => b.CreateDate).ToList();
                    foreach (var kt in ktTaskList)
                    {
                        LogHelper.Info($"空托出库缓存信息" + JsonConvert.SerializeObject(kt), "空托出库");
 
                        var tm = DateTime.Now.Subtract(kt.CreateDate).TotalMinutes;
                        LogHelper.Info($"空托{kt.task_no}出库缓存时间间隔信息:{tm}", "空托出库");
                        if (tm < 1)
                        {
                            continue;
                        }
 
                        var workFlow = TaskHelper.selectWorkFlowByType(kt.BUSI_TYPE, kt.TOOLS_TPYE);
 
 
                        if (workFlow == null)
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败,流程编号:{kt.BUSI_TYPE},工装类型{kt.TOOLS_TPYE},没找到对应作业流程", "空托出库");
                            continue;
                        }
                        else
                        {
                            LogHelper.Info($"空托{kt.task_no}出库作业流程信息" + JsonConvert.SerializeObject(workFlow), "空托出库");
                        }
 
 
 
                        //出库任务
 
                        //接驳位
                        var connection = "";
 
                        //接驳位库区
                        var connectionArea = "";
 
 
                        //查找给定终点
                        var end = LocationHelper.GetLoc(kt.Location_To);
                        LogHelper.Info($"空托{kt.task_no}出库任务下发终点信息" + JsonConvert.SerializeObject(end), "空托出库");
 
 
                        if (end == null)
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败,终点:{kt.Location_To},没找到", "空托出库");
                            continue;
                        }
 
 
 
 
 
                        //查找起点
                        List<Location> strrtList;
 
                        Location start = null;
 
 
                        if (!string.IsNullOrEmpty(workFlow.ZONECODE))
                        {
                            strrtList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
                        }
                        else
                        {
                            strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
                        }
 
 
 
 
                        //寻找立库区空托
                        start = LocationHelper.FindStartcolByLoclistAndcntr(strrtList, workFlow.STARTAREA);
 
 
                        LogHelper.Info($"空托{kt.task_no}出库任务下发起点信息" + JsonConvert.SerializeObject(start), "空托出库");
 
                        if (start == null )
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败,起点库区{workFlow.STARTAREA},没找到起点", "空托出库");
                            continue;
                        }
 
                       
 
 
                        //获取托盘码
                        var cntrCode = LocationHelper.GetLocCntrCode(start.S_CODE);
 
                        if (workFlow.SENDWCS == "Y")
                        {
 
                            //正式代码,调用接口寻找可用接驳位
                            var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
 
                            var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
                            foreach (var item in balanceConnectionList)
                            {
                                if (item.loc.N_CURRENT_NUM < 2)
                                {
                                    connection = item.loc.S_CODE;
                                    connectionArea = item.loc.S_AREA_Name;
                                    LogHelper.Info($"空托{kt.task_no}出库任务下发寻找到可用接驳位{connection}", "空托出库");
                                    break;
                                }
                            }
 
                            if (connection == "")
                            {
                                LogHelper.Info($"空托{kt.task_no}出库任务下发寻找接驳位失败", "Mes任空托出库务下发");
                                continue;
                            }
                        }
 
 
                        var startTask = TaskHelper.GetTaskByStartLoc(start.S_CODE);
                        if (startTask != null)
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败,起点{start.S_CODE}有执行中任务{startTask.S_CODE}", "空托出库");
                            continue;
                        }
 
                        //起点终点查找成功,创建作业
 
                        var taskType = int.Parse(workFlow.FLOWCODE);
 
                        var operation = new WmsWork
                        {
                            // 作业号
                            S_CODE = kt.task_no,
                            // 作业类型
                            N_TYPE = taskType,
                            // 作业类型
                            S_TYPE = workFlow.FLOWNAME,
                            // 起点货位
                            S_START_LOC = start.S_CODE,
                            // 起点库区编码
                            S_START_AREA = start.S_AREA_CODE,
                            //接驳位
                            CONNECTION = connection,
                            // 终点货位
                            S_END_LOC = end.S_CODE,
                            // 终点库区编码
                            S_END_AREA = end.S_AREA_CODE,
                            // 容器编码
                            S_CNTR_CODE = cntrCode,
                            // 作业定义名称
                            S_OP_DEF_NAME = workFlow.FLOWNAME,
                            //优先级
                            N_PRIORITY = kt.Priority,
                            //工装类型
                            TOOLSTYPE = kt.TOOLS_TPYE,
                            //起点库区名称
                            S_START_AREA_NAME = start.S_AREA_Name,
                            //起点库区名称
                            S_END_AREA_NAME = end.S_AREA_Name,
                            //起点库区名称
                            CONNECTION_AREA = connectionArea
                        };
 
                        //创建作业
                        if (WMSHelper.CreateWmsWork(operation) && TaskHelper.ChangeMesKtTask(kt))
                        {
 
                            LogHelper.Info($"空托{kt.task_no}出库作业创建成功{operation.S_CODE}", "空托出库");
                        }
                        else
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发创建作业失败", "空托出库");
                            continue;
                        }
 
                    }
                }
            }
            catch (Exception ex)
            {
 
                LogHelper.Info($"空托出库异常信息" + ex.Message, "空托出库");
            }
        }
    }
}