Example usage for java.math BigDecimal subtract

List of usage examples for java.math BigDecimal subtract

Introduction

In this page you can find the example usage for java.math BigDecimal subtract.

Prototype

public BigDecimal subtract(BigDecimal subtrahend) 

Source Link

Document

Returns a BigDecimal whose value is (this - subtrahend) , and whose scale is max(this.scale(), subtrahend.scale()) .

Usage

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public BigDecimal getAusgegebeneMengePreis(Integer lossollmaterialIId, java.sql.Timestamp tStichtag,
        TheClientDto theClientDto) throws EJBExceptionLP {
    try {//ww  w . j  a v a2 s .  c o m
        BigDecimal bdMenge = new BigDecimal(0);
        BigDecimal bdWert = new BigDecimal(0);
        LosistmaterialDto[] losist = losistmaterialFindByLossollmaterialIId(lossollmaterialIId);
        for (int i = 0; i < losist.length; i++) {

            BigDecimal bdAusgegeben = getLagerFac().getMengeEinerBelegposition(LocaleFac.BELEGART_LOS,
                    losist[i].getIId(), tStichtag);

            if (Helper.short2boolean(losist[i].getBAbgang())) {

                BigDecimal bdPreis = getLagerFac().getGemittelterGestehungspreisEinerAbgangsposition(
                        LocaleFac.BELEGART_LOS, losist[i].getIId());
                bdMenge = bdMenge.add(bdAusgegeben);
                bdWert = bdWert.add(bdPreis.multiply(bdAusgegeben));
            } else {
                BigDecimal bdPreis = getLagerFac().getGemittelterEinstandspreisEinerZugangsposition(
                        LocaleFac.BELEGART_LOS, losist[i].getIId());
                bdMenge = bdMenge.subtract(bdAusgegeben);
                bdWert = bdWert.subtract(bdPreis.multiply(bdAusgegeben));
            }
        }
        if (bdMenge.doubleValue() == 0) {
            return bdMenge;
        } else {
            return bdWert.divide(bdMenge, BigDecimal.ROUND_HALF_EVEN);
        }
    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
        return null;
    }
}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

public BigDecimal[] getGutSchlechtInarbeit(Integer lossollarbeitsplanIId, Integer personalIId,
        java.sql.Timestamp tVon, java.sql.Timestamp tBis, TheClientDto theClientDto) {
    LosgutschlechtDto[] dtos = losgutschlechtFindByLossollarbeitsplanIId(lossollarbeitsplanIId);
    LossollarbeitsplanDto lossollarbeitsplanDto = lossollarbeitsplanFindByPrimaryKey(lossollarbeitsplanIId);
    LosDto losDto = losFindByPrimaryKey(lossollarbeitsplanDto.getLosIId());

    BigDecimal bdGut = new BigDecimal(0);
    BigDecimal bdSchlecht = new BigDecimal(0);
    BigDecimal bdInarbeit = new BigDecimal(0);
    BigDecimal bdOffen = losDto.getNLosgroesse();

    for (int i = 0; i < dtos.length; i++) {

        if (personalIId != null && dtos[i].getZeitdatenIId() != null) {
            Zeitdaten z = em.find(Zeitdaten.class, dtos[i].getZeitdatenIId());

            if (z.getPersonalIId().equals(personalIId)) {

                if ((tVon == null || tVon != null && tVon.before(z.getTZeit()))
                        && (tBis == null || tBis != null && tBis.after(z.getTZeit()))) {
                    bdGut = bdGut.add(dtos[i].getNGut());
                    bdSchlecht = bdSchlecht.add(dtos[i].getNSchlecht());
                    bdInarbeit = bdInarbeit.add(dtos[i].getNInarbeit());
                }/*from w  w w . ja va  2 s.co m*/

            }

        } else {

            bdGut = bdGut.add(dtos[i].getNGut());
            bdSchlecht = bdSchlecht.add(dtos[i].getNSchlecht());
            bdInarbeit = bdInarbeit.add(dtos[i].getNInarbeit());
        }

    }

    bdOffen = bdOffen.subtract(bdGut).subtract(bdSchlecht);

    boolean bTheoretischeIstZeit = false;

    try {
        ParametermandantDto parameterIstZeit = (ParametermandantDto) getParameterFac().getMandantparameter(
                theClientDto.getMandant(), ParameterFac.KATEGORIE_PERSONAL,
                ParameterFac.PARAMETER_THEORETISCHE_IST_ZEIT_RECHNUNG);

        bTheoretischeIstZeit = ((Boolean) parameterIstZeit.getCWertAsObject());

    } catch (RemoteException ex5) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER, ex5);
    }
    // lt. WH:Wenn TheoretischeIstZeit und "nicht ruesten", dann die
    // Gut/Schlecht Stueck der Ruestzeit des AGs abziehen

    if (bTheoretischeIstZeit == true) {

        // Wenn nicht ruesten
        if (lossollarbeitsplanDto.getAgartCNr() != null) {

            Query query = em.createNamedQuery("LossollarbeitsplanfindByLosIIdIArbeitsgangnummer");
            query.setParameter(1, lossollarbeitsplanDto.getLosIId());
            query.setParameter(2, lossollarbeitsplanDto.getIArbeitsgangnummer());
            Collection<?> cl = query.getResultList();

            if (cl != null) {
                Iterator<?> iterator = cl.iterator();
                while (iterator.hasNext()) {
                    Lossollarbeitsplan lossollarbeitsplanTemp = (Lossollarbeitsplan) iterator.next();
                    if (lossollarbeitsplanTemp.getAgartCNr() == null) {
                        LosgutschlechtDto[] dtosRuestZeit = losgutschlechtFindByLossollarbeitsplanIId(
                                lossollarbeitsplanTemp.getIId());

                        for (int i = 0; i < dtosRuestZeit.length; i++) {
                            bdOffen = bdOffen.subtract(dtosRuestZeit[i].getNGut())
                                    .subtract(dtosRuestZeit[i].getNSchlecht());
                        }

                    }
                }

            }
        }
    }

    return new BigDecimal[] { bdGut, bdSchlecht, bdInarbeit, bdOffen };
}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

