--[[
|
编码:
|
名称: 预分配料箱算法
|
作者：HAN
|
日期：2024-8-5
|
|
来源：巨星料箱库
|
|
算法标识 CBG -- Compatible Bin Grid 专指WMS中与物料存储适配的料格系统
|
料格可以装载货品数量通过体积和料格体积或，重量和料箱的最大载重进行计算得到
|
算法特点：
|
-- 尽量有大一些的料格装更多的货品，减少入库任务条数（提高入库操作效率）
|
|
函数：
|
|
-- Release_Pre_Alloc_Cntr 释放预分配料箱
|
-- Pre_Alloc_Cntr_CBG 预分配料箱算法
|
|
|
功能:
|
空料箱呼出算法，货物可以适配多种类型料箱，根据入库的总体积进行计算
|
|
更改记录:
|
V2.0 HAN 20241220 对升格进行提前处理，加了一个专门的升格链表
|
|
-------------------------------------------------------------------------------------------------------------------------
|
几个主要数据类型定义
|
1) item_list -- 入库货品清单
|
{
|
item_code -- SKU编码
|
volume -- 单个体积
|
weight -- 单个重量
|
item_name,
|
cell_type:"A/B/C/D/E" -- 货品最小适配料格类型
|
qty -- 计划入库数量
|
alloc_qty -- 已经安排料箱的货品数量
|
cntr_cell_list -- 已经配货的料格 { cntr_code:"", cell_no:"", item_code:"xx", item_name:"", entry_batch_no:"SN01",
|
weight, volume, qty:10 ,sum_volume:10, sum_weigt:10}
|
|
empty_cell_type -- Q 数量的空料格类型 辅助用，表示本次整体呼出的空料箱类型
|
Q -- 需要呼出空料格数量
|
}
|
2) supplement_cntr_list -- 补料呼出的料箱
|
{
|
cntr_code:"xxx"
|
cell_type:"A/B/C/D/E"
|
cntr_good_weight: 100 -- 容器中货品重量
|
full: false/true,
|
empty_cell_num: 0,
|
empty_cell_list:[{"cell_no"，item_code, item_name}] -- 呼出的补料料箱中的空料格 cell 属性同下面的 cell_list
|
cell_list:{
|
{ cntr_code:"", cell_no:"", item_code:"xx", item_name:"", entry_batch_no:"SN01", weight, volume, qty:10 ,sum_volume:10, sum_weigt:10}
|
}
|
}
|
3） out_cntr_list -- 呼出的空料箱( 和 supplement_cntr_list 是一样的)
|
{
|
cntr_code = "XXX",
|
cell_type = "A/B/C/D/E",
|
cntr_good_weight = 0,
|
full = false,
|
empty_cell_num = 0,
|
empty_cell_list:[{"cell_no"，item_code, item_name}]
|
cell_list:{ -- 分配货品的料格
|
{ cntr_code:"", cell_no:"", item_code:"xx", item_name:"", entry_batch_no:"SN01", weight, volume, qty:10 ,sum_volume:10, sum_weigt:10}
|
}
|
}
|
变更记录:
|
V2.0 HAN 20241030
|
-- 取消给容器加锁
|
V3.0 HAN 20241104
|
-- 升格这里的处理有改进
|
V4.0 HAN 20241108
|
-- 补料呼出料箱和空料箱进行检查，相同料箱号的合并
|
]]
|
|
prj_base = require( "prj_base" )
|
wms_cntr = require( "wms_container" )
|
|
-- wms_pac_dmg 是制定料箱类型的精准预分配方法，属于 pre-alloction container 的一种，先require
|
local wms_pac = require( "wms_pac_dmg" )
|
|
-- 释放预分配的料格数量
|
function wms_pac.Release_Pre_Alloc_Cntr( strLuaDEID, bs_type, bs_no )
|
local nRet, strRetInfo
|
local data_objs
|
|
if lua.StrIsEmpty( bs_type ) then
|
return 1, "Release_Pre_Alloc_Cntr 函数中 bs_type 必须有值"
|
end
|
if lua.StrIsEmpty( bs_no ) then
|
return 1, "Release_Pre_Alloc_Cntr 函数中 bs_no 必须有值"
|
end
|
-- 释放预分配的料格数量
|
local strCondition = "S_BS_TYPE = '"..bs_type.."' AND S_BS_NO = '"..bs_no.."'"
|
nRet, data_objs = m3.QueryDataObject(strLuaDEID, "Pre_Alloc_CNTR_Detail", strCondition, "S_CNTR_CODE" )
|
if (nRet ~= 0) then
|
lua.Stop( strLuaDEID, "QueryDataObject失败!"..data_objs )
|
return
|
end
|
|
if ( data_objs ~= '' ) then
|
local n, m
|
local pac_detail
|
local cntr_list = {}
|
local find
|
for n = 1, #data_objs do
|
pac_detail = m3.KeyValueAttrsToObjAttr(data_objs[n].attrs)
|
find = false
|
local cell = { cell_no = pac_detail.S_CELL_NO }
|
for m = 1, #cntr_list do
|
if ( cntr_list[m].cntr_code == pac_detail.S_CNTR_CODE ) then
|
find = true
|
table.insert( cntr_list[m].cell_list, cell )
|
break
|
end
|
end
|
if ( find == false ) then
|
local cntr = {
|
cntr_code = pac_detail.S_CNTR_CODE,
|
cell_list = {}
|
}
|
table.insert( cntr.cell_list, cell )
|
table.insert( cntr_list, cntr )
|
end
|
end
|
|
local cell_num
|
for m = 1, #cntr_list do
|
strCondition = "S_CODE = '"..cntr_list[m].cntr_code.."'"
|
cell_num = #cntr_list[m].cell_list
|
nRet, strRetInfo = mobox.decDataObjAccQty( strLuaDEID, "Container", strCondition, "N_ALLOC_CELL_NUM", cell_num )
|
if ( nRet ~= 0 ) then
|
lua.Stop( strLuaDEID, "decDataObjAccQty(Container)失败! "..strRetInfo )
|
return
|
end
|
end
|
|
-- 把料格状态=3（预约）的设置为 0
|
strUpdateSql = "N_EMPTY_FULL = 0, S_ALLOC_OP_CODE = ''"
|
strCondition = "N_EMPTY_FULL = 3 AND S_ALLOC_OP_CODE = '"..bs_no.."'"
|
nRet, strRetInfo = mobox.updateDataAttrByCondition( strLuaDEID, "Container_Cell", strCondition, strUpdateSql )
|
if ( nRet ~= 0 ) then
|
lua.Stop( strLuaDEID, "更新【Container_Cell】状态信息失败!"..strRetInfo )
|
return
|
end
|
end
|
return 0
|
end
|
|
-- item list 排序函数 把体积大的排前面
|
local function item_sort_volume( item_a, item_b )
|
return item_a.volume > item_b.volume
|
end
|
|
-- 根据货品体积计算需要多少个 料格， 料格体积 box_volume
|
-- item_volume 货品单个体积
|
-- 返回参数1 -- 料格数量 2 -- 可装货品数量 3 -- 错误标记非0为越界
|
local function calculate_box_count_by_volume(box_volume, item_volume, qty )
|
|
if ( 0 == item_volume or 0 == box_volume ) then return 0,0 end
|
local items_per_box = math.floor( box_volume / item_volume )
|
|
-- 单品就超体积，这种情况一般是数据错误
|
if ( items_per_box == 0 ) then return 0,0 end
|
|
local num_boxes = math.floor( qty / items_per_box)
|
return num_boxes, num_boxes*items_per_box
|
end
|
|
-- 返回需要多少个料格，及装载的货品数量
|
-- 返回参数1 -- 料格数量 2 -- 可装货品数量 3 -- 错误标记非0为越界
|
local function calculate_box_count_by_weight( pac_cfg, cell_type_index, item_weight, qty )
|
if ( 0 == item_weight ) then return 0,0 end
|
local items_per_box = math.floor( pac_cfg.ctd.load_capacity / item_weight )
|
|
-- 单品就超重，这种情况一般是数据错误
|
if ( items_per_box == 0 ) then return 0,0 end
|
|
local num_boxes = math.floor( qty / items_per_box)
|
return num_boxes*pac_cfg.ctd.grid_box_def[cell_type_index].box_num, items_per_box*num_boxes
|
end
|
|
-- 计算出item中的 Qa/Qb/Qc/Qd/Qe 数量
|
-- grid_def {cell_type="A",box_num = 1, volume = 72000 }
|
local function generate_item_needemptycell_qty( strLuaDEID, ctd, item_list, grid_def )
|
local nRet, strRetInfo, n
|
|
local qty, total_volume, volumeX, pk_qty, qX
|
local cell_volume = grid_def.volume or 0
|
local box_num = grid_def.box_num or 0
|
if box_num <= 0 then
|
return 1,"料箱类型定义中料格定义不合规! box_num 必须大于0"
|
end
|
|
local cntr_max_weight = ctd.load_capacity or 0
|
local cell_weight = cntr_max_weight/grid_def.box_num
|
local cell_type = grid_def.cell_type
|
local sum_Q = 0
|
local loading_limit
|
|
if ( cell_volume == nil or cell_volume <= 0 ) then
|
return 1,"料箱类型定义中料格定义不合规! 料格体积必须大于0"
|
end
|
|
for n = 1, #item_list do
|
-- MDY BY HAN 20241211 如果当前进行匹配的料格类型 大于 货品的最小适配料格（A,B,C,D,E），不做判断
|
if ( cell_type > item_list[n].S_CELL_TYPE ) then goto continue end
|
|
item_list[n].empty_cell_type = cell_type -- 当前呼出的料箱规格
|
item_list[n].Q = 0 -- cell_type 类型的料格数量
|
|
if (item_list[n].qty > item_list[n].alloc_qty ) then
|
|
qty = item_list[n].qty - item_list[n].alloc_qty
|
if ( lua.equation( qty, 0 ) ) then goto continue end
|
|
-- 根据容器定义中的计数方法进行判断 Mixed 为混合模式，会从根据情况从体积计算变成重量计算
|
if ctd.count_method == "Mixed" or ctd.count_method == "Volume" then
|
-- *** 注意这里还留下一个问题，就是重量是否会超，可能要对 calculate_box_count_by_volume 优化一下
|
total_volume = qty*item_list[n].volume
|
pk_qty = 0
|
if ( total_volume > cell_volume ) then
|
item_list[n].Q, pk_qty = calculate_box_count_by_volume( cell_volume, item_list[n].volume, qty )
|
volumeX = (item_list[n].volume)*(qty-pk_qty)
|
else
|
volumeX = total_volume
|
end
|
|
-- 如果整除后还有余数, 判断这些体积是否增加一个料格
|
if ( volumeX > 0 ) then
|
-- 如果料格在料箱中最小的料格说明不能再降格了
|
if (item_list[n].S_CELL_TYPE == cell_type or grid_def.is_smallest ) then
|
item_list[n].Q = item_list[n].Q + 1
|
else
|
-- 2024-9-28 改进
|
-- 如果剩余体积 > 降格后料格体积 Q需要加1
|
nRet, next_grid_def = wms_cntr.Get_CTD_Next_GridDef( ctd, cell_type )
|
if nRet ~= 0 then
|
return 1, "wms_cntr.Get_CTD_Next_GridDef 失败!"..next_grid_def
|
end
|
if ( volumeX > next_grid_def.volume ) then
|
item_list[n].Q = item_list[n].Q + 1
|
end
|
end
|
end
|
elseif ctd.count_method == "Limit" then
|
-- 获取 SKU 在 grid_def.cell_type 的料格中的装载数量
|
nRet, loading_limit = wms_base.GetSKU_LoadingLimit( item_list[n], ctd.ctd_code, grid_def.cell_type )
|
if nRet ~= 0 then
|
return 1, loading_limit
|
end
|
-- qX 为余数
|
if qty >= loading_limit then
|
item_list[n].Q = math.floor(qty/loading_limit)
|
qX = qty - item_list[n].Q*loading_limit
|
else
|
qX = qty
|
end
|
if qX > 0 then
|
-- 如果料格在料箱中最小的料格说明不能再降格了
|
if (item_list[n].S_CELL_TYPE == cell_type or grid_def.is_smallest ) then
|
item_list[n].Q = item_list[n].Q + 1
|
else
|
-- 如果剩余体积 > 降格后料格数量
|
nRet, next_grid_def = wms_cntr.Get_CTD_Next_GridDef( ctd, cell_type )
|
if nRet ~= 0 then
|
return 1, "wms_cntr.Get_CTD_Next_GridDef 失败!"..next_grid_def
|
end
|
|
nRet, loading_limit = wms_base.GetSKU_LoadingLimit( item_list[n], ctd.ctd_code, next_grid_def.cell_type )
|
if nRet ~= 0 then
|
return 1, loading_limit
|
end
|
if ( qX > loading_limit ) then
|
item_list[n].Q = item_list[n].Q + 1
|
end
|
end
|
end
|
else
|
return 1, "料箱计数方法 = '"..ctd.count_method.."'的算法还没实现!"
|
end
|
-- 计算呼出料格总数
|
sum_Q = sum_Q + item_list[n].Q
|
end
|
::continue::
|
end
|
return 0, sum_Q
|
end
|
|
-- 检查 item_list 中的item是否有物料的最低适配货隔 == cell_type 并且还有量没分配料格的，如果有说明该类型的料格缺少
|
-- 如果有货品必须要cell_type类型料箱，返回 true, 并且返回是item_list中的货品下标
|
local function have_this_cell_type( item_list, cell_type )
|
local n
|
|
for n = 1, #item_list do
|
if ( item_list[n].ok == false and item_list[n].S_CELL_TYPE == cell_type ) then
|
if ( item_list[n].qty > item_list[n].alloc_qty ) then
|
if ( lua.equation( item_list[n].qty, item_list[n].alloc_qty ) == false ) then
|
return true, n
|
end
|
end
|
end
|
end
|
return false, 0
|
end
|
|
-- 把空料格数量小的排前面
|
local function empty_cntr_sort( item_a, item_b )
|
return item_a.empty_cell_num < item_b.empty_cell_num
|
end
|
|
local function cntr_in_this_list( cntr_code, out_cntr_result )
|
if ( nil == out_cntr_result ) then return false end
|
local n
|
|
for n = 1, #out_cntr_result do
|
if ( out_cntr_result[n].cntr_code == cntr_code ) then return true end
|
end
|
return false
|
end
|
|
--[[ ***
|
呼出 cell_need_num 个 cell_type 类型的空料格，需要多少个料箱
|
从数据库查询获取 料箱类型 = cell_type 有空料格的料箱列表，并且根据空料格数量的大小进行排序，空料格数量大的在最前面
|
|
输入参数:
|
pac_cfg -- 预分配配置参数
|
cell_type 呼出料箱类型
|
cell_need_num 需要呼出多少个料格
|
|
out_cntr_list 呼出料箱列表, 是本函数计算后的主要成果
|
query_cntr_list -- 除 out_cntr_list 外可用的料箱，用于 out_cntr_list 在分配货物是因为重量的原因不能使用需要分配新的料箱
|
out_cntr_result -- 已经呼出的料箱
|
|
返回3个参数，格式（nRet,x_sum_Q, strErrInfo ）
|
nRet 0 正常 1 -- 无法匹配需求 2 -- 程序错误
|
x_sum_Q 呼出的料格缺少的cell_type类型的料格数量
|
]]
|
local function generate_out_cntr_list( strLuaDEID, pac_cfg, cell_type, cell_need_num, out_cntr_list, query_cntr_list, out_cntr_result )
|
local nRet, strRetInfo, strCondition, strOrder, n
|
|
-- 输入参数判断
|
if ( pac_cfg.wh_code == nil or pac_cfg.wh_code == '' ) then
|
return 1, 0, "输入参数错误， wh_code必须有值"
|
end
|
local str_loc_where = "S_WH_CODE = '"..pac_cfg.wh_code.."'"
|
if ( pac_cfg.area_code ~= nil and pac_cfg.area_code ~= '') then
|
str_loc_where = str_loc_where.." AND S_AREA_CODE = '"..pac_cfg.area_code.."'"
|
end
|
|
if ( pac_cfg.aisle ~= nil and pac_cfg.aisle ~= '') then
|
str_loc_where = str_loc_where.." AND S_AISLE_CODE IN ("..pac_cfg.aisle..")"
|
end
|
local cntr_max_weight = pac_cfg.ctd.load_capacity
|
local cntr_condition = " S_CTD_CODE = '"..pac_cfg.ctd.ctd_code.."'"
|
|
-- N_EMPTY_FULL < 2 料箱未满
|
strCondition = "N_EMPTY_CELL_NUM > N_ALLOC_CELL_NUM AND S_SPEC = '"..cell_type.."' AND N_LOCK_STATE = 0 AND C_ENABLE = 'Y' AND "..cntr_condition.." AND N_EMPTY_FULL < 2 AND N_EMPTY_CELL_NUM > 0 "..
|
" AND S_CODE IN (select S_CNTR_CODE from TN_Loc_Container with (NOLOCK) where S_LOC_CODE IN (select S_CODE from TN_Location with (NOLOCK) where "..str_loc_where..")) "
|
if pac_cfg.ctd.check_capacity then
|
if cntr_max_weight <= 0 then
|
return 1, "容器类型定义'"..pac_cfg.ctd.ctd_code.."'中缺少容器载重参数!"
|
end
|
strCondition = strCondition.." AND F_GOOD_WEIGHT < "..cntr_max_weight
|
end
|
|
strOrder = "(N_EMPTY_CELL_NUM - N_ALLOC_CELL_NUM) desc"
|
|
local cntr_objs, cntr_attr
|
nRet, cntr_objs = m3.QueryDataObject(strLuaDEID, "Container", strCondition, strOrder )
|
if nRet ~= 0 then return 2, 0, cntr_objs end
|
if cntr_objs == '' then
|
return 0, cell_need_num, "没找到匹配的料箱"
|
end
|
|
local empty_cell_num, qty
|
local empty_cntr_list = {}
|
local query_cntr_count = 0 -- 这样的箱子不需要太多不超过100
|
|
query_cntr_list = {} -- 查询出来的符合条件的料箱
|
|
for n = 1, #cntr_objs do
|
cntr_attr = m3.KeyValueAttrsToObjAttr(cntr_objs[n].attrs)
|
-- 防止找到的料箱已经在呼出的料箱列表中
|
if ( cntr_in_this_list( cntr_attr.S_CODE, out_cntr_result ) ) then goto continue end
|
|
if ( cell_need_num > 0 ) then
|
-- 呼出料箱空料格数量
|
empty_cell_num = lua.StrToNumber( cntr_attr.N_EMPTY_CELL_NUM ) - lua.StrToNumber( cntr_attr.N_ALLOC_CELL_NUM )
|
if ( cell_need_num > empty_cell_num ) then
|
qty = empty_cell_num
|
else
|
-- 特别关注: 需要找到最适配的料箱 cell_need_num = empty_cell_num 是最优的
|
if ( cell_need_num == empty_cell_num ) then
|
qty = cell_need_num
|
else
|
-- 把当前这个料箱加到附加链表, 没找到最优数量的料格后会从这个 empty_cntr_list 里获取
|
local empty_cntr = {
|
cntr_code = cntr_attr.S_CODE,
|
cntr_good_weight = lua.StrToNumber( cntr_attr.F_GOOD_WEIGHT ),
|
empty_cell_num = empty_cell_num
|
}
|
table.insert( empty_cntr_list, empty_cntr )
|
goto continue
|
end
|
end
|
|
-- 分配成功, 把这个料箱加入呼出料箱列表
|
local out_cntr = {
|
cntr_code = cntr_attr.S_CODE,
|
cntr_good_weight = lua.StrToNumber( cntr_attr.F_GOOD_WEIGHT ),
|
cell_type = cell_type,
|
empty_cell_list = {},
|
full = false,
|
cell_list = {}
|
}
|
table.insert( out_cntr_list, out_cntr )
|
cell_need_num = cell_need_num - qty
|
else
|
-- query_cntr_list 是候补
|
local out_cntr = {
|
cntr_code = cntr_attr.S_CODE,
|
cntr_good_weight = lua.StrToNumber( cntr_attr.F_GOOD_WEIGHT ),
|
cell_type = cell_type,
|
empty_cell_list = {},
|
full = false,
|
cell_list = {}
|
}
|
table.insert( query_cntr_list, out_cntr )
|
query_cntr_count = query_cntr_count + 1
|
if ( query_cntr_count > 100 ) then break end
|
end
|
|
::continue::
|
end
|
|
-- 如果还有 cell_need_num 没分配， 从上面为了适配料格数量跳过的哪些料格
|
if ( cell_need_num > 0 and #empty_cntr_list > 0 ) then
|
table.sort( empty_cntr_list, empty_cntr_sort )
|
-- 取第一个空料箱（这个是空料箱数最接近cell_need_num）
|
local out_cntr = {
|
cntr_code = empty_cntr_list[1].cntr_code,
|
cntr_good_weight = empty_cntr_list[1].cntr_good_weight,
|
cell_type = cell_type,
|
empty_cell_list = {},
|
full = false,
|
cell_list = {}
|
}
|
table.insert( out_cntr_list, out_cntr )
|
|
for n = 2, #empty_cntr_list do
|
if ( query_cntr_count > 100 ) then break end
|
local out_cntr = {
|
cntr_code = empty_cntr_list[n].cntr_code,
|
cntr_good_weight = empty_cntr_list[n].cntr_good_weight,
|
cell_type = cell_type,
|
empty_cell_list = {},
|
full = false,
|
cell_list = {}
|
}
|
table.insert( query_cntr_list, out_cntr )
|
query_cntr_count = query_cntr_count + 1
|
end
|
cell_need_num = 0
|
end
|
return 0, cell_need_num
|
end
|
|
-- 在呼出的空料箱里分配货物, 遍历 item_list 把item_list的货品批分到 呼出的空料箱中，空料箱资源是 out_cntr_list
|
local function distribute_to_outcntrlist( strLuaDEID, pac_cfg, item_list, out_cntr_list, cell_type )
|
local nRet, strRetInfo, nCount, n, m, qty, si_qty, i
|
local sum_Q = 0 -- 补料料箱里批分掉的Q
|
local empty_cell_count
|
|
nCount = #item_list
|
if ( nCount == 0 ) then return 0 end
|
-- m 是呼出的料箱列表下标
|
for m = 1, #out_cntr_list do
|
empty_cell_count = lua.GetTableCount( out_cntr_list[m].empty_cell_list )
|
if ( empty_cell_count > 0 ) then
|
-- 遍历item_list n 是货品列表下标
|
for n = 1, nCount do
|
-- > 0 说明有cell_type类型的料箱格需求
|
if ( item_list[n].ok == false and item_list[n].Q > 0 and item_list[n].empty_cell_type == cell_type ) then
|
-- 遍历呼出的空料箱里的空料格
|
for i = 1, empty_cell_count do
|
if ( out_cntr_list[m].empty_cell_list[i].item_code == '' ) then
|
-- 取一个空料格存储计算能存储多少个货品
|
local cntr_cell = {}
|
cntr_cell.cntr_code = out_cntr_list[m].cntr_code
|
cntr_cell.cell_no = out_cntr_list[m].empty_cell_list[i].cell_no
|
cntr_cell.good_volume = 0 -- 是空料格
|
cntr_cell.cell_type = cell_type
|
nRet, si_qty = wms_cntr.Get_CntrCell_Goods_Qty( pac_cfg.ctd, out_cntr_list[m].cntr_good_weight, cntr_cell, item_list[n] )
|
if ( nRet ~= 0 ) then
|
return 1, si_qty
|
end
|
|
qty = item_list[n].qty - item_list[n].alloc_qty
|
if ( si_qty > qty ) then si_qty = qty end
|
-- 呼出料箱里加一个料格存储 item
|
if ( si_qty > 0 ) then
|
-- 生成批次号
|
nRet, strSN = prj_base.Generate_Batch_No( item_list[n].S_ITEM_CODE )
|
if ( nRet ~= 0 ) then return 1, strSN end
|
|
item_list[n].alloc_qty = item_list[n].alloc_qty + si_qty
|
if ( lua.equation( item_list[n].alloc_qty, item_list[n].qty ) ) then
|
item_list[n].ok = true
|
end
|
|
-- 把分配掉的si_qty个货品加到呼出的空料格里
|
local cell_item = {
|
cntr_code = cntr_cell.cntr_code,
|
cell_type = cntr_cell.cell_type,
|
cell_no = cntr_cell.cell_no,
|
item_code = item_list[n].S_ITEM_CODE,
|
item_name = item_list[n].S_ITEM_NAME,
|
row = item_list[n].row,
|
entry_batch_no = strSN,
|
qty = si_qty,
|
sum_volume = si_qty*item_list[n].volume,
|
sum_weight = si_qty*item_list[n].weight,
|
weight = item_list[n].weight,
|
volume = item_list[n].volume,
|
sku = item_list[n]
|
}
|
table.insert( out_cntr_list[m].cell_list, cell_item )
|
|
-- 20241104 容器料格分配数量+1，料格设置为预分配
|
nRet, strRetInfo = wms_cntr.CNTR_cell_alloc_set( strLuaDEID, cntr_cell.cntr_code, cntr_cell.cell_no, pac_cfg.bs_no )
|
if nRet ~= 0 then
|
return 1, strRetInfo
|
end
|
-- 容器中商品的总重量需要加上刚加入到料格里的货品重量
|
out_cntr_list[m].cntr_good_weight = out_cntr_list[m].cntr_good_weight + cell_item.sum_weight
|
table.insert( item_list[n].cntr_cell_list, cell_item )
|
-- empty_cell_list 里item_code 设置为有值，表示这个空料格已经有货
|
out_cntr_list[m].empty_cell_list[i].item_code = item_list[n].S_ITEM_CODE
|
out_cntr_list[m].empty_cell_list[i].item_name = item_list[n].S_ITEM_NAME
|
item_list[n].Q = item_list[n].Q - 1
|
end
|
end
|
if ( item_list[n].Q <= 0 ) then
|
break
|
end
|
end
|
end
|
end
|
end
|
end
|
|
return 0
|
end
|
|
local function item_sort_by_cell_tye( item_a, item_b )
|
return item_a.S_CELL_TYPE < item_b.S_CELL_TYPE
|
end
|
|
-- 删除呼出容器中的empty_cell 列表中 名为 cell_no 的料格
|
local function remove_empty_cell( cntr, cell_no )
|
local n
|
for n = 1, #cntr.empty_cell_list do
|
if (cntr.empty_cell_list[n].cell_no == cell_no ) then
|
table.remove( cntr.empty_cell_list, n )
|
return
|
end
|
end
|
end
|
|
-- 把料箱中已经分配了item的空料格删除
|
local function remove_empty_cell_have_item_code( cntr )
|
-- 清除料箱里的空容器列表
|
local m = 1
|
while cntr.empty_cell_list[m] do
|
if (cntr.empty_cell_list[m].item_code ~= '' ) then
|
table.remove( cntr.empty_cell_list, m )
|
else
|
m = m + 1
|
end
|
end
|
end
|
|
-- 把一个指定的货品批分到 呼出容器列表 中, 如果 out_cntr_list 批分不完，从 query_cntr_list 里继续批分
|
local function distribute_item_to_out_cntr_list( strLuaDEID, pac_cfg, item, out_cntr_list )
|
local nRet, strRetInfo, nCount, n, m, qty, si_qty, i
|
local empty_cell_count
|
|
if ( item.ok ) then return end
|
for m = 1, #out_cntr_list do
|
-- 遍历呼出的空料箱里的空料格
|
for i = 1, #out_cntr_list[m].empty_cell_list do
|
if ( out_cntr_list[m].empty_cell_list[i].item_code == '' ) then
|
-- 取一个空料格存储计算能存储多少个货品
|
local cntr_cell = {}
|
cntr_cell.cntr_code = out_cntr_list[m].cntr_code
|
cntr_cell.cell_no = out_cntr_list[m].empty_cell_list[i].cell_no
|
cntr_cell.good_volume = 0 -- 是空料格
|
cntr_cell.cell_type = out_cntr_list[m].cell_type
|
nRet, si_qty = wms_cntr.Get_CntrCell_Goods_Qty( pac_cfg.ctd, out_cntr_list[m].cntr_good_weight, cntr_cell, item )
|
if ( nRet ~= 0 ) then
|
return 1, si_qty
|
end
|
|
qty = item.qty - item.alloc_qty
|
if ( si_qty > qty ) then
|
si_qty = qty
|
end
|
|
-- 呼出料箱里加一个料格存储 item
|
if ( si_qty > 0 ) then
|
-- 生成批次号
|
nRet, strSN = prj_base.Generate_Batch_No( item.S_ITEM_CODE )
|
if ( nRet ~= 0 ) then return 1, strSN end
|
|
item.alloc_qty = item.alloc_qty + si_qty
|
if ( lua.equation( item.alloc_qty, item.qty ) ) then item.ok = true end
|
|
-- 把分配掉的si_qty个货品加到呼出的空料格里
|
local cell_item = {
|
cntr_code = cntr_cell.cntr_code,
|
cell_type = cntr_cell.cell_type,
|
cell_no = cntr_cell.cell_no,
|
item_code = item.S_ITEM_CODE,
|
item_name = item.S_ITEM_NAME,
|
row = item.row,
|
entry_batch_no = strSN,
|
qty = si_qty,
|
sum_volume = si_qty*item.volume,
|
sum_weight = si_qty*item.weight,
|
weight = item.weight,
|
volume = item.volume,
|
sku = item
|
}
|
table.insert( out_cntr_list[m].cell_list, cell_item )
|
|
-- 容器料格分配数量+1，料格设置为预分配
|
nRet, strRetInfo = wms_cntr.CNTR_cell_alloc_set( strLuaDEID, cntr_cell.cntr_code, cntr_cell.cell_no, pac_cfg.bs_no )
|
if nRet ~= 0 then
|
return 1, strRetInfo
|
end
|
-- 容器中商品的总重量需要加上刚加入到料格里的货品重量
|
out_cntr_list[m].cntr_good_weight = out_cntr_list[m].cntr_good_weight + cell_item.sum_weight
|
table.insert( item.cntr_cell_list, cell_item )
|
-- empty_cell_list 里item_code 设置为有值，表示这个空料格已经有货
|
out_cntr_list[m].empty_cell_list[i].item_code = item.S_ITEM_CODE
|
out_cntr_list[m].empty_cell_list[i].item_name = item.S_ITEM_NAME
|
end
|
end
|
if ( item.ok ) then break end
|
end
|
remove_empty_cell_have_item_code( out_cntr_list[m] )
|
if ( item.ok ) then break end
|
end
|
|
return 0
|
end
|
|
-- 把一个料格加入呼出料箱列表
|
local function put_cell_item_to_out_cntr_list( out_cntr_list, cell_item )
|
local n
|
|
for n = 1, #out_cntr_list do
|
if ( out_cntr_list[n].cntr_code == cell_item.cntr_code ) then
|
table.insert( out_cntr_list[n].cell_list, cell_item )
|
-- 容器中商品的总重量需要加上岗加入到料格里的货品重量
|
out_cntr_list[n].cntr_good_weight = out_cntr_list[n].cntr_good_weight + cell_item.sum_weight
|
return
|
end
|
end
|
end
|
|
-- 从已经呼出的料箱列表中分配一个空的料格
|
-- out_cntr_list 已经呼出的料箱列表，cell_type 匹配的料格类型， item 分配的货品， need_q 需要的料格数量
|
local function alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, out_cntr_list, cell_type, item, need_q )
|
local n, empty_cell_count
|
local alloc_item = false
|
local cntr_cell = {}
|
|
for n = 1, #out_cntr_list do
|
empty_cell_count = lua.GetTableCount( out_cntr_list[n].empty_cell_list )
|
alloc_item = false
|
if ( out_cntr_list[n].full == false and out_cntr_list[n].cell_type == cell_type and empty_cell_count > 0 ) then
|
for i = 1, empty_cell_count do
|
if ( out_cntr_list[n].empty_cell_list[i].item_code == '' ) then
|
-- 取一个空料格存储计算能存储多少个货品
|
cntr_cell.cntr_code = out_cntr_list[n].cntr_code
|
cntr_cell.cell_no = out_cntr_list[n].empty_cell_list[i].cell_no
|
cntr_cell.good_volume = 0 -- 是空料格
|
cntr_cell.cell_type = cell_type
|
nRet, si_qty = wms_cntr.Get_CntrCell_Goods_Qty( pac_cfg.ctd, out_cntr_list[n].cntr_good_weight, cntr_cell, item )
|
if ( nRet ~= 0 ) then
|
return 1, si_qty
|
end
|
|
-- 需要分配料格的数量 qty，如果计算出来的数量大于需求数量，就用需求数量
|
qty = item.qty - item.alloc_qty
|
if ( si_qty > qty ) then si_qty = qty end
|
|
-- 呼出料箱里加一个料格存储 item
|
if ( si_qty > 0 ) then
|
-- 生成批次号
|
nRet, strSN = prj_base.Generate_Batch_No( item.S_ITEM_CODE )
|
if ( nRet ~= 0 ) then return 1, strSN end
|
|
item.alloc_qty = item.alloc_qty + si_qty
|
if ( lua.equation( item.alloc_qty, item.qty ) ) then item.ok = true end
|
|
-- 把分配掉的si_qty个货品加到补料呼出的容器里
|
local cell_item = {
|
cntr_code = cntr_cell.cntr_code,
|
cell_type = cntr_cell.cell_type,
|
cell_no = cntr_cell.cell_no,
|
item_code = item.S_ITEM_CODE,
|
item_name = item.S_ITEM_NAME,
|
row = item.row,
|
entry_batch_no = strSN,
|
qty = si_qty,
|
sum_volume = si_qty*item.volume,
|
sum_weight = si_qty*item.weight,
|
weight = item.weight,
|
volume = item.volume,
|
sku = item
|
}
|
|
put_cell_item_to_out_cntr_list( out_cntr_list, cell_item )
|
table.insert( item.cntr_cell_list, cell_item )
|
|
-- 容器料格分配数量+1，料格设置为预分配
|
nRet, strRetInfo = wms_cntr.CNTR_cell_alloc_set( strLuaDEID, cntr_cell.cntr_code, cntr_cell.cell_no, pac_cfg.bs_no )
|
if nRet ~= 0 then
|
return 1, strRetInfo
|
end
|
-- empty_cell_list 里item_code 设置为有值，表示这个空料格已经有货
|
out_cntr_list[n].empty_cell_list[i].item_code = item.S_ITEM_CODE
|
out_cntr_list[n].empty_cell_list[i].item_name = item.S_ITEM_NAME
|
need_q = need_q - 1
|
alloc_item = true
|
if ( need_q == 0 ) then break end
|
end
|
end
|
end
|
end
|
|
-- 删除那些已经分配货品的空料格empty_cell
|
if ( alloc_item ) then
|
remove_empty_cell_have_item_code( out_cntr_list[n] )
|
end
|
if ( need_q == 0 ) then break end
|
end
|
return 0, need_q
|
end
|
|
-- 清除呼出料箱列表中没有cell_list的节点
|
local function remove_no_cell_list_out_cntr_list( out_cntr_list )
|
local n = 1
|
while out_cntr_list[n] do
|
if (#out_cntr_list[n].cell_list == 0 ) then
|
table.remove( out_cntr_list, n )
|
else
|
n = n + 1
|
end
|
end
|
end
|
|
--[[
|
step2 遍历SKU清单进行料箱预分配
|
输入参数:
|
pac_cfg -- 预分配算法基本参数配置
|
item_list -- 需要做预分配的货品明细
|
supplement_cntr_list 补料呼出的料箱列表
|
out_cntr_result -- 呼出的料箱列表
|
|
注意：料格类型A体积最大，依次类推
|
--]]
|
local function get_out_cntr_list_cbg( strLuaDEID, pac_cfg, item_list, supplement_cntr_list, out_cntr_result )
|
local nRet, strRetInfo
|
|
if pac_cfg.ctd.count_method == "Volume" then
|
-- 排序把体积大的放前面
|
table.sort( item_list, item_sort_volume )
|
end
|
|
-- 从A类型料箱开始一直到E类型料箱呼出空料箱（大宗货品用A料框来满足入库需求）
|
local sum_Q, cell_type_index, Qx, x_sum_Q
|
local out_cntr_list = {}
|
local cell_type
|
local b_have_this_cell_type = false
|
local item_index, n
|
local upgrad_item_list = {} -- 需要进行升格的物料
|
local query_cntr_list
|
|
-- 从A类型料格开始变量容器定义的料格类型
|
for cell_type_index, grid_def in ipairs( pac_cfg.ctd.grid_box_def ) do
|
cell_type = grid_def.cell_type
|
-- step1 获取某类型空料箱格数量
|
nRet, sum_Q = generate_item_needemptycell_qty( strLuaDEID, pac_cfg.ctd, item_list, grid_def, cntr_max_weight )
|
if ( nRet ~= 0 ) then
|
return nRet, sym_Q
|
end
|
|
if ( sum_Q > 0 ) then
|
--呼出空料箱格 生成 out_cntr_list
|
out_cntr_list = {}
|
query_cntr_list = {}
|
|
-- 呼出数量最匹配的空料箱, 返回 out_cntr_list [{"cnter":"","good_weight":10, cell_type:"B"}]
|
-- x_sum_Q 是不足的 cell_type 料格数量，需要进行降格
|
nRet, x_sum_Q, strRetInfo = generate_out_cntr_list( strLuaDEID, pac_cfg, cell_type, sum_Q, out_cntr_list, query_cntr_list )
|
if (nRet ~= 0 ) then
|
return 2, "generate_out_cntr_list 发生错误! "..strRetInfo
|
end
|
|
-- 存在呼出的料箱列表，把货品批分到呼出的料箱格
|
if ( lua.IsTableEmpty( out_cntr_list ) == false ) then
|
-- 设置 out_cntr_list 中 empty_cell_list
|
nRet, strRetInfo = wms_pac.set_out_cntr_empty_cell( strLuaDEID, out_cntr_list )
|
if nRet ~= 0 then
|
return 2, strRetInfo
|
end
|
-- 把 item_list 中的货品批分到 呼出的 out_cntr_list 中的容器中
|
nRet, strRetInfo = distribute_to_outcntrlist( strLuaDEID, pac_cfg, item_list, out_cntr_list, cell_type )
|
if ( nRet ~= 0 ) then
|
return 2, "step4.3 发生错误! "..strRetInfo
|
end
|
wms_pac.reset_empty_cell_info( out_cntr_list )
|
lua.table_merge( out_cntr_result, out_cntr_list )
|
end
|
if ( x_sum_Q > 0 ) then
|
-- 如果未分配料箱的货品中还存在 cell_type 的料格
|
b_have_this_cell_type, item_index = have_this_cell_type( item_list, cell_type )
|
if ( b_have_this_cell_type ) then
|
-- 如果不是A类型的料格需要考虑升格
|
if ( cell_type == 'A') then
|
local x_qty = item_list[item_index].qty - item_list[item_index].alloc_qty
|
return 1, "在分配货品编码 = '"..item_list[item_index].S_ITEM_CODE.."'时, 料箱类型 = "..cell_type.."的料箱不足! 货品数量 = "..x_qty
|
end
|
end
|
|
-- MDF 20241220
|
-- 说明没呼出足够的适配料箱
|
if ( cell_type_index == 1 ) then -- A 料格
|
-- 降格处理 A --> B
|
lua.Warning( strLuaDEID, debug.getinfo(1), pac_cfg.bs_type.."-->'"..pac_cfg.bs_no.."'有"..x_sum_Q.."个A料箱降格!" )
|
else
|
-- 升格处理 B --> A
|
lua.Warning( strLuaDEID, debug.getinfo(1), pac_cfg.bs_type.."-->'"..pac_cfg.bs_no.."'有"..x_sum_Q.."个"..cell_type.."料箱升格!" )
|
-- 把item_list中 item.Q > 0 的加入升格通道
|
n = 1
|
while item_list[n] do
|
if (item_list[n].Q > 0 ) then
|
item_list[n].upgrad_cell_index = cell_type_index
|
table.insert( upgrad_item_list, item_list[n] )
|
table.remove( item_list, n )
|
else
|
n = n + 1
|
end
|
end
|
end
|
end
|
-- MDF 20241220
|
-- 判断 item_list 中的数量是否已经全部分配到容器，如果全部分配了料箱 break
|
if ( wms_pac.item_list_is_all_ok( item_list ) or #item_list == 0 ) then
|
break
|
end
|
end
|
end
|
|
-- MDF 20241220 ***
|
-- step5 如果有升料格需求的货品进行升格处理
|
-- 如果有升料格的货品进入升格
|
local qty, total_volume, Q, cell_volume, pk_qty, xQty
|
for n = 1, #upgrad_item_list do
|
if ( upgrad_item_list[n].ok == false ) then
|
cell_type_index = upgrad_item_list[n].upgrad_cell_index
|
-- 升格循环
|
while ( cell_type_index > 1 ) do
|
cell_type_index = cell_type_index - 1 -- 升一个料格
|
cell_type = pac_cfg.ctd.grid_box_def[cell_type_index].cell_type
|
|
qty = upgrad_item_list[n].qty - upgrad_item_list[n].alloc_qty
|
|
if pac_cfg.ctd.count_method == "Mixed" or pac_cfg.ctd.count_method == "Volume" then
|
total_volume = qty*upgrad_item_list[n].volume
|
cell_volume = pac_cfg.ctd.grid_box_def[cell_type_index].volume
|
if ( total_volume > cell_volume ) then
|
--Q = math.floor( total_volume/cell_volume )
|
Q, pk_qty = calculate_box_count_by_volume( cell_volume, upgrad_item_list[n].volume, qty )
|
else
|
Q = 1
|
end
|
elseif pac_cfg.ctd.count_method == "Limit" then
|
-- 获取 SKU 在 grid_def.cell_type 的料格中的装载数量
|
nRet, loading_limit = wms_base.GetSKU_LoadingLimit( upgrad_item_list[n], pac_cfg.ctd.ctd_code, cell_type )
|
if nRet ~= 0 then
|
return 1, loading_limit
|
end
|
if qty >= loading_limit then
|
Q = math.floor(qty/loading_limit)
|
else
|
Q = 1
|
end
|
else
|
return 1, "料箱计数方法 = '"..pac_cfg.ctd.count_method.."'的算法还没实现!"
|
end
|
-- 从补料呼出的容器里找
|
nRet, Q = alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, supplement_cntr_list, cell_type, upgrad_item_list[n], Q )
|
if ( nRet ~= 0 ) then return 1, Q end
|
if ( Q == 0 ) then break end
|
|
-- 从呼出容器里找
|
nRet, Q = alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, out_cntr_result, cell_type, upgrad_item_list[n], Q )
|
if ( nRet ~= 0 ) then return 1, Q end
|
if ( Q == 0 ) then break end
|
|
-- 从新呼出一个料箱容器
|
out_cntr_list = {}
|
query_cntr_list = {}
|
nRet, Q, strRetInfo = generate_out_cntr_list( strLuaDEID, pac_cfg, cell_type, Q, out_cntr_list, query_cntr_list, out_cntr_result )
|
if (nRet ~= 0 ) then
|
return 2, "step5.1 发生错误! "..strRetInfo
|
end
|
if ( lua.IsTableEmpty( out_cntr_list ) == false ) then
|
-- 设置 out_cntr_list 中 empty_cell_list
|
nRet, strRetInfo = wms_pac.set_out_cntr_empty_cell( strLuaDEID, out_cntr_list )
|
if nRet ~= 0 then
|
return 2, strRetInfo
|
end
|
-- 把 upgrad_item_list 中的货品批分到 呼出的 out_cntr_list 中的容器中
|
nRet, strRetInfo = distribute_item_to_out_cntr_list( strLuaDEID, pac_cfg, upgrad_item_list[n], out_cntr_list )
|
if ( nRet ~= 0 ) then
|
return 2, "step5.2 发生错误! "..strRetInfo
|
end
|
wms_pac.reset_empty_cell_info( out_cntr_list )
|
lua.table_merge( out_cntr_result, out_cntr_list )
|
end
|
if ( Q == 0 ) then break end
|
end
|
end
|
end
|
|
-- MDF 20241220 ***
|
-- step6 检查升格后货品是否有没有匹配到料箱的，如果有需要降格
|
local xVolume
|
for n = 1, #upgrad_item_list do
|
if ( upgrad_item_list[n].ok == false ) then
|
-- 开始降格
|
cell_type_index = upgrad_item_list[n].upgrad_cell_index
|
while ( cell_type_index < 5 ) do
|
cell_type_index = cell_type_index + 1 -- 降一个料格
|
cell_type = pac_cfg.ctd.grid_box_def[cell_type_index].cell_type
|
|
if ( upgrad_item_list[n].S_CELL_TYPE < cell_type ) then break end
|
|
qty = upgrad_item_list[n].qty - upgrad_item_list[n].alloc_qty
|
|
if pac_cfg.ctd.count_method == "Mixed" or pac_cfg.ctd.count_method == "Volume" then
|
total_volume = qty*upgrad_item_list[n].volume
|
cell_volume = pac_cfg.ctd.grid_box_def[cell_type_index].volume
|
if ( total_volume > cell_volume ) then
|
--Q = math.floor( total_volume/cell_volume )
|
Q, pk_qty = calculate_box_count_by_volume( cell_volume, upgrad_item_list[n].volume, qty )
|
xVolume = upgrad_item_list[n].volume*(qty-pk_qty)
|
if ( xVolume > 0 ) then Q = Q + 1 end
|
else
|
Q = 1
|
end
|
elseif pac_cfg.ctd.count_method == "Limit" then
|
-- 获取 SKU 在 grid_def.cell_type 的料格中的装载数量
|
nRet, loading_limit = wms_base.GetSKU_LoadingLimit( upgrad_item_list[n], pac_cfg.ctd.ctd_code, cell_type )
|
if nRet ~= 0 then
|
return 1, loading_limit
|
end
|
if qty >= loading_limit then
|
Q = math.floor(qty/loading_limit)
|
xQty = qty - Q*loading_limit
|
if xQty > 0 then Q = Q + 1 end
|
else
|
Q = 1
|
end
|
else
|
return 1, "料箱计数方法 = '"..pac_cfg.ctd.count_method.."'的算法还没实现!"
|
end
|
-- 从补料呼出的容器里找
|
nRet, Q = alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, supplement_cntr_list, cell_type, upgrad_item_list[n], Q )
|
if ( nRet ~= 0 ) then return 2, Q end
|
if ( Q == 0 ) then break end
|
-- 从呼出容器里找
|
nRet, Q = alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, out_cntr_result, cell_type, upgrad_item_list[n], Q )
|
if ( nRet ~= 0 ) then return 2, Q end
|
if ( Q == 0 ) then break end
|
-- 从新呼出一个料箱容器
|
out_cntr_list = {}
|
nRet, Q, strRetInfo = generate_out_cntr_list( strLuaDEID, pac_cfg, cell_type, Q, out_cntr_list, query_cntr_list, out_cntr_result )
|
if (nRet ~= 0 ) then
|
return 2, "step6.1 发生错误! "..strRetInfo
|
end
|
if ( lua.IsTableEmpty( out_cntr_list ) == false ) then
|
-- 设置 out_cntr_list 中 empty_cell_list
|
nRet, strRetInfo = wms_pac.set_out_cntr_empty_cell( strLuaDEID, out_cntr_list )
|
if nRet ~= 0 then
|
return 2, strRetInfo
|
end
|
|
-- 把 upgrad_item_list 中的货品批分到 呼出的 out_cntr_list 中的容器中
|
nRet, strRetInfo = distribute_item_to_out_cntr_list( strLuaDEID, pac_cfg, upgrad_item_list[n], out_cntr_list )
|
if ( nRet ~= 0 ) then
|
return 2, "step6.2 发生错误! "..strRetInfo
|
end
|
wms_pac.reset_empty_cell_info( out_cntr_list )
|
lua.table_merge( out_cntr_result, out_cntr_list )
|
end
|
if ( Q == 0 ) then break end
|
end
|
end
|
end
|
|
-- step7 判断货品是否已经全部分配料箱完成，没完成报错
|
-- 把 item_list 和 upgrad_item_list 合并
|
lua.table_merge( item_list, upgrad_item_list )
|
|
-- 重置 supplement_cntr_list 和 out_cntr_list 中的empty_cell 等属性,
|
local s_cntr_have_empty_cell = wms_pac.reset_empty_cell_info( supplement_cntr_list )
|
local o_cntr_have_empty_cell = wms_pac.reset_empty_cell_info( out_cntr_result )
|
|
-- step8 遍历item_list 对没找到呼出料箱的货品进行单个呼出
|
-- 有可能因为重量超的原因上面分配的料格没办法装下货品
|
local Q1, Q2
|
for n = 1, #item_list do
|
if ( item_list[n].ok == false ) then
|
cell_type_index = string.byte( item_list[n].S_CELL_TYPE ) - string.byte( "A" ) + 1
|
while ( cell_type_index >= 1 ) do
|
cell_type = pac_cfg.ctd.grid_box_def[cell_type_index].cell_type
|
qty = item_list[n].qty - item_list[n].alloc_qty
|
|
-- 根据体积算的料格数量
|
if pac_cfg.ctd.count_method == "Mixed" or pac_cfg.ctd.count_method == "Volume" then
|
total_volume = qty*item_list[n].volume
|
cell_volume = pac_cfg.ctd.grid_box_def[cell_type_index].volume
|
if ( total_volume > cell_volume ) then
|
--Q = math.floor( total_volume/cell_volume )
|
Q1, pk_qty = calculate_box_count_by_volume( cell_volume, item_list[n].volume, qty )
|
xVolume = item_list[n].volume*(qty-pk_qty)
|
if ( xVolume > 0 ) then Q1 = Q1 + 1 end
|
else
|
Q1 = 1
|
end
|
-- 根据重量算的料格数量
|
Q2, pk_qty = calculate_box_count_by_weight( pac_cfg, cell_type_index, item_list[n].weight, qty )
|
xVolume = item_list[n].volume*(qty-pk_qty)
|
if ( xVolume > 0 ) then Q2 = Q2 + 1 end
|
|
if ( Q2 > Q1 ) then
|
Q = Q2
|
else
|
Q = Q1
|
end
|
elseif pac_cfg.ctd.count_method == "Limit" then
|
-- 获取 SKU 在 grid_def.cell_type 的料格中的装载数量
|
nRet, loading_limit = wms_base.GetSKU_LoadingLimit( item_list[n], pac_cfg.ctd.ctd_code, cell_type )
|
if nRet ~= 0 then
|
return 1, loading_limit
|
end
|
if qty >= loading_limit then
|
Q = math.floor(qty/loading_limit)
|
xQty = qty - Q*loading_limit
|
if xQty > 0 then Q = Q + 1 end
|
else
|
Q = 1
|
end
|
else
|
return 1, "料箱计数方法 = '"..pac_cfg.ctd.count_method.."'的算法还没实现!"
|
end
|
|
-- 从呼出容器里找
|
nRet, Q = alloc_cell_in_out_cntr_list( strLuaDEID, pac_cfg, out_cntr_result, cell_type, item_list[n], Q )
|
if ( nRet ~= 0 ) then return 2, Q end
|
if ( Q == 0 ) then break end
|
|
-- 从新呼出一个料箱容器
|
out_cntr_list = {}
|
nRet, Q, strRetInfo = generate_out_cntr_list( strLuaDEID, pac_cfg, cell_type, Q, out_cntr_list, query_cntr_list, out_cntr_result )
|
if (nRet ~= 0 ) then
|
return 2, "step8.1 发生错误! "..strRetInfo
|
end
|
if ( lua.IsTableEmpty( out_cntr_list ) == false ) then
|
-- 设置 out_cntr_list 中 empty_cell_list
|
nRet, strRetInfo = wms_pac.set_out_cntr_empty_cell( strLuaDEID, out_cntr_list )
|
if nRet ~= 0 then
|
return 2, strRetInfo
|
end
|
-- 把 upgrad_item_list 中的货品批分到 呼出的 out_cntr_list 中的容器中
|
nRet, strRetInfo = distribute_item_to_out_cntr_list( strLuaDEID, pac_cfg, item_list[n], out_cntr_list )
|
if ( nRet ~= 0 ) then
|
return 2, "step8.2 发生错误! "..strRetInfo
|
end
|
-- 清除呼出料箱列表中没有cell_list的节点
|
remove_no_cell_list_out_cntr_list( out_cntr_list )
|
if ( #out_cntr_list > 0 ) then
|
wms_pac.reset_empty_cell_info( out_cntr_list )
|
lua.table_merge( out_cntr_result, out_cntr_list )
|
end
|
end
|
|
if ( item_list[n].ok ) then break end
|
cell_type_index = cell_type_index - 1
|
end
|
end
|
end
|
return 0
|
end
|
|
--[[
|
item_list -- 需要预分配料箱的货品
|
pac_cfg -- 预分配料箱配置参数
|
{
|
wh_code, area_code 仓库，库区编码
|
factory
|
station 站台
|
aisle -- 可用巷道
|
bs_type 来源类型：入库单、入库波次
|
bs_no 来源单号
|
cntr_out_op_def = "料箱出库", --空料箱出库的作业定义
|
cntr_back_op_def = "货品入库" --料箱回库的主业定义
|
empty_cntr_out_rule = {} --空料箱呼出策略定义
|
ctd = {}
|
}
|
|
返回参数:
|
nRet 返回值：0 成功 1 -- 料箱不足 2 -- 程序错误
|
|
返回: pac_list 呼出的料箱列表 pac_detail_list 站台入库任务列表
|
]]
|
function wms_pac.Pre_Alloc_Cntr_CBG( strLuaDEID, pac_cfg, item_list )
|
local nRet, strRetInfo
|
local wh_code, area_code, station, bs_type, bs_no
|
local ctd_code
|
local sku_count = #item_list
|
local equipment = pac_cfg.equipment or ''
|
local supplement_cntr_list = {}
|
local out_cntr_result = {}
|
|
-- step1: 输入参数校验,及初始化
|
if ( sku_count == 0 ) then
|
return 0
|
end
|
|
if ( pac_cfg == nil or type( pac_cfg ) ~= "table" ) then
|
return 2, "Pre_Alloc_Cntr_CBG 函数输入参数错误: pac_cfg 必须有值，必须是 table 类型"
|
end
|
|
wh_code = lua.Get_StrAttrValue( pac_cfg.wh_code )
|
if ( wh_code == '' ) then
|
return 2, "Pre_Alloc_Cntr_CBG 函数输入参数错误: pac_cfg 参数中的 wh_code 必须有值!"
|
end
|
|
area_code = lua.Get_StrAttrValue( pac_cfg.area_code )
|
station = lua.Get_StrAttrValue( pac_cfg.station )
|
bs_type = lua.Get_StrAttrValue( pac_cfg.bs_type )
|
bs_no = lua.Get_StrAttrValue( pac_cfg.bs_no )
|
ctd_code = lua.Get_StrAttrValue( pac_cfg.ctd.ctd_code )
|
if ( ctd_code == "" ) then
|
return 2, "Pre_Alloc_Cntr_CBG 算法只适合 Cell_Box 类型的容器进行分配， pac_cfg中的参数 ctd_code 错误!"
|
end
|
local cntr_max_weight = pac_cfg.ctd.load_capacity
|
|
-- 如果 ctd 容器类型定义中定义过 混箱规则，这些规则一般会用到空料箱呼出规则中
|
-- 比如在国科项目中，不同产品线的物料是不能放在一个料箱的，而产品线也确定了料箱存放区域，空料箱要优先从这些区域呼出
|
|
local storage_area_set = {}
|
if not lua.IsTableEmpty( pac_cfg.empty_cntr_out_rule ) then
|
-- 根据 呼出空料箱策略，组织空料箱呼出库区
|
nRet, storage_area_set = wms_base.Get_Storage_Area_By_Strategy( pac_cfg.empty_cntr_out_rule, pac_cfg.mixing_attr_value )
|
if nRet ~= 0 then
|
return 1, storage_area_set
|
end
|
-- 对入库单中的库区和 空料箱呼出的库区 进行Check
|
for _, storage_area in ipairs( storage_area_set ) do
|
if storage_area.wh_code ~= pac_cfg.wh_code then
|
return 1, "空料箱呼出策略 '"..pac_cfg.empty_cntr_out_rule.no.."' 中定义的仓库编码和入库单中的仓库不一致!"
|
end
|
if lua.StrIsEmpty( storage_area.area_code ) then
|
return 1, "空料箱呼出策略 '"..pac_cfg.empty_cntr_out_rule.no.."' 中定义的策略必须指定到库区编码!"
|
end
|
end
|
end
|
|
-- step2 计算补料呼出料箱
|
local have_si_empty_cell = false
|
local pac_is_ok = false
|
|
if ( pac_cfg.ctd.si_enable ) then
|
nRet, supplement_cntr_list = wms_pac.get_replenishment_cntr_list( strLuaDEID, pac_cfg, item_list )
|
if ( nRet ~= 0 ) then
|
return 2, supplement_cntr_list
|
end
|
-- 首先判断一下补料呼出料箱中是否有存在 空料格, 有空料格设置 empty_cell_list 属性
|
have_si_empty_cell = wms_pac.set_replenishment_cntr_emptycell( strLuaDEID, supplement_cntr_list )
|
-- step1.3 检查补料箱中是否和合适料格做预分配
|
if not wms_pac.item_list_is_all_ok( item_list ) and have_si_empty_cell then
|
for _, sku in ipairs( item_list ) do
|
if ( sku.qty > sku.alloc_qty ) then
|
for _, si_cntr in ipairs( supplement_cntr_list ) do
|
nRet, strRetInfo = wms_pac.pre_alloc_sku_to_out_cntr( strLuaDEID, pac_cfg, sku, si_cntr )
|
if ( nRet ~= 0 ) then
|
return 1, strRetInfo
|
end
|
if sku.ok then
|
break
|
end
|
end
|
end
|
end
|
-- 删除 empty_cell_list 中已经分配出去的料格，返回 supplement_cntr_list 是否还有空料格
|
have_si_empty_cell = wms_pac.reset_empty_cell_info( supplement_cntr_list )
|
end
|
-- 判断是否已经完成预分配
|
pac_is_ok = wms_pac.item_list_is_all_ok( item_list )
|
end
|
|
if not pac_is_ok then
|
-- 继续呼出料箱
|
if lua.IsTableEmpty( storage_area_set ) then
|
nRet, strRetInfo = get_out_cntr_list_cbg( strLuaDEID, pac_cfg, item_list, supplement_cntr_list, out_cntr_result )
|
if ( nRet ~= 0 ) then
|
return 2, strRetInfo
|
end
|
else
|
-- 如果有呼出空料箱策略
|
for _, storage_area in ipairs( storage_area_set ) do
|
pac_cfg.area_code = storage_area.area_code
|
nRet, strRetInfo = get_out_cntr_list_cbg( strLuaDEID, pac_cfg, item_list, supplement_cntr_list, out_cntr_result )
|
if ( nRet ~= 0 ) then
|
return 2, strRetInfo
|
end
|
pac_is_ok = wms_pac.item_list_is_all_ok( item_list )
|
if pac_is_ok then
|
break
|
end
|
end
|
end
|
end
|
|
local msg_list = {} -- 保存无法分配料格的货品数量
|
for n = 1, #item_list do
|
if ( item_list[n].ok == false ) then
|
local qty = item_list[n].qty-item_list[n].alloc_qty
|
local msg = "系统没有匹配到货品编码 = '"..item_list[n].S_ITEM_CODE.."'的适配料箱进行预分配, 货品的适配料格类型 = '"..item_list[n].S_CELL_TYPE.."', 数量 = "..qty
|
table.insert( msg_list, msg )
|
end
|
end
|
if ( #msg_list > 0 ) then
|
-- 这些货品没有合适的料箱
|
return 1, lua.table2str( msg_list )
|
end
|
return 0, supplement_cntr_list, out_cntr_result
|
end
|
|
-- 生成 【Pre_Alloc_Container】【Pre_Alloc_CNTR_Detail】
|
-- replenish = Y 表示是补料呼出料箱 station -- 站台
|
local function generate_pac_detail( strLuaDEID, pac_cfg, cntr_code, replenish, cell_list, pac_list, pac_detail_list )
|
local nRet, strRetInfo
|
local n
|
|
local pac = m3.AllocObject2( strLuaDEID, "Pre_Alloc_Container" )
|
pac.S_CNTR_CODE = cntr_code
|
pac.C_REPLENISH = replenish
|
pac.S_BS_TYPE = pac_cfg.bs_type
|
pac.S_BS_NO = pac_cfg.bs_no
|
pac.S_STATION_NO = pac_cfg.station
|
pac.S_OUT_OP_NAME = pac_cfg.cntr_out_op_def
|
pac.S_BACK_OP_NAME = pac_cfg.cntr_back_op_def
|
pac.S_FACTORY = pac_cfg.factory
|
|
nRet, pac = m3.CreateDataObj2(strLuaDEID, pac)
|
if (nRet ~= 0 ) then return 1, "创建【预分配容器】失败!"..pac end
|
table.insert( pac_list, pac )
|
|
local pac_detail
|
|
for n = 1, #cell_list do
|
pac_detail = m3.AllocObject2( strLuaDEID, "Pre_Alloc_CNTR_Detail" )
|
pac_detail.S_PAC_NO = pac.S_PAC_NO
|
pac_detail.S_CNTR_CODE = cntr_code
|
pac_detail.S_CELL_NO = cell_list[n].cell_no
|
pac_detail.S_STATION_NO = pac_cfg.station
|
|
pac_detail.S_STORER = cell_list[n].sku.S_STORER
|
pac_detail.S_ITEM_CODE = cell_list[n].item_code
|
pac_detail.S_ITEM_STATE = cell_list[n].sku.S_ITEM_STATE
|
pac_detail.S_ITEM_NAME = cell_list[n].item_name
|
|
pac_detail.S_OWNER = cell_list[n].sku.S_OWNER
|
pac_detail.S_SUPPLIER_NO = cell_list[n].sku.S_SUPPLIER_NO
|
pac_detail.S_BATCH_NO = cell_list[n].sku.S_BATCH_NO
|
pac_detail.S_SERIAL_NO = cell_list[n].sku.S_SERIAL_NO
|
pac_detail.D_PRD_DATE = cell_list[n].sku.D_PRD_DATE
|
pac_detail.D_EXP_DATE = cell_list[n].sku.D_EXP_DATE
|
|
pac_detail.F_WEIGHT = cell_list[n].weight
|
pac_detail.F_VOLUME = cell_list[n].volume
|
|
pac_detail.S_WMS_BN = cell_list[n].wms_bn
|
pac_detail.F_QTY = cell_list[n].qty
|
|
pac_detail.S_BS_TYPE = pac_cfg.bs_type
|
pac_detail.S_BS_NO = pac_cfg.bs_no
|
pac_detail.N_BS_ROW_NO = cell_list[n].row
|
|
-- 把SKU中的明细扩展属性带入
|
for _, udf_attr in ipairs(UDF_ATTRS) do
|
pac_detail[udf_attr] = cell_list[n].sku[udf_attr]
|
end
|
|
nRet, pac_detail = m3.CreateDataObj2(strLuaDEID, pac_detail)
|
if (nRet ~= 0 ) then return 1, "创建【预分配容器明细】失败!"..pac_detail end
|
|
table.insert( pac_detail_list, pac_detail )
|
end
|
return 0
|
end
|
|
-- 从数据对象(字段)中获取 attrs_array 中的属性值
|
local function get_data_object_attr_value( object_data, attrs_array )
|
local attr_value = {}
|
local key_value = ''
|
local value
|
|
for _, attr in ipairs( attrs_array ) do
|
value = object_data[attr] or ''
|
key_value = key_value..attr.."='"..value.."';"
|
attr_value[attr] = value
|
end
|
return lua.trim_laster_char( key_value ), attr_value
|
end
|
|
--[[
|
把 item_list 根据容器类型定义 ctd 中的混箱规则，把相同混箱规则的 item 分组，生成 split_item_list
|
ctd.mixing_attrs_def = {
|
{attr = "S_BATCH_NO", type = "string"},
|
..
|
}
|
ctd.mixing_attrs = {"S_BATCH_NO",...}
|
|
split_item_list = {
|
mixing_attr_value = {S_BATCH_NO="xxx",S_X="xxx"},
|
mixing_key = "S_BATCH_NO='xx';S_STATE='xx'"
|
item_list = {
|
{S_ITEM_CODE = "X1",...},
|
}
|
}
|
--]]
|
local function split_item_list_by_mixing_rule( ctd, item_list, split_item_list )
|
local mixing_attr_value = {}
|
local find, mixing_key
|
|
if lua.isTableEmpty( ctd.mixing_attrs ) then
|
return 1, "容器类型定义'"..ctd.ctd_code.."'中的混箱规则不能为空!"
|
end
|
for _, item in ipairs( item_list ) do
|
mixing_key, mixing_attr_value = get_data_object_attr_value( item, ctd.mixing_attrs )
|
find = false
|
for _, split_item in ipairs( split_item_list ) do
|
if split_item.mixing_key == mixing_key then
|
find = true
|
table.insert( split_item.item_list, item )
|
break
|
end
|
end
|
if not find then
|
local split_item = {
|
mixing_attr_value = mixing_attr_value,
|
mixing_key = mixing_key,
|
item_list = {}
|
}
|
table.insert( split_item.item_list, item )
|
table.insert( split_item_list, split_item )
|
end
|
end
|
return 0
|
end
|
|
--[[
|
预分配料箱，物料预先指定存储料格及料格中最大存储数量，或重量
|
如果货品
|
Designated Material Grid -- 简称 DMG 意思是每个货品都指定了一种料格进行存储
|
特点:
|
一种货品保存在一种类型的料格
|
料格中货品最大存储数量计算方法有两种， 1 -- 系统设置最大储藏数量 2 -- 系统设置重量后根据料格载重进行计算
|
在匹配料箱时，一个料箱只能用相同的数量计算方法
|
|
来源项目: 艾默生料箱库
|
|
输入参数:
|
pac_cfg -- 预分配料箱配置参数
|
{
|
handling_model -- 搬运模式 AGV;PickingAGV;AS/RS
|
factory 工厂标识
|
wh_code, area_code 仓库，库区编码
|
station 站台
|
bs_type 来源类型：入库单、入库波次
|
bs_no 来源单号
|
aisle 可用巷道 {"A01","A02",...}
|
cntr_out_op_def = "料箱出库", --空料箱出库的作业定义
|
cntr_back_op_def = "货品入库" --料箱回库的主业定义
|
empty_cntr_out_rule = "xxx" --空料箱呼出策略
|
}
|
|
---- 下面两个参数是系统运算后的结果返回 ----
|
pac_list -- Pre_Alloc_Container 对象列表
|
pac_detail_list Pre_Alloc_CNTR_Detail 列表
|
--]]
|
function wms_pac.Pre_Alloc_Cntr( strLuaDEID, pac_cfg, pac_list, pac_detail_list )
|
local nRet, strRetInfo, n
|
|
lua.DebugEx( strLuaDEID, "In Pre_Alloc_Cntr", "OK")
|
lua.DebugEx( strLuaDEID, "pac_cfg --> ", pac_cfg )
|
|
-- step1: 输入参数合法性检查
|
local ctd_list
|
nRet, ctd_list = wms_pac.Get_ItemList_GroupBy_CntrType( strLuaDEID, pac_cfg )
|
if ( nRet ~= 0 ) then
|
return 1, ctd_list
|
end
|
|
-- 如果有输入‘空料箱呼出策略’ 需要从系统获取该策略
|
if not lua.StrIsEmpty( pac_cfg.empty_cntr_out_rule ) then
|
local strategy = {}
|
nRet, strategy = wms_base.GetStrategyInfo( "EmptyCntrOut_Strategy", pac_cfg.empty_cntr_out_rule )
|
if nRet ~= 0 then
|
return 1, "在获取'空料箱呼出策略'时失败! "..strategy
|
end
|
pac_cfg.empty_cntr_out_rule = strategy
|
end
|
|
local area_code = pac_cfg.area_code or ''
|
local station = pac_cfg.station or ''
|
|
|
-- 根据容器类型进行料箱预分配
|
local si_match_attrs, str_val
|
local count_method
|
|
local supplement_cntr_list = {}
|
local out_cntr_list = {}
|
|
for n = 1, #ctd_list do
|
-- 通过容器类型定义设置 料箱呼出规则
|
nRet, pac_cfg.ctd = wms_cntr.GetCTDInfo( ctd_list[n].ctd_code )
|
if ( nRet ~= 0 ) then
|
return 1, "容器类型定义'"..ctd_list[n].ctd_code.."'转换数据格式! --> "..pac_cfg.ctd
|
end
|
|
-- 入库货品初始化
|
for _, item in ipairs( ctd_list[n].item_list ) do
|
if ( lua.StrIsEmpty( item.S_CELL_TYPE ) ) then
|
return 1, "编码'"..item.S_ITEM_CODE.."'的 SKU 没有定义料格类型/S_CELL_TYPE"
|
end
|
count_method = lua.Get_StrAttrValue( item.S_COUNT_METHOD )
|
if ( count_method ~= "Volume" and count_method ~= "Weight" and count_method ~= "Limit" ) then
|
return 1, "编码'"..item.S_ITEM_CODE.."'的 SKU 定义的料格计算货品容量的方法不符合 DMG 算法的要求!"
|
end
|
if ( count_method == "Volume" ) then
|
if ( item.volume <= 0 ) then
|
return 1, "编码'"..item.S_ITEM_CODE.."'的 SKU 定义的料格计数方法是根据体积计算，没有设置SKU的体积!"
|
end
|
elseif ( count_method == "Weight" ) then
|
if ( item.weight <= 0 ) then
|
return 1, "编码'"..item.S_ITEM_CODE.."'的 SKU 定义的料格计数方法是根据重量计算，没有设置SKU的重量!"
|
end
|
end
|
item.mixing_rule = {}
|
if ( pac_cfg.ctd.have_mixing_rule ) then
|
-- 获取 SKU 的混箱属性
|
for _, attr in ipairs( pac_cfg.ctd.mixing_attrs ) do
|
item.mixing_rule[attr] = lua.Get_StrAttrValue( item[attr])
|
end
|
end
|
end
|
|
-- 对pac_cfg中的入库作业定义进行处理，获取入库作业的上架策略，通过这个策略去查找空料箱
|
if ( pac_cfg.ctd.ecda_rule == "Flex match" ) then
|
-- 灵活匹配可以匹配多种类型料格
|
|
-- 需要进一步对入库货品进行分类（根据混箱规则，比如相同产品线）
|
if pac_cfg.ctd.have_mixing_rule then
|
-- 根据混箱规则对入库货品明细进行分割，相同混箱规则的放一起，加入 split_item_list
|
-- split_item_list = {{"mixing_value":{S_UDF01="PRD-01"}, item_list:{}},...}
|
local split_item_list = {}
|
nRet, strRetInfo = split_item_list_by_mixing_rule( pac_cfg.ctd, ctd_list[n].item_list, split_item_list )
|
if nRet ~= 0 then
|
return 1, strRetInfo
|
end
|
-- 分别对有相同混箱规则的货品进行 容器预分配
|
for _, split_item in ipairs( split_item_list ) do
|
local s_cntr_list = {}
|
local o_cntr_list = {}
|
pac_cfg.mixing_attr_value = split_item.mixing_attr_value
|
nRet, s_cntr_list, o_cntr_list = wms_pac.Pre_Alloc_Cntr_CBG( strLuaDEID, pac_cfg, split_item.item_list )
|
if ( nRet ~= 0 ) then
|
return nRet, s_cntr_list
|
end
|
lua.table_merge( supplement_cntr_list, s_cntr_list )
|
lua.table_merge( out_cntr_list, o_cntr_list )
|
end
|
|
else
|
nRet, supplement_cntr_list, out_cntr_list = wms_pac.Pre_Alloc_Cntr_CBG( strLuaDEID, pac_cfg, ctd_list[n].item_list )
|
if ( nRet ~= 0 ) then
|
return nRet, supplement_cntr_list
|
end
|
end
|
elseif ( pac_cfg.ctd.ecda_rule == "SDM Grid" ) then
|
-- 用于标识特定区域必须使用单一指定材料
|
nRet, supplement_cntr_list, out_cntr_list = wms_pac.Pre_Alloc_Cntr_DMG( strLuaDEID, pac_cfg, ctd_list[n].item_list )
|
if ( nRet ~= 0 ) then
|
return nRet, supplement_cntr_list
|
end
|
else
|
return 1, "系统不支持名为'"..pac_cfg.ctd.ecda_rule.."'的料箱呼出规则!"
|
end
|
|
-- step9 创建 预分配容器
|
-- 20241108 HAN 补料呼出的料箱和空料箱呼出的如果料箱号是一样的需要合并一下，合并在补料箱列表
|
-- 如果呼出的有补料和空料箱的时候要检查
|
for n = 1, #supplement_cntr_list do
|
for m = 1, #out_cntr_list do
|
if (supplement_cntr_list[n].cntr_code == out_cntr_list[m].cntr_code) then
|
for i = 1, #out_cntr_list[m].cell_list do
|
table.insert( supplement_cntr_list[n].cell_list, out_cntr_list[m].cell_list[i])
|
remove_empty_cell( supplement_cntr_list[n], out_cntr_list[m].cell_list[i].cell_no )
|
end
|
out_cntr_list[m].cell_list = {}
|
end
|
end
|
end
|
|
-- 生成 【Pre_Alloc_Container】【Pre_Alloc_CNTR_Detail】
|
local cell_list
|
for n = 1, #supplement_cntr_list do
|
cell_list = supplement_cntr_list[n].cell_list
|
if ( #cell_list > 0 ) then
|
nRet, strRetInfo = generate_pac_detail( strLuaDEID, pac_cfg, supplement_cntr_list[n].cntr_code, 'Y',
|
cell_list, pac_list, pac_detail_list )
|
if ( nRet ~= 0 ) then
|
return 2, "补料 generate_pac_detail 发生错误! "..strRetInfo
|
end
|
end
|
end
|
|
for n = 1, #out_cntr_list do
|
cell_list = out_cntr_list[n].cell_list
|
if ( #cell_list > 0 ) then
|
nRet, strRetInfo = generate_pac_detail( strLuaDEID, pac_cfg, out_cntr_list[n].cntr_code, 'N',
|
cell_list, pac_list, pac_detail_list )
|
if ( nRet ~= 0 ) then
|
return 2, "呼出空料箱 generate_pac_detail 发生错误! "..strRetInfo
|
end
|
end
|
end
|
end
|
|
-- 设置入库单业务状态为 PreAlloc_OK/预分配完成（ps:入库需要的料箱已经确定）
|
local strUpdateSql
|
local strCondition
|
if ( pac_cfg.bs_type == "Inbound_Order" ) then
|
strUpdateSql = "N_B_STATE = "..INBOUND_STATE.PreAlloc_OK
|
strCondition = "S_NO = '"..pac_cfg.bs_no.."'"
|
nRet, strRetInfo = mobox.updateDataAttrByCondition( strLuaDEID, "Inbound_Order", strCondition, strUpdateSql )
|
if ( nRet ~= 0 ) then
|
return 2, "更新【入库单】信息失败!"..strRetInfo
|
end
|
elseif ( pac_cfg.bs_type == "Inbound_Wave" ) then
|
strUpdateSql = "N_B_STATE = "..IN_WAVE_STATE.PreAlloc_OK
|
strCondition = "S_WAVE_NO = '"..pac_cfg.bs_no.."'"
|
nRet, strRetInfo = mobox.updateDataAttrByCondition( strLuaDEID, "Inbound_Wave", strCondition, strUpdateSql )
|
if ( nRet ~= 0 ) then
|
return 2, "更新【入库波次】信息失败!"..strRetInfo
|
end
|
end
|
return 0
|
end
|
|
--[[
|
预分配容器 回库 后表示一个入库的任务完成，需要判断一下入库单是否可以完成
|
--]]
|
|
function wms_pac.After_PAC_Finish( strLuaDEID, pac_no )
|
local nRet, strRetInfo
|
|
if ( pac_no == nil or pac_no == '' ) then
|
return 1, "wms_pac.After_PAC_Finish 函数中 pac_no 必须有值!"
|
end
|
|
-- 获取 Pre_Alloc_CNTR_Detail
|
local strOrder = ''
|
local strCondition = "S_PAC_NO = '"..pac_no.."'"
|
|
nRet, strRetInfo = mobox.queryDataObjAttr( strLuaDEID, "Pre_Alloc_CNTR_Detail", strCondition, strOrder )
|
if ( nRet ~= 0 ) then return 1, "获取【预分配容器明细】失败! "..strRetInfo end
|
if ( strRetInfo == '' ) then
|
return 0
|
end
|
|
local retObjs = json.decode( strRetInfo )
|
local n
|
local pac_detail = {}
|
|
for n = 1, #retObjs do
|
nRet, pac_detail = m3.ObjAttrStrToLuaObj( "Pre_Alloc_CNTR_Detail", lua.table2str(retObjs[n].attrs) )
|
if ( nRet ~= 0 ) then return 1, "m3.ObjAttrStrToLuaObj(Pre_Alloc_CNTR_Detail) 失败! "..pac_detail end
|
-- 根据业务来源加 F_ACC_I_QTY/累计入库数量
|
if ( pac_detail.bs_type == "Inbound_Order" ) then
|
if ( pac_detail.bs_no ~= nil and pac_detail.bs_no ~= '' ) then
|
strCondition = "S_IO_NO = '"..pac_detail.bs_no.."' AND S_ITEM_CODE = '"..pac_detail.item_code.."'"
|
local strSetAttr = "F_ACC_I_QTY = F_ACC_I_QTY +"..pac_detail.act_qty
|
if ( lua.equation( 0, pac_detail.cancel_qty ) == false ) then
|
strSetAttr = strSetAttr..", F_ACC_C_QTY = F_ACC_C_QTY + "..pac_detail.cancel_qty
|
end
|
nRet, strRetInfo = mobox.updateDataAttrByCondition(strLuaDEID, "Inbound_Detail", strCondition, strSetAttr )
|
if (nRet ~= 0) then return 1, "设置【Inbound_Detail】累计入库数量失败!"..strRetInfo end
|
end
|
end
|
if ( pac_detail.bs_type == 'Inbound_Wave' ) then
|
if ( pac_detail.bs_no ~= nil and pac_detail.bs_no ~= '' ) then
|
strCondition = "S_WAVE_NO = '"..pac_detail.bs_no.."' AND S_ITEM_CODE = '"..pac_detail.item_code.."'"
|
local strSetAttr = "F_ACC_I_QTY = F_ACC_I_QTY +"..pac_detail.act_qty
|
if ( lua.equation( 0, pac_detail.cancel_qty ) == false ) then
|
strSetAttr = strSetAttr..", F_ACC_C_QTY = F_ACC_C_QTY + "..pac_detail.cancel_qty
|
end
|
nRet, strRetInfo = mobox.updateDataAttrByCondition(strLuaDEID, "IW_Detail", strCondition, strSetAttr )
|
if (nRet ~= 0) then return 1, "设置【IW_Detail】累计入库数量失败!"..strRetInfo end
|
end
|
end
|
end
|
return 0
|
end
|
|
return wms_pac
|
