Example usage for java.math BigDecimal doubleValue

List of usage examples for java.math BigDecimal doubleValue

Introduction

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

Prototype

@Override
public double doubleValue() 

Source Link

Document

Converts this BigDecimal to a double .

Usage

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

public LossollmaterialDto updateLossollmaterial(LossollmaterialDto lossollmaterialDto,
        TheClientDto theClientDto) throws EJBExceptionLP {
    Integer iId = lossollmaterialDto.getIId();
    LosDto losDto = losFindByPrimaryKey(lossollmaterialDto.getLosIId());
    if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ERLEDIGT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_BEREITS_ERLEDIGT, "");
    }//from  w w w . java2  s. co m
    if (losDto.getStatusCNr().equals(FertigungFac.STATUS_STORNIERT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_STORNIERT, "");
    }
    try {
        Lossollmaterial lossollmaterial = em.find(Lossollmaterial.class, iId);

        if (!lossollmaterial.getArtikelIId().equals(lossollmaterialDto.getArtikelIId())) {
            // Wenn Update auf Artikel, dann Position loeschen und neu
            // anlegen
            removeLossollmaterial(lossollmaterialDto, theClientDto);

            lossollmaterialDto = createLossollmaterial(lossollmaterialDto, theClientDto);

            lossollmaterial = em.find(Lossollmaterial.class, lossollmaterialDto.getIId());

        }

        if (lossollmaterial == null) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_UPDATE, "");
        }

        if (getMandantFac().hatZusatzfunktionberechtigung(MandantFac.ZUSATZFUNKTION_GERAETESERIENNUMMERN,
                theClientDto)) {
            if (losDto.getStuecklisteIId() != null) {

                // PJ 16622

                Artikel artikel = em.find(Artikel.class, lossollmaterialDto.getArtikelIId());
                if (Helper.short2boolean(artikel.getBSeriennrtragend())) {

                    BigDecimal ssg = lossollmaterialDto.getNMenge().divide(losDto.getNLosgroesse(), 4,
                            BigDecimal.ROUND_HALF_UP);

                    if (ssg.doubleValue() != 1) {
                        throw new EJBExceptionLP(
                                EJBExceptionLP.FEHLER_POSITIONSMENGE_EINES_SNR_ARTIKELS_MUSS_1_SEIN_WENN_GERAETESNR,
                                new Exception(
                                        "FEHLER_POSITIONSMENGE_EINES_SNR_ARTIKELS_MUSS_1_SEIN_WENN_GERAETESNR"));

                    }

                }

            }
        }
        lossollmaterialDto.setTAendern(new Timestamp(System.currentTimeMillis()));
        lossollmaterialDto.setPersonalIIdAendern(theClientDto.getIDPersonal());
        setLossollmaterialFromLossollmaterialDto(lossollmaterial, lossollmaterialDto, theClientDto);
        // angelegt -> reservierung updaten
        if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ANGELEGT)) {
            ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKey(lossollmaterial.getArtikelIId(),
                    theClientDto);
            java.sql.Date dTermin;
            if (lossollmaterial.getNMenge().compareTo(new BigDecimal(0)) > 0) {
                // Positive Reservierung: produktionsstart
                dTermin = losDto.getTProduktionsbeginn();
            } else {
                // Negative Reservierung: produktionsende
                dTermin = losDto.getTProduktionsende();
            }
            updateReservierung(artikelDto, lossollmaterialDto.getIId(), lossollmaterialDto.getNMenge(),
                    new java.sql.Timestamp(dTermin.getTime()));
        }
        // ausgegeben -> fehlmenge aktualisieren
        else {
            getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, lossollmaterialDto.getIId(), false,
                    theClientDto);
        }
        return lossollmaterialDto;
        // }
        // catch (FinderException ex) {
        // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_UPDATE, ex);
    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
        return null;
    }
}

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

