package book.stock;
|
|
import java.math.BigDecimal;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Set;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.action.ActionProvider;
|
import foundation.dao.DataPackage;
|
import foundation.dao.DataSource;
|
import foundation.dao.DataWriter;
|
import foundation.dao.Filter;
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.EntitySaver;
|
import foundation.persist.NamedSQL;
|
import foundation.persist.SQLRunner;
|
import foundation.util.ID;
|
import foundation.util.Util;
|
|
public class BookWriter extends ActionProvider {
|
|
private static Logger logger;
|
public static final String FieldName_BatchMark = "batch_mark";
|
|
static {
|
logger = LogManager.getLogger(BookWriter.class);
|
}
|
|
public BookWriter() {
|
|
}
|
|
@Override
|
protected void publishMethod() {
|
//1. 获取库存记账描述列表
|
addMethod("getBookCommandList");
|
|
//2. 获取库存记账描述
|
addMethod("getBookCommand");
|
|
//3. 记账
|
addMethod("write");
|
}
|
|
public void getBookCommandList() {
|
BookCommandBucket bucket = BookCommandBucket.getInstance();
|
dataWriter.addValue("data", bucket);
|
}
|
|
public void getBookCommand() {
|
String commandCode = dataReader.getString("code");
|
List<BookCommandMeta> metas = BookCommandBucket.getMeta(commandCode);
|
|
if (metas == null) {
|
logger.error("book command [{}] can not find: ", commandCode);
|
return;
|
}
|
|
dataWriter.addValue("data", metas);
|
}
|
|
public void write() throws Exception {
|
String commandCode = context.getStepParam();
|
List<BookCommand> bookCommands = BookCommandBucket.get(commandCode);
|
|
if (bookCommands == null || (bookCommands.isEmpty())) {
|
throw new Exception("book command [{" + commandCode + "}] can not find: ");
|
}
|
|
DataPackage dataPackage = dataReader.getDataPackage();
|
|
//2. 获取公司及仓库
|
for (BookCommand bookCommand: bookCommands) {
|
getOrgAndWarehouse(dataPackage, bookCommand);
|
}
|
|
//3. 账本加锁
|
lockStockBook(bookCommands);
|
|
//4. 创建流水表（FlowTable）并进行校验
|
boolean isContinue = true;
|
for (BookCommand bookCommand: bookCommands) {
|
isContinue = isContinue && getFlowTableAndValidate(bookCommand, bookCommand.getDataSource());
|
}
|
|
if (!isContinue) {
|
logger.error("validate not success, skip...");
|
return;
|
}
|
|
//5. 根据Command和FlowTable记账
|
for (BookCommand bookCommand: bookCommands) {
|
doWriteBook(bookCommand);
|
}
|
}
|
|
private void getOrgAndWarehouse(DataPackage document, BookCommand bookCommand) throws Exception {
|
DataWriter dataWriter = context.getDataWriter();
|
|
//1. 设置单据到Command
|
bookCommand.setDocument(document);
|
|
//2. 获取公司
|
Entity entity = document.getMasterEntity();
|
String direction = bookCommand.getWarehouseDirection();
|
String accountField = "account_id";
|
String orgField = "customer_id";
|
|
String org_id = entity.getString(orgField);
|
if (Util.isEmpty(org_id)) {
|
orgField = accountField;
|
}
|
|
if (!Util.isEmpty(direction) && "to".equalsIgnoreCase(direction)) {
|
orgField = direction + "_" + orgField;
|
}
|
|
String customer_id = entity.getString(orgField);
|
|
if (Util.isEmpty(customer_id)) {
|
task.terminate();
|
dataWriter.reportOneError("stock.write", "客户ID没有获取");
|
return;
|
}
|
|
DataObject dataObject = DataObject.getInstance("md_org_account");
|
Entity org = dataObject.getTableEntity(customer_id);
|
bookCommand.setOrg(org);
|
|
if (org == null) {
|
task.terminate();
|
dataWriter.reportOneError("stock.write", "客户没有获取");
|
return;
|
}
|
|
//3. 获取仓库
|
dataObject = DataObject.getInstance("wm_warehouse");
|
Entity warehouse = null;
|
String warehouseField = "warehouse_id";
|
|
if (!Util.isEmpty(direction)) {
|
warehouseField = direction + "_" + warehouseField;
|
}
|
|
String warehouseId = entity.getString(warehouseField);
|
if (!Util.isEmpty(warehouseId)) {
|
warehouse = dataObject.getTableEntity(warehouseId);
|
}
|
else {
|
Filter filter = new Filter("account_id", customer_id).add("type_code", "Master");
|
warehouse = dataObject.getTableEntity(filter);
|
}
|
|
if ((warehouse == null || warehouse.isEmpty()) && Util.isEmpty(bookCommand.getWarehouseSource())) {
|
dataWriter.reportOneError("库存记账", "仓库不存在");
|
task.terminate();
|
return;
|
}
|
|
bookCommand.setWarehouse(warehouse);
|
}
|
|
private void lockStockBook(List<BookCommand> bookCommands) throws Exception {
|
for (BookCommand bookCommand: bookCommands) {
|
NamedSQL lockStockBook = NamedSQL.getInstance("lockStockBook");
|
lockStockBook.setParam("batch_mark", bookCommand.getBatchMark());
|
lockStockBook.setParam("detailTableName", bookCommand.getDocumentDetailTableName());
|
lockStockBook.setParam("document_id", bookCommand.getDocumentId());
|
lockStockBook.setParam("warehouse_id", bookCommand.getWarehouseID());
|
SQLRunner.execSQL(lockStockBook);
|
}
|
}
|
private boolean getFlowTableAndValidate(BookCommand bookCommand, DataSource dataSource) throws Exception {
|
if (DataSource.File == dataSource) {
|
return getFlowTableAndValidateFromFile(bookCommand);
|
}
|
|
return getFlowTableAndValidate(bookCommand);
|
}
|
|
private boolean getFlowTableAndValidate(BookCommand bookCommand) throws Exception {
|
boolean result = true;
|
String value = null;
|
|
Entity warehouse = bookCommand.getWarehouse();
|
boolean detailedWarehouse = bookCommand.getDetailedWarehouse();
|
|
//1. 根据【单据】+【明细账】获取记账工作表
|
NamedSQL getStockBookFlow = NamedSQL.getInstance("getStockFlowBasicFields");
|
|
getStockBookFlow.setParam("tableName", bookCommand.getDocumentTableName());
|
getStockBookFlow.setParam("detailTableName", bookCommand.getDocumentDetailTableName());
|
getStockBookFlow.setParam("document_id", bookCommand.getDocumentId());
|
getStockBookFlow.setParam("org_id", bookCommand.getOrgID());
|
getStockBookFlow.setParam("batch_mark", bookCommand.getBatchMark());
|
|
if (detailedWarehouse) {
|
getStockBookFlow.setParam("warehouse_id", bookCommand.getWarehouseSource() + "_id");
|
getStockBookFlow.setParam("warehouse_code", bookCommand.getWarehouseSource() + "_code");
|
getStockBookFlow.setParam("warehouse_name", bookCommand.getWarehouseSource() + "_name");
|
}
|
else {
|
getStockBookFlow.setParam("warehouse_id", Util.quotedStr(warehouse.getId()));
|
getStockBookFlow.setParam("warehouse_code", Util.quotedStr(warehouse.getString("code")));
|
getStockBookFlow.setParam("warehouse_name", Util.quotedStr(warehouse.getString("name")));
|
}
|
|
getStockBookFlow.setParam("document_doc_type", bookCommand.getDocumentDocTypeSegment());
|
getStockBookFlow.setParam("document_order_right", bookCommand.getDocumentOrderRightSegment());
|
getStockBookFlow.setParam("document_stock_type", bookCommand.getDocumentStockTypeSegment());
|
//@he
|
getStockBookFlow.setParam("document_qty", IStockLetter.Table_DocumentDetail + "." + bookCommand.getDocumentQtySegment());
|
|
Filter filter = new Filter();
|
filter.add("document_detail.parent_id", bookCommand.getDocumentId());
|
filter.add(bookCommand.getFilter());
|
getStockBookFlow.setFilter(filter);
|
|
//1.6. 获取数据
|
EntitySet entitySet = SQLRunner.getEntitySet(getStockBookFlow);
|
|
//1.6.1 植入撤销调整获取明细数据
|
if (entitySet == null || entitySet.isEmpty()) {
|
NamedSQL getStockBookImplatnFlow = NamedSQL.getInstance("getStockFlowBasicFieldsByImplantCancel");
|
Set<String> nameList = getStockBookFlow.getVariantNames();
|
for (String name : nameList) {
|
value = getStockBookFlow.getParam(name);
|
getStockBookImplatnFlow.setParam(name, value);
|
}
|
|
getStockBookImplatnFlow.setParam("host_id", bookCommand.getDocument().getMasterEntity().getString("host_id", ""));
|
|
filter = new Filter();
|
filter.add("document.host_id", bookCommand.getDocument().getMasterEntity().getString("host_id", ""));
|
filter.add(bookCommand.getFilter());
|
getStockBookImplatnFlow.setFilter(filter);
|
|
entitySet = SQLRunner.getEntitySet(getStockBookImplatnFlow);
|
}
|
|
FlowTable flowTable = bookCommand.getFlowTable();
|
flowTable.setEntitySet(entitySet);
|
|
return result;
|
}
|
|
private boolean getFlowTableAndValidateFromFile(BookCommand bookCommand) throws Exception {
|
boolean result = true;
|
DataPackage dataPackage = bookCommand.getDocument();
|
DataPackage host = dataPackage.getHost();
|
host.loadOneDataFromFile();
|
|
bookCommand.setDocument(host);
|
String detailName = bookCommand.getDocumentDetailTableName();
|
Entity master = dataPackage.getMasterEntity();
|
Entity hostMaster = host.getMasterEntity(DataSource.File);
|
EntitySet detailSet = host.getItemEntitySet(detailName, DataSource.File);
|
|
NamedSQL namedSQL = NamedSQL.getInstance("getFlowFields");
|
namedSQL.setTableName(IStockLetter.Table_BookFlow);
|
EntitySet flowSet = SQLRunner.getEntitySet(namedSQL);
|
|
Entity oneFlow;
|
boolean detailedWarehouse = bookCommand.getDetailedWarehouse();
|
|
for (Entity entity: detailSet) {
|
BigDecimal qty = entity.getBigDecimal(bookCommand.getDocumentQtySegment(), BigDecimal.ZERO);
|
|
if (BigDecimal.ZERO.compareTo(qty) == 0) {
|
continue;
|
}
|
|
oneFlow = flowSet.newEntity();
|
oneFlow.set(IStockLetter.Field_DocumentDocType, bookCommand.getDocumentDocType());
|
|
oneFlow.set(IStockLetter.Field_DocCode, master.getString("code"));
|
oneFlow.set(IStockLetter.Field_DocDate, master.getString(IStockLetter.Field_DocDate));
|
|
oneFlow.set(IStockLetter.Field_BuId, hostMaster.getString(IStockLetter.Field_BuId));
|
oneFlow.set(IStockLetter.Field_BuName, hostMaster.getString(IStockLetter.Field_BuName));
|
|
oneFlow.set(IStockLetter.Field_DocDetailId, entity.getId());
|
oneFlow.set(IStockLetter.Field_ProductId, entity.getString(IStockLetter.Field_ProductId));
|
oneFlow.set(IStockLetter.Field_ProductCode, entity.getString(IStockLetter.Field_ProductCode));
|
oneFlow.set(IStockLetter.Field_ProductName, entity.getString(IStockLetter.Field_ProductName));
|
oneFlow.set(IStockLetter.Field_BatchNo, entity.getString(IStockLetter.Field_BatchNo));
|
oneFlow.set(IStockLetter.Field_BatchSn, entity.getString(IStockLetter.Field_BatchSn));
|
oneFlow.set(IStockLetter.Field_ValidFrom, entity.getString(IStockLetter.Field_ValidFrom));
|
oneFlow.set(IStockLetter.Field_ValidTo, entity.getString(IStockLetter.Field_ValidTo));
|
oneFlow.set(IStockLetter.Field_Qty, qty);
|
|
if (detailedWarehouse) {
|
oneFlow.set(IStockLetter.Field_WarehouseId, entity.getString(IStockLetter.Field_WarehouseId));
|
oneFlow.set(IStockLetter.Field_WarehouseCode, entity.getString(IStockLetter.Field_WarehouseCode));
|
oneFlow.set(IStockLetter.Field_WarehouseName, entity.getString(IStockLetter.Field_WarehouseName));
|
oneFlow.set(IStockLetter.Field_DocumentOrderRight, entity.getString(IStockLetter.Field_DocumentOrderRight));
|
oneFlow.set(IStockLetter.Field_DocumentStockType, entity.getString(IStockLetter.Field_DocumentStockType));
|
}
|
else {
|
oneFlow.set(IStockLetter.Field_WarehouseId, hostMaster.getString(IStockLetter.Field_WarehouseId));
|
oneFlow.set(IStockLetter.Field_WarehouseCode, hostMaster.getString(IStockLetter.Field_WarehouseCode));
|
oneFlow.set(IStockLetter.Field_WarehouseName, hostMaster.getString(IStockLetter.Field_WarehouseName));
|
oneFlow.set(IStockLetter.Field_DocumentOrderRight, hostMaster.getString(IStockLetter.Field_DocumentOrderRight));
|
oneFlow.set(IStockLetter.Field_DocumentStockType, hostMaster.getString(IStockLetter.Field_DocumentOrderRight));
|
}
|
|
if (Util.isEmpty(oneFlow.getString(IStockLetter.Field_WarehouseId))) {
|
Entity warehouse = bookCommand.getWarehouse();
|
oneFlow.set(IStockLetter.Field_WarehouseId, warehouse.getString("id"));
|
oneFlow.set(IStockLetter.Field_WarehouseCode, warehouse.getString("code"));
|
oneFlow.set(IStockLetter.Field_WarehouseName, warehouse.getString("name"));
|
}
|
|
flowSet.append(oneFlow);
|
}
|
|
FlowTable flowTable = bookCommand.getFlowTable();
|
flowTable.setEntitySet(flowSet);
|
|
return result;
|
}
|
|
public void doWriteBook(BookCommand bookCommand) throws Exception {
|
//1. 记库存流水
|
writeStockFlow(bookCommand);
|
|
//2. 记库存明细
|
writeStockDetail(bookCommand);
|
}
|
|
private void writeStockFlow(BookCommand bookCommand) throws Exception {
|
QtyCommand qtyCommand = bookCommand.getQtyCommand();
|
if (qtyCommand.isDoNothing()) {
|
return;
|
}
|
|
//1. 记录流水账
|
DataObject dataObject = DataObject.getInstance("wm_book_flow");
|
|
String batchMark = bookCommand.getBatchMark();
|
Entity org = bookCommand.getOrg();
|
String docType = bookCommand.getDocumentDocType();
|
OrderRight orderRight = bookCommand.getOrderRight();
|
StockType stockType = bookCommand.getStockType();
|
Entity warehouse = bookCommand.getWarehouse();
|
|
FlowTable flowTable = bookCommand.getFlowTable();
|
|
for (Entity flow : flowTable) {
|
BigDecimal qty = flow.getBigDecimal("qty");
|
EntitySaver saver = dataObject.createEntitySaver();
|
|
saver.set("id", ID.newValue());
|
saver.set("batch_mark", batchMark);
|
|
saver.set(IStockLetter.Field_DocDetailId, flow.getValue(IStockLetter.Field_DocDetailId));
|
saver.set("document_doc_type", flow.getValue("document_doc_type"));
|
saver.set("config_doc_type", bookCommand.getDocumentDocType());
|
saver.set("doc_type", tranferDocumentDocType(IfEnpty(flow.getString("document_doc_type"), docType)));
|
|
saver.set(IStockLetter.Field_DocCode, flow.getValue(IStockLetter.Field_DocCode));
|
saver.set(IStockLetter.Field_DocDate, flow.getValue(IStockLetter.Field_DocDate));
|
saver.set("book_date", bookCommand.getBookDate());
|
|
saver.set("org_id", org.getId());
|
saver.set("org_code", org.getString("code"));
|
saver.set("org_name", org.getString("account_name"));
|
saver.set("account_id", org.getId());
|
|
saver.set("warehouse_id", flow.getValue("warehouse_id"));
|
saver.set("warehouse_code", flow.getValue("warehouse_code"));
|
saver.set("warehouse_name", flow.getValue("warehouse_name"));
|
|
saver.set("document_order_right", flow.getValue("document_order_right"));
|
saver.set("config_order_right", orderRight.name());
|
saver.set("order_right_code", IfEnpty(flow.getString("document_order_right"), orderRight.name()));
|
|
saver.set("document_stock_type", flow.getValue("document_stock_type"));
|
saver.set("config_stock_type", stockType.name());
|
saver.set("stock_type_code", IfEnpty(flow.getString("stock_type_code"), stockType.name()));
|
|
saver.set("product_id", flow.getValue("product_id"));
|
saver.set("product_code", flow.getString("product_code"));
|
saver.set("product_name", flow.getString("product_name"));
|
saver.set("bu_id", flow.getValue("bu_id"));
|
saver.set("bu_name", flow.getValue("bu_name"));
|
|
saver.set("batch_no", IfEnpty(flow.getString("batch_no"),"N/A"));
|
saver.set("batch_sn", flow.getString("batch_sn", ""));
|
saver.set("valid_from", flow.getValue("valid_from"));
|
saver.set("valid_to", flow.getValue("valid_to"));
|
|
//增加仓库类型
|
saver.set("type_code", warehouse.getString("type_code", ""));
|
saver.set("type_name", warehouse.getString("type_name", ""));
|
|
boolean qtyChanged = false;
|
boolean negativeConver = bookCommand.isNegativeConvert();
|
|
if (qtyCommand.isSetAdd()) {
|
BigDecimal qty_add = qty.multiply(qtyCommand.getAddOperator());
|
|
if (qty_add.compareTo(BigDecimal.ZERO) < 0 && negativeConver) {
|
saver.set("qty_delete", BigDecimal.ZERO.subtract(qty_add));
|
}
|
else {
|
saver.set("qty_add", qty_add);
|
}
|
qtyChanged = true;
|
}
|
|
if (qtyCommand.isSetDelete()) {
|
BigDecimal qty_delete = qty.multiply(qtyCommand.getDeleteOperator());
|
|
if (qty_delete.compareTo(BigDecimal.ZERO) < 0 && negativeConver) {
|
saver.set("qty_add", BigDecimal.ZERO.subtract(qty_delete));
|
}
|
else {
|
saver.set("qty_delete", qty_delete);
|
}
|
qtyChanged = true;
|
}
|
|
FreezeCondition freezeCondition = bookCommand.getFreezeCondition();
|
|
if (qtyCommand.isSetFreeze()) {
|
BigDecimal qty_freeze = qty.multiply(qtyCommand.getFreezeOperator());
|
|
//1. 例如：库存调整单，只有调减审批的时候才需要正数记冻结，只有调减审批不通过才能用负数记冻结
|
if (freezeCondition.isCompatible(qty_freeze)) {
|
saver.set("qty_freeze", qty_freeze);
|
qtyChanged = true;
|
}
|
}
|
|
if (qtyCommand.isSetUnfreeze()) {
|
BigDecimal qty_unfreeze = qty.multiply(qtyCommand.getUnfreezeOperator());
|
|
//2. 例如：库存调整单，只有调减审批通过的时候才需要减少冻结
|
if (freezeCondition.isCompatible(qty_unfreeze)) {
|
saver.set("qty_unfreeze", qty_unfreeze);
|
qtyChanged = true;
|
}
|
}
|
|
if(qtyChanged) {
|
saver.insert();
|
}
|
}
|
|
NamedSQL writeStockFlowBookFields = NamedSQL.getInstance("writeStockFlowBookFields");
|
writeStockFlowBookFields.setParam("batch_mark", batchMark);
|
writeStockFlowBookFields.execute();
|
}
|
|
private void writeStockDetail(BookCommand bookCommand) throws Exception {
|
BookResult result = new BookResult();
|
|
String batchMark = bookCommand.getBatchMark();
|
Date bookDate = bookCommand.getBookDate();
|
Entity org = bookCommand.getOrg();
|
|
//1. 计入需要增加的库存明细
|
NamedSQL writeInsertStockDetail = NamedSQL.getInstance("writeInsertStockDetail");
|
writeInsertStockDetail.setParam("batch_mark", batchMark);
|
writeInsertStockDetail.setParam("org_id", org.getId());
|
writeInsertStockDetail.setParam("org_code", org.getString("code"));
|
writeInsertStockDetail.setParam("org_name", org.getString("account_name"));
|
writeInsertStockDetail.setParam("create_time", bookDate);
|
writeInsertStockDetail.setParam("update_time", bookDate);
|
int insertCount = SQLRunner.execSQL(writeInsertStockDetail);
|
result.setInsertCount(insertCount);
|
|
//2. 计入需要修改数量的库存明细
|
NamedSQL writeUpdateStockDetail = NamedSQL.getInstance("writeUpdateStockDetail");
|
writeUpdateStockDetail.setParam("batch_mark", batchMark);
|
writeUpdateStockDetail.setParam("update_time", bookDate);
|
int updateCount = SQLRunner.execSQL(writeUpdateStockDetail);
|
result.setUpdateCount(updateCount);
|
|
//3. 检查负库存
|
NamedSQL getNegativeStockDetail = NamedSQL.getInstance("getNegativeStockDetail");
|
getNegativeStockDetail.setParam("batch_mark", batchMark);
|
EntitySet negativeStock = SQLRunner.getEntitySet(getNegativeStockDetail);
|
|
if (negativeStock.size() > 0) {
|
dataWriter.reportOneError("库存校验", "库存不足，无法过账");
|
|
dataWriter.addValue("negative_stock", negativeStock);
|
|
throw new Exception("库存不足，无法过账");
|
}
|
|
//4. 补充明细账字段（产品分类编码、产品分类名称、产品编码、产品名称、OrderRightName、StockTypeName）
|
NamedSQL resetStockDetailOtherFields = NamedSQL.getInstance("resetStockDetailOtherFields");
|
resetStockDetailOtherFields.setParam("batch_mark", bookCommand.getBatchMark());
|
resetStockDetailOtherFields.execute();
|
|
//5. 删除数量为0的库存明细
|
NamedSQL writeDeleteStockDetail = NamedSQL.getInstance("writeDeleteStockDetail");
|
writeDeleteStockDetail.setParam("batch_mark", batchMark);
|
int deleteCount = SQLRunner.execSQL(writeDeleteStockDetail);
|
result.setDeleteCount(deleteCount);
|
|
//6. 日志并校验
|
logger.debug("库存明细>>计划记账{}条， 插入{} 条，修改{}条， 删除{}条；批次号：{}",
|
result.getPlanCount(), result.getInsertCount(),
|
result.getUpdateCount(), result.getDeleteCount(), batchMark);
|
|
if (!result.isValid()) {
|
// throw new Exception("库存明细记账时存在错误，操作已经终止并回滚");
|
}
|
}
|
|
private String IfEnpty(String one, String another) {
|
if (!Util.isEmpty(one)) {
|
return one;
|
}
|
|
return another;
|
}
|
|
public Object tranferDocumentDocType(Object doc_type) {
|
if ("普通销售出库".equals(doc_type)) {
|
return "普通销售入库";
|
}
|
return doc_type;
|
}
|
|
}
|
