pfz_smile
/
depositroy
2
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
Browse Source

完成拆单入库功能

lwx_dev
erdanergou 3 years ago
parent
e2d5813057
commit
6ceec46fe8
16 changed files with 616 additions and 223 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 52
      src/main/java/com/dreamchaser/depository_manage/controller/MaterialController.java
  2. 2
      src/main/java/com/dreamchaser/depository_manage/controller/SplitController.java
  3. 10
      src/main/java/com/dreamchaser/depository_manage/controller/UserController.java
  4. 9
      src/main/java/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.java
  5. 7
      src/main/java/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.xml
  6. 26
      src/main/java/com/dreamchaser/depository_manage/service/SplitUnitService.java
  7. 247
      src/main/java/com/dreamchaser/depository_manage/service/impl/DepositoryRecordServiceImpl.java
  8. 104
      src/main/java/com/dreamchaser/depository_manage/service/impl/MaterialServiceImpl.java
  9. 282
      src/main/java/com/dreamchaser/depository_manage/service/impl/SplitUnitServiceImpl.java
  10. 2
      src/main/resources/templates/pages/depository/table-stock.html
  11. 9
      src/test/java/com/dreamchaser/depository_manage/TestForOther.java
  12. 7
      target/classes/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.xml
  13. 2
      target/classes/templates/pages/depository/table-stock.html
  14. 1
      target/classes/templates/pages/material/selectMaterial.html
  15. 77
      target/classes/templates/pages/split/split_add.html
  16. 2
      target/classes/templates/pages/warehouse/depository_add.html

52
src/main/java/com/dreamchaser/depository_manage/controller/MaterialController.java
View File

@ -598,33 +598,35 @@ public class MaterialController {
break; break;
} }
} }
}else{ } else {
// 如果是拆单单位 // 如果是拆单单位
for (InventoryP inventoryP : inventoryPList) { for (InventoryP inventoryP : inventoryPList) {
// 获取对应拆单库存处理记录
SplitInventory splitInventory = splitUnitService.findSplitInventoryByIid(inventoryP.getId()); Map<String, Object> paramForSplitInfo = new HashMap<>();
if(splitInventory != null) { paramForSplitInfo.put("mid", inventoryP.getMid());
// 如果存在 paramForSplitInfo.put("newUnit", unit);
// 获取当前拆单记录
// 获取对应拆单记录 SplitInfo splitInfo = splitUnitService.findSplitInfoByMidAndUnit(paramForSplitInfo);
SplitInfo splitInfoById = splitUnitService.findSplitInfoById(splitInventory.getSid());
// 获取当前所有拆单单位 // 获取最高级对应当前单位的数量
int saveQuantity = splitInventory.getSaveQuantity() + inventoryP.getQuantity() * splitInfoById.getQuantity(); int saveQuantity = inventoryP.getQuantity() * splitUnitService.findSplitInfoQuantity(splitInfo);
if (quantity <= saveQuantity) { // 如果当前数量合适则跳出循环
flag = true; SplitInventory splitInventory = splitUnitService.findSplitInventoryByIidAndSid(inventoryP.getId(), splitInfo.getId());
break; saveQuantity += splitInventory.getSaveQuantity();
}
}else{ SplitInfo parentSplitInfo = splitUnitService.findSplitInfoById(splitInfo.getParentId());;
// 如果不存在 while (parentSplitInfo != null){
Map<String,Object> paramForSplitInfo = new HashMap<>(); splitInventory = splitUnitService.findSplitInventoryByIidAndSid(inventoryP.getId(), parentSplitInfo.getId());
paramForSplitInfo.put("mid",inventoryP.getMid()); splitInfo = splitUnitService.findSplitInfoByParentId(parentSplitInfo.getId());
paramForSplitInfo.put("newUnit",unit); saveQuantity += splitInventory.getSaveQuantity() * splitInfo.getQuantity();
SplitInfo splitInfo = splitUnitService.findSplitInfoByMidAndUnit(paramForSplitInfo); parentSplitInfo = splitUnitService.findSplitInfoById(parentSplitInfo.getParentId());
int saveQuantity = inventoryP.getQuantity() * splitInfo.getQuantity(); }
if(quantity <= saveQuantity){
flag = true; if (quantity <= saveQuantity) { // 如果当前数量合适则跳出循环
break; flag = true;
} break;
} }
} }
} }

2
src/main/java/com/dreamchaser/depository_manage/controller/SplitController.java
View File

