List of usage examples for java.math BigDecimal divide
public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
private void aktualisiereAZAllerLosablieferungen(Integer losIId, TheClientDto theClientDto) { LosDto losDto = losFindByPrimaryKey(losIId); try {//from w w w . jav a 2s . co m // Sollzeiten LossollarbeitsplanDto[] soll = lossollarbeitsplanFindByLosIId(losDto.getIId()); int SOLL = 0; int IST = 1; int WERT = 2; // Sollzeiten nach Artikel verdichten HashMap<Integer, Object[]> listSollVerdichtet = new HashMap<Integer, Object[]>(); for (int i = 0; i < soll.length; i++) { if (listSollVerdichtet.containsKey(soll[i].getArtikelIIdTaetigkeit())) { Object[] oTemp = listSollVerdichtet.get(soll[i].getArtikelIIdTaetigkeit()); BigDecimal sollZeit = soll[i].getNGesamtzeit(); if (soll[i].getMaschineIId() != null) { sollZeit = sollZeit.multiply(new BigDecimal(2)); } oTemp[SOLL] = ((BigDecimal) oTemp[SOLL]).add(sollZeit); oTemp[IST] = new BigDecimal(0.00); oTemp[WERT] = new BigDecimal(0.00); listSollVerdichtet.put(soll[i].getArtikelIIdTaetigkeit(), oTemp); } else { Object[] oZeile = new Object[3]; BigDecimal sollZeit = soll[i].getNGesamtzeit(); if (soll[i].getMaschineIId() != null) { sollZeit = sollZeit.multiply(new BigDecimal(2)); } oZeile[SOLL] = sollZeit; oZeile[IST] = new BigDecimal(0.00); oZeile[WERT] = new BigDecimal(0.00); listSollVerdichtet.put(soll[i].getArtikelIIdTaetigkeit(), oZeile); } } // Maschinenzeiten AuftragzeitenDto[] zeitenMaschine = getZeiterfassungFac().getAllMaschinenzeitenEinesBeleges(losIId, null, null, null, theClientDto); // "normale" Zeiten AuftragzeitenDto[] zeitenMann = getZeiterfassungFac().getAllZeitenEinesBeleges(LocaleFac.BELEGART_LOS, losIId, null, null, null, null, false, false, theClientDto); LosablieferungDto[] losablieferungDtos = losablieferungFindByLosIIdOhneNeuberechnungUndOhneSnrChnr( losIId, theClientDto); boolean bErledigtOderUeberliefert = false; BigDecimal bdGesamtAbgeliefert = new BigDecimal(0.00); for (int i = 0; i < losablieferungDtos.length; i++) { LosablieferungDto losablieferungDto = losablieferungDtos[i]; bdGesamtAbgeliefert = bdGesamtAbgeliefert.add(losablieferungDto.getNMenge()); } if (losDto.getStatusCNr().equals(LocaleFac.STATUS_ERLEDIGT) || bdGesamtAbgeliefert.doubleValue() >= losDto.getNLosgroesse().doubleValue()) { bErledigtOderUeberliefert = true; } BigDecimal bdKostenGesamt = new BigDecimal(0.00); BigDecimal bdVerbrauchteKostenGesamt = new BigDecimal(0.00); HashMap<Integer, BigDecimal> hmUeberigeZeitderVorhergehendenAblieferung = new HashMap(); HashMap bdUeberigeKostenderVorhergehendenAblieferung = new HashMap<Object, BigDecimal>(); for (int i = 0; i < losablieferungDtos.length; i++) { LosablieferungDto losablieferungDto = losablieferungDtos[i]; HashMap<Integer, Object[]> hmAblieferung = new HashMap<Integer, Object[]>(); Iterator<?> it = listSollVerdichtet.keySet().iterator(); while (it.hasNext()) { Integer key = (Integer) it.next(); Object[] oNew = new Object[3]; Object[] oVorhanden = listSollVerdichtet.get(key); oNew[SOLL] = oVorhanden[SOLL]; oNew[IST] = oVorhanden[IST]; oNew[WERT] = oVorhanden[WERT]; hmAblieferung.put(key, oNew); } for (int j = 0; j < zeitenMaschine.length; j++) { BigDecimal bdIst = new BigDecimal(0.00); if (zeitenMaschine[j].getTsEnde() != null) { if (i == 0 && i == losablieferungDtos.length - 1) { if (zeitenMaschine[j].getTsEnde().before(losablieferungDto.getTAendern()) || zeitenMaschine[j].getTsEnde().after(losablieferungDtos[0].getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMaschine[j].getDdDauer().doubleValue())); } } else if (i == 0) { if (zeitenMaschine[j].getTsEnde().before(losablieferungDto.getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMaschine[j].getDdDauer().doubleValue())); } } else if (i == losablieferungDtos.length - 1) { if (zeitenMaschine[j].getTsEnde().after(losablieferungDtos[i - 1].getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMaschine[j].getDdDauer().doubleValue())); } } else { if (zeitenMaschine[j].getTsEnde().after(losablieferungDtos[i - 1].getTAendern()) && zeitenMaschine[j].getTsEnde().before(losablieferungDto.getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMaschine[j].getDdDauer().doubleValue())); } } } if (bdIst.doubleValue() > 0) { bdKostenGesamt = bdKostenGesamt.add(zeitenMaschine[j].getBdKosten()); if (hmAblieferung.containsKey(zeitenMaschine[j].getArtikelIId())) { Object[] oZeile = hmAblieferung.get(zeitenMaschine[j].getArtikelIId()); oZeile[IST] = ((BigDecimal) oZeile[IST]).add(bdIst); oZeile[WERT] = ((BigDecimal) oZeile[WERT]).add(zeitenMaschine[j].getBdKosten()); hmAblieferung.put(zeitenMaschine[j].getArtikelIId(), oZeile); } else { Object[] oZeile = new Object[3]; oZeile[SOLL] = new BigDecimal(0.00); oZeile[IST] = bdIst; oZeile[WERT] = zeitenMaschine[j].getBdKosten(); hmAblieferung.put(zeitenMaschine[j].getArtikelIId(), oZeile); } } } // Zeiten Mann for (int j = 0; j < zeitenMann.length; j++) { BigDecimal bdIst = new BigDecimal(0.00); if (zeitenMann[j].getTsEnde() != null) { if (i == 0 && i == losablieferungDtos.length - 1) { if (zeitenMann[j].getTsEnde().before(losablieferungDto.getTAendern()) || zeitenMann[j].getTsEnde().after(losablieferungDtos[0].getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMann[j].getDdDauer().doubleValue())); } } else if (i == 0) { if (zeitenMann[j].getTsEnde().before(losablieferungDto.getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMann[j].getDdDauer().doubleValue())); } } else if (i == losablieferungDtos.length - 1) { if (zeitenMann[j].getTsEnde().after(losablieferungDtos[i - 1].getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMann[j].getDdDauer().doubleValue())); } } else { if (zeitenMann[j].getTsEnde().after(losablieferungDtos[i - 1].getTAendern()) && zeitenMann[j].getTsEnde().before(losablieferungDto.getTAendern())) { bdIst = bdIst.add(new BigDecimal(zeitenMann[j].getDdDauer().doubleValue())); } } } if (bdIst.doubleValue() > 0) { bdKostenGesamt = bdKostenGesamt.add(zeitenMann[j].getBdKosten()); if (hmAblieferung.containsKey(zeitenMann[j].getArtikelIId())) { Object[] oZeile = hmAblieferung.get(zeitenMann[j].getArtikelIId()); oZeile[IST] = ((BigDecimal) oZeile[IST]).add(bdIst); oZeile[WERT] = ((BigDecimal) oZeile[WERT]).add(zeitenMann[j].getBdKosten()); hmAblieferung.put(zeitenMann[j].getArtikelIId(), oZeile); } else { Object[] oZeile = new Object[3]; oZeile[SOLL] = new BigDecimal(0.00); oZeile[IST] = bdIst; oZeile[WERT] = zeitenMann[j].getBdKosten(); hmAblieferung.put(zeitenMann[j].getArtikelIId(), oZeile); } } } Iterator<?> itTemp = hmAblieferung.keySet().iterator(); BigDecimal azWertDerAblieferung = new BigDecimal(0.00); while (itTemp.hasNext()) { Integer key = (Integer) itTemp.next(); Object[] oZeile = hmAblieferung.get(key); // Sollsatzgroesze ermitteln BigDecimal bdIstAblieferung = (BigDecimal) oZeile[IST]; // Vorherige uebrige Zeit dazuzaehlen if (hmUeberigeZeitderVorhergehendenAblieferung.containsKey(key)) { bdIstAblieferung = bdIstAblieferung .add((BigDecimal) hmUeberigeZeitderVorhergehendenAblieferung.get(key)); } BigDecimal bdSollAblieferung = (BigDecimal) oZeile[SOLL]; BigDecimal bdKostenAblieferung = (BigDecimal) oZeile[WERT]; if (bdUeberigeKostenderVorhergehendenAblieferung.containsKey(key)) { bdKostenAblieferung = bdKostenAblieferung .add((BigDecimal) bdUeberigeKostenderVorhergehendenAblieferung.get(key)); } if (bdSollAblieferung.doubleValue() != 0) { // Sollsatzgroesse ermitteln BigDecimal sollsatzgroesse = bdSollAblieferung .divide(losDto.getNLosgroesse(), 4, BigDecimal.ROUND_HALF_EVEN) .multiply(losablieferungDto.getNMenge()); BigDecimal maxSollsatzKosten = bdSollAblieferung.multiply(losablieferungDto.getNMenge()); BigDecimal tatsaechlicheKosten = null; if (bdKostenAblieferung.doubleValue() > maxSollsatzKosten.doubleValue()) { tatsaechlicheKosten = maxSollsatzKosten; } else { tatsaechlicheKosten = bdKostenAblieferung; } azWertDerAblieferung = azWertDerAblieferung.add(tatsaechlicheKosten); if (bdKostenAblieferung.doubleValue() > azWertDerAblieferung.doubleValue()) { bdUeberigeKostenderVorhergehendenAblieferung.put(key, bdKostenAblieferung.subtract(azWertDerAblieferung)); } } else { azWertDerAblieferung = azWertDerAblieferung.add(bdKostenAblieferung); } System.out.println(azWertDerAblieferung); } bdVerbrauchteKostenGesamt = bdVerbrauchteKostenGesamt.add(azWertDerAblieferung); // Wenn ERLEDIGT oder Ueberliefert //Den Rest hinzufuegen if (bErledigtOderUeberliefert && i == losablieferungDtos.length - 1) { BigDecimal restKosten = bdKostenGesamt.subtract(bdVerbrauchteKostenGesamt); azWertDerAblieferung = azWertDerAblieferung.add(restKosten); } if (losablieferungDto.getNMenge().doubleValue() != 0) { azWertDerAblieferung = azWertDerAblieferung.divide(losablieferungDto.getNMenge(), 4, BigDecimal.ROUND_HALF_EVEN); } Losablieferung losablieferung = em.find(Losablieferung.class, losablieferungDto.getIId()); if (losablieferung == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, ""); } losablieferung.setNArbeitszeitwert(azWertDerAblieferung); losablieferung.setNArbeitszeitwertdetailliert(azWertDerAblieferung); } } catch (RemoteException ex1) { throwEJBExceptionLPRespectOld(ex1); } }
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 {//from w w w. j a v a 2s . co 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.NEVER) public KapazitaetsvorschauDto getKapazitaetsvorschau(TheClientDto theClientDto) throws EJBExceptionLP { KapazitaetsvorschauDto kapDto = null; Session session = null;/* w ww.j a v a2 s. c om*/ 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
/** * Ist-Arbeitszeit fuer eine Ablieferung pro abgelieferter Einheit * bestimmen.//from w w w . j a v a 2 s. c om * * @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
@TransactionTimeout(1000) public void aktualisiereNachtraeglichPreiseAllerLosablieferungen(Integer losIId, TheClientDto theClientDto, boolean bNurLetztenMaterialwertNeuBerechnen) throws EJBExceptionLP { LosDto losDto = losFindByPrimaryKey(losIId); try {/*from www. j a va 2s. c o m*/ 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; } // AZ-Werte aktualisieren if (bSollGleichIstzeiten) { aktualisiereAZAllerLosablieferungenWennSollIstGleichIst(losIId, theClientDto); } else { aktualisiereAZAllerLosablieferungen(losIId, theClientDto); } // Preise berechnen: // -------------------------------------------------------------- // --------- // 1. der inklusive aller bisherigen ablieferungen erledigte // Materialwert if (bNurLetztenMaterialwertNeuBerechnen == false) { materialwertAllerLosablieferungenNeuBerechnen(losDto, theClientDto); } // PJ 14807 boolean bAblieferpreisIstDurchschnitspreis = false; ParametermandantDto parameter = getParameterFac().getMandantparameter(theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_ABLIEFERUNGSPREIS_IST_DURCHSCHNITTSPREIS); bAblieferpreisIstDurchschnitspreis = ((Boolean) parameter.getCWertAsObject()); BigDecimal bdMaterialwertGesamt = getErledigterMaterialwertNEU(losDto, theClientDto); // -------------------------------------------------------------- // --------- // nun der detaillierte Arbeitszeitwert (mit Beruecksichtigung // der Unterlose) // 1. der inklusive aller bisherigen ablieferungen erledigte // Arbeitszeitwert BigDecimal bdArbeitszeitwertAusUnterlosenGesamt = getErledigterArbeitszeitwertAusUnterlosen(losDto, theClientDto); // PJ14807 BigDecimal bdAzWertDurchschnitt = new BigDecimal(0); BigDecimal bdMatWertDurchschnitt = new BigDecimal(0); if (bAblieferpreisIstDurchschnitspreis == true) { BigDecimal bdGesamtkosten = new BigDecimal(0); // Maschinenzeiten AuftragzeitenDto[] zeitenMaschine = getZeiterfassungFac().getAllMaschinenzeitenEinesBeleges(losIId, null, null, null, theClientDto); for (int j = 0; j < zeitenMaschine.length; j++) { bdGesamtkosten = bdGesamtkosten.add(zeitenMaschine[j].getBdKosten()); } // "normale" Zeiten AuftragzeitenDto[] zeitenMann = getZeiterfassungFac().getAllZeitenEinesBeleges( LocaleFac.BELEGART_LOS, losIId, null, null, null, null, false, false, theClientDto); for (int j = 0; j < zeitenMann.length; j++) { bdGesamtkosten = bdGesamtkosten.add(zeitenMann[j].getBdKosten()); } bdGesamtkosten = bdGesamtkosten.add(bdArbeitszeitwertAusUnterlosenGesamt); BigDecimal bdAbgeliefertGesamt = getErledigteMenge(losDto.getIId(), theClientDto); if (bdAbgeliefertGesamt.doubleValue() > 0) { bdAzWertDurchschnitt = bdGesamtkosten.divide(bdAbgeliefertGesamt, 4, BigDecimal.ROUND_HALF_EVEN); bdMatWertDurchschnitt = bdMaterialwertGesamt.divide(bdAbgeliefertGesamt, 4, BigDecimal.ROUND_HALF_EVEN); } } Query query = em.createNamedQuery("LosablieferungfindByLosIId"); query.setParameter(1, losIId); Collection<?> losablieferungs = query.getResultList(); LosablieferungDto[] losabDtos = assembleLosablieferungDtosOhneSnrs(losablieferungs); for (Iterator<?> iter = losablieferungs.iterator(); iter.hasNext();) { Losablieferung losablieferung = (Losablieferung) iter.next(); // 2. bisher erledigte duerfen aber nicht mehr beruecksichtigt // werden -> subtrahieren // Diese werden durch die "Assemblierung" neu geladen (es // koennten sich Werte geaendert haben), das Find faellt aber // weg BigDecimal bdMaterialwert = bdMaterialwertGesamt; if (bAblieferpreisIstDurchschnitspreis == false) { if (bNurLetztenMaterialwertNeuBerechnen == true && iter.hasNext() == false) { // Ausser die betroffene Ablieferung selbst for (int i = 0; i < losabDtos.length; i++) { if (!losablieferung.getIId().equals(losabDtos[i].getIId())) { bdMaterialwert = bdMaterialwert.subtract( losabDtos[i].getNMaterialwert().multiply(losabDtos[i].getNMenge())); } } // 3. Nach Division durch die Menge der neuen // Ablieferung // hab // ich den Einzelwert losablieferung.setNMaterialwert( bdMaterialwert.divide(losablieferung.getNMenge(), 4, BigDecimal.ROUND_HALF_EVEN)); } // ---------------------------------------------------------- // ---- // --------- // Gestehungspreis: ist die Summe aus Materialwert und // Arbeitszeitwert losablieferung.setNGestehungspreis( losablieferung.getNMaterialwert().add(losablieferung.getNArbeitszeitwert())); BigDecimal bdArbeitszeitwertAusUnterlosen = bdArbeitszeitwertAusUnterlosenGesamt; // 2. bisher erledigte duerfen aber nicht mehr // beruecksichtigt // werden -> subtrahieren for (int i = 0; i < losabDtos.length; i++) { if (!losablieferung.getIId().equals(losabDtos[i].getIId())) { bdArbeitszeitwertAusUnterlosen = bdArbeitszeitwertAusUnterlosen.subtract(losabDtos[i] .getNArbeitszeitwertdetailliert().multiply(losabDtos[i].getNMenge())); } } // 3. Nach Division durch die Menge der neuen Ablieferung // hab // ich den Einzelwert BigDecimal bdAZWertAusUnterlosen = bdArbeitszeitwertAusUnterlosen .divide(losablieferung.getNMenge(), 4, BigDecimal.ROUND_HALF_EVEN); // 4. Dazu kommt noch der AZ-Wert aus diesem Los losablieferung.setNArbeitszeitwertdetailliert( bdAZWertAusUnterlosen.add(losablieferung.getNArbeitszeitwert())); // ---------------------------------------------------------- // ---- // --------- // nun der detaillierte Materialwert // der ist einfach die Differenz zwischen Gestehungspreis // und // Detailliertem Arbeitszeitwert losablieferung.setNMaterialwertdetailliert(losablieferung.getNGestehungspreis() .subtract(losablieferung.getNArbeitszeitwertdetailliert())); } else { losablieferung.setNMaterialwertdetailliert(bdMatWertDurchschnitt); losablieferung.setNMaterialwert(bdMatWertDurchschnitt); losablieferung.setNArbeitszeitwertdetailliert(bdAzWertDurchschnitt); losablieferung.setNArbeitszeitwert(bdAzWertDurchschnitt); losablieferung.setNGestehungspreis(bdMatWertDurchschnitt.add(bdAzWertDurchschnitt)); } // speichern if (bNurLetztenMaterialwertNeuBerechnen == false || (bNurLetztenMaterialwertNeuBerechnen == true && iter.hasNext() == false)) { losablieferung.setTAendern(losablieferung.getTAendern()); losablieferung.setBGestehungspreisneuberechnen(Helper.boolean2Short(false)); LosablieferungDto loaDot = assembleLosablieferungDto(losablieferung); // auch in Lagerbewegung aendern bucheLosAblieferungAufLager(loaDot, losDto, theClientDto); } } } catch (RemoteException ex1) { throwEJBExceptionLPRespectOld(ex1); } // catch (FinderException ex) { // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, // ex); // } }
From source file:org.apache.ofbiz.accounting.invoice.InvoiceServices.java
public static Map<String, Object> createInvoiceFromReturn(DispatchContext dctx, Map<String, Object> context) { Delegator delegator = dctx.getDelegator(); LocalDispatcher dispatcher = dctx.getDispatcher(); GenericValue userLogin = (GenericValue) context.get("userLogin"); Locale locale = (Locale) context.get("locale"); String returnId = (String) context.get("returnId"); List<GenericValue> billItems = UtilGenerics.checkList(context.get("billItems")); String errorMsg = UtilProperties.getMessage(resource, "AccountingErrorCreatingInvoiceForReturn", UtilMisc.toMap("returnId", returnId), locale); // List invoicesCreated = new ArrayList(); try {//from ww w . ja v a 2 s. c o m String invoiceTypeId; String description; // get the return header GenericValue returnHeader = EntityQuery.use(delegator).from("ReturnHeader").where("returnId", returnId) .queryOne(); if (returnHeader == null || returnHeader.get("returnHeaderTypeId") == null) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "AccountingReturnTypeCannotBeNull", locale)); } if (returnHeader.getString("returnHeaderTypeId").startsWith("CUSTOMER_")) { invoiceTypeId = "CUST_RTN_INVOICE"; description = "Return Invoice for Customer Return #" + returnId; } else { invoiceTypeId = "PURC_RTN_INVOICE"; description = "Return Invoice for Vendor Return #" + returnId; } List<GenericValue> returnItems = returnHeader.getRelated("ReturnItem", null, null, false); if (!returnItems.isEmpty()) { for (GenericValue returnItem : returnItems) { if ("RETURN_COMPLETED".equals(returnItem.getString("statusId"))) { GenericValue product = returnItem.getRelatedOne("Product", false); if (!ProductWorker.isPhysical(product)) { boolean isNonPhysicalItemToReturn = false; List<GenericValue> returnItemBillings = returnItem.getRelated("ReturnItemBilling", null, null, false); if (!returnItemBillings.isEmpty()) { GenericValue invoice = EntityUtil.getFirst(returnItemBillings) .getRelatedOne("Invoice", false); if ("INVOICE_CANCELLED".equals(invoice.getString("statusId"))) { isNonPhysicalItemToReturn = true; } } else { isNonPhysicalItemToReturn = true; } if (isNonPhysicalItemToReturn) { if (UtilValidate.isEmpty(billItems)) { billItems = new ArrayList<GenericValue>(); } billItems.add(returnItem); } } } } } Map<String, Object> results = ServiceUtil.returnSuccess(); if (UtilValidate.isNotEmpty(billItems)) { // set the invoice data Map<String, Object> input = UtilMisc.<String, Object>toMap("invoiceTypeId", invoiceTypeId, "statusId", "INVOICE_IN_PROCESS"); input.put("partyId", returnHeader.get("toPartyId")); input.put("partyIdFrom", returnHeader.get("fromPartyId")); input.put("currencyUomId", returnHeader.get("currencyUomId")); input.put("invoiceDate", UtilDateTime.nowTimestamp()); input.put("description", description); input.put("billingAccountId", returnHeader.get("billingAccountId")); input.put("userLogin", userLogin); // call the service to create the invoice Map<String, Object> serviceResults = dispatcher.runSync("createInvoice", input); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } String invoiceId = (String) serviceResults.get("invoiceId"); // keep track of the invoice total vs the promised return total (how much the customer promised to return) BigDecimal invoiceTotal = ZERO; BigDecimal promisedTotal = ZERO; // loop through shipment receipts to create invoice items and return item billings for each item and adjustment int invoiceItemSeqNum = 1; String invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS); for (GenericValue item : billItems) { boolean shipmentReceiptFound = false; boolean itemIssuanceFound = false; GenericValue returnItem = null; BigDecimal quantity = BigDecimal.ZERO; if ("ShipmentReceipt".equals(item.getEntityName())) { shipmentReceiptFound = true; } else if ("ItemIssuance".equals(item.getEntityName())) { itemIssuanceFound = true; } else if ("ReturnItem".equals(item.getEntityName())) { quantity = item.getBigDecimal("returnQuantity"); returnItem = item; } else { Debug.logError("Unexpected entity " + item + " of type " + item.getEntityName(), module); } // we need the related return item and product if (shipmentReceiptFound) { returnItem = item.getRelatedOne("ReturnItem", true); } else if (itemIssuanceFound) { GenericValue shipmentItem = item.getRelatedOne("ShipmentItem", true); GenericValue returnItemShipment = EntityUtil .getFirst(shipmentItem.getRelated("ReturnItemShipment", null, null, false)); returnItem = returnItemShipment.getRelatedOne("ReturnItem", true); } if (returnItem == null) continue; // Just to prevent NPE GenericValue product = returnItem.getRelatedOne("Product", true); // extract the return price as a big decimal for convenience BigDecimal returnPrice = returnItem.getBigDecimal("returnPrice"); // determine invoice item type from the return item type String invoiceItemTypeId = getInvoiceItemType(delegator, returnItem.getString("returnItemTypeId"), null, invoiceTypeId, null); if (invoiceItemTypeId == null) { return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource, "AccountingNoKnownInvoiceItemTypeReturnItemType", UtilMisc.toMap("returnItemTypeId", returnItem.getString("returnItemTypeId")), locale)); } if (shipmentReceiptFound) { quantity = item.getBigDecimal("quantityAccepted"); } else if (itemIssuanceFound) { quantity = item.getBigDecimal("quantity"); } // create the invoice item for this shipment receipt input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", quantity); input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack input.put("amount", returnItem.get("returnPrice")); input.put("productId", returnItem.get("productId")); input.put("taxableFlag", product.get("taxable")); input.put("description", returnItem.get("description")); // TODO: what about the productFeatureId? input.put("userLogin", userLogin); serviceResults = dispatcher.runSync("createInvoiceItem", input); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } // copy the return item information into ReturnItemBilling input = UtilMisc.toMap("returnId", returnId, "returnItemSeqId", returnItem.get("returnItemSeqId"), "invoiceId", invoiceId); input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack input.put("quantity", quantity); input.put("amount", returnItem.get("returnPrice")); input.put("userLogin", userLogin); if (shipmentReceiptFound) { input.put("shipmentReceiptId", item.get("receiptId")); } serviceResults = dispatcher.runSync("createReturnItemBilling", input); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } if (Debug.verboseOn()) { Debug.logVerbose("Creating Invoice Item with amount " + returnPrice + " and quantity " + quantity + " for shipment [" + item.getString("shipmentId") + ":" + item.getString("shipmentItemSeqId") + "]", module); } String parentInvoiceItemSeqId = invoiceItemSeqId; // increment the seqId counter after creating the invoice item and return item billing invoiceItemSeqNum += 1; invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS); // keep a running total (note: a returnItem may have many receipts. hence, the promised total quantity is the receipt quantityAccepted + quantityRejected) BigDecimal cancelQuantity = ZERO; if (shipmentReceiptFound) { cancelQuantity = item.getBigDecimal("quantityRejected"); } else if (itemIssuanceFound) { cancelQuantity = item.getBigDecimal("cancelQuantity"); } if (cancelQuantity == null) cancelQuantity = ZERO; BigDecimal actualAmount = returnPrice.multiply(quantity).setScale(DECIMALS, ROUNDING); BigDecimal promisedAmount = returnPrice.multiply(quantity.add(cancelQuantity)) .setScale(DECIMALS, ROUNDING); invoiceTotal = invoiceTotal.add(actualAmount).setScale(DECIMALS, ROUNDING); promisedTotal = promisedTotal.add(promisedAmount).setScale(DECIMALS, ROUNDING); // for each adjustment related to this ReturnItem, create a separate invoice item List<GenericValue> adjustments = returnItem.getRelated("ReturnAdjustment", null, null, true); for (GenericValue adjustment : adjustments) { if (adjustment.get("amount") == null) { Debug.logWarning("Return adjustment [" + adjustment.get("returnAdjustmentId") + "] has null amount and will be skipped", module); continue; } // determine invoice item type from the return item type invoiceItemTypeId = getInvoiceItemType(delegator, adjustment.getString("returnAdjustmentTypeId"), null, invoiceTypeId, null); if (invoiceItemTypeId == null) { return ServiceUtil .returnError( errorMsg + UtilProperties.getMessage(resource, "AccountingNoKnownInvoiceItemTypeReturnAdjustmentType", UtilMisc.toMap("returnAdjustmentTypeId", adjustment.getString("returnAdjustmentTypeId")), locale)); } // prorate the adjustment amount by the returned amount; do not round ratio BigDecimal ratio = quantity.divide(returnItem.getBigDecimal("returnQuantity"), 100, ROUNDING); BigDecimal amount = adjustment.getBigDecimal("amount"); amount = amount.multiply(ratio).setScale(DECIMALS, ROUNDING); if (Debug.verboseOn()) { Debug.logVerbose("Creating Invoice Item with amount " + adjustment.getBigDecimal("amount") + " prorated to " + amount + " for return adjustment [" + adjustment.getString("returnAdjustmentId") + "]", module); } // prepare invoice item data for this adjustment input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", BigDecimal.ONE); input.put("amount", amount); input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack input.put("productId", returnItem.get("productId")); input.put("description", adjustment.get("description")); input.put("overrideGlAccountId", adjustment.get("overrideGlAccountId")); input.put("parentInvoiceId", invoiceId); input.put("parentInvoiceItemSeqId", parentInvoiceItemSeqId); input.put("taxAuthPartyId", adjustment.get("taxAuthPartyId")); input.put("taxAuthGeoId", adjustment.get("taxAuthGeoId")); input.put("userLogin", userLogin); // only set taxable flag when the adjustment is not a tax // TODO: Note that we use the value of Product.taxable here. This is not an ideal solution. Instead, use returnAdjustment.includeInTax if (adjustment.get("returnAdjustmentTypeId").equals("RET_SALES_TAX_ADJ")) { input.put("taxableFlag", "N"); } // create the invoice item serviceResults = dispatcher.runSync("createInvoiceItem", input); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } // increment the seqId counter invoiceItemSeqNum += 1; invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS); // keep a running total (promised adjustment in this case is the same as the invoice adjustment) invoiceTotal = invoiceTotal.add(amount).setScale(DECIMALS, ROUNDING); promisedTotal = promisedTotal.add(amount).setScale(DECIMALS, ROUNDING); } } // ratio of the invoice total to the promised total so far or zero if the amounts were zero BigDecimal actualToPromisedRatio = ZERO; if (invoiceTotal.signum() != 0) { actualToPromisedRatio = invoiceTotal.divide(promisedTotal, 100, ROUNDING); // do not round ratio } // loop through return-wide adjustments and create invoice items for each List<GenericValue> adjustments = returnHeader.getRelated("ReturnAdjustment", UtilMisc.toMap("returnItemSeqId", "_NA_"), null, true); for (GenericValue adjustment : adjustments) { // determine invoice item type from the return item type String invoiceItemTypeId = getInvoiceItemType(delegator, adjustment.getString("returnAdjustmentTypeId"), null, invoiceTypeId, null); if (invoiceItemTypeId == null) { return ServiceUtil .returnError( errorMsg + UtilProperties .getMessage(resource, "AccountingNoKnownInvoiceItemTypeReturnAdjustmentType", UtilMisc.toMap("returnAdjustmentTypeId", adjustment.getString("returnAdjustmentTypeId")), locale)); } // prorate the adjustment amount by the actual to promised ratio BigDecimal amount = adjustment.getBigDecimal("amount").multiply(actualToPromisedRatio) .setScale(DECIMALS, ROUNDING); if (Debug.verboseOn()) { Debug.logVerbose("Creating Invoice Item with amount " + adjustment.getBigDecimal("amount") + " prorated to " + amount + " for return adjustment [" + adjustment.getString("returnAdjustmentId") + "]", module); } // prepare the invoice item for the return-wide adjustment input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", BigDecimal.ONE); input.put("amount", amount); input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack input.put("description", adjustment.get("description")); input.put("overrideGlAccountId", adjustment.get("overrideGlAccountId")); input.put("taxAuthPartyId", adjustment.get("taxAuthPartyId")); input.put("taxAuthGeoId", adjustment.get("taxAuthGeoId")); input.put("userLogin", userLogin); // XXX TODO Note: we need to implement ReturnAdjustment.includeInTax for this to work properly input.put("taxableFlag", adjustment.get("includeInTax")); // create the invoice item serviceResults = dispatcher.runSync("createInvoiceItem", input); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } // increment the seqId counter invoiceItemSeqNum += 1; invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS); } // Set the invoice to READY serviceResults = dispatcher.runSync("setInvoiceStatus", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "statusId", "INVOICE_READY", "userLogin", userLogin)); if (ServiceUtil.isError(serviceResults)) { return ServiceUtil.returnError(errorMsg, null, null, serviceResults); } // return the invoiceId results.put("invoiceId", invoiceId); } return results; } catch (GenericServiceException e) { Debug.logError(e, errorMsg + e.getMessage(), module); return ServiceUtil.returnError(errorMsg + e.getMessage()); } catch (GenericEntityException e) { Debug.logError(e, errorMsg + e.getMessage(), module); return ServiceUtil.returnError(errorMsg + e.getMessage()); } }
From source file:org.openbravo.test.costing.TestCosting.java
private BigDecimal getAveragePrice(List<BigDecimal> priceList, List<BigDecimal> quantityList) { try {//from w ww .ja v a 2s . c om BigDecimal priceTotal = amount0; for (int i = 0; i < quantityList.size(); i++) priceTotal = priceTotal.add(quantityList.get(i).multiply(priceList.get(i))); return priceTotal.divide(getTotalQuantity(quantityList), 5, BigDecimal.ROUND_HALF_UP); } catch (Exception e) { throw new OBException(e); } }
From source file:org.ofbiz.order.order.OrderServices.java
/** * Determines the total amount invoiced for a given order item over all invoices by totalling the item subtotal (via OrderItemBilling), * any adjustments for that item (via OrderAdjustmentBilling), and the item's share of any order-level adjustments (that calculated * by applying the percentage of the items total that the item represents to the order-level adjustments total (also via * OrderAdjustmentBilling). Also returns the quantity invoiced for the item over all invoices, to aid in prorating. * @param dctx DispatchContext//from w ww . ja v a2 s.c om * @param context Map * @return Map */ public static Map<String, Object> getOrderItemInvoicedAmountAndQuantity(DispatchContext dctx, Map<String, ? extends Object> context) { Delegator delegator = dctx.getDelegator(); Locale locale = (Locale) context.get("locale"); String orderId = (String) context.get("orderId"); String orderItemSeqId = (String) context.get("orderItemSeqId"); GenericValue orderHeader = null; GenericValue orderItemToCheck = null; BigDecimal orderItemTotalValue = ZERO; BigDecimal invoicedQuantity = ZERO; // Quantity invoiced for the target order item try { orderHeader = delegator.findByPrimaryKey("OrderHeader", UtilMisc.toMap("orderId", orderId)); if (UtilValidate.isEmpty(orderHeader)) { String errorMessage = UtilProperties.getMessage(resource_error, "OrderErrorOrderIdNotFound", context, locale); Debug.logError(errorMessage, module); return ServiceUtil.returnError(errorMessage); } orderItemToCheck = delegator.findByPrimaryKey("OrderItem", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", orderItemSeqId)); if (UtilValidate.isEmpty(orderItemToCheck)) { String errorMessage = UtilProperties.getMessage(resource_error, "OrderErrorOrderItemNotFound", context, locale); Debug.logError(errorMessage, module); return ServiceUtil.returnError(errorMessage); } BigDecimal orderItemsSubtotal = ZERO; // Aggregated value of order items, non-tax and non-shipping item-level adjustments BigDecimal invoicedTotal = ZERO; // Amount invoiced for the target order item BigDecimal itemAdjustments = ZERO; // Item-level tax- and shipping-adjustments // Aggregate the order items subtotal List<GenericValue> orderItems = orderHeader.getRelated("OrderItem", UtilMisc.toList("orderItemSeqId")); Iterator<GenericValue> oit = orderItems.iterator(); while (oit.hasNext()) { GenericValue orderItem = oit.next(); // Look at the orderItemBillings to discover the amount and quantity ever invoiced for this order item List<GenericValue> orderItemBillings = delegator.findByAnd("OrderItemBilling", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", orderItem.get("orderItemSeqId"))); Iterator<GenericValue> oibit = orderItemBillings.iterator(); while (oibit.hasNext()) { GenericValue orderItemBilling = oibit.next(); BigDecimal quantity = orderItemBilling.getBigDecimal("quantity"); BigDecimal amount = orderItemBilling.getBigDecimal("amount").setScale(orderDecimals, orderRounding); if (UtilValidate.isEmpty(invoicedQuantity) || UtilValidate.isEmpty(amount)) continue; // Add the item base amount to the subtotal orderItemsSubtotal = orderItemsSubtotal.add(quantity.multiply(amount)); // If the item is the target order item, add the invoiced quantity and amount to their respective totals if (orderItemSeqId.equals(orderItem.get("orderItemSeqId"))) { invoicedQuantity = invoicedQuantity.add(quantity); invoicedTotal = invoicedTotal.add(quantity.multiply(amount)); } } // Retrieve the adjustments for this item List<GenericValue> orderAdjustments = delegator.findByAnd("OrderAdjustment", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", orderItem.get("orderItemSeqId"))); Iterator<GenericValue> oait = orderAdjustments.iterator(); while (oait.hasNext()) { GenericValue orderAdjustment = oait.next(); String orderAdjustmentTypeId = orderAdjustment.getString("orderAdjustmentTypeId"); boolean includeInTax = orderAdjustment.getBoolean("includeInTax").booleanValue(); // Look at the orderAdjustmentBillings to discove the amount ever invoiced for this order adjustment List<GenericValue> orderAdjustmentBillings = delegator.findByAnd("OrderAdjustmentBilling", UtilMisc.toMap("orderAdjustmentId", orderAdjustment.get("orderAdjustmentId"))); Iterator<GenericValue> oabit = orderAdjustmentBillings.iterator(); while (oabit.hasNext()) { GenericValue orderAjustmentBilling = oabit.next(); BigDecimal amount = orderAjustmentBilling.getBigDecimal("amount").setScale(orderDecimals, orderRounding); if (UtilValidate.isEmpty(amount)) continue; if (includeInTax || "SALES_TAX".equals(orderAdjustmentTypeId) || "SHIPPING_CHARGES".equals(orderAdjustmentTypeId)) { if (orderItemSeqId.equals(orderItem.get("orderItemSeqId"))) { // Add tax- and shipping-adjustment amounts to the total adjustments for the target order item itemAdjustments = itemAdjustments.add(amount); } } else { // Add non-tax and non-shipping adjustment amounts to the order items subtotal orderItemsSubtotal = orderItemsSubtotal.add(amount); if (orderItemSeqId.equals(orderItem.get("orderItemSeqId"))) { // If the item is the target order item, add non-tax and non-shipping adjustment amounts to the invoiced total invoicedTotal = invoicedTotal.add(amount); } } } } } // Total the order-header-level adjustments for the order BigDecimal orderHeaderAdjustmentsTotalValue = ZERO; List<GenericValue> orderHeaderAdjustments = delegator.findByAnd("OrderAdjustment", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", "_NA_")); Iterator<GenericValue> ohait = orderHeaderAdjustments.iterator(); while (ohait.hasNext()) { GenericValue orderHeaderAdjustment = ohait.next(); List<GenericValue> orderHeaderAdjustmentBillings = delegator.findByAnd("OrderAdjustmentBilling", UtilMisc.toMap("orderAdjustmentId", orderHeaderAdjustment.get("orderAdjustmentId"))); Iterator<GenericValue> ohabit = orderHeaderAdjustmentBillings.iterator(); while (ohabit.hasNext()) { GenericValue orderHeaderAdjustmentBilling = ohabit.next(); BigDecimal amount = orderHeaderAdjustmentBilling.getBigDecimal("amount").setScale(orderDecimals, orderRounding); if (UtilValidate.isEmpty(amount)) continue; orderHeaderAdjustmentsTotalValue = orderHeaderAdjustmentsTotalValue.add(amount); } } // How much of the order-level adjustments total does the target order item represent? The assumption is: the same // proportion of the adjustments as of the invoiced total for the item to the invoiced total for all items. These // figures don't take tax- and shipping- adjustments into account, so as to be in accordance with the code in InvoiceServices BigDecimal invoicedAmountProportion = ZERO; if (orderItemsSubtotal.signum() != 0) { invoicedAmountProportion = invoicedTotal.divide(orderItemsSubtotal, 5, orderRounding); } BigDecimal orderItemHeaderAjustmentAmount = orderHeaderAdjustmentsTotalValue .multiply(invoicedAmountProportion); orderItemTotalValue = invoicedTotal.add(orderItemHeaderAjustmentAmount); // Add back the tax- and shipping- item-level adjustments for the order item orderItemTotalValue = orderItemTotalValue.add(itemAdjustments); } catch (GenericEntityException e) { Debug.logError(e, module); return ServiceUtil.returnError(e.getMessage()); } Map<String, Object> result = ServiceUtil.returnSuccess(); result.put("invoicedAmount", orderItemTotalValue.setScale(orderDecimals, orderRounding)); result.put("invoicedQuantity", invoicedQuantity.setScale(orderDecimals, orderRounding)); return result; }