private void materialwertAllerLosablieferungenNeuBerechnen(LosDto losDto, TheClientDto theClientDto) {

    Query query = em.createNamedQuery("LosablieferungfindByLosIId");
    query.setParameter(1, losDto.getIId());
    Collection<?> losablieferungs = query.getResultList();
    LossollmaterialDto[] losmat = lossollmaterialFindByLosIId(losDto.getIId());

    BigDecimal bdAbgeliefertGesamt = getErledigteMenge(losDto.getIId(), theClientDto);

    BigDecimal bdVorherigerWertDerAblieferung = new BigDecimal(0);

    boolean bErledigt = false;

    if (losDto.getStatusCNr().equals(LocaleFac.STATUS_ERLEDIGT)
            || bdAbgeliefertGesamt.doubleValue() >= losDto.getNLosgroesse().doubleValue()) {
        bErledigt = true;/*www.  j  a  va  2s. co m*/
    }

    HashMap<Integer, LagerbewegungDto[]> hmLagerbewegungen = new HashMap<Integer, LagerbewegungDto[]>();

    for (int i = 0; i < losmat.length; i++) {

        BigDecimal bdPreis = getAusgegebeneMengePreis(losmat[i].getIId(), null, theClientDto);

        LosistmaterialDto[] istmatDtos = losistmaterialFindByLossollmaterialIId(losmat[i].getIId());

        ArrayList al = new ArrayList();

        for (int j = 0; j < istmatDtos.length; j++) {

            List<SeriennrChargennrMitMengeDto> snrDtos = getLagerFac()
                    .getAllSeriennrchargennrEinerBelegartposition(LocaleFac.BELEGART_LOS,
                            istmatDtos[j].getIId());

            for (int k = 0; k < snrDtos.size(); k++) {

                LagerbewegungDto bewDto = getLagerFac().getLetzteintrag(LocaleFac.BELEGART_LOS,
                        istmatDtos[j].getIId(), snrDtos.get(k).getCSeriennrChargennr());

                bewDto.setNGestehungspreis(bdPreis);

                al.add(bewDto);

            }

        }

        LagerbewegungDto[] returnArray = new LagerbewegungDto[al.size()];
        hmLagerbewegungen.put(losmat[i].getIId(), (LagerbewegungDto[]) al.toArray(returnArray));

    }

    BigDecimal abgeliefert = new BigDecimal(0);

    int iAblieferung = 0;

    for (Iterator<?> iter = losablieferungs.iterator(); iter.hasNext();) {
        Losablieferung losablieferung = (Losablieferung) iter.next();
        iAblieferung++;
        abgeliefert = abgeliefert.add(losablieferung.getNMenge());

        BigDecimal bdWertIstProAblieferung = new BigDecimal(0.0000);

        for (int i = 0; i < losmat.length; i++) {

            // Sollsatzgroesse der Position

            BigDecimal ssg = losmat[i].getNMenge()
                    .divide(losDto.getNLosgroesse(), 4, BigDecimal.ROUND_HALF_EVEN).multiply(abgeliefert);

            BigDecimal bdMengeIst = new BigDecimal(0.0000);

            BigDecimal bdWertIstProPosition = new BigDecimal(0.0000);

            if (hmLagerbewegungen.containsKey(losmat[i].getIId())) {
                LagerbewegungDto[] bewDtos = (LagerbewegungDto[]) hmLagerbewegungen.get(losmat[i].getIId());

                if (bewDtos != null) {

                    for (int l = 0; l < bewDtos.length; l++) {

                        if (bErledigt && iter.hasNext() == false) {

                            if (Helper.short2boolean(bewDtos[l].getBAbgang())) {

                                bdMengeIst = bdMengeIst.add(bewDtos[l].getNMenge());
                                bdWertIstProPosition = bdWertIstProPosition
                                        .add(bewDtos[l].getNGestehungspreis().multiply(bewDtos[l].getNMenge()));

                            } else {
                                bdMengeIst = bdMengeIst.subtract(bewDtos[l].getNMenge());
                                bdWertIstProPosition = bdWertIstProPosition.subtract(
                                        bewDtos[l].getNEinstandspreis().multiply(bewDtos[l].getNMenge()));
                            }
                        } else {
                            if (losablieferung.getTAendern().getTime() >= bewDtos[l].getTBuchungszeit()
                                    .getTime()) {

                                if (bdMengeIst.abs().add(bewDtos[l].getNMenge()).doubleValue() > ssg.abs()
                                        .doubleValue()) {

                                    BigDecimal mengeSSg = null;

                                    if (bdMengeIst.abs().doubleValue() < ssg.abs().doubleValue()) {
                                        mengeSSg = ssg.subtract(bdMengeIst);
                                    } else {
                                        mengeSSg = new BigDecimal(0);
                                    }

                                    bdMengeIst = bdMengeIst.add(bewDtos[l].getNMenge());

                                    if (Helper.short2boolean(bewDtos[l].getBAbgang())) {

                                        bdWertIstProPosition = bdWertIstProPosition
                                                .add(bewDtos[l].getNGestehungspreis().multiply(mengeSSg));
                                    } else {
                                        bdWertIstProPosition = bdWertIstProPosition
                                                .add(bewDtos[l].getNEinstandspreis().multiply(mengeSSg));
                                    }

                                } else {

                                    bdMengeIst = bdMengeIst.add(bewDtos[l].getNMenge());

                                    if (Helper.short2boolean(bewDtos[l].getBAbgang())) {

                                        bdWertIstProPosition = bdWertIstProPosition.add(bewDtos[l]
                                                .getNGestehungspreis().multiply(bewDtos[l].getNMenge()));
                                    } else {
                                        bdWertIstProPosition = bdWertIstProPosition.subtract(bewDtos[l]
                                                .getNEinstandspreis().multiply(bewDtos[l].getNMenge()));
                                    }
                                }

                            }
                        }

                        System.out.println(bewDtos[l].getIIdBuchung() + ":" + bdWertIstProPosition);
                    }

                    System.out.println(losmat[i].getArtikelIId() + ":" + bdWertIstProPosition);

                    bdWertIstProAblieferung = bdWertIstProAblieferung.add(bdWertIstProPosition);
                }

            }
        }

        losablieferung.setNMaterialwert(bdWertIstProAblieferung.subtract(bdVorherigerWertDerAblieferung)
                .divide(losablieferung.getNMenge(), 4, BigDecimal.ROUND_HALF_EVEN));

        em.merge(losablieferung);
        em.flush();

        bdVorherigerWertDerAblieferung = bdWertIstProAblieferung;

    }

}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

