Demo
2024-02-04 8cb4b3e784bcbe9fbbd95dec54f41528a6bb7fe0
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
using System;
using System.Collections.Generic;
using System.Linq;
using Model.ModelDto.SysDto;
using SqlSugar;
using WMS.Entity.BllAsnEntity;
using WMS.Entity.Context;
using WMS.Entity.SysEntity;
 
namespace WMS.BLL.Logic
{
    /// <summary>
    /// 分配库位
    /// </summary>
    public class AllotLocation
    {
        /// <summary>
        /// 获取合适的库位
        /// </summary>
        /// <param name="houseNo">仓库号</param>
        /// <param name="areaList">区域集合</param>
        /// <param name="roadwayNo">巷道号(可空)</param>
        /// <returns></returns>
        public SysStorageLocat GetSuiTableLocate(string houseNo, List<string> areaList,string roadwayNo = "")
        {
            try
            {
                var db = DataContext.Db;
                /* 1.先判断仓库(立库或者平库)
                 * 2.如果是立库 再判断是否指定巷道号
                 */
                var house = db.Queryable<SysWareHouse>().First(m => m.WareHouseNo == houseNo);
                if (house == null)
                {
                    throw new Exception($"未查询到{houseNo}仓库信息");
                }
 
                var roadList = db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo) )
                    .GroupBy(m=>m.RoadwayNo).Select(m=>m.RoadwayNo).ToList();
 
