SOPHAL/ERP
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First commit (wating to add alerts in budget)

Browse Source
This commit is contained in:
BACHIR SOULDI
2025-09-04 13:21:24 +01:00
parent f70bf3341b
commit 9eb959f07a
192 changed files with 51034 additions and 4992 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/exceptions/IExceptionMessage.java
View File

@@ -147,4 +147,6 @@ public interface IExceptionMessage {
static final String UNIT_COST_CALCULATION_NO_PRODUCT = /*$$(*/
"Please select an element (a product, a product category or a product family) to run calculation" /*)*/;
static final String STOCK_MOVE_NOT_VALIDATED = /*$$(*/ "Stock move not validated by SCH" /*)*/;
}

58
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/BillOfMaterialServiceImpl.java
View File

@@ -24,8 +24,11 @@ import com.axelor.apps.base.service.ProductService;
import com.axelor.apps.base.service.app.AppBaseService;
import com.axelor.apps.production.db.BillOfMaterial;
import com.axelor.apps.production.db.BillOfMaterialConsumption;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.TempBomTree;
import com.axelor.apps.production.db.repo.BillOfMaterialConsumptionRepository;
import com.axelor.apps.production.db.repo.BillOfMaterialRepository;
import com.axelor.apps.production.db.repo.ManufOrderRepository;
import com.axelor.apps.production.db.repo.TempBomTreeRepository;
import com.axelor.apps.production.exceptions.IExceptionMessage;
import com.axelor.apps.production.report.IReport;
@@ -50,7 +53,6 @@ import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.axelor.apps.production.db.repo.BillOfMaterialConsumptionRepository;
public class BillOfMaterialServiceImpl implements BillOfMaterialService {
@@ -373,23 +375,67 @@ public class BillOfMaterialServiceImpl implements BillOfMaterialService {
return newBom;
}
@Transactional
public BillOfMaterialConsumption createBomConsumptionFromRawMaterial(BillOfMaterial bom) {
public BillOfMaterialConsumption createBomConsumptionFromRawMaterial(
BillOfMaterial bom, ManufOrder manufOrder) {
BillOfMaterialConsumption newBom = new BillOfMaterialConsumption();
newBom.setDefineSubBillOfMaterial(false);
newBom.setPriority(bom.getPriority());
newBom.setProduct(bom.getProduct());
newBom.setQty(bom.getQty());
newBom.setRealQty(bom.getQty());
newBom.setUnit(bom.getUnit());
newBom.setUnit(bom.getUnit());
newBom.setName(bom.getName());
newBom.setFullName(bom.getFullName());
// billOfMaterialConsumptionRepository.save(newBom);
newBom.setManufOrder(manufOrder);
return newBom;
}
@Transactional
public void createBomAndAttachToManufOrder(ManufOrder manufOrder) {
if (manufOrder.getBillOfMaterial() != null
&& manufOrder.getBillOfMaterialConsumptionList().size() == 0) {
for (BillOfMaterial bom : manufOrder.getBillOfMaterial().getBillOfMaterialSet()) {
BillOfMaterialConsumption newBom =
Beans.get(BillOfMaterialServiceImpl.class)
.createBomConsumptionFromRawMaterial(bom, manufOrder);
manufOrder.addBillOfMaterialConsumptionListItem(newBom);
}
log.debug(
"Bill of Material Consumption List size: {}",
manufOrder.getBillOfMaterialConsumptionList().size());
Beans.get(ManufOrderRepository.class).save(manufOrder);
}
}
/**
* Splits the Bill of Material consumption line into two lines.
*
* @param manufOrder
* @param billConsumptionList
* @param splitQty
*/
@Transactional
public void splitBillOfMaterialConsumption(
ManufOrder manufOrder,
List<BillOfMaterialConsumption> billConsumptionList,
BigDecimal splitQty) {
for (BillOfMaterialConsumption billOfMaterialConsumption : billConsumptionList) {
BigDecimal totalQty = billOfMaterialConsumption.getQty();
totalQty = totalQty.subtract(splitQty);
BillOfMaterialConsumption newLine =
Beans.get(BillOfMaterialConsumptionRepository.class)
.copy(billOfMaterialConsumption, true);
newLine.setProduct(billOfMaterialConsumption.getProduct());
newLine.setRealQty(splitQty);
newLine.setQty(splitQty);
newLine.setUnit(billOfMaterialConsumption.getUnit());
newLine.setName(billOfMaterialConsumption.getName());
newLine.setTrackingNumber(billOfMaterialConsumption.getTrackingNumber());
billOfMaterialConsumption.setQty(totalQty);
manufOrder.addBillOfMaterialConsumptionListItem(newLine);
}
}
}

234
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/MrpServiceProductionImpl.java
View File

@@ -41,13 +41,11 @@ import com.axelor.apps.supplychain.db.Mrp;
import com.axelor.apps.supplychain.db.MrpForecast;
import com.axelor.apps.supplychain.db.MrpLine;
import com.axelor.apps.supplychain.db.MrpLineOrigin;
import com.axelor.apps.supplychain.db.MrpLineSaleAndMargin;
import com.axelor.apps.supplychain.db.MrpLineSophal;
import com.axelor.apps.supplychain.db.MrpLineType;
import com.axelor.apps.supplychain.db.ProductionMasterPlan;
import com.axelor.apps.supplychain.db.repo.MrpForecastRepository;
import com.axelor.apps.supplychain.db.repo.MrpLineRepository;
import com.axelor.apps.supplychain.db.repo.MrpLineSaleAndMarginRepository;
import com.axelor.apps.supplychain.db.repo.MrpLineSophalRepository;
import com.axelor.apps.supplychain.db.repo.MrpLineTypeRepository;
import com.axelor.apps.supplychain.db.repo.MrpRepository;
@@ -65,15 +63,9 @@ import java.lang.invoke.MethodHandles;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.mozilla.universalchardet.prober.statemachine.Big5SMModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -475,9 +467,7 @@ public class MrpServiceProductionImpl extends MrpServiceImpl {
Map<Long, Double> productQty)
throws AxelorException {
log.debug("****** FORTHUPPER ******** {} {}",product,qty);
log.debug("****** FORTHUPPER ******** {} {}", product, qty);
if (mrp.getIncludeBOM()) {
@@ -487,16 +477,20 @@ public class MrpServiceProductionImpl extends MrpServiceImpl {
super.createdProductionMasterPlan(product, mrp, qty, defaultBillOfMaterial.getQty());
for (BillOfMaterial billOfMaterial : defaultBillOfMaterial.getBillOfMaterialSet()) {
List<ProductionMasterPlan> productionMasterPlans = Beans.get(ProductionMasterPlanRepository.class).all().fetchStream()
.filter(t -> t.getProduct() == product && t.getMrp() == mrp).collect(Collectors.toList());
List<ProductionMasterPlan> productionMasterPlans =
Beans.get(ProductionMasterPlanRepository.class)
.all()
.fetchStream()
.filter(t -> t.getProduct() == product && t.getMrp() == mrp)
.collect(Collectors.toList());
Product subProduct = billOfMaterial.getProduct();
if (this.isMrpProduct(subProduct)) {
Double prodQty = productQty.get(subProduct.getId()) == null
Double prodQty =
productQty.get(subProduct.getId()) == null
? Double.parseDouble("0")
: productQty.get(subProduct.getId());
@@ -512,8 +506,6 @@ public class MrpServiceProductionImpl extends MrpServiceImpl {
productionMasterPlans);
}
}
}
} else {
super.createMrpLineSophal(mrp, product, unit, qty, mrpForecastList, productQty);
@@ -528,113 +520,119 @@ public class MrpServiceProductionImpl extends MrpServiceImpl {
BigDecimal qty,
BillOfMaterial billOfMaterial,
BigDecimal defaultQty,
List<ProductionMasterPlan> productionMasterPlans ) throws AxelorException {
List<ProductionMasterPlan> productionMasterPlans)
throws AxelorException {
MrpLineSophal mrpLineSophal = new MrpLineSophal();
log.debug("****** FORTH ******** {} {}",product,qty);
log.debug("****** FORTH ******** {} {}", product, qty);
BigDecimal qtyReqPerBatch = billOfMaterial.getQty();
int currentMonth = LocalDate.now().getMonth().getValue();
BigDecimal currentProductionPlan = BigDecimal.ZERO;
BigDecimal remaining= BigDecimal.ZERO;
BigDecimal remaining = BigDecimal.ZERO;
BigDecimal decreasingQty = qty;
BigDecimal totalQtyUsed = BigDecimal.ZERO;
BigDecimal futureQty = BigDecimal.ZERO;
BigDecimal purchaseQty = BigDecimal.ZERO;
if(mrp.getIncludeFutureQty()){
futureQty = Beans.get(StockLocationServiceImpl.class).getFutureQty(product.getId(), mrp.getStockLocation().getCompany().getId(), 0L);
if (mrp.getIncludeFutureQty()) {
futureQty =
Beans.get(StockLocationServiceImpl.class)
.getFutureQty(product.getId(), mrp.getStockLocation().getCompany().getId(), 0L);
decreasingQty = decreasingQty.add(futureQty);
}
if(mrp.getIncludePurchaseQty()){
purchaseQty = Beans.get(ProductStockLocationServiceImpl.class).getPurchaseOrderQty(product, mrp.getStockLocation().getCompany(), null);
if (mrp.getIncludePurchaseQty()) {
purchaseQty =
Beans.get(ProductStockLocationServiceImpl.class)
.getPurchaseOrderQty(product, mrp.getStockLocation().getCompany(), null);
decreasingQty = decreasingQty.add(purchaseQty);
}
BigDecimal initialQty = decreasingQty;
for (int index = currentMonth; index < 13; index++) {
currentProductionPlan = getCurrentProductionPlan(parentProduct, mrp, index);
BigDecimal qtyReqForProd = currentProductionPlan.multiply(qtyReqPerBatch);
if(mrp.getIncludeBomWaste()){
qtyReqForProd = qtyReqForProd.add(qtyReqForProd.multiply(billOfMaterial.getWasteRate().divide(new BigDecimal("100"),0,RoundingMode.HALF_UP)));
}
currentProductionPlan = getCurrentProductionPlan(parentProduct, mrp, index);
BigDecimal qtyReqForProd = currentProductionPlan.multiply(qtyReqPerBatch);
if (mrp.getIncludeBomWaste()) {
qtyReqForProd =
qtyReqForProd.add(
qtyReqForProd.multiply(
billOfMaterial
.getWasteRate()
.divide(new BigDecimal("100"), 0, RoundingMode.HALF_UP)));
}
totalQtyUsed.add(qtyReqForProd);
log.debug("totalQtyUsed**************** {}",totalQtyUsed);
if(decreasingQty.compareTo(qtyReqForProd) > 0) {
remaining = decreasingQty.subtract(qtyReqForProd);
decreasingQty = BigDecimal.ZERO;
}else{
remaining = BigDecimal.ZERO;
decreasingQty = qtyReqForProd.subtract(decreasingQty);
totalQtyUsed.add(qtyReqForProd);
log.debug("totalQtyUsed**************** {}", totalQtyUsed);
if(mrp.getIncludeStockRule()){
StockRules stockRules = stockRulesService.getStockRules(
product,
null,
StockRulesRepository.TYPE_FUTURE,
StockRulesRepository.USE_CASE_USED_FOR_MRP);
if(stockRules != null && stockRules.getReOrderQty() != null){
decreasingQty = stockRules.getReOrderQty().max(decreasingQty);
}
if (decreasingQty.compareTo(qtyReqForProd) > 0) {
remaining = decreasingQty.subtract(qtyReqForProd);
decreasingQty = BigDecimal.ZERO;
} else {
remaining = BigDecimal.ZERO;
decreasingQty = qtyReqForProd.subtract(decreasingQty);
if (mrp.getIncludeStockRule()) {
StockRules stockRules =
stockRulesService.getStockRules(
product,
null,
StockRulesRepository.TYPE_FUTURE,
StockRulesRepository.USE_CASE_USED_FOR_MRP);
if (stockRules != null && stockRules.getReOrderQty() != null) {
decreasingQty = stockRules.getReOrderQty().max(decreasingQty);
}
}
}
}
switch (index) {
case 1:
mrpLineSophal.setJanuary(decreasingQty);
break;
case 2:
mrpLineSophal.setFebruary(decreasingQty);
break;
case 3:
mrpLineSophal.setMarch(decreasingQty);
break;
case 4:
mrpLineSophal.setApril(decreasingQty);
case 5:
mrpLineSophal.setMay(decreasingQty);
case 6:
mrpLineSophal.setJuin(decreasingQty);
break;
case 7:
mrpLineSophal.setJuly(decreasingQty);
break;
case 8:
mrpLineSophal.setAugust(decreasingQty);
break;
case 9:
mrpLineSophal.setSeptember(decreasingQty);
break;
case 10:
mrpLineSophal.setOctober(decreasingQty);
break;
case 11:
mrpLineSophal.setNovember(decreasingQty);
break;
case 12:
mrpLineSophal.setDecember(decreasingQty);
break;
default:
break;
}
switch (index) {
case 1:
mrpLineSophal.setJanuary(decreasingQty);
break;
case 2:
mrpLineSophal.setFebruary(decreasingQty);
break;
case 3:
mrpLineSophal.setMarch(decreasingQty);
break;
case 4:
mrpLineSophal.setApril(decreasingQty);
case 5:
mrpLineSophal.setMay(decreasingQty);
case 6:
mrpLineSophal.setJuin(decreasingQty);
break;
case 7:
mrpLineSophal.setJuly(decreasingQty);
break;
case 8:
mrpLineSophal.setAugust(decreasingQty);
break;
case 9:
mrpLineSophal.setSeptember(decreasingQty);
break;
case 10:
mrpLineSophal.setOctober(decreasingQty);
break;
case 11:
mrpLineSophal.setNovember(decreasingQty);
break;
case 12:
mrpLineSophal.setDecember(decreasingQty);
break;
default:
break;
}
if(remaining.compareTo(BigDecimal.ZERO) > 0){
decreasingQty = decreasingQty.add(remaining);
}else{
decreasingQty = BigDecimal.ZERO;
}
if (remaining.compareTo(BigDecimal.ZERO) > 0) {
decreasingQty = decreasingQty.add(remaining);
} else {
decreasingQty = BigDecimal.ZERO;
}
}
mrpLineSophal.setQty(qty);
mrpLineSophal.setTotalQtyUsed(totalQtyUsed);
mrpLineSophal.setInitialQty(initialQty);
@@ -648,56 +646,58 @@ public class MrpServiceProductionImpl extends MrpServiceImpl {
Beans.get(MrpLineSophalRepository.class).save(mrpLineSophal);
}
private BigDecimal getCurrentProductionPlan(Product product, Mrp mrp, int monthSelect) {
private BigDecimal getCurrentProductionPlan(Product product,Mrp mrp,int monthSelect){
ProductionMasterPlan productionMasterPlan =
Beans.get(ProductionMasterPlanRepository.class)
.all()
.fetchStream()
.filter(t -> t.getProduct() == product && t.getMrp() == mrp)
.findFirst()
.orElse(null);
ProductionMasterPlan productionMasterPlan = Beans.get(ProductionMasterPlanRepository.class).all().fetchStream().filter(t -> t.getProduct() == product && t.getMrp() == mrp).findFirst().orElse(null);
log.debug("productionMasterPlan >>>>>>>>>>>> {}", productionMasterPlan);
log.debug("productionMasterPlan >>>>>>>>>>>> {}" , productionMasterPlan);
if (productionMasterPlan != null) {
if(productionMasterPlan != null){
switch (monthSelect) {
case 1:
return productionMasterPlan.getJanuaryBatchQty();
case 2:
return productionMasterPlan.getFebruaryBatchQty();
case 3:
return productionMasterPlan.getMarchBatchQty();
case 4:
return productionMasterPlan.getAprilBatchQty();
case 5:
return productionMasterPlan.getMayBatchQty();
case 6:
return productionMasterPlan.getJuinBatchQty();
case 7:
return productionMasterPlan.getJulyBatchQty();
case 8:
return productionMasterPlan.getAugustBatchQty();
case 9:
return productionMasterPlan.getSeptemberBatchQty();
case 10:
return productionMasterPlan.getOctoberBatchQty();
case 11:
return productionMasterPlan.getNovemberBatchQty();
case 12:
return productionMasterPlan.getDecemberBatchQty();
default:
return BigDecimal.ZERO;
}
}
return BigDecimal.ZERO;
}
}

62
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/Previous.java
View File

@@ -1,50 +1,34 @@
package com.axelor.apps.production.service;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.Month;
import java.time.format.TextStyle;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import com.axelor.apps.supplychain.db.MrpForecast;
public class Previous {
public static void main(String[] args) throws IOException {
String s = null;
Process p = Runtime.getRuntime().exec("python /Users\\Bachir.souldi.SOPHAL\\Desktop\\dev\\whatsapp_erp\\index.py hello");
BufferedReader stdInput = new BufferedReader(new
InputStreamReader(p.getInputStream()));
public static void main(String[] args) throws IOException {
String s = null;
BufferedReader stdError = new BufferedReader(new
InputStreamReader(p.getErrorStream()));
Process p =
Runtime.getRuntime()
.exec(
"python /Users\\Bachir.souldi.SOPHAL\\Desktop\\dev\\whatsapp_erp\\index.py hello");
BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
// read the output from the command
System.out.println("Here is the standard output of the command:\n");
while ((s = stdInput.readLine()) != null) {
System.out.println(s);
}
// read any errors from the attempted command
System.out.println("Here is the standard error of the command (if any):\n");
while ((s = stdError.readLine()) != null) {
System.out.println(s);
}
System.exit(0);
}
BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
// read the output from the command
System.out.println("Here is the standard output of the command:\n");
while ((s = stdInput.readLine()) != null) {
System.out.println(s);
}
// read any errors from the attempted command
System.out.println("Here is the standard error of the command (if any):\n");
while ((s = stdError.readLine()) != null) {
System.out.println(s);
}
System.exit(0);
}
}

10
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/StockMoveProductionServiceImpl.java
View File

@@ -67,10 +67,10 @@ public class StockMoveProductionServiceImpl extends StockMoveServiceSupplychainI
@Override
public void checkExpirationDates(StockMove stockMove) throws AxelorException {
if (stockMove.getInManufOrder() != null) {
stockMoveLineService.checkExpirationDates(stockMove);
} else {
super.checkExpirationDates(stockMove);
}
// if (stockMove.getInManufOrder() != null) {
// stockMoveLineService.checkExpirationDates(stockMove);
// } else {
super.checkExpirationDates(stockMove);
// }
}
}

7
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/manuforder/ManufOrderService.java
View File

@@ -68,6 +68,10 @@ public interface ManufOrderService {
public void createToConsumeProdProductList(ManufOrder manufOrder);
@Transactional(rollbackOn = {Exception.class})
public StockMove createToConsumeProdProductList(ManufOrder manufOrder, int size)
throws AxelorException;
/**
* Compute the quantity on generated prod product line. If the quantity of the bill of material is
* equal to the quantity of manuf order then the prod product line will have the same quantity as
@@ -239,4 +243,7 @@ public interface ManufOrderService {
* @return the query.
*/
public String getBuildingQtyForAProduct(Long productId, Long companyId, Long stockLocationId);
@Transactional(rollbackOn = {Exception.class})
public StockMove createOutgoinfStockMove(ManufOrder manufOrder) throws AxelorException;
}

164
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/manuforder/ManufOrderServiceImpl.java
View File

@@ -123,7 +123,6 @@ public class ManufOrderServiceImpl implements ManufOrderService {
}
Company company = billOfMaterial.getCompany();
// BigDecimal bomQty = billOfMaterial.getQty();
// BigDecimal qty = qtyRequested.divide(bomQty, 0, RoundingMode.CEILING).multiply(bomQty);
@@ -150,6 +149,100 @@ public class ManufOrderServiceImpl implements ManufOrderService {
}
@Override
@Transactional(rollbackOn = {Exception.class})
public StockMove createToConsumeProdProductList(ManufOrder manufOrder, int times)
throws AxelorException {
BigDecimal manufOrderQty = manufOrder.getQty();
BillOfMaterial billOfMaterial = manufOrder.getBillOfMaterial();
BigDecimal bomQty = billOfMaterial.getQty();
StockMove stockMove =
Beans.get(ManufOrderStockMoveService.class)
._createToConsumeStockMove(manufOrder, manufOrder.getCompany());
if (billOfMaterial.getBillOfMaterialSet() != null) {
for (BillOfMaterial billOfMaterialLine :
getSortedBillsOfMaterials(billOfMaterial.getBillOfMaterialSet())) {
if (!billOfMaterialLine.getHasNoManageStock()) {
Product product =
productVariantService.getProductVariant(
manufOrder.getProduct(), billOfMaterialLine.getProduct());
BigDecimal qty =
computeToConsumeProdProductLineQuantity(
bomQty, manufOrderQty, billOfMaterialLine.getQty())
.multiply(new BigDecimal(times));
ProdProduct prodProduct = new ProdProduct(product, qty, billOfMaterialLine.getUnit());
StockMoveLine stockMoveline =
Beans.get(ManufOrderStockMoveService.class)
._createStockMoveLine(
prodProduct, stockMove, StockMoveLineService.TYPE_IN_PRODUCTIONS);
stockMove.addStockMoveLineListItem(stockMoveline);
}
}
}
return Beans.get(StockMoveRepository.class).save(stockMove);
}
@Override
@Transactional(rollbackOn = {Exception.class})
public StockMove createOutgoinfStockMove(ManufOrder manufOrder) throws AxelorException {
BigDecimal manufOrderQty = manufOrder.getQty();
BillOfMaterial billOfMaterial = manufOrder.getBillOfMaterial();
BigDecimal bomQty = billOfMaterial.getQty();
StockConfigProductionService stockConfigService = Beans.get(StockConfigProductionService.class);
StockConfig stockConfig = stockConfigService.getStockConfig(manufOrder.getCompany());
StockLocation virtualStockLocation =
stockConfigService.getProductionVirtualStockLocation(stockConfig);
StockMove stockMove =
Beans.get(ManufOrderStockMoveService.class)
._createToConsumeStockMove(manufOrder, manufOrder.getCompany());
stockMove.setPartner(manufOrder.getCompany().getPartner());
stockMove.setTypeSelect(StockMoveRepository.TYPE_OUTGOING);
stockMove.setFromStockLocation(manufOrder.getWorkshopStockLocation());
stockMove.setToStockLocation(virtualStockLocation);
if (billOfMaterial.getBillOfMaterialSet() != null) {
for (BillOfMaterial billOfMaterialLine :
getSortedBillsOfMaterials(billOfMaterial.getBillOfMaterialSet())) {
if (!billOfMaterialLine.getHasNoManageStock()) {
Product product =
productVariantService.getProductVariant(
manufOrder.getProduct(), billOfMaterialLine.getProduct());
BigDecimal qty =
computeToConsumeProdProductLineQuantity(
bomQty, manufOrderQty, billOfMaterialLine.getQty());
ProdProduct prodProduct = new ProdProduct(product, qty, billOfMaterialLine.getUnit());
StockMoveLine stockMoveline =
Beans.get(ManufOrderStockMoveService.class)
._createStockMoveLine(
prodProduct, stockMove, StockMoveLineService.TYPE_IN_PRODUCTIONS);
stockMove.addStockMoveLineListItem(stockMoveline);
manufOrder.addConsumedStockMoveLineListItem(stockMoveline);
}
}
}
return Beans.get(StockMoveRepository.class).save(stockMove);
}
@Override
@Transactional(rollbackOn = {Exception.class})
public void createToConsumeProdProductList(ManufOrder manufOrder) {
BigDecimal manufOrderQty = manufOrder.getQty();
@@ -180,6 +273,38 @@ public class ManufOrderServiceImpl implements ManufOrderService {
}
}
public void createToConsumeProdProductListFromSelectedManufOrder(
List<ManufOrder> manufOrderList) {
BigDecimal manufOrderQty =
manufOrderList.stream().map(ManufOrder::getQty).reduce(BigDecimal.ZERO, BigDecimal::add);
BillOfMaterial billOfMaterial = manufOrderList.get(0).getBillOfMaterial();
BigDecimal bomQty = billOfMaterial.getQty();
if (billOfMaterial.getBillOfMaterialSet() != null) {
for (BillOfMaterial billOfMaterialLine :
getSortedBillsOfMaterials(billOfMaterial.getBillOfMaterialSet())) {
if (!billOfMaterialLine.getHasNoManageStock()) {
Product product =
productVariantService.getProductVariant(
manufOrderList.get(0).getProduct(), billOfMaterialLine.getProduct());
BigDecimal qty =
computeToConsumeProdProductLineQuantity(
bomQty, manufOrderQty, billOfMaterialLine.getQty());
ProdProduct prodProduct = new ProdProduct(product, qty, billOfMaterialLine.getUnit());
manufOrderList.get(0).addToConsumeProdProductListItem(prodProduct);
prodProductRepo.persist(prodProduct); // id by order of creation
}
}
}
}
@Override
public BigDecimal computeToConsumeProdProductLineQuantity(
BigDecimal bomQty, BigDecimal manufOrderQty, BigDecimal lineQty) {
@@ -294,11 +419,11 @@ public class ManufOrderServiceImpl implements ManufOrderService {
}
if (!manufOrder.getIsConsProOnOperation()) {
//bachir temp
// bachir temp
// this.createToConsumeProdProductList(manufOrder);
}
//bachir temp
// bachir temp
// this.createToProduceProdProductList(manufOrder);
return manufOrder;
@@ -328,10 +453,12 @@ public class ManufOrderServiceImpl implements ManufOrderService {
}
}
if(manufOrder.getBillOfMaterial() != null){
if (manufOrder.getBillOfMaterial() != null) {
for (BillOfMaterial bom : manufOrder.getBillOfMaterial().getBillOfMaterialSet()) {
BillOfMaterialConsumption newBom = Beans.get(BillOfMaterialServiceImpl.class).createBomConsumptionFromRawMaterial(bom);
manufOrder.addBillOfMaterialConsumptionListItem(newBom);
BillOfMaterialConsumption newBom =
Beans.get(BillOfMaterialServiceImpl.class)
.createBomConsumptionFromRawMaterial(bom, manufOrder);
manufOrder.addBillOfMaterialConsumptionListItem(newBom);
}
}
@@ -339,6 +466,10 @@ public class ManufOrderServiceImpl implements ManufOrderService {
manufOrder.setPlannedEndDateT(manufOrderWorkflowService.computePlannedEndDateT(manufOrder));
System.out.println("***************************");
System.out.println("yessssssssssssssssss");
System.out.println("***************************");
manufOrderRepo.save(manufOrder);
}
@@ -373,6 +504,10 @@ public class ManufOrderServiceImpl implements ManufOrderService {
productionConfigService.getManufOrderSequence(
productionConfig, manufOrder.getWorkshopStockLocation());
if (manufOrder.getStypeSelect() == ManufOrderRepository.STYPE_PACKAGING_ORDER) {
sequence = productionConfig.getPackagingOrderSequence();
}
String seq = sequenceService.getSequenceNumber(sequence);
if (seq == null) {
@@ -618,12 +753,13 @@ public class ManufOrderServiceImpl implements ManufOrderService {
if (stockMoveOpt.isPresent()) {
stockMove = stockMoveOpt.get();
} else {
stockMove =
manufOrderStockMoveService._createToConsumeStockMove(manufOrder, manufOrder.getCompany());
manufOrder.addInStockMoveListItem(stockMove);
Beans.get(StockMoveService.class).plan(stockMove);
// stockMove =
// manufOrderStockMoveService._createToConsumeStockMove(manufOrder,
// manufOrder.getCompany());
// manufOrder.addInStockMoveListItem(stockMove);
// Beans.get(StockMoveService.class).plan(stockMove);
}
updateStockMoveFromManufOrder(consumedStockMoveLineList, stockMove);
// updateStockMoveFromManufOrder(consumedStockMoveLineList, stockMove);
}
@Override
@@ -741,11 +877,11 @@ public class ManufOrderServiceImpl implements ManufOrderService {
.convert(
stockMoveLine.getUnit(),
prodProduct.getUnit(),
stockMoveLine.getQty(),
stockMoveLine.getQty().scale(),
stockMoveLine.getRealQty(),
stockMoveLine.getRealQty().scale(),
product));
} else {
consumedQty = consumedQty.add(stockMoveLine.getQty());
consumedQty = consumedQty.add(stockMoveLine.getRealQty());
}
}
return consumedQty.subtract(prodProduct.getQty());

193
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/manuforder/ManufOrderStockMoveService.java
View File

@@ -20,6 +20,7 @@ package com.axelor.apps.production.service.manuforder;
import com.axelor.apps.base.db.Company;
import com.axelor.apps.base.db.Product;
import com.axelor.apps.base.db.repo.ProductRepository;
import com.axelor.apps.production.db.BillOfMaterialConsumption;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.OperationOrder;
import com.axelor.apps.production.db.ProdProcess;
@@ -33,6 +34,7 @@ import com.axelor.apps.stock.db.StockConfig;
import com.axelor.apps.stock.db.StockLocation;
import com.axelor.apps.stock.db.StockMove;
import com.axelor.apps.stock.db.StockMoveLine;
import com.axelor.apps.stock.db.repo.StockMoveLineRepository;
import com.axelor.apps.stock.db.repo.StockMoveRepository;
import com.axelor.apps.stock.service.StockMoveLineService;
import com.axelor.apps.stock.service.StockMoveService;
@@ -49,6 +51,7 @@ import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -92,7 +95,34 @@ public class ManufOrderStockMoveService {
// case where we had to split tracked stock move lines
if (stockMove.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
manufOrder.addConsumedStockMoveLineListItem(stockMoveLine);
manufOrder.addTransferedStockMoveLineListItem(stockMoveLine);
}
}
}
}
public void createToTransferStockMove(ManufOrder manufOrder) throws AxelorException {
Company company = manufOrder.getCompany();
if (manufOrder.getToConsumeProdProductList() != null && company != null) {
StockMove stockMove = this._createToConsumeStockMove(manufOrder, company);
for (ProdProduct prodProduct : manufOrder.getToConsumeProdProductList()) {
this._createStockMoveLine(prodProduct, stockMove, StockMoveLineService.TYPE_IN_PRODUCTIONS);
}
if (stockMove.getStockMoveLineList() != null && !stockMove.getStockMoveLineList().isEmpty()) {
stockMoveService.plan(stockMove);
manufOrder.addInStockMoveListItem(stockMove);
}
// fill here the consumed stock move line list item to manage the
// case where we had to split tracked stock move lines
if (stockMove.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
manufOrder.addTransferedStockMoveLineListItem(stockMoveLine);
}
}
}
@@ -114,8 +144,8 @@ public class ManufOrderStockMoveService {
null,
null,
company,
fromStockLocation,
virtualStockLocation,
manufOrder.getProdProcess().getStockLocation(),
manufOrder.getWorkshopStockLocation(),
null,
manufOrder.getPlannedStartDateT().toLocalDate(),
null,
@@ -205,6 +235,9 @@ public class ManufOrderStockMoveService {
if (stockMove.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
if (manufOrder.getTrackingNumber() != null) {
stockMoveLine.setTrackingNumber(manufOrder.getTrackingNumber());
}
manufOrder.addProducedStockMoveLineListItem(stockMoveLine);
}
}
@@ -219,7 +252,52 @@ public class ManufOrderStockMoveService {
*/
@Transactional(rollbackOn = {Exception.class})
public void consumeInStockMoves(ManufOrder manufOrder) throws AxelorException {
StockConfigProductionService stockConfigService = Beans.get(StockConfigProductionService.class);
StockConfig stockConfig = stockConfigService.getStockConfig(manufOrder.getCompany());
StockLocation virtualStockLocation =
stockConfigService.getProductionVirtualStockLocation(stockConfig);
for (StockMove stockMove : manufOrder.getInStockMoveList()) {
if (stockMove.getStatusSelect() == StockMoveRepository.STATUS_REALIZED) {
StockMove move = Beans.get(StockMoveRepository.class).copy(stockMove, true);
move.setPartner(manufOrder.getCompany().getPartner());
move.setTypeSelect(StockMoveRepository.TYPE_OUTGOING);
move.setFromStockLocation(manufOrder.getWorkshopStockLocation());
move.setToStockLocation(virtualStockLocation);
// move.setInManufOrder(null);
move.setOutManufOrder(manufOrder);
Beans.get(StockMoveRepository.class).save(move);
if (move.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : move.getStockMoveLineList()) {
stockMoveLine.setTransferedManufOrder(null);
stockMoveLine.setConsumedManufOrder(manufOrder);
manufOrder.addConsumedStockMoveLineListItem(stockMoveLine);
}
}
// stockMoveService.plan(move);
}
finishStockMove(stockMove);
}
}
@Transactional(rollbackOn = {Exception.class})
public void validateOutStockMoves(ManufOrder manufOrder) throws AxelorException {
for (StockMove stockMove : manufOrder.getOutStockMoveList()) {
System.out.println("***************************");
System.out.println(stockMove.getStockMoveSeq());
stockMoveService.plan(stockMove);
finishStockMove(stockMove);
}
}
@Transactional(rollbackOn = {Exception.class})
public void validateInStockMoves(ManufOrder manufOrder) throws AxelorException {
for (StockMove stockMove : manufOrder.getInStockMoveList()) {
System.out.println("***************************");
System.out.println(stockMove.getStockMoveSeq());
stockMoveService.plan(stockMove);
finishStockMove(stockMove);
}
}
@@ -270,7 +348,7 @@ public class ManufOrderStockMoveService {
return stockMove;
}
protected StockMoveLine _createStockMoveLine(
public StockMoveLine _createStockMoveLine(
ProdProduct prodProduct, StockMove stockMove, int inOrOutType) throws AxelorException {
return _createStockMoveLine(prodProduct, stockMove, inOrOutType, prodProduct.getQty());
@@ -318,9 +396,11 @@ public class ManufOrderStockMoveService {
for (StockMove stockMove : manufOrder.getInStockMoveList()) {
this.finishStockMove(stockMove);
}
for (StockMove stockMove : manufOrder.getOutStockMoveList()) {
updateRealPrice(manufOrder, stockMove);
this.finishStockMove(stockMove);
if (manufOrder.getStypeSelect() == ManufOrderRepository.STYPE_PACKAGING_ORDER) {
for (StockMove stockMove : manufOrder.getOutStockMoveList()) {
updateRealPrice(manufOrder, stockMove);
// this.finishStockMove(stockMove);
}
}
}
@@ -347,7 +427,7 @@ public class ManufOrderStockMoveService {
if (stockMove != null && stockMove.getStatusSelect() == StockMoveRepository.STATUS_PLANNED) {
stockMove.setIsWithBackorder(false);
stockMoveService.copyQtyToRealQty(stockMove);
// stockMoveService.copyQtyToRealQty(stockMove);
stockMoveService.realize(stockMove);
}
}
@@ -393,7 +473,7 @@ public class ManufOrderStockMoveService {
StockLocation fromStockLocation;
StockLocation toStockLocation;
List<StockMove> stockMoveList;
Set<StockMove> stockMoveList;
if (inOrOut == PART_FINISH_IN) {
stockMoveList = manufOrder.getInStockMoveList();
@@ -455,6 +535,13 @@ public class ManufOrderStockMoveService {
* ManufOrder#outStockMoveList}
* @return an optional stock move
*/
public Optional<StockMove> getPlannedStockMove(Set<StockMove> stockMoveList) {
return stockMoveList
.stream()
.filter(stockMove -> stockMove.getStatusSelect() == StockMoveRepository.STATUS_PLANNED)
.findFirst();
}
public Optional<StockMove> getPlannedStockMove(List<StockMove> stockMoveList) {
return stockMoveList
.stream()
@@ -533,6 +620,7 @@ public class ManufOrderStockMoveService {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
stockMoveLine.setProducedManufOrder(null);
stockMoveLine.setTransferedManufOrder(null);
}
}
}
@@ -562,6 +650,13 @@ public class ManufOrderStockMoveService {
stockMoveLine ->
stockMoveLine.getStockMove().getStatusSelect()
== StockMoveRepository.STATUS_CANCELED);
// clear all lists from planned lines
manufOrder
.getTransferedStockMoveLineList()
.removeIf(
stockMoveLine ->
stockMoveLine.getStockMove().getStatusSelect()
== StockMoveRepository.STATUS_CANCELED);
stockMove.clearStockMoveLineList();
// create a new list
@@ -641,4 +736,84 @@ public class ManufOrderStockMoveService {
return qtyToUpdate.multiply(prodProductQty).divide(manufOrderQty, 2, RoundingMode.HALF_EVEN);
}
@Transactional
public void createToReturnStockMove(ManufOrder manufOrder) throws AxelorException {
Company company = manufOrder.getCompany();
if (manufOrder.getConsumedStockMoveLineList() != null && company != null) {
StockMove outStockMove = manufOrder.getConsumedStockMoveLineList().get(0).getStockMove();
StockMove stockMove = Beans.get(StockMoveRepository.class).copy(outStockMove, false);
StockLocation fromLocation = manufOrder.getWorkshopStockLocation();
StockLocation toLocation = manufOrder.getProdProcess().getStockLocation();
stockMove.setFromStockLocation(fromLocation);
stockMove.setToStockLocation(toLocation);
stockMove.setPartner(null);
stockMove.setTypeSelect(StockMoveRepository.TYPE_INTERNAL);
for (StockMoveLine stockMoveLine : manufOrder.getConsumedStockMoveLineList()) {
BigDecimal diff = stockMoveLine.getQty().subtract(stockMoveLine.getRealQty());
StockMoveLine stockMoveLine2 =
Beans.get(StockMoveLineRepository.class).copy(stockMoveLine, false);
if (diff.compareTo(BigDecimal.ZERO) > 0) {
stockMoveLine2.setQty(diff);
stockMoveLine2.setRealQty(diff);
stockMoveLine2.setConsumedManufOrder(null);
stockMoveLine2.setReturnedManufOrder(manufOrder);
stockMove.addStockMoveLineListItem(stockMoveLine2);
}
}
stockMoveService.plan(stockMove);
manufOrder.addOutStockMoveListItem(stockMove);
// fill here the consumed stock move line list item to manage the
// case where we had to split tracked stock move lines
if (stockMove.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
stockMoveLine.setConsumedManufOrder(null);
manufOrder.addToReturnStockMoveLineListItem(stockMoveLine);
}
}
}
}
@Transactional
public void createTempStockMove(ManufOrder manufOrder) throws AxelorException {
StockMove stockMove = this._createToConsumeStockMove(manufOrder, manufOrder.getCompany());
stockMove.setTypeSelect(StockMoveRepository.TYPE_OUTGOING);
stockMove.setFromStockLocation(manufOrder.getWorkshopStockLocation());
StockConfigProductionService stockConfigService = Beans.get(StockConfigProductionService.class);
StockConfig stockConfig = stockConfigService.getStockConfig(manufOrder.getCompany());
StockLocation virtualStockLocation =
stockConfigService.getProductionVirtualStockLocation(stockConfig);
stockMove.setToStockLocation(virtualStockLocation);
stockMove.setPartner(manufOrder.getCompany().getPartner());
for (BillOfMaterialConsumption billOfMaterialConsumption : manufOrder.getBillOfMaterialConsumptionList()) {
StockMoveLine stockMoveLine = stockMoveLineService.createStockMoveLine(
billOfMaterialConsumption.getProduct(),
billOfMaterialConsumption.getProduct().getName(),
billOfMaterialConsumption.getProduct().getDescription(),
billOfMaterialConsumption.getRealQty(),
BigDecimal.ZERO,
BigDecimal.ZERO,
billOfMaterialConsumption.getProduct().getUnit(),
stockMove,
StockMoveLineService.TYPE_OUT_PRODUCTIONS,
false,
BigDecimal.ZERO);
stockMoveLine.setTrackingNumber(billOfMaterialConsumption.getTrackingNumber());
stockMove.addStockMoveLineListItem(stockMoveLine);
}
if (stockMove.getStockMoveLineList() != null && !stockMove.getStockMoveLineList().isEmpty()) {
stockMoveService.plan(stockMove);
manufOrder.addOutStockMoveListItem(stockMove);
}
}
}

172
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/manuforder/ManufOrderWorkflowService.java
View File

@@ -26,20 +26,30 @@ import com.axelor.apps.base.service.app.AppBaseService;
import com.axelor.apps.message.db.Template;
import com.axelor.apps.message.db.repo.EmailAccountRepository;
import com.axelor.apps.message.service.TemplateMessageService;
import com.axelor.apps.production.db.BillOfMaterial;
import com.axelor.apps.production.db.BillOfMaterialConsumption;
import com.axelor.apps.production.db.DocumentationManufOrder;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.OperationOrder;
import com.axelor.apps.production.db.ProdProcess;
import com.axelor.apps.production.db.ProdProcessLine;
import com.axelor.apps.production.db.ProductionConfig;
import com.axelor.apps.production.db.repo.BillOfMaterialRepository;
import com.axelor.apps.production.db.repo.CostSheetRepository;
import com.axelor.apps.production.db.repo.DocumentationManufOrderRepository;
import com.axelor.apps.production.db.repo.ManufOrderRepository;
import com.axelor.apps.production.db.repo.OperationOrderRepository;
import com.axelor.apps.production.db.repo.ProdProcessRepository;
import com.axelor.apps.production.db.repo.ProductionConfigRepository;
import com.axelor.apps.production.exceptions.IExceptionMessage;
import com.axelor.apps.production.service.BillOfMaterialServiceImpl;
import com.axelor.apps.production.service.app.AppProductionService;
import com.axelor.apps.production.service.costsheet.CostSheetService;
import com.axelor.apps.production.service.operationorder.OperationOrderService;
import com.axelor.apps.production.service.operationorder.OperationOrderWorkflowService;
import com.axelor.apps.stock.db.StockMove;
import com.axelor.apps.stock.db.TrackingNumber;
import com.axelor.apps.stock.db.repo.TrackingNumberRepository;
import com.axelor.exception.AxelorException;
import com.axelor.exception.db.repo.TraceBackRepository;
import com.axelor.i18n.I18n;
@@ -49,8 +59,11 @@ import com.google.common.base.Strings;
import com.google.inject.Inject;
import com.google.inject.persist.Transactional;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@@ -101,11 +114,16 @@ public class ManufOrderWorkflowService {
}
if (!manufOrder.getIsConsProOnOperation()
&& CollectionUtils.isEmpty(manufOrder.getToConsumeProdProductList())) {
// manufOrderService.createToConsumeProdProductList(manufOrder);
manufOrderService.createToConsumeProdProductList(manufOrder);
}
System.out.println(
"*********************************************CollectionUtils.isEmpty(manufOrder.getToProduceProdProductList())");
System.out.println(CollectionUtils.isEmpty(manufOrder.getToProduceProdProductList()));
System.out.println(
"*********************************************CollectionUtils.isEmpty(manufOrder.getToProduceProdProductList())");
if (CollectionUtils.isEmpty(manufOrder.getToProduceProdProductList())) {
// manufOrderService.createToProduceProdProductList(manufOrder);
manufOrderService.createToProduceProdProductList(manufOrder);
}
if (manufOrder.getPlannedStartDateT() == null && manufOrder.getPlannedEndDateT() == null) {
@@ -132,11 +150,21 @@ public class ManufOrderWorkflowService {
manufOrder.setUnit(manufOrder.getBillOfMaterial().getUnit());
}
if (!manufOrder.getIsConsProOnOperation()) {
// manufOrderStockMoveService.createToConsumeStockMove(manufOrder);
// if (!manufOrder.getIsConsProOnOperation()) {
System.out.println("manufOrder<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
System.out.println();
System.out.println(manufOrder);
System.out.println(manufOrder.getStypeSelect());
System.out.println("manufOrder<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
if (manufOrder.getStypeSelect() == ManufOrderRepository.STYPE_PACKAGING_ORDER) {
manufOrderStockMoveService.createToConsumeStockMove(manufOrder);
}
manufOrderService.createOutgoinfStockMove(manufOrder);
// }
manufOrderStockMoveService.createToProduceStockMove(manufOrder);
if (manufOrder.getStypeSelect() == ManufOrderRepository.STYPE_PACKAGING_ORDER) {
manufOrderStockMoveService.createToProduceStockMove(manufOrder);
}
manufOrder.setStatusSelect(ManufOrderRepository.STATUS_PLANNED);
manufOrder.setCancelReason(null);
manufOrder.setCancelReasonStr(null);
@@ -147,15 +175,30 @@ public class ManufOrderWorkflowService {
@Transactional(rollbackOn = {Exception.class})
public void start(ManufOrder manufOrder) throws AxelorException {
// manufOrder.setRealStartDateT(
// Beans.get(AppProductionService.class).getTodayDateTime().toLocalDateTime());
manufOrder.setRealStartDateT(
Beans.get(AppProductionService.class).getTodayDateTime().toLocalDateTime());
int beforeOrAfterConfig = manufOrder.getProdProcess().getStockMoveRealizeOrderSelect();
if (beforeOrAfterConfig == ProductionConfigRepository.REALIZE_START) {
for (StockMove stockMove : manufOrder.getInStockMoveList()) {
// manufOrderStockMoveService.finishStockMove(stockMove);
if (!stockMove.getIsValidatedProduction()) {
throw new AxelorException(
TraceBackRepository.CATEGORY_NO_VALUE,
I18n.get(IExceptionMessage.STOCK_MOVE_NOT_VALIDATED));
}
manufOrderStockMoveService.finishStockMove(stockMove);
}
}
if (manufOrder.getBillOfMaterial() != null) {
for (BillOfMaterial bom : manufOrder.getBillOfMaterial().getBillOfMaterialSet()) {
BillOfMaterialConsumption newBom =
Beans.get(BillOfMaterialServiceImpl.class)
.createBomConsumptionFromRawMaterial(bom, manufOrder);
manufOrder.addBillOfMaterialConsumptionListItem(newBom);
}
}
manufOrder.setStatusSelect(ManufOrderRepository.STATUS_IN_PROGRESS);
manufOrderRepo.save(manufOrder);
}
@@ -234,8 +277,8 @@ public class ManufOrderWorkflowService {
}
manufOrderStockMoveService.finish(manufOrder);
// manufOrder.setRealEndDateT(
// Beans.get(AppProductionService.class).getTodayDateTime().toLocalDateTime());
manufOrder.setRealEndDateT(
Beans.get(AppProductionService.class).getTodayDateTime().toLocalDateTime());
manufOrder.setStatusSelect(ManufOrderRepository.STATUS_FINISHED);
manufOrder.setEndTimeDifference(
new BigDecimal(
@@ -325,6 +368,11 @@ public class ManufOrderWorkflowService {
.getProducedStockMoveLineList()
.forEach(stockMoveLine -> stockMoveLine.setProducedManufOrder(null));
}
if (manufOrder.getTransferedStockMoveLineList() != null) {
manufOrder
.getTransferedStockMoveLineList()
.forEach(stockMoveLine -> stockMoveLine.setTransferedManufOrder(null));
}
if (manufOrder.getDiffConsumeProdProductList() != null) {
manufOrder.clearDiffConsumeProdProductList();
}
@@ -449,4 +497,108 @@ public class ManufOrderWorkflowService {
}
return true;
}
@Transactional(rollbackOn = {Exception.class})
public Long createDocumentationManufOrder(ManufOrder manufOrder) throws AxelorException {
DocumentationManufOrder documentationManufOrder = new DocumentationManufOrder();
documentationManufOrder.setStatusSelect(1);
documentationManufOrder.setProduct(manufOrder.getProduct());
documentationManufOrder.setTrackingNumber(manufOrder.getTrackingNumber());
documentationManufOrder.setManufOrder(manufOrder);
ProdProcess prodProcess = Beans.get(ProdProcessRepository.class).findByName("DOCUMENTATION");
for (ProdProcessLine prodProcessLine :
Beans.get(ManufOrderServiceImpl.class)
._sortProdProcessLineByPriority(prodProcess.getProdProcessLineList())) {
documentationManufOrder.addOperationOrderListItem(
Beans.get(OperationOrderService.class).createOperationOrder(manufOrder, prodProcessLine));
}
DocumentationManufOrder savedocumentationManufOrder =
Beans.get(DocumentationManufOrderRepository.class).save(documentationManufOrder);
return savedocumentationManufOrder.getId();
}
@Transactional(rollbackOn = {Exception.class})
public Long createPackagingOrder(ManufOrder manufOrder) throws AxelorException {
ManufOrderService manufOrderService = Beans.get(ManufOrderService.class);
// ProdProcess prodProcess = Beans.get(ProdProcessRepository.class).all().filter("self.product =
// ?1 and self.typeSelect = ?2",manufOrder.getProduct(),
// ManufOrderRepository.STYPE_PACKAGING_ORDER).fetchOne();
BillOfMaterial billOfMaterial =
Beans.get(BillOfMaterialRepository.class)
.all()
.filter(
"self.product = ?1 and self.typeSelect = ?2",
manufOrder.getProduct(),
ManufOrderRepository.STYPE_PACKAGING_ORDER)
.fetchOne();
ManufOrder packagingOrder =
manufOrderService.generateManufOrder(
manufOrder.getProduct(),
manufOrder.getQty(),
ManufOrderService.DEFAULT_PRIORITY,
ManufOrderService.IS_TO_INVOICE,
billOfMaterial,
manufOrder.getRealEndDateT(),
null,
ManufOrderService.ORIGIN_TYPE_OTHER);
packagingOrder.setTrackingNumber(manufOrder.getTrackingNumber());
packagingOrder.setStypeSelect(ManufOrderRepository.STYPE_PACKAGING_ORDER);
packagingOrder.setOriginManufOrder(manufOrder);
packagingOrder.setProductionOrder(manufOrder.getProductionOrder());
ManufOrder packOrder = Beans.get(ManufOrderRepository.class).save(packagingOrder);
return packOrder.getId();
}
@Transactional(rollbackOn = {Exception.class})
public void createAndAssignTrackingNumber(OperationOrder operationOrder) throws AxelorException {
ManufOrderService manufOrderService = Beans.get(ManufOrderService.class);
// Optional<OperationOrder> operationOrder1 =
// manufOrder.getOperationOrderList().stream().filter(op
// ->op.getOperationName().equals("MELANGE")).findFirst();
// Optional<OperationOrder> operationOrder2 =
// manufOrder.getOperationOrderList().stream().filter(op
// ->op.getOperationName().equals("GRANULATION")).findFirst();
// ProdProcess prodProcess = Beans.get(ProdProcessRepository.class).all().filter("self.product =
// ?1 and self.typeSelect = ?2",manufOrder.getProduct(),
// ManufOrderRepository.STYPE_PACKAGING_ORDER).fetchOne();
ManufOrder manufOrder = operationOrder.getManufOrder();
BillOfMaterial billOfMaterial = manufOrder.getBillOfMaterial();
Product product = billOfMaterial.getProduct();
Integer lifeTime = billOfMaterial.getProductLifeTimeInMonth();
Integer seq = billOfMaterial.getProducedTrackingNumberSeq();
String workShopName = billOfMaterial.getWorkshopStockLocation().getName();
String lastYear = String.valueOf(LocalDate.now().getYear()).substring(2);
String workShopCode = "";
if (workShopName.length() >= 6) {
workShopCode = Character.toString(workShopName.charAt(5));
}
DecimalFormat df = new DecimalFormat("000");
String formattedseq = df.format(seq);
String sequence = workShopCode + lastYear + formattedseq;
LocalDate perishableDate =
LocalDate.now().plusMonths(lifeTime).with(TemporalAdjusters.lastDayOfMonth());
TrackingNumber trackingNumber = new TrackingNumber();
trackingNumber.setProduct(product);
trackingNumber.setPerishableExpirationDate(perishableDate);
trackingNumber.setTrackingNumberSeq(sequence);
manufOrder.setTrackingNumber(Beans.get(TrackingNumberRepository.class).save(trackingNumber));
Integer nextSeq = billOfMaterial.getProducedTrackingNumberSeq() + 1;
billOfMaterial.setProducedTrackingNumberSeq(nextSeq);
Beans.get(BillOfMaterialRepository.class).save(billOfMaterial);
Beans.get(ManufOrderRepository.class).save(manufOrder);
}
}

4
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/operationorder/OperationOrderServiceImpl.java
View File

@@ -115,6 +115,10 @@ public class OperationOrderServiceImpl implements OperationOrderService {
OperationOrderRepository.STATUS_DRAFT,
prodProcessLine);
operationOrder.setProduct(prodProcessLine.getProduct());
operationOrder.setQty(prodProcessLine.getQty());
operationOrder.setUnit(prodProcessLine.getUnit());
this._createHumanResourceList(operationOrder, machineWorkCenter);
return Beans.get(OperationOrderRepository.class).save(operationOrder);

60
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/operationorder/OperationOrderWorkflowService.java
View File

@@ -92,10 +92,10 @@ public class OperationOrderWorkflowService {
// Duration.between(
// operationOrder.getPlannedStartDateT(), operationOrder.getPlannedEndDateT())));
// ManufOrder manufOrder = operationOrder.getManufOrder();
// if (manufOrder == null || manufOrder.getIsConsProOnOperation()) {
// operationOrderStockMoveService.createToConsumeStockMove(operationOrder);
// }
ManufOrder manufOrder = operationOrder.getManufOrder();
if (manufOrder == null || manufOrder.getIsConsProOnOperation()) {
operationOrderStockMoveService.createToConsumeStockMove(operationOrder);
}
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_PLANNED);
@@ -195,26 +195,26 @@ public class OperationOrderWorkflowService {
public void start(OperationOrder operationOrder) throws AxelorException {
if (operationOrder.getStatusSelect() != OperationOrderRepository.STATUS_IN_PROGRESS) {
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_IN_PROGRESS);
// operationOrder.setRealStartDateT(appProductionService.getTodayDateTime().toLocalDateTime());
operationOrder.setRealStartDateT(appProductionService.getTodayDateTime().toLocalDateTime());
// startOperationOrderDuration(operationOrder);
startOperationOrderDuration(operationOrder);
// if (operationOrder.getManufOrder() != null) {
// int beforeOrAfterConfig =
// operationOrder.getManufOrder().getProdProcess().getStockMoveRealizeOrderSelect();
// if (beforeOrAfterConfig == ProductionConfigRepository.REALIZE_START) {
// for (StockMove stockMove : operationOrder.getInStockMoveList()) {
// Beans.get(ManufOrderStockMoveService.class).finishStockMove(stockMove);
// }
if (operationOrder.getManufOrder() != null) {
int beforeOrAfterConfig =
operationOrder.getManufOrder().getProdProcess().getStockMoveRealizeOrderSelect();
if (beforeOrAfterConfig == ProductionConfigRepository.REALIZE_START) {
for (StockMove stockMove : operationOrder.getInStockMoveList()) {
Beans.get(ManufOrderStockMoveService.class).finishStockMove(stockMove);
}
// StockMove newStockMove =
// operationOrderStockMoveService._createToConsumeStockMove(
// operationOrder, operationOrder.getManufOrder().getCompany());
// newStockMove.setStockMoveLineList(new ArrayList<>());
// Beans.get(StockMoveService.class).plan(newStockMove);
// operationOrder.addInStockMoveListItem(newStockMove);
// }
// }
StockMove newStockMove =
operationOrderStockMoveService._createToConsumeStockMove(
operationOrder, operationOrder.getManufOrder().getCompany());
newStockMove.setStockMoveLineList(new ArrayList<>());
Beans.get(StockMoveService.class).plan(newStockMove);
operationOrder.addInStockMoveListItem(newStockMove);
}
}
operationOrderRepo.save(operationOrder);
}
@@ -233,7 +233,7 @@ public class OperationOrderWorkflowService {
public void pause(OperationOrder operationOrder) {
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_STANDBY);
// stopOperationOrderDuration(operationOrder);
stopOperationOrderDuration(operationOrder);
operationOrderRepo.save(operationOrder);
}
@@ -247,7 +247,7 @@ public class OperationOrderWorkflowService {
public void resume(OperationOrder operationOrder) {
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_IN_PROGRESS);
// startOperationOrderDuration(operationOrder);
startOperationOrderDuration(operationOrder);
operationOrderRepo.save(operationOrder);
}
@@ -261,9 +261,9 @@ public class OperationOrderWorkflowService {
@Transactional(rollbackOn = {Exception.class})
public void finish(OperationOrder operationOrder) throws AxelorException {
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_FINISHED);
// operationOrder.setRealEndDateT(appProductionService.getTodayDateTime().toLocalDateTime());
operationOrder.setRealEndDateT(appProductionService.getTodayDateTime().toLocalDateTime());
// stopOperationOrderDuration(operationOrder);
stopOperationOrderDuration(operationOrder);
// operationOrderStockMoveService.finish(operationOrder);
operationOrderRepo.save(operationOrder);
@@ -286,14 +286,14 @@ public class OperationOrderWorkflowService {
operationOrder.setStatusSelect(OperationOrderRepository.STATUS_CANCELED);
if (oldStatus == OperationOrderRepository.STATUS_IN_PROGRESS) {
// stopOperationOrderDuration(operationOrder);
stopOperationOrderDuration(operationOrder);
}
if (operationOrder.getConsumedStockMoveLineList() != null) {
// operationOrder
// .getConsumedStockMoveLineList()
// .forEach(stockMoveLine -> stockMoveLine.setConsumedOperationOrder(null));
operationOrder
.getConsumedStockMoveLineList()
.forEach(stockMoveLine -> stockMoveLine.setConsumedOperationOrder(null));
}
// operationOrderStockMoveService.cancel(operationOrder);
operationOrderStockMoveService.cancel(operationOrder);
operationOrderRepo.save(operationOrder);
}

52
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/service/productionorder/ProductionOrderServiceImpl.java
View File

@@ -23,19 +23,27 @@ import com.axelor.apps.base.service.administration.SequenceService;
import com.axelor.apps.production.db.BillOfMaterial;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.ProductionOrder;
import com.axelor.apps.production.db.repo.ManufOrderRepository;
import com.axelor.apps.production.db.repo.ProductionOrderRepository;
import com.axelor.apps.production.exceptions.IExceptionMessage;
import com.axelor.apps.production.service.manuforder.ManufOrderService;
import com.axelor.apps.production.service.manuforder.ManufOrderServiceImpl;
import com.axelor.apps.sale.db.SaleOrder;
import com.axelor.apps.stock.db.StockMove;
import com.axelor.apps.stock.db.StockMoveLine;
import com.axelor.apps.stock.db.repo.StockMoveRepository;
import com.axelor.apps.stock.service.StockMoveService;
import com.axelor.exception.AxelorException;
import com.axelor.exception.db.repo.TraceBackRepository;
import com.axelor.i18n.I18n;
import com.axelor.inject.Beans;
import com.google.inject.Inject;
import com.google.inject.persist.Transactional;
import java.lang.invoke.MethodHandles;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -127,13 +135,11 @@ public class ProductionOrderServiceImpl implements ProductionOrderService {
int originType)
throws AxelorException {
BigDecimal bomQty = billOfMaterial.getQty();
BigDecimal manufCount = qtyRequested.divide(bomQty, 0, RoundingMode.CEILING);
for (int index = 0; index < manufCount.intValue(); index++) {
ManufOrder manufOrder =
for (int index = 0; index < manufCount.intValue(); index++) {
ManufOrder manufOrder =
manufOrderService.generateManufOrder(
product,
bomQty,
@@ -143,17 +149,49 @@ for (int index = 0; index < manufCount.intValue(); index++) {
startDate,
endDate,
originType);
if (manufOrder != null) {
if (saleOrder != null) {
manufOrder.setSaleOrder(saleOrder);
manufOrder.setClientPartner(saleOrder.getClientPartner());
}
manufOrder.setStypeSelect(ManufOrderRepository.STYPE_MANUF_ORDER);
productionOrder.addManufOrderListItem(manufOrder);
}
}
}
return productionOrderRepo.save(productionOrder);
}
@Transactional(rollbackOn = {Exception.class})
public StockMove generateConsumeStockMoveFromSelectedManufOrder(
ProductionOrder productionOrder, List<ManufOrder> manufOrderList) throws AxelorException {
ManufOrder manufOrder = manufOrderList.get(0);
StockMove stockMove =
Beans.get(ManufOrderServiceImpl.class)
.createToConsumeProdProductList(manufOrder, manufOrderList.size());
for (ManufOrder manufOrder2 : manufOrderList) {
if (stockMove.getStockMoveLineList() != null && !stockMove.getStockMoveLineList().isEmpty()) {
Beans.get(ManufOrderServiceImpl.class).createToConsumeProdProductList(manufOrder2);
Beans.get(StockMoveService.class).plan(stockMove);
}
if (stockMove.getStockMoveLineList() != null) {
for (StockMoveLine stockMoveLine : stockMove.getStockMoveLineList()) {
manufOrder2.addTransferedStockMoveLineListItem(stockMoveLine);
}
}
manufOrder2.addInStockMoveListItem(stockMove);
Beans.get(ProductionOrderRepository.class).save(productionOrder);
}
stockMove.setOrigin(productionOrder.getProductionOrderSeq());
stockMove.setOriginId(productionOrder.getId());
stockMove.setOriginTypeSelect(StockMoveRepository.ORIGIN_PRODUCTION_ORDER);
return Beans.get(StockMoveRepository.class).save(stockMove);
}
}

229
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/web/ManufOrderController.java
View File

@@ -19,17 +19,24 @@ package com.axelor.apps.production.web;
import com.axelor.apps.ReportFactory;
import com.axelor.apps.base.service.app.AppBaseService;
import com.axelor.apps.production.db.BillOfMaterial;
import com.axelor.apps.production.db.BillOfMaterialConsumption;
import com.axelor.apps.production.db.CostSheet;
import com.axelor.apps.production.db.DocumentationManufOrder;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.OperationOrder;
import com.axelor.apps.production.db.repo.BillOfMaterialConsumptionRepository;
import com.axelor.apps.production.db.repo.CostSheetRepository;
import com.axelor.apps.production.db.repo.ManufOrderRepository;
import com.axelor.apps.production.exceptions.IExceptionMessage;
import com.axelor.apps.production.report.IReport;
import com.axelor.apps.production.service.BillOfMaterialServiceImpl;
import com.axelor.apps.production.service.costsheet.CostSheetService;
import com.axelor.apps.production.service.manuforder.ManufOrderService;
import com.axelor.apps.production.service.manuforder.ManufOrderStockMoveService;
import com.axelor.apps.production.service.manuforder.ManufOrderWorkflowService;
import com.axelor.apps.report.engine.ReportSettings;
import com.axelor.db.mapper.Mapper;
import com.axelor.exception.AxelorException;
import com.axelor.exception.service.TraceBackService;
import com.axelor.i18n.I18n;
@@ -45,7 +52,10 @@ import java.lang.invoke.MethodHandles;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.eclipse.birt.core.exception.BirtException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -107,7 +117,6 @@ public class ManufOrderController {
response.setNotify(I18n.get(IExceptionMessage.MANUF_ORDER_EMAIL_NOT_SENT));
}
response.setReload(true);
} catch (Exception e) {
TraceBackService.trace(response, e);
}
@@ -185,9 +194,7 @@ public class ManufOrderController {
manufOrders =
Beans.get(ManufOrderRepository.class)
.all()
.filter(
"self.id in ?1",
context.get("_ids"))
.filter("self.id in ?1", context.get("_ids"))
.fetch();
}
for (ManufOrder manufOrder : manufOrders) {
@@ -211,9 +218,7 @@ public class ManufOrderController {
manufOrders =
Beans.get(ManufOrderRepository.class)
.all()
.filter(
"self.id in ?1",
context.get("_ids"))
.filter("self.id in ?1", context.get("_ids"))
.fetch();
}
for (ManufOrder manufOrder : manufOrders) {
@@ -237,9 +242,7 @@ public class ManufOrderController {
manufOrders =
Beans.get(ManufOrderRepository.class)
.all()
.filter(
"self.id in ?1",
context.get("_ids"))
.filter("self.id in ?1", context.get("_ids"))
.fetch();
}
for (ManufOrder manufOrder : manufOrders) {
@@ -263,9 +266,7 @@ public class ManufOrderController {
manufOrders =
Beans.get(ManufOrderRepository.class)
.all()
.filter(
"self.id in ?1",
context.get("_ids"))
.filter("self.id in ?1", context.get("_ids"))
.fetch();
}
for (ManufOrder manufOrder : manufOrders) {
@@ -297,6 +298,26 @@ public class ManufOrderController {
TraceBackService.trace(response, e);
}
}
/**
* Called from manuf order form on clicking realize button. Call {@link
* ManufOrderStockMoveService#consumeInStockMoves(ManufOrder)} to consume material used in manuf
* order.
*
* @param request
* @param response
*/
public void validateOutStockMove(ActionRequest request, ActionResponse response) {
try {
ManufOrder manufOrder = request.getContext().asType(ManufOrder.class);
manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrder.getId());
Beans.get(ManufOrderStockMoveService.class).validateOutStockMoves(manufOrder);
response.setReload(true);
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
/**
* Method that generate a Pdf file for an manufacturing order
@@ -581,4 +602,186 @@ public class ManufOrderController {
TraceBackService.trace(response, e);
}
}
public void createPackagingOrder(ActionRequest request, ActionResponse response) {
try {
Long manufOrderId = (Long) request.getContext().get("id");
ManufOrder manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrderId);
if (!Beans.get(ManufOrderWorkflowService.class).finish(manufOrder)) {
response.setNotify(I18n.get(IExceptionMessage.MANUF_ORDER_EMAIL_NOT_SENT));
}
// response.setReload(true);
ManufOrder manufOrder2 = Beans.get(ManufOrderRepository.class).find(manufOrderId);
if (manufOrder.getStypeSelect() == ManufOrderRepository.STYPE_MANUF_ORDER) {
Long packagingOrderid =
Beans.get(ManufOrderWorkflowService.class).createPackagingOrder(manufOrder2);
response.setView(
ActionView.define("Pckaging order")
.model(ManufOrder.class.getName())
.add("form", "manuf-order-form")
.add("grid", "manuf-order-grid")
.context("_showRecord", String.valueOf(packagingOrderid))
.domain("self.id = " + packagingOrderid)
.map());
} else if (manufOrder2.getStypeSelect() == ManufOrderRepository.STYPE_PACKAGING_ORDER) {
Long docManufOrderid =
Beans.get(ManufOrderWorkflowService.class).createDocumentationManufOrder(manufOrder2);
response.setView(
ActionView.define("Documentation order")
.model(DocumentationManufOrder.class.getName())
.add("form", "documentation-manuf-order-form")
.add("grid", "documentation-manuf-order-grid")
.context("_showRecord", String.valueOf(docManufOrderid))
.domain("self.id = " + docManufOrderid)
.map());
}
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
public void createTrackingNumberAndAssign(ActionRequest request, ActionResponse response)
throws AxelorException {
Long manufOrderId = (Long) request.getContext().get("id");
ManufOrder manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrderId);
Optional<OperationOrder> operationOrder1 =
manufOrder
.getOperationOrderList()
.stream()
.filter(op -> op.getOperationName().equals("MELANGE"))
.findFirst();
Optional<OperationOrder> operationOrder2 =
manufOrder
.getOperationOrderList()
.stream()
.filter(op -> op.getOperationName().equals("GRANULATION"))
.findFirst();
if (operationOrder1 != null) {
if (operationOrder1.isPresent()) {
Beans.get(ManufOrderWorkflowService.class)
.createAndAssignTrackingNumber(operationOrder1.get());
}
} else if (operationOrder2 != null) {
if (operationOrder2.isPresent()) {
Beans.get(ManufOrderWorkflowService.class)
.createAndAssignTrackingNumber(operationOrder2.get());
}
}
response.setReload(true);
}
public void createToReturnStockMove(ActionRequest request, ActionResponse response)
throws AxelorException {
Long manufOrderId = (Long) request.getContext().get("id");
ManufOrder manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrderId);
Beans.get(ManufOrderStockMoveService.class).createToReturnStockMove(manufOrder);
response.setReload(true);
}
public void planOF(ActionRequest request, ActionResponse response) throws AxelorException {
try {
Long manufOrderId = (Long) request.getContext().get("id");
ManufOrder manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrderId);
if (manufOrder.getBillOfMaterial() != null) {
for (BillOfMaterial bom : manufOrder.getBillOfMaterial().getBillOfMaterialSet()) {
BillOfMaterialConsumption newBom =
Beans.get(BillOfMaterialServiceImpl.class)
.createBomConsumptionFromRawMaterial(bom, manufOrder);
manufOrder.addBillOfMaterialConsumptionListItem(newBom);
}
}
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
public void prefillConsumption(ActionRequest request, ActionResponse response) {
try {
Long manufOrderId = (Long) request.getContext().get("id");
ManufOrder manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrderId);
if (manufOrder.getBillOfMaterial() != null) {
Beans.get(BillOfMaterialServiceImpl.class).createBomAndAttachToManufOrder(manufOrder);
response.setReload(true);
}
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
public void splitBillConsumption(ActionRequest request, ActionResponse response) {
try {
List<HashMap> selectedBillConsumptionMapList =
(List<HashMap>) request.getContext().get("billOfMaterialConsumptionList");
Map manufOrderMap = (Map<String, Object>) request.getContext().get("manufOrder");
if (selectedBillConsumptionMapList == null) {
response.setFlash(I18n.get("Please select at least one line."));
return;
}
List<BillOfMaterialConsumption> billConsumptionList = new ArrayList<>();
BillOfMaterialConsumptionRepository billConsumptionRepo =
Beans.get(BillOfMaterialConsumptionRepository.class);
for (HashMap map : selectedBillConsumptionMapList) {
BillOfMaterialConsumption billConsumption =
(BillOfMaterialConsumption) Mapper.toBean(BillOfMaterialConsumption.class, map);
billConsumptionList.add(billConsumptionRepo.find(billConsumption.getId()));
}
if (billConsumptionList.isEmpty()) {
response.setFlash(I18n.get("Please select at least one line."));
return;
}
BigDecimal splitQty = new BigDecimal(request.getContext().get("splitQty").toString());
if (splitQty == null || splitQty.compareTo(BigDecimal.ZERO) < 1) {
response.setFlash(I18n.get("Please enter a valid quantity."));
return;
}
ManufOrder manufOrder = Mapper.toBean(ManufOrder.class, manufOrderMap);
manufOrder = Beans.get(ManufOrderRepository.class).find(manufOrder.getId());
Beans.get(BillOfMaterialServiceImpl.class)
.splitBillOfMaterialConsumption(manufOrder, billConsumptionList, splitQty);
response.setCanClose(true);
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
public void consumeStockMoveTemp(ActionRequest request, ActionResponse response) {
try {
Context context = request.getContext();
List<ManufOrder> manufOrders = new ArrayList<>();
if (context.get("id") != null) {
Long manufOrderId = (Long) request.getContext().get("id");
manufOrders.add(Beans.get(ManufOrderRepository.class).find(manufOrderId));
} else if (context.get("_ids") != null) {
manufOrders =
Beans.get(ManufOrderRepository.class)
.all()
.filter(
"self.id in ?1",
context.get("_ids"))
.fetch();
}
for (ManufOrder manufOrder : manufOrders) {
Beans.get(ManufOrderStockMoveService.class).createTempStockMove(manufOrder);
}
response.setReload(true);
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
}

17
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/web/OperationOrderController.java
View File

@@ -129,6 +129,23 @@ public class OperationOrderController {
try {
OperationOrder operationOrder = request.getContext().asType(OperationOrder.class);
operationOrder = Beans.get(OperationOrderRepository.class).find(operationOrder.getId());
System.out.println("*******************************************");
System.out.println(operationOrder.getManufOrder().getTrackingNumber());
System.out.println(operationOrder.getOperationName());
System.out.println(operationOrder.getManufOrder().getTrackingNumber() == null);
System.out.println(operationOrder.getOperationName() == "MELANGE");
if (operationOrder.getManufOrder().getTrackingNumber() == null) {
System.out.println("***is null****99999");
if (operationOrder.getOperationName().equals("MELANGE")) {
System.out.println("*******************************************99999");
Beans.get(ManufOrderWorkflowService.class).createAndAssignTrackingNumber(operationOrder);
} else if (operationOrder.getOperationName().equals("GRANULATION")) {
Beans.get(ManufOrderWorkflowService.class).createAndAssignTrackingNumber(operationOrder);
}
}
Beans.get(OperationOrderWorkflowService.class).start(operationOrder);
response.setReload(true);
} catch (Exception e) {

45
modules/axelor-open-suite/axelor-production/src/main/java/com/axelor/apps/production/web/ProductionOrderController.java
View File

@@ -21,13 +21,19 @@ import com.axelor.apps.base.db.Product;
import com.axelor.apps.base.db.repo.ProductRepository;
import com.axelor.apps.base.service.app.AppBaseService;
import com.axelor.apps.production.db.BillOfMaterial;
import com.axelor.apps.production.db.ManufOrder;
import com.axelor.apps.production.db.ProductionOrder;
import com.axelor.apps.production.db.repo.BillOfMaterialRepository;
import com.axelor.apps.production.db.repo.ManufOrderRepository;
import com.axelor.apps.production.db.repo.ProductionOrderRepository;
import com.axelor.apps.production.exceptions.IExceptionMessage;
import com.axelor.apps.production.service.manuforder.ManufOrderService;
import com.axelor.apps.production.service.productionorder.ProductionOrderService;
import com.axelor.apps.production.service.productionorder.ProductionOrderServiceImpl;
import com.axelor.apps.stock.db.StockMove;
import com.axelor.db.mapper.Mapper;
import com.axelor.exception.AxelorException;
import com.axelor.exception.service.TraceBackService;
import com.axelor.i18n.I18n;
import com.axelor.inject.Beans;
import com.axelor.rpc.ActionRequest;
@@ -38,6 +44,9 @@ import java.math.BigDecimal;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Singleton
@@ -104,4 +113,40 @@ public class ProductionOrderController {
response.setCanClose(true);
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
public void generateConsumeStockMoveFromSelectedManufOrder(
ActionRequest request, ActionResponse response) {
try {
List<HashMap> selectedManufOrderMapList =
(List<HashMap>) request.getContext().get("manufOrderList");
Map productionOrderMap = (Map<String, Object>) request.getContext().get("productionOrder");
if (selectedManufOrderMapList == null) {
response.setFlash(I18n.get(IExceptionMessage.UNIT_COST_CALCULATION_IMPORT_FAIL_ERROR));
return;
}
List<ManufOrder> manufOrderList = new ArrayList<>();
ManufOrderRepository manufOrderRepository = Beans.get(ManufOrderRepository.class);
for (HashMap map : selectedManufOrderMapList) {
ManufOrder manufOrder = (ManufOrder) Mapper.toBean(ManufOrder.class, map);
manufOrderList.add(manufOrderRepository.find(manufOrder.getId()));
}
if (manufOrderList.isEmpty()) {
response.setFlash(I18n.get(IExceptionMessage.UNIT_COST_CALCULATION_IMPORT_FAIL_ERROR));
return;
}
ProductionOrder productionOrder = Mapper.toBean(ProductionOrder.class, productionOrderMap);
productionOrder = Beans.get(ProductionOrderRepository.class).find(productionOrder.getId());
StockMove stockMove =
Beans.get(ProductionOrderServiceImpl.class)
.generateConsumeStockMoveFromSelectedManufOrder(productionOrder, manufOrderList);
response.setCanClose(true);
response.setFlash("Generated successfully : " + stockMove.getStockMoveSeq());
} catch (Exception e) {
TraceBackService.trace(response, e);
}
}
}

12
modules/axelor-open-suite/axelor-production/src/main/resources/domains/BillOfMaterial.xml
View File

@@ -31,8 +31,15 @@
<many-to-one name="originalBillOfMaterial" ref="com.axelor.apps.production.db.BillOfMaterial" title="Original bill of material" />
<one-to-many name="bomChildTreeList" ref="TempBomTree" mappedBy="parentBom"/>
<one-to-many name="bomTreeList" ref="TempBomTree" mappedBy="bom"/>
<integer name="typeSelect" title="Bom type" selection="production.bill.of.material.type.select" default="1"/>
<integer name="productLifeTimeInMonth" title="Product lifetime in months" />
<integer name="producedTrackingNumberSeq" title="Produced tracking number seq" />
<string name="note" large="true"/>
<finder-method name="findByProductAndTypeSelect" using="product,typeSelect" all="true"/>
<extra-code><![CDATA[
@@ -42,6 +49,9 @@
public static final int STATUS_APPLICABLE = 3;
public static final int STATUS_OBSOLETE = 4;
public static final int MANUF_TYPE_SELECT = 1;
public static final int PACKAGING_TYPE_SELECT = 2;
]]></extra-code>
<track>

6
modules/axelor-open-suite/axelor-production/src/main/resources/domains/BillOfMaterialConsumption.xml
View File

@@ -15,9 +15,9 @@
<boolean name="defineSubBillOfMaterial" title="Define sub bill of material"/>
<many-to-one name="unit" ref="com.axelor.apps.base.db.Unit" title="Unit"/>
<many-to-one name="company" ref="com.axelor.apps.base.db.Company" title="Company"/>
<string name="fullName" namecolumn="true" title="Label"/>
<string name="fullName" namecolumn="true" title="Label"/>
<many-to-one name="trackingNumber" ref="com.axelor.apps.stock.db.TrackingNumber" title="Tracking Nbr."/>
<many-to-one ref="ManufOrder" name="manufOrder" />
<string name="note" large="true"/>
<track>

13
modules/axelor-open-suite/axelor-production/src/main/resources/domains/DocumentationManufOrder.xml
View File

@@ -7,6 +7,19 @@
<entity name="DocumentationManufOrder" lang="java">
<many-to-one name="product" ref="com.axelor.apps.base.db.Product" title="Product" initParam="true"/>
<many-to-one name="trackingNumber" ref="com.axelor.apps.stock.db.TrackingNumber" title="Tracking Nbr."/>
<many-to-one name="conformityCertificateFile" ref="com.axelor.meta.db.MetaFile" title="Conformity certificate file" />
<many-to-one name="manufOrder" ref="com.axelor.apps.production.db.ManufOrder" title="ManufOrder"/>
<string name="noteconformityCertificateFile" large="true" multiline="true" title="Conformity certificate file note"/>
<integer name="stypeSelect" title="Typeselect" selection="production.documentation.manuf.order.typeselect" />
<integer name="statusSelect" title="Status select" selection="production.documentation.manuf.order.statusSelect" />
<decimal name="qty" title="Qty" initParam="true"/>
<one-to-many name="operationOrderList" ref="com.axelor.apps.production.db.OperationOrder" title="Operation orders" orderBy="priority"/>
<track>
<field name="statusSelect" />
</track>
</entity>
</domain-models>

16
modules/axelor-open-suite/axelor-production/src/main/resources/domains/ManufOrder.xml
View File

@@ -30,6 +30,8 @@
<one-to-many name="producedStockMoveLineList" ref="com.axelor.apps.stock.db.StockMoveLine" mappedBy="producedManufOrder" title="Produced products" orphanRemoval="false"/>
<one-to-many name="wasteProdProductList" ref="com.axelor.apps.production.db.ProdProduct" mappedBy="wasteManufOrder" title="Waste"/>
<one-to-many name="transferedStockMoveLineList" ref="com.axelor.apps.stock.db.StockMoveLine" mappedBy="transferedManufOrder" title="Transfered products" orphanRemoval="false"/>
<one-to-many name="toReturnStockMoveLineList" ref="com.axelor.apps.stock.db.StockMoveLine" mappedBy="returnedManufOrder" title="Returned products" orphanRemoval="false"/>
<boolean name="isConsProOnOperation" title="Manage consumed products on operations" initParam="true"/>
@@ -50,9 +52,9 @@
<datetime name="realStartDateT" title="Real start date"/>
<datetime name="realEndDateT" title="Real end date"/>
<decimal name="endTimeDifference" title="Time difference (Minutes)"/>
<one-to-many name="inStockMoveList" ref="com.axelor.apps.stock.db.StockMove" title="Stock moves in" mappedBy="inManufOrder"/>
<one-to-many name="outStockMoveList" ref="com.axelor.apps.stock.db.StockMove" title="Stock moves out" mappedBy="outManufOrder"/>
<!-- mappedBy="inManufOrder" -->
<many-to-many name="inStockMoveList" ref="com.axelor.apps.stock.db.StockMove" title="Stock moves in" />
<many-to-many name="outStockMoveList" ref="com.axelor.apps.stock.db.StockMove" title="Stock moves out" mappedBy="outManufOrder"/>
<many-to-one name="wasteStockMove" ref="com.axelor.apps.stock.db.StockMove" title="Waste stock move"/>
@@ -75,6 +77,9 @@
<one-to-many name="billOfMaterialConsumptionList" title="Bom consumption list" ref="com.axelor.apps.production.db.BillOfMaterialConsumption" />
<many-to-one name="originManufOrder" ref="ManufOrder" title="Origin Manuf order" />
<unique-constraint columns="manufOrderSeq,company"/>
<extra-code><![CDATA[
@@ -85,6 +90,11 @@
public static final int STATUS_IN_PROGRESS = 4;
public static final int STATUS_STANDBY = 5;
public static final int STATUS_FINISHED = 6;
public static final int STYPE_MANUF_ORDER = 1;
public static final int STYPE_PACKAGING_ORDER = 2;
]]></extra-code>
<track>

1
modules/axelor-open-suite/axelor-production/src/main/resources/domains/OperationOrder.xml
View File

@@ -17,6 +17,7 @@
<many-to-one name="product" ref="com.axelor.apps.base.db.Product" title="Product" />
<decimal name="qty" title="Quantity"/>
<many-to-one name="unit" ref="com.axelor.apps.base.db.Unit" title="mass" />
<many-to-one name="workCenter" ref="com.axelor.apps.production.db.WorkCenter" title="Work center" initParam="true"/>
<many-to-one name="machineWorkCenter" ref="com.axelor.apps.production.db.WorkCenter" title="Machine" initParam="true"/>

8
modules/axelor-open-suite/axelor-production/src/main/resources/domains/ProdProcess.xml
View File

@@ -31,6 +31,11 @@
<integer name="stockMoveRealizeOrderSelect" default="1" massUpdate="true"
selection="production.manuf.order.stock.move.realize.order.select"/>
<integer name="typeSelect" title="ProdProcess type" selection="production.prod.process.type.select" default="1"/>
<finder-method name="findByProductAndTypeSelect" using="product,typeSelect" all="true"/>
<extra-code><![CDATA[
// STATUS SELECT
@@ -38,6 +43,9 @@
public static final int STATUS_VALIDATED = 2;
public static final int STATUS_APPLICABLE = 3;
public static final int STATUS_OBSOLETE = 4;
public static final int MANUF_TYPE_SELECT = 1;
public static final int PACKAGING_TYPE_SELECT = 2;
]]></extra-code>

1
modules/axelor-open-suite/axelor-production/src/main/resources/domains/ProdProcessLine.xml
View File

@@ -23,6 +23,7 @@
<one-to-many name="objectDescriptionList" ref="com.axelor.apps.production.db.ObjectDescription" mappedBy="prodProcessLine" title="Descriptions"/>
<many-to-one name="product" ref="com.axelor.apps.base.db.Product" title="Product" />
<many-to-one name="unit" ref="com.axelor.apps.base.db.Unit" title="Unit" />
<decimal name="qty" title="Quantity"/>
<track>

1
modules/axelor-open-suite/axelor-production/src/main/resources/domains/ProductionConfig.xml
View File

@@ -11,6 +11,7 @@
<integer name="stockMoveRealizeOrderSelect" default="1"
selection="production.manuf.order.stock.move.realize.order.select"/>
<many-to-one name="manufOrderSequence" title="Default sequence" ref="com.axelor.apps.base.db.Sequence"/>
<many-to-one name="packagingOrderSequence" title="Packaging order sequence" ref="com.axelor.apps.base.db.Sequence"/>
<one-to-many name="workshopSequenceConfigLineList" title="Sequence by workshop" mappedBy="productionConfig" ref="com.axelor.apps.production.db.WorkshopSequenceConfigLine"/>
<boolean name="finishMoAutomaticEmail" title="Send email when manufacturing order finished" default="false"/>
<many-to-one name="finishMoMessageTemplate" title="Message template" ref="com.axelor.apps.message.db.Template"/>

7
modules/axelor-open-suite/axelor-production/src/main/resources/domains/ProductionOrder.xml
View File

@@ -14,7 +14,12 @@
<many-to-one name="saleOrder" ref="com.axelor.apps.sale.db.SaleOrder" title="Sale order" />
<one-to-many name="manufOrderList" ref="com.axelor.apps.production.db.ManufOrder" mappedBy="productionOrder" title="Manufacturing orders" orderBy="prioritySelect"/>
<one-to-many name="inStockMoveList" ref="com.axelor.apps.stock.db.StockMove" title="Stock moves in" mappedBy="inProductionOrder"/>
<string name="productionOrderSeqSelect" title="Production order Seq select" selection="production.order.sequence.select"/>
<many-to-one name="product" ref="com.axelor.apps.base.db.Product" title="Product"/>
<boolean name="isClosed" >
<![CDATA[
if(manufOrderList == null || manufOrderList.isEmpty())

6
modules/axelor-open-suite/axelor-production/src/main/resources/domains/StockMove.xml
View File

@@ -7,14 +7,18 @@
<entity name="StockMove" lang="java">
<many-to-one name="inManufOrder" ref="com.axelor.apps.production.db.ManufOrder"/>
<many-to-one name="inProductionOrder" ref="com.axelor.apps.production.db.ProductionOrder"/>
<!-- <many-to-one name="inManufOrder" ref="com.axelor.apps.production.db.ManufOrder"/> -->
<many-to-one name="outManufOrder" ref="com.axelor.apps.production.db.ManufOrder"/>
<many-to-one name="inOperationOrder" ref="com.axelor.apps.production.db.OperationOrder"/>
<boolean name="isValidatedProduction" title="Is validated production" />
<extra-code>
<![CDATA[
public static final String ORIGIN_MANUF_ORDER = "com.axelor.apps.production.db.ManufOrder";
public static final String ORIGIN_OPERATION_ORDER = "com.axelor.apps.production.db.OperationOrder";
public static final String ORIGIN_PRODUCTION_ORDER = "com.axelor.apps.production.db.ProductionOrder";
]]>
</extra-code>

3
modules/axelor-open-suite/axelor-production/src/main/resources/domains/StockMoveLine.xml
View File

@@ -9,6 +9,9 @@
<many-to-one name="consumedManufOrder" ref="com.axelor.apps.production.db.ManufOrder" title="Manufacturing order"/>
<many-to-one name="producedManufOrder" ref="com.axelor.apps.production.db.ManufOrder" title="Manufacturing order"/>
<many-to-one name="returnedManufOrder" ref="com.axelor.apps.production.db.ManufOrder" title="Manufacturing order"/>
<many-to-one name="transferedManufOrder" ref="com.axelor.apps.production.db.ManufOrder" title="Manufacturing order"/>
<many-to-one name="productionOrder" ref="com.axelor.apps.production.db.ProductionOrder" title="Production order"/>
<many-to-one name="consumedOperationOrder" ref="com.axelor.apps.production.db.OperationOrder" title="Operation order"/>