public LosablieferungDto updateLosablieferung(LosablieferungDto losablieferungDto,
        boolean bMaterialZurueckbuchen, TheClientDto theClientDto) throws EJBExceptionLP {

    // losstatus pruefen

    LosDto losDto = losFindByPrimaryKey(losablieferungDto.getLosIId());
    if (losDto.getStatusCNr().equals(FertigungFac.STATUS_STORNIERT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_STORNIERT, "");
    } else if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ERLEDIGT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_BEREITS_ERLEDIGT, "");
    } else if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ANGELEGT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_NOCH_NICHT_AUSGEGEBEN, "");
    } else if (losDto.getStatusCNr().equals(FertigungFac.STATUS_GESTOPPT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_GESTOPPT, "");
    }//w  w w.  j a  v a  2s. c  o m

    Losablieferung laVorher = em.find(Losablieferung.class, losablieferungDto.getIId());

    // Los updaten, wenn Mengenreduktion
    if (losablieferungDto.getNMenge().doubleValue() > 0
            && losablieferungDto.getNMenge().doubleValue() < laVorher.getNMenge().doubleValue()) {

        Losablieferung losablieferung = em.find(Losablieferung.class, losablieferungDto.getIId());
        setLosablieferungFromLosablieferungDto(losablieferung, losablieferungDto);

        try {
            bucheLosAblieferungAufLager(losablieferungDto, losDto, theClientDto);
        } catch (RemoteException e) {
            throwEJBExceptionLPRespectOld(e);
        }

        // Material zurueckbuchen
        if (bMaterialZurueckbuchen) {
            LosablieferungDto[] dtos = losablieferungFindByLosIId(losDto.getIId(), false, theClientDto);
            BigDecimal bdGesamtAbgeliefert = new BigDecimal(0.00);
            for (int i = 0; i < dtos.length; i++) {
                LosablieferungDto losablieferungenDto = dtos[i];
                bdGesamtAbgeliefert = bdGesamtAbgeliefert.add(losablieferungenDto.getNMenge());
            }

            LossollmaterialDto[] sollmatDtos = lossollmaterialFindByLosIId(losDto.getIId());
            for (int i = 0; i < sollmatDtos.length; i++) {
                LossollmaterialDto sollmatDto = sollmatDtos[i];

                if (sollmatDto.getNMenge().doubleValue() != 0) {
                    BigDecimal sollsatzgroesse = sollmatDto.getNMenge()
                            .divide(sollmatDto.getNMenge(), 6, BigDecimal.ROUND_HALF_EVEN)
                            .multiply(bdGesamtAbgeliefert);

                    // Wenn nachtraegliche position, dann auslassen
                    if (Helper.short2boolean(sollmatDto.getBNachtraeglich()) == false) {
                        LosistmaterialDto[] losistmaterialDtos = losistmaterialFindByLossollmaterialIId(
                                sollmatDto.getIId());

                        BigDecimal istMaterialPlusNachtraeglich = new BigDecimal(0);

                        for (int j = 0; j < losistmaterialDtos.length; j++) {
                            LosistmaterialDto istmaterialDto = losistmaterialDtos[j];
                            // wenn Lagerzugang, der wird ausgelassen
                            if (Helper.short2boolean(istmaterialDto.getBAbgang())) {
                                istMaterialPlusNachtraeglich = istMaterialPlusNachtraeglich
                                        .add(istmaterialDto.getNMenge());
                            }

                        }

                        // Wenn ausgegebenes Material grosser als
                        // Sollsatzgroesse
                        if (istMaterialPlusNachtraeglich.doubleValue() > sollsatzgroesse.doubleValue()) {
                            BigDecimal zuReduzieren = Helper.rundeKaufmaennisch(
                                    istMaterialPlusNachtraeglich.subtract(sollsatzgroesse), 4);

                            for (int j = losistmaterialDtos.length; j > 0; j--) {
                                if (zuReduzieren.doubleValue() > 0) {
                                    LosistmaterialDto istmaterialDto = losistmaterialDtos[j - 1];

                                    // wenn Lagerzugang, der wird
                                    // ausgelassen
                                    if (Helper.short2boolean(istmaterialDto.getBAbgang())) {

                                        LagerbewegungDto lagerbewegungDto = getLagerFac().getLetzteintrag(
                                                LocaleFac.BELEGART_LOS, istmaterialDto.getIId(), null);

                                        BigDecimal nMengeAbsolut = new BigDecimal(0);

                                        if (zuReduzieren.doubleValue() >= istmaterialDto.getNMenge()
                                                .doubleValue()) {
                                            nMengeAbsolut = istmaterialDto.getNMenge().subtract(zuReduzieren);

                                            nMengeAbsolut = new BigDecimal(0);
                                        } else {
                                            nMengeAbsolut = istmaterialDto.getNMenge().subtract(zuReduzieren);
                                            zuReduzieren = new BigDecimal(0);

                                        }

                                        // Korrekturbuchung
                                        // Belegdatum wird nicht auf
                                        // heute
                                        // gesetzt lt. WH 20090115
                                        getLagerFac().bucheAb(LocaleFac.BELEGART_LOS, losDto.getIId(),
                                                istmaterialDto.getIId(), sollmatDto.getArtikelIId(),
                                                nMengeAbsolut, lagerbewegungDto.getNVerkaufspreis(),
                                                istmaterialDto.getLagerIId(), (String) null,
                                                losablieferungDto.getTAendern(), theClientDto);

                                        // Losistmaterial updaten
                                        updateLosistmaterialMenge(istmaterialDto.getIId(), nMengeAbsolut,
                                                theClientDto);

                                        zuReduzieren = zuReduzieren.subtract(istmaterialDto.getNMenge());

                                    }
                                }
                            }

                        }
                    }
                }
            }

        }

        LosablieferungDto[] dtos = losablieferungFindByLosIId(losDto.getIId(), false, theClientDto);
        // Wenn es die letzte Ablieferung ist, nur die letzte neu berechnen,
        // ansonsten alle
        if (dtos[dtos.length - 1].getIId().equals(losablieferungDto.getIId())) {
            aktualisiereNachtraeglichPreiseAllerLosablieferungen(losDto.getIId(), theClientDto, true);
        } else {
            aktualisiereNachtraeglichPreiseAllerLosablieferungen(losDto.getIId(), theClientDto, false);
        }

    } else {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_UPDATE_LOSABLIEFERUNG_FEHLER_MENGE,
                new Exception("Menge neu muss > 0 und kleiner der alten Menge sein."));
    }

    return losablieferungDto;

}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

