liufumingren b2fed22caa refactor: 扫码查单优先外部WMS,兜底老系统方法
- scan 查单顺序改为:优先 newWms.queryOrder,未命中再兜底老系统 getOrderInfo
- 外部WMS命中走 _packWmsOrder 回传,老系统命中走 _packOrder 本地打包
- 更新日志文案以区分订单来源
2026-08-29 23:25:22 +08:00

535 lines
25 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

const Service = require('egg').Service;
const { v4: uuidv4 } = require('uuid');
const axios = require('axios');
const fs = require('fs');
class Gzt extends Service {
async index(){
let task = await this.app.mysql.get('dblocal').query(`select * from ye4s_warehouse`);
return task;
}
async getBindCode(sid){
const {ctx} = this;
let ssid = ctx.socket.id;
if(sid){
ssid = sid;
}
// 删除该 socket 之前绑定的旧 bindcode,防止同一个 socket 不断重连产生大量冗余 key
// 用 try-catch 包裹,避免 Redis 异常导致 WebSocket 连接崩溃
try {
const oldCode = await this.app.redis.get('cache').get(`socket_bindcode_${ssid}`);
if(oldCode){
await this.app.redis.get('cache').del(`bindcode_${oldCode}`);
}
} catch (e) {
// Redis 清理失败不影响主流程
}
let code = uuidv4();
// 正向映射:bindcode → socketId
this.app.redis.get("cache").set(`bindcode_${code}`,ssid,'EX',200);
// 反向映射:socketId → bindcode,用于下次重连时清理旧 key
this.app.redis.get('cache').set(`socket_bindcode_${ssid}`,code,'EX',200);
return `https://ye4s.wms.gztbyc.com/qrcode/build?text=${code}&label=&logo=0&labelalignment=center&foreground=%23000000&background=%23ffffff&size=300&padding=10&logosize=50&labelfontsize=14&errorcorrection=medium`;
}
async startRecording(gztid,grabnum){
let apiUrl = "http://file2.gztbyc.com/startRecording";
const params = new URLSearchParams();
params.append('id', gztid);
params.append('code', grabnum);
try {
const response = await axios.post(apiUrl, params, {
headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
});
return response.data;
} catch (error) {
//console.log("error",error);
return error;
}
}
async getBindInfo(code){
const {ctx} = this;
const sid = ctx.socket.id;
let results = {};
let gzt = await this.getGztByCode(code);
if(!gzt){
return {};
}
await this.app.redis.get('cache').set(`gzt_${gzt.id}`,sid);
gzt.user = await this.getUser(gzt.workers_ids);
gzt.work = await this.getWork(gzt.work_id);
if(gzt.user){
this.todayCount(sid,gzt.user.id,gzt.wareHouseId);
}
this.scanLogger(sid,gzt.id,gzt.wareHouseId);
return gzt;
}
async todayCount(sid,userid,WAREHOUSEID){
if(!userid){
return false;
}
let WAREHOUSE = await this.app.mysql.get('dblocal').get('ye4s_warehouse',{WAREHOUSEID:WAREHOUSEID});
let workDate = WAREHOUSE.workDate;
const counts = await this.app.mysql.get('dblocal').query(
`select COALESCE(SUM(dabaos), 0) as orderCount,COALESCE(SUM(GOODSCOUNT), 0) as GOODSCOUNT from ye4s_workers_works where WAREHOUSEID=? and userId=? and workDate=?`,
[WAREHOUSEID, userid, workDate]
);
const todayCountData = {
orderCount:parseInt(counts[0].orderCount),
GOODSCOUNT:parseInt(counts[0].GOODSCOUNT)
}
this._push(sid, 'todayCount', todayCountData);
}
async getMyWork(sid,userid,WAREHOUSEID){
const lastOrder = await this.app.mysql.get('dblocal').get('ye4s_workers_works', {
userId: userid,
dabaos: 1,
WAREHOUSEID:WAREHOUSEID
}, {
orders: [['createtime', 'desc']], // 按 createtime 降序排序
limit: 1, // 限制只获取一行数据
});
let order = await this.app.mysql.get('dbwms').get(`yj_wmsorder`,{POSTNUM:lastOrder.POSTNUM});
const pack = await this.app.mysql.get('dbwms').get(`yj_pack`,{ID:order.PACKID,WAREHOUSEID:WAREHOUSEID});
order.PACKNAME = pack?pack.NAME:"";
order.items = order.ITEMS.split("|").filter(item => item !== undefined && item !== null && item !== '').map(item=>{
let tmp_item = item.split(",");
return [tmp_item[2]+tmp_item[3],tmp_item[1]];
});
this._push(sid, 'order', order);
}
async scan2(barcode,gztid){
await this.appendToFile(`${barcode},${gztid}`);
return 1;
}
async appendToFile(contentToAppend) {
const filePath = `app/public/scan_logs.txt`;
// 追加内容到文件
fs.appendFile(filePath, contentToAppend+"\n", (err) => {
if (err) {
//console.error('Error appending to file:', err);
return;
}
//console.log('Content was appended to file successfully.');
});
}
async scan(barcode,gztid){
const {ctx} = this;
ctx.logger.info(`[scan] 开始处理 | barcode=${barcode} | gztid=${gztid}`);
const sid = await this.app.redis.get('cache').get(`gzt_${gztid}`);
const gzt = await this.getGztInfo(gztid);
if(!gzt){
ctx.logger.warn(`[scan] 工作台不存在 | gztid=${gztid}`);
return 0;
}
ctx.logger.info(`[scan] 工作台信息 | gztid=${gztid} | WAREHOUSEID=${gzt.WAREHOUSEID} | userid=${gzt.userid} | wms_order_ids=${gzt.wms_order_ids}`);
console.log("gzt",gzt);
let logininfo = "";
try {
const tmp = JSON.parse(atob(barcode));
if(tmp.uuid){
ctx.logger.info(`[scan] 识别为工牌 | uuid=${tmp.uuid}`);
const user = await this.getUserIdByUUid(barcode);
//console.log(user);
if(user){
ctx.logger.info(`[scan] 工牌用户有效 | userId=${user.id} | 当前工作台用户=${gzt.userid}`);
this.scanLogger(sid,gztid,5400,"工牌");
if(gzt.userid==user.id){
//登出
this._push(sid, 'logout', user);
//打包完成
if(gzt.work_id){
await this.app.mysql.get('dblocal').update("ye4s_workers_works",{updatetime:Math.round(new Date() / 1000)},{where:{id:gzt.work_id}});
this.stopVideo(gzt);
}
// 登出时发送结束打包任务(通知外部WMS)
await this._finishPack({
workbench_id: gzt.other_id || gztid,
warehouse_id: gzt.WAREHOUSEID,
});
await this.app.mysql.get('dblocal').update("ye4s_gzt",{workers_ids:null,work_id:null},{where:{id:gztid}});
}else{
//其他工作台登出
const other_gzt = await this.app.mysql.get('dblocal').get("ye4s_gzt",{workers_ids:user.id.toString(),type:2});
if(other_gzt){
if(other_gzt.work_id){
await this.app.mysql.get('dblocal').update("ye4s_workers_works",{updatetime:Math.round(new Date() / 1000)},{where:{id:other_gzt.work_id}});
this.stopVideo(other_gzt);
}
await this.app.mysql.get('dblocal').update("ye4s_gzt",{workers_ids:null,work_id:null},{where:{id:other_gzt.id}});
const other_sid = await this.app.redis.get('cache').get(`gzt_${other_gzt.id}`);
if(other_sid){
this._push(other_sid, 'logout', user);
}
}
//登入
await this.app.mysql.get('dblocal').update("ye4s_gzt",{workers_ids:user.id},{where:{id:gztid}});
//登入通知工作台
if(sid){
this._push(sid, 'login', user);
}
this.todayCount(sid,user.id,gzt.WAREHOUSEID);
}
}else{
throw new Error("无用户");
}
}else{
throw new Error("非工牌");
}
} catch (e) {
ctx.logger.info(`[scan] 非工牌,进入订单/包材判断 | barcode=${barcode}`);
// 非工牌,判断是包材还是订单
const pack = await this.app.redis.get("cache").get(`pack_${barcode}`);
if (pack) {
ctx.logger.info(`[scan] 识别为包材 | barcode=${barcode} | wms_order_ids=${gzt.wms_order_ids}`);
if (!gzt.wms_order_ids) {
ctx.logger.info(`[scan] 包材-无打包订单,拒绝 | barcode=${barcode}`);
this._push(sid, 'msg', '当前无打包订单,不需要扫描包材');
} else {
ctx.logger.info(`[scan] 包材-绑定打包 | barcode=${barcode}`);
this.bindPack();
}
} else {
ctx.logger.info(`[scan] 非包材,查询订单 | barcode=${barcode} | WAREHOUSEID=${gzt.WAREHOUSEID}`);
// 优先查询外部WMS → 兜底老系统方法 → 无记录
let order = null;
let isWmsOrder = false;
const wmsResult = await this.ctx.service.newWms.queryOrder(barcode, gzt.WAREHOUSEID);
if (wmsResult && wmsResult.success) {
ctx.logger.info(`[scan] 外部WMS订单命中 | barcode=${barcode}`);
order = wmsResult.data;
isWmsOrder = true;
} else {
ctx.logger.info(`[scan] 外部WMS未命中,查询老系统 | barcode=${barcode}`);
order = await this.getOrderInfo(barcode.replace(/-1-1-/g, ''), gzt.WAREHOUSEID);
if (order) {
ctx.logger.info(`[scan] 老系统订单命中 | barcode=${barcode} | PLSENDFLAG=${order.PLSENDFLAG}`);
} else {
ctx.logger.info(`[scan] 老系统也未找到 | barcode=${barcode}`);
}
}
if (order) {
if (!gzt.userid) {
ctx.logger.info(`[scan] 订单-未登录,拒绝打包 | barcode=${barcode}`);
this._push(sid, 'msg', '请先扫描工号登陆');
} else if (isWmsOrder) {
ctx.logger.info(`[scan] 订单-外部WMS打包 | barcode=${barcode}`);
// 外部WMS订单:回传打包状态到外部
await this._packWmsOrder(gzt, order, sid);
} else if (order.FLAG != 0 || order.ISLOCK == 1) {
ctx.logger.info(`[scan] 订单-已拦截/取消,拒绝打包 | barcode=${barcode} | FLAG=${order.FLAG} | ISLOCK=${order.ISLOCK}`);
this._push(sid, 'msg', '订单拦截');
} else if (order.PLSENDFLAG === 0) {
ctx.logger.info(`[scan] 订单-未复核,拒绝打包 | barcode=${barcode} | PLSENDFLAG=${order.PLSENDFLAG}`);
this._push(sid, 'msg', '订单未复核');
} else {
ctx.logger.info(`[scan] 订单-本地打包 | barcode=${barcode} | grabnum=${order.grabnum}`);
await this._packOrder(gzt, order, sid);
}
} else {
ctx.logger.info(`[scan] 无记录 | barcode=${barcode}`);
this._push(sid, 'msg', '无记录');
}
}
this.scanLogger(sid, gztid, 5400, barcode);
ctx.logger.info(`[scan] 处理完成 | barcode=${barcode}`);
}
return 1;
}
// 本地订单打包处理
async _packOrder(gzt, order, sid) {
const { ctx } = this;
const lastTime = Math.round(new Date() / 1000) - 864000;
const dupField = order.isSandan == 1 ? 'POSTNUM' : 'grabnum';
const dupValue = order.isSandan == 1 ? order.POSTNUM : order.grabnum;
const line = await this.app.mysql.get('dblocal').query(
`select id from ye4s_workers_works where ${dupField}=? and dabaos>0 and createtime>?`,
[dupValue, lastTime]
);
if (line.length > 0) {
const Name = order.isSandan == 1 ? order.POSTNUM : order.grabnum;
this._push(sid, 'msg', `${Name}已打包`);
return;
}
try {
order.userId = gzt.userid;
order.gztid = gzt.gztid;
delete order.PLSENDFLAG;
const row = await this.app.mysql.get('dblocal').insert("ye4s_workers_works", order);
const packorder = await this.getWork(row.insertId);
this._push(sid, 'order', packorder);
if (sid) {
this.todayCount(sid, gzt.userid, gzt.WAREHOUSEID);
}
const record_res = await this.startRecording(gzt.gztid, order.isSandan == 1 ? order.POSTNUM : order.grabnum);
await this.app.mysql.get('dblocal').update("ye4s_workers_works", { updatetime: Math.round(new Date() / 1000) }, { where: { id: gzt.work_id } });
await this.app.mysql.get('dblocal').update("ye4s_gzt", { work_id: row.insertId, info: JSON.stringify(record_res) }, { where: { id: gzt.gztid } });
ctx.app.wsdl('addOperate', [gzt.WAREHOUSEID, order.isSandan == 1 ? order.POSTNUM : order.grabnum, gzt.wmsusername, `${gzt.user_real_name}/打包`]);
// 本地订单打包完成后,通知外部WMS结束任务
try {
await ctx.service.newWms.finishPack({
workbench_id: gzt.other_id || gzt.gztid,
warehouse_id: gzt.WAREHOUSEID,
});
ctx.logger.info(`[_packOrder] 通知外部WMS结束任务成功 | workbench_id=${gzt.other_id || gzt.gztid}`);
} catch (e) {
ctx.logger.error('[_packOrder] 通知外部WMS结束任务失败:', e.message);
}
} catch (e) {
console.error("打包错误", e);
}
}
// 外部WMS订单打包处理(仅回传给外部WMS,不写入本地DB)
async _packWmsOrder(gzt, order, sid) {
const { ctx } = this;
try {
// 外部WMS订单:判断是否已拦截/取消、是否已打包,做相应通知处理
const check = this.ctx.service.newWms.checkOrderStatus(order);
if (check.intercepted) {
ctx.logger.info(`[scan] 外部WMS订单已拦截/取消,拒绝打包 | POSTNUM=${order.POSTNUM} | status=${order.status} | intercept_flag=${order.intercept_flag}`);
this._push(sid, 'msg', '订单拦截');
return;
}
if (check.packed) {
ctx.logger.info(`[scan] 外部WMS订单已打包,跳过回传 | POSTNUM=${order.POSTNUM} | pack_flag=${order.pack_flag} | pack_status=${order.pack_status}`);
this._push(sid, 'msg', '订单已打包');
return;
}
// 设置工作台ID,使用 gzt 表的 other_id
order.gztid = gzt.other_id || '';
// 查询完整用户信息
const packUser = await this.getUser(gzt.userid);
order.users = packUser && packUser.id ? [packUser] : [];
// 回传给外部WMS
const reportResult = await this.ctx.service.newWms.reportPackStatus(order);
if (!reportResult || reportResult.flag !== 'success') {
ctx.logger.warn(`[scan] 外部WMS回传失败 | POSTNUM=${order.POSTNUM} | result=`, reportResult);
this._push(sid, 'msg', '外部WMS回传失败');
return;
}
// 推送前端(对齐原系统字段格式)
this._push(sid, 'order', {
grabnum: order.grabnum,
POSTNUM: order.POSTNUM,
items: order.items,
dabaos: order.dabaos,
wms_order_ids: String(order.wms_order_ids || ''),
PACKNAME: order.PACKNAME,
GOODSCOUNT: order.GOODSCOUNT,
gztid: order.gztid,
users: order.users,
});
if (sid) {
this.todayCount(sid, gzt.userid, gzt.WAREHOUSEID);
}
ctx.app.wsdl('addOperate', [gzt.WAREHOUSEID, order.grabnum, gzt.wmsusername, `${gzt.user_real_name}/打包`]);
} catch (e) {
ctx.logger.error('[scan] WMS打包错误:', e);
console.error("WMS打包错误", e);
}
}
// 结束打包任务:直接关闭该工作台最后一个未结束任务(不限订单)
// 与 _packOrder 的差异:_packOrder 是在新任务到来时关闭其他订单的旧任务;
// _finishPack 是直接关闭该工作台最后一个未结束任务
async _finishPack({ workbench_id, warehouse_id }) {
const { ctx } = this;
if (!workbench_id) {
ctx.logger.warn('[_finishPack] workbench_id 不能为空');
return { finished: false, message: 'workbench_id 不能为空' };
}
if (!warehouse_id) {
ctx.logger.warn('[_finishPack] warehouse_id 不能为空');
return { finished: false, message: 'warehouse_id 不能为空' };
}
// 查询该工作台下最新的打包任务(不限订单类型,不限是否WMS)
const lastTask = await this.app.mysql.get('dblocal').query(
`select id, grabnum, wms_order_ids, POSTNUM, createtime, types, dabaos from ye4s_workers_works
where gztid=? and WAREHOUSEID=? and dabaos>0
order by id desc limit 1`,
[workbench_id, warehouse_id]
);
const end_time = Math.round(new Date() / 1000);
// 始终通知外部WMS结束打包任务(即使本地无记录,外部WMS可能有自己的任务追踪)
try {
const wmsResult = await ctx.service.newWms.finishPack({
workbench_id,
warehouse_id,
});
ctx.logger.info(`[_finishPack] 外部WMS结束任务返回:`, JSON.stringify(wmsResult));
} catch (e) {
ctx.logger.error('[_finishPack] 调用外部WMS结束任务异常:', e.message);
}
if (!lastTask || lastTask.length === 0) {
ctx.logger.info(`[_finishPack] 本地无未结束的打包任务 | workbench_id=${workbench_id}`);
return { finished: false, message: '无未结束的打包任务' };
}
const task = lastTask[0];
ctx.logger.info(`[_finishPack] 结束本地打包任务 | task_id=${task.id} | POSTNUM=${task.POSTNUM} | types=${task.types} | workbench_id=${workbench_id}`);
return {
finished: true,
task_id: task.id,
order_id: task.wms_order_ids || task.POSTNUM,
end_time,
};
}
async bindPack(){
}
async startOrder(sid,gzt,WAREHOUSEID,orders){
//开始打包
//记录数据库
//开启打包视频
//推送信息到前端
}
async stopVideo(gzt){
//结束打包视频
}
async getUser(userId){
if(!userId){
return {};
}
let user_results = await this.app.mysql.get('dblocal').select(`ye4s_user`,{where:{id:userId},columns:['id','wms_account_id','real_name']});
return user_results?user_results[0]:{};
}
async getWork(work_id){
if(!work_id){
return {};
}
const work = await this.app.mysql.get("dblocal").select("ye4s_workers_works",{where:{id:work_id},columns:['grabnum','POSTNUM','items','dabaos','wms_order_ids','PACKNAME','GOODSCOUNT'],limit:1});
let work_tmp = work.length>0?work[0]:{};
if(work_tmp.items){
work_tmp.items = work_tmp.items.split("|").filter(item1 => item1.trim()).map(item=>{
return item.split(",");
});
}
return work_tmp;
}
async getOrderInfo(postNumer,WAREHOUSEID){
let datas = await this.app.redis.get("post_order_cache").get(`order:${WAREHOUSEID}:${postNumer}`);
if(!datas){
datas = await this.getOrderInfoBySql(postNumer,WAREHOUSEID);
let datas_tmp = JSON.stringify(datas);
await this.app.redis.get("post_order_cache").set(`order:${WAREHOUSEID}:${postNumer}`,datas_tmp,'EX',60*60*6);
}else{
datas = JSON.parse(datas);
}
return datas;
}
async getOrderInfoBySql(postNumer,WAREHOUSEID){
const order_tmp = await this.app.mysql.get('dbwms').query(
`select order1.ID as ID,GRABNUM,POSTNUM,pack.NAME as PACKNAME,PLSENDFLAG,ITEMS,order1.FLAG as FLAG,order1.ISLOCK as ISLOCK from yj_wmsorder order1 left join yj_pack pack on pack.ID=order1.PACKID where order1.POSTNUM=? and order1.WAREHOUSEID=?`,
[postNumer, WAREHOUSEID]
);
const order = order_tmp?order_tmp[0]:null;
if(!order){
return null;
}
const WAREHOUSE = await this.app.mysql.get('dblocal').get('ye4s_warehouse',{WAREHOUSEID:WAREHOUSEID});
const items_counts = order.ITEMS.split("|").map(item=>{
let count = 0;
try {
count = parseInt(item.split(',')[1])?parseInt(item.split(',')[1]):0;
} catch (e) {
count = 0;
}
return count;
})
let item_count=0;
items_counts.forEach(item=>{
item_count+=item;
})
let datas = {
dabaos:1,
workDate:WAREHOUSE.workDate,
userId:0,
types:3,
count:1,
grabnum:order.GRABNUM,
POSTNUM:postNumer,
WAREHOUSEID:WAREHOUSEID,
createtime:Math.round(new Date() / 1000),
workers:'',
GOODSCOUNT:item_count,
items:order.ITEMS,
orders:[order.POSTNUM].join(','),
wms_order_ids:[order.ID].join(','),
PACKNAME:order.PACKNAME,
isSandan:1,
PLSENDFLAG:order.PLSENDFLAG,
FLAG:order.FLAG,
ISLOCK:order.ISLOCK
}
if(order.GRABNUM.indexOf('B')>-1){
//团购
const orders = await this.app.mysql.get('dbwms').select("yj_wmsorder",{where:{GRABNUM:order.GRABNUM}});
datas.dabaos = orders.length;
datas.count = orders.length;
datas.orders = orders.map(item=>{
return item.POSTNUM;
}).join(',');
datas.wms_order_ids = orders.map(item=>{
return item.ID;
}).join(',');
datas.GOODSCOUNT *= orders.length;
datas.isSandan = 0;
return datas;
}else{
//散单
return datas;
}
}
async getGztByCode(tmp_code){
const results = await this.app.mysql.get('dblocal').select(`ye4s_gzt`,{where:{tmp_code:tmp_code},columns:['name','workers_ids','id','wareHouseId','work_id','sandanType','other_id'],limit:1});
return results?results[0]:null;
}
async getGztInfo(gztid){
const gzt = await this.app.mysql.get('dblocal').query(
`select gzt.wareHouseId as WAREHOUSEID,gzt.name as name,gzt.username as wmsusername,gzt.sandanType as sandanType,gzt.id as gztid,gzt.other_id as other_id,works.grabnum as grabnum,works.POSTNUM,works.items,works.dabaos,works.wms_order_ids,user.id as userid,user.real_name as user_real_name,gzt.work_id as work_id from ye4s_gzt gzt left join ye4s_workers_works works on works.id=gzt.work_id left join ye4s_user user on user.id=gzt.workers_ids where gzt.id=?`,
[gztid]
);
return gzt?gzt[0]:null;
}
async getUserIdByUUid(uuid){
const user = await this.app.mysql.get('dblocal').get("ye4s_user",{tmp_code:uuid});
return user?user:null;
}
async scanLogger(sid,gzt_id,WAREHOUSEID,code=null){
if(code){
await this.app.mysql.get('dblocal').insert('ye4s_scan_logger',{code:code,gztid:gzt_id,createTime:Math.round(new Date() / 1000),WAREHOUSEID:WAREHOUSEID});
}
const lastOrder = await this.app.mysql.get('dblocal').select('ye4s_scan_logger',{
where:{
gztid: gzt_id,
WAREHOUSEID:WAREHOUSEID
},
columns:['code'],
orders: [['createtime', 'desc']], // 按 createtime 降序排序
limit: 10, // 限制只获取一行数据
});
this._push(sid, 'scanLogger', lastOrder);
}
async order(sid,userid,WAREHOUSEID){
let msg = "扫描成功,开始打包";
this._push(sid, 'order', { orders: order, msg: msg });
}
// ========== IO 推送 ==========
_push(sid, method, data) {
if (!sid) return;
this.app.io.to(sid).emit('genericResponse', { method, data });
}
}
module.exports = Gzt;