public LossollmaterialDto createLossollmaterial(LossollmaterialDto lossollmaterialDto,
        TheClientDto theClientDto) throws EJBExceptionLP {
    // log/*from   w w w .  ja v  a  2s  .c  o m*/
    myLogger.logData(lossollmaterialDto);
    // begin
    LosDto losDto = losFindByPrimaryKey(lossollmaterialDto.getLosIId());
    if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ERLEDIGT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_BEREITS_ERLEDIGT, "");
    }
    if (losDto.getStatusCNr().equals(FertigungFac.STATUS_STORNIERT)) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FERTIGUNG_DAS_LOS_IST_STORNIERT, "");
    }

    if (lossollmaterialDto.getIBeginnterminoffset() == null) {
        lossollmaterialDto.setIBeginnterminoffset(0);
    }

    lossollmaterialDto.setPersonalIIdAendern(theClientDto.getIDPersonal());
    // primary key
    Integer iId = getPKGeneratorObj().getNextPrimaryKey(PKConst.PK_LOSSOLLMATERIAL);
    lossollmaterialDto.setIId(iId);
    // nachtraeglich ?
    boolean bNachtraeglich = false;
    if (lossollmaterialDto.getBNachtraeglich() == null) {
        lossollmaterialDto.setBNachtraeglich(Helper.boolean2Short(true));
        bNachtraeglich = true;
    }
    if (getMandantFac().hatZusatzfunktionberechtigung(MandantFac.ZUSATZFUNKTION_GERAETESERIENNUMMERN,
            theClientDto)) {
        if (losDto.getStuecklisteIId() != null) {

            // PJ 16622

            Artikel artikel = em.find(Artikel.class, lossollmaterialDto.getArtikelIId());
            if (Helper.short2boolean(artikel.getBSeriennrtragend())) {

                BigDecimal ssg = lossollmaterialDto.getNMenge().divide(losDto.getNLosgroesse(), 4,
                        BigDecimal.ROUND_HALF_UP);

                if (ssg.doubleValue() != 1) {
                    throw new EJBExceptionLP(
                            EJBExceptionLP.FEHLER_POSITIONSMENGE_EINES_SNR_ARTIKELS_MUSS_1_SEIN_WENN_GERAETESNR,
                            new Exception(
                                    "FEHLER_POSITIONSMENGE_EINES_SNR_ARTIKELS_MUSS_1_SEIN_WENN_GERAETESNR"));

                }

            }

        }
    }

    try {
        // rounddto: vor dem Create
        lossollmaterialDto.round(new Integer(4),
                getMandantFac().getNachkommastellenPreisAllgemein(theClientDto.getMandant()));
        Lossollmaterial lossollmaterial = new Lossollmaterial(lossollmaterialDto.getIId(),
                lossollmaterialDto.getLosIId(), lossollmaterialDto.getArtikelIId(),
                lossollmaterialDto.getNMenge(), lossollmaterialDto.getEinheitCNr(),
                lossollmaterialDto.getMontageartIId(), lossollmaterialDto.getISort(),
                lossollmaterialDto.getBNachtraeglich(), lossollmaterialDto.getNSollpreis(),
                lossollmaterialDto.getPersonalIIdAendern(), lossollmaterialDto.getIBeginnterminoffset());

        em.persist(lossollmaterial);
        em.flush();
        lossollmaterialDto.setTAendern(lossollmaterial.getTAendern());
        setLossollmaterialFromLossollmaterialDto(lossollmaterial, lossollmaterialDto, theClientDto);
        // reservierung
        if (bNachtraeglich) {
            // Reservierung anlegen
            ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKey(lossollmaterialDto.getArtikelIId(),
                    theClientDto);
            // wenn los angelegt -> reservierung
            if (losDto.getStatusCNr().equals(FertigungFac.STATUS_ANGELEGT)) {
                java.sql.Date dTermin;
                if (lossollmaterialDto.getNMenge().compareTo(new BigDecimal(0)) > 0) {
                    // Positive Reservierung: produktionsstart
                    dTermin = losDto.getTProduktionsbeginn();
                } else {
                    // Negative Reservierung: produktionsende
                    dTermin = losDto.getTProduktionsende();
                }
                createReservierung(artikelDto, lossollmaterialDto.getIId(), lossollmaterialDto.getNMenge(),
                        new java.sql.Timestamp(dTermin.getTime()));
            }
            // wenn ausgegeben -> fehlmenge
            else {
                getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, lossollmaterialDto.getIId(),
                        false, theClientDto);
            }
        }
        return lossollmaterialDto;
    } catch (EntityExistsException ex) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_ANLEGEN, ex);
    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
        return null;
    }
}

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 w w w  .ja v  a  2 s .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: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;/*from   ww  w.  j  av  a 2s. 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

@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public HashMap<Integer, StuecklistepositionDto> holeAlleLossollmaterialFuerStuecklistenAktualisierung(
        Integer stuecklisteIId, BigDecimal bdLosgroesse, int iEbene,
        HashMap<Integer, StuecklistepositionDto> hmPositionen, TheClientDto theClientDto) {
    iEbene++;//from  w  w w .j a  va 2  s.c om

    if (hmPositionen == null) {
        hmPositionen = new HashMap<Integer, StuecklistepositionDto>();
    }
    try {
        StuecklistepositionDto[] stkPos = getStuecklisteFac()
                .stuecklistepositionFindByStuecklisteIId(stuecklisteIId, theClientDto);

        StuecklisteDto stklDto = getStuecklisteFac().stuecklisteFindByPrimaryKey(stuecklisteIId, theClientDto);

        for (int i = 0; i < stkPos.length; i++) {
            // alle stuecklistenpositionen ins los uebernehmen

            // W02451
            if (stkPos[i].getArtikelIId() == 6093) {
                int u = 0;
            }

            // Einheit umrechnen
            ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall(stkPos[i].getArtikelIId(),
                    theClientDto);

            BigDecimal bdFaktor = getSystemFac().rechneUmInAndereEinheit(new BigDecimal(1),
                    stkPos[i].getEinheitCNr(), artikelDto.getEinheitCNr(), stkPos[i].getIId(), theClientDto);

            // nun die Dimensionen
            BigDecimal bdDimProdukt = new BigDecimal(1);
            EinheitDto einheitDto = getSystemFac().einheitFindByPrimaryKey(stkPos[i].getEinheitCNr(),
                    theClientDto);
            if (einheitDto.getIDimension().intValue() >= 1) {
                if (stkPos[i].getFDimension1() != null) {
                    bdDimProdukt = bdDimProdukt
                            .multiply(new BigDecimal(stkPos[i].getFDimension1().floatValue()));
                }
            }
            if (einheitDto.getIDimension().intValue() >= 2) {
                if (stkPos[i].getFDimension2() != null) {
                    bdDimProdukt = bdDimProdukt
                            .multiply(new BigDecimal(stkPos[i].getFDimension2().floatValue()));
                }
            }
            if (einheitDto.getIDimension().intValue() >= 3) {
                if (stkPos[i].getFDimension3() != null) {
                    bdDimProdukt = bdDimProdukt
                            .multiply(new BigDecimal(stkPos[i].getFDimension3().floatValue()));
                }
            }
            // verschnitt
            BigDecimal bdMenge = Helper.berechneMengeInklusiveVerschnitt(stkPos[i].getNMenge(),
                    artikelDto.getFVerschnittfaktor(), artikelDto.getFVerschnittbasis(), bdLosgroesse);

            // endgueltige Menge berechnen
            BigDecimal posMenge = bdMenge.multiply(bdDimProdukt).multiply(bdLosgroesse).multiply(bdFaktor)
                    .divide(new BigDecimal(stklDto.getIErfassungsfaktor().doubleValue()),
                            BigDecimal.ROUND_HALF_EVEN);

            if (posMenge.doubleValue() < 0.001 && posMenge.doubleValue() > 0.000001) {
                posMenge = new BigDecimal("0.001");
                posMenge = posMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN);
            } else {
                posMenge = posMenge.setScale(3, BigDecimal.ROUND_HALF_EVEN);
            }

            stkPos[i].setNMenge(posMenge);

            StuecklisteDto stuecklisteDto = getStuecklisteFac()
                    .stuecklisteFindByMandantCNrArtikelIIdOhneExc(stkPos[i].getArtikelIId(), theClientDto);

            if (stuecklisteDto != null && stuecklisteDto.getStuecklisteartCNr()
                    .equals(StuecklisteFac.STUECKLISTEART_HILFSSTUECKLISTE)) {
                if (iEbene < 10) {
                    holeAlleLossollmaterialFuerStuecklistenAktualisierung(stuecklisteDto.getIId(), posMenge,
                            iEbene, hmPositionen, theClientDto);
                }

            } else {

                if (stkPos[i].getNMenge().doubleValue() > 0) {

                    if (hmPositionen.containsKey(stkPos[i].getArtikelIId())) {

                        StuecklistepositionDto p = hmPositionen.get(stkPos[i].getArtikelIId());
                        p.setNMenge(stkPos[i].getNMenge().add(p.getNMenge()));
                        hmPositionen.put(stkPos[i].getArtikelIId(), p);
                    } else {
                        hmPositionen.put(stkPos[i].getArtikelIId(), stkPos[i]);
                    }
                }

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

    return hmPositionen;

}

From source file: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;//w  w w . j a  v a2 s .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 void bucheTOPSArtikelAufHauptLager(Integer losIId, TheClientDto theClientDto,
        BigDecimal zuzubuchendeSatzgroesse) {
    LossollmaterialDto[] dtos = lossollmaterialFindByLosIId(losIId);
    try {//from w  ww.  ja v a2  s  .co m
        Integer hauptlagerIId = getLagerFac().getHauptlagerDesMandanten(theClientDto).getIId();

        LosDto losDto = losFindByPrimaryKey(losIId);

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

            ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall(dtos[i].getArtikelIId(),
                    theClientDto);
            artklaIId = artikelDto.getArtklaIId();

            if (artklaIId != null) {
                boolean bTops = Helper.short2boolean(
                        getArtikelFac().artklaFindByPrimaryKey(artklaIId, theClientDto).getBTops());

                if (bTops == true) {

                    BigDecimal sollsatzgroesse = dtos[i].getNMenge().divide(losDto.getNLosgroesse(), 4,
                            BigDecimal.ROUND_HALF_EVEN);
                    BigDecimal zuzubuchendeMenge = null;

                    if (zuzubuchendeSatzgroesse == null) {
                        zuzubuchendeMenge = dtos[i].getNMenge()
                                .subtract(getAusgegebeneMenge(dtos[i].getIId(), null, theClientDto));
                    } else {
                        zuzubuchendeMenge = sollsatzgroesse.multiply(zuzubuchendeSatzgroesse);
                    }

                    if (zuzubuchendeMenge.doubleValue() > 0) {

                        HandlagerbewegungDto handDto = new HandlagerbewegungDto();
                        handDto.setArtikelIId(dtos[i].getArtikelIId());
                        handDto.setNMenge(zuzubuchendeMenge);
                        handDto.setBAbgang(Helper.boolean2Short(false));
                        handDto.setCKommentar("TOPS " + losDto.getCNr());
                        handDto.setLagerIId(hauptlagerIId);
                        handDto.setNEinstandspreis(getLagerFac().getGemittelterGestehungspreisDesHauptlagers(
                                dtos[i].getArtikelIId(), theClientDto));
                        getLagerFac().createHandlagerbewegung(handDto, theClientDto);
                        // CK:13872
                        // Dann aufs Los buchen

                        LosistmaterialDto istmat = new LosistmaterialDto();
                        istmat.setLagerIId(hauptlagerIId);
                        istmat.setLossollmaterialIId(dtos[i].getIId());
                        istmat.setNMenge(zuzubuchendeMenge);
                        istmat.setBAbgang(Helper.boolean2Short(true));
                        // ist-wert anlegen und lagerbuchung
                        // durchfuehren
                        createLosistmaterial(istmat, null, theClientDto);

                        // Reservierung loeschen
                        removeReservierung(artikelDto, dtos[i].getIId());
                        // Fehlmenge anlegen
                        getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, dtos[i].getIId(), false,
                                theClientDto);

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

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

@TransactionTimeout(5000)
public TreeMap<String, Object[]> aktualisiereLoseAusStueckliste(Integer stuecklisteIId,
        TheClientDto theClientDto) {/*ww  w .  ja v a2 s .  co  m*/

    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:com.lp.server.fertigung.ejbfac.FertigungFacBean.java