public void vonSollpositionMengeZuruecknehmen(Integer lossollmaterialIId, BigDecimal nMenge, Integer losIIdZiel,
        Integer lagerIIdZiel, TheClientDto theClientDto) {

    BigDecimal bdAusgegeben = getAusgegebeneMenge(lossollmaterialIId, null, theClientDto);

    BigDecimal bdMengeGesamt = new BigDecimal(nMenge.doubleValue());

    if (nMenge.doubleValue() > bdAusgegeben.doubleValue()) {
        nMenge = bdAusgegeben;//  ww w  .  j  a  v a 2 s .c  om
    }

    LossollmaterialDto solldto = lossollmaterialFindByPrimaryKey(lossollmaterialIId);

    if (nMenge.doubleValue() > 0) {

        LosistmaterialDto[] dtosLosist = losistmaterialFindByLossollmaterialIId(lossollmaterialIId);

        for (int j = 0; j < dtosLosist.length; j++) {
            if (dtosLosist[j].getNMenge().doubleValue() > 0 && nMenge.doubleValue() > 0) {
                BigDecimal istmenge = dtosLosist[j].getNMenge();

                BigDecimal diffPosition = dtosLosist[j].getNMenge();

                BigDecimal bdMengeNeu = null;

                if (nMenge.doubleValue() > istmenge.doubleValue()) {
                    bdMengeNeu = new BigDecimal(0);
                    nMenge = nMenge.subtract(istmenge);
                } else {
                    bdMengeNeu = istmenge.subtract(nMenge);
                    nMenge = new BigDecimal(0);
                }

                diffPosition = diffPosition.subtract(bdMengeNeu);

                updateLosistmaterialMenge(dtosLosist[j].getIId(), bdMengeNeu, theClientDto);

                if (lagerIIdZiel != null && diffPosition.doubleValue() > 0) {
                    try {
                        if (!lagerIIdZiel.equals(dtosLosist[j].getLagerIId())) {
                            getLagerFac()
                                    .bucheUm(solldto.getArtikelIId(), dtosLosist[j].getLagerIId(),
                                            solldto.getArtikelIId(), lagerIIdZiel, diffPosition, null,
                                            "Umbuchung Materialumlagerung",
                                            getLagerFac().getGemittelterGestehungspreisEinerAbgangsposition(
                                                    LocaleFac.BELEGART_LOS, dtosLosist[j].getIId()),
                                            theClientDto);
                        }
                    } catch (RemoteException e) {
                        throwEJBExceptionLPRespectOld(e);
                    }
                }

                if (losIIdZiel != null) {

                    LossollmaterialDto[] sollDtos = lossollmaterialFindyByLosIIdArtikelIId(losIIdZiel,
                            solldto.getArtikelIId(), theClientDto);

                    if (sollDtos != null && sollDtos.length > 0) {
                        LossollmaterialDto solldtoZiel = lossollmaterialFindByPrimaryKey(sollDtos[0].getIId());
                        LosistmaterialDto losistmaterialDto = new LosistmaterialDto();
                        losistmaterialDto.setLagerIId(dtosLosist[j].getLagerIId());
                        losistmaterialDto.setBAbgang(Helper.boolean2Short(true));
                        losistmaterialDto.setNMenge(diffPosition);

                        gebeMaterialNachtraeglichAus(solldtoZiel, losistmaterialDto, null, true, theClientDto);
                    } else {
                        LossollmaterialDto lossollmaterialDto = new LossollmaterialDto();
                        lossollmaterialDto.setLosIId(losIIdZiel);
                        try {
                            lossollmaterialDto.setNSollpreis(getLagerFac()
                                    .getGemittelterGestehungspreisEinesLagers(solldto.getArtikelIId(),
                                            dtosLosist[j].getLagerIId(), theClientDto));
                        } catch (RemoteException e) {
                            throwEJBExceptionLPRespectOld(e);
                        }
                        lossollmaterialDto.setNMenge(bdMengeGesamt);
                        lossollmaterialDto.setMontageartIId(solldto.getMontageartIId());

                        ArtikelDto aDto = getArtikelFac().artikelFindByPrimaryKey(solldto.getArtikelIId(),
                                theClientDto);

                        lossollmaterialDto.setEinheitCNr(aDto.getEinheitCNr());
                        lossollmaterialDto.setArtikelIId(solldto.getArtikelIId());

                        LosistmaterialDto losistmaterialDto = new LosistmaterialDto();
                        losistmaterialDto.setLagerIId(dtosLosist[j].getLagerIId());
                        losistmaterialDto.setBAbgang(Helper.boolean2Short(true));

                        losistmaterialDto.setNMenge(diffPosition);

                        gebeMaterialNachtraeglichAus(lossollmaterialDto, losistmaterialDto, null, true,
                                theClientDto);
                    }

                }

            }
        }
    }

}

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. j ava  2  s.  c  om
        // 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

@TransactionTimeout(6000)
public void perAuftragsnummerLoseAbliefern(Integer auftragIId, TheClientDto theClientDto) {
    // Alle//from  w ww.jav  a2s .  co  m
    try {

        AuftragpositionDto[] dtos = getAuftragpositionFac().auftragpositionFindByAuftragOffeneMenge(auftragIId);
        ArrayList<Object> alGehtNicht = new ArrayList<Object>();
        for (int i = 0; i < dtos.length; i++) {
            AuftragpositionDto auftragpositionDto = dtos[i];

            if (auftragpositionDto.getArtikelIId() != null) {
                StuecklisteDto stuecklisteDto = getStuecklisteFac()
                        .stuecklisteFindByMandantCNrArtikelIIdOhneExc(auftragpositionDto.getArtikelIId(),
                                theClientDto);
                if (stuecklisteDto != null
                        && Helper.short2boolean(stuecklisteDto.getBMaterialbuchungbeiablieferung()) == true) {
                    ArtikelDto artikelDto = getArtikelFac()
                            .artikelFindByPrimaryKey(stuecklisteDto.getArtikelIId(), theClientDto);

                    BigDecimal nMengeOffen = auftragpositionDto.getNOffeneMenge();

                    Session session = FLRSessionFactory.getFactory().openSession();

                    Criteria crit = session.createCriteria(FLRLosReport.class);

                    String[] stati = new String[2];
                    stati[0] = FertigungFac.STATUS_IN_PRODUKTION;
                    stati[1] = FertigungFac.STATUS_TEILERLEDIGT;
                    crit.add(Restrictions.in(FertigungFac.FLR_LOS_STATUS_C_NR, stati));
                    crit.add(Restrictions.eq("mandant_c_nr", theClientDto.getMandant()));
                    crit.add(Restrictions.eq(FertigungFac.FLR_LOS_STUECKLISTE_I_ID, stuecklisteDto.getIId()));

                    crit.addOrder(Order.asc("c_nr"));

                    List<?> resultList = crit.list();
                    Iterator<?> resultListIterator = resultList.iterator();

                    while (resultListIterator.hasNext() && nMengeOffen.doubleValue() > 0) {
                        FLRLosReport flrLos = (FLRLosReport) resultListIterator.next();

                        BigDecimal bdOffenLos = flrLos.getN_losgroesse()
                                .subtract(getFertigungFac().getErledigteMenge(flrLos.getI_id(), theClientDto));
                        if (bdOffenLos.doubleValue() > 0) {

                            boolean bErledigt = false;

                            LosablieferungDto losablieferungDto = new LosablieferungDto();
                            losablieferungDto.setLosIId(flrLos.getI_id());

                            if (bdOffenLos.doubleValue() >= nMengeOffen.doubleValue()) {
                                losablieferungDto.setNMenge(nMengeOffen);
                                if (bdOffenLos.doubleValue() == nMengeOffen.doubleValue()) {
                                    bErledigt = true;
                                }
                                nMengeOffen = new BigDecimal(0);

                            } else {
                                losablieferungDto.setNMenge(bdOffenLos);
                                nMengeOffen = nMengeOffen.subtract(bdOffenLos);
                                bErledigt = true;
                            }
                            // Materialbuchen
                            bucheMaterialAufLos(losFindByPrimaryKey(flrLos.getI_id()),
                                    losablieferungDto.getNMenge(), false, false, true, theClientDto, null,
                                    false);

                            // Sind sollsatzgroeszen unterschritten?
                            // Sollsatzgroessen pruefen
                            pruefePositionenMitSollsatzgroesseUnterschreitung(flrLos.getI_id(),
                                    losablieferungDto.getNMenge(), theClientDto);

                            createLosablieferung(losablieferungDto, theClientDto, bErledigt);

                        }
                    }

                    if (nMengeOffen.doubleValue() > 0) {
                        alGehtNicht.add(artikelDto.formatArtikelbezeichnung() + " "
                                + Helper.formatZahl(nMengeOffen, 4, theClientDto.getLocUi()) + " "
                                + artikelDto.getEinheitCNr());
                    }

                }
            }

        }

        if (alGehtNicht.size() > 0) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER_ABLIEFERN_PER_AUFTRAGSNUMMER_NICHT_MOEGLICH,
                    alGehtNicht, new Exception("Zuwenig offene Lose"));

        }

    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
    }

}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

