List of usage examples for java.math BigDecimal multiply
public BigDecimal multiply(BigDecimal multiplicand)
(this × multiplicand), and whose scale is (this.scale() + multiplicand.scale()) . From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
private BigDecimal getErledigterMaterialwertEinerSollpositionNEU(BigDecimal bdLosgroesse, BigDecimal bdErledigteMenge, TheClientDto theClientDto, LosDto losDto, BigDecimal bdAusgegeben, BigDecimal gesamtpreis, BigDecimal sollmenge) { // wenn volle menge erledigt oder sogar mehr oder Los=erledigt if (bdLosgroesse.compareTo(bdErledigteMenge) <= 0 || losDto.getStatusCNr().equals(FertigungFac.STATUS_ERLEDIGT)) { // dann alles return gesamtpreis; } else {//w w w . ja va2 s.c o m // Sollsatzgroesse berechnen BigDecimal bdSollsatzgroesse = sollmenge.multiply(bdErledigteMenge).divide(bdLosgroesse, 6, BigDecimal.ROUND_HALF_EVEN); // weniger oder gleich wie sollmenge ausgegeben if (bdAusgegeben.compareTo(bdSollsatzgroesse) <= 0) { // dann alles return gesamtpreis; } // wenn mehr ausgegeben else { BigDecimal bdEinzelpreis = new BigDecimal(0); if (bdAusgegeben.doubleValue() > 0) { bdEinzelpreis = gesamtpreis.divide(bdAusgegeben, 4, BigDecimal.ROUND_HALF_EVEN); } // dann mit sollsatzgroesse return bdSollsatzgroesse.multiply(bdEinzelpreis); } } }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public HashMap<Integer, StuecklistepositionDto> holeAlleLossollmaterialFuerStuecklistenAktualisierung( Integer stuecklisteIId, BigDecimal bdLosgroesse, int iEbene, HashMap<Integer, StuecklistepositionDto> hmPositionen, TheClientDto theClientDto) { iEbene++;/*w ww . j a v a 2s . co m*/ if (hmPositionen == null) { hmPositionen = new HashMap<Integer, StuecklistepositionDto>(); } try { StuecklistepositionDto[] stkPos = getStuecklisteFac() .stuecklistepositionFindByStuecklisteIId(stuecklisteIId, theClientDto); StuecklisteDto stklDto = getStuecklisteFac().stuecklisteFindByPrimaryKey(stuecklisteIId, theClientDto); for (int i = 0; i < stkPos.length; i++) { // alle stuecklistenpositionen ins los uebernehmen // W02451 if (stkPos[i].getArtikelIId() == 6093) { int u = 0; } // Einheit umrechnen ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall(stkPos[i].getArtikelIId(), theClientDto); BigDecimal bdFaktor = getSystemFac().rechneUmInAndereEinheit(new BigDecimal(1), stkPos[i].getEinheitCNr(), artikelDto.getEinheitCNr(), stkPos[i].getIId(), theClientDto); // nun die Dimensionen BigDecimal bdDimProdukt = new BigDecimal(1); EinheitDto einheitDto = getSystemFac().einheitFindByPrimaryKey(stkPos[i].getEinheitCNr(), theClientDto); if (einheitDto.getIDimension().intValue() >= 1) { if (stkPos[i].getFDimension1() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension1().floatValue())); } } if (einheitDto.getIDimension().intValue() >= 2) { if (stkPos[i].getFDimension2() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension2().floatValue())); } } if (einheitDto.getIDimension().intValue() >= 3) { if (stkPos[i].getFDimension3() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension3().floatValue())); } } // verschnitt BigDecimal bdMenge = Helper.berechneMengeInklusiveVerschnitt(stkPos[i].getNMenge(), artikelDto.getFVerschnittfaktor(), artikelDto.getFVerschnittbasis(), bdLosgroesse); // endgueltige Menge berechnen BigDecimal posMenge = bdMenge.multiply(bdDimProdukt).multiply(bdLosgroesse).multiply(bdFaktor) .divide(new BigDecimal(stklDto.getIErfassungsfaktor().doubleValue()), BigDecimal.ROUND_HALF_EVEN); if (posMenge.doubleValue() < 0.001 && posMenge.doubleValue() > 0.000001) { posMenge = new BigDecimal("0.001"); posMenge = posMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN); } else { posMenge = posMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN); } stkPos[i].setNMenge(posMenge); StuecklisteDto stuecklisteDto = getStuecklisteFac() .stuecklisteFindByMandantCNrArtikelIIdOhneExc(stkPos[i].getArtikelIId(), theClientDto); if (stuecklisteDto != null && stuecklisteDto.getStuecklisteartCNr() .equals(StuecklisteFac.STUECKLISTEART_HILFSSTUECKLISTE)) { if (iEbene < 10) { holeAlleLossollmaterialFuerStuecklistenAktualisierung(stuecklisteDto.getIId(), posMenge, iEbene, hmPositionen, theClientDto); } } else { if (stkPos[i].getNMenge().doubleValue() > 0) { if (hmPositionen.containsKey(stkPos[i].getArtikelIId())) { StuecklistepositionDto p = hmPositionen.get(stkPos[i].getArtikelIId()); p.setNMenge(stkPos[i].getNMenge().add(p.getNMenge())); hmPositionen.put(stkPos[i].getArtikelIId(), p); } else { hmPositionen.put(stkPos[i].getArtikelIId(), stkPos[i]); } } } } } catch (RemoteException ex1) { throwEJBExceptionLPRespectOld(ex1); } return hmPositionen; }
From source file:org.openbravo.common.actionhandler.SetNewBPCurrency.java
@Override protected JSONObject doExecute(Map<String, Object> parameters, String content) { JSONObject jsonRequest = null;//from ww w .ja va 2 s. co m OBContext.setAdminMode(true); try { jsonRequest = new JSONObject(content); JSONObject params = jsonRequest.getJSONObject("_params"); final String strOrgId = jsonRequest.getString("inpadOrgId"); final String strFromCurrencyId = jsonRequest.getString("inpbpCurrencyId"); final String strToCurrencyId = params.getString("C_Currency_ID"); final String strRate = params.getString("Rate"); final String strAmount = params.getString("Foreign_Amount"); final boolean strSetAmount = params.getBoolean("Amount"); final boolean strUseDefaultConversion = params.getBoolean("Default_Conversion_Rate"); final String strBpartnerId = jsonRequest.getString("C_BPartner_ID"); final String glItemId = params.getString("c_glitem_id"); BigDecimal creditUsed = BigDecimal.ZERO; BigDecimal rate = BigDecimal.ZERO; Double amount = new Double(0); if (strSetAmount && !"null".equals(strAmount)) { amount = Double.parseDouble(strAmount); } if (strUseDefaultConversion && !strSetAmount) { rate = getConversionRate(strOrgId, strFromCurrencyId, strToCurrencyId); if (rate == BigDecimal.ZERO && !strFromCurrencyId.equals(strToCurrencyId)) { try { jsonRequest = new JSONObject(); String message = OBMessageUtils.messageBD("NoCurrencyConversion"); JSONObject errorMessage = new JSONObject(); errorMessage.put("severity", "error"); errorMessage.put("text", message); jsonRequest.put("message", errorMessage); } catch (Exception e) { OBDal.getInstance().rollbackAndClose(); log.error(e.getMessage(), e); } return jsonRequest; } } else { rate = "null".equals(strRate) ? BigDecimal.ZERO : BigDecimal.valueOf(Double.parseDouble(strRate)); } BusinessPartner businessPartner = OBDal.getInstance().get(BusinessPartner.class, strBpartnerId); creditUsed = businessPartner.getCreditUsed(); ScrollableResults scroll = null; GLItem glItem = OBDal.getInstance().get(GLItem.class, glItemId); Currency currency = OBDal.getInstance().get(Currency.class, strToCurrencyId); BigDecimal creditAmount = BigDecimal.ZERO; BigDecimal creditRate = BigDecimal.ONE; // Convert available credit automatically if (!StringUtils.equals(strFromCurrencyId, strToCurrencyId) && !StringUtils.isEmpty(glItemId) && !StringUtils.equals(glItemId, "null")) { // Get the rate if (!strSetAmount) { creditRate = rate; } else if (creditUsed.compareTo(BigDecimal.ZERO) != 0) { creditRate = BigDecimal.valueOf(amount).divide(creditUsed, FIN_Utility.getConversionRatePrecision(RequestContext.get().getVariablesSecureApp()), RoundingMode.HALF_UP); } // Loop through all payment documents which generate credit scroll = FinancialUtils.getPaymentsWithCredit(businessPartner.getId(), strFromCurrencyId); int i = 0; try { while (scroll.next()) { final String paymentCreditId = (String) scroll.get()[0]; final FIN_Payment paymentCredit = OBDal.getInstance().get(FIN_Payment.class, paymentCreditId); creditAmount = paymentCredit.getGeneratedCredit().subtract(paymentCredit.getUsedCredit()); // Create a payment to consume the credit with a glitem FIN_Payment payment1 = (FIN_Payment) DalUtil.copy(paymentCredit, false); payment1.setPaymentDate(new Date()); payment1.setAmount(creditAmount); payment1.setDocumentNo(FIN_Utility.getDocumentNo(payment1.getOrganization(), payment1.getDocumentType().getDocumentCategory(), "DocumentNo_FIN_Payment")); payment1.setProcessed(false); payment1.setPosted("N"); payment1.setDescription(null); payment1.setGeneratedCredit(BigDecimal.ZERO); payment1.setUsedCredit(BigDecimal.ZERO); // Create a payment detail to consume the credit with a glitem FIN_PaymentDetail paymentDetail1 = OBProvider.getInstance().get(FIN_PaymentDetail.class); paymentDetail1.setClient(paymentCredit.getClient()); paymentDetail1.setOrganization(paymentCredit.getOrganization()); paymentDetail1.setFinPayment(payment1); paymentDetail1.setAmount(creditAmount); paymentDetail1.setRefund(false); paymentDetail1.setGLItem(glItem); paymentDetail1.setPrepayment(false); // Create a payment schedule detail to consume the credit with a glitem FIN_PaymentScheduleDetail paymentScheduleDetail1 = OBProvider.getInstance() .get(FIN_PaymentScheduleDetail.class); paymentScheduleDetail1.setClient(paymentCredit.getClient()); paymentScheduleDetail1.setOrganization(paymentCredit.getOrganization()); paymentScheduleDetail1.setPaymentDetails(paymentDetail1); paymentScheduleDetail1.setAmount(creditAmount); // Process the payment paymentDetail1.getFINPaymentScheduleDetailList().add(paymentScheduleDetail1); payment1.getFINPaymentDetailList().add(paymentDetail1); OBDal.getInstance().save(payment1); OBDal.getInstance().save(paymentDetail1); OBDal.getInstance().save(paymentScheduleDetail1); FIN_PaymentProcess.doProcessPayment(payment1, "D", false, null, null); // Modify description of original credit payment String paymentCreditDesc = paymentCredit.getDescription() + "\n" + String.format( OBMessageUtils.messageBD("APRM_CreditUsedPayment"), payment1.getDocumentNo()); paymentCredit.setDescription((paymentCreditDesc.length() > 255) ? paymentCreditDesc.substring(0, 251).concat("...").toString() : paymentCreditDesc.toString()); // Create a payment to refund the credit FIN_Payment payment2 = (FIN_Payment) DalUtil.copy(paymentCredit, false); payment2.setPaymentDate(new Date()); payment2.setAmount(creditAmount.negate()); payment2.setDocumentNo(FIN_Utility.getDocumentNo(payment2.getOrganization(), payment2.getDocumentType().getDocumentCategory(), "DocumentNo_FIN_Payment")); payment2.setProcessed(false); payment2.setPosted("N"); payment2.setDescription( OBMessageUtils.messageBD("APRM_RefundPayment") + ": " + payment1.getDocumentNo()); payment2.setGeneratedCredit(BigDecimal.ZERO); payment2.setUsedCredit(creditAmount); // Create a payment credit to refund the credit FIN_Payment_Credit paymentCredit2 = OBProvider.getInstance().get(FIN_Payment_Credit.class); paymentCredit2.setClient(paymentCredit.getClient()); paymentCredit2.setOrganization(paymentCredit.getOrganization()); paymentCredit2.setPayment(payment2); paymentCredit2.setCreditPaymentUsed(paymentCredit); paymentCredit2.setAmount(creditAmount); paymentCredit2.setCurrency(paymentCredit.getCurrency()); // Create a payment detail to refund the credit FIN_PaymentDetail paymentDetail2 = OBProvider.getInstance().get(FIN_PaymentDetail.class); paymentDetail2.setClient(paymentCredit.getClient()); paymentDetail2.setOrganization(paymentCredit.getOrganization()); paymentDetail2.setFinPayment(payment2); paymentDetail2.setAmount(creditAmount.negate()); paymentDetail2.setRefund(true); paymentDetail2.setPrepayment(true); // Create a payment schedule detail to refund the credit FIN_PaymentScheduleDetail paymentScheduleDetail2 = OBProvider.getInstance() .get(FIN_PaymentScheduleDetail.class); paymentScheduleDetail2.setClient(paymentCredit.getClient()); paymentScheduleDetail2.setOrganization(paymentCredit.getOrganization()); paymentScheduleDetail2.setPaymentDetails(paymentDetail2); paymentScheduleDetail2.setAmount(creditAmount.negate()); // Process the payment paymentDetail2.getFINPaymentScheduleDetailList().add(paymentScheduleDetail2); payment2.getFINPaymentDetailList().add(paymentDetail2); payment2.getFINPaymentCreditList().add(paymentCredit2); paymentCredit.setUsedCredit(creditAmount); OBDal.getInstance().save(paymentCredit); OBDal.getInstance().save(payment2); OBDal.getInstance().save(paymentCredit2); OBDal.getInstance().save(paymentDetail2); OBDal.getInstance().save(paymentScheduleDetail2); FIN_PaymentProcess.doProcessPayment(payment2, "D", false, null, null); i++; if (i % 100 == 0) { OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } } // Set the new currency businessPartner.setCurrency(currency); // Loop through all payment documents which generate credit scroll.beforeFirst(); i = 0; while (scroll.next()) { final String paymentCreditId = (String) scroll.get()[0]; final FIN_Payment paymentCredit = OBDal.getInstance().get(FIN_Payment.class, paymentCreditId); // Create a payment to create the credit with a glitem FIN_Payment payment3 = (FIN_Payment) DalUtil.copy(paymentCredit, false); payment3.setPaymentDate(new Date()); payment3.setCurrency(currency); payment3.setAmount(BigDecimal.ZERO); payment3.setDocumentNo(FIN_Utility.getDocumentNo(payment3.getOrganization(), payment3.getDocumentType().getDocumentCategory(), "DocumentNo_FIN_Payment")); payment3.setProcessed(false); payment3.setPosted("N"); payment3.setDescription(null); final BigDecimal generatedCredit = creditAmount.multiply(creditRate) .setScale(currency.getStandardPrecision().intValue(), RoundingMode.HALF_UP); payment3.setGeneratedCredit(generatedCredit); payment3.setUsedCredit(BigDecimal.ZERO); // Create a payment detail to create the credit with a glitem FIN_PaymentDetail paymentDetail3 = OBProvider.getInstance().get(FIN_PaymentDetail.class); paymentDetail3.setClient(paymentCredit.getClient()); paymentDetail3.setOrganization(paymentCredit.getOrganization()); paymentDetail3.setFinPayment(payment3); paymentDetail3.setAmount(generatedCredit); paymentDetail3.setRefund(false); paymentDetail3.setPrepayment(true); // Create a payment detail to create the credit with a glitem FIN_PaymentDetail paymentDetail4 = OBProvider.getInstance().get(FIN_PaymentDetail.class); paymentDetail4.setClient(paymentCredit.getClient()); paymentDetail4.setOrganization(paymentCredit.getOrganization()); paymentDetail4.setFinPayment(payment3); paymentDetail4.setAmount(generatedCredit.negate()); paymentDetail4.setGLItem(glItem); paymentDetail4.setRefund(false); paymentDetail4.setPrepayment(false); // Create a payment schedule detail to create the credit with a glitem FIN_PaymentScheduleDetail paymentScheduleDetail3 = OBProvider.getInstance() .get(FIN_PaymentScheduleDetail.class); paymentScheduleDetail3.setClient(paymentCredit.getClient()); paymentScheduleDetail3.setOrganization(paymentCredit.getOrganization()); paymentScheduleDetail3.setPaymentDetails(paymentDetail3); paymentScheduleDetail3.setAmount(generatedCredit); // Create a payment schedule detail to create the credit with a glitem FIN_PaymentScheduleDetail paymentScheduleDetail4 = OBProvider.getInstance() .get(FIN_PaymentScheduleDetail.class); paymentScheduleDetail4.setClient(paymentCredit.getClient()); paymentScheduleDetail4.setOrganization(paymentCredit.getOrganization()); paymentScheduleDetail4.setPaymentDetails(paymentDetail4); paymentScheduleDetail4.setAmount(generatedCredit.negate()); // Process the payment paymentDetail3.getFINPaymentScheduleDetailList().add(paymentScheduleDetail3); paymentDetail4.getFINPaymentScheduleDetailList().add(paymentScheduleDetail4); payment3.getFINPaymentDetailList().add(paymentDetail3); payment3.getFINPaymentDetailList().add(paymentDetail4); OBDal.getInstance().save(payment3); OBDal.getInstance().save(paymentDetail3); OBDal.getInstance().save(paymentDetail4); OBDal.getInstance().save(paymentScheduleDetail3); OBDal.getInstance().save(paymentScheduleDetail4); OBDal.getInstance().save(paymentCredit); FIN_PaymentProcess.doProcessPayment(payment3, "D", false, null, null); i++; if (i % 100 == 0) { OBDal.getInstance().flush(); OBDal.getInstance().getSession().clear(); } } } finally { scroll.close(); } } if (strSetAmount && creditUsed.compareTo(BigDecimal.valueOf(amount)) != 0) { businessPartner.setCreditUsed(BigDecimal.valueOf(amount)); } if (!strToCurrencyId.equals(strFromCurrencyId) && strToCurrencyId != null && !"null".equals(strToCurrencyId)) { businessPartner.setCurrency(OBDal.getInstance().get(Currency.class, strToCurrencyId)); if (rate.compareTo(BigDecimal.ZERO) != 0 && creditUsed.compareTo(BigDecimal.ZERO) != 0 && !strSetAmount) { businessPartner.setCreditUsed(creditUsed.multiply(rate)); } } String messageText = OBMessageUtils.messageBD("CurrencyUpdated"); JSONObject msg = new JSONObject(); msg.put("severity", "success"); msg.put("text", OBMessageUtils.parseTranslation(messageText)); jsonRequest.put("message", msg); } catch (Exception e) { OBDal.getInstance().rollbackAndClose(); log.error("Error in set new currency Action Handler", e); try { jsonRequest = new JSONObject(); Throwable ex = DbUtility.getUnderlyingSQLException(e); String message = OBMessageUtils.translateError(ex.getMessage()).getMessage(); JSONObject errorMessage = new JSONObject(); errorMessage.put("severity", "error"); errorMessage.put("text", message); jsonRequest.put("message", errorMessage); } catch (Exception e2) { log.error(e.getMessage(), e2); // do nothing, give up } } finally { OBContext.restorePreviousMode(); } return jsonRequest; }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
private void erstelleLossollmaterial(Integer losIId, Integer stuecklisteIId, BigDecimal bdPositionsMenge, Integer lagerIId_Hauptlager, boolean bFlachdruecken, int iEbene, TheClientDto theClientDto) { iEbene++;/*from w w w . j ava 2 s. c o m*/ try { StuecklistepositionDto[] stkPos = getStuecklisteFac() .stuecklistepositionFindByStuecklisteIId(stuecklisteIId, theClientDto); StuecklisteDto stklDto = getStuecklisteFac().stuecklisteFindByPrimaryKey(stuecklisteIId, theClientDto); for (int i = 0; i < stkPos.length; i++) { // alle stuecklistenpositionen ins los uebernehmen LossollmaterialDto losMatDto = new LossollmaterialDto(); losMatDto.setArtikelIId(stkPos[i].getArtikelIId()); losMatDto.setBNachtraeglich(Helper.boolean2Short(false)); losMatDto.setCKommentar(stkPos[i].getCKommentar()); losMatDto.setCPosition(stkPos[i].getCPosition()); losMatDto.setFDimension1(stkPos[i].getFDimension1()); losMatDto.setFDimension2(stkPos[i].getFDimension2()); losMatDto.setFDimension3(stkPos[i].getFDimension3()); losMatDto.setILfdnummer(stkPos[i].getILfdnummer()); losMatDto.setIBeginnterminoffset(stkPos[i].getIBeginnterminoffset()); losMatDto.setISort(stkPos[i].getISort()); losMatDto.setLosIId(losIId); losMatDto.setMontageartIId(stkPos[i].getMontageartIId()); // Einheit umrechnen ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKey(stkPos[i].getArtikelIId(), theClientDto); losMatDto.setEinheitCNr(artikelDto.getEinheitCNr()); BigDecimal bdFaktor = getSystemFac().rechneUmInAndereEinheit(new BigDecimal(1), artikelDto.getEinheitCNr(), stkPos[i].getEinheitCNr(), stkPos[i].getIId(), theClientDto); // nun die Dimensionen BigDecimal bdDimProdukt = new BigDecimal(1); EinheitDto einheitDto = getSystemFac().einheitFindByPrimaryKey(stkPos[i].getEinheitCNr(), theClientDto); if (einheitDto.getIDimension().intValue() >= 1) { if (stkPos[i].getFDimension1() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension1().floatValue())); } } if (einheitDto.getIDimension().intValue() >= 2) { if (stkPos[i].getFDimension2() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension2().floatValue())); } } if (einheitDto.getIDimension().intValue() >= 3) { if (stkPos[i].getFDimension3() != null) { bdDimProdukt = bdDimProdukt .multiply(new BigDecimal(stkPos[i].getFDimension3().floatValue())); } } // verschnitt BigDecimal bdMenge = Helper.berechneMengeInklusiveVerschnitt(stkPos[i].getNMenge(), artikelDto.getFVerschnittfaktor(), artikelDto.getFVerschnittbasis(), bdPositionsMenge); // endgueltige Menge berechnen if (bdFaktor.doubleValue() != 0) { bdMenge = bdMenge.divide(bdFaktor, BigDecimal.ROUND_HALF_EVEN); BigDecimal losSollMenge = bdMenge.multiply(bdDimProdukt).multiply(bdPositionsMenge).divide( new BigDecimal(stklDto.getIErfassungsfaktor().doubleValue()), BigDecimal.ROUND_HALF_EVEN); if (losSollMenge.doubleValue() < 0.001 && losSollMenge.doubleValue() > 0.000001) { losSollMenge = new BigDecimal("0.001"); losSollMenge = losSollMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN); } else { losSollMenge = losSollMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN); } losMatDto.setNMenge(losSollMenge); } BigDecimal bdSollpreis = getLagerFac().getGemittelterGestehungspreisEinesLagers( stkPos[i].getArtikelIId(), lagerIId_Hauptlager, theClientDto); losMatDto.setNSollpreis(bdSollpreis); // Datensatz speichern // Wenn Unterstueckliste und Hilfsstueckliste: StuecklisteDto stuecklisteDto = getStuecklisteFac() .stuecklisteFindByMandantCNrArtikelIIdOhneExc(stkPos[i].getArtikelIId(), theClientDto); if (stuecklisteDto != null && stuecklisteDto.getArtikelIId() == 3376) { int u = 0; } if (stuecklisteDto != null && stuecklisteDto.getStuecklisteartCNr() .equals(StuecklisteFac.STUECKLISTEART_HILFSSTUECKLISTE) && bFlachdruecken == true) { if (iEbene < 10) { erstelleLossollmaterial(losIId, stuecklisteDto.getIId(), losMatDto.getNMenge(), lagerIId_Hauptlager, true, iEbene, theClientDto); } } else { LossollmaterialDto lossollmaterialDto = createLossollmaterial(losMatDto, theClientDto); Integer iOriginal_IId = new Integer(lossollmaterialDto.getIId()); // Ersatztypen anlegen PosersatzDto[] posersatzDtos = getStuecklisteFac() .posersatzFindByStuecklistepositionIId(stkPos[i].getIId()); if (iEbene < 10) { for (int k = 0; k < posersatzDtos.length; k++) { losMatDto.setArtikelIId(posersatzDtos[k].getArtikelIIdErsatz()); losMatDto.setNMenge(new BigDecimal(0)); losMatDto.setLossollmaterialIIdOriginal(iOriginal_IId); createLossollmaterial(losMatDto, theClientDto); } } } } } catch (RemoteException ex1) { throwEJBExceptionLPRespectOld(ex1); } }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
public void bucheTOPSArtikelAufHauptLager(Integer losIId, TheClientDto theClientDto, BigDecimal zuzubuchendeSatzgroesse) { LossollmaterialDto[] dtos = lossollmaterialFindByLosIId(losIId); try {// w w w. j a v a 2 s. c o m Integer hauptlagerIId = getLagerFac().getHauptlagerDesMandanten(theClientDto).getIId(); LosDto losDto = losFindByPrimaryKey(losIId); for (int i = 0; i < dtos.length; i++) { Integer artklaIId = null; ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall(dtos[i].getArtikelIId(), theClientDto); artklaIId = artikelDto.getArtklaIId(); if (artklaIId != null) { boolean bTops = Helper.short2boolean( getArtikelFac().artklaFindByPrimaryKey(artklaIId, theClientDto).getBTops()); if (bTops == true) { BigDecimal sollsatzgroesse = dtos[i].getNMenge().divide(losDto.getNLosgroesse(), 4, BigDecimal.ROUND_HALF_EVEN); BigDecimal zuzubuchendeMenge = null; if (zuzubuchendeSatzgroesse == null) { zuzubuchendeMenge = dtos[i].getNMenge() .subtract(getAusgegebeneMenge(dtos[i].getIId(), null, theClientDto)); } else { zuzubuchendeMenge = sollsatzgroesse.multiply(zuzubuchendeSatzgroesse); } if (zuzubuchendeMenge.doubleValue() > 0) { HandlagerbewegungDto handDto = new HandlagerbewegungDto(); handDto.setArtikelIId(dtos[i].getArtikelIId()); handDto.setNMenge(zuzubuchendeMenge); handDto.setBAbgang(Helper.boolean2Short(false)); handDto.setCKommentar("TOPS " + losDto.getCNr()); handDto.setLagerIId(hauptlagerIId); handDto.setNEinstandspreis(getLagerFac().getGemittelterGestehungspreisDesHauptlagers( dtos[i].getArtikelIId(), theClientDto)); getLagerFac().createHandlagerbewegung(handDto, theClientDto); // CK:13872 // Dann aufs Los buchen LosistmaterialDto istmat = new LosistmaterialDto(); istmat.setLagerIId(hauptlagerIId); istmat.setLossollmaterialIId(dtos[i].getIId()); istmat.setNMenge(zuzubuchendeMenge); istmat.setBAbgang(Helper.boolean2Short(true)); // ist-wert anlegen und lagerbuchung // durchfuehren createLosistmaterial(istmat, null, theClientDto); // Reservierung loeschen removeReservierung(artikelDto, dtos[i].getIId()); // Fehlmenge anlegen getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, dtos[i].getIId(), false, theClientDto); } } } } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
/** * Ist-Arbeitszeit fuer eine Ablieferung pro abgelieferter Einheit * bestimmen./*w w w . j av a 2 s . c o m*/ * * @param losablieferungIId * Integer * @param bWertOderZeit * boolean fuer Wert = true, fuer Zeit = false * @param theClientDto * String * @return BigDecimal * @throws EJBExceptionLP */ private BigDecimal getErledigteArbeitszeitEinerLosablieferung(Integer losablieferungIId, boolean bWertOderZeit, boolean bMitMaschinenZeit, TheClientDto theClientDto, boolean bRekursiv) throws EJBExceptionLP { BigDecimal bdErgebnis = new BigDecimal(0); LosablieferungDto losablieferungDto = losablieferungFindByPrimaryKey(losablieferungIId, false, theClientDto); try { // Alle Ablieferungen auf dieses Los aufsteigend nach datum sortiert LosablieferungDto[] abl = losablieferungFindByLosIId(losablieferungDto.getLosIId(), false, theClientDto); // Rueckwaertsschleife, da die werte der vorgaenger berechnet werden // muessen (rekursiv) for (int i = abl.length - 1; i > 0; i--) { // wenn ich die aktuelle gefunden hab, subtrahier ich den wert // des vorgaengers if (abl[i].getIId().equals(losablieferungIId)) { bdErgebnis = bdErgebnis.subtract(getErledigteArbeitszeitEinerLosablieferung(abl[i - 1].getIId(), bWertOderZeit, bMitMaschinenZeit, theClientDto, true).multiply(abl[i - 1].getNMenge())); break; } } // ------------------------------------------------------------------ // ---- BigDecimal summeAblieferungen = new BigDecimal(0); // Sollsatzfaktor bestimmen BigDecimal bdErledigt = new BigDecimal(0); for (int i = 0; i < abl.length; i++) { summeAblieferungen = summeAblieferungen.add(abl[i].getNMenge()); if (!abl[i].getTAendern().after(losablieferungDto.getTAendern())) { bdErledigt = bdErledigt.add(abl[i].getNMenge()); } } LosDto losDto = losFindByPrimaryKey(losablieferungDto.getLosIId()); // Wenn Los ueberliefert oder Erledigt, dann zaehlen alle Zeidaten // zum Arbeitszeitwert boolean bAlleZeitenZaehlenFuerArbeitswert = false; if (summeAblieferungen.doubleValue() >= losDto.getNLosgroesse().doubleValue() || losDto.getStatusCNr().equals(LocaleFac.STATUS_ERLEDIGT)) { if (bRekursiv == false) { bAlleZeitenZaehlenFuerArbeitswert = true; } } BigDecimal bdFaktor = bdErledigt.divide(losDto.getNLosgroesse(), 10, BigDecimal.ROUND_HALF_EVEN); // ------------------------------------------------------------------ // ---- // Sollzeiten LossollarbeitsplanDto[] soll = getFertigungFac() .lossollarbeitsplanFindByLosIId(losablieferungDto.getLosIId()); // Sollzeiten nach Artikel verdichten und mit Sollsatzfaktor // multiplizieren HashMap<Integer, BigDecimal> listSollVerdichtet = new HashMap<Integer, BigDecimal>(); for (int i = 0; i < soll.length; i++) { BigDecimal bdBisher = listSollVerdichtet.get(soll[i].getArtikelIIdTaetigkeit()); if (bdBisher == null) { listSollVerdichtet.put(soll[i].getArtikelIIdTaetigkeit(), soll[i].getNGesamtzeit().multiply(bdFaktor)); } else { listSollVerdichtet.put(soll[i].getArtikelIIdTaetigkeit(), bdBisher.add(soll[i].getNGesamtzeit().multiply(bdFaktor))); } } // ------------------------------------------------------------------ // ---- // gebuchte Zeiten holen ParametermandantDto parametermandantDto = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_ISTZEITEN_GLEICH_SOLLZEITEN); boolean bSollGleichIstzeiten = false; if (((java.lang.Boolean) parametermandantDto.getCWertAsObject()).booleanValue() == true) { bSollGleichIstzeiten = true; } // Maschinenzeiten AuftragzeitenDto[] zeitenMaschine = null; AuftragzeitenDto[] zeiten = null; if (bSollGleichIstzeiten == false) { // Maschinenzeiten zeitenMaschine = getZeiterfassungFac().getAllMaschinenzeitenEinesBeleges( losablieferungDto.getLosIId(), null, null, null, theClientDto); // "normale" Zeiten zeiten = getZeiterfassungFac().getAllZeitenEinesBeleges(LocaleFac.BELEGART_LOS, losablieferungDto.getLosIId(), null, null, null, null, false, false, theClientDto); } else { zeiten = new AuftragzeitenDto[listSollVerdichtet.size()]; zeitenMaschine = new AuftragzeitenDto[0]; bAlleZeitenZaehlenFuerArbeitswert = true; int row = 0; for (Iterator<?> iter = listSollVerdichtet.keySet().iterator(); iter.hasNext();) { Integer artikelIId = (Integer) iter.next(); BigDecimal gesamtzeit = listSollVerdichtet.get(artikelIId); AuftragzeitenDto az = new AuftragzeitenDto(); az.setArtikelIId(artikelIId); az.setDdDauer(new Double(gesamtzeit.doubleValue())); BigDecimal bdPreis = getLagerFac() .getGemittelterGestehungspreisAllerLaegerEinesMandanten(artikelIId, theClientDto); az.setBdKosten(gesamtzeit.multiply(bdPreis)); zeiten[row] = az; row++; } } // ------------------------------------------------------------------ // ---- // relevante Ist-Zeiten nach Ident verdichten HashMap<Integer, BigDecimal> listIstWert = new HashMap<Integer, BigDecimal>(); HashMap<Integer, BigDecimal> listIstZeit = new HashMap<Integer, BigDecimal>(); if (bMitMaschinenZeit) { for (int i = 0; i < zeitenMaschine.length; i++) { // Wenn vor der Ablieferung gebucht, dann addieren if ((zeitenMaschine[i].getTsEnde() != null && zeitenMaschine[i].getTsEnde().before(losablieferungDto.getTAendern())) || bAlleZeitenZaehlenFuerArbeitswert == true) { BigDecimal bdBisherWert = listIstWert.get(zeitenMaschine[i].getArtikelIId()); BigDecimal bdBisherZeit = listIstZeit.get(zeitenMaschine[i].getArtikelIId()); if (bdBisherWert == null) { listIstWert.put(zeitenMaschine[i].getArtikelIId(), zeitenMaschine[i].getBdKosten()); listIstZeit.put(zeitenMaschine[i].getArtikelIId(), new BigDecimal(zeitenMaschine[i].getDdDauer())); } else { listIstWert.put(zeitenMaschine[i].getArtikelIId(), bdBisherWert.add(zeitenMaschine[i].getBdKosten())); listIstZeit.put(zeitenMaschine[i].getArtikelIId(), bdBisherZeit.add(new BigDecimal(zeitenMaschine[i].getDdDauer()))); } } } } // "normale" Zeiten for (int i = 0; i < zeiten.length; i++) { // Wenn vor der Ablieferung gebucht, dann addieren if ((zeiten[i].getTsEnde() != null && zeiten[i].getTsEnde().before(losablieferungDto.getTAendern())) || bAlleZeitenZaehlenFuerArbeitswert == true) { BigDecimal bdBisherWert = listIstWert.get(zeiten[i].getArtikelIId()); BigDecimal bdBisherZeit = listIstZeit.get(zeiten[i].getArtikelIId()); if (bdBisherWert == null) { listIstWert.put(zeiten[i].getArtikelIId(), zeiten[i].getBdKosten()); listIstZeit.put(zeiten[i].getArtikelIId(), new BigDecimal(zeiten[i].getDdDauer())); } else { listIstWert.put(zeiten[i].getArtikelIId(), bdBisherWert.add(zeiten[i].getBdKosten())); listIstZeit.put(zeiten[i].getArtikelIId(), bdBisherZeit.add(new BigDecimal(zeiten[i].getDdDauer()))); } } } // ------------------------------------------------------------------ // ---- for (Iterator<?> iter = listIstZeit.keySet().iterator(); iter.hasNext();) { Integer artikelIId = (Integer) iter.next(); // Wenn das Los erledigt ist, dann zaehlen alle if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ERLEDIGT) || (bdErledigt.doubleValue() >= losDto.getNLosgroesse().doubleValue())) { if (bWertOderZeit) { bdErgebnis = bdErgebnis.add(listIstWert.get(artikelIId)); } else { bdErgebnis = bdErgebnis.add(listIstZeit.get(artikelIId)); } } // nicht vollstaendig erledigte Lose kriegen hoechstens die // anhand sollsatzgroesse errechnete zeit else { BigDecimal bdIstZeit = listIstZeit.get(artikelIId); BigDecimal bdSollZeit = listSollVerdichtet.get(artikelIId); if (bdSollZeit == null) { // nothing here // Taetigkeiten, die im Sollarbeitsplan nicht enthalten // waren, werden hier noch nicht gezaehlt } else { // Ist liegt unter Soll -> ganzer Wert bzw. Zeit if (bdSollZeit.compareTo(bdIstZeit) >= 0) { if (bWertOderZeit) { bdErgebnis = bdErgebnis.add(listIstWert.get(artikelIId)); } else { bdErgebnis = bdErgebnis.add(listIstZeit.get(artikelIId)); } } // Sollsatzzeit ueberschritten else { if (bWertOderZeit) { bdErgebnis = bdErgebnis.add(listIstWert.get(artikelIId).multiply(bdSollZeit) .divide(bdIstZeit, 4, BigDecimal.ROUND_HALF_EVEN)); } else { bdErgebnis = bdErgebnis.add(bdSollZeit); } } } } } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } if (losablieferungDto.getNMenge().doubleValue() != 0) { return bdErgebnis.divide(losablieferungDto.getNMenge(), 4, BigDecimal.ROUND_HALF_EVEN); } else { return new BigDecimal(0); } }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
@TransactionAttribute(TransactionAttributeType.NEVER) public KapazitaetsvorschauDto getKapazitaetsvorschau(TheClientDto theClientDto) throws EJBExceptionLP { KapazitaetsvorschauDto kapDto = null; Session session = null;/*from ww w. j a v a 2s . c o m*/ try { // ------------------------------------------------------------------ // ----- // Benoetigte Parameter holen // ------------------------------------------------------------------ // ----- // Default Sicht nach Wochen // final int iSicht = FertigungFac.KAPAZITAETSVORSCHAU_NACH_WOCHEN; // Anzahl der angezeigten Vatergruppen. Alles andere wird nach // "Sonstige" verdichtet final ParametermandantDto parameterAnzahlGruppen = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_FERTIGUNG_KAPAZITAETSVORSCHAU_ANZAHL_GRUPPEN); final int iParamAnzahlGruppen = (Integer) parameterAnzahlGruppen.getCWertAsObject(); // Angezeigter Zeitraum = Anzahl der Spalten final ParametermandantDto parameterZeitraum = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_FERTIGUNG_KAPAZITAETSVORSCHAU_ZEITRAUM); final int iParamZeitraum = (Integer) parameterZeitraum.getCWertAsObject(); // ------------------------------------------------------------------ // ----- // Hibernate-Session erstellen // ------------------------------------------------------------------ // ----- SessionFactory factory = FLRSessionFactory.getFactory(); session = factory.openSession(); // ------------------------------------------------------------------ // ----- // Artikel- / Maschinen-Vatergruppen holen // ------------------------------------------------------------------ // ----- // Alle Artikel-Vatergruppen Criteria cArtikelVatergruppen = session.createCriteria(FLRArtikelgruppe.class); cArtikelVatergruppen.add(Restrictions.isNull(ArtikelFac.FLR_ARTIKELGRUPPE_FLRARTIKELGRUPPE)); List<?> listArtikelgruppen = cArtikelVatergruppen.list(); // Alle Maschinen-Vatergruppen Criteria cMaschinengruppen = session.createCriteria(FLRMaschinengruppe.class); List<?> listMaschinengruppen = cMaschinengruppen.list(); // ------------------------------------------------------------------ // ----- // Anzahl der sub-Diagramme bestimmen // das ist grundsaetzlich (iParamAnzahlGruppen + 1) x 2 ... // (Anzahl d. anzuzeigenden Vatergruppen + Sonstige) f. AZ und // Maschinen // wenn es weniger Vatergruppen als anzuzeigende gibt, reduziert // sich das aber // Gibt es keine Vatergruppe, wird daher alles nach "Sonstige" // verdichtet // ------------------------------------------------------------------ // ----- final int iAnzuzeigendeArtikelgruppen = Math.min(iParamAnzahlGruppen, listArtikelgruppen.size()); final int iAnzuzeigendeMaschinengruppen = Math.min(iParamAnzahlGruppen, listMaschinengruppen.size()); final int iAnzahlZeilen = iAnzuzeigendeArtikelgruppen + 1 + iAnzuzeigendeMaschinengruppen + 1; // ------------------------------------------------------------------ // ----- // Dto initialisieren // ------------------------------------------------------------------ // ----- kapDto = new KapazitaetsvorschauDto(iAnzahlZeilen, iParamZeitraum); // ------------------------------------------------------------------ // ----- // Beschriftung der x-Achse ermitteln. das sind die Kalenderwochen // ------------------------------------------------------------------ // ----- HashMap<Integer, Integer> hmKWIndizes = new HashMap<Integer, Integer>(); String[] kw = new String[iParamZeitraum]; GregorianCalendar gc = new GregorianCalendar(); for (int i = 0; i < kw.length; i++) { int iKw = gc.get(GregorianCalendar.WEEK_OF_YEAR); kw[i] = "" + iKw; kapDto.setISpaltenueberschrift(i, kw[i]); hmKWIndizes.put(gc.get(GregorianCalendar.WEEK_OF_YEAR), i); gc.setTimeInMillis(gc.getTimeInMillis() + 7 * 24 * 60 * 60 * 1000); // 1 Woche dazu } // ------------------------------------------------------------------ // ----- // Beschriftung der y-Achse ermitteln. das sind die Namen der // Vatergruppen bzw. 2 x "Sonstige". // Weiters werden die Indizes im Daten-Array fuer die jeweiligen // Gruppen festgelegt. // ------------------------------------------------------------------ // ----- String sSonstige = getTextRespectUISpr("lp.sonstige", theClientDto.getMandant(), theClientDto.getLocUi()); HashMap<Integer, Integer> hmArtikelGruppenIndizes = new HashMap<Integer, Integer>(); HashMap<Integer, Integer> hmMaschinenGruppenIndizes = new HashMap<Integer, Integer>(); // zuerst die Artikelvatergruppen for (int i = 0; i < iAnzuzeigendeArtikelgruppen; i++) { FLRArtikelgruppe item = (FLRArtikelgruppe) listArtikelgruppen.get(i); kapDto.setIZeilenueberschrift(i, item.getC_nr()); hmArtikelGruppenIndizes.put(item.getI_id(), i); } // Dann Sonstige Artikelgruppen final int indexSonstigeArtikelGruppen = iAnzuzeigendeArtikelgruppen; kapDto.setIZeilenueberschrift(indexSonstigeArtikelGruppen, sSonstige); // Maschinengruppen for (int i = 0; i < iAnzuzeigendeMaschinengruppen; i++) { FLRMaschinengruppe item = (FLRMaschinengruppe) listMaschinengruppen.get(i); int index = iAnzuzeigendeArtikelgruppen + 1 + i; kapDto.setIZeilenueberschrift(index, item.getC_bez()); hmMaschinenGruppenIndizes.put(item.getI_id(), index); } // zuletzt Sonstige Maschinengruppen final int indexSonstigeMaschinenGruppen = iAnzuzeigendeArtikelgruppen + 1 + iAnzuzeigendeMaschinengruppen; kapDto.setIZeilenueberschrift(indexSonstigeMaschinenGruppen, sSonstige); // ------------------------------------------------------------------ // ----- // Lose holen // ------------------------------------------------------------------ // ----- Criteria cLose = session.createCriteria(FLRLos.class); // Filter nach Mandant cLose.add(Restrictions.eq(FertigungFac.FLR_LOS_MANDANT_C_NR, theClientDto.getMandant())); // Alle Stati ausser Erledigt, Gestoppt, Storniert Collection<String> cLoseStati = new LinkedList<String>(); cLoseStati.add(FertigungFac.STATUS_ERLEDIGT); cLoseStati.add(FertigungFac.STATUS_GESTOPPT); cLoseStati.add(FertigungFac.STATUS_STORNIERT); cLose.add(Restrictions.not(Restrictions.in(FertigungFac.FLR_LOS_STATUS_C_NR, cLoseStati))); List<?> listLose = cLose.list(); // ------------------------------------------------------------------ // ----- // Auswertungszeitraum und verfuegbare Kapazitaeten ermitteln // ------------------------------------------------------------------ // ----- // 3 Monate in die zukunft Calendar c = Calendar.getInstance(); c.setTimeInMillis(System.currentTimeMillis()); c.set(Calendar.MONTH, c.get(Calendar.MONTH) + 3); java.util.Date dMax = Helper.cutDate(new java.sql.Date(c.getTimeInMillis())); java.sql.Timestamp tVon = Helper.cutTimestamp(new java.sql.Timestamp(System.currentTimeMillis())); java.sql.Timestamp tBis = Helper.cutTimestamp(new java.sql.Timestamp(dMax.getTime())); // Verfuegbare Zeiten holen SollverfuegbarkeitDto[] oVerfuegbar = getZeiterfassungFac().getVerfuegbareSollzeit(tVon, tBis, theClientDto); // diese nun aufteilen for (int i = 0; i < oVerfuegbar.length; i++) { SollverfuegbarkeitDto svDto = oVerfuegbar[i]; // "normale" AZ if (svDto.isBMannarbeitszeit()) { // die sind einer Artikelgruppe zugeordnet if (svDto.getIGruppeid() != null) { Integer iZeile = hmArtikelGruppenIndizes.get(svDto.getIGruppeid()); // ist das eine sichtbare Gruppe if (iZeile != null) { for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(iZeile, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } // wenn nicht, dann zu den sonstigen else { for (int iSpalte = 0; iSpalte < kapDto .getDetails()[indexSonstigeArtikelGruppen].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(indexSonstigeArtikelGruppen, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } } // Rest = Sonstige Artikelgruppen else { if (svDto.getTDatum() != null) { // Die KW dieses Datums ermitteln, damit das // zugeordnet werden kann GregorianCalendar gcSV = new GregorianCalendar(); gcSV.setTime(svDto.getTDatum()); int kwSV = gcSV.get(Calendar.WEEK_OF_YEAR); Integer iIndexDerKW = hmKWIndizes.get(kwSV); if (iIndexDerKW != null) { // Hier nicht mit 5 multiplizieren, da es fuer // jeden Tag einen eigenen Eintrag gibt kapDto.addBdVerfuegbareStunden(indexSonstigeArtikelGruppen, iIndexDerKW, svDto.getNSollstunden()); } else { // diese KW wird nicht mehr angezeigt - brauch // ich nicht einrechnen } } } } // Maschinenzeit - die Verfuegbarkeit ist jeden Tag gleich else { Integer iZeile = hmMaschinenGruppenIndizes.get(svDto.getIGruppeid()); // ist das eine sichtbare Gruppe if (iZeile != null) { for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(iZeile, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } // wenn nicht, dann zu den sonstigen else { for (int iSpalte = 0; iSpalte < kapDto .getDetails()[indexSonstigeMaschinenGruppen].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(indexSonstigeMaschinenGruppen, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } } } // ------------------------------------------------------------------ // ----- // Offene Zeiten ermitteln // ------------------------------------------------------------------ // ----- for (Iterator<?> iter = listLose.iterator(); iter.hasNext();) { FLRLos los = (FLRLos) iter.next(); // Offene Menge ermitteln BigDecimal bdOffen = los.getN_losgroesse(); for (Iterator<?> iterAblieferung = los.getAblieferungset().iterator(); iterAblieferung.hasNext();) { FLRLosablieferung item = (FLRLosablieferung) iterAblieferung.next(); bdOffen = bdOffen.subtract(item.getN_menge()); } // nur Lose mit tatsaechlich offener Menge>0 if (bdOffen.compareTo(new BigDecimal(0)) > 0) { // Faktor zur Berechnung der offenen Zeiten = offene Menge / // Losgroesse. 2 Nachkommastellen sollten reichen. BigDecimal bdFaktor = bdOffen.divide(los.getN_losgroesse(), 2, BigDecimal.ROUND_HALF_EVEN); // Arbeitsplan holen Criteria cLosAZ = session.createCriteria(FLRLossollarbeitsplan.class); cLosAZ.add(Restrictions.eq(FertigungFac.FLR_LOSSOLLARBEITSPLAN_LOS_I_ID, los.getI_id())); List<?> listLosAZ = cLosAZ.list(); // fuer alle Taetigkeiten for (Iterator<?> iterAZ = listLosAZ.iterator(); iterAZ.hasNext();) { FLRLossollarbeitsplan losAZ = (FLRLossollarbeitsplan) iterAZ.next(); BigDecimal bdOffeneStunden = losAZ.getN_gesamtzeit().multiply(bdFaktor); // ------------------------------------------------------ // ----------------- // Index der Gruppe bestimmen, der ich das zuordnen muss // ------------------------------------------------------ // ----------------- int iZeilenIndex; // 1. nach Maschinengruppe // 2. nach Artikelgruppe der Taetigkeit FLRMaschine flrMaschine = losAZ.getFlrmaschine(); Integer iMaschinengruppeIId = null; Integer iArtikelgruppeIId = null; if (flrMaschine != null) { FLRMaschinengruppe flrMaschinengruppe = flrMaschine.getFlrmaschinengruppe(); if (flrMaschinengruppe != null) { // Wenn diese Maschinengruppe dargestellt wird, // dann kommt hier der index raus. Integer i = hmMaschinenGruppenIndizes.get(flrMaschinengruppe.getI_id()); iMaschinengruppeIId = flrMaschinengruppe.getI_id(); if (i != null) { iZeilenIndex = i; } // wenn nicht -> sonstige. else { iZeilenIndex = indexSonstigeMaschinenGruppen; } } // Maschinen ohne Maschinengruppe werden nach // "Sonstige" verdichtet. else { iZeilenIndex = indexSonstigeMaschinenGruppen; } } else { FLRArtikel flrArtikel = losAZ.getFlrartikel(); FLRArtikelgruppe flrArtikelgruppe = flrArtikel.getFlrartikelgruppe(); if (flrArtikelgruppe != null) { // Wenn diese Artikelgruppe dargestellt wird, // dann kommt hier der index raus. Integer i = hmArtikelGruppenIndizes.get(flrArtikelgruppe.getI_id()); iArtikelgruppeIId = flrArtikelgruppe.getI_id(); if (i != null) { iZeilenIndex = i; } // wenn nicht -> sonstige. else { iZeilenIndex = indexSonstigeArtikelGruppen; } } // Taetigkeiten ohne Artikelgruppe werden nach // "Sonstige" verdichtet. else { iZeilenIndex = indexSonstigeArtikelGruppen; } } // ------------------------------------------------------ // ----------------- // Jetzt hab ich die Gruppe, der ich das zuordnen muss // nun muss die Zeit aufgeteilt werden // ------------------------------------------------------ // ----------------- java.util.Date tLosStarttermin = los.getT_produktionsbeginn(); java.util.Date tLosEndetermin = los.getT_produktionsende(); // beide Termine duerfen nicht vor heute liegen if (tLosStarttermin.before(getDate())) { tLosStarttermin = getDate(); } if (tLosEndetermin.before(getDate())) { tLosEndetermin = getDate(); } // Anzahl der betroffenen Kalenderwochen bestimmen GregorianCalendar gcStart = new GregorianCalendar(); gcStart.setTime(tLosStarttermin); GregorianCalendar gcEnde = new GregorianCalendar(); gcEnde.setTime(tLosEndetermin); int iStartKW = gcStart.get(Calendar.WEEK_OF_YEAR); int iEndeKW = gcEnde.get(Calendar.WEEK_OF_YEAR); int iAnzahlKW = 1 + iEndeKW - iStartKW; // nun auf die Wochen aufteilen BigDecimal bdOffeneStundenJeWoche = bdOffeneStunden; if (iAnzahlKW > 0) { bdOffeneStundenJeWoche = bdOffeneStunden.divide(new BigDecimal(iAnzahlKW), 2, RoundingMode.HALF_UP); } for (int iAktuelleKW = iStartKW; iAktuelleKW <= iEndeKW; iAktuelleKW++) { Integer indexDerKW = hmKWIndizes.get(iAktuelleKW); // wird diese Woche auch angezeigt? if (indexDerKW != null) { KapazitaetsvorschauDetailDto detailDto = new KapazitaetsvorschauDetailDto(); detailDto.setArtikelgruppeIId(iArtikelgruppeIId); detailDto.setArtikelIIdTaetigkeit(losAZ.getFlrartikel().getI_id()); detailDto.setBdDauer(bdOffeneStundenJeWoche); detailDto.setLosIId(los.getI_id()); detailDto.setLossollarbeitsplanIId(losAZ.getI_id()); detailDto.setMaschinengruppeIId(iMaschinengruppeIId); kapDto.addDetail(iZeilenIndex, indexDerKW, detailDto); } } } } } // ------------------------------------------------------------------ // ----- // Diagramm aus den Daten erstellen // ------------------------------------------------------------------ // ----- SymbolAxis xAchse = new SymbolAxis("KW", kw); CombinedDomainXYPlot plot = new CombinedDomainXYPlot(xAchse); for (int iZeile = 0; iZeile < kapDto.getDetails().length; iZeile++) { XYSeries datenZeile = new XYSeries(kapDto.getIZeilenueberschrift(iZeile)); // Balkenfarben festlegen ( >100% = rot, sonst hellgrau) // fuer jede zeile und jede spalte Paint[][] paints = new Paint[1][kapDto.getDetails()[iZeile].length]; for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { BigDecimal bdVerfuegbar = kapDto.getBdVerfuegbareStunden()[iZeile][iSpalte]; BigDecimal bdBenoetigt = new BigDecimal(0); // Benoetigte Zeit jet Gruppe je Woche ermitteln for (Iterator<?> iter = kapDto.getDetails()[iZeile][iSpalte].iterator(); iter.hasNext();) { KapazitaetsvorschauDetailDto item = (KapazitaetsvorschauDetailDto) iter.next(); bdBenoetigt = bdBenoetigt.add(item.getBdDauer()); } BigDecimal value = new BigDecimal(0); if (bdVerfuegbar.compareTo(new BigDecimal(0)) > 0) { value = (bdBenoetigt.multiply(new BigDecimal(100))).divide(bdVerfuegbar, 4, BigDecimal.ROUND_HALF_EVEN); if (value.doubleValue() > 100.0) { paints[0][iSpalte] = Color.red; } else { paints[0][iSpalte] = Color.lightGray; } } // tage ohne Verfuegbarkeit mach ich 100% und weisz else { value = new BigDecimal(100.0); // Wochen ohne Kapazitaet aber mit geplanter Zeit if (bdBenoetigt.compareTo(new BigDecimal(0)) > 0) { paints[0][iSpalte] = Color.MAGENTA; } // Wenn nichts verfuegbar aber auch nichts benoetigt -> // weiss else { paints[0][iSpalte] = Color.white; } } XYDataItem data = new XYDataItem(iSpalte, value.doubleValue()); datenZeile.add(data); } // Zur Collection XYSeriesCollection xyDataset = new XYSeriesCollection(); xyDataset.addSeries(datenZeile); // subplot erstellen XYItemRenderer renderer1 = new CustomXYBarRenderer(paints); // renderer1.setItemLabelsVisible(true); // Legende nicht anzeigen renderer1.setBaseSeriesVisibleInLegend(false); NumberAxis zeilenAchse = new NumberAxis(kapDto.getIZeilenueberschrift(iZeile)); // Beschriftung der Y-Achse um 90 grad drehen zeilenAchse.setLabelAngle(Math.PI / 2.0); zeilenAchse.setAutoRange(true); XYPlot subplot1 = new XYPlot(xyDataset, null, zeilenAchse, renderer1); subplot1.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT); // Markierung bei 100% final Marker target = new ValueMarker(100.0); target.setPaint(Color.darkGray); // target.setLabel("100 %"); // Label // target.setLabelAnchor(RectangleAnchor.TOP_RIGHT); // target.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT); subplot1.addRangeMarker(target); plot.add(subplot1); // plot.add(subplot1, 1); } JFreeChart lStackedBarChart = new JFreeChart(plot); kapDto.setJfcKapazitaetsvorschau(lStackedBarChart); } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } finally { if (session != null) { session.close(); } } return kapDto; }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
private void bucheNegativesollmengenAufLager(LosDto losDto, BigDecimal bdGesamtAbgeliefert, TheClientDto theClientDto) {//from ww w.j a va 2 s. c o m Query query = em.createNamedQuery("LossollmaterialfindByLosIId"); query.setParameter(1, losDto.getIId()); Collection<?> cl = query.getResultList(); LossollmaterialDto[] sollmat = assembleLossollmaterialDtos(cl); Integer lagerIId = null; ParametermandantDto parametermandantDto; try { parametermandantDto = getParameterFac().getMandantparameter(theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_NEGATIVE_SOLLMENGEN_BUCHEN_AUF_ZIELLAGER); if (((java.lang.Boolean) parametermandantDto.getCWertAsObject()).booleanValue() == true) { lagerIId = losDto.getLagerIIdZiel(); } else { // Laeger des Loses LoslagerentnahmeDto[] laeger = loslagerentnahmeFindByLosIId(losDto.getIId()); lagerIId = laeger[0].getLagerIId(); } } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } for (int i = 0; i < sollmat.length; i++) { LossollmaterialDto sollmatZeile = sollmat[i]; if (sollmatZeile.getNMenge().doubleValue() < 0) { // Sollsatzgroesse BigDecimal ssg = sollmatZeile.getNMenge().abs().divide(losDto.getNLosgroesse(), 10, BigDecimal.ROUND_HALF_EVEN); BigDecimal soll = bdGesamtAbgeliefert.multiply(ssg); BigDecimal ausgegeben = getAusgegebeneMenge(sollmatZeile.getIId(), null, theClientDto).abs(); BigDecimal mengeNeu = soll.subtract(ausgegeben); if (mengeNeu.doubleValue() > 0) { LosistmaterialDto istmat = new LosistmaterialDto(); istmat.setLagerIId(lagerIId); istmat.setLossollmaterialIId(sollmat[i].getIId()); istmat.setNMenge(mengeNeu.abs()); istmat.setBAbgang(Helper.boolean2Short(false)); createLosistmaterial(istmat, null, theClientDto); } } } }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
public ArrayList<LosAusAuftragDto> holeAlleMoeglichenUnterloseEinerStueckliste(Integer artikelIId, BigDecimal zielmenge, int stdVorlaufzeit, Timestamp tLetzterBeginn, ArrayList<LosAusAuftragDto> losDtos, AuftragDto auftragDto, BigDecimal bdLosgroesse, TheClientDto theClientDto) { try {/*from w w w . j a v a 2 s . c o m*/ StuecklisteDto stuecklisteDto = getStuecklisteFac() .stuecklisteFindByMandantCNrArtikelIIdOhneExc(artikelIId, theClientDto); if (stuecklisteDto != null && !stuecklisteDto.getStuecklisteartCNr() .equals(StuecklisteFac.STUECKLISTEART_HILFSSTUECKLISTE)) { ArrayList<?> stuecklisteAufegloest = getStuecklisteFac().getStrukturDatenEinerStueckliste( stuecklisteDto.getIId(), theClientDto, StuecklisteReportFac.REPORT_STUECKLISTE_OPTION_SORTIERUNG_ARTIKELNR, 0, null, false, true, zielmenge, null, true); Timestamp tEnde = Helper.addiereTageZuTimestamp(tLetzterBeginn, -stdVorlaufzeit); if (stuecklisteDto.getNDefaultdurchlaufzeit() == null) { stuecklisteDto.setNDefaultdurchlaufzeit(new BigDecimal(0)); } Timestamp tBeginn = Helper.addiereTageZuTimestamp(tEnde, -stuecklisteDto.getNDefaultdurchlaufzeit().intValue()); LosAusAuftragDto laDto = new LosAusAuftragDto(); LosDto losDto = new LosDto(); losDto.setTProduktionsbeginn(new java.sql.Date(tBeginn.getTime())); losDto.setTProduktionsende(new java.sql.Date(tEnde.getTime())); losDto.setStuecklisteIId(stuecklisteDto.getIId()); losDto.setLagerIIdZiel(stuecklisteDto.getLagerIIdZiellager()); losDto.setFertigungsgruppeIId(stuecklisteDto.getFertigungsgruppeIId()); losDto.setNLosgroesse(zielmenge.multiply(bdLosgroesse)); losDto.setKostenstelleIId(auftragDto.getKostenstelleIId()); losDto.setCProjekt(auftragDto.getCBezProjektbezeichnung()); laDto.setLosDto(losDto); laDto.setFehlmengen(getFehlmengeFac() .getAnzahlFehlmengeEinesArtikels(stuecklisteDto.getArtikelIId(), theClientDto)); laDto.setReservierungen( getReservierungFac().getAnzahlReservierungen(stuecklisteDto.getArtikelIId(), theClientDto)); BigDecimal lagerstand = new BigDecimal(0); LagerDto[] allelaegerDtos = getLagerFac().lagerFindByMandantCNr(theClientDto.getMandant()); for (int i = 0; i < allelaegerDtos.length; i++) { if (Helper.short2boolean(allelaegerDtos[i].getBInternebestellung())) { lagerstand = lagerstand.add(getLagerFac().getLagerstand(stuecklisteDto.getArtikelIId(), allelaegerDtos[i].getIId(), theClientDto)); } } laDto.setLagerstand(lagerstand); laDto.setOffeneFertigungsmenge( getFertigungFac().getAnzahlInFertigung(stuecklisteDto.getArtikelIId(), theClientDto)); losDtos.add(laDto); for (int j = 0; j < stuecklisteAufegloest.size(); j++) { StuecklisteMitStrukturDto strukt = (StuecklisteMitStrukturDto) stuecklisteAufegloest.get(j); if (strukt.getStuecklistepositionDto() != null && strukt.getStuecklistepositionDto().getArtikelIId() != null) { losDtos = holeAlleMoeglichenUnterloseEinerStueckliste( strukt.getStuecklistepositionDto().getArtikelIId(), strukt.getStuecklistepositionDto().getNZielmenge().multiply(zielmenge), stdVorlaufzeit, tBeginn, losDtos, auftragDto, bdLosgroesse, theClientDto); } } } } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } return losDtos; }
From source file:org.openbravo.test.costing.TestCosting.java
@Test public void testCostingGG() throws Exception { final int day0 = 0; final int day1 = 5; final int day2 = 10; final int day3 = 15; final int day4 = 20; final int day5 = 25; final BigDecimal price1 = new BigDecimal("15.00"); final BigDecimal price2 = new BigDecimal("12.00"); final BigDecimal price3 = new BigDecimal("13.50"); final BigDecimal quantity1 = new BigDecimal("100"); final BigDecimal quantity2 = new BigDecimal("200"); try {/* w ww. ja v a 2s .com*/ OBContext.setOBContext(USER_ID, ROLE_ID, CLIENT_ID, ORGANIZATION_ID); OBContext.setAdminMode(true); // Create a new product for the test Product product = createProduct(price1); // Create purchase order and book it Order purchaseOrder1 = createPurchaseOrder(product, price1, quantity1, day0); // Create purchase order and book it Order purchaseOrder2 = createPurchaseOrder(product, price2, quantity1, day1); // Create goods receipt, run costing background, post it and assert it ShipmentInOut goodsReceipt1 = createGoodsReceipt(purchaseOrder1, price1, quantity1, day2); // Create goods receipt, run costing background, post it and assert it ShipmentInOut goodsReceipt2 = createGoodsReceipt(purchaseOrder2, price2, quantity1, day3); // Create purchase invoice, post it and assert it List<ShipmentInOut> goodsReceiptList = new ArrayList<ShipmentInOut>(); goodsReceiptList.add(goodsReceipt1); goodsReceiptList.add(goodsReceipt2); List<BigDecimal> priceList = new ArrayList<BigDecimal>(); priceList.add(price1); priceList.add(price2); createPurchaseInvoice(goodsReceiptList, priceList, quantity2, day5); // Update transaction total cost amount manualCostAdjustment(getProductTransactions(product.getId()).get(1), quantity1.multiply(price1), false, day4); // Assert product transactions List<ProductTransactionAssert> productTransactionAssertList = new ArrayList<ProductTransactionAssert>(); productTransactionAssertList.add( new ProductTransactionAssert(OBDal.getInstance().get(ShipmentInOut.class, goodsReceipt1.getId()) .getMaterialMgmtShipmentInOutLineList().get(0), price1, price1, true, false)); productTransactionAssertList.add( new ProductTransactionAssert(OBDal.getInstance().get(ShipmentInOut.class, goodsReceipt2.getId()) .getMaterialMgmtShipmentInOutLineList().get(0), price2, price1, true, true)); assertProductTransaction(product.getId(), productTransactionAssertList); // Assert product costing List<MaterialTransaction> transactionList = getProductTransactions(product.getId()); List<ProductCostingAssert> productCostingAssertList = new ArrayList<ProductCostingAssert>(); productCostingAssertList .add(new ProductCostingAssert(transactionList.get(0), price1, null, price1, quantity1)); productCostingAssertList .add(new ProductCostingAssert(transactionList.get(1), price1, price3, price1, quantity2)); assertProductCosting(product.getId(), productCostingAssertList); // Assert cost adjustment List<CostAdjustment> costAdjustmentList = getCostAdjustment(product.getId()); List<List<CostAdjustmentAssert>> costAdjustmentAssertList = new ArrayList<List<CostAdjustmentAssert>>(); List<CostAdjustmentAssert> costAdjustmentAssertLineList = new ArrayList<CostAdjustmentAssert>(); costAdjustmentAssertLineList.add(new CostAdjustmentAssert(transactionList.get(1), "MCC", quantity1.multiply(price1).add(quantity1.multiply(price2).negate()), day4, true)); costAdjustmentAssertList.add(costAdjustmentAssertLineList); assertCostAdjustment(costAdjustmentList, costAdjustmentAssertList); // Post cost adjustment 1 and assert it postDocument(costAdjustmentList.get(0)); List<DocumentPostAssert> documentPostAssertList = new ArrayList<DocumentPostAssert>(); documentPostAssertList.add(new DocumentPostAssert("61000", amount0, quantity1.multiply(price1).add(quantity1.multiply(price2).negate()), null)); documentPostAssertList.add(new DocumentPostAssert("35000", quantity1.multiply(price1).add(quantity1.multiply(price2).negate()), amount0, null)); CostAdjustment costAdjustment = OBDal.getInstance().get(CostAdjustment.class, costAdjustmentList.get(0).getId()); assertDocumentPost(costAdjustment, product.getId(), documentPostAssertList); OBDal.getInstance().commitAndClose(); } catch (Exception e) { System.out.println(e.getMessage()); throw new OBException(e); } finally { OBContext.restorePreviousMode(); } }