@ -123,7 +123,7 @@ public class SplitController {
List<Inventory> inventoryByMid = materialService.findInventoryByMid(splitInfoByMidAndUnit.getMid()); List<Inventory> inventoryByMid = materialService.findInventoryByMid(splitInfoByMidAndUnit.getMid());
if(inventoryByMid.size() > 0){ if(inventoryByMid.size() > 0){
Inventory inventory = inventoryByMid.get(0); Inventory inventory = inventoryByMid.get(0);
return new RestResponse(inventory.getPrice() / splitInfoByMidAndUnit.getQuantity()); return new RestResponse(inventory.getPrice() / splitUnitService.findSplitInfoQuantity(splitInfoByMidAndUnit));
} }
}else{ }else{
Integer mid = ObjectFormatUtil.toInteger(map.get("mid")); Integer mid = ObjectFormatUtil.toInteger(map.get("mid"));

10
src/main/java/com/dreamchaser/depository_manage/controller/UserController.java
View File

@ -156,17 +156,17 @@ public class UserController {
JSONObject data = (JSONObject) jsonObject.get("data"); JSONObject data = (JSONObject) jsonObject.get("data");
String userkey = (String) data.get("key"); String userkey = (String) data.get("key");
if(userkey != null) { if(userkey != null) {
String usertoken = (String) data.get("token"); String userToken = (String) data.get("token");
String keyAndToken = userkey + "&" +usertoken; String keyAndToken = userkey + "&" +userToken;
UserByPort userinfo = JSONObject.toJavaObject((JSONObject) data.get("userinfo"), UserByPort.class); UserByPort userinfo = JSONObject.toJavaObject((JSONObject) data.get("userinfo"), UserByPort.class);
// 将key与token暂存至池中保存 // 将key与token暂存至池中保存
UserKeyAndTokenPool.addKeyAndToken(userinfo.getNumber(),keyAndToken); UserKeyAndTokenPool.addKeyAndToken(userinfo.getNumber(),keyAndToken);
AuthenticationTokenPool.addToken(usertoken,userinfo); AuthenticationTokenPool.addToken(userToken,userinfo);
HttpSession session = request.getSession(); HttpSession session = request.getSession();
session.setAttribute("token"+userinfo.getId(),usertoken); session.setAttribute("token"+userinfo.getId(),userToken);
session.setAttribute("userToken",userinfo); session.setAttribute("userToken",userinfo);
session.setMaxInactiveInterval(1800); session.setMaxInactiveInterval(1800);
if(!flag){ if(!flag){
@ -179,7 +179,7 @@ public class UserController {
} }
// 设置放入时间 // 设置放入时间
userinfo.setInstant(Instant.now()); userinfo.setInstant(Instant.now());
return new RestResponse(usertoken); return new RestResponse(userToken);
}else{ }else{
return CrudUtil.NOT_EXIST_USER_OR_ERROR_PWD_RESPONSE; return CrudUtil.NOT_EXIST_USER_OR_ERROR_PWD_RESPONSE;
} }

9
src/main/java/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.java
View File

@ -149,8 +149,15 @@ public interface SplitUnitMapper {
* @param Iid 待查询库存id * @param Iid 待查询库存id
* @return * @return
*/ */
SplitInventory findSplitInventoryByIid(Integer Iid); List<SplitInventory> findSplitInventoryByIid(Integer Iid);
/**
* 根据父级查询拆单记录
* @param parentId 待查询父级
* @return
*/
SplitInfo findSplitInfoByParentId(Integer parentId);
} }

7
src/main/java/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.xml
View File

@ -306,6 +306,13 @@
</if> </if>
</select> </select>
<select id="findSplitInfoByParentId" parameterType="int" resultMap="splitInfoMap">
select
<include refid="splitInfoAllColumns"/>
from `split` s
where s.parentId = #{parentId}
</select>
</mapper> </mapper>

26
src/main/java/com/dreamchaser/depository_manage/service/SplitUnitService.java
View File

@ -98,5 +98,29 @@ public interface SplitUnitService {
* @param Iid 待查询库存id * @param Iid 待查询库存id
* @return * @return
*/ */
SplitInventory findSplitInventoryByIid(Integer Iid); List<SplitInventory> findSplitInventoryByIid(Integer Iid);
/**
* 用于计算当前拆单单位与基础单位之间的进率
*
* @param splitInfo 待查询拆单记录
* @return
*/
int findSplitInfoQuantity(SplitInfo splitInfo);
/**
* 根据库存id与拆单记录id获取对应拆单库存处理记录
* @param Iid 待查询库存id
* @param sid 待查询拆单id
* @return
*/
SplitInventory findSplitInventoryByIidAndSid(Integer Iid,Integer sid);
/**
* 根据父级查询拆单记录
* @param parentId 待查询父级
* @return
*/
SplitInfo findSplitInfoByParentId(Integer parentId);
} }

247
src/main/java/com/dreamchaser/depository_manage/service/impl/DepositoryRecordServiceImpl.java
View File

@ -129,9 +129,9 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
Double amounts = (quantity * price * 100); Double amounts = (quantity * price * 100);
// 获取平均价格 // 获取平均价格
double avgPrice = 0.0; double avgPrice = 0.0;
if(quantity != 0){ if (quantity != 0) {
avgPrice = (amounts) / ( quantity); avgPrice = (amounts) / (quantity);
}else{ } else {
avgPrice = price * 100; avgPrice = price * 100;
} }
@ -171,9 +171,9 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
map.put("newInMid", newMid); map.put("newInMid", newMid);
// 如果包含realQuantity则代表是入库的拆单单位 // 如果包含realQuantity则代表是入库的拆单单位
if(map.containsKey("realQuantity")){ if (map.containsKey("realQuantity")) {
// 将入库数量修改为realQuantity // 将入库数量修改为realQuantity
map.put("quantity",map.get("realQuantity")); map.put("quantity", map.get("realQuantity"));
} }
return depositoryRecordMapper.insertApplicationInRecord(map); return depositoryRecordMapper.insertApplicationInRecord(map);
} }
@ -541,8 +541,8 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
Integer mid = ObjectFormatUtil.toInteger(map.get("mid")); Integer mid = ObjectFormatUtil.toInteger(map.get("mid"));
Material materialById = materialMapper.findMaterialById(mid); Material materialById = materialMapper.findMaterialById(mid);
String unit = (String) map.get("unit"); String unit = (String) map.get("unit");
if("-1".equals(unit)){ if ("-1".equals(unit)) {
map.put("unit",materialById.getUnit()); map.put("unit", materialById.getUnit());
} }
if (placeById.getMax() - placeById.getQuantity() > quantity) { if (placeById.getMax() - placeById.getQuantity() > quantity) {
// 如果当前库位还能存放 // 如果当前库位还能存放
@ -773,7 +773,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
// 获取出库申请时的单位 // 获取出库申请时的单位
String unit = applicationOutMinById.getUnit(); String unit = applicationOutMinById.getUnit();
MaterialAndPlace placeAndMaterialByMidAndPid = null; MaterialAndPlace placeAndMaterialByMidAndPid = null;
if("-1".equals(unit)) { if ("-1".equals(unit)) {
// 如果是按基础单位出库 // 如果是按基础单位出库
@ -801,8 +801,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
restResponse.setStatusInfo(new StatusInfo("出库失败", "当前位置未发现该物料")); restResponse.setStatusInfo(new StatusInfo("出库失败", "当前位置未发现该物料"));
return restResponse; return restResponse;
} }
} } else { // 如果是默认库位
else { // 如果是默认库位
Map<String, Object> params = new HashMap<>(); Map<String, Object> params = new HashMap<>();
params.put("mid", inventory.getId()); params.put("mid", inventory.getId());
params.put("pid", 0); params.put("pid", 0);
@ -845,8 +844,6 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
placeMapper.UpdatePlace(placeById); placeMapper.UpdatePlace(placeById);
// 如果是库存转移订单 // 如果是库存转移订单
Map<String, Object> map = new HashMap<>(); Map<String, Object> map = new HashMap<>();
if (record.getIstransfer() == 1) { if (record.getIstransfer() == 1) {
@ -860,7 +857,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功")); restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功"));
// 进行子订单的相关处理 // 进行子订单的相关处理
updateApplicationMinOutInfo(id,applicationOutMinById,record,trueOut,userByPort,placeId,userAgent); updateApplicationMinOutInfo(id, applicationOutMinById, record, trueOut, userByPort, placeId, userAgent);
// 更新入库批次中的物料数量 // 更新入库批次中的物料数量
new Thread(new Runnable() { new Thread(new Runnable() {
@ -887,30 +884,45 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
} }
} }
}).start(); }).start();
} } else {
else {
restResponse.setStatus(508); restResponse.setStatus(508);
restResponse.setData(""); restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足")); restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足"));
} }
} } else {
else{
// 如果是拆单后的单位 // 如果是拆单后的单位
// 获取拆单库存处理记录
SplitInventory splitInventory = splitUnitMapper.findSplitInventoryByIid(inventory.getId()); // 用于获取对应的拆单记录
if(splitInventory != null) { Map<String, Object> paramForSplitInfo = new HashMap<>();
paramForSplitInfo.put("mid", inventory.getMid());
paramForSplitInfo.put("newUnit", record.getUnit());
// 获取对应拆单记录
SplitInfo splitInfo = splitUnitMapper.findSplitInfoByMidAndUnit(paramForSplitInfo);
// 获取当前拆单库存
Map<String, Object> paramForSplitInventory = new HashMap<>();
paramForSplitInventory.put("sid", splitInfo.getId());
paramForSplitInventory.put("iid", inventory.getId());
SplitInventory splitInventory = splitUnitMapper.findSplitInventoryByIidAndSid(paramForSplitInventory);
if (splitInventory != null) {
// 如果拆单库存处理记录存在 // 如果拆单库存处理记录存在
if (splitInventory.getSaveQuantity() >= trueOut) { if (splitInventory.getSaveQuantity() >= trueOut) {
// 如果当前待处理树可以满足需求 // 如果当前待处理树可以满足需求
splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() - trueOut); splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() - trueOut);
// 设置当前拆单后的出库数量
if (splitInventory.getOutQuantity() != null) { if (splitInventory.getOutQuantity() != null) {
splitInventory.setOutQuantity(splitInventory.getOutQuantity() + trueOut); splitInventory.setOutQuantity(splitInventory.getOutQuantity() + trueOut);
} else { } else {
splitInventory.setOutQuantity(trueOut); splitInventory.setOutQuantity(trueOut);
} }
// 修改库存处理记录
splitUnitMapper.updateSplitInventory(splitInventory); splitUnitMapper.updateSplitInventory(splitInventory);
// 进行子订单的相关处理 // 进行子订单的相关处理
@ -926,100 +938,111 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
// 如果不能满足需求 // 如果不能满足需求
// 获取对应的拆单记录 // 获取对应的拆单记录
SplitInfo splitInfo = splitUnitMapper.findSplitInfoById(splitInventory.getSid()); SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventory.getSid());
// 获取剩余不足的数量 // 获取剩余不足的数量
int surplus = trueOut - splitInventory.getSaveQuantity(); int surplus = trueOut - splitInventory.getSaveQuantity();
if (surplus < splitInfo.getQuantity()) {
// 如果剩余不足的数量小于拆单单位对应的数量
Map<String, Object> params = new HashMap<>(); if (surplus < splitInfoById.getQuantity()) {
params.put("mid", inventory.getId());
params.put("pid", placeId);
// 获取当前物料在库位中的数量 if (splitInfoById.getParentId() != null) {
placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(params); // 如果当前拆单没有父级
if (placeAndMaterialByMidAndPid != null) { // 如果剩余不足的数量小于拆单单位对应的数量
// 如果当前库位存在该物料
if (placeAndMaterialByMidAndPid.getQuantity() < 1) { Map<String, Object> params = new HashMap<>();
// 如果当前库存中的物料库存不足以出库 params.put("mid", inventory.getId());
flag = false; params.put("pid", placeId);
// 获取当前物料在库位中的数量
placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(params);
if (placeAndMaterialByMidAndPid != null) {
// 如果当前库位存在该物料
if (placeAndMaterialByMidAndPid.getQuantity() < 1) {
// 如果当前库存中的物料库存不足以出库
flag = false;
}
} else {
restResponse.setStatus(566);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "当前位置未发现该物料"));
return restResponse;
} }
} else {
restResponse.setStatus(566);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "当前位置未发现该物料"));
return restResponse;
}
// 如果物料数量可以出库并且库位数量充足 // 如果物料数量可以出库并且库位数量充足
if (inventory.getQuantity() >= 1 && flag) { if (inventory.getQuantity() >= 1 && flag) {
// 令库存-1 // 令库存-1
inventory.setQuantity(inventory.getQuantity() - 1); inventory.setQuantity(inventory.getQuantity() - 1);
// 重新计算总额 // 重新计算总额
inventory.setAmounts(inventory.getQuantity() * inventory.getPrice()); inventory.setAmounts(inventory.getQuantity() * inventory.getPrice());
// 重新计算单价 // 重新计算单价
BigDecimal decimal = new BigDecimal(inventory.getAmounts() / inventory.getQuantity()); BigDecimal decimal = new BigDecimal(inventory.getAmounts() / inventory.getQuantity());
Double price = decimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); Double price = decimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
inventory.setPrice(price); inventory.setPrice(price);
// 修改库存记录 // 修改库存记录
materialMapper.updateInventory(inventory); materialMapper.updateInventory(inventory);
// 修改当前库位存放物料的数量 // 修改当前库位存放物料的数量
placeAndMaterialByMidAndPid.setQuantity(placeAndMaterialByMidAndPid.getQuantity() - 1); placeAndMaterialByMidAndPid.setQuantity(placeAndMaterialByMidAndPid.getQuantity() - 1);
placeMapper.updateMaterialAndPlace(placeAndMaterialByMidAndPid); placeMapper.updateMaterialAndPlace(placeAndMaterialByMidAndPid);
// 修改库位数量 // 修改库位数量
Place placeById = placeMapper.findPlaceById(placeId); Place placeById = placeMapper.findPlaceById(placeId);
placeById.setQuantity(placeById.getQuantity() - 1); placeById.setQuantity(placeById.getQuantity() - 1);
placeMapper.UpdatePlace(placeById); placeMapper.UpdatePlace(placeById);
// 如果是库存转移订单 // 如果是库存转移订单
Map<String, Object> map = new HashMap<>(); Map<String, Object> map = new HashMap<>();
if (record.getIstransfer() == 1) { if (record.getIstransfer() == 1) {
map.put("quantity", "1"); map.put("quantity", "1");
map.put("applicantId", record.getApplicantId()); map.put("applicantId", record.getApplicantId());
map.put("minRecordId", applicationOutMinById.getId()); // 出库订单编号 map.put("minRecordId", applicationOutMinById.getId()); // 出库订单编号
transferMaterial(map); transferMaterial(map);
} }
// 设置剩余拆单库存处理数量 // 设置剩余拆单库存处理数量
splitInventory.setSaveQuantity(splitInfo.getQuantity() + splitInventory.getSaveQuantity() - trueOut); splitInventory.setSaveQuantity(splitInfoById.getQuantity() + splitInventory.getSaveQuantity() - trueOut);
splitInventory.setOutQuantity(splitInventory.getOutQuantity() + trueOut); splitInventory.setOutQuantity(splitInventory.getOutQuantity() + trueOut);
splitUnitMapper.updateSplitInventory(splitInventory); splitUnitMapper.updateSplitInventory(splitInventory);
updateApplicationMinOutInfo(id, applicationOutMinById, record, trueOut, userByPort, placeId, userAgent);
restResponse.setStatus(200);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功"));
} else {
restResponse.setStatus(508);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足"));
}
}else{
//如果有父级
updateApplicationMinOutInfo(id, applicationOutMinById, record, trueOut, userByPort, placeId, userAgent);
restResponse.setStatus(200);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功"));
} else {
restResponse.setStatus(508);
restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足"));
} }
} else { } else {
// 如果大于 // 如果大于
// 获取库存重要减少的数量 // 获取库存重要减少的数量
int surplus_redundant = surplus / splitInfo.getQuantity(); int surplus_redundant = surplus / splitInfoById.getQuantity();
// 获取拆单库存处理中要处理数量 // 获取拆单库存处理中要处理数量
int saveQuantity = surplus - surplus_redundant * splitInfo.getQuantity(); int saveQuantity = surplus - surplus_redundant * splitInfoById.getQuantity();
if (saveQuantity > splitInventory.getSaveQuantity()) { if (saveQuantity > splitInventory.getSaveQuantity()) {
// 如果要处理的数量大于剩余数量 // 如果要处理的数量大于剩余数量
// 获取一个数量 // 获取一个数量
surplus_redundant += 1; surplus_redundant += 1;
splitInventory.setSaveQuantity(splitInfo.getQuantity() + splitInventory.getSaveQuantity() - saveQuantity); splitInventory.setSaveQuantity(splitInfoById.getQuantity() + splitInventory.getSaveQuantity() - saveQuantity);
} else { } else {
// 如果不大于 // 如果不大于
splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() - saveQuantity); splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() - saveQuantity);
@ -1095,17 +1118,11 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
} }
} }
}
else{ } else {
// 如果拆单库存处理记录不存在 // 如果拆单库存处理记录不存在
// 用于获取对应的拆单记录 if (inventory.getQuantity() * splitInfo.getQuantity() > trueOut) {
Map<String,Object> paramForSplitInfo = new HashMap<>();
paramForSplitInfo.put("mid",inventory.getMid());
paramForSplitInfo.put("newUnit",record.getUnit());
// 获取对应拆单记录
SplitInfo splitInfo = splitUnitMapper.findSplitInfoByMidAndUnit(paramForSplitInfo);
if(inventory.getQuantity() * splitInfo.getQuantity() > trueOut){
// 如果当前库存数量满足要求 // 如果当前库存数量满足要求
// 获取当前出库的具体数目 // 获取当前出库的具体数目
@ -1138,12 +1155,12 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
placeMapper.UpdatePlace(placeById); placeMapper.UpdatePlace(placeById);
// 添加拆单库存处理记录 // 添加拆单库存处理记录
Map<String,Object> insertSplitInventory = new HashMap<>(); Map<String, Object> insertSplitInventory = new HashMap<>();
insertSplitInventory.put("sid",splitInfo.getId()); insertSplitInventory.put("sid", splitInfo.getId());
insertSplitInventory.put("iid",inventory.getId()); insertSplitInventory.put("iid", inventory.getId());
insertSplitInventory.put("outQuantity",trueOut); insertSplitInventory.put("outQuantity", trueOut);
insertSplitInventory.put("inQuantity",0); insertSplitInventory.put("inQuantity", 0);
insertSplitInventory.put("saveQuantity",splitInfo.getQuantity() - residue_realQuantity); insertSplitInventory.put("saveQuantity", splitInfo.getQuantity() - residue_realQuantity);
splitUnitMapper.addSplitInventory(insertSplitInventory); splitUnitMapper.addSplitInventory(insertSplitInventory);
@ -1163,7 +1180,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功")); restResponse.setStatusInfo(new StatusInfo("出库成功", "出库成功"));
}else { } else {
restResponse.setStatus(508); restResponse.setStatus(508);
restResponse.setData(""); restResponse.setData("");
restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足")); restResponse.setStatusInfo(new StatusInfo("出库失败", "出库失败，库存不足"));
@ -1174,19 +1191,38 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
return restResponse; return restResponse;
} }
/**
* 用于有父级拆单记录的出库处理
* @param splitInfo 当前拆单记录
* @param inventory 当前库存记录
* @return
*/
RestResponse updateSplitInventoryInfo(SplitInfo splitInfo,Inventory inventory){
// 获取当前拆单的父级
SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfo.getParentId());
//
Map<String,Object> paramForSplitInventory = new HashMap<>();
paramForSplitInventory.put("sid",splitInfo.getId());
paramForSplitInventory.put("iid",inventory.getId());
splitUnitMapper.findSplitInventoryByIidAndSid(paramForSplitInventory);
return null;
}
/** /**
* 用于完成出库时的相关处理操作 * 用于完成出库时的相关处理操作
* @param id 子订单id *
* @param id 子订单id
* @param applicationOutMinById 待处理的子订单 * @param applicationOutMinById 待处理的子订单
* @param record 子订单对应的主订单 * @param record 子订单对应的主订单
* @param trueOut 实际出库数量 * @param trueOut 实际出库数量
* @param userByPort 当前登录用户 * @param userByPort 当前登录用户
* @param placeId 出库库位id * @param placeId 出库库位id
* @param userAgent user-agent * @param userAgent user-agent
*/ */
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
void updateApplicationMinOutInfo(Integer id, ApplicationOutRecordMin applicationOutMinById, ApplicationOutRecordP record, Integer trueOut, UserByPort userByPort, Integer placeId, String userAgent){ void updateApplicationMinOutInfo(Integer id, ApplicationOutRecordMin applicationOutMinById, ApplicationOutRecordP record, Integer trueOut, UserByPort userByPort, Integer placeId, String userAgent) {
String redisMinRecordKey = "minRecord:" + id; // 设置redis中子订单键值 String redisMinRecordKey = "minRecord:" + id; // 设置redis中子订单键值
// 修改redis中本子订单状态 // 修改redis中本子订单状态
// redisTemplate.opsForHash().put(redisMinRecordKey,"state","2"); // redisTemplate.opsForHash().put(redisMinRecordKey,"state","2");
@ -1678,8 +1714,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
qyWxOperationService.sendMessageForOtherUserByCard(ObjectFormatUtil.toInteger(id), s, userAgent, 1); qyWxOperationService.sendMessageForOtherUserByCard(ObjectFormatUtil.toInteger(id), s, userAgent, 1);
} }
}).start(); }).start();
} } else {
else {
String result = ""; String result = "";
// 开启线程更改其他用户卡片模板样式 // 开启线程更改其他用户卡片模板样式
String simpleTime = DateUtil.getSimpleTime(new Date()); String simpleTime = DateUtil.getSimpleTime(new Date());

104
src/main/java/com/dreamchaser/depository_manage/service/impl/MaterialServiceImpl.java
View File

@ -628,17 +628,33 @@ public class MaterialServiceImpl implements MaterialService {
m.setTypeId(materialTypeByOldId.getOldId()); m.setTypeId(materialTypeByOldId.getOldId());
m.setWarningCount(warningCount); m.setWarningCount(warningCount);
// 获取当前是否存在拆单处理记录 // 获取当前是否存在拆单处理记录
SplitInventory splitInventoryByIid = splitUnitMapper.findSplitInventoryByIid(m.getId()); List<SplitInventory> splitInventoryList = splitUnitMapper.findSplitInventoryByIid(m.getId());
if (splitInventoryByIid != null) {
if (splitInventoryList.size() > 0) {
// 如果存在拆单库存处理记录 // 如果存在拆单库存处理记录
// 获取拆单信息 // 获取拆单信息
SplitInfo splitInfo = splitUnitMapper.findSplitInfoById(splitInventoryByIid.getSid()); StringBuilder showQuantity = new StringBuilder();
if (Integer.compare(m.getQuantity(), 0) == 0) { double amounts = 0.0;
m.setShowQuantity(splitInfo.getNewUnit() + ":" + splitInventoryByIid.getSaveQuantity()); if (Integer.compare(m.getQuantity(), 0) != 0) {
} else { showQuantity.append(m.getUnit()).append(":").append(m.getQuantity());
m.setShowQuantity(m.getUnit() + ":" + m.getQuantity() + "," + splitInfo.getNewUnit() + ":" + splitInventoryByIid.getSaveQuantity()); }
for (SplitInventory splitInventory : splitInventoryList) {
SplitInfo splitInfo = splitUnitMapper.findSplitInfoById(splitInventory.getSid());
if (Integer.compare(splitInventory.getSaveQuantity(), 0) != 0) {
showQuantity.append(splitInfo.getNewUnit()).append(":").append(splitInventory.getSaveQuantity()).append(" ");
// 计算拆单后的单价
BigDecimal bigDecimal = BigDecimal.valueOf(inventory.getPrice() / splitInfo.getQuantity());
double split_price = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
amounts += split_price * splitInventory.getSaveQuantity();
}
} }
m.setAmounts(m.getAmounts() + amounts);
m.setShowQuantity(showQuantity.toString());
} else { } else {
m.setShowQuantity(m.getUnit() + ":" + m.getQuantity()); m.setShowQuantity(m.getUnit() + ":" + m.getQuantity());
} }
@ -1722,22 +1738,24 @@ public class MaterialServiceImpl implements MaterialService {
if (version == null) { if (version == null) {
version = ""; version = "";
} }
String title = inventory.getMname() + ",规格型号： " + version; StringBuilder title = new StringBuilder(inventory.getMname() + ",规格型号： " + version);
if (inventory.getDepositoryId() != null) { if (inventory.getDepositoryId() != null) {
// 如果当前是库存 // 如果当前是库存
// 获取对应拆单库存处理记录 // 获取对应拆单库存处理记录
title += ",当前库存为：" + inventory.getUnit() + ":" + inventory.getQuantity(); title.append(",当前库存为：").append(inventory.getUnit()).append(":").append(inventory.getQuantity());
SplitInventory splitInventoryByIid = splitUnitMapper.findSplitInventoryByIid(inventory.getId()); List<SplitInventory> splitInventoryList = splitUnitMapper.findSplitInventoryByIid(inventory.getId());
if (splitInventoryByIid != null) { if (splitInventoryList.size() > 0) {
// 如果存在 // 如果存在
// 获取对应的拆单记录 // 获取对应的拆单记录
SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventoryByIid.getSid()); for (SplitInventory splitInventory : splitInventoryList) {
title += "," + splitInventoryByIid.getSaveQuantity() + splitInfoById.getNewUnit(); SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventory.getSid());
title.append(",").append(splitInventory.getSaveQuantity()).append(splitInfoById.getNewUnit());
}
} }
} }
map.put("title", title); map.put("title", title.toString());
map.put("id", inventory.getId()); map.put("id", inventory.getId());
result.add(map); result.add(map);
} }
@ -1749,23 +1767,28 @@ public class MaterialServiceImpl implements MaterialService {
if (version == null) { if (version == null) {
version = ""; version = "";
} }
String title = inventory.getMname() + ",规格型号： " + version; StringBuilder title = new StringBuilder(inventory.getMname() + ",规格型号： " + version);
if (inventory.getDepositoryId() != null) { if (inventory.getDepositoryId() != null) {
// 如果当前是库存 // 如果当前是库存
// 如果当前是库存 // 如果当前是库存
// 获取对应拆单库存处理记录 // 获取对应拆单库存处理记录
title += ",当前库存为：" + inventory.getUnit() + ":" + inventory.getQuantity(); title.append(",当前库存为：").append(inventory.getUnit()).append(":").append(inventory.getQuantity());
SplitInventory splitInventoryByIid = splitUnitMapper.findSplitInventoryByIid(inventory.getId()); List<SplitInventory> splitInventoryList = splitUnitMapper.findSplitInventoryByIid(inventory.getId());
if (splitInventoryByIid != null) { if (splitInventoryList.size() > 0) {
// 如果存在 // 如果存在
// 获取对应的拆单记录 // 获取对应的拆单记录
SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventoryByIid.getSid()); for (SplitInventory splitInventory :
title += "," + splitInventoryByIid.getSaveQuantity() + splitInfoById.getNewUnit(); splitInventoryList) {
SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventory.getSid());
title.append(",").append(splitInventory.getSaveQuantity()).append(splitInfoById.getNewUnit());
}
} }
} }
map.put("title", title); map.put("title", title.toString());
map.put("id", inventory.getId()); map.put("id", inventory.getId());
result.add(map); result.add(map);
} }
@ -2379,7 +2402,7 @@ public class MaterialServiceImpl implements MaterialService {
materialByTypeIds = materialMapper.findMaterialByTypeIdsAndMname(paramForMnameAndMtid); materialByTypeIds = materialMapper.findMaterialByTypeIdsAndMname(paramForMnameAndMtid);
} else if ("2".equals(type)) { } else if ("2".equals(type)) {
inventoryByTypeIdsAndMname= materialMapper.findInventoryByTypeIdsAndMname(paramForMnameAndMtid); inventoryByTypeIdsAndMname = materialMapper.findInventoryByTypeIdsAndMname(paramForMnameAndMtid);
} }
// 查询当前物料类型所包含的物料 // 查询当前物料类型所包含的物料
@ -2393,7 +2416,7 @@ public class MaterialServiceImpl implements MaterialService {
// 1.定义CompletionService // 1.定义CompletionService
CompletionService<Object> completionService = new ExecutorCompletionService<Object>(exs); CompletionService<Object> completionService = new ExecutorCompletionService<Object>(exs);
if("1".equals(type)) { if ("1".equals(type)) {
for (MaterialType mt : materialTypeByOldIds) { for (MaterialType mt : materialTypeByOldIds) {
// 获取当前物料类型 // 获取当前物料类型
// 开启对应线程 // 开启对应线程
@ -2401,7 +2424,7 @@ public class MaterialServiceImpl implements MaterialService {
// 添加到线程结果列表 // 添加到线程结果列表
futureList.add(future); futureList.add(future);
} }
}else if("2".equals(type)){ } else if ("2".equals(type)) {
for (MaterialType mt : materialTypeByOldIds) { for (MaterialType mt : materialTypeByOldIds) {
// 获取当前物料类型 // 获取当前物料类型
// 开启对应线程 // 开启对应线程
@ -2459,7 +2482,7 @@ public class MaterialServiceImpl implements MaterialService {
List<Inventory> inventoryList = new ArrayList<>(); List<Inventory> inventoryList = new ArrayList<>();
// 将物料打包成树结构对应结果 // 将物料打包成树结构对应结果
List<Object> objectList = new ArrayList<>(); List<Object> objectList = new ArrayList<>();
if("1".equals(type)) { if ("1".equals(type)) {
for (int i = 0; i < materiaList.size(); i++) { for (int i = 0; i < materiaList.size(); i++) {
Material material = materiaList.get(i); Material material = materiaList.get(i);
// 如果当前物料是当前物料类型下的物料 // 如果当前物料是当前物料类型下的物料
@ -2467,8 +2490,8 @@ public class MaterialServiceImpl implements MaterialService {
materialList.add(material); materialList.add(material);
} }
} }
objectList = AddMaterialByTypeForSelectMname(materialList, null); objectList = AddMaterialByTypeForSelectMname(materialList, null);
}else if("2".equals(type)){ } else if ("2".equals(type)) {
for (int i = 0; i < inventorys.size(); i++) { for (int i = 0; i < inventorys.size(); i++) {
Inventory inventory = inventorys.get(i); Inventory inventory = inventorys.get(i);
// 如果当前物料是当前物料类型下的物料 // 如果当前物料是当前物料类型下的物料
@ -2476,7 +2499,7 @@ public class MaterialServiceImpl implements MaterialService {
inventoryList.add(inventory); inventoryList.add(inventory);
} }
} }
objectList = AddMaterialByTypeForSelectMname(null,inventoryList); objectList = AddMaterialByTypeForSelectMname(null, inventoryList);
} }
// 封装成对应的结构 // 封装成对应的结构
@ -2500,9 +2523,9 @@ public class MaterialServiceImpl implements MaterialService {
} }
// 在类别后添加物料名称（通过物料名称搜索) // 在类别后添加物料名称（通过物料名称搜索)
public List<Object> AddMaterialByTypeForSelectMname(List<Material> materialList,List<Inventory> inventoryList) { public List<Object> AddMaterialByTypeForSelectMname(List<Material> materialList, List<Inventory> inventoryList) {
List<Object> result = new ArrayList<>(); List<Object> result = new ArrayList<>();
if(materialList!=null) { if (materialList != null) {
for (Material material : materialList) { for (Material material : materialList) {
Map<String, Object> map = new HashMap<>(); Map<String, Object> map = new HashMap<>();
String version = material.getVersion(); String version = material.getVersion();
@ -2515,25 +2538,30 @@ public class MaterialServiceImpl implements MaterialService {
map.put("id", material.getId()); map.put("id", material.getId());
result.add(map); result.add(map);
} }
}else if(inventoryList != null){ } else if (inventoryList != null) {
for (Inventory inventory : inventoryList) { for (Inventory inventory : inventoryList) {
Map<String, Object> map = new HashMap<>(); Map<String, Object> map = new HashMap<>();
String version = inventory.getVersion(); String version = inventory.getVersion();
if (version == null) { if (version == null) {
version = ""; version = "";
} }
String title = ""; StringBuilder title = new StringBuilder();
title = inventory.getMname() + ",规格型号： " + version+"，库存数量："+inventory.getUnit() +":"+inventory.getQuantity(); title = new StringBuilder(inventory.getMname() + ",规格型号： " + version + "，库存数量：" + inventory.getUnit() + ":" + inventory.getQuantity());
// 获取对应拆单库存处理记录 // 获取对应拆单库存处理记录
SplitInventory splitInventoryByIid = splitUnitMapper.findSplitInventoryByIid(inventory.getId()); List<SplitInventory> splitInventoryList = splitUnitMapper.findSplitInventoryByIid(inventory.getId());
if(splitInventoryByIid != null){ if (splitInventoryList.size() > 0) {
// 如果不为空 // 如果不为空
// 获取对应拆单信息 // 获取对应拆单信息
SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventoryByIid.getSid()); for (SplitInventory splitInventory :
title +="，"+splitInfoById.getNewUnit()+":"+splitInventoryByIid.getSaveQuantity(); splitInventoryList) {
SplitInfo splitInfoById = splitUnitMapper.findSplitInfoById(splitInventory.getSid());
title.append("，").append(splitInfoById.getNewUnit()).append(":").append(splitInventory.getSaveQuantity());
}
} }
map.put("title", title); map.put("title", title.toString());
map.put("id", inventory.getId()); map.put("id", inventory.getId());
result.add(map); result.add(map);
} }

282
src/main/java/com/dreamchaser/depository_manage/service/impl/SplitUnitServiceImpl.java
View File

@ -1,16 +1,11 @@
package com.dreamchaser.depository_manage.service.impl; package com.dreamchaser.depository_manage.service.impl;
import com.dreamchaser.depository_manage.entity.Inventory; import com.dreamchaser.depository_manage.entity.*;
import com.dreamchaser.depository_manage.entity.SplitInfo;
import com.dreamchaser.depository_manage.entity.SplitInventory;
import com.dreamchaser.depository_manage.exception.MyException;
import com.dreamchaser.depository_manage.mapper.*; import com.dreamchaser.depository_manage.mapper.*;
import com.dreamchaser.depository_manage.pojo.SplitInfoP; import com.dreamchaser.depository_manage.pojo.SplitInfoP;
import com.dreamchaser.depository_manage.service.DepositoryRecordService; import com.dreamchaser.depository_manage.service.DepositoryRecordService;
import com.dreamchaser.depository_manage.service.MaterialService;
import com.dreamchaser.depository_manage.service.SplitUnitService; import com.dreamchaser.depository_manage.service.SplitUnitService;
import com.dreamchaser.depository_manage.utils.ObjectFormatUtil; import com.dreamchaser.depository_manage.utils.ObjectFormatUtil;
import com.sun.mail.imap.protocol.ID;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
@ -91,11 +86,10 @@ public class SplitUnitServiceImpl implements SplitUnitService {
// 用于存储最终计算结果 // 用于存储最终计算结果
Integer result = 0; Integer result = 0;
if (splitInfoForUnit != null) {
if (splitInfoForUnit != null) {
// 获取当前进制 // 获取当前进制
// Integer scale = findSplitInfoQuantity(splitInfoForUnit); Integer scale = splitInfoForUnit.getQuantity();
Integer scale = findSplitInfoQuantity(splitInfoForUnit);
// 获取当前处理的类型 // 获取当前处理的类型
String type = (String) map.get("type"); String type = (String) map.get("type");
@ -117,15 +111,14 @@ public class SplitUnitServiceImpl implements SplitUnitService {
// 获取对应的库存记录 // 获取对应的库存记录
inventory = materialMapper.findInventoryById(iid); inventory = materialMapper.findInventoryById(iid);
} else { } else {
Map<String, Object> param = new HashMap<>(); Map<String, Object> param = new HashMap<>();
param.put("depositoryId", map.get("depositoryId")); param.put("depositoryId", map.get("depositoryId"));
param.put("mid", map.get("mid")); param.put("mid", map.get("mid"));
// 判断该仓库中有无该物物料 // 判断该仓库中有无该物物料
List<Inventory> materialByCondition = materialMapper.findInventory(param); List<Inventory> inventoryList = materialMapper.findInventory(param);
if (materialByCondition.size() > 0) { if (inventoryList.size() > 0) {
inventory = materialByCondition.get(0); inventory = inventoryList.get(0);
paramForInsertSplitInventory.put("iid", inventory.getId()); paramForInsertSplitInventory.put("iid", inventory.getId());
@ -144,15 +137,20 @@ public class SplitUnitServiceImpl implements SplitUnitService {
// 最终存储到拆单处理的数量 // 最终存储到拆单处理的数量
double saveQuantity = quantity - disposeQuantity * scale; double saveQuantity = quantity - disposeQuantity * scale;
if (splitInventory != null) { if (splitInventory != null) {
// 如果有过记录 // 如果有过记录
// 最终存储数量 // 最终存储数量
int realQuantity = (int) Math.round(saveQuantity) + splitInventory.getSaveQuantity(); int realQuantity = (int) Math.round(saveQuantity) + splitInventory.getSaveQuantity();
if (realQuantity > scale) { if (realQuantity >= scale) {
// 如果当前入库的数量大于拆单规定的进制数量 // 如果当前入库的数量大于拆单规定的进制数量
int quantity_in = realQuantity - (realQuantity / scale);
// 计算要进的数目
int quantity_in = (realQuantity / scale) ;
// 更新处理数量
disposeQuantity += quantity_in; disposeQuantity += quantity_in;
// 拆单库存实际入库的数量
realQuantity = realQuantity - quantity_in * scale; realQuantity = realQuantity - quantity_in * scale;
} }
// 设置当前计量单位的库存 // 设置当前计量单位的库存
@ -165,7 +163,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
splitInventory.setInQuantity((int) Math.round(quantity)); splitInventory.setInQuantity((int) Math.round(quantity));
} }
splitUnitMapper.updateSplitInventory(splitInventory); result += splitUnitMapper.updateSplitInventory(splitInventory);
if (disposeQuantity != 0) { if (disposeQuantity != 0) {
// 用于更改库存的数量 // 用于更改库存的数量
@ -176,25 +174,101 @@ public class SplitUnitServiceImpl implements SplitUnitService {
} }
// 实际入库数量 // 实际入库数量
map.put("realQuantity", quantity.toString()); map.put("realQuantity", quantity.toString());
result += depositoryRecordService.applicationInPlace(map); if (splitInfoForUnit.getParentId() != null) {
} else { SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
updateSplitInfoSaveQuantity(parentSplitInfo, disposeQuantity, inventory.getId(), map,quantity.intValue());
} else {
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfoForUnit);
map.put("price",price.toString());
depositoryRecordService.applicationInPlace(map);
}
}
else {
// 如果没有记录 // 如果没有记录
// 获取当前拆单记录的父级
Integer parentId = splitInfoForUnit.getParentId();
if (disposeQuantity != 0) { if (disposeQuantity != 0) {
// 用于更改库存的数量 // 用于更改库存的数量
map.put("quantity", String.valueOf(disposeQuantity)); map.put("quantity", String.valueOf(disposeQuantity));
} else { } else {
map.put("quantity", "0"); map.put("quantity", "0");
} }
// 实际入库数量
map.put("realQuantity", quantity.toString());
result += depositoryRecordService.applicationInPlace(map);
paramForInsertSplitInventory.put("inQuantity", quantity); if (disposeQuantity > splitInfoForUnit.getQuantity()) {
paramForInsertSplitInventory.put("outQuantity", 0); //如果当前处理数量大于设置的进制数量
paramForInsertSplitInventory.put("saveQuantity", saveQuantity);
paramForInsertSplitInventory.put("iid", map.get("newInMid")); // 实际入库数量
splitUnitMapper.addSplitInventory(paramForInsertSplitInventory); map.put("realQuantity", quantity.toString());
if (parentId != null) {
// 如果该记录有父级拆单
SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(parentId);
if (inventory != null) {
updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), inventory.getId(), map,quantity.intValue());
} else {
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfoForUnit);
map.put("price",price.toString());
result += depositoryRecordService.applicationInPlace(map);
updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), ObjectFormatUtil.toInteger(map.get("newInMid")), map,quantity.intValue());
}
} else {
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfoForUnit);
map.put("price",price.toString());
result += depositoryRecordService.applicationInPlace(map);
}
} else {
// 如果不大于设置的进制数量
paramForInsertSplitInventory.put("inQuantity", quantity);
paramForInsertSplitInventory.put("outQuantity", 0);
paramForInsertSplitInventory.put("saveQuantity", saveQuantity);
if (inventory != null) {
// 如果有库存记录
paramForInsertSplitInventory.put("iid", inventory.getId());
} else {
// 如果没有库存记录
// 插入一条库存记录
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfoForUnit);
map.put("price",price.toString());
if(parentId != null){
// 如果有父级
// 先插入一条库存记录用于后续操作
map.put("quantity","0");
result += depositoryRecordService.applicationInPlace(map);
}else{
// 如果没有父级
result += depositoryRecordService.applicationInPlace(map);
}
paramForInsertSplitInventory.put("iid", map.get("newInMid"));
}
splitUnitMapper.addSplitInventory(paramForInsertSplitInventory);
if(parentId != null){
// 获取父级
SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
updateSplitInfoSaveQuantity(parentSplitInfo,disposeQuantity,ObjectFormatUtil.toInteger(map.get("newInMid")),map,quantity.intValue());
}
}
} }
} }
} }
@ -209,7 +283,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
* @param splitInfo 待查询拆单记录 * @param splitInfo 待查询拆单记录
* @return * @return
*/ */
private int findSplitInfoQuantity(SplitInfo splitInfo) { public int findSplitInfoQuantity(SplitInfo splitInfo) {
int quantity = 1; int quantity = 1;
quantity *= splitInfo.getQuantity(); quantity *= splitInfo.getQuantity();
if (splitInfo.getParentId() != null) { if (splitInfo.getParentId() != null) {
@ -220,6 +294,158 @@ public class SplitUnitServiceImpl implements SplitUnitService {
} }
} }
/**
* 根据库存id与拆单记录id获取对应拆单库存处理记录
* @param Iid 待查询库存id
* @param sid 待查询拆单id
* @return
*/
@Override
public SplitInventory findSplitInventoryByIidAndSid(Integer Iid, Integer sid) {
Map<String,Object> param = new HashMap<>();
param.put("iid",Iid);
param.put("sid",sid);
return splitUnitMapper.findSplitInventoryByIidAndSid(param);
}
/**
* 根据父级查询拆单记录
* @param parentId 待查询父级
* @return
*/
@Override
public SplitInfo findSplitInfoByParentId(Integer parentId) {
return splitUnitMapper.findSplitInfoByParentId(parentId);
}
/**
* 用于拆单库存处理记录的修改
* @param splitInfo 对应拆单记录
* @param quantity 修改数目
* @param map 入库条件
* @param inQuantity 最终入库数量
*/
private void updateSplitInfoSaveQuantity(SplitInfo splitInfo, int quantity, int iid, Map<String, Object> map,int inQuantity) {
int result = 0;
// 获取当前拆单记录的父级拆单记录
Integer parentId = splitInfo.getParentId();
// 获取当前拆单记录对应的拆开库存处理记录
Map<String, Object> paramForSplitInventory = new HashMap<>();
paramForSplitInventory.put("iid", iid);
paramForSplitInventory.put("sid", splitInfo.getId());
SplitInventory splitInventory = splitUnitMapper.findSplitInventoryByIidAndSid(paramForSplitInventory);
// 获取当前进制
int scale = splitInfo.getQuantity();
// 计算处理数量(下取整)
int disposeQuantity = (int) Math.round(Math.floor(quantity / scale));
// 最终存储到拆单处理的数量
double saveQuantity = quantity - disposeQuantity * scale;
if (splitInventory != null) {
// 如果拆单库存处理记录不为空
if (splitInventory.getSaveQuantity() + saveQuantity > splitInfo.getQuantity()) {
// 当前库存拆单记录与新入库的数目大于预设的进制
// 定义当前实际修改数量
double new_saveQuantity = splitInventory.getSaveQuantity() + saveQuantity - splitInfo.getQuantity();
// 令计算处理数量+1
disposeQuantity += 1;
// 定义保存数量
splitInventory.setSaveQuantity((int) (splitInventory.getSaveQuantity() + new_saveQuantity));
// 定义添加数量
splitInventory.setInQuantity((int) (splitInventory.getInQuantity() + new_saveQuantity));
// 修改库存拆单库存处理记录
splitUnitMapper.updateSplitInventory(splitInventory);
if (parentId != null) {
// 如果当前拆单的父级不为空
// 获取具体父级
SplitInfo splitInfoForParent = splitUnitMapper.findSplitInfoById(parentId);
updateSplitInfoSaveQuantity(splitInfoForParent, disposeQuantity, splitInventory.getIid(), map,inQuantity);
} else {
// 如果为空
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfo);
map.put("price",price.toString());
map.put("quantity", String.valueOf(disposeQuantity));
map.put("realQuantity", String.valueOf(inQuantity));
depositoryRecordService.applicationInPlace(map);
}
}
else {
// 当前库存拆单记录与新入库的数目不大于预设的进制
splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() + disposeQuantity);
splitInventory.setInQuantity(splitInventory.getInQuantity() + disposeQuantity);
splitUnitMapper.updateSplitInventory(splitInventory);
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfo);
map.put("price",price.toString());
map.put("quantity", "0");
map.put("realQuantity", String.valueOf(inQuantity));
depositoryRecordService.applicationInPlace(map);
}
}
else {
// 如果为空
Map<String, Object> paramForInsertSplitInventory = new HashMap<>();
paramForInsertSplitInventory.put("sid", splitInfo.getId());
paramForInsertSplitInventory.put("inQuantity", quantity);
paramForInsertSplitInventory.put("outQuantity", 0);
paramForInsertSplitInventory.put("iid", map.get("newInMid"));
if (quantity > splitInfo.getQuantity()) {
// 如果当前处理数量大于当前设置的进制数量
// 计算需要进位的数量
int quantity_scale = quantity / splitInfo.getQuantity();
// 计算剩余处理的数量
int quantity_residue = quantity - quantity_scale * splitInfo.getQuantity();
paramForInsertSplitInventory.put("saveQuantity", quantity_residue);
splitUnitMapper.addSplitInventory(paramForInsertSplitInventory);
if (parentId != null) {
// 如果其有父级
// 获取当前拆单记录的父级
SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(parentId);
updateSplitInfoSaveQuantity(parentSplitInfo, quantity_scale, iid, map,inQuantity);
} else {
Double price = Double.parseDouble((String) map.get("price"));
price = price * findSplitInfoQuantity(splitInfo);
map.put("price",price.toString());
map.put("quantity", String.valueOf(quantity_scale));
map.put("realQuantity", String.valueOf(inQuantity));
depositoryRecordService.applicationInPlace(map);
}
} else {
// 如果不大于
paramForInsertSplitInventory.put("saveQuantity", String.valueOf(inQuantity));
splitUnitMapper.addSplitInventory(paramForInsertSplitInventory);
map.put("quantity", "0");
map.put("realQuantity", String.valueOf(inQuantity));
depositoryRecordService.applicationInPlace(map);
}
}
}
/** /**
* 根据条件查询对应拆单详细信息 * 根据条件查询对应拆单详细信息
* *
@ -385,7 +611,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
* @return * @return
*/ */
@Override @Override
public SplitInventory findSplitInventoryByIid(Integer Iid) { public List<SplitInventory> findSplitInventoryByIid(Integer Iid) {
return splitUnitMapper.findSplitInventoryByIid(Iid); return splitUnitMapper.findSplitInventoryByIid(Iid);
} }