public void bucheFehlmengenNach(LosDto losDto, LossollmaterialDto[] sollmat, TheClientDto theClientDto) {
    try {//  ww  w .  j  a  v  a  2 s.c  o m

        // Laeger des Loses
        LoslagerentnahmeDto[] laeger = loslagerentnahmeFindByLosIId(losDto.getIId());
        // nun vom lager abbuchen
        for (int i = 0; i < sollmat.length; i++) {
            ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKey(sollmat[i].getArtikelIId(),
                    theClientDto);
            // seriennummerntragende werden jetzt gar nicht gebucht

            ArtikelfehlmengeDto artikelfehlemngeDto = getFehlmengeFac()
                    .artikelfehlmengeFindByBelegartCNrBelegartPositionIIdOhneExc(LocaleFac.BELEGART_LOS,
                            sollmat[i].getIId());

            if (artikelfehlemngeDto != null) {

                BigDecimal bdAbzubuchendeMenge = artikelfehlemngeDto.getNMenge();
                if (!Helper.short2boolean(artikelDto.getBSeriennrtragend())) {
                    if (!Helper.short2boolean(artikelDto.getBChargennrtragend())) {
                        for (int j = 0; j < laeger.length; j++) {
                            // wenn noch was abzubuchen ist (Menge > 0)
                            if (bdAbzubuchendeMenge.compareTo(new BigDecimal(0)) == 1) {
                                BigDecimal bdLagerstand = null;
                                if (Helper.short2boolean(artikelDto.getBLagerbewirtschaftet())) {
                                    bdLagerstand = getLagerFac().getLagerstand(artikelDto.getIId(),
                                            laeger[j].getLagerIId(), theClientDto);

                                } else {
                                    bdLagerstand = new BigDecimal(999999999);
                                }
                                // wenn ein lagerstand da ist
                                if (bdLagerstand.compareTo(new BigDecimal(0)) == 1) {
                                    BigDecimal bdMengeVonLager;
                                    if (bdLagerstand.compareTo(bdAbzubuchendeMenge) == 1) {
                                        // wenn mehr als ausreichend auf
                                        // lager
                                        bdMengeVonLager = bdAbzubuchendeMenge;
                                    } else {
                                        // dann nur den lagerstand entnehmen
                                        bdMengeVonLager = bdLagerstand;
                                    }
                                    LosistmaterialDto istmat = new LosistmaterialDto();
                                    istmat.setLagerIId(laeger[j].getLagerIId());
                                    istmat.setLossollmaterialIId(sollmat[i].getIId());
                                    istmat.setNMenge(bdMengeVonLager);
                                    istmat.setBAbgang(Helper.boolean2Short(true));
                                    // ist-wert anlegen und lagerbuchung
                                    // durchfuehren
                                    createLosistmaterial(istmat, null, theClientDto);
                                    // menge reduzieren
                                    bdAbzubuchendeMenge = bdAbzubuchendeMenge.subtract(bdMengeVonLager);
                                }
                            }
                        }
                    }
                } else {
                    /**
                     * @todo falls nur eine charge auf lager ist -> trotzdem
                     *       buchen PJ 4220
                     */
                }

            }

        }

    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
    }

}

From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

