//#region
|
import BaseService from "./baseService";
|
import { BasePlate } from "../entity/basicInfo/base/basePlate";
|
import { BaseProductInfo } from "../entity/basicInfo/base/baseProductInfo";
|
import { TaskQueue } from "../entity/basicInfo/base/taskQueue";
|
import { BasePosition } from "../entity/basicInfo/base/basePosition";
|
import { tran, transList } from "../public/webServiceHelper";
|
import * as mssql from "mssql";
|
import { Raw, MoreThan, In, Like } from "typeorm";
|
import { TaskQueueLog } from "../entity/basicInfo/base/taskQueueLog";
|
import { BaseEquipment } from "../entity/basicInfo/base/baseEquipment";
|
import { SaleOrder } from "../entity/outbound/sale/saleOrder";
|
import { vBaseProductPosition } from "../entity/storage/product/vBaseProductPosition";
|
import { BaseProductPosition } from "../entity/storage/product/baseProductPosition";
|
import { BaseProductPlaceHolder } from "../entity/storage/storage/baseProductPlaceHolder";
|
import { BasePlateType } from "../entity/basicInfo/base/basePlateType";
|
import { BaseEmptyEquipmentReturnList } from "../entity/outbound/sale/baseEmptyEquipmentReturnList";
|
import { BaseEmptyEquipmentReturn } from "../entity/outbound/sale/baseEmptyEquipmentReturn";
|
import { BaseEmptyEquipmentList } from "../entity/inbound/purchase/baseEmptyEquipmentList";
|
import { BaseEmptyEquipment } from "../entity/inbound/purchase/baseEmptyEquipment";
|
import { BaseForklift } from "../entity/basicInfo/workshop/baseForklift";
|
import moment = require("moment");
|
import { PurchaseShelve } from "../entity/inbound/purchase/purchaseShelve";
|
import { PurchaseShelveList } from "../entity/inbound/purchase/purchaseShelveList";
|
|
// 高度超过1000的器具，不允许使用的货位列表，以下货位不允许器具高度超过1000
|
let positionHeight1000 = [
|
"8-02-01-02",
|
"8-03-01-02",
|
"8-03-25-02",
|
"8-02-25-02",
|
"7-02-01-02",
|
"7-02-24-02",
|
"7-03-01-02",
|
"7-03-24-02",
|
"5-02-01-02",
|
"5-01-01-02",
|
"5-01-20-02",
|
"5-02-20-02",
|
"4-02-01-02",
|
"4-03-01-02",
|
"4-02-21-02",
|
"4-03-21-02",
|
"2-02-01-02",
|
"2-03-01-02",
|
"2-02-20-02",
|
"2-03-20-02",
|
"1-01-01-02",
|
"1-02-01-02",
|
"1-01-19-02",
|
"1-02-19-02"
|
];
|
// 正在分配移库货位
|
let _isTransferSorting = false;
|
//#endregion
|
|
/**
|
* WCS Service
|
*/
|
export default class Wcs extends BaseService {
|
//#region 创建入库任务单
|
/**
|
* 创建任务单
|
*/
|
public async createTask(transId) {
|
let info = this.getInfo();
|
info.result = false;
|
try {
|
// WCS中间件url地址
|
tran.domainUrl = this.app.config.domainUrl;
|
const result: any = await tran.getGoodsWeight({ transId });
|
let msg = `transId=${transId}获取设备重量：` + JSON.stringify(result);
|
this.saveMongoLog("创建任务单", msg);
|
/**
|
* 返回数据结构GetGoodsWeightResult：P71-1992-001,10
|
* P71-1992-001为器具编号
|
* 10为重量
|
*/
|
if (result && result.GetGoodsWeightResult) {
|
const datas = result.GetGoodsWeightResult.split(",");
|
let msg = `transId=${transId}称重器具编号：` + datas;
|
this.saveMongoLog("创建任务单", msg);
|
const sizeInfo: any = await this.updatedYnamicWeight(datas[0], datas[1], transId);
|
|
if (sizeInfo.result) {
|
info.result = true;
|
info.data = sizeInfo.data;
|
info.msg = "通知输送线进料";
|
} else {
|
info.result = false;
|
info.msg = sizeInfo.msg;
|
}
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = error.message;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 更新入库标签打印中的“动态称重
|
/**
|
* 更新入库标签打印中的“动态称重
|
*/
|
public async updatedYnamicWeight(plateCode, dynamicWeight, transId) {
|
let info = this.getInfo();
|
let { ctx } = this;
|
dynamicWeight = Number(dynamicWeight);
|
let userInfo = await ctx.helper.userInfo();
|
try {
|
let orderInfo = await this.dbRead.findOne(PurchaseShelve, {
|
userProduct_Id: userInfo.userProduct_Id,
|
plateCode: plateCode,
|
onShelveStatus: "待上架",
|
orderType: In(["入库上架"])
|
});
|
if (orderInfo) {
|
// 产品重量差 = 绝对值abs( (动态称重[产品100KG+器具20KG] - 器具重量[20KG]) - 合计重量[90KG]) = 10KG
|
// 理论重量公差合计 = sum(明细.下线数量 * 商品单位重量公差) =8KG
|
// 重量是否超重判断
|
// if(产品重量差>理论重量公差合计) {
|
// // 超重
|
// } else {
|
// // 未超重
|
// }
|
// 器具信息
|
let plateInfo = await this.dbRead.findOne(BasePlate, {
|
plateCode: plateCode
|
});
|
// 如果器具重量为0，将当前计算出的器具重量更新以下
|
if (!plateInfo.plateWeight) {
|
let plateWeight = dynamicWeight - orderInfo.totalWeight;
|
if (plateWeight < 0) {
|
plateWeight = 0;
|
}
|
await this.dbWrite.update(BasePlate, plateInfo.plate_Id, {
|
plateWeight: plateWeight
|
});
|
plateInfo.plateWeight = plateWeight;
|
}
|
// 获取明细
|
let details = await this.dbRead.find(PurchaseShelveList, {
|
shelve_Id: orderInfo.shelve_Id
|
});
|
let theoryTotalWeight = 0; // 理论重量公差合计
|
for (let detail of details) {
|
let prodInfo = await this.dbRead.findOne(BaseProductInfo, detail.product_Id);
|
theoryTotalWeight += Number(prodInfo.weightTolerance) * detail.quantity;
|
}
|
// 产品实际重量差
|
let weightSpan = dynamicWeight - Number(plateInfo.plateWeight) - Number(orderInfo.totalWeight);
|
weightSpan = Math.abs(weightSpan); // 绝对值
|
|
// 是否超重
|
let isOverWeight = weightSpan > theoryTotalWeight ? 1 : 0;
|
|
await this.dbWrite.update(
|
PurchaseShelve,
|
{
|
shelve_Id: orderInfo.shelve_Id
|
},
|
{
|
dynamicWeight: dynamicWeight,
|
isOverWeight: isOverWeight
|
}
|
);
|
if (orderInfo.isPassWeight === 1 || !isOverWeight) {
|
// 创建任务队列
|
let taskInfo = await this.createTaskQueue(orderInfo, transId);
|
let msg = "transId=" + transId + "创建任务单：" + taskInfo.billCode + "托盘号=" + taskInfo.plateCode;
|
this.saveMongoLog("创建入库任务单", msg, taskInfo);
|
info.result = true;
|
info.msg = "动态称重更新成功，任务单创建成功";
|
info.data = {
|
isOverWeight: isOverWeight,
|
length: plateInfo.length,
|
width: plateInfo.width,
|
height: plateInfo.height,
|
orderInfo: orderInfo,
|
taskInfo: taskInfo
|
};
|
} else {
|
let msg = `${orderInfo.shelveCode}超重无法创建任务`;
|
this.saveMongoLog("创建入库任务单", msg);
|
}
|
} else {
|
// 空器具入库
|
let returnInfo = await this.dbRead.findOne(BaseEmptyEquipmentReturnList, {
|
plateCode: plateCode,
|
returnStatus: "新建"
|
});
|
if (returnInfo) {
|
// 空器具入库
|
// 创建任务队列
|
let taskInfo = await this.createTaskQueueEmptyIn(returnInfo, transId);
|
let msg = ("transId=" + transId + "创建任务单：" + taskInfo.billCode + "托盘号=", taskInfo.plateCode);
|
this.saveMongoLog("创建空器具任务单", msg, taskInfo);
|
info.result = true;
|
info.msg = "动态称重更新成功，任务单创建成功";
|
info.data = {
|
orderInfo: returnInfo,
|
taskInfo: taskInfo
|
};
|
} else {
|
info.result = false;
|
info.msg = plateCode + "没有找到对应的器具编号";
|
}
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = error.message;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 创建任务队列
|
/**
|
* 创建任务队列
|
*/
|
public async createTaskQueue(orderInfo: PurchaseShelve, transId) {
|
// 创建队列
|
let taskInfo = await this.dbRead.findOne(TaskQueue, {
|
bill_Id: orderInfo.shelve_Id,
|
taskType: "上架单"
|
});
|
if (!taskInfo) {
|
taskInfo = new TaskQueue();
|
}
|
let transInfo = transList.find(item => item.transId === transId);
|
taskInfo.billCode = orderInfo.shelveCode;
|
taskInfo.bill_Id = orderInfo.shelve_Id;
|
taskInfo.creator = "自动化";
|
taskInfo.enable = 1;
|
taskInfo.platUser_Id = 1;
|
taskInfo.tranCode = transId;
|
taskInfo.tranStatus = "正常";
|
taskInfo.userProduct_Id = 1007;
|
taskInfo.taskType = "上架单";
|
taskInfo.taskStatus = "新建";
|
taskInfo.doCount = 1;
|
taskInfo.storage_Id = orderInfo.storage_Id;
|
taskInfo.storageName = orderInfo.storageName;
|
// taskInfo.plateType = orderInfo.plateType;
|
taskInfo.plateCode = orderInfo.plateCode;
|
taskInfo.direction = transInfo.position; // 方向：east、west
|
await this.dbWrite.save(taskInfo);
|
|
return taskInfo;
|
}
|
//#endregion
|
|
//#region 创建任务队列 - 空器具入库
|
/**
|
* 创建任务队列
|
*/
|
public async createTaskQueueEmptyIn(returnInfo: BaseEmptyEquipmentReturnList, transId) {
|
let mainInfo = await this.dbRead.findOne(BaseEmptyEquipmentReturn, returnInfo.emptyEquipmentReturn_Id);
|
// 创建队列
|
let taskInfo = await this.dbRead.findOne(TaskQueue, {
|
bill_Id: returnInfo.returnList_Id,
|
taskType: "空器具上架"
|
});
|
if (!taskInfo) {
|
taskInfo = new TaskQueue();
|
}
|
let transInfo = transList.find(item => item.transId === transId);
|
taskInfo.billCode = mainInfo.emptyEquipmentReturnCode + "-" + returnInfo.returnList_Id;
|
taskInfo.bill_Id = returnInfo.returnList_Id;
|
taskInfo.creator = "自动化";
|
taskInfo.enable = 1;
|
taskInfo.platUser_Id = 1;
|
taskInfo.tranCode = transId;
|
taskInfo.tranStatus = "正常";
|
taskInfo.userProduct_Id = 1007;
|
taskInfo.taskType = "空器具上架";
|
taskInfo.taskStatus = "新建";
|
taskInfo.doCount = 1;
|
taskInfo.storage_Id = mainInfo.storage_Id;
|
taskInfo.storageName = mainInfo.storageName;
|
taskInfo.plateType = returnInfo.plateType;
|
taskInfo.plateCode = returnInfo.plateCode;
|
taskInfo.direction = transInfo.position; // 方向：east、west
|
taskInfo.orderNumber = 0;
|
await this.dbWrite.save(taskInfo);
|
|
return taskInfo;
|
}
|
//#endregion
|
|
//#region 创建任务队列 - 空器具出库
|
/**
|
* 创建任务队列
|
*/
|
public async createTaskQueueEmptyOut(equipInfo: BaseEmptyEquipmentList) {
|
let mainInfo = await this.dbRead.findOne(BaseEmptyEquipment, equipInfo.emptyEquipment_Id);
|
let billCode = mainInfo.emptyEquipmentCode + "-" + equipInfo.emptyEquipmentList_Id;
|
// 创建队列
|
let taskInfo = await this.dbRead.findOne(TaskQueue, {
|
billCode: billCode,
|
taskType: "空器具下架"
|
});
|
// 队列已创建直接返回
|
if (taskInfo) {
|
return taskInfo;
|
}
|
|
taskInfo = new TaskQueue();
|
//根据出库口输送线ID找到输送线信息
|
let transInfo = transList.find(item => Number(item.endId) === Number(mainInfo.transId));
|
if (!transInfo) {
|
return "-1"; // 输送线不存在
|
}
|
|
let ppInfo = await this.dbRead
|
.createQueryBuilder(BaseProductPosition, "t")
|
.where({
|
product_Id: 0,
|
productStorage: MoreThan(0),
|
plateCode: equipInfo.plateCode,
|
productPosition_Id: Raw(() => {
|
// 排除已经分配的库存
|
return `NOT EXISTS(SELECT 1 FROM Task_Queue Q Where Q.productPosition_Id=t.productPosition_Id and taskStatus<>'任务完成')`;
|
})
|
})
|
.getOne();
|
if (!ppInfo) {
|
return "-2"; // 没有可用库存
|
}
|
let posInfo = await this.dbRead.findOne(BasePosition, {
|
positionName: ppInfo.positionName
|
});
|
|
if (posInfo.shelveCode === "01") {
|
/**
|
* 如果存在双排货位，有效存放内排空货位
|
* 01货架优先取02货架对应的货位空器具
|
* 04货架优先取03货架对应的货位空器具
|
*/
|
let outPositionName = this.replaceString(posInfo.positionName, 3, "2");
|
let outPpInfo = await this.dbRead.findOne(BaseProductPosition, {
|
product_Id: 0, // 0表示空器具
|
productStorage: MoreThan(0),
|
plateTypeCode: ppInfo.plateTypeCode,
|
positionName: outPositionName
|
});
|
|
// 如果内排货位没有库存优先使用
|
if (outPpInfo) {
|
let msg = `内排货位${ppInfo.positionName}优先取外排货位${outPpInfo.positionName}`;
|
this.saveMongoLog("空器具出库任务单", msg, taskInfo);
|
ppInfo = outPpInfo;
|
// 内排优先取外排数据
|
}
|
} else if (posInfo.shelveCode === "03") {
|
let outPositionName = this.replaceString(posInfo.positionName, 3, "4");
|
let outPpInfo = await this.dbRead.findOne(BaseProductPosition, {
|
product_Id: 0,
|
productStorage: MoreThan(0),
|
plateTypeCode: ppInfo.plateTypeCode,
|
positionName: outPositionName
|
});
|
|
// 如果内排货位没有库存优先使用
|
if (outPpInfo) {
|
let msg = `内排货位${ppInfo.positionName}优先取外排货位${outPpInfo.positionName}`;
|
this.saveMongoLog("空器具出库任务单", msg, taskInfo);
|
ppInfo = outPpInfo;
|
}
|
}
|
|
// 判断是否需要生成移库单
|
if (posInfo.shelveCode === "01") {
|
/**
|
* 如果存在双排货位，有效存放内排空货位
|
* 01货架优先取02货架对应的货位空器具
|
* 04货架优先取03货架对应的货位空器具
|
*/
|
let outPositionName = this.replaceString(posInfo.positionName, 3, "2");
|
let outPpInfo = await this.dbRead.findOne(BaseProductPosition, {
|
productStorage: MoreThan(0),
|
positionName: outPositionName
|
});
|
|
// 需要生成移库单
|
if (outPpInfo) {
|
let tranBillCode = billCode + "L";
|
let msg = `${outPpInfo.plateCode}外排货位${outPpInfo.positionName}需要移库`;
|
this.saveMongoLog("空器具出库任务单", msg, taskInfo);
|
let transferTaskInfo = await this.dbRead.findOne(TaskQueue, {
|
billCode: tranBillCode,
|
taskType: "移库单"
|
});
|
if (!transferTaskInfo) {
|
transferTaskInfo = new TaskQueue();
|
}
|
transferTaskInfo.billCode = tranBillCode;
|
transferTaskInfo.bill_Id = equipInfo.emptyEquipmentList_Id;
|
transferTaskInfo.creator = "自动化";
|
transferTaskInfo.enable = 1;
|
transferTaskInfo.platUser_Id = 1;
|
transferTaskInfo.tranCode = "" + mainInfo.transId;
|
transferTaskInfo.tranStatus = "正常";
|
transferTaskInfo.userProduct_Id = 1007;
|
transferTaskInfo.taskType = "移库单";
|
if (!transferTaskInfo.taskStatus) transferTaskInfo.taskStatus = "任务创建成功";
|
transferTaskInfo.doCount = 1;
|
transferTaskInfo.storage_Id = mainInfo.storage_Id;
|
transferTaskInfo.storageName = mainInfo.storageName;
|
transferTaskInfo.plateType = outPpInfo.plateType;
|
transferTaskInfo.plateCode = outPpInfo.plateCode;
|
transferTaskInfo.fromPositionName = outPpInfo.positionName;
|
transferTaskInfo.toPositionName = null;
|
transferTaskInfo.direction = transInfo.position; // 方向：east、west
|
await this.dbWrite.save(transferTaskInfo);
|
}
|
} else if (posInfo.shelveCode === "03") {
|
let outPositionName = this.replaceString(posInfo.positionName, 3, "4");
|
let outPpInfo = await this.dbRead.findOne(BaseProductPosition, {
|
productStorage: MoreThan(0),
|
positionName: outPositionName
|
});
|
|
// 如果内排货位没有库存优先使用
|
if (outPpInfo) {
|
let tranBillCode = billCode + "R";
|
let msg = `${outPpInfo.plateCode}外排货位${outPpInfo.positionName}需要移库`;
|
this.saveMongoLog("空器具出库任务单", msg, taskInfo);
|
let transferTaskInfo = await this.dbRead.findOne(TaskQueue, {
|
billCode: tranBillCode,
|
taskType: "移库单"
|
});
|
if (!transferTaskInfo) {
|
transferTaskInfo = new TaskQueue();
|
}
|
transferTaskInfo.billCode = tranBillCode;
|
transferTaskInfo.bill_Id = equipInfo.emptyEquipmentList_Id;
|
transferTaskInfo.creator = "自动化";
|
transferTaskInfo.enable = 1;
|
transferTaskInfo.platUser_Id = 1;
|
transferTaskInfo.tranCode = "" + mainInfo.transId;
|
transferTaskInfo.tranStatus = "正常";
|
transferTaskInfo.userProduct_Id = 1007;
|
transferTaskInfo.taskType = "移库单";
|
if (!transferTaskInfo.taskStatus) transferTaskInfo.taskStatus = "任务创建成功";
|
transferTaskInfo.doCount = 1;
|
transferTaskInfo.storage_Id = mainInfo.storage_Id;
|
transferTaskInfo.storageName = mainInfo.storageName;
|
transferTaskInfo.plateType = outPpInfo.plateType;
|
transferTaskInfo.plateCode = outPpInfo.plateCode;
|
transferTaskInfo.fromPositionName = outPpInfo.positionName;
|
transferTaskInfo.toPositionName = null;
|
transferTaskInfo.direction = transInfo.position; // 方向：east、west
|
await this.dbWrite.save(transferTaskInfo);
|
}
|
}
|
|
taskInfo.billCode = billCode;
|
taskInfo.bill_Id = equipInfo.emptyEquipmentList_Id;
|
taskInfo.creator = "自动化";
|
taskInfo.enable = 1;
|
taskInfo.platUser_Id = 1;
|
taskInfo.tranCode = "" + mainInfo.transId;
|
taskInfo.tranStatus = "正常";
|
taskInfo.userProduct_Id = 1007;
|
taskInfo.taskType = "空器具下架";
|
if (!taskInfo.taskStatus) taskInfo.taskStatus = "任务创建成功";
|
taskInfo.doCount = 1;
|
taskInfo.storage_Id = mainInfo.storage_Id;
|
taskInfo.storageName = mainInfo.storageName;
|
taskInfo.plateType = ppInfo.plateType;
|
taskInfo.plateCode = ppInfo.plateCode;
|
taskInfo.fromPositionName = ppInfo.positionName;
|
taskInfo.toPositionName = mainInfo.transId;
|
taskInfo.direction = transInfo.position; // 方向：east、west
|
taskInfo.productPosition_Id = ppInfo.productPosition_Id; // 库存ID
|
taskInfo.orderNumber = 0;
|
await this.dbWrite.save(taskInfo);
|
|
// 明细中的器具编号
|
equipInfo.plateCode = taskInfo.plateCode;
|
equipInfo.plateType = taskInfo.plateType;
|
await this.dbWrite.save(equipInfo);
|
|
return taskInfo;
|
}
|
//#endregion
|
|
//#region 入库分配货位
|
/**
|
* 入库分配货位
|
*/
|
public async sortPosition(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
let product_Id = 0;
|
if (taskInfo.taskType === "上架单") {
|
let orderInfo = await this.dbRead.findOne(PurchaseShelve, taskInfo.bill_Id);
|
let orderDetail = await this.dbRead.findOne(PurchaseShelveList, {
|
shelve_Id: taskInfo.bill_Id
|
});
|
product_Id = orderDetail.product_Id;
|
if (taskInfo.toPositionName && orderInfo.positionName) {
|
info.result = true;
|
info.msg = "货位已分配，不需要重复分配";
|
return info;
|
}
|
} else if (taskInfo.taskType === "空器具上架") {
|
product_Id = 0;
|
if (taskInfo.toPositionName) {
|
info.result = true;
|
info.msg = "货位已分配，不需要重复分配";
|
return info;
|
}
|
}
|
// 同巷道（同层）同器具种类至少留一个空位作为移库使用
|
let where = `
|
/*同巷道（同层）同器具种类至少留一个空位作为移库使用*/
|
EXISTS
|
(
|
SELECT COUNT(1) FROM dbo.Base_Position b
|
WHERE b.AreaCode=t.AreaCode
|
AND b.plateType LIKE '%${taskInfo.plateType}%'
|
AND NOT EXISTS(Select 1 from dbo.Base_ProductPosition p Where b.Storage_Id=p.Storage_Id And b.PositionName=p.PositionName And p.productStorage>0)
|
HAVING COUNT(1)>1
|
)
|
/*在任务单中不存在*/
|
AND NOT EXISTS
|
(
|
SELECT 1 FROM Task_Queue Q WHERE Q.toPositionName=t.PositionName
|
AND Q.taskStatus<>'任务完成'
|
)
|
/*无库存*/
|
AND NOT EXISTS
|
(
|
SELECT 1 FROM dbo.Base_ProductPosition p Where p.Storage_Id=t.Storage_Id And p.PositionName=t.PositionName And p.productStorage>0
|
)
|
/*器具种类*/
|
AND plateType LIKE '%${taskInfo.plateType}%'
|
AND Enable=1
|
`;
|
|
// 器具种类高度超过1000的货位限制分配
|
let plateTypeInfo = await this.dbRead.findOne(BasePlateType, {
|
plateType: taskInfo.plateType
|
});
|
if (plateTypeInfo && plateTypeInfo.height >= 1000) {
|
where += ` AND PositionName NOT IN('${positionHeight1000.join("','")}')`;
|
}
|
|
// 码垛机故障，对应货位不允许分拣上架
|
let srmList = await this.dbRead.find(BaseEquipment, {
|
enable: 0,
|
deviceType: "堆垛机"
|
});
|
if (srmList.length) {
|
where += ` AND AreaCode NOT IN('${srmList.map(item => "0" + item.deviceCode).join("','")}')`;
|
}
|
// RGV故障，对应货位不允许分拣上架
|
let rgvList = await this.dbRead.find(BaseEquipment, {
|
enable: 0,
|
deviceType: "RGV"
|
});
|
if (rgvList.length) {
|
where += ` AND AreaCode NOT IN('${rgvList.map(item => "0" + item.deviceCode).join("','")}')`;
|
}
|
// 输送线位置，东西向，优先速度快，优先靠近输送线
|
let tranInfo = transList.find(item => item.transId === Number(taskInfo.tranCode));
|
let orderBy: any = {
|
positionName: "ASC"
|
};
|
if (tranInfo.position === "east") {
|
// 货位编码数字大的是东边
|
orderBy = {
|
positionName: "DESC"
|
};
|
}
|
let sql = `SELECT top 1 positionName FROM (
|
SELECT t.positionName,
|
(SELECT count(1) FROM dbo.vBase_ProductPosition pp WHERE pp.AreaCode=t.AreaCode AND pp.Product_Id=${product_Id}) AS AreaCodeQty
|
FROM dbo.Base_Position t
|
WHERE ${where}
|
) tt
|
ORDER BY tt.AreaCodeQty, PositionName ${orderBy.positionName}`;
|
let posList = await this.dbRead.query(sql);
|
let posInfo = null;
|
if (posList.length) {
|
posInfo = posList[0];
|
}
|
if (!posInfo) {
|
info.msg = "没有可用货位";
|
info.result = false;
|
info.statusCode = 330;
|
return info;
|
}
|
if (posInfo.shelveCode === "02") {
|
/**
|
* 如果存在双排货位，有效存放内排空货位
|
* 02货架优先取01货架对应的空货位
|
* 03货架优先取04货架对应的空货位
|
*/
|
let innerPositionName = this.replaceString(posInfo.positionName, 3, "1");
|
let innerPosInfo = await this.dbRead
|
.createQueryBuilder(BasePosition, "t")
|
.where({
|
storage_Id: posInfo.storage_Id,
|
positionName: innerPositionName,
|
enable: 1,
|
position_Id: Raw(() => {
|
return `NOT EXISTS(Select 1 from Base_ProductPosition p Where t.Storage_Id=p.Storage_Id And t.PositionName=p.PositionName And productStorage>0)`;
|
})
|
})
|
.orderBy(orderBy)
|
.getOne();
|
|
// 如果内排货位没有库存优先使用
|
if (!innerPosInfo) {
|
posInfo = innerPosInfo;
|
}
|
} else if (posInfo.shelveCode === "03") {
|
let innerPositionName = this.replaceString(posInfo.positionName, 3, "4");
|
let innerPosInfo = await this.dbRead
|
.createQueryBuilder(BasePosition, "t")
|
.where({
|
storage_Id: posInfo.storage_Id,
|
positionName: innerPositionName,
|
productStorage: MoreThan(0),
|
enable: 1,
|
position_Id: Raw(() => {
|
return `NOT EXIST(Select 1 from Base_ProductPosition p Where t.Storage_Id=p.Storage_Id And t.PositionName=p.PositionName And productStorage>0)`;
|
})
|
})
|
.getOne();
|
|
// 如果内排货位没有库存优先使用
|
if (!innerPosInfo) {
|
posInfo = innerPosInfo;
|
}
|
}
|
|
if (posInfo) {
|
if (taskInfo.taskType === "上架单") {
|
await this.dbWrite.update(
|
PurchaseShelve,
|
{
|
shelve_Id: taskInfo.bill_Id
|
},
|
{
|
positionName: posInfo.positionName,
|
onShelveStatus: "在途中"
|
}
|
);
|
} else if (taskInfo.taskType === "空器具上架") {
|
await this.dbWrite.update(
|
BaseEmptyEquipmentReturnList,
|
{
|
returnList_Id: taskInfo.bill_Id
|
},
|
{
|
returnStatus: "在途中"
|
}
|
);
|
}
|
|
// 更新任务单中目标货位
|
await this.dbWrite.update(TaskQueue, taskInfo.task_Id, {
|
toPositionName: posInfo.positionName
|
});
|
let orderInfo = await this.dbRead.findOne(PurchaseShelve, taskInfo.bill_Id);
|
let { ctx } = this;
|
let userInfo = await ctx.helper.userInfo();
|
// 更改器具管理里器具的当前位置
|
await this.dbWrite.update(
|
BasePlate,
|
{
|
plateCode: orderInfo.plateCode,
|
userProduct_Id: userInfo.userProduct_Id
|
},
|
{
|
currentLocation: posInfo.positionName
|
}
|
);
|
|
info.msg = "确认入库成功";
|
info.result = true;
|
} else {
|
info.msg = "没有可用货位";
|
info.result = false;
|
info.statusCode = 330;
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
let msg = "入库货位分拣失败：" + error.message;
|
this.saveMongoLog("入库分配货位", msg, taskInfo);
|
}
|
return info;
|
}
|
private replaceString(str, index, newChar) {
|
const strAry = str.split("");
|
strAry[index] = newChar;
|
return strAry.join("");
|
}
|
//#endregion
|
|
//#region 移库分配货位
|
/**
|
* 正在分配移库货位
|
*/
|
public get isTransferSorting() {
|
return _isTransferSorting;
|
}
|
/**
|
* 正在分配移库货位
|
*/
|
public set isTransferSorting(val: boolean) {
|
_isTransferSorting = val;
|
}
|
|
/**
|
* 移库分配货位
|
*/
|
public async transferSortPosition(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
let orderInfo = await this.dbRead.findOne(SaleOrder, taskInfo.bill_Id);
|
let ppInfo = await this.dbRead.findOne(vBaseProductPosition, {
|
storage_Id: orderInfo.storage_Id,
|
positionName: taskInfo.fromPositionName
|
});
|
// 找到同巷道一个空位作为移库使用
|
let where = `
|
EXISTS
|
(
|
SELECT COUNT(1) FROM dbo.Base_Position b
|
WHERE b.AreaCode=t.AreaCode And PositionName='${taskInfo.fromPositionName}'
|
HAVING COUNT(1)>=1
|
)
|
AND NOT EXISTS(Select 1 From dbo.Base_ProductPosition p Where t.Storage_Id=p.Storage_Id and p.productStorage>0 AND t.PositionName=p.PositionName)
|
-- 排除已经分配的货位
|
AND NOT EXISTS(Select 1 From Task_Queue q Where q.toPositionName=t.PositionName AND q.taskStatus NOT IN('任务完成'))
|
`;
|
|
// 器具种类高度超过1000的货位限制分配
|
let plateTypeInfo = await this.dbRead.findOne(BasePlateType, {
|
plateType: orderInfo.plateType
|
});
|
if (plateTypeInfo && plateTypeInfo.height >= 1000) {
|
where += ` AND PositionName NOT IN('${positionHeight1000.join("','")}')`;
|
}
|
|
// 码垛机故障，对应货位不允许分拣上架
|
let srmList = await this.dbRead.find(BaseEquipment, {
|
enable: 0,
|
deviceType: "堆垛机"
|
});
|
if (srmList.length) {
|
where += ` AND AreaCode NOT IN('${srmList.map(item => "0" + item.deviceCode).join("','")}')`;
|
}
|
// RGV故障，对应货位不允许分拣上架
|
let rgvList = await this.dbRead.find(BaseEquipment, {
|
enable: 0,
|
deviceType: "RGV"
|
});
|
if (rgvList.length) {
|
where += ` AND AreaCode NOT IN('${rgvList.map(item => "0" + item.deviceCode).join("','")}')`;
|
}
|
// 输送线位置，东西向，优先速度快，优先靠近输送线
|
let orderBy: any = {
|
positionName: "ASC"
|
};
|
// let tranInfo = transList.find(item => item.transId === Number(taskInfo.tranCode));
|
// let orderBy: any = {
|
// positionName: "ASC"
|
// };
|
// if (tranInfo.position === "east") {
|
// // 货位编码数字大的是东边
|
// orderBy = {
|
// positionName: "DESC"
|
// };
|
// }
|
let posInfo = await this.dbRead
|
.createQueryBuilder(BasePosition, "t")
|
.where({
|
plateType: ppInfo.plateType,
|
enable: 1,
|
position_Id: Raw(() => {
|
return where;
|
})
|
})
|
.orderBy(orderBy)
|
.getOne();
|
/**
|
* 如果存在双排货位，有效存放内排空货位
|
* 02货架优先取01货架对应的空货位
|
* 03货架优先取04货架对应的空货位
|
*/
|
if (!posInfo) {
|
info.msg = "没有可用货位";
|
info.result = false;
|
return info;
|
}
|
if (posInfo.shelveCode === "02") {
|
let innerPositionName = this.replaceString(posInfo.positionName, 3, "2");
|
let innerPosInfo = await this.dbRead
|
.createQueryBuilder(BasePosition, "t")
|
.where({
|
storage_Id: posInfo.storage_Id,
|
positionName: innerPositionName,
|
enable: 1,
|
position_Id: Raw(() => {
|
return `NOT EXISTS(Select 1 from Base_ProductPosition p Where t.Storage_Id=p.Storage_Id And t.PositionName=p.PositionName And productStorage>0)`;
|
})
|
})
|
.orderBy(orderBy)
|
.getOne();
|
|
// 如果内排货位没有库存优先使用
|
if (!innerPosInfo) {
|
posInfo = innerPosInfo;
|
}
|
} else if (posInfo.shelveCode === "03") {
|
let innerPositionName = this.replaceString(posInfo.positionName, 3, "4");
|
let innerPosInfo = await this.dbRead
|
.createQueryBuilder(BasePosition, "t")
|
.where({
|
storage_Id: posInfo.storage_Id,
|
positionName: innerPositionName,
|
productStorage: MoreThan(0),
|
enable: 1,
|
position_Id: Raw(() => {
|
return `NOT EXIST(Select 1 from Base_ProductPosition p Where t.Storage_Id=p.Storage_Id And t.PositionName=p.PositionName And productStorage>0)`;
|
})
|
})
|
.getOne();
|
|
// 如果内排货位没有库存优先使用
|
if (!innerPosInfo) {
|
posInfo = innerPosInfo;
|
}
|
}
|
|
if (posInfo) {
|
taskInfo.toPositionName = posInfo.positionName;
|
await this.dbWrite.save(taskInfo);
|
|
info.msg = "确认入库成功";
|
info.result = true;
|
} else {
|
info.msg = "没有可用货位";
|
info.result = false;
|
}
|
_isTransferSorting = false;
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
_isTransferSorting = false;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 更新任务状态
|
/**
|
* 更新任务状态
|
* @remark 状态备注
|
*/
|
public async updateTaskStatus(taskInfo: TaskQueue, status: string, msg?: string, remark?: string) {
|
let info = this.getInfo();
|
try {
|
await this.dbWrite.update(TaskQueue, taskInfo.task_Id, {
|
taskStatus: status,
|
remark: remark
|
});
|
await this.saveLog(taskInfo, msg);
|
|
info.msg = "任务状态更新成功";
|
info.result = true;
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 保存日志 saveLog
|
/**
|
* 保存日志 saveLog
|
*/
|
public async saveLog(taskInfo: TaskQueue, msg?: string) {
|
let info = this.getInfo();
|
try {
|
let msgInfo = new TaskQueueLog();
|
msgInfo = Object.assign(msgInfo, taskInfo);
|
msgInfo.createDate = new Date();
|
if (msg) {
|
msgInfo.logDesc = msg;
|
}
|
await this.ctx.service.common.setAccountInfo(msgInfo);
|
await this.dbWrite.save(msgInfo);
|
|
info.msg = "日志保存成功";
|
info.result = true;
|
} catch (error) {
|
info.result = false;
|
info.msg = "日志保存错误：" + error.message;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 保存mongodb日志 saveLog
|
/**
|
* 保存日志 saveMongoLog
|
*/
|
public async saveMongoLog(type: string, msg: string, taskInfo?: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
console.log(type + "：", msg, moment(new Date()).format("YYYY-MM-DD HH:mm:ss"));
|
// 记录数据到mongodb日志中
|
let db = this.app.mongodb;
|
let collection = db.collection("sysLog");
|
let dataInfo: any = {
|
type: type,
|
msg: msg,
|
createDate: new Date()
|
};
|
if (taskInfo) {
|
dataInfo.billCode = taskInfo.billCode;
|
}
|
await collection.insert(dataInfo);
|
|
info.msg = "日志保存成功";
|
info.result = true;
|
} catch (error) {
|
info.result = false;
|
info.msg = "日志保存错误：" + error.message;
|
}
|
return info;
|
}
|
//#endregion
|
|
//#region 确认入库
|
public async checkEnterStorage(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
const connection: any = await this.dbWrite.connection;
|
let request = new mssql.Request(connection.driver.master);
|
request.input("shelve_Id", taskInfo.bill_Id);
|
request.input("user_Id", 1);
|
request.input("userTrueName", "码垛机");
|
request.output("outMsg", mssql.NVarChar(2000));
|
let result = await request.execute("sp_Purchase_Order_OneKeyShelve");
|
let outMsg = result.output.outMsg;
|
if (outMsg != null && outMsg) {
|
info.msg = outMsg;
|
info.result = false;
|
} else {
|
info.msg = `${taskInfo.billCode}确认入库成功`;
|
info.result = true;
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
}
|
// 保存确认入库日志
|
// await this.saveLog(taskInfo, info.msg);
|
|
return info;
|
}
|
//#endregion
|
|
//#region 确认入库 - 空器具
|
public async checkEnterStorageEmpty(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
let userInfo = await this.userInfo;
|
let returnInfo = await this.dbRead.findOne(BaseEmptyEquipmentReturnList, taskInfo.bill_Id);
|
let mainInfo = await this.dbRead.findOne(BaseEmptyEquipmentReturn, returnInfo.emptyEquipmentReturn_Id);
|
let ppInfo = await this.dbRead.findOne(BaseProductPosition, {
|
plateCode: taskInfo.plateCode,
|
productStorage: MoreThan(0)
|
});
|
// 如果不存在新建
|
if (!ppInfo) {
|
ppInfo = new BaseProductPosition();
|
}
|
|
ppInfo.billCode = taskInfo.billCode;
|
ppInfo.className = "空器具上架";
|
ppInfo.class_Id = 0;
|
ppInfo.consignorCode = mainInfo.consignorCode;
|
ppInfo.consignorName = mainInfo.consignorName;
|
ppInfo.consignor_Id = mainInfo.consignor_Id;
|
|
ppInfo.createID = 1;
|
ppInfo.creator = "码垛机";
|
ppInfo.detailID = taskInfo.task_Id;
|
ppInfo.enterCode = mainInfo.emptyEquipmentReturnCode;
|
ppInfo.inStorageDate = new Date();
|
ppInfo.mainID = mainInfo.emptyEquipmentReturn_Id;
|
ppInfo.orderCode = mainInfo.emptyEquipmentReturnCode;
|
ppInfo.orignStorage = 1;
|
ppInfo.partStatus = "合格";
|
|
ppInfo.platUser_Id = userInfo.platUser_Id;
|
ppInfo.productAttribute = "正常";
|
ppInfo.productCode = returnInfo.productCode;
|
ppInfo.productModel = returnInfo.productCode;
|
ppInfo.productName = "空器具";
|
ppInfo.productSpec = null;
|
ppInfo.productStorage = 1;
|
ppInfo.positionName = taskInfo.toPositionName;
|
ppInfo.plateCode = taskInfo.plateCode;
|
ppInfo.plateType = taskInfo.plateType;
|
ppInfo.plateTypeCode = taskInfo.plateCode.substr(0, 8);
|
|
ppInfo.product_Id = returnInfo.product_Id;
|
ppInfo.providerShortName = "青汽";
|
ppInfo.provider_Id = 0;
|
ppInfo.providerCode = "qingqi";
|
ppInfo.storageName = mainInfo.storageName;
|
ppInfo.storageStatus = "正常";
|
ppInfo.storage_Id = mainInfo.storage_Id;
|
await this.ctx.service.common.setAccountInfo(ppInfo);
|
await this.dbWrite.save(ppInfo);
|
|
// 更新任务库存ID
|
await this.dbWrite.update(TaskQueue, taskInfo.task_Id, {
|
productPosition_Id: ppInfo.productPosition_Id
|
});
|
|
// 校验是否入库成功
|
ppInfo = await this.dbRead.findOne(BaseProductPosition, {
|
plateCode: taskInfo.plateCode,
|
productStorage: MoreThan(0)
|
});
|
if (ppInfo) {
|
// 更新空器具状态
|
await this.dbWrite.update(BaseEmptyEquipmentReturnList, returnInfo.returnList_Id, {
|
returnStatus: "已入库"
|
});
|
|
// 更新主表状态
|
let finishCount = await this.dbRead.count(BaseEmptyEquipmentReturnList, {
|
emptyEquipmentReturn_Id: mainInfo.emptyEquipmentReturn_Id,
|
returnStatus: "已入库"
|
});
|
let allCount = await this.dbRead.count(BaseEmptyEquipmentReturnList, {
|
emptyEquipmentReturn_Id: mainInfo.emptyEquipmentReturn_Id
|
});
|
if (allCount > finishCount && finishCount > 0) {
|
await this.dbRead.update(
|
BaseEmptyEquipmentReturn,
|
{
|
emptyEquipmentReturn_Id: mainInfo.emptyEquipmentReturn_Id
|
},
|
{
|
statusText: "部分入库"
|
}
|
);
|
} else if (allCount <= finishCount) {
|
await this.dbRead.update(
|
BaseEmptyEquipmentReturn,
|
{
|
emptyEquipmentReturn_Id: mainInfo.emptyEquipmentReturn_Id
|
},
|
{
|
statusText: "已入库"
|
}
|
);
|
// 空器具已入库后，更改器具管理里面器具的当前位置outCommand
|
await this.dbWrite.update(
|
BasePlate,
|
{
|
plateCode: taskInfo.plateCode,
|
userProduct_Id: userInfo.userProduct_Id
|
},
|
{
|
currentLocation: ppInfo.positionName
|
}
|
);
|
await this.dbWrite.update(
|
BaseForklift,
|
{
|
forkliftName: mainInfo.allocatedForklift
|
},
|
{
|
forkliftStatus: "空闲中"
|
}
|
);
|
}
|
|
info.msg = `${taskInfo.billCode}空器具确认入库成功`;
|
info.result = true;
|
} else {
|
info.result = false;
|
info.msg = `${taskInfo.billCode} - ${taskInfo.plateCode}空器具入库失败`;
|
this.saveMongoLog("空器具确认入库", info.msg, taskInfo);
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
let msg = `${taskInfo.billCode} - ${taskInfo.plateCode}空器具上架错误：` + error.message;
|
this.saveMongoLog("空器具确认入库", msg, taskInfo);
|
}
|
|
return info;
|
}
|
//#endregion
|
|
//#region 确认确认上架
|
public async checkShelveStorage(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
const connection: any = await this.dbWrite.connection;
|
let request = new mssql.Request(connection.driver.master);
|
request.input("shelve_Id", taskInfo.bill_Id);
|
request.input("user_Id", 1);
|
request.input("userTrueName", "码垛机");
|
request.output("outMsg", mssql.NVarChar(2000));
|
let result = await request.execute("sp_Purchase_Order_OneKeyShelve");
|
let outMsg = result.output.outMsg;
|
if (outMsg != null && outMsg) {
|
info.msg = outMsg;
|
info.result = false;
|
} else {
|
info.msg = `${taskInfo.billCode}确认入库成功`;
|
info.result = true;
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
}
|
// 保存确认入库日志
|
// await this.saveLog(taskInfo, info.msg);
|
|
return info;
|
}
|
//#endregion
|
|
//#region 确认出库
|
public async checkOutStorage(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
let { ctx } = this;
|
let userInfo = await ctx.helper.userInfo();
|
|
try {
|
// 将器具下架到分拣区
|
let orderInfo = await this.dbRead.findOne(SaleOrder, taskInfo.bill_Id);
|
let holderList = await this.dbRead.find(BaseProductPlaceHolder, {
|
mainID: orderInfo.order_Id,
|
className: "销售订单"
|
});
|
let ppList = await this.dbRead.find(BaseProductPosition, {
|
productPosition_Id: In(holderList.map(item => item.productPosition_Id))
|
});
|
// 转移新货位库存
|
for (let ppInfo of ppList) {
|
// 新货位库存
|
let newppInfo = new BaseProductPosition();
|
newppInfo = Object.assign(newppInfo, ppInfo);
|
newppInfo.productPosition_Id = 0;
|
newppInfo.positionName = "分拣区";
|
newppInfo.className = "码垛机下架";
|
newppInfo.billCode = "" + taskInfo.task_Id;
|
await this.ctx.service.common.setAccountInfo(newppInfo);
|
await this.dbWrite.save(newppInfo);
|
// 原货位库存减为0
|
await this.dbWrite.update(BaseProductPosition, ppInfo.productPosition_Id, {
|
productStorage: 0
|
});
|
// 将占位数据更新为0
|
await this.dbWrite.update(
|
BaseProductPlaceHolder,
|
{
|
productPosition_Id: ppInfo.productPosition_Id
|
},
|
{
|
placeholderStorage: 0
|
}
|
);
|
await this.dbWrite.update(SaleOrder, orderInfo.order_Id, {
|
statusText: "已完成"
|
});
|
// 出库完成后更改器具管理里器具的当前位置
|
await this.dbWrite.update(
|
BasePlate,
|
{
|
plateCode: orderInfo.plateCode,
|
userProduct_Id: userInfo.userProduct_Id
|
},
|
{
|
currentLocation: orderInfo.outTransId
|
}
|
);
|
// 如果状态为已完成后修改叉车管理里叉车司机的叉车状态
|
if (orderInfo.statusText === "已完成") {
|
// 根据选中的目的地id查找叉车为空闲中的叉车
|
let forklift = await this.dbRead.findOne(BaseForklift, {
|
forkliftStatus: "空闲中",
|
userProduct_Id: userInfo.userProduct_Id,
|
destination_Id: Like("%" + orderInfo.destination_Id + "%")
|
});
|
if (forklift) {
|
// 更新出库单的叉车司机
|
await this.dbWrite.update(SaleOrder, orderInfo.order_Id, {
|
relationDrivers: forklift.relationDrivers
|
});
|
// 把查到的叉车司机任务状态改为任务中
|
await this.dbWrite.update(
|
BaseForklift,
|
{
|
forklift_Id: forklift.forklift_Id
|
},
|
{
|
forkliftStatus: "任务中"
|
}
|
);
|
}
|
}
|
}
|
info.result = true;
|
info.msg = "出库成功";
|
} catch (error) {
|
info.result = false;
|
info.msg = "错误：" + error.message;
|
}
|
// 保存确认入库日志
|
await this.saveLog(taskInfo, info.msg);
|
|
return info;
|
}
|
//#endregion
|
|
//#region 确认出库 - 空器具
|
public async checkOutStorageEmpty(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
let { ctx } = this;
|
let userInfo = await ctx.helper.userInfo();
|
try {
|
// 将器具下架到分拣区
|
let detailInfo = await this.dbRead.findOne(BaseEmptyEquipmentList, taskInfo.bill_Id);
|
// 明细不存在，直接更新任务
|
if (!detailInfo) {
|
info.result = true;
|
info.msg = `${taskInfo.billCode} - ${taskInfo.plateCode}明细已删除`;
|
return info;
|
}
|
|
let ppList = await this.dbRead.find(BaseProductPosition, {
|
plateCode: detailInfo.plateCode,
|
productStorage: MoreThan(0)
|
});
|
for (let ppInfo of ppList) {
|
// 原货位库存减为0
|
await this.dbWrite.update(BaseProductPosition, ppInfo.productPosition_Id, {
|
productStorage: 0
|
});
|
await this.dbWrite.update(BaseEmptyEquipmentList, detailInfo.emptyEquipmentList_Id, {
|
status: "已出库"
|
});
|
}
|
|
ppList = await this.dbRead.find(BaseProductPosition, {
|
plateCode: detailInfo.plateCode,
|
productStorage: MoreThan(0)
|
});
|
if (!ppList.length) {
|
// 更新主表状态
|
let finishCount = await this.dbRead.count(BaseEmptyEquipmentList, {
|
emptyEquipment_Id: detailInfo.emptyEquipment_Id,
|
status: "已出库"
|
});
|
// 空器具出库后更改器具管理里器具的当前位置为冲压车间
|
await this.dbWrite.update(
|
BasePlate,
|
{
|
plateCode: detailInfo.plateCode,
|
userProduct_Id: userInfo.userProduct_Id
|
},
|
{
|
currentLocation: "冲压车间"
|
}
|
);
|
let allCount = await this.dbRead.count(BaseEmptyEquipmentList, {
|
emptyEquipment_Id: detailInfo.emptyEquipment_Id
|
});
|
if (allCount > finishCount && finishCount > 0) {
|
await this.dbRead.update(
|
BaseEmptyEquipment,
|
{
|
emptyEquipment_Id: detailInfo.emptyEquipment_Id
|
},
|
{
|
statusText: "部分出库"
|
}
|
);
|
} else if (allCount <= finishCount) {
|
await this.dbRead.update(
|
BaseEmptyEquipment,
|
{
|
emptyEquipment_Id: detailInfo.emptyEquipment_Id
|
},
|
{
|
statusText: "已出库"
|
}
|
);
|
// 空器具出库后更改器具管理里器具的当前位置为冲压车间
|
await this.dbWrite.update(
|
BasePlate,
|
{
|
plateCode: detailInfo.plateCode,
|
userProduct_Id: userInfo.userProduct_Id
|
},
|
{
|
currentLocation: "冲压车间"
|
}
|
);
|
}
|
info.result = true;
|
info.msg = `${taskInfo.billCode} - ${taskInfo.plateCode}空器具出库成功`;
|
} else {
|
info.result = false;
|
info.msg = `${taskInfo.billCode} - ${taskInfo.plateCode}空器具出库失败`;
|
this.saveMongoLog("空器具确认出库", info.msg, taskInfo);
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = `${taskInfo.billCode} - ${taskInfo.plateCode}空器具出库错误：` + error.message;
|
this.saveMongoLog("空器具确认出库", info.msg, taskInfo);
|
}
|
// 保存确认入库日志
|
await this.saveLog(taskInfo, info.msg);
|
|
return info;
|
}
|
//#endregion
|
|
//#region 确认转移货位
|
public async checkTransferStorage(taskInfo: TaskQueue) {
|
let info = this.getInfo();
|
try {
|
let ppList = await this.dbRead.find(BaseProductPosition, {
|
positionName: taskInfo.fromPositionName,
|
productStorage: MoreThan(0)
|
});
|
if (!ppList.length) {
|
info.result = false;
|
info.msg = "移库失败，原货位库存不存在";
|
|
await this.dbWrite.update(TaskQueue, taskInfo.task_Id, {
|
remark: info.msg
|
});
|
return;
|
}
|
|
let msg = "";
|
for (let ppInfo of ppList) {
|
// 转移新货位库存
|
let newppInfo = new BaseProductPosition();
|
newppInfo = Object.assign(newppInfo, ppInfo);
|
newppInfo.productPosition_Id = 0;
|
newppInfo.positionName = taskInfo.toPositionName;
|
newppInfo.className = "货位转移";
|
newppInfo.billCode = "" + taskInfo.task_Id;
|
msg = "源库存ID=" + ppInfo.productPosition_Id + "，目标库存ID=" + newppInfo.productPosition_Id;
|
newppInfo.remark = msg;
|
await this.ctx.service.common.setAccountInfo(newppInfo);
|
await this.dbWrite.insert(BaseProductPosition, newppInfo);
|
// 原货位库存减为0
|
await this.dbWrite.update(BaseProductPosition, ppInfo.productPosition_Id, {
|
productStorage: 0
|
});
|
|
// 更新库存ID、备注
|
await this.dbWrite.update(TaskQueue, taskInfo.task_Id, {
|
productPosition_Id: newppInfo.productPosition_Id,
|
remark: msg
|
});
|
}
|
info.result = true;
|
info.msg = "移库成功，" + msg;
|
} catch (error) {
|
info.msg = "转移错误：" + error.message;
|
info.result = false;
|
}
|
// 保存确认入库日志
|
await this.saveLog(taskInfo, info.msg);
|
|
return info;
|
}
|
//#endregion
|
|
//#region 创建回库任务单
|
/**
|
* 创建回库任务单
|
*/
|
public async createTask_hk(transId) {
|
let info = this.getInfo();
|
info.result = false;
|
try {
|
// WCS中间件url地址
|
tran.domainUrl = this.app.config.domainUrl;
|
const result: any = await tran.getGoodsWeight({ transId });
|
let msg = "获取设备重量：" + JSON.stringify(result);
|
this.saveMongoLog("创建回库任务单", msg);
|
/**
|
* 返回数据结构GetGoodsWeightResult：P71-1992-001,10
|
* P71-1992-001为器具编号
|
* 10为重量
|
*/
|
if (result && result.GetGoodsWeightResult) {
|
const datas = result.GetGoodsWeightResult.split(",");
|
let msg = "称重器具编号：" + datas;
|
this.saveMongoLog("创建回库任务单", msg);
|
const sizeInfo: any = await this.updatedYnamicWeight(datas[0], datas[1], transId);
|
|
if (sizeInfo.result) {
|
info.result = true;
|
info.data = sizeInfo.data;
|
info.msg = "通知输送线进料";
|
} else {
|
info.result = false;
|
info.msg = sizeInfo.msg;
|
}
|
}
|
} catch (error) {
|
info.result = false;
|
info.msg = error.message;
|
}
|
return info;
|
}
|
//#endregion
|
}
|