2
src/main/resources/templates/pages/depository/table-stock.html
View File

@ -169,7 +169,7 @@
} }
// 所处库位 // 所处库位
var placeCodeItem = $("[lay-id='currentTableId'] tr:eq(" + (i+1) + ")").children()[9]; var placeCodeItem = $("[lay-id='currentTableId'] tr:eq(" + (i+1) + ")").children()[8];
var aItem = placeCodeItem.childNodes[0]; var aItem = placeCodeItem.childNodes[0];
for (let k = 0; k < placeCode.length; k++) { for (let k = 0; k < placeCode.length; k++) {
if(placeCode[k] !== ""){ if(placeCode[k] !== ""){

9
src/test/java/com/dreamchaser/depository_manage/TestForOther.java
View File

@ -1,8 +1,12 @@
package com.dreamchaser.depository_manage; package com.dreamchaser.depository_manage;
import com.dreamchaser.depository_manage.entity.SplitInfo; import com.dreamchaser.depository_manage.entity.SplitInfo;
import com.dreamchaser.depository_manage.entity.SplitInventory;
import com.dreamchaser.depository_manage.mapper.SplitUnitMapper; import com.dreamchaser.depository_manage.mapper.SplitUnitMapper;
import com.dreamchaser.depository_manage.pojo.InventoryP;
import com.dreamchaser.depository_manage.service.SplitUnitService;
import com.dreamchaser.depository_manage.utils.CreateQrCodeUtil; import com.dreamchaser.depository_manage.utils.CreateQrCodeUtil;
import com.dreamchaser.depository_manage.utils.ObjectFormatUtil;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
@ -24,10 +28,13 @@ import java.io.OutputStream;
public class TestForOther { public class TestForOther {
@Test @Test
public void Test() throws IOException { public void Test() throws IOException {
Double a = 24.0;
System.out.println(a.intValue());
} }
} }

7
target/classes/com/dreamchaser/depository_manage/mapper/SplitUnitMapper.xml
View File

@ -306,6 +306,13 @@
</if> </if>
</select> </select>
<select id="findSplitInfoByParentId" parameterType="int" resultMap="splitInfoMap">
select
<include refid="splitInfoAllColumns"/>
from `split` s
where s.parentId = #{parentId}
</select>
</mapper> </mapper>

2
target/classes/templates/pages/depository/table-stock.html
View File

@ -169,7 +169,7 @@
} }
// 所处库位 // 所处库位
var placeCodeItem = $("[lay-id='currentTableId'] tr:eq(" + (i+1) + ")").children()[9]; var placeCodeItem = $("[lay-id='currentTableId'] tr:eq(" + (i+1) + ")").children()[8];
var aItem = placeCodeItem.childNodes[0]; var aItem = placeCodeItem.childNodes[0];
for (let k = 0; k < placeCode.length; k++) { for (let k = 0; k < placeCode.length; k++) {
if(placeCode[k] !== ""){ if(placeCode[k] !== ""){

1
target/classes/templates/pages/material/selectMaterial.html
View File

@ -23,6 +23,7 @@
var tempData = []; var tempData = [];
var req = {}; var req = {};
req.mname = mname; req.mname = mname;
req.type = "1";
var test = tree.render({ var test = tree.render({
elem: '#test2' elem: '#test2'
, data: [] , data: []

77
target/classes/templates/pages/split/split_add.html
View File

@ -34,10 +34,10 @@
padding-right: 0px; padding-right: 0px;
} }
.inputdiv .layui-unselect { .layui-form-select{
border-style: none;
width: 100%; width: 100%;
} }
</style> </style>
<div class="layuimini-container"> <div class="layuimini-container">
<div class="layuimini-main"> <div class="layuimini-main">
@ -119,8 +119,9 @@
<label class="layui-form-label">计量单位:</label> <label class="layui-form-label">计量单位:</label>
<div class="layui-input-block"> <div class="layui-input-block">
<input type="text" name="oldUnit" class="layui-input" id="unit" readonly <select id="unit" name="oldUnit">
lay-verify="required"/>
</select>
</div> </div>
</div> </div>
@ -240,7 +241,7 @@
codeValue.val(""); codeValue.val("");
version.val(""); version.val("");
typeName.val(""); typeName.val("");
unit.val(""); unit.empty();
return false; return false;
} else if (d.count === 0) { } else if (d.count === 0) {
layer.msg("没有该物品，请确认输入是否正确"); layer.msg("没有该物品，请确认输入是否正确");
@ -249,7 +250,7 @@
materialName.val(""); materialName.val("");
version.val(""); version.val("");
typeName.val(""); typeName.val("");
unit.val(""); unit.empty();
return false; return false;
} else { } else {
var material = d.data[0]; var material = d.data[0];
@ -258,7 +259,34 @@
codeValue.val(material.code); codeValue.val(material.code);
version.val(material.version); version.val(material.version);
typeName.val(material.typeName); typeName.val(material.typeName);
unit.val(material.unit);
unit.append(new Option(material.unit,material.unit));
var splitInfoList = material["splitInfoList"];
$.each(splitInfoList,function (index,item) {
$("#unit").append(new Option(item.newUnit, item.newUnit));//往下拉菜单里添加元素
});
form.render();
var materialAndBarCodeList = material["materialAndBarCodeList"];
if (materialAndBarCodeList !== null && materialAndBarCodeList.length > 0) {
// 如果有对应的条形码
$("#barCode").remove();
var barCodeSelect = `
<select id="barCode" name= "barCode"></select>`;
$("#barCodeImg").before(barCodeSelect);
form.render();
$.each(materialAndBarCodeList, function (index, item) {
$("#barCode").append(new Option(item.bmcode, item.id));//往下拉菜单里添加元素
});
form.render();
}else{
let children = $("#barCode").parent().children();
if(children.length > 2){
$("#barCode").empty();
$(children[1]).empty();
}
}
} }
} }
}); });
@ -301,10 +329,16 @@
} }
$("#code").val(code); $("#code").val(code);
$("#version").val(material.version); $("#version").val(material.version);
$("#unit").val(material.unit); $("#unit").append(new Option(material.unit,material.unit));
var splitInfoList = material["splitInfoList"];
$.each(splitInfoList,function (index,item) {
$("#unit").append(new Option(item.newUnit, item.newUnit));//往下拉菜单里添加元素
});
form.render();
$("#typeName").val(material.typeName); $("#typeName").val(material.typeName);
var materialAndBarCodeList = material["materialAndBarCodeList"]; var materialAndBarCodeList = material["materialAndBarCodeList"];
if (materialAndBarCodeList.length > 0) {
if (materialAndBarCodeList !== null && materialAndBarCodeList.length > 0) {
// 如果有对应的条形码 // 如果有对应的条形码
$("#barCode").remove(); $("#barCode").remove();
var barCodeSelect = ` var barCodeSelect = `
@ -315,6 +349,12 @@
$("#barCode").append(new Option(item.bmcode, item.id));//往下拉菜单里添加元素 $("#barCode").append(new Option(item.bmcode, item.id));//往下拉菜单里添加元素
}); });
form.render(); form.render();
}else{
let children = $("#barCode").parent().children();
if(children.length > 2){
$("#barCode").empty();
$(children[1]).empty();
}
} }
} }
}); });
@ -406,7 +446,7 @@
$("#code").val(""); $("#code").val("");
$("#barCode").val(""); $("#barCode").val("");
$("#version").val(""); $("#version").val("");
$("#unit").val(""); $("#unit").empty();
$("#typeName").val(""); $("#typeName").val("");
form.render(); form.render();
@ -414,11 +454,17 @@
$("#mname").val(d.mname); $("#mname").val(d.mname);
$("#mid").val( d.mid); $("#mid").val( d.mid);
$("#version").val(d.version); $("#version").val(d.version);
$("#unit").val(d.unit); $("#unit").empty();
$('#unit').append(new Option(d.unit,d.unit));
var splitInfoList = d["splitInfoList"];
$.each(splitInfoList,function (index,item) {
$("#unit").append(new Option(item.newUnit, item.newUnit));//往下拉菜单里添加元素
});
form.render();
$("#typeName").val(d.typeName); $("#typeName").val(d.typeName);
// 获取物料与条形码的对应关系 // 获取物料与条形码的对应关系
var materialAndBarCodeList = d["materialAndBarCodeList"]; var materialAndBarCodeList = d["materialAndBarCodeList"];
if (materialAndBarCodeList.length > 0) { if (materialAndBarCodeList !== null && materialAndBarCodeList.length > 0) {
// 如果有对应的条形码 // 如果有对应的条形码
$("#barCode").remove(); $("#barCode").remove();
$(".layui-unselect").remove(); $(".layui-unselect").remove();
@ -433,8 +479,11 @@
}); });
form.render(); form.render();
} else { } else {
$("#barCode").remove(); let children = $("#barCode").parent().children();
$(".layui-unselect").remove(); if(children.length > 2){
$("#barCode").empty();
$(children[1]).empty();
}
} }
} }

2
target/classes/templates/pages/warehouse/depository_add.html
View File

@ -112,7 +112,7 @@
dataType:'json', dataType:'json',
contentType: "application/json;charset=utf-8", contentType: "application/json;charset=utf-8",
success:function(d){ success:function(d){
if(data.value != "") { if(data.value !== "") {
$('#adminorg').empty(); $('#adminorg').empty();
$('#adminorg').append(new Option("请选择部门", "")); $('#adminorg').append(new Option("请选择部门", ""));
$.each(d.data, function (index, item) { $.each(d.data, function (index, item) {

Write Preview
Loading…
Cancel
Save