@TransactionTimeout(5000)
public TreeMap<String, Object[]> aktualisiereLoseAusStueckliste(Integer stuecklisteIId,
        TheClientDto theClientDto) {//from   ww w.  ja  v a2s  . com

    TreeMap<String, Object[]> tmAktualisierteLose = new TreeMap<String, Object[]>();

    ParametermandantDto parameter = null;
    try {
        parameter = getParameterFac().getMandantparameter(theClientDto.getSMandantenwaehrung(),
                ParameterFac.KATEGORIE_STUECKLISTE,
                ParameterFac.PARAMETER_BEI_LOS_AKTUALISIERUNG_MATERIAL_NACHBUCHEN);
    } catch (RemoteException e1) {
        throwEJBExceptionLPRespectOld(e1);
    }
    boolean bMaterialNachbuchen = (Boolean) parameter.getCWertAsObject();

    Session session = FLRSessionFactory.getFactory().openSession();

    String queryString = "SELECT l FROM FLRLosReport l WHERE l.status_c_nr IN ('" + LocaleFac.STATUS_ANGELEGT
            + "','" + LocaleFac.STATUS_AUSGEGEBEN + "','" + LocaleFac.STATUS_IN_PRODUKTION
            + "') AND l.mandant_c_nr='" + theClientDto.getMandant() + "' AND l.stueckliste_i_id IS NOT NULL ";

    if (stuecklisteIId != null) {
        queryString += " AND l.stueckliste_i_id=" + stuecklisteIId;
    }

    org.hibernate.Query query = session.createQuery(queryString);
    List<?> results = query.list();
    Iterator<?> resultListIterator = results.iterator();
    while (resultListIterator.hasNext()) {
        FLRLosReport los = (FLRLosReport) resultListIterator.next();

        if (los.getStatus_c_nr().equals(LocaleFac.STATUS_ANGELEGT)) {
            aktualisiereSollArbeitsplanAusStueckliste(los.getI_id(), theClientDto);
            aktualisiereSollMaterialAusStueckliste(los.getI_id(), theClientDto);
        } else {

            LoslagerentnahmeDto[] laeger = loslagerentnahmeFindByLosIId(los.getI_id());

            aktualisiereSollArbeitsplanAusStueckliste(los.getI_id(), theClientDto);

            // Alle stuecklistenpositionen holen + Hilfsstueckliste und dann
            // verdichten
            HashMap<Integer, StuecklistepositionDto> hmStuecklistenposition = getFertigungFac()
                    .holeAlleLossollmaterialFuerStuecklistenAktualisierung(los.getStueckliste_i_id(),
                            los.getN_losgroesse(), 0, null, theClientDto);

            LossollmaterialDto[] sollmatDtos = lossollmaterialFindByLosIId(los.getI_id());

            for (int i = 0; i < sollmatDtos.length; i++) {
                try {
                    if (!Helper.short2boolean(sollmatDtos[i].getBNachtraeglich())) {
                        // War vor SP2000 --> &&
                        // sollmatDtos[i].getNMenge().doubleValue() > 0

                        LosistmaterialDto[] istmaterialDtos = losistmaterialFindByLossollmaterialIId(
                                sollmatDtos[i].getIId());
                        BigDecimal bdAusgegeben = getAusgegebeneMenge(sollmatDtos[i].getIId(), null,
                                theClientDto);
                        ArtikelDto artikelDto = getArtikelFac()
                                .artikelFindByPrimaryKeySmall(sollmatDtos[i].getArtikelIId(), theClientDto);

                        Object[] oZeileReport = new Object[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ANZAHL_SPALTEN];
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_LOSNUMMER] = los
                                .getC_nr();
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ARTIKELNUMMER] = artikelDto
                                .getCNr();
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_EINHEIT] = artikelDto
                                .getEinheitCNr();
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_SOLLMENGE] = sollmatDtos[i]
                                .getNMenge();
                        if (artikelDto.getArtikelsprDto() != null) {
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_BEZEICHNUNG] = artikelDto
                                    .getArtikelsprDto().getCBez();
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ZUSATZBEZEICHNUNG] = artikelDto
                                    .getArtikelsprDto().getCZbez();
                        }

                        if (hmStuecklistenposition.containsKey(sollmatDtos[i].getArtikelIId())) {

                            // Mengen abziehen
                            StuecklistepositionDto stklPos = hmStuecklistenposition
                                    .get(sollmatDtos[i].getArtikelIId());

                            sollmatDtos[i].setNMenge(stklPos.getNMenge());

                            Lossollmaterial sollmatBean = em.find(Lossollmaterial.class,
                                    sollmatDtos[i].getIId());

                            BigDecimal diffSollmenge = stklPos.getNMenge().subtract(sollmatBean.getNMenge());

                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_SOLLMENGE] = diffSollmenge;

                            sollmatBean.setNMenge(stklPos.getNMenge());
                            sollmatBean.setIBeginnterminoffset(stklPos.getIBeginnterminoffset());

                            BigDecimal diff = bdAusgegeben.subtract(sollmatDtos[i].getNMenge());

                            if (diff.doubleValue() == 0 && diffSollmenge.doubleValue() != 0) {
                                oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = new BigDecimal(
                                        0);
                                tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                        los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                            } else {

                                if (bMaterialNachbuchen == true || (bMaterialNachbuchen == false && Helper
                                        .short2boolean(artikelDto.getBLagerbewirtschaftet()) == false)) {

                                    if (Helper.short2boolean(artikelDto.getBSeriennrtragend())
                                            || Helper.short2boolean(artikelDto.getBChargennrtragend())) {
                                        sollmatDtos[i] = null;

                                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = new BigDecimal(
                                                0);
                                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_BEMERKUNG] = "Der Artikel ist SNR/CNR behaftet und wurde nicht ber\u00FCcksichtigt.";

                                        tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                                los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                                        continue;
                                    }

                                    if (diff.doubleValue() > 0) {

                                        for (int j = 0; j < istmaterialDtos.length; j++) {
                                            if (diff.doubleValue() > 0) {
                                                BigDecimal istmenge = istmaterialDtos[j].getNMenge();

                                                BigDecimal bdMengeNeu = null;

                                                if (diff.doubleValue() > istmenge.doubleValue()) {
                                                    bdMengeNeu = new BigDecimal(0);
                                                    diff = diff.subtract(istmenge);
                                                } else {
                                                    bdMengeNeu = istmenge.subtract(diff);
                                                    diff = new BigDecimal(0);
                                                }

                                                updateLosistmaterialMenge(istmaterialDtos[j].getIId(),
                                                        bdMengeNeu, theClientDto);
                                            }
                                        }

                                        BigDecimal bdAusgegebenNachher = getAusgegebeneMenge(
                                                sollmatDtos[i].getIId(), null, theClientDto);

                                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = bdAusgegebenNachher
                                                .subtract(bdAusgegeben);

                                        tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                                los.getC_nr() + artikelDto.getCNr(), oZeileReport);
                                    } else {
                                        BigDecimal bdAbzubuchendeMenge = diff.abs();
                                        for (int j = 0; j < laeger.length; j++) {
                                            // wenn noch was abzubuchen ist
                                            // (Menge >
                                            // 0)
                                            if (bdAbzubuchendeMenge.compareTo(new BigDecimal(0)) == 1) {
                                                BigDecimal bdLagerstand = null;
                                                if (Helper
                                                        .short2boolean(artikelDto.getBLagerbewirtschaftet())) {

                                                    bdLagerstand = getLagerFac().getLagerstand(
                                                            artikelDto.getIId(), laeger[j].getLagerIId(),
                                                            theClientDto);

                                                } else {
                                                    bdLagerstand = new BigDecimal(999999999);
                                                }
                                                // wenn ein lagerstand da
                                                // ist
                                                if (bdLagerstand.compareTo(new BigDecimal(0)) == 1) {
                                                    BigDecimal bdMengeVonLager;
                                                    if (bdLagerstand.compareTo(bdAbzubuchendeMenge) == 1) {
                                                        // wenn mehr als
                                                        // ausreichend
                                                        // auf
                                                        // lager
                                                        bdMengeVonLager = bdAbzubuchendeMenge;
                                                    } else {
                                                        // dann nur den
                                                        // lagerstand
                                                        // entnehmen
                                                        bdMengeVonLager = bdLagerstand;
                                                    }
                                                    LosistmaterialDto istmat = new LosistmaterialDto();
                                                    istmat.setLagerIId(laeger[j].getLagerIId());
                                                    istmat.setLossollmaterialIId(sollmatDtos[i].getIId());
                                                    istmat.setNMenge(bdMengeVonLager);

                                                    if (sollmatDtos[i].getNMenge().doubleValue() > 0) {
                                                        istmat.setBAbgang(Helper.boolean2Short(true));
                                                    } else {
                                                        istmat.setBAbgang(Helper.boolean2Short(false));
                                                    }

                                                    // ist-wert anlegen und
                                                    // lagerbuchung
                                                    // durchfuehren
                                                    createLosistmaterial(istmat, null, theClientDto);
                                                    // menge reduzieren
                                                    bdAbzubuchendeMenge = bdAbzubuchendeMenge
                                                            .subtract(bdMengeVonLager);
                                                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = bdMengeVonLager;

                                                    tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                                            los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                                                } else {
                                                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = new BigDecimal(
                                                            0);
                                                    tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                                            los.getC_nr() + artikelDto.getCNr(), oZeileReport);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            hmStuecklistenposition.remove(sollmatDtos[i].getArtikelIId());
                            getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS,
                                    sollmatDtos[i].getIId(), false, theClientDto);
                        } else {

                            // Los-Sollmaterial loeschen

                            verknuepfungZuBestellpositionUndArbeitsplanLoeschen(sollmatDtos[i].getIId());

                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_SOLLMENGE] = sollmatDtos[i]
                                    .getNMenge().multiply(new BigDecimal(-1));

                            if (bMaterialNachbuchen == true || istmaterialDtos.length == 0
                                    || (bMaterialNachbuchen == false && Helper
                                            .short2boolean(artikelDto.getBLagerbewirtschaftet()) == false)) {
                                for (int j = 0; j < istmaterialDtos.length; j++) {
                                    removeLosistmaterial(istmaterialDtos[j], theClientDto);
                                }

                                removeLossollmaterial(sollmatDtos[i], theClientDto);

                                oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = bdAusgegeben
                                        .multiply(new BigDecimal(-1));
                                tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                        los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                            } else {
                                sollmatDtos[i].setNMenge(new BigDecimal(0));
                                updateLossollmaterial(sollmatDtos[i], theClientDto);
                                oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = new BigDecimal(
                                        0);
                                tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                        los.getC_nr() + artikelDto.getCNr(), oZeileReport);
                            }

                            getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS,
                                    sollmatDtos[i].getIId(), false, theClientDto);
                            sollmatDtos[i] = null;

                        }

                    }
                } catch (RemoteException e) {
                    throwEJBExceptionLPRespectOld(e);
                }

            }

            // Nun alle uebrigen Sollmaterial=0 loeschen
            for (int i = 0; i < sollmatDtos.length; i++) {
                if (sollmatDtos[i] != null && !Helper.short2boolean(sollmatDtos[i].getBNachtraeglich())
                        && sollmatDtos[i].getNMenge().doubleValue() == 0) {

                    // Los-Sollmaterial loeschen
                    LosistmaterialDto[] istmaterialDtos = losistmaterialFindByLossollmaterialIId(
                            sollmatDtos[i].getIId());

                    boolean bAlleIstMaterialSindNull = true;

                    for (int z = 0; z < istmaterialDtos.length; z++) {
                        if (istmaterialDtos[z].getNMenge().doubleValue() != 0) {
                            bAlleIstMaterialSindNull = false;
                        }
                    }
                    ArtikelDto artikelDto = getArtikelFac()
                            .artikelFindByPrimaryKeySmall(sollmatDtos[i].getArtikelIId(), theClientDto);
                    if (bMaterialNachbuchen == true || bAlleIstMaterialSindNull == true
                            || (bMaterialNachbuchen == false
                                    && Helper.short2boolean(artikelDto.getBLagerbewirtschaftet()) == false)) {

                        BigDecimal bdAusgegeben = getAusgegebeneMenge(sollmatDtos[i].getIId(), null,
                                theClientDto);

                        for (int j = 0; j < istmaterialDtos.length; j++) {
                            removeLosistmaterial(istmaterialDtos[j], theClientDto);
                        }

                        verknuepfungZuBestellpositionUndArbeitsplanLoeschen(sollmatDtos[i].getIId());
                        removeLossollmaterial(sollmatDtos[i], theClientDto);

                        if (bdAusgegeben.doubleValue() != 0) {

                            Object[] oZeileReport = new Object[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ANZAHL_SPALTEN];
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_LOSNUMMER] = los
                                    .getC_nr();
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ARTIKELNUMMER] = artikelDto
                                    .getCNr();
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_EINHEIT] = artikelDto
                                    .getEinheitCNr();
                            if (artikelDto.getArtikelsprDto() != null) {
                                oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_BEZEICHNUNG] = artikelDto
                                        .getArtikelsprDto().getCBez();
                                oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ZUSATZBEZEICHNUNG] = artikelDto
                                        .getArtikelsprDto().getCZbez();
                            }
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = bdAusgegeben
                                    .multiply(new BigDecimal(-1));

                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_SOLLMENGE] = new BigDecimal(
                                    0);

                            tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                    los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                        }
                    }

                }
            }

            // Alle noch nicht verbrauchten neu eintragen

            Iterator it = hmStuecklistenposition.keySet().iterator();
            while (it.hasNext()) {

                try {
                    LagerDto lagerDtoMandant = getLagerFac().getHauptlagerDesMandanten(theClientDto);
                    Integer artikelIId = (Integer) it.next();

                    StuecklistepositionDto stklPos = hmStuecklistenposition.get(artikelIId);
                    BigDecimal bdAbzubuchendeMenge = stklPos.getNMenge();

                    ArtikelDto artikelDto = getArtikelFac()
                            .artikelFindByPrimaryKeySmall(stklPos.getArtikelIId(), theClientDto);

                    Object[] oZeileReport = new Object[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ANZAHL_SPALTEN];
                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_LOSNUMMER] = los
                            .getC_nr();
                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ARTIKELNUMMER] = artikelDto
                            .getCNr();
                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_EINHEIT] = artikelDto
                            .getEinheitCNr();
                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_SOLLMENGE] = stklPos
                            .getNMenge();

                    if (artikelDto.getArtikelsprDto() != null) {
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_BEZEICHNUNG] = artikelDto
                                .getArtikelsprDto().getCBez();
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_ZUSATZBEZEICHNUNG] = artikelDto
                                .getArtikelsprDto().getCZbez();
                    }

                    LossollmaterialDto losMatDto = new LossollmaterialDto();
                    losMatDto.setArtikelIId(stklPos.getArtikelIId());
                    losMatDto.setBNachtraeglich(Helper.boolean2Short(false));
                    losMatDto.setCKommentar(stklPos.getCKommentar());
                    losMatDto.setCPosition(stklPos.getCPosition());
                    losMatDto.setFDimension1(stklPos.getFDimension1());
                    losMatDto.setFDimension2(stklPos.getFDimension2());
                    losMatDto.setFDimension3(stklPos.getFDimension3());
                    losMatDto.setILfdnummer(stklPos.getILfdnummer());
                    losMatDto.setEinheitCNr(stklPos.getEinheitCNr());
                    losMatDto.setLosIId(los.getI_id());
                    losMatDto.setMontageartIId(stklPos.getMontageartIId());
                    losMatDto.setNMenge(stklPos.getNMenge());
                    losMatDto.setISort(new Integer(0));

                    BigDecimal bdSollpreis = getLagerFac().getGemittelterGestehungspreisEinesLagers(
                            stklPos.getArtikelIId(), lagerDtoMandant.getIId(), theClientDto);
                    losMatDto.setNSollpreis(bdSollpreis);

                    Integer sollmatIId = createLossollmaterial(losMatDto, theClientDto).getIId();
                    if (bMaterialNachbuchen == true || (bMaterialNachbuchen == false
                            && Helper.short2boolean(artikelDto.getBLagerbewirtschaftet()) == false)) {

                        if (Helper.short2boolean(artikelDto.getBSeriennrtragend())
                                || Helper.short2boolean(artikelDto.getBChargennrtragend())) {
                            oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_BEMERKUNG] = "Der Artikel ist SNR/CNR behaftet und wurde nicht ber\u00FCcksichtigt.";

                            tmAktualisierteLose.put(los.getC_nr() + artikelDto.getCNr(), oZeileReport);
                            continue;
                        }

                        for (int j = 0; j < laeger.length; j++) {
                            // wenn noch was abzubuchen ist
                            // (Menge >
                            // 0)
                            if (bdAbzubuchendeMenge.compareTo(new BigDecimal(0)) == 1) {
                                BigDecimal bdLagerstand = null;
                                if (Helper.short2boolean(artikelDto.getBLagerbewirtschaftet())) {

                                    bdLagerstand = getLagerFac().getLagerstand(artikelDto.getIId(),
                                            laeger[j].getLagerIId(), theClientDto);

                                } else {
                                    bdLagerstand = new BigDecimal(999999999);
                                }
                                // wenn ein lagerstand da ist
                                if (bdLagerstand.compareTo(new BigDecimal(0)) == 1) {
                                    BigDecimal bdMengeVonLager;
                                    if (bdLagerstand.compareTo(bdAbzubuchendeMenge) == 1) {
                                        // wenn mehr als
                                        // ausreichend
                                        // auf
                                        // lager
                                        bdMengeVonLager = bdAbzubuchendeMenge;
                                    } else {
                                        // dann nur den
                                        // lagerstand
                                        // entnehmen
                                        bdMengeVonLager = bdLagerstand;
                                    }
                                    LosistmaterialDto istmat = new LosistmaterialDto();
                                    istmat.setLagerIId(laeger[j].getLagerIId());
                                    istmat.setLossollmaterialIId(sollmatIId);
                                    istmat.setNMenge(bdMengeVonLager);

                                    if (stklPos.getNMenge().doubleValue() > 0) {
                                        istmat.setBAbgang(Helper.boolean2Short(true));
                                    } else {
                                        istmat.setBAbgang(Helper.boolean2Short(false));
                                    }

                                    // ist-wert anlegen und
                                    // lagerbuchung
                                    // durchfuehren
                                    createLosistmaterial(istmat, null, theClientDto);
                                    // menge reduzieren
                                    bdAbzubuchendeMenge = bdAbzubuchendeMenge.subtract(bdMengeVonLager);

                                    oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = bdMengeVonLager;
                                    tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                            los.getC_nr() + artikelDto.getCNr(), oZeileReport);

                                }
                            }
                        }
                    } else {
                        oZeileReport[StuecklisteReportFac.REPORT_STUECKLISTE_LOSEAKTUALISIERT_KORREKTUR_AUSGABEMENGE] = new BigDecimal(
                                0);
                        tmAktualisierteLose = add2TreeMap(tmAktualisierteLose,
                                los.getC_nr() + artikelDto.getCNr(), oZeileReport);
                    }

                    getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, losMatDto.getIId(), false,
                            theClientDto);

                } catch (RemoteException e) {
                    throwEJBExceptionLPRespectOld(e);
                }
            }

            // Los aktualisieren
            Los losUpd = em.find(Los.class, los.getI_id());
            losUpd.setTAktualisierungstueckliste(getTimestamp());

        }

    }

    return tmAktualisierteLose;
}