private void aktualisiereAZAllerLosablieferungen(Integer losIId, TheClientDto theClientDto) {
    LosDto losDto = losFindByPrimaryKey(losIId);
    try {// w  w  w .  j a  v a 2 s .  com
        // 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

public void bucheMaterialAufLos(LosDto losDto, BigDecimal menge, boolean bHandausgabe,
        boolean bNurFehlmengenAnlegenUndReservierungenLoeschen, boolean bUnterstuecklistenAbbuchen,
        TheClientDto theClientDto, ArrayList<BucheSerienChnrAufLosDto> bucheSerienChnrAufLosDtos,
        boolean throwExceptionWhenCreate) {
    try {/* ww w  .j  av a  2 s  .  c  o m*/

        Query query = em.createNamedQuery("LossollmaterialfindByLosIId");
        query.setParameter(1, losDto.getIId());
        Collection<?> cl = query.getResultList();
        // if (cl.isEmpty()) {
        // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FIND, null);
        // }
        LossollmaterialDto[] sollmat = assembleLossollmaterialDtos(cl);
        LosablieferungDto[] dtos = losablieferungFindByLosIId(losDto.getIId(), false, theClientDto);
        BigDecimal bdBereitsabgeliefert = new BigDecimal(0);
        for (int i = 0; i < dtos.length; i++) {
            bdBereitsabgeliefert = bdBereitsabgeliefert.add(dtos[i].getNMenge());
        }

        // PJ18216
        boolean bNichtLagerbewSofortAusgeben = false;
        try {
            ParametermandantDto parameterM = getParameterFac().getMandantparameter(theClientDto.getMandant(),
                    ParameterFac.KATEGORIE_FERTIGUNG,
                    ParameterFac.PARAMETER_NICHT_LAGERBEWIRTSCHAFTETE_SOFORT_AUSGEBEN);
            bNichtLagerbewSofortAusgeben = ((Boolean) parameterM.getCWertAsObject()).booleanValue();

        } catch (RemoteException ex) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER, ex);
        }

        // 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

            if (!bNurFehlmengenAnlegenUndReservierungenLoeschen) {
                if (!bHandausgabe || (bHandausgabe == true && bNichtLagerbewSofortAusgeben == true)) {

                    // PJ18216
                    if (bHandausgabe == true && bNichtLagerbewSofortAusgeben == true) {

                        if (Helper.short2boolean(artikelDto.getBLagerbewirtschaftet())) {
                            continue;
                        }

                    }

                    StuecklisteDto stuecklisteDto = getStuecklisteFac()
                            .stuecklisteFindByMandantCNrArtikelIIdOhneExc(artikelDto.getIId(), theClientDto);
                    if (bUnterstuecklistenAbbuchen == false && stuecklisteDto != null) {
                    } else {

                        BigDecimal bdAbzubuchendeMenge = new BigDecimal(0.0000);
                        if (menge == null) {
                            bdAbzubuchendeMenge = sollmat[i].getNMenge();
                        } else {
                            if (losDto.getNLosgroesse().doubleValue() != 0) {
                                BigDecimal sollsatzGroesse = sollmat[i].getNMenge()
                                        .divide(losDto.getNLosgroesse(), 10, BigDecimal.ROUND_HALF_EVEN);

                                sollsatzGroesse = Helper.rundeKaufmaennisch(sollsatzGroesse, 3);

                                BigDecimal bdBereitsausgegeben = getAusgegebeneMenge(sollmat[i].getIId(), null,
                                        theClientDto);
                                BigDecimal bdGesamtmenge = Helper.rundeKaufmaennisch(
                                        bdBereitsabgeliefert.add(menge).multiply(sollsatzGroesse), 4);
                                if (bdGesamtmenge.subtract(bdBereitsausgegeben).doubleValue() > 0) {
                                    bdAbzubuchendeMenge = bdGesamtmenge.subtract(bdBereitsausgegeben);
                                } else {
                                    if (bdGesamtmenge.doubleValue() < 0) {
                                        bdAbzubuchendeMenge = bdGesamtmenge.subtract(bdBereitsausgegeben).abs();

                                    }
                                }
                            }
                        }

                        // wg. PJ 15370
                        if (sollmat[i].getNMenge().doubleValue() > 0) {

                            if (!Helper.short2boolean(artikelDto.getBSeriennrtragend())
                                    && !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())) {

                                            // PJ18290
                                            boolean bImmerAusreichendVerfuegbar = false;
                                            try {
                                                ParametermandantDto parameterM = getParameterFac()
                                                        .getMandantparameter(theClientDto.getMandant(),
                                                                ParameterFac.KATEGORIE_ARTIKEL,
                                                                ParameterFac.PARAMETER_LAGER_IMMER_AUSREICHEND_VERFUEGBAR);
                                                bImmerAusreichendVerfuegbar = ((Boolean) parameterM
                                                        .getCWertAsObject()).booleanValue();

                                            } catch (RemoteException ex) {
                                                throw new EJBExceptionLP(EJBExceptionLP.FEHLER, ex);
                                            }
                                            if (bImmerAusreichendVerfuegbar == true) {
                                                bdLagerstand = new BigDecimal(999999999);
                                            } else {
                                                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);

                                            if (sollmat[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);
                                        }
                                    }
                                }

                            } else {
                                if (bucheSerienChnrAufLosDtos != null) {
                                    for (int j = 0; j < bucheSerienChnrAufLosDtos.size(); j++) {
                                        BucheSerienChnrAufLosDto dtoTemp = bucheSerienChnrAufLosDtos.get(j);

                                        if (dtoTemp.getLossollmaterialIId().equals(sollmat[i].getIId())) {

                                            LosistmaterialDto istmat = new LosistmaterialDto();
                                            istmat.setLagerIId(dtoTemp.getLagerIId());
                                            istmat.setLossollmaterialIId(dtoTemp.getLossollmaterialIId());
                                            istmat.setNMenge(dtoTemp.getNMenge());
                                            if (sollmat[i].getNMenge().doubleValue() > 0) {
                                                istmat.setBAbgang(Helper.boolean2Short(true));
                                            } else {
                                                istmat.setBAbgang(Helper.boolean2Short(false));
                                            }
                                            // ist-wert anlegen und
                                            // lagerbuchung
                                            // durchfuehren
                                            createLosistmaterial(istmat, dtoTemp.getCSeriennrChargennr(),
                                                    theClientDto);

                                        }

                                    }
                                }
                            }
                        }
                    }

                }
            }

            // Reservierung loeschen
            removeReservierung(artikelDto, sollmat[i].getIId());
            // Fehlmenge anlegen
            getFehlmengeFac().aktualisiereFehlmenge(LocaleFac.BELEGART_LOS, sollmat[i].getIId(),
                    throwExceptionWhenCreate, theClientDto);
        }

    }
    // catch (FinderException ex) {
    // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FIND, ex);
    // }
    catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
    }

}