                //数据字典(获取字典中仓库类型)
                var dic = db.Queryable<SysDictionary>().First(m => m.Id.ToString() == house.Type);
                switch (dic.DictName)
                {
                    //是否指定巷道
                    case "立体库" when !string.IsNullOrWhiteSpace(roadwayNo):
                        {
                            var roadwayList = new List<SysStorageRoadway>();
                            var roadway = db.Queryable<SysStorageRoadway>().First(m => m.RoadwayNo == roadwayNo);
                            if (roadway == null)
                            {
                                throw new Exception($"未查询到{roadwayNo}巷道信息");
                            }
 
                            if (!roadList.Contains(roadwayNo))
                            {
                                throw new Exception("当前物料存放区域未在指定巷道中");
                            }
                            if (roadway.Status == "1")
                            {
                                throw new Exception($"{roadwayNo}巷道已停用");
                            }
 
                            //查询该巷道并且标志为正常的的储位
                            roadwayList.Add(roadway);
                            var locate = GetLocateByRoadways(roadwayList,areaList);
                            if (locate == null)
                            {
                                throw new Exception($"{roadwayNo}巷道没有合适的空储位");
                            }
                            return locate;
                        }
                    //立体库没有指定巷道(循环巷道根据优先级分配)
                    case "立体库" when string.IsNullOrWhiteSpace(roadwayNo):
                        {
                            var roadwayList = db.Queryable<SysStorageRoadway>().Where(m => m.WareHouseNo == houseNo && m.Status == "0" && roadList.Contains(m.RoadwayNo)).OrderBy(m => new { m.Priority, m.RoadwayNo }).ToList();
 
                            var locate = GetLocateByRoadways(roadwayList,areaList);
                            if (locate == null)
                            {
                                throw new Exception($"{houseNo}仓库已启用的巷道中没有合适的空储位");
                            }
                            return locate;
                        }
                    //平库  该代码块目前是错误的逻辑、后期有库位信息了改
                    case "平库":
                        {
                            //查询该巷道并且标志为正常的的储位
                            var locates = db.Queryable<SysStorageLocat>()
                                .Where(m => m.WareHouseNo == houseNo && m.Flag == "0" && m.Status == "0")
                                .OrderBy(m => new { m.Layer, m.Column, m.Row }).ToList();
                            return locates.First();
                        }
                    //没有仓库类型
                    default:
                        throw new Exception($"未查询到{houseNo}仓库类型信息,无法为其分配储位");
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
 
        /// <summary>
        /// 获取合适空储位信息(根据巷道集合判断)
        /// </summary>
        /// <param name="roadways">巷道集合</param>
        /// <param name="areaList">区域集合</param>
        /// <returns></returns>
        private SysStorageLocat GetLocateByRoadways(List<SysStorageRoadway> roadways,List<string> areaList)
        {
            try
            {
                var db = DataContext.Db;
                #region 入库分配规则
 
                var funSet = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位分配上下" && m.IsEnable == "NO");
                var funSet2 = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位分配左右" && m.IsEnable == "NO");
                var funSet3 = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位跳巷分配" && m.IsEnable == "NO");
 
                var topOrBom = 1; // 储位分配上下 0 上 1 下
                var leftOrRight = 0; // 储位分配上下 0 左 1 右
                var laneAllot = 0; //储位跳巷分配 0:跳着分配(一个一个分配)1:巷道按照优先级分配,同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                if (funSet != null)
                {
                    switch (funSet.SetValue)
                    {
                        case "Top":
                            topOrBom = 0;//立库储位分配由上往下分配
                            break;
                        case "Bottom":
                            topOrBom = 1;//立库储位分配由下往上分配
                            break;
                        default:
                            topOrBom = 1;// 默认:由下往上
                            break;
                    }
                }
                if (funSet2 != null)
                {
                    switch (funSet2.SetValue)
                    {
                        case "Left":
                            leftOrRight = 0;//立库储位分配由上往下分配
                            break;
                        case "Right":
                            leftOrRight = 1;//立库储位分配由下往上分配
                            break;
                        default:
                            leftOrRight = 1;// 默认:由下往上
                            break;
                    }
                }
                if (funSet3 != null)
                {
                    switch (funSet3.SetValue)
                    {
                        case "JumpLaneAllot":
                            laneAllot = 0;//立库储位分配 巷道同优先级巷道跳着分配(一个一个分配)
                            break;
                        case "RankLaneAllot":
                            laneAllot = 1;//立库储位分配 巷道按照优先级分配,同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                            break;
                        default:
                            laneAllot = 1;// 默认 跳着分配
                            break;
                    }
                }
                #endregion
 
                #region MyRegion
 
                SysStorageLocat locate = null; // 储位信息
                //SysStorageLocat log = db.Ado.SqlQuerySingle<SysStorageLocat>("select * from SysStorageLocat where LocatNo = (select Top(1) LocatNo from BllPalletBind order by CreateTime desc)"); //巷道最后一次使用记录
                SysRoadwayUseLog log= db.Ado.SqlQuerySingle<SysRoadwayUseLog>("select Top(1) * from SysRoadwayUseLog where IsDel=0 order by CreateTime desc"); //巷道最后一次使用记录
 
                if (laneAllot == 0)//跳巷道平均分配
                {
                    //如果同级巷道有多条则查上次位置日志
                    if (roadways.Count > 1)
                    {
                        log = db.Queryable<SysRoadwayUseLog>().OrderByDescending(l => l.Id).First();
                    }
                    //取各巷道所有排第一个合适位
                    foreach (var l in roadways)
                    {
                        //如果上次是当前巷道则跳出
                        if (log != null && l.RoadwayNo == log.RoadwayNo)
                        {
                            continue;
                        }
                        //取当前巷最优位置
                        locate = GetLocateByRoadway(l.RoadwayNo, topOrBom, leftOrRight, areaList);
                        //当前巷有位置则退出
                        if (locate != null)
                        {
                            break;
                        }
                    }
                    //如果跳巷道并且未找到合适空储位,则跳到最后一次使用的巷道查询
                    if (locate == null)
                    {
                        if (log != null)
                        {
                            locate = GetLocateByRoadway(log.RoadwayNo, topOrBom, leftOrRight, areaList);
                        }
                    }
                }
                else//按照巷道优先级分配
                {
                    foreach (var item in roadways)
                    {
                        locate = GetLocateByRoadway(item.RoadwayNo, topOrBom, leftOrRight, areaList);
                    }
                }
 
                #endregion
 
                return locate;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
 
        /// <summary>
        /// 取当前巷最优位置
        /// </summary>
        /// <param name="roadwayNo">巷道号</param>
        /// <param name="topOrBom">储位分配上下 0 上 1 下</param>
        /// <param name="leftOrRight">储位分配上下 0 左 1 右</param>
        /// <param name="areaList">区域集合</param>
        /// <returns></returns>
        private SysStorageLocat GetLocateByRoadway(string roadwayNo, int topOrBom, int leftOrRight,List<string> areaList)
        {
            var db = DataContext.Db;
            var str = "''";
            //查询该巷道并且标志为正常的的储位
            SysStorageLocat data;
            
            foreach (var area in areaList)
            {
                var sql = $@"select * from SysStorageLocat where IsDel = 0 and Flag = 0 and [Status] = 0 and RoadwayNo = '{roadwayNo}' and AreaNo = '{area}' and LocatNo not in({str}) ";
                sql += "order by ";
                sql += topOrBom == 0 ? "Layer desc, " : "Layer, ";
                sql += leftOrRight == 0 ? "[Column], " : "[Column] desc, ";
                sql += " Row desc; ";
 
 
                var locateList = db.Ado.SqlQuery<SysStorageLocat>(sql);
                data = locateList.FirstOrDefault();
                if (data != null)
                {
                    return data;
                }
            }
 
            return null;
 
           
 
        }
    }
}