From source file:org.openbravo.test.costing.TestCosting.java

@Test
public void testCostingN2() throws Exception {

    final int day0 = 0;
    final int day1 = 5;
    final int day2 = 10;
    final int day3 = 15;
    final BigDecimal price1 = new BigDecimal("5.00");
    final BigDecimal quantity1 = new BigDecimal("10");
    final BigDecimal quantity2 = new BigDecimal("8");
    final BigDecimal quantity3 = new BigDecimal("12");

    try {// w  w  w .  j  a v a 2 s .c om

        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 goods receipt, run costing background, post it and assert it
        ShipmentInOut goodsReceipt1 = createGoodsReceipt(product, price1, quantity1, day0);

        // Create goods shipment, run costing background, post it and assert it
        ShipmentInOut goodsShipment1 = createGoodsShipment(product, price1, quantity2, day2);

        // Create goods receipt, run costing background, post it and assert it
        ShipmentInOut goodsReceipt2 = createGoodsReceipt(product, price1, quantity1, day3);

        // Create goods shipment, run costing background, post it and assert it
        ShipmentInOut goodsShipment2 = createGoodsShipment(product, price1, quantity1, day1);

        // 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));
        productTransactionAssertList.add(new ProductTransactionAssert(OBDal.getInstance()
                .get(ShipmentInOut.class, goodsShipment2.getId()).getMaterialMgmtShipmentInOutLineList().get(0),
                price1, price1));
        productTransactionAssertList.add(new ProductTransactionAssert(OBDal.getInstance()
                .get(ShipmentInOut.class, goodsShipment1.getId()).getMaterialMgmtShipmentInOutLineList().get(0),
                price1, price1));
        productTransactionAssertList.add(
                new ProductTransactionAssert(OBDal.getInstance().get(ShipmentInOut.class, goodsReceipt2.getId())
                        .getMaterialMgmtShipmentInOutLineList().get(0), price1, price1));
        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(3), price1, null, price1,
                quantity3.subtract(quantity1)));
        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), "BDT", amount0, day1, true));
        costAdjustmentAssertList.add(costAdjustmentAssertLineList);
        assertCostAdjustment(costAdjustmentList, costAdjustmentAssertList);

        OBDal.getInstance().commitAndClose();

    } catch (Exception e) {
        System.out.println(e.getMessage());
        throw new OBException(e);
    }

    finally {
        OBContext.restorePreviousMode();
    }
}