Java tutorial
/******************************************************************************* * HELIUM V, Open Source ERP software for sustained success * at small and medium-sized enterprises. * Copyright (C) 2004 - 2014 HELIUM V IT-Solutions GmbH * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published * by the Free Software Foundation, either version 3 of theLicense, or * (at your option) any later version. * * According to sec. 7 of the GNU Affero General Public License, version 3, * the terms of the AGPL are supplemented with the following terms: * * "HELIUM V" and "HELIUM 5" are registered trademarks of * HELIUM V IT-Solutions GmbH. The licensing of the program under the * AGPL does not imply a trademark license. Therefore any rights, title and * interest in our trademarks remain entirely with us. If you want to propagate * modified versions of the Program under the name "HELIUM V" or "HELIUM 5", * you may only do so if you have a written permission by HELIUM V IT-Solutions * GmbH (to acquire a permission please contact HELIUM V IT-Solutions * at trademark@heliumv.com). * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * * Contact: developers@heliumv.com ******************************************************************************/ package com.lp.server.bestellung.ejbfac; import java.math.BigDecimal; import java.math.MathContext; import java.math.RoundingMode; import java.rmi.RemoteException; import java.sql.Date; import java.sql.Timestamp; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import javax.annotation.Resource; import javax.ejb.SessionContext; import javax.ejb.Stateless; import javax.ejb.TransactionAttribute; import javax.ejb.TransactionAttributeType; import javax.persistence.EntityExistsException; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import javax.persistence.Query; import org.hibernate.Criteria; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.criterion.Order; import org.hibernate.criterion.Restrictions; import com.lp.server.anfrage.service.AnfrageDto; import com.lp.server.anfrage.service.AnfrageServiceFac; import com.lp.server.anfrage.service.AnfragepositionDto; import com.lp.server.angebot.service.AngebotDto; import com.lp.server.angebot.service.AngebotpositionDto; import com.lp.server.artikel.fastlanereader.generated.FLRArtikel; import com.lp.server.artikel.service.ArtikelDto; import com.lp.server.artikel.service.ArtikelFac; import com.lp.server.artikel.service.ArtikellieferantDto; import com.lp.server.artikel.service.ArtklaDto; import com.lp.server.artikel.service.LagerDto; import com.lp.server.bestellung.ejb.Bestellvorschlag; import com.lp.server.bestellung.fastlanereader.BestellvorschlagHandler; import com.lp.server.bestellung.fastlanereader.generated.FLRBestellposition; import com.lp.server.bestellung.fastlanereader.generated.FLRBestellvorschlag; import com.lp.server.bestellung.service.BestellpositionDto; import com.lp.server.bestellung.service.BestellpositionFac; import com.lp.server.bestellung.service.BestellungDto; import com.lp.server.bestellung.service.BestellungFac; import com.lp.server.bestellung.service.BestellvorschlagDto; import com.lp.server.bestellung.service.BestellvorschlagDtoAssembler; import com.lp.server.bestellung.service.BestellvorschlagFac; import com.lp.server.fertigung.fastlanereader.generated.FLRLos; import com.lp.server.fertigung.service.FertigungFac; import com.lp.server.fertigung.service.LosDto; import com.lp.server.fertigung.service.LossollmaterialDto; import com.lp.server.fertigung.service.MaterialbedarfDto; import com.lp.server.partner.fastlanereader.LieferantHandler; import com.lp.server.partner.service.AnsprechpartnerDto; import com.lp.server.partner.service.LieferantDto; import com.lp.server.personal.service.PersonalDto; import com.lp.server.stueckliste.fastlanereader.generated.FLRStueckliste; import com.lp.server.stueckliste.service.StuecklisteDto; import com.lp.server.stueckliste.service.StuecklisteMitStrukturDto; import com.lp.server.stueckliste.service.StuecklisteReportFac; import com.lp.server.stueckliste.service.StuecklistepositionDto; import com.lp.server.system.pkgenerator.PKConst; import com.lp.server.system.pkgenerator.bl.PKGeneratorObj; import com.lp.server.system.service.KostenstelleDto; import com.lp.server.system.service.LocaleFac; import com.lp.server.system.service.LockMeDto; import com.lp.server.system.service.MandantDto; import com.lp.server.system.service.ParameterFac; import com.lp.server.system.service.ParametermandantDto; import com.lp.server.system.service.TheClientDto; import com.lp.server.util.Facade; import com.lp.server.util.fastlanereader.FLRSessionFactory; import com.lp.server.util.fastlanereader.service.query.FilterKriterium; import com.lp.server.util.fastlanereader.service.query.SortierKriterium; import com.lp.util.EJBExceptionLP; import com.lp.util.Helper; @Stateless public class BestellvorschlagFacBean extends Facade implements BestellvorschlagFac { @PersistenceContext private EntityManager em; @Resource private SessionContext context; public Integer createBestellvorschlag(BestellvorschlagDto bestellvorschlagDtoI, TheClientDto theClientDto) throws EJBExceptionLP { myLogger.entry(); // Preconditions. if (bestellvorschlagDtoI == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_DTO_IS_NULL, new Exception("bestellvorschlagDtoI == null")); } if (bestellvorschlagDtoI.getCMandantCNr() == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FELD_DARF_NICHT_NULL_SEIN, new Exception("bestellvorschlagDtoI.getCMandantCNr() == null")); } if (bestellvorschlagDtoI.getIArtikelId() == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FELD_DARF_NICHT_NULL_SEIN, new Exception("bestellvorschlagDtoI.getIArtikelId()== null")); } if (bestellvorschlagDtoI.getBNettopreisuebersteuert() == null) { bestellvorschlagDtoI.setBNettopreisuebersteuert(Helper.boolean2Short(false)); } // bestellvorschlagDtoI.setPersonalAendernIID(theClientDto.getIDPersonal( // )); // bestellvorschlagDtoI.setPersonalAnlegenIID(theClientDto.getIDPersonal( // )); // PK fuer Partner generieren. PKGeneratorObj pkGen = new PKGeneratorObj(); Integer iIdBestellvorschlag = pkGen.getNextPrimaryKey(PKConst.PK_BESTELLVORSCHLAG); bestellvorschlagDtoI.setIId(iIdBestellvorschlag); try { Bestellvorschlag bestellvorschlag = new Bestellvorschlag(bestellvorschlagDtoI.getIId(), bestellvorschlagDtoI.getDRabattsatz(), bestellvorschlagDtoI.getNNettoGesamtPreisMinusRabatte(), bestellvorschlagDtoI.getNNettogesamtpreis(), bestellvorschlagDtoI.getNRabattbetrag(), bestellvorschlagDtoI.getNNettoeinzelpreis(), bestellvorschlagDtoI.getILieferantId(), bestellvorschlagDtoI.getIBelegartId(), bestellvorschlagDtoI.getCBelegartCNr(), bestellvorschlagDtoI.getTLiefertermin(), bestellvorschlagDtoI.getNZubestellendeMenge(), bestellvorschlagDtoI.getIArtikelId(), bestellvorschlagDtoI.getCMandantCNr(), bestellvorschlagDtoI.getBNettopreisuebersteuert()); em.persist(bestellvorschlag); em.flush(); setBestellvorschlagFromBestellvorschlagDto(bestellvorschlag, bestellvorschlagDtoI); } catch (EntityExistsException ex) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_ANLEGEN, ex); } return bestellvorschlagDtoI.getIId(); } public void removeBestellvorschlag(Integer iId) throws EJBExceptionLP { // try { Bestellvorschlag toRemove = em.find(Bestellvorschlag.class, iId); if (toRemove == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, ""); } try { em.remove(toRemove); em.flush(); } catch (EntityExistsException er) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_LOESCHEN, er); } // } // catch (RemoveException ex) { // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_LOESCHEN, ex); // } } /** * * @param bestellvorschlagDto * BestellvorschlagDto * @throws EJBExceptionLP */ public void removeBestellvorschlag(BestellvorschlagDto bestellvorschlagDto) throws EJBExceptionLP { if (bestellvorschlagDto != null) { Integer iId = bestellvorschlagDto.getIId(); removeBestellvorschlag(iId); } } public void updateBestellvorschlag(BestellvorschlagDto bestellvorschlagDto) throws EJBExceptionLP { if (bestellvorschlagDto != null) { Integer iId = bestellvorschlagDto.getIId(); // try { Bestellvorschlag bestellvorschlag = em.find(Bestellvorschlag.class, iId); if (bestellvorschlag == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, ""); } setBestellvorschlagFromBestellvorschlagDto(bestellvorschlag, bestellvorschlagDto); // } // catch (FinderException ex) { // throw new // EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, ex); // } } } public void updateBestellvorschlags(BestellvorschlagDto[] bestellvorschlagDtos) throws EJBExceptionLP { if (bestellvorschlagDtos != null) { for (int i = 0; i < bestellvorschlagDtos.length; i++) { updateBestellvorschlag(bestellvorschlagDtos[i]); } } } public BestellvorschlagDto bestellvorschlagFindByPrimaryKey(Integer iId) throws EJBExceptionLP { // try { Bestellvorschlag bestellvorschlag = em.find(Bestellvorschlag.class, iId); if (bestellvorschlag == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, ""); } return assembleBestellvorschlagDto(bestellvorschlag); // } // catch (FinderException ex) { // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FINDBYPRIMARYKEY, // ex); // } } public boolean mindestbestellwertErreicht(Integer iLieferantId, TheClientDto theClientDto) { boolean bMindestbestellwertErreicht = false; LieferantDto lieferantDto = getLieferantFac().lieferantFindByPrimaryKey(iLieferantId, theClientDto); if (lieferantDto.getNMindestbestellwert() != null && lieferantDto.getNMindestbestellwert().doubleValue() > 0) { BestellvorschlagDto[] bestDtos = bestellvorschlagFindByLieferantIIdMandantCNr(iLieferantId, theClientDto.getMandant()); BigDecimal gesamt = new BigDecimal(0); for (int i = 0; i < bestDtos.length; i++) { if (bestDtos[i].getNNettogesamtpreis() != null) { gesamt = gesamt .add(bestDtos[i].getNZubestellendeMenge().multiply(bestDtos[i].getNNettogesamtpreis())); } } if (gesamt.doubleValue() >= lieferantDto.getNMindestbestellwert().doubleValue()) { bMindestbestellwertErreicht = true; } } else { bMindestbestellwertErreicht = true; } return bMindestbestellwertErreicht; } public BestellvorschlagDto[] bestellvorschlagFindByLieferantIIdMandantCNr(Integer iLieferantId, String cNrMandant) throws EJBExceptionLP { Query query = em.createNamedQuery("BestellvorschlagfindByLieferantIIdMandantCNr"); query.setParameter(1, iLieferantId); query.setParameter(2, cNrMandant); Collection<?> cl = query.getResultList(); // if(cl.isEmpty()){ // throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FIND, null); // } return assembleBestellvorschlagDtos(cl); } public BestellvorschlagDto[] bestellvorschlagFindByLieferantIIdMandantCNrOhneExc(Integer iLieferantId, String cNrMandant) { try { Query query = em.createNamedQuery("BestellvorschlagfindByLieferantIIdMandantCNr"); query.setParameter(1, iLieferantId); query.setParameter(2, cNrMandant); return assembleBestellvorschlagDtos(query.getResultList()); } catch (Throwable th) { return null; } } private void setBestellvorschlagFromBestellvorschlagDto(Bestellvorschlag bestellvorschlag, BestellvorschlagDto bestellvorschlagDto) { bestellvorschlag.setMandantCNr(bestellvorschlagDto.getCMandantCNr()); bestellvorschlag.setArtikelIId(bestellvorschlagDto.getIArtikelId()); bestellvorschlag.setNZubestellendemenge(bestellvorschlagDto.getNZubestellendeMenge()); bestellvorschlag.setTLiefertermin(bestellvorschlagDto.getTLiefertermin()); bestellvorschlag.setBelegartCNr(bestellvorschlagDto.getCBelegartCNr()); bestellvorschlag.setIBelegartid(bestellvorschlagDto.getIBelegartId()); bestellvorschlag.setIBelegartpositionid(bestellvorschlagDto.getIBelegartpositionid()); bestellvorschlag.setLieferantIId(bestellvorschlagDto.getILieferantId()); bestellvorschlag.setNNettoeinzelpreis(bestellvorschlagDto.getNNettoeinzelpreis()); bestellvorschlag.setNRabattbetrag(bestellvorschlagDto.getNRabattbetrag()); bestellvorschlag.setFRabattsatz(bestellvorschlagDto.getDRabattsatz()); bestellvorschlag.setNNettogesamtpreis(bestellvorschlagDto.getNNettogesamtpreis()); bestellvorschlag.setBNettopreisuebersteuert(bestellvorschlagDto.getBNettopreisuebersteuert()); bestellvorschlag.setProjektIId(bestellvorschlagDto.getProjektIId()); em.merge(bestellvorschlag); em.flush(); } public long getAnzahlBestellvorschlagDesMandanten(TheClientDto theClientDto) throws EJBExceptionLP { long rowCount = 0; SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; try { session = factory.openSession(); String queryString = "select count(distinct flrbestellvorschlag.i_id) " + " from FLRBestellvorschlag flrbestellvorschlag " + " where flrbestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR + "='" + theClientDto.getMandant() + "'"; org.hibernate.Query query = session.createQuery(queryString); List<?> rowCountResult = query.list(); if (rowCountResult != null && rowCountResult.size() > 0) { rowCount = ((Long) rowCountResult.get(0)).longValue(); } } catch (Exception e) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER, e); } finally { closeSession(session); } return rowCount; } private BestellvorschlagDto assembleBestellvorschlagDto(Bestellvorschlag bestellvorschlag) { return BestellvorschlagDtoAssembler.createDto(bestellvorschlag); } private BestellvorschlagDto[] assembleBestellvorschlagDtos(Collection<?> bestellvorschlaege) { List<BestellvorschlagDto> list = new ArrayList<BestellvorschlagDto>(); if (bestellvorschlaege != null) { Iterator<?> iterator = bestellvorschlaege.iterator(); while (iterator.hasNext()) { Bestellvorschlag bestellvorschlag = (Bestellvorschlag) iterator.next(); list.add(assembleBestellvorschlagDto(bestellvorschlag)); } } BestellvorschlagDto[] returnArray = new BestellvorschlagDto[list.size()]; return (BestellvorschlagDto[]) list.toArray(returnArray); } public void erstelleBestellvorschlagAnhandEinesAngebots(Integer angebotIId, java.sql.Date dLiefertermin, TheClientDto theClientDto) { loescheBestellvorlaegeEinesMandaten(theClientDto); try { AngebotpositionDto[] agposDtos = getAngebotpositionFac() .angebotpositionFindByAngebotIIdOhneAlternative(angebotIId, theClientDto); AngebotDto angebotDto = getAngebotFac().angebotFindByPrimaryKey(angebotIId, theClientDto); for (int i = 0; i < agposDtos.length; i++) { if (agposDtos[i].getArtikelIId() != null) { ArtikelDto artikelDto = getArtikelFac() .artikelFindByPrimaryKeySmall(agposDtos[i].getArtikelIId(), theClientDto); StuecklisteDto stklDto = getStuecklisteFac().stuecklisteFindByArtikelIIdMandantCNrOhneExc( agposDtos[i].getArtikelIId(), theClientDto.getMandant()); if (stklDto != null) { List<?> m = null; try { m = getStuecklisteFac().getStrukturDatenEinerStueckliste(stklDto.getIId(), theClientDto, StuecklisteReportFac.REPORT_STUECKLISTE_OPTION_SORTIERUNG_OHNE, 0, null, true, true, agposDtos[i].getNMenge(), null, false); } catch (RemoteException ex4) { throwEJBExceptionLPRespectOld(ex4); } Iterator<?> it = m.listIterator(); while (it.hasNext()) { StuecklisteMitStrukturDto struktur = (StuecklisteMitStrukturDto) it.next(); StuecklistepositionDto position = struktur.getStuecklistepositionDto(); bestellvorschlagDtoErzeugen(LocaleFac.BELEGART_ANGEBOT, theClientDto.getMandant(), position.getArtikelIId(), angebotDto.getIId(), null, new java.sql.Timestamp(dLiefertermin.getTime()), position.getNZielmenge().multiply(agposDtos[i].getNMenge()), angebotDto.getProjektIId(), theClientDto); } } else { if (Helper.short2boolean(artikelDto.getBLagerbewirtschaftet()) == true) { bestellvorschlagDtoErzeugen(LocaleFac.BELEGART_ANGEBOT, theClientDto.getMandant(), artikelDto.getIId(), angebotDto.getIId(), agposDtos[i].getIId(), new java.sql.Timestamp(dLiefertermin.getTime()), agposDtos[i].getNMenge(), angebotDto.getProjektIId(), theClientDto); } } } } } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } } public void erstelleBestellvorschlagAnhandStuecklistenmindestlagerstand(java.sql.Date dLiefertermin, TheClientDto theClientDto) { loescheBestellvorlaegeEinesMandaten(theClientDto); SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; HashMap<Integer, BigDecimal> hmArtikel = new HashMap<Integer, BigDecimal>(); session = factory.openSession(); String queryString = "SELECT stkl,(SELECT count(*) FROM FLRStuecklisteposition AS pos WHERE pos.flrartikel.i_id=stkl.flrartikel.i_id ) as anzstklpos FROM FLRStueckliste AS stkl WHERE stkl.mandant_c_nr='" + theClientDto.getMandant() + "' AND stkl.flrartikel.f_lagermindest > 0"; String sLocUI = Helper.locale2String(theClientDto.getLocUi()); session.enableFilter("filterLocale").setParameter("paramLocale", sLocUI); org.hibernate.Query query = session.createQuery(queryString); List<?> resultList = query.list(); Iterator<?> resultListIterator = resultList.iterator(); while (resultListIterator.hasNext()) { Object[] o = (Object[]) resultListIterator.next(); FLRStueckliste flrStueckliste = (FLRStueckliste) o[0]; long iAzahlinVerwendung = 0; if (o[1] != null) { iAzahlinVerwendung = (Long) o[1]; } if (iAzahlinVerwendung == 0) { // Dann ists eine Wurzelstueckliste // Diese nun aufloesen List<?> m = null; try { m = getStuecklisteFac().getStrukturDatenEinerStueckliste(flrStueckliste.getI_id(), theClientDto, StuecklisteReportFac.REPORT_STUECKLISTE_OPTION_SORTIERUNG_OHNE, 0, null, true, true, new BigDecimal(flrStueckliste.getFlrartikel().getF_lagermindest()), null, false); } catch (RemoteException ex4) { throwEJBExceptionLPRespectOld(ex4); } Iterator<?> it = m.listIterator(); while (it.hasNext()) { StuecklisteMitStrukturDto struktur = (StuecklisteMitStrukturDto) it.next(); StuecklistepositionDto position = struktur.getStuecklistepositionDto(); BigDecimal nBedarf = position.getNZielmenge(); if (hmArtikel.containsKey(position.getArtikelIId())) { nBedarf = nBedarf.add(hmArtikel.get(position.getArtikelIId())); } hmArtikel.put(position.getArtikelIId(), nBedarf); } } } closeSession(session); // Nun alle Artikel, welche noch nicht in der Liste sind, und einen // Lagermindeststand haben, hinzufuegen session = factory.openSession(); queryString = "SELECT a, (SELECT stkl FROM FLRStueckliste AS stkl WHERE stkl.mandant_c_nr=a.mandant_c_nr AND stkl.artikel_i_id=a.i_id) FROM FLRArtikel AS a WHERE a.mandant_c_nr='" + theClientDto.getMandant() + "' AND a.f_lagermindest > 0 AND a.b_lagerbewirtschaftet=1"; query = session.createQuery(queryString); resultList = query.list(); resultListIterator = resultList.iterator(); while (resultListIterator.hasNext()) { Object[] o = (Object[]) resultListIterator.next(); FLRArtikel a = (FLRArtikel) o[0]; FLRStueckliste s = (FLRStueckliste) o[1]; if (!hmArtikel.containsKey(a.getI_id())) { if (s == null || Helper.short2boolean(s.getB_fremdfertigung()) == true) { hmArtikel.put(a.getI_id(), new BigDecimal(a.getF_lagermindest())); } } } closeSession(session); try { LagerDto[] lagerDto = getLagerFac().lagerFindByMandantCNr(theClientDto.getMandant()); Iterator<Integer> it = hmArtikel.keySet().iterator(); while (it.hasNext()) { Integer artikelIId = it.next(); ArtikelDto aDto = getArtikelFac().artikelFindByPrimaryKeySmall(artikelIId, theClientDto); if (Helper.short2boolean(aDto.getBLagerbewirtschaftet())) { BigDecimal nBedarf = hmArtikel.get(artikelIId); // Nun bei allen Artikel die // Lagerstaende/In-Fertigung/Bestellt // abziehen BigDecimal bdBestellt = getArtikelbestelltFac().getAnzahlBestellt(artikelIId); BigDecimal bdInFertigung = getFertigungFac().getAnzahlInFertigung(artikelIId, theClientDto); BigDecimal bdLagerstand = new BigDecimal(0); for (int j = 0; j < lagerDto.length; j++) { if (Helper.short2boolean(lagerDto[j].getBBestellvorschlag())) { bdLagerstand = bdLagerstand.add( getLagerFac().getLagerstand(artikelIId, lagerDto[j].getIId(), theClientDto)); } } // Wenn groesser 0, dann bestellen BigDecimal diff = nBedarf.subtract(bdBestellt).subtract(bdInFertigung).subtract(bdLagerstand); if (diff.doubleValue() > 0) { bestellvorschlagDtoErzeugen(null, theClientDto.getMandant(), artikelIId, null, null, new java.sql.Timestamp(dLiefertermin.getTime()), diff, null, theClientDto); } } } } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } } /** * METHODE VON CK * * @param iVorlaufzeit * Integer * @param dateFuerEintraegeOhneLiefertermin * Date * @param theClientDto * String */ @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public void erstelleBestellvorschlag(Integer iVorlaufzeit, Integer iToleranz, java.sql.Date dateFuerEintraegeOhneLiefertermin, ArrayList<Integer> arLosIId, ArrayList<Integer> arAuftragIId, boolean bMitNichtlagerbewirtschafteten, boolean bNurLospositionenBeruecksichtigen, TheClientDto theClientDto) { // alten bestellvorschlag loeschen loescheBestellvorlaegeEinesMandaten(theClientDto); Session session = null; try { // Wenn auftragsIId angebeben werden, dann deren Los suchen if (arAuftragIId != null) { for (int i = 0; i < arAuftragIId.size(); i++) { LosDto[] losDtos = getFertigungFac().losFindByAuftragIId(arAuftragIId.get(i)); for (int j = 0; j < losDtos.length; j++) { if (arLosIId == null) { arLosIId = new ArrayList<Integer>(); } arLosIId.add(losDtos[j].getIId()); } } } // Wenn losIIds vorhanden dann nur die Artikel dieser Lose ArrayList<Integer> arArtikelIIds = new ArrayList<Integer>(); if (arLosIId != null) { if (arLosIId.size() > 0) { Object[] oLosIId = new Object[arLosIId.size()]; oLosIId = arLosIId.toArray(); session = FLRSessionFactory.getFactory().openSession(); org.hibernate.Criteria critLose = session.createCriteria(FLRLos.class); critLose.add(Restrictions.in(FertigungFac.FLR_LOS_I_ID, oLosIId)); List<?> resultListLose = critLose.list(); Iterator<?> resultListLoseIterator = resultListLose.iterator(); while (resultListLoseIterator.hasNext()) { FLRLos los = (FLRLos) resultListLoseIterator.next(); LossollmaterialDto[] material = getFertigungFac() .lossollmaterialFindByLosIId(los.getI_id()); for (int i = 0; i < material.length; i++) { if (material[i].getArtikelIId() != null) { arArtikelIIds.add(material[i].getArtikelIId()); } } } } closeSession(session); } // Alle Lagerbewirtschafteten Artikel holen session = FLRSessionFactory.getFactory().openSession(); org.hibernate.Criteria crit = session.createCriteria(FLRArtikel.class); // Filter nach Mandant crit.add(Restrictions.eq(ArtikelFac.FLR_ARTIKEL_MANDANT_C_NR, theClientDto.getMandant())); // keine Hand- und AZ-Artikel crit.add(Restrictions.not(Restrictions.in(ArtikelFac.FLR_ARTIKELLISTE_ARTIKELART_C_NR, new String[] { ArtikelFac.ARTIKELART_HANDARTIKEL, ArtikelFac.ARTIKELART_ARBEITSZEIT }))); if (bMitNichtlagerbewirtschafteten == false) { // nur lagerbewirtschaftete crit.add(Restrictions.eq(ArtikelFac.FLR_ARTIKEL_B_LAGERBEWIRTSCHAFTET, Helper.boolean2Short(true))); } // Zusaetlich nach Losen wenn Materialien vorhanden if (arArtikelIIds.size() > 0) { Object[] oArtikelIIds = arArtikelIIds.toArray(); crit.add(Restrictions.in(ArtikelFac.FLR_ARTIKEL_I_ID, oArtikelIIds)); } List<?> resultList = crit.list(); Iterator<?> resultListIterator = resultList.iterator(); while (resultListIterator.hasNext()) { FLRArtikel artikel = (FLRArtikel) resultListIterator.next(); if (Helper.short2boolean(artikel.getB_lagerbewirtschaftet())) { // Ist dieser Artikel eine Stueckliste? StuecklisteDto stuecklisteDto = getStuecklisteFac() .stuecklisteFindByMandantCNrArtikelIIdOhneExc(artikel.getI_id(), theClientDto); if (stuecklisteDto != null && Helper.short2boolean(stuecklisteDto.getBFremdfertigung()) == false) { // selbstgefertigte Stuecklisten werden im BV nicht // beruecksichtigt. } else { ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKey(artikel.getI_id(), theClientDto); ArtklaDto artklsDto = null; if (artikelDto.getArtklaIId() != null) { artklsDto = getArtikelFac().artklaFindByPrimaryKey(artikelDto.getArtklaIId(), theClientDto); } if (artklsDto != null && Helper.short2boolean(artklsDto.getBTops()) == true) { // Keine tops artikel } else { // Wenn keine Stueckliste, bzw. Fremdgefertigte // Stueckliste, dann ArrayList<?> al = null; if (bNurLospositionenBeruecksichtigen == true) { al = getInternebestellungFac().berechneBedarfe(artikelDto, iVorlaufzeit, iToleranz, dateFuerEintraegeOhneLiefertermin, false, theClientDto, arLosIId); } else { al = getInternebestellungFac().berechneBedarfe(artikelDto, iVorlaufzeit, iToleranz, dateFuerEintraegeOhneLiefertermin, false, theClientDto, null); } MaterialbedarfDto[] materialbedarf = new MaterialbedarfDto[al.size()]; materialbedarf = (MaterialbedarfDto[]) al.toArray(materialbedarf); for (int i = 0; i < materialbedarf.length; i++) { bestellvorschlagDtoErzeugen(materialbedarf[i].getSBelegartCNr(), artikel.getMandant_c_nr(), artikel.getI_id(), materialbedarf[i].getIBelegIId(), materialbedarf[i].getIBelegpositionIId(), new java.sql.Timestamp(materialbedarf[i].getTTermin().getTime()), materialbedarf[i].getNMenge(), materialbedarf[i].getProjektIId(), theClientDto); } } } } else { if (bMitNichtlagerbewirtschafteten == true) { BigDecimal stdMenge = new BigDecimal(0); ArtikellieferantDto[] dtos = getArtikelFac() .artikellieferantFindByArtikelIId(artikel.getI_id(), theClientDto); if (dtos != null && dtos.length > 0 && dtos[0].getFStandardmenge() != null) { stdMenge = new BigDecimal(dtos[0].getFStandardmenge()); } bestellvorschlagDtoErzeugen(null, artikel.getMandant_c_nr(), artikel.getI_id(), null, null, new java.sql.Timestamp(dateFuerEintraegeOhneLiefertermin.getTime()), stdMenge, null, theClientDto); } } } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } finally { closeSession(session); } } @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public void bestellvorschlagInLiefergruppenanfragenUmwandeln(String projekt, TheClientDto theClientDto) { // Liefergruppen HashMap<Integer, ArrayList<FLRBestellvorschlag>> liefergruppen = new HashMap<Integer, ArrayList<FLRBestellvorschlag>>(); Session session = FLRSessionFactory.getFactory().openSession(); String queryString = "SELECT bv" + " FROM FLRBestellvorschlag AS bv " + " ORDER BY bv.flrartikel.flrliefergruppe.i_id ASC WHERE bv.flrartikel.flrliefergruppe.i_id IS NOT NULL "; org.hibernate.Query hqlquery = session.createQuery(queryString); List<FLRBestellvorschlag> resultList = hqlquery.list(); Iterator<FLRBestellvorschlag> resultListIterator = resultList.iterator(); while (resultListIterator.hasNext()) { FLRBestellvorschlag bv = resultListIterator.next(); if (bv.getFlrartikel().getFlrliefergruppe() != null) { ArrayList<FLRBestellvorschlag> alArtikel = null; if (liefergruppen.containsKey(bv.getFlrartikel().getFlrliefergruppe().getI_id())) { alArtikel = liefergruppen.get(bv.getFlrartikel().getFlrliefergruppe().getI_id()); } else { alArtikel = new ArrayList<FLRBestellvorschlag>(); } alArtikel.add(bv); liefergruppen.put(bv.getFlrartikel().getFlrliefergruppe().getI_id(), alArtikel); } } KostenstelleDto kostenstelleDto = getPersonalFac() .personalFindByPrimaryKey(theClientDto.getIDPersonal(), theClientDto).getKostenstelleDto_Stamm(); Iterator<Integer> liefergrupenIds = liefergruppen.keySet().iterator(); while (liefergrupenIds.hasNext()) { Integer liefergruppeIId = liefergrupenIds.next(); ArrayList<FLRBestellvorschlag> alArtikel = liefergruppen.get(liefergruppeIId); AnfrageDto anfrageDto = new AnfrageDto(); anfrageDto.setMandantCNr(theClientDto.getMandant()); anfrageDto.setCBez(projekt); anfrageDto.setLiefergruppeIId(liefergruppeIId); anfrageDto.setFWechselkursmandantwaehrungzubelegwaehrung(1D); anfrageDto.setFAllgemeinerRabattsatz(0D); anfrageDto.setNTransportkosteninanfragewaehrung(new BigDecimal(0)); anfrageDto.setWaehrungCNr(theClientDto.getSMandantenwaehrung()); anfrageDto.setTBelegdatum(Helper.cutTimestamp(new Timestamp(System.currentTimeMillis()))); anfrageDto.setStatusCNr(AnfrageServiceFac.ANFRAGESTATUS_ANGELEGT); anfrageDto.setArtCNr(AnfrageServiceFac.ANFRAGEART_LIEFERGRUPPE); anfrageDto.setBelegartCNr(LocaleFac.BELEGART_ANFRAGE); anfrageDto.setKostenstelleIId(kostenstelleDto.getIId()); Integer anfrageIId = getAnfrageFac().createAnfrage(anfrageDto, theClientDto); for (int i = 0; i < alArtikel.size(); i++) { FLRBestellvorschlag bv = alArtikel.get(i); AnfragepositionDto anfragepositionDto = new AnfragepositionDto(); anfragepositionDto.setBelegIId(anfrageIId); anfragepositionDto.setArtikelIId(bv.getArtikel_i_id()); anfragepositionDto.setPositionsartCNr(AnfrageServiceFac.ANFRAGEPOSITIONART_IDENT); anfragepositionDto.setNMenge(bv.getN_zubestellendemenge()); anfragepositionDto.setEinheitCNr(bv.getFlrartikel().getEinheit_c_nr()); anfragepositionDto.setNRichtpreis(new BigDecimal(0)); anfragepositionDto.setBArtikelbezeichnunguebersteuert(Helper.boolean2Short(false)); getAnfragepositionFac().createAnfrageposition(anfragepositionDto, theClientDto); try { getBestellvorschlagFac().removeBestellvorschlag(bv.getI_id()); } catch (Exception e) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEIM_LOESCHEN, "Bestellvorschlag ID=" + bv.getI_id()); } } } session.close(); } public void artikellieferantZuruecksetzen(ArrayList<Integer> bestellvorschlagIIds, TheClientDto theClientDto) { for (int i = 0; i < bestellvorschlagIIds.size(); i++) { Bestellvorschlag bestellvorschlag = em.find(Bestellvorschlag.class, bestellvorschlagIIds.get(i)); ArtikellieferantDto[] artLiefDto = getArtikelFac() .artikellieferantFindByArtikelIId(bestellvorschlag.getArtikelIId(), theClientDto); if (artLiefDto != null && artLiefDto.length > 0) { bestellvorschlag.setLieferantIId(artLiefDto[0].getLieferantIId()); } } } public void bestellvorschlagDtoErzeugen(String belegartCNr, String mandantCNr, Integer artikelIId, Integer belegIId, Integer belegpositionIId, java.sql.Timestamp tTermin, BigDecimal nMenge, Integer projektIId, TheClientDto theClientDto) { BestellvorschlagDto bestellvorschlagDto = new BestellvorschlagDto(); bestellvorschlagDto.setCBelegartCNr(belegartCNr); bestellvorschlagDto.setCMandantCNr(mandantCNr); bestellvorschlagDto.setIArtikelId(artikelIId); bestellvorschlagDto.setIBelegartId(belegIId); bestellvorschlagDto.setIBelegartpositionid(belegpositionIId); bestellvorschlagDto.setTLiefertermin(tTermin); bestellvorschlagDto.setNZubestellendeMenge(nMenge); bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(false)); bestellvorschlagDto.setProjektIId(projektIId); // Einkaufspreis des ersten Lieferanten in // Mandantenwaehrung ArtikellieferantDto[] artLiefDto = getArtikelFac().artikellieferantFindByArtikelIId(artikelIId, theClientDto); if (artLiefDto != null) { Integer iKleinsterIsort = null; for (int y = 0; y < artLiefDto.length; y++) { if (iKleinsterIsort == null) { iKleinsterIsort = y; } else { if (artLiefDto[iKleinsterIsort].getISort().intValue() > artLiefDto[y].getISort().intValue()) { iKleinsterIsort = y; } } } ArtikellieferantDto helper = new ArtikellieferantDto(); if (iKleinsterIsort != null) { helper = artLiefDto[iKleinsterIsort]; ArtikellieferantDto helper2 = getArtikelFac().getArtikelEinkaufspreis(artikelIId, helper.getLieferantIId(), nMenge, theClientDto.getSMandantenwaehrung(), null, theClientDto); bestellvorschlagDto.setILieferantId(helper.getLieferantIId()); if (helper2 != null) { bestellvorschlagDto.setNNettoeinzelpreis(helper2.getNEinzelpreis()); bestellvorschlagDto.setNNettogesamtpreis(helper2.getNNettopreis()); bestellvorschlagDto.setDRabattsatz(helper2.getFRabatt()); if (helper2.getNEinzelpreis() != null && helper2.getFRabatt() != null) { bestellvorschlagDto.setNRabattbetrag(Helper.rundeKaufmaennisch(helper2.getNEinzelpreis() .multiply(new BigDecimal(helper2.getFRabatt()).movePointLeft(2)), 4)); } if (Helper.short2boolean(helper2.getBRabattbehalten())) { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(false)); } else { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(true)); } } else { bestellvorschlagDto.setNNettoeinzelpreis(helper.getNEinzelpreis()); bestellvorschlagDto.setNNettogesamtpreis(helper.getNNettopreis()); bestellvorschlagDto.setDRabattsatz(helper.getFRabatt()); if (helper.getNEinzelpreis() != null && helper.getFRabatt() != null) { bestellvorschlagDto.setNRabattbetrag(Helper.rundeKaufmaennisch(helper.getNEinzelpreis() .multiply(new BigDecimal(helper.getFRabatt()).movePointLeft(2)), 4)); } if (Helper.short2boolean(helper.getBRabattbehalten())) { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(false)); } else { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(true)); } } } } try { context.getBusinessObject(BestellvorschlagFac.class).createBestellvorschlag(bestellvorschlagDto, theClientDto); } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } } public void loescheBestellvorlaegeEinesMandaten(TheClientDto theClientDto) { Session session = FLRSessionFactory.getFactory().openSession(); try { String hqlDelete = "delete FLRBestellvorschlag where mandant_c_nr = :param1"; session.createQuery(hqlDelete).setString("param1", theClientDto.getMandant()).executeUpdate(); } finally { closeSession(session); } } private BestellvorschlagDto[] bereinigeBestellvorschlagVonVeraltenArtikeln(BestellvorschlagDto[] bvDtos, TheClientDto theClientDto) { boolean bRausfiltern = false; try { ParametermandantDto param = getParameterFac().getMandantparameter(theClientDto.getMandant(), ParameterFac.KATEGORIE_STUECKLISTE, ParameterFac.PARAMETER_STRUKTURIERTER_STKLIMPORT); if (param.getCWertAsObject() != null && ((Integer) param.getCWertAsObject()) == 1) { bRausfiltern = true; } } catch (RemoteException e) { throwEJBExceptionLPRespectOld(e); } if (bRausfiltern == true) { ArrayList<BestellvorschlagDto> alDaten = new ArrayList<BestellvorschlagDto>(); Object[] o = getBestellungReportFac().getGeaenderteArtikelDaten(theClientDto); HashMap hmVeralteteArtikel = (HashMap) o[0]; for (int i = 0; i < bvDtos.length; i++) { if (!hmVeralteteArtikel.containsKey(bvDtos[i].getIArtikelId())) { alDaten.add(bvDtos[i]); } } return (BestellvorschlagDto[]) alDaten.toArray(new BestellvorschlagDto[] {}); } else { return bvDtos; } } @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public Boolean createBESausBVfuerAlleLieferantenMitGleichenTermin(FilterKriterium[] fk, SortierKriterium[] ski, TheClientDto theClientDto, Integer kostenstelleIId, boolean bProjektklammerberuecksichtigen) { Boolean bool = new Boolean(true); try { // alle Lieferanten ArrayList<?> lieferantenIds = (ArrayList<?>) LieferantHandler .getFLRLieferantenliste(LieferantHandler.getQueryLieferantenliste()); for (int i = 0; i < lieferantenIds.size(); i++) { FilterKriterium[] fkneu = new FilterKriterium[2]; fkneu[0] = new FilterKriterium(BestellungFac.FLR_BESTELLUNG_FLRLIEFERANT + "." + "i_id", true, "'" + lieferantenIds.get(i) + "'", FilterKriterium.OPERATOR_EQUAL, false); fkneu[1] = new FilterKriterium(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_T_LIEFERTERMIN, true, "", FilterKriterium.OPERATOR_IS + " " + FilterKriterium.OPERATOR_NOT_NULL, false); BestellvorschlagDto[] aBestellvorschlagDto = BestellvorschlagHandler.getListeBestellvorschlaege( fkneu, ski, BestellvorschlagFac.BES_NACH_BV_FUER_JEDEN_LF_UND_GLEICHE_TERMIN); aBestellvorschlagDto = bereinigeBestellvorschlagVonVeraltenArtikeln(aBestellvorschlagDto, theClientDto); if (bProjektklammerberuecksichtigen == true) { HashMap<Integer, BestellvorschlagDto[]> hmNachProjektenGetrennt = trenneNachProjekten( aBestellvorschlagDto); Iterator itProjekte = hmNachProjektenGetrennt.keySet().iterator(); while (itProjekte.hasNext()) { BestellvorschlagDto[] bbDtos = hmNachProjektenGetrennt.get(itProjekte.next()); getBestellvorschlagFac().befuellenDerBestellungUndBestellposition(bbDtos, kostenstelleIId, theClientDto); } } else { getBestellvorschlagFac().befuellenDerBestellungUndBestellposition(aBestellvorschlagDto, kostenstelleIId, theClientDto); } } } catch (EJBExceptionLP e) { bool = new Boolean(false); } return bool; } @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public Boolean createBESausBVjeLieferant(FilterKriterium[] fk, SortierKriterium[] ski, TheClientDto theClientDto, Integer kostenstelleIId, boolean bProjektklammerberuecksichtigen) { // alle Lieferanten ArrayList<?> lieferantenIds = (ArrayList<?>) LieferantHandler .getFLRLieferantenliste(LieferantHandler.getQueryLieferantenliste()); for (int i = 0; i < lieferantenIds.size(); i++) { FilterKriterium[] fkneu = new FilterKriterium[1]; fkneu[0] = new FilterKriterium(BestellungFac.FLR_BESTELLUNG_FLRLIEFERANT + "." + "i_id", true, "'" + lieferantenIds.get(i) + "'", FilterKriterium.OPERATOR_EQUAL, false); BestellvorschlagDto[] aBestellvorschlagDto = BestellvorschlagHandler.getListeBestellvorschlaege(fkneu, ski, BestellvorschlagFac.BES_NACH_BV_FUER_JEDEN_LF); aBestellvorschlagDto = bereinigeBestellvorschlagVonVeraltenArtikeln(aBestellvorschlagDto, theClientDto); if (bProjektklammerberuecksichtigen == true) { HashMap<Integer, BestellvorschlagDto[]> hmNachProjektenGetrennt = trenneNachProjekten( aBestellvorschlagDto); Iterator itProjekte = hmNachProjektenGetrennt.keySet().iterator(); while (itProjekte.hasNext()) { BestellvorschlagDto[] bbDtos = hmNachProjektenGetrennt.get(itProjekte.next()); getBestellvorschlagFac().befuellenDerBestellungausBVfuerBestimmtenLieferant(bbDtos, kostenstelleIId, theClientDto); } } else { getBestellvorschlagFac().befuellenDerBestellungausBVfuerBestimmtenLieferant(aBestellvorschlagDto, kostenstelleIId, theClientDto); } } return new Boolean(true); } public Boolean createBESausBVfuerBestimmtenLieferantUndTermin(FilterKriterium[] fk, SortierKriterium[] ski, TheClientDto theClientDto, Integer kostenstelleIId, boolean bProjektklammerberuecksichtigen) { BestellvorschlagDto[] aBestellvorschlagDto = BestellvorschlagHandler.getListeBestellvorschlaege(fk, ski, BestellvorschlagFac.BES_NACH_BV_FUER_BESTIMMTEN_LF_UND_TERMIN); aBestellvorschlagDto = bereinigeBestellvorschlagVonVeraltenArtikeln(aBestellvorschlagDto, theClientDto); if (bProjektklammerberuecksichtigen == true) { HashMap<Integer, BestellvorschlagDto[]> hmNachProjektenGetrennt = trenneNachProjekten( aBestellvorschlagDto); Iterator itProjekte = hmNachProjektenGetrennt.keySet().iterator(); while (itProjekte.hasNext()) { BestellvorschlagDto[] bbDtos = hmNachProjektenGetrennt.get(itProjekte.next()); befuellenDerBestellungUndBestellposition(bbDtos, kostenstelleIId, theClientDto); } } else { befuellenDerBestellungUndBestellposition(aBestellvorschlagDto, kostenstelleIId, theClientDto); } return new Boolean(true); } @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public BestellungDto[] createBESausBVzuRahmen(FilterKriterium[] fk, SortierKriterium[] ski, TheClientDto theClientDto) throws EJBExceptionLP, RemoteException { BestellvorschlagDto[] aBestellvorschlagDto = BestellvorschlagHandler.getListeBestellvorschlaege(fk, ski, BestellvorschlagFac.BES_ABRUFE_ZU_RAHMEN); aBestellvorschlagDto = bereinigeBestellvorschlagVonVeraltenArtikeln(aBestellvorschlagDto, theClientDto); return getBestellvorschlagFac().erstelleAbrufbestellungenAusBV(aBestellvorschlagDto, theClientDto); } @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED) public Boolean createBESausBVfueBestimmtenLieferant(FilterKriterium[] fk, SortierKriterium[] ski, TheClientDto theClientDto, Integer kostenstelleIId, boolean bProjektklammerberuecksichtigen) { BestellvorschlagDto[] aBestellvorschlagDto = BestellvorschlagHandler.getListeBestellvorschlaege(fk, ski, BestellvorschlagFac.BES_NACH_BV_FUER_BESTIMMTEN_LF); aBestellvorschlagDto = bereinigeBestellvorschlagVonVeraltenArtikeln(aBestellvorschlagDto, theClientDto); if (bProjektklammerberuecksichtigen == true) { HashMap<Integer, BestellvorschlagDto[]> hmNachProjektenGetrennt = trenneNachProjekten( aBestellvorschlagDto); Iterator itProjekte = hmNachProjektenGetrennt.keySet().iterator(); while (itProjekte.hasNext()) { BestellvorschlagDto[] bbDtos = hmNachProjektenGetrennt.get(itProjekte.next()); getBestellvorschlagFac().befuellenDerBestellungausBVfuerBestimmtenLieferant(bbDtos, kostenstelleIId, theClientDto); } } else { getBestellvorschlagFac().befuellenDerBestellungausBVfuerBestimmtenLieferant(aBestellvorschlagDto, kostenstelleIId, theClientDto); } return new Boolean(true); } private HashMap<Integer, BestellvorschlagDto[]> trenneNachProjekten( BestellvorschlagDto[] aBestellvorschlagDto) { HashMap<Integer, ArrayList<BestellvorschlagDto>> hmGetrenntNachProjekten = new HashMap<Integer, ArrayList<BestellvorschlagDto>>(); for (int i = 0; i < aBestellvorschlagDto.length; i++) { Integer projektIId = aBestellvorschlagDto[i].getProjektIId(); ArrayList<BestellvorschlagDto> alBV = new ArrayList<BestellvorschlagDto>(); if (hmGetrenntNachProjekten.containsKey(projektIId)) { alBV = hmGetrenntNachProjekten.get(projektIId); } else { alBV = new ArrayList<BestellvorschlagDto>(); } alBV.add(aBestellvorschlagDto[i]); hmGetrenntNachProjekten.put(projektIId, alBV); } HashMap<Integer, BestellvorschlagDto[]> hmProjekte = new HashMap<Integer, BestellvorschlagDto[]>(); Iterator it = hmGetrenntNachProjekten.keySet().iterator(); while (it.hasNext()) { Integer projektIId = (Integer) it.next(); ArrayList<BestellvorschlagDto> alBV = hmGetrenntNachProjekten.get(projektIId); hmProjekte.put(projektIId, (BestellvorschlagDto[]) alBV.toArray(new BestellvorschlagDto[alBV.size()])); } return hmProjekte; } public void befuellenDerBestellungausBVfuerBestimmtenLieferant(BestellvorschlagDto[] aBestellvorschlagDto, Integer kostenstelleIId, TheClientDto theClientDto) throws EJBExceptionLP { try { // isort in Bestellposition int j = 0; MandantDto mandantDto = getMandantFac().mandantFindByPrimaryKey(theClientDto.getMandant(), theClientDto); boolean bBestellungAnlegen = true; Integer iIdBestellung = null; for (int i = 0; i < aBestellvorschlagDto.length; i++) { // anlegen der Bestellung LieferantDto lieferantDto = getLieferantFac() .lieferantFindByPrimaryKey(aBestellvorschlagDto[0].getILieferantId(), theClientDto); BigDecimal wechselkurs = getLocaleFac().getWechselkurs2(mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), theClientDto); if (bBestellungAnlegen == true) { BestellungDto bestellungDto = new BestellungDto(); AnsprechpartnerDto ansprechpartnerDto[] = getAnsprechpartnerFac() .ansprechpartnerFindByAnsprechpartnerIId(lieferantDto.getPartnerIId(), theClientDto); if (ansprechpartnerDto.length > 0) { bestellungDto.setAnsprechpartnerIId(ansprechpartnerDto[0].getIId()); } PersonalDto anfordererDto = getPersonalFac() .personalFindByPrimaryKey(theClientDto.getIDPersonal(), theClientDto); bestellungDto.setPersonalIIdAnforderer(anfordererDto.getIId()); bestellungDto.setPersonalIIdAendern(theClientDto.getIDPersonal()); bestellungDto.setPersonalIIdAnlegen(theClientDto.getIDPersonal()); bestellungDto.setProjektIId(aBestellvorschlagDto[0].getProjektIId()); bestellungDto.setZahlungszielIId(lieferantDto.getZahlungszielIId()); bestellungDto.setBelegartCNr(LocaleFac.BELEGART_BESTELLUNG); // bestellungDto.setBestelltextIIdFusstext(); // bestellungDto.setBestelltextIIdKopftext(); bestellungDto.setBestellungartCNr(BestellungFac.BESTELLUNGART_FREIE_BESTELLUNG_C_NR); bestellungDto.setStatusCNr(BestellungFac.BESTELLSTATUS_ANGELEGT); ParametermandantDto parameterDto = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_BESTELLUNG, ParameterFac.PARAMETER_DEFAULT_TEILLIEFERUNG); bestellungDto.setBTeillieferungMoeglich( Helper.boolean2Short((Boolean) parameterDto.getCWertAsObject())); bestellungDto.setDBelegdatum(this.getDate()); bestellungDto.setDLiefertermin(aBestellvorschlagDto[0].getTLiefertermin()); bestellungDto.setKostenstelleIId(kostenstelleIId); bestellungDto.setLieferantIIdBestelladresse(lieferantDto.getIId()); bestellungDto.setLieferantIIdRechnungsadresse(lieferantDto.getIId()); // Default Lieferadresse ist die Adresse des aktuellen // Mandanten Integer iPartnerIIdLIeferadresse = getMandantFac() .mandantFindByPrimaryKey(theClientDto.getMandant(), theClientDto) .getPartnerIIdLieferadresse(); bestellungDto.setPartnerIIdLieferadresse(iPartnerIIdLIeferadresse); bestellungDto.setSpediteurIId(lieferantDto.getIdSpediteur()); bestellungDto.setMandantCNr(mandantDto.getCNr()); bestellungDto.setLieferartIId(lieferantDto.getLieferartIId()); bestellungDto.setWaehrungCNr(lieferantDto.getWaehrungCNr()); bestellungDto.setFAllgemeinerRabattsatz(new Double(0)); bestellungDto .setFWechselkursmandantwaehrungzubelegwaehrung(new Double(wechselkurs.doubleValue())); iIdBestellung = getBestellungFac().createBestellung(bestellungDto, theClientDto); bBestellungAnlegen = false; } // Positionen anlegen. BestellpositionDto bestellpositionDto = new BestellpositionDto(); ArtikelDto artikelDto = getArtikelFac() .artikelFindByPrimaryKey(aBestellvorschlagDto[i].getIArtikelId(), theClientDto); bestellpositionDto.setBNettopreisuebersteuert(Helper.boolean2Short(false)); bestellpositionDto.setArtikelIId(aBestellvorschlagDto[i].getIArtikelId()); bestellpositionDto.setBDrucken(Helper.boolean2Short(false)); bestellpositionDto.setPositionsartCNr(BestellpositionFac.BESTELLPOSITIONART_IDENT); bestellpositionDto.setBestellpositionstatusCNr(BestellpositionFac.BESTELLPOSITIONSTATUS_OFFEN); bestellpositionDto.setBestellungIId(iIdBestellung); bestellpositionDto.setCBez(artikelDto.getArtikelsprDto().getCBez()); bestellpositionDto.setISort(new Integer(j++)); bestellpositionDto.setEinheitCNr(artikelDto.getEinheitCNr()); bestellpositionDto.setNMenge(aBestellvorschlagDto[i].getNZubestellendeMenge()); if (aBestellvorschlagDto[i].getCBelegartCNr() != null && aBestellvorschlagDto[i].getCBelegartCNr().equals(LocaleFac.BELEGART_LOS) && aBestellvorschlagDto[i].getIBelegartpositionid() != null) { LossollmaterialDto lossollmaterialDto = getFertigungFac() .lossollmaterialFindByPrimaryKeyOhneExc( aBestellvorschlagDto[i].getIBelegartpositionid()); if (lossollmaterialDto != null) { bestellpositionDto.setLossollmaterialIId(aBestellvorschlagDto[i].getIBelegartpositionid()); } } bestellpositionDto.setNMaterialzuschlag(new BigDecimal(0)); if (artikelDto.getMaterialIId() != null) { BigDecimal zuschlag = getMaterialFac() .materialzuschlagFindAktuellenzuschlag(artikelDto.getMaterialIId(), theClientDto); if (zuschlag != null) { bestellpositionDto.setNMaterialzuschlag(zuschlag); if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null) { BigDecimal nettogesamtpreis = aBestellvorschlagDto[i].getNNettoeinzelpreis(); if (aBestellvorschlagDto[i].getNRabattbetrag() != null) { nettogesamtpreis = nettogesamtpreis .subtract(aBestellvorschlagDto[i].getNRabattbetrag()); } nettogesamtpreis = nettogesamtpreis.add(zuschlag); aBestellvorschlagDto[i].setNNettogesamtpreis(nettogesamtpreis); } } } if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null) { bestellpositionDto.setNNettoeinzelpreis(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNNettoeinzelpreis(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNNettoeinzelpreis(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNNettogesamtpreis() != null) { bestellpositionDto.setNNettogesamtpreis(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNNettogesamtpreis(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNNettogesamtpreis(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNRabattbetrag() != null) { bestellpositionDto.setNRabattbetrag(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNRabattbetrag(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNRabattbetrag(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null && !(aBestellvorschlagDto[i].getNNettoeinzelpreis().compareTo(new BigDecimal(0)) == 0)) { bestellpositionDto.setDRabattsatz(new Double(new BigDecimal(100) .subtract(Helper.calculateRatioInDecimal(aBestellvorschlagDto[i].getNRabattbetrag(), aBestellvorschlagDto[i].getNNettoeinzelpreis())) .doubleValue())); } else { bestellpositionDto.setDRabattsatz(new Double(0)); } bestellpositionDto.setBNettopreisuebersteuert(aBestellvorschlagDto[i].getBNettopreisuebersteuert()); bestellpositionDto.setTUebersteuerterLiefertermin(aBestellvorschlagDto[i].getTLiefertermin()); getBestellpositionFac().createBestellposition(bestellpositionDto, theClientDto, BestellpositionFac.PREISPFLEGEARTIKELLIEFERANT_PREIS_UNVERAENDERT, null); this.removeBestellvorschlag(aBestellvorschlagDto[i]); } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } } public BestellungDto[] erstelleAbrufbestellungenAusBV(BestellvorschlagDto[] bestellvorschlagDto, TheClientDto theClientDto) throws EJBExceptionLP, RemoteException { Session session = FLRSessionFactory.getFactory().openSession(); try { ArrayList<Integer> alUeberlieferteBestellungIId = new ArrayList<Integer>(); HashMap<Integer, Integer> hmAbrufeZuRahmen = new HashMap<Integer, Integer>(); for (int i = 0; i < bestellvorschlagDto.length; i++) { boolean bUebergeleitet = false; if (bestellvorschlagDto[i].getILieferantId() != null) { BigDecimal bdZuBestellendeMenge = bestellvorschlagDto[i].getNZubestellendeMenge(); Criteria besPos = session.createCriteria(FLRBestellposition.class); Criteria best = besPos.createCriteria(BestellpositionFac.FLR_BESTELLPOSITION_FLRBESTELLUNG); Criteria artikel = besPos.createCriteria(BestellpositionFac.FLR_BESTELLPOSITION_FLRARTIKEL); // Filter auf den Mandanten best.add(Restrictions.eq(BestellungFac.FLR_BESTELLUNG_MANDANT_C_NR, theClientDto.getMandant())); // nur Rahmenbestellungen. best.add(Restrictions.eq(BestellungFac.FLR_BESTELLUNG_BESTELLUNGART_C_NR, BestellungFac.BESTELLUNGART_RAHMENBESTELLUNG_C_NR)); // Einschraenkung nach Status Offen, Erledigt Collection<String> cStati = new LinkedList<String>(); cStati.add(BestellungFac.BESTELLSTATUS_TEILERLEDIGT); cStati.add(BestellungFac.BESTELLSTATUS_BESTAETIGT); cStati.add(BestellungFac.BESTELLSTATUS_OFFEN); best.add(Restrictions.in(BestellungFac.FLR_BESTELLUNG_BESTELLUNGSTATUS_C_NR, cStati)); best.add(Restrictions.eq(BestellungFac.FLR_BESTELLUNG_LIEFERANT_I_ID_BESTELLADRESSE, bestellvorschlagDto[i].getILieferantId())); besPos.add(Restrictions.gt(BestellpositionFac.FLR_BESTELLPOSITION_N_OFFENEMENGE, new BigDecimal(0))); artikel.add( Restrictions.eq(ArtikelFac.FLR_ARTIKEL_I_ID, bestellvorschlagDto[i].getIArtikelId())); // Sortierung damit die aelteren Rahmen zuerst abgerufen // werden best.addOrder(Order.desc(BestellungFac.FLR_BESTELLUNG_T_LIEFERTERMIN)); // Query ausfuehren List<?> besposList = besPos.list(); Iterator<?> besposListIterator = besposList.iterator(); boolean bMengeGenuegt = false; ArrayList<Integer> alVerwendeteBesPosIId = new ArrayList<Integer>(); while (besposListIterator.hasNext() && !bMengeGenuegt) { FLRBestellposition bespos = (FLRBestellposition) besposListIterator.next(); if (bdZuBestellendeMenge.compareTo(bespos.getN_offenemenge()) < 0) { bMengeGenuegt = true; } else { bdZuBestellendeMenge = bdZuBestellendeMenge.subtract(bespos.getN_offenemenge()); } alVerwendeteBesPosIId.add(bespos.getI_id()); } // Jetzt haben wir eine Liste aller Rahmenpositionen die // verwendet werden sollen. BigDecimal bdBereitsBestellteMenge = new BigDecimal(0); for (int y = 0; y < alVerwendeteBesPosIId.size(); y++) { BestellpositionDto besPosDto = getBestellpositionFac() .bestellpositionFindByPrimaryKey(alVerwendeteBesPosIId.get(y)); BestellungDto abrufBestellungDto = null; if (hmAbrufeZuRahmen.containsKey(besPosDto.getBelegIId())) { abrufBestellungDto = getBestellungFac() .bestellungFindByPrimaryKey(hmAbrufeZuRahmen.get(besPosDto.getBelegIId())); } BestellungDto rahmenBestellungDto = getBestellungFac() .bestellungFindByPrimaryKey(besPosDto.getBelegIId()); boolean bAbrufvorhanden = false; // wenn wir bereits durch einen anderen Bestellvorschlag // einen Abruf fuer diesen Lieferanten mit diesem // Liefertermin angelegt haben if (abrufBestellungDto != null) { if (abrufBestellungDto.getDLiefertermin() .equals(bestellvorschlagDto[i].getTLiefertermin())) { bAbrufvorhanden = true; } } if (!bAbrufvorhanden) { // Wir haben fuer diese Bestellung noch keinen Abruf // und legen diesen an MandantDto mandantDto = getMandantFac() .mandantFindByPrimaryKey(theClientDto.getMandant(), theClientDto); // Wechselkurs ist immer der aktuelle BigDecimal wechselkurs = getLocaleFac().getWechselkurs2( rahmenBestellungDto.getWaehrungCNr(), mandantDto.getWaehrungCNr(), theClientDto); abrufBestellungDto = new BestellungDto(); abrufBestellungDto.setFWechselkursmandantwaehrungzubelegwaehrung( new Double(wechselkurs.doubleValue())); abrufBestellungDto .setPersonalIIdAnforderer(rahmenBestellungDto.getPersonalIIdAnforderer()); abrufBestellungDto.setPersonalIIdAendern(theClientDto.getIDPersonal()); abrufBestellungDto.setPersonalIIdAnlegen(theClientDto.getIDPersonal()); abrufBestellungDto.setZahlungszielIId(rahmenBestellungDto.getZahlungszielIId()); abrufBestellungDto.setBelegartCNr(LocaleFac.BELEGART_BESTELLUNG); abrufBestellungDto .setBestellungartCNr(BestellungFac.BESTELLUNGART_ABRUFBESTELLUNG_C_NR); abrufBestellungDto.setStatusCNr(BestellungFac.BESTELLSTATUS_ANGELEGT); abrufBestellungDto.setIBestellungIIdRahmenbestellung(rahmenBestellungDto.getIId()); abrufBestellungDto .setBTeillieferungMoeglich(rahmenBestellungDto.getBTeillieferungMoeglich()); abrufBestellungDto.setDBelegdatum(this.getDate()); abrufBestellungDto.setDLiefertermin(bestellvorschlagDto[i].getTLiefertermin()); abrufBestellungDto.setKostenstelleIId(rahmenBestellungDto.getKostenstelleIId()); abrufBestellungDto.setLieferantIIdBestelladresse( rahmenBestellungDto.getLieferantIIdBestelladresse()); abrufBestellungDto.setLieferantIIdRechnungsadresse( rahmenBestellungDto.getLieferantIIdRechnungsadresse()); abrufBestellungDto.setSpediteurIId(rahmenBestellungDto.getSpediteurIId()); abrufBestellungDto.setMandantCNr(mandantDto.getCNr()); abrufBestellungDto.setLieferartIId(rahmenBestellungDto.getLieferartIId()); abrufBestellungDto.setWaehrungCNr(rahmenBestellungDto.getWaehrungCNr()); abrufBestellungDto .setFAllgemeinerRabattsatz(rahmenBestellungDto.getFAllgemeinerRabattsatz()); Integer iAbrufBEstellungIId = getBestellungFac().createBestellung(abrufBestellungDto, theClientDto); abrufBestellungDto = getBestellungFac().bestellungFindByPrimaryKey(iAbrufBEstellungIId); hmAbrufeZuRahmen.put(besPosDto.getBelegIId(), abrufBestellungDto.getIId()); } // Bestellung wurde nun angelgt oder war bereits // vorhanden // Jetzt die Position anlegen oder updaten BestellpositionDto[] vorhandeneAbrufe = getBestellpositionFac() .bestellpositionFindByBestellung(abrufBestellungDto.getIId(), theClientDto); BestellpositionDto abrufBestellpositionDto = null; for (int x = 0; x < vorhandeneAbrufe.length; x++) { if (bestellvorschlagDto[i].getIArtikelId() .equals(vorhandeneAbrufe[x].getArtikelIId())) { abrufBestellpositionDto = vorhandeneAbrufe[x]; } } BigDecimal bdbenoetigteMenge = bestellvorschlagDto[i].getNZubestellendeMenge() .subtract(bdBereitsBestellteMenge); BigDecimal bdAbrufmenge; if (bdbenoetigteMenge.compareTo(besPosDto.getNOffeneMenge()) > 0) { if (y == alVerwendeteBesPosIId.size() - 1) { // Letzte Pos, also wird ueberliefert bdAbrufmenge = bdbenoetigteMenge; if (!alUeberlieferteBestellungIId.contains(besPosDto.getBelegIId())) { alUeberlieferteBestellungIId.add(besPosDto.getBelegIId()); } } else { bdAbrufmenge = besPosDto.getNOffeneMenge(); } } else { bdAbrufmenge = bdbenoetigteMenge; } if (abrufBestellpositionDto == null) { abrufBestellpositionDto = new BestellpositionDto(); abrufBestellpositionDto.setNMenge(bdAbrufmenge); bdbenoetigteMenge = bdbenoetigteMenge.subtract(bdAbrufmenge); ArtikelDto artikelDto = getArtikelFac() .artikelFindByPrimaryKey(bestellvorschlagDto[i].getIArtikelId(), theClientDto); abrufBestellpositionDto.setIBestellpositionIIdRahmenposition(besPosDto.getIId()); abrufBestellpositionDto.setArtikelIId(bestellvorschlagDto[i].getIArtikelId()); abrufBestellpositionDto.setBDrucken(Helper.boolean2Short(false)); abrufBestellpositionDto.setPositionsartCNr(BestellpositionFac.BESTELLPOSITIONART_IDENT); abrufBestellpositionDto .setBestellpositionstatusCNr(BestellpositionFac.BESTELLPOSITIONSTATUS_OFFEN); abrufBestellpositionDto.setBestellungIId(abrufBestellungDto.getIId()); abrufBestellpositionDto.setCBez(artikelDto.getArtikelsprDto().getCBez()); // bestellpositionDto.setISort(new Integer(j++)); abrufBestellpositionDto.setEinheitCNr(artikelDto.getEinheitCNr()); abrufBestellpositionDto.setNNettoeinzelpreis(besPosDto.getNNettoeinzelpreis()); abrufBestellpositionDto.setNNettogesamtpreis(besPosDto.getNNettogesamtpreis()); abrufBestellpositionDto.setNRabattbetrag(besPosDto.getNRabattbetrag()); abrufBestellpositionDto.setDRabattsatz(besPosDto.getDRabattsatz()); abrufBestellpositionDto.setNMaterialzuschlag(besPosDto.getNMaterialzuschlag()); abrufBestellpositionDto .setBNettopreisuebersteuert(besPosDto.getBNettopreisuebersteuert()); abrufBestellpositionDto .setTUebersteuerterLiefertermin(bestellvorschlagDto[i].getTLiefertermin()); getBestellpositionFac().createAbrufbestellposition(abrufBestellpositionDto, BestellpositionFac.PREISPFLEGEARTIKELLIEFERANT_PREIS_UNVERAENDERT, null, theClientDto); } else { BigDecimal bdMenge = bdAbrufmenge.add(abrufBestellpositionDto.getNMenge()); abrufBestellpositionDto.setNMenge(bdMenge); bdbenoetigteMenge = bdbenoetigteMenge.subtract(bdMenge); getBestellpositionFac().updateAbrufbestellposition(abrufBestellpositionDto, BestellpositionFac.PREISPFLEGEARTIKELLIEFERANT_PREIS_UNVERAENDERT, null, theClientDto); } bUebergeleitet = true; } if (bUebergeleitet) { this.removeBestellvorschlag(bestellvorschlagDto[i]); } } } BestellungDto[] toReturn = new BestellungDto[alUeberlieferteBestellungIId.size()]; for (int x = 0; x < alUeberlieferteBestellungIId.size(); x++) { toReturn[x] = getBestellungFac().bestellungFindByPrimaryKey(alUeberlieferteBestellungIId.get(x)); } return toReturn; } catch (Exception e) { throw new EJBExceptionLP(e); } finally { session.close(); } } /** * hier wird Bestellung und Bestellpositionen befuellt fuer Ueberleitung aus * dem Bestellvorschlag * * @param aBestellvorschlagDto * BestellvorschlagDto[] * @param kostenstelleIId * kostenstelleIId * @param theClientDto * String * @throws EJBExceptionLP */ public void befuellenDerBestellungUndBestellposition(BestellvorschlagDto[] aBestellvorschlagDto, Integer kostenstelleIId, TheClientDto theClientDto) throws EJBExceptionLP { try { // isort in Bestellposition int j = 0; MandantDto mandantDto = getMandantFac().mandantFindByPrimaryKey(theClientDto.getMandant(), theClientDto); Integer iIdBestellung = null; for (int i = 0; i < aBestellvorschlagDto.length; i++) { // anlegen der Bestellung LieferantDto lieferantDto = getLieferantFac() .lieferantFindByPrimaryKey(aBestellvorschlagDto[0].getILieferantId(), theClientDto); BigDecimal wechselkurs = getLocaleFac().getWechselkurs2(lieferantDto.getWaehrungCNr(), mandantDto.getWaehrungCNr(), theClientDto); // Pro Lieferant und Termin eine eigene Bestellung anlegen BestellungDto bestellungDto = new BestellungDto(); AnsprechpartnerDto ansprechpartnerDto[] = getAnsprechpartnerFac() .ansprechpartnerFindByAnsprechpartnerIId(lieferantDto.getPartnerIId(), theClientDto); if (ansprechpartnerDto.length > 0) { bestellungDto.setAnsprechpartnerIId(ansprechpartnerDto[0].getIId()); } PersonalDto anfordererDto = getPersonalFac().personalFindByPrimaryKey(theClientDto.getIDPersonal(), theClientDto); bestellungDto.setPersonalIIdAnforderer(anfordererDto.getIId()); bestellungDto.setPersonalIIdAendern(theClientDto.getIDPersonal()); bestellungDto.setPersonalIIdAnlegen(theClientDto.getIDPersonal()); bestellungDto.setZahlungszielIId(lieferantDto.getZahlungszielIId()); bestellungDto.setProjektIId(aBestellvorschlagDto[0].getProjektIId()); bestellungDto.setBelegartCNr(LocaleFac.BELEGART_BESTELLUNG); // bestellungDto.setBestelltextIIdFusstext(); // bestellungDto.setBestelltextIIdKopftext(); bestellungDto.setBestellungartCNr(BestellungFac.BESTELLUNGART_FREIE_BESTELLUNG_C_NR); bestellungDto.setStatusCNr(BestellungFac.BESTELLSTATUS_ANGELEGT); ParametermandantDto parameterDto = getParameterFac().getMandantparameter(theClientDto.getMandant(), ParameterFac.KATEGORIE_BESTELLUNG, ParameterFac.PARAMETER_DEFAULT_TEILLIEFERUNG); bestellungDto .setBTeillieferungMoeglich(Helper.boolean2Short((Boolean) parameterDto.getCWertAsObject())); bestellungDto.setDBelegdatum(this.getDate()); bestellungDto.setDLiefertermin(aBestellvorschlagDto[0].getTLiefertermin()); bestellungDto.setKostenstelleIId(kostenstelleIId); bestellungDto.setLieferantIIdBestelladresse(lieferantDto.getIId()); bestellungDto.setLieferantIIdRechnungsadresse(lieferantDto.getIId()); // Default Lieferadresse ist die Adresse des aktuellen // Mandanten Integer iPartnerIIdLIeferadresse = getMandantFac() .mandantFindByPrimaryKey(theClientDto.getMandant(), theClientDto) .getPartnerIIdLieferadresse(); bestellungDto.setPartnerIIdLieferadresse(iPartnerIIdLIeferadresse); bestellungDto.setSpediteurIId(lieferantDto.getIdSpediteur()); bestellungDto.setMandantCNr(mandantDto.getCNr()); bestellungDto.setLieferartIId(lieferantDto.getLieferartIId()); bestellungDto.setWaehrungCNr(lieferantDto.getWaehrungCNr()); bestellungDto.setFAllgemeinerRabattsatz(new Double(0)); bestellungDto.setFWechselkursmandantwaehrungzubelegwaehrung(new Double(wechselkurs.doubleValue())); iIdBestellung = getBestellungFac().createBestellung(bestellungDto, theClientDto); // Positionen anlegen. BestellpositionDto bestellpositionDto = new BestellpositionDto(); ArtikelDto artikelDto = getArtikelFac() .artikelFindByPrimaryKey(aBestellvorschlagDto[i].getIArtikelId(), theClientDto); bestellpositionDto.setArtikelIId(aBestellvorschlagDto[i].getIArtikelId()); bestellpositionDto.setBDrucken(Helper.boolean2Short(false)); bestellpositionDto.setPositionsartCNr(BestellpositionFac.BESTELLPOSITIONART_IDENT); bestellpositionDto.setBestellpositionstatusCNr(BestellpositionFac.BESTELLPOSITIONSTATUS_OFFEN); bestellpositionDto.setBestellungIId(iIdBestellung); bestellpositionDto.setCBez(artikelDto.getArtikelsprDto().getCBez()); bestellpositionDto.setISort(new Integer(j++)); bestellpositionDto.setEinheitCNr(artikelDto.getEinheitCNr()); bestellpositionDto.setNMenge(aBestellvorschlagDto[i].getNZubestellendeMenge()); if (aBestellvorschlagDto[i].getCBelegartCNr() != null && aBestellvorschlagDto[i].getCBelegartCNr().equals(LocaleFac.BELEGART_LOS) && aBestellvorschlagDto[i].getIBelegartpositionid() != null) { LossollmaterialDto lossollmaterialDto = getFertigungFac() .lossollmaterialFindByPrimaryKeyOhneExc( aBestellvorschlagDto[i].getIBelegartpositionid()); if (lossollmaterialDto != null) { bestellpositionDto.setLossollmaterialIId(aBestellvorschlagDto[i].getIBelegartpositionid()); } } bestellpositionDto.setNMaterialzuschlag(new BigDecimal(0)); if (artikelDto.getMaterialIId() != null) { BigDecimal zuschlag = getMaterialFac() .materialzuschlagFindAktuellenzuschlag(artikelDto.getMaterialIId(), theClientDto); if (zuschlag != null) { bestellpositionDto.setNMaterialzuschlag(zuschlag); if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null) { BigDecimal nettogesamtpreis = aBestellvorschlagDto[i].getNNettoeinzelpreis(); if (aBestellvorschlagDto[i].getNRabattbetrag() != null) { nettogesamtpreis = nettogesamtpreis .subtract(aBestellvorschlagDto[i].getNRabattbetrag()); } nettogesamtpreis = nettogesamtpreis.add(zuschlag); aBestellvorschlagDto[i].setNNettogesamtpreis(nettogesamtpreis); } } } if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null) { bestellpositionDto.setNNettoeinzelpreis(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNNettoeinzelpreis(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNNettoeinzelpreis(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNNettogesamtpreis() != null) { bestellpositionDto.setNNettogesamtpreis(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNNettogesamtpreis(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNNettogesamtpreis(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNRabattbetrag() != null) { bestellpositionDto.setNRabattbetrag(getLocaleFac().rechneUmInAndereWaehrungZuDatum( aBestellvorschlagDto[i].getNRabattbetrag(), mandantDto.getWaehrungCNr(), lieferantDto.getWaehrungCNr(), new Date(System.currentTimeMillis()), theClientDto)); } else { bestellpositionDto.setNRabattbetrag(new BigDecimal(0)); aBestellvorschlagDto[i].setNRabattbetrag(new BigDecimal(0)); } if (aBestellvorschlagDto[i].getNNettoeinzelpreis() != null && !(aBestellvorschlagDto[i].getNNettoeinzelpreis().compareTo(new BigDecimal(0)) == 0)) { bestellpositionDto.setDRabattsatz(new Double(new BigDecimal(100) .subtract(Helper.calculateRatioInDecimal(aBestellvorschlagDto[i].getNRabattbetrag(), aBestellvorschlagDto[i].getNNettoeinzelpreis())) .doubleValue())); } else { bestellpositionDto.setDRabattsatz(new Double(0)); } bestellpositionDto.setBNettopreisuebersteuert(aBestellvorschlagDto[i].getBNettopreisuebersteuert()); bestellpositionDto.setTUebersteuerterLiefertermin(aBestellvorschlagDto[i].getTLiefertermin()); getBestellpositionFac().createBestellposition(bestellpositionDto, theClientDto, BestellpositionFac.PREISPFLEGEARTIKELLIEFERANT_PREIS_UNVERAENDERT, null); this.removeBestellvorschlag(aBestellvorschlagDto[i]); } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } } public void removeLockDesBestellvorschlagesWennIchIhnSperre(TheClientDto theClientDto) throws EJBExceptionLP { try { LockMeDto[] lockMeDtoLock = getTheJudgeFac() .findByWerWasOhneExc(BestellvorschlagFac.LOCKME_BESTELLVORSCHLAG, theClientDto.getMandant()); if (lockMeDtoLock != null && lockMeDtoLock.length > 0) { if (lockMeDtoLock[0].getPersonalIIdLocker().equals(theClientDto.getIDPersonal()) && lockMeDtoLock[0].getCUsernr().trim().equals(theClientDto.getIDUser().trim())) { getTheJudgeFac().removeLockedObject(lockMeDtoLock[0]); } } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } } /** * Pruefen, ob der Bestellvorschlag des Mandanten, auf dem der Benutzer * arbeitet, freigegeben ist. falls nicht, wird eine Exception geworfen. * * @param theClientDto * String * @throws EJBExceptionLP */ public void pruefeBearbeitenDesBestellvorschlagsErlaubt(TheClientDto theClientDto) throws EJBExceptionLP { try { // lock-objekt zusammenstellen LockMeDto lockMeDto = new LockMeDto(); lockMeDto.setCUsernr(theClientDto.getIDUser()); lockMeDto.setCWas(theClientDto.getMandant()); lockMeDto.setCWer(BestellvorschlagFac.LOCKME_BESTELLVORSCHLAG); LockMeDto[] lockMeDtoLock = getTheJudgeFac() .findByWerWasOhneExc(BestellvorschlagFac.LOCKME_BESTELLVORSCHLAG, theClientDto.getMandant()); if (lockMeDtoLock != null && lockMeDtoLock.length > 0) { if (lockMeDtoLock[0].getPersonalIIdLocker().equals(theClientDto.getIDPersonal()) && lockMeDtoLock[0].getCUsernr().trim().equals(theClientDto.getIDUser().trim())) { // dann ist er eh durch diesen benutzer auf diesem client // gelockt return; } else { ArrayList<Object> al = new ArrayList<Object>(); al.add(lockMeDtoLock[0].getCUsernr()); throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BESTELLVORSCHLAG_IST_GESPERRT, al, new Exception("Bestellvorschlag auf Mandant " + theClientDto.getMandant() + " gesperrt durch Personal Id " + lockMeDtoLock[0].getPersonalIIdLocker())); } } else { // dann sperren lockMeDto.setPersonalIIdLocker(theClientDto.getIDPersonal()); getTheJudgeFac().addLockedObject(lockMeDto, theClientDto); } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } } private void verdichteBestellvorschlagNachMindesbestellmengen(boolean bBeruecksichtigeProjektklammer, TheClientDto theClientDto) throws EJBExceptionLP { SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; try { session = factory.openSession(); // Zuerst die ID's aller vorkommender Artikel holen. String queryString = "select distinct bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_ARTIKEL_I_ID + " from FLRBestellvorschlag bestellvorschlag where bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR + "='" + theClientDto.getMandant() + "'"; org.hibernate.Query query = session.createQuery(queryString); List<?> rowCountResult = query.list(); // nun die Eintraege fuer jeden Artikel verdichten. for (Iterator<?> itArtikel = rowCountResult.iterator(); itArtikel.hasNext();) { ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall((Integer) itArtikel.next(), theClientDto); ArrayList<Integer> alProjekte = new ArrayList<Integer>(); if (bBeruecksichtigeProjektklammer == true) { String queryStringProjekte = "select distinct bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID + " from FLRBestellvorschlag bestellvorschlag where bestellvorschlag.artikel_i_id=" + artikelDto.getIId() + " AND bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR + "='" + theClientDto.getMandant() + "'"; org.hibernate.Query queryProjekte = session.createQuery(queryStringProjekte); List<?> resultProjekte = queryProjekte.list(); Iterator itProjekte = resultProjekte.iterator(); while (itProjekte.hasNext()) { Integer projektIId = (Integer) itProjekte.next(); alProjekte.add(projektIId); } } else { alProjekte.add(null); } for (int j = 0; j < alProjekte.size(); j++) { Integer projektIId = alProjekte.get(j); // Alle BV-Eintraege des Mandanten auflisten. Criteria crit = session.createCriteria(FLRBestellvorschlag.class); // Filter nach Mandant crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR, theClientDto.getMandant())); // Filter nach Artikel crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_ARTIKEL_I_ID, artikelDto.getIId())); if (bBeruecksichtigeProjektklammer == true) { if (projektIId == null) { crit.add(Restrictions.isNull(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID)); } else { crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID, projektIId)); } } // Sortierung nach Liefertermin. crit.addOrder(Order.asc(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_T_LIEFERTERMIN)); List<?> resultList = crit.list(); // Da die Eintraege zwischendurch auf Mindest- bzw. // Verpackungsmengen // aufgerundet werden muessen, entwickelt sich zwischendurch // ein // Guthaben BigDecimal bdGuthaben = new BigDecimal(0); ArtikellieferantDto artLief = null; // nun alle Eintraege durchiterieren. for (Iterator<?> itBV = resultList.iterator(); itBV.hasNext();) { FLRBestellvorschlag bv = (FLRBestellvorschlag) itBV.next(); Bestellvorschlag bvEntity = em.find(Bestellvorschlag.class, bv.getI_id()); if (bvEntity == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_BEI_FIND, ""); } if (bv.getArtikel_i_id() != null && bv.getLieferant_i_id() != null) { if (artLief == null) { // lazy loading fuer jeden // Artikel. artLief = getArtikelFac().artikellieferantFindByArtikellIIdLieferantIIdOhneExc( bv.getArtikel_i_id(), bv.getLieferant_i_id(), theClientDto); } // Wenn der Artikellieferant definiert ist (von dort // kommen VPE und Mindestbestellmenge) if (artLief != null) { if (bdGuthaben.compareTo(bv.getN_zubestellendemenge()) >= 0) { // Wenn durch Mengenerhoehungen vorheriger // Eintraege genug Guthaben // "erzielt" wurde, um auf diese Position // verzichten zu koennen -> loeschen. bdGuthaben = bdGuthaben.subtract(bv.getN_zubestellendemenge()); removeBestellvorschlag(bv.getI_id()); } else { BigDecimal bdMindestbestellmenge = new BigDecimal(0); if (artLief.getFMindestbestelmenge() != null) { // Ist keine Mindestbestellmenge // definiert, // kann ich deren Behandlung als // abgeschlossen betrachten. bdMindestbestellmenge = new BigDecimal(artLief.getFMindestbestelmenge()); } // Wenn die zu bestellende Menge // geringer // als die Mindestbestellmenge ist, // dann muss ich auf die // Mindestbestellmenge // erhoehen. if (bv.getN_zubestellendemenge().compareTo(bdMindestbestellmenge) < 0) { BigDecimal bdDifferenz = bdMindestbestellmenge .subtract(bv.getN_zubestellendemenge()); bv.setN_zubestellendemenge(bdMindestbestellmenge); bdGuthaben = bdGuthaben.add(bdDifferenz); // speichern bvEntity.setNZubestellendemenge(bdMindestbestellmenge); } // Zuletzt muss noch auf die // Verpackungseinheit // geprueft werden. (sofern diese definiert // ist) if (artLief.getNVerpackungseinheit() != null) { if (artLief.getNVerpackungseinheit().doubleValue() != 0) { // Die zu bestellende Menge muss // immer // ein Vielfaches der VPE sein. int iNachkommastellenMandant = getMandantFac() .getNachkommastellenMenge(theClientDto.getMandant()); BigDecimal bdVPE = artLief.getNVerpackungseinheit(); bdVPE = bdVPE.setScale(iNachkommastellenMandant, RoundingMode.HALF_UP); BigDecimal bdMenge = bv.getN_zubestellendemenge() .setScale(iNachkommastellenMandant, RoundingMode.HALF_UP); BigDecimal bdDivRest = bdMenge.divideAndRemainder(bdVPE, new MathContext(4, RoundingMode.HALF_UP))[1].setScale( iNachkommastellenMandant, RoundingMode.HALF_UP); if (bdDivRest.compareTo( new BigDecimal(0).setScale(iNachkommastellenMandant)) != 0) { BigDecimal bdDifferenz = bdVPE.subtract(bdDivRest); bdGuthaben = bdGuthaben.add(bdDifferenz); // speichern bvEntity.setNZubestellendemenge( bvEntity.getNZubestellendemenge().add(bdDifferenz)); } } } } } } } } } } // catch (FinderException ex) { // throw new EJBExceptionLP(EJBExceptionLP.FEHLER, ex); // } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } finally { closeSession(session); } } /** * BV-Eintraege eines Mandante verdichten. (Einrechnen der * Verpackungseinheiten und Mindestbestellmengen) * * * @param theClientDto * String * @throws EJBExceptionLP */ public void verdichteBestellvorschlag(Long lVerdichtungszeitraum, boolean bMindestbestellmengenBeruecksichtigt, boolean bBeruecksichtigeProjektklammer, TheClientDto theClientDto) throws EJBExceptionLP { verdichteBestellvorschlagNachDatum(lVerdichtungszeitraum, bBeruecksichtigeProjektklammer, theClientDto); if (bMindestbestellmengenBeruecksichtigt) { verdichteBestellvorschlagNachMindesbestellmengen(bBeruecksichtigeProjektklammer, theClientDto); } } private void verdichteBestellvorschlagNachDatum(Long lVerdichtungszeitraumparam, boolean bBeruecksichtigeProjektklammer, TheClientDto theClientDto) { SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; session = factory.openSession(); // Zuerst die ID's aller vorkommender Artikel holen. String queryString = "select distinct bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_ARTIKEL_I_ID + " from FLRBestellvorschlag bestellvorschlag where bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR + "='" + theClientDto.getMandant() + "'"; org.hibernate.Query query = session.createQuery(queryString); List<?> rowCountResult = query.list(); // nun die Eintraege fuer jeden Artikel verdichten. for (Iterator<?> itArtikel = rowCountResult.iterator(); itArtikel.hasNext();) { ArtikelDto artikelDto = getArtikelFac().artikelFindByPrimaryKeySmall((Integer) itArtikel.next(), theClientDto); ArrayList<Integer> alProjekte = new ArrayList<Integer>(); if (bBeruecksichtigeProjektklammer == true) { String queryStringProjekte = "select distinct bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID + " from FLRBestellvorschlag bestellvorschlag where bestellvorschlag.artikel_i_id=" + artikelDto.getIId() + " AND bestellvorschlag." + BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR + "='" + theClientDto.getMandant() + "'"; org.hibernate.Query queryProjekte = session.createQuery(queryStringProjekte); List<?> resultProjekte = queryProjekte.list(); Iterator itProjekte = resultProjekte.iterator(); while (itProjekte.hasNext()) { Integer projektIId = (Integer) itProjekte.next(); alProjekte.add(projektIId); } } else { alProjekte.add(null); } for (int j = 0; j < alProjekte.size(); j++) { Integer projektIId = alProjekte.get(j); // Alle BV-Eintraege des Mandanten auflisten. Criteria crit = session.createCriteria(FLRBestellvorschlag.class); // Filter nach Mandant crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR, theClientDto.getMandant())); // Filter nach Artikel crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_ARTIKEL_I_ID, artikelDto.getIId())); if (bBeruecksichtigeProjektklammer == true) { if (projektIId == null) { crit.add(Restrictions.isNull(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID)); } else { crit.add( Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_PROJEKT_I_ID, projektIId)); } } // Sortierung nach Liefertermin. crit.addOrder(Order.asc(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_T_LIEFERTERMIN)); List<?> resultList = crit.list(); FLRBestellvorschlag[] bestVorschlaege = (FLRBestellvorschlag[]) resultList .toArray(new FLRBestellvorschlag[] {}); // der erste Bestellvorschlag ist der frueheste Bestellvorschlag bvFirst = em.find(Bestellvorschlag.class, bestVorschlaege[0].getI_id()); if (bvFirst == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER, ""); } Long lVerdichtungszeitraum = 60 * 60 * 1000 * 24 * lVerdichtungszeitraumparam; // Alle Bestellvorschlaege dieses Artikels, // die vor dem Datum sind muessen auf diesem gesammelt werden Timestamp dateOfVerdichtung = new Timestamp( bvFirst.getTLiefertermin().getTime() + lVerdichtungszeitraum); for (int i = 1; i < bestVorschlaege.length; i++) { if (bestVorschlaege[i].getT_liefertermin().before(dateOfVerdichtung) || bestVorschlaege[i].getT_liefertermin().compareTo(dateOfVerdichtung) == 0) { // Bestellvorschlag wird auf vorherigen verdichtet bvFirst.setNZubestellendemenge( bvFirst.getNZubestellendemenge().add(bestVorschlaege[i].getN_zubestellendemenge())); // Der Beleg wird geloescht, da das nicht mehr stimmen // kann bvFirst.setBelegartCNr(null); bvFirst.setIBelegartid(null); bvFirst.setIBelegartpositionid(null); if (bBeruecksichtigeProjektklammer == false) { bvFirst.setProjektIId(null); } // Der Bestellvorschlag der verdichtet wurde kann // geloescht werden removeBestellvorschlag(bestVorschlaege[i].getI_id()); System.out.println("verdichtet"); } else { // Der Liefertermin wird die neue Referenz // fuer die naechsten Vorschlaege bvFirst = em.find(Bestellvorschlag.class, bestVorschlaege[i].getI_id()); dateOfVerdichtung = new Timestamp( bvFirst.getTLiefertermin().getTime() + lVerdichtungszeitraum); } } } } } public void uebernimmLieferantAusLieferantOptimieren(Integer bestellvorschlagIId, Integer lieferantIIdNeu, TheClientDto theClientDto) { BestellvorschlagDto bestellvorschlagDto = bestellvorschlagFindByPrimaryKey(bestellvorschlagIId); bestellvorschlagDto.setILieferantId(lieferantIIdNeu); ArtikellieferantDto alDto = getArtikelFac().getArtikelEinkaufspreis(bestellvorschlagDto.getIArtikelId(), lieferantIIdNeu, bestellvorschlagDto.getNZubestellendeMenge(), theClientDto.getSMandantenwaehrung(), Helper.cutDate(new java.sql.Date(System.currentTimeMillis())), theClientDto); if (alDto != null) { bestellvorschlagDto.setNNettoeinzelpreis(alDto.getNEinzelpreis()); bestellvorschlagDto.setNNettogesamtpreis(alDto.getNNettopreis()); bestellvorschlagDto.setDRabattsatz(alDto.getFRabatt()); if (alDto.getNEinzelpreis() != null && alDto.getFRabatt() != null) { bestellvorschlagDto.setNRabattbetrag(Helper.rundeKaufmaennisch( alDto.getNEinzelpreis().multiply(new BigDecimal(alDto.getFRabatt()).movePointLeft(2)), 4)); } if (Helper.short2boolean(alDto.getBRabattbehalten())) { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(false)); } else { bestellvorschlagDto.setBNettopreisuebersteuert(Helper.boolean2Short(true)); } bestellvorschlagDto.setNNettoGesamtPreisMinusRabatte(alDto.getNNettopreis()); } updateBestellvorschlag(bestellvorschlagDto); } public Map getAllLieferantenDesBestellvorschlages(TheClientDto theClientDto) { LinkedHashMap<Object, Object> tmLieferanten = new LinkedHashMap<Object, Object>(); Session session = FLRSessionFactory.getFactory().openSession(); String queryString = "SELECT distinct bv.lieferant_i_id,bv.flrlieferant.flrpartner.c_name1nachnamefirmazeile1 FROM FLRBestellvorschlag bv WHERE bv.mandant_c_nr='" + theClientDto.getMandant() + "' ORDER BY bv.flrlieferant.flrpartner.c_name1nachnamefirmazeile1 ASC"; org.hibernate.Query hqlquery = session.createQuery(queryString); List<?> resultList = hqlquery.list(); Iterator<?> resultListIterator = resultList.iterator(); while (resultListIterator.hasNext()) { Object[] o = (Object[]) resultListIterator.next(); Integer lieferantIId = (Integer) o[0]; LieferantDto lieferantDto = getLieferantFac().lieferantFindByPrimaryKey(lieferantIId, theClientDto); tmLieferanten.put(lieferantIId, lieferantDto.getPartnerDto().formatFixName1Name2()); } return tmLieferanten; } /** * Spaeter wieder beschaffbare Positionen aus dem BV entfernen. * "Spaeter Wiederbeschaffbar" heisst: Das Datum des naechsten geplanten * Bestellvorschlags + Wiederbeschaffungszeit liegt vor dem Datum, an dem * die Artikel benoetigt werden. * * @param tNaechsterBV * Date * @param theClientDto * String * @throws EJBExceptionLP */ public void loescheSpaeterWiederbeschaffbarePositionen(java.sql.Date tNaechsterBV, TheClientDto theClientDto) throws EJBExceptionLP { // Precondition if (tNaechsterBV == null) { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_PARAMETER_IS_NULL, new Exception("tWBMoeglichBis == null")); } SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; try { session = factory.openSession(); // Alle BV-Eintraege des Mandanten auflisten. Criteria crit = session.createCriteria(FLRBestellvorschlag.class); // Filter nach Mandant crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR, theClientDto.getMandant())); List<?> resultList = crit.list(); // Wiederbeschaffungszeit kann in Tagen oder Wochen angegeben // werden. ParametermandantDto parameterDtoWBZ = getParameterFac().getMandantparameter(theClientDto.getMandant(), ParameterFac.KATEGORIE_ARTIKEL, ParameterFac.PARAMETER_ARTIKELWIEDERBESCHAFFUNGSZEIT); final int iFaktorWBZ; if (parameterDtoWBZ.getCWert().equals(ArtikelFac.WIEDERBESCHAFFUNGSZEIT_EINHEIT_KW)) { iFaktorWBZ = 7; } else if (parameterDtoWBZ.getCWert().equals(ArtikelFac.WIEDERBESCHAFFUNGSZEIT_EINHEIT_TAGE)) { iFaktorWBZ = 1; } else { throw new EJBExceptionLP(EJBExceptionLP.FEHLER_MANDANTPARAMETER_NICHT_ANGELEGT, new Exception( ParameterFac.PARAMETER_ARTIKELWIEDERBESCHAFFUNGSZEIT + " ist nicht richtig definiert")); } for (Iterator<?> iter = resultList.iterator(); iter.hasNext();) { FLRBestellvorschlag item = (FLRBestellvorschlag) iter.next(); if (item.getArtikel_i_id() != null && item.getLieferant_i_id() != null) { ArtikellieferantDto artLief = getArtikelFac() .artikellieferantFindByArtikellIIdLieferantIIdOhneExc(item.getArtikel_i_id(), item.getLieferant_i_id(), theClientDto); // Wenn der Artikellieferant definiert ist (von dort kommt // die Wiederbeschaffungszeit) // und wenn auch eine WBZ definiert ist. if (artLief != null && artLief.getIWiederbeschaffungszeit() != null) { // Wiederbeschaffungszeit in Tagen int iWBZInTagen = iFaktorWBZ * artLief.getIWiederbeschaffungszeit(); java.sql.Date tMussBestellenBis = Helper.addiereTageZuDatum(item.getT_liefertermin(), -iWBZInTagen); // Wenn ich den also beim naechsten BV auch noch // bestellen kann, dann loesch ich ihn raus if (tNaechsterBV.before(tMussBestellenBis)) { removeBestellvorschlag(item.getI_id()); } } } } } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } finally { closeSession(session); } } public void loescheBestellvorschlaegeAbTermin(Date dTermin, TheClientDto theClientDto) { SessionFactory factory = FLRSessionFactory.getFactory(); Session session = null; session = factory.openSession(); // Alle BV-Eintraege des Mandanten auflisten. Criteria crit = session.createCriteria(FLRBestellvorschlag.class); // Filter nach Mandant crit.add(Restrictions.eq(BestellvorschlagFac.FLR_BESTELLVORSCHLAG_MANDANT_C_NR, theClientDto.getMandant())); List<?> resultList = crit.list(); for (Iterator<?> iter = resultList.iterator(); iter.hasNext();) { FLRBestellvorschlag item = (FLRBestellvorschlag) iter.next(); if (item.getT_liefertermin().after(dTermin)) { removeBestellvorschlag(item.getI_id()); } } closeSession(session); } }