Example usage for org.hibernate.criterion Restrictions gt

List of usage examples for org.hibernate.criterion Restrictions gt

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. gt

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions gt.

Prototype

public static SimpleExpression gt(String propertyName, Object value)

Source Link

Document

Apply a "greater than" constraint to the named property

Usage

From source file:com.lm.lic.manager.hibernate.LicenseDAO.java

License:Open Source License

public Integer findNumInUseIsvLicenses(String isvId, String storeId, String platformId, Date startDate,
        Date endDate) {/*w  w  w  .  j ava 2s  .  c om*/
    Integer numLics = 0;
    try {
        Long lisvid = Long.parseLong(isvId);

        Criteria criteria = getSession().createCriteria(License.class);
        criteria.add(Restrictions.eq("isv.id", lisvid));
        criteria.add(Restrictions.eq("inUse", true));
        criteria.add(Restrictions.eq("decom", false));

        Criteria prodCriteria = null;
        if (StringUtils.hasText(storeId)) {
            Long lsid = Long.parseLong(storeId);
            prodCriteria = criteria.createCriteria("product");
            prodCriteria.add(Restrictions.eq("listingStore.id", lsid));
        }

        if (StringUtils.hasText(platformId)) {
            Long lfid = Long.parseLong(platformId);
            if (prodCriteria == null)
                prodCriteria = criteria.createCriteria("product");
            prodCriteria.add(Restrictions.eq("platform.id", lfid));
        }

        if (startDate != null && endDate != null)
            criteria.add(Restrictions.between(TIME_ACTIVATED, startDate, endDate));
        else {
            if (startDate != null)
                criteria.add(Restrictions.gt(TIME_ACTIVATED, startDate));
            if (endDate != null)
                criteria.add(Restrictions.lt(TIME_ACTIVATED, endDate));
        }

        criteria.setProjection(Projections.rowCount());
        numLics = (Integer) criteria.list().get(0);
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return numLics;
}

From source file:com.lm.lic.manager.hibernate.LicenseVerifIncidentDAO.java

License:Open Source License

@SuppressWarnings("unchecked")
public List<LicenseVerifIncident> findIsvVerifs(Long isvId, String licType, String respType,
        Integer firstResult, Integer maxResults, String orderBy, String orderDir, Date startDate,
        Date endDate) {//  ww w . j av a 2  s.  c  o  m
    List<LicenseVerifIncident> rfls = null;
    try {
        Criteria mainCriteria = getSession().createCriteria(LicenseVerifIncident.class);
        mainCriteria.add(Restrictions.eq("isv.id", isvId));
        Criteria prodCriteria = addEnabledUnDeletedProductCriteria(mainCriteria);

        addLicTypeRespTypeCrit(licType, respType, mainCriteria, prodCriteria);

        mainCriteria.setFirstResult(firstResult);
        mainCriteria.setMaxResults(maxResults);

        if (startDate != null && endDate != null)
            mainCriteria.add(Restrictions.between(TIME_REQUESTED, startDate, endDate));
        else {
            if (startDate != null)
                mainCriteria.add(Restrictions.gt(TIME_REQUESTED, startDate));
            if (endDate != null)
                mainCriteria.add(Restrictions.lt(TIME_REQUESTED, endDate));
        }
        createOrderByFieldAliasIfApplicable(orderBy, orderDir, mainCriteria, prodCriteria);
        rfls = mainCriteria.list();
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return rfls;
}

From source file:com.lm.lic.manager.hibernate.LicenseVerifIncidentDAO.java

License:Open Source License

public Integer findNumIsvVerifs(String isvId, String licType, String respType, Date startDate, Date endDate) {
    Integer numVerifs = 0;/*from ww w .  j  a v  a 2s  . c  om*/
    try {
        Long lisvid = Long.parseLong(isvId);
        Criteria mainCriteria = getSession().createCriteria(LicenseVerifIncident.class);
        mainCriteria.add(Restrictions.eq("isv.id", lisvid));
        Criteria prodCriteria = mainCriteria.createCriteria("product");
        prodCriteria.add(Restrictions.eq("deleted", false));

        addLicTypeRespTypeCrit(licType, respType, mainCriteria, prodCriteria);

        if (startDate != null && endDate != null)
            mainCriteria.add(Restrictions.between(TIME_REQUESTED, startDate, endDate));
        else {
            if (startDate != null)
                mainCriteria.add(Restrictions.gt(TIME_REQUESTED, startDate));
            if (endDate != null)
                mainCriteria.add(Restrictions.lt(TIME_REQUESTED, endDate));
        }

        mainCriteria.setProjection(Projections.rowCount());
        numVerifs = (Integer) mainCriteria.list().get(0);
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return numVerifs;
}

From source file:com.lm.lic.manager.hibernate.LicenseVerifIncidentDAO.java

License:Open Source License

public Integer findNumProdVerifs(String prodId, String licType, String respType, Date startDate, Date endDate) {
    Integer numLics = 0;//  w w w .jav a2s.co  m
    try {
        Long lpid = Long.parseLong(prodId);
        Criteria mainCriteria = getSession().createCriteria(LicenseVerifIncident.class);
        mainCriteria.add(Restrictions.eq("product.id", lpid));
        Criteria prodCriteria = mainCriteria.createCriteria("product");
        prodCriteria.add(Restrictions.eq("deleted", false));

        addLicTypeRespTypeCrit(licType, respType, mainCriteria, prodCriteria);

        if (startDate != null && endDate != null)
            mainCriteria.add(Restrictions.between(TIME_REQUESTED, startDate, endDate));
        else {
            if (startDate != null)
                mainCriteria.add(Restrictions.gt(TIME_REQUESTED, startDate));
            if (endDate != null)
                mainCriteria.add(Restrictions.lt(TIME_REQUESTED, endDate));
        }

        mainCriteria.setProjection(Projections.rowCount());
        numLics = (Integer) mainCriteria.list().get(0);
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return numLics;
}

From source file:com.lm.lic.manager.hibernate.LicenseVerifIncidentDAO.java

License:Open Source License

private void addLicTypeRespTypeCrit(String licType, String respType, Criteria mainCriteria,
        Criteria prodCriteria) {//from www . ja v  a2 s .c  om
    if (StringUtils.hasText(respType)) {
        if (respType.equals(LicenseVerificationStatus.YES_AUTHORIZED.value())) {
            Criterion afCrit = Restrictions.eq("verResp", LicenseVerificationStatus.AUTHORIZED_FOREVER.value());
            Criterion apCrit = Restrictions.eq("verResp",
                    LicenseVerificationStatus.AUTHORIZED_PERMANENT.value());
            Criterion atCrit = Restrictions.eq("verResp", LicenseVerificationStatus.AUTHORIZED_TRIAL.value());
            LogicalExpression orExp = Restrictions.or(afCrit, apCrit);
            orExp = Restrictions.or(orExp, atCrit);
            mainCriteria.add(orExp);
        } else
            mainCriteria.add(Restrictions.eq("verResp", respType));
    }

    if (CoarseLicenseType.isForever(licType))
        prodCriteria.add(Restrictions.gt("licLifeInDays", GenConst.YEAR_LIFE_LONG));
    else if (CoarseLicenseType.isPermanent(licType))
        prodCriteria.add(Restrictions.eq("licLifeInDays", GenConst.YEAR_LIFE_LONG));
    else if (CoarseLicenseType.isTrial(licType))
        prodCriteria.add(Restrictions.lt("licLifeInDays", GenConst.YEAR_LIFE_LONG));
}

From source file:com.lp.server.angebot.bl.AngebotUebersichtHandler.java

License:Open Source License

/**
 * Der Wert aller Angebote in Mandantenwaehrung, die lt. Belegdatum in einem
 * bestimmten Zeitraum angelegt wurden und deren Status != (Angelegt ||
 * Storniert) ist. Optional kann auch nach einem bestimmten Vertreter
 * ausgewertet werden.//  ww w.  ja v  a  2  s. co  m
 * 
 * @param gcBerechnungsdatumVonI
 *            Belegdatum von
 * @param gcBerechnungsdatumBisI
 *            Belegdatum bis
 * @param iIdVertreterI
 *            der Vertreter, null erlaubt
 * @param iIndexSpaltentyp
 *            fuer welche Spalte soll die Berechnung erfolgen
 * @param cNrUserI
 *            der aktuelle Benutzer
 * @return BigDecimal der Gesamtwert in Mandantenwaehrung
 * @throws EJBExceptionLP
 *             Ausnahme
 */
private BigDecimal getWertInMandantenwaehrung(GregorianCalendar gcBerechnungsdatumVonI,
        GregorianCalendar gcBerechnungsdatumBisI, Integer iIdVertreterI, int iIndexSpaltentyp,
        TheClientDto theClientDto) throws EJBExceptionLP {
    BigDecimal nGesamtwertInMandantenwaehrung = new BigDecimal(0);

    Session session = null;

    try {
        // System.out.println("Spaltentyp: " + iIndexSpaltentyp);
        // System.out.println("Von: " +
        // Helper.formatDatum(gcBerechnungsdatumVonI.getTime(),
        // getTheClient(sCurrentUser).getLocUi()));
        // System.out.println("Bis: " +
        // Helper.formatDatum(gcBerechnungsdatumBisI.getTime(),
        // getTheClient(sCurrentUser).getLocUi()));

        SessionFactory factory = FLRSessionFactory.getFactory();
        session = factory.openSession();

        // Criteria duerfen keine Texts oder Blobs enthalten!

        // Criteria anlegen
        Criteria critAngebotposition = session.createCriteria(FLRAngebotpositionReport.class);
        Criteria critAngebot = critAngebotposition
                .createCriteria(AngebotpositionFac.FLR_ANGEBOTPOSITION_FLRANGEBOT);

        // zuerst alle jene Einschraenkungen, die fuer alle Spaltentypen der
        // Uebersicht gelten
        critAngebot.add(Restrictions.eq("mandant_c_nr", theClientDto.getMandant()));

        if (iIdVertreterI != null) {
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_VERTRETER_I_ID, iIdVertreterI));
        }

        // UW 22.03.06 alle nicht alternativen Positionen mit positiver
        // Menge
        critAngebotposition.add(Restrictions.isNotNull(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE));
        critAngebotposition
                .add(Restrictions.gt(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE, new BigDecimal(0)));
        critAngebotposition.add(
                Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_B_ALTERNATIVE, new Short((short) 0)));

        // die folgenden Einschraenkungen sind vom Spaltentyp der Ubersicht
        // abhaengig
        // IDX_GESAMT: Basis ist Belegdatum, alle Angebote mit Status !=
        // (Angelegt || Storniert)
        // IDX_OFFEN: Basis ist Belegdatum, alle Angebote mit Status Offen
        // IDX_OFFENTERMINBEWERTET: Basis ist Realisierungstermin, alle
        // Angebote mit Status offen;
        // der Wert wird jeweils mit der Auftragswahrscheinlichkeit
        // multipliziert
        // IDX_BESTELLT: Basis ist Belegdatum, Erledigungsgrund == Auftrag
        // erhalten
        if (iIndexSpaltentyp == IDX_GESAMT) {
            critAngebot.add(Restrictions.ne(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                    AngebotServiceFac.ANGEBOTSTATUS_ANGELEGT));
            critAngebot.add(Restrictions.ne(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                    AngebotServiceFac.ANGEBOTSTATUS_STORNIERT));
        } else if (iIndexSpaltentyp == IDX_OFFEN || iIndexSpaltentyp == IDX_OFFENTERMINBEWERTET) {
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                    AngebotServiceFac.ANGEBOTSTATUS_OFFEN));
        } else if (iIndexSpaltentyp == IDX_BESTELLT) {
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                    AngebotServiceFac.ANGEBOTSTATUS_ERLEDIGT));
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTERLEDIGUNGSGRUND_C_NR,
                    AngebotServiceFac.ANGEBOTERLEDIGUNGSGRUND_AUFTRAGERHALTEN));
        }

        if (iIndexSpaltentyp == IDX_GESAMT || iIndexSpaltentyp == IDX_OFFEN
                || iIndexSpaltentyp == IDX_BESTELLT) {
            if (gcBerechnungsdatumVonI.getTime() != null) {
                critAngebot.add(
                        Restrictions.ge(AngebotFac.FLR_ANGEBOT_T_BELEGDATUM, gcBerechnungsdatumVonI.getTime()));
            }

            if (gcBerechnungsdatumBisI.getTime() != null) {
                critAngebot.add(
                        Restrictions.lt(AngebotFac.FLR_ANGEBOT_T_BELEGDATUM, gcBerechnungsdatumBisI.getTime()));
            }
        }

        if (iIndexSpaltentyp == IDX_OFFENTERMINBEWERTET) {
            if (gcBerechnungsdatumVonI.getTime() != null) {
                critAngebot.add(Restrictions.ge(AngebotFac.FLR_ANGEBOT_T_REALISIERUNGSTERMIN,
                        gcBerechnungsdatumVonI.getTime()));
            }

            if (gcBerechnungsdatumBisI.getTime() != null) {
                critAngebot.add(Restrictions.lt(AngebotFac.FLR_ANGEBOT_T_REALISIERUNGSTERMIN,
                        gcBerechnungsdatumBisI.getTime()));
            }
        }

        List<?> list = critAngebotposition.list();

        int iIndex = 0;
        Iterator<?> it = list.iterator();

        while (it.hasNext()) {
            FLRAngebotpositionReport flrangebotposition = (FLRAngebotpositionReport) it.next();

            // der Beitrag der einzelnen Position in Angebotswaehrung
            BigDecimal nBeitragDerPositionInAngebotswaehrung = flrangebotposition
                    .getN_nettogesamtpreisplusversteckteraufschlagminusrabatte()
                    .multiply(flrangebotposition.getN_menge());

            BigDecimal nBeitragDerPositionInMandantenwaehrung = nBeitragDerPositionInAngebotswaehrung
                    .multiply(Helper.getKehrwert(new BigDecimal(flrangebotposition.getFlrangebot()
                            .getF_wechselkursmandantwaehrungzuangebotswaehrung().doubleValue())));

            if (iIndexSpaltentyp == IDX_OFFENTERMINBEWERTET) {
                double dAuftragswahrscheinlichkeit = flrangebotposition.getFlrangebot()
                        .getF_auftragswahrscheinlichkeit().doubleValue();

                nBeitragDerPositionInMandantenwaehrung = nBeitragDerPositionInMandantenwaehrung
                        .multiply(new BigDecimal(dAuftragswahrscheinlichkeit).movePointLeft(2));
            }

            nBeitragDerPositionInMandantenwaehrung = Helper
                    .rundeKaufmaennisch(nBeitragDerPositionInMandantenwaehrung, 4);
            checkNumberFormat(nBeitragDerPositionInMandantenwaehrung);

            nGesamtwertInMandantenwaehrung = nGesamtwertInMandantenwaehrung
                    .add(nBeitragDerPositionInMandantenwaehrung);

            iIndex++;
        }
    } catch (Throwable t) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FLR, new Exception(t));
    } finally {
        try {
            session.close();
        } catch (HibernateException he) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER_HIBERNATE, he);
        }
    }

    return nGesamtwertInMandantenwaehrung;
}

From source file:com.lp.server.angebot.ejbfac.AngebotFacBean.java

License:Open Source License

/**
 * Ueber Hibernate alle berechnungsrelevanten Positionen eines Angebots
 * holen. <br>//from  w  ww  .java2s  .  co  m
 * Diese Methode mu&szlig; innerhalb einer offenen Hibernate Session aufgerufen
 * werden. <br>
 * 
 * @todo diese Methode muesste eigentlich in der AngebotpositionFac
 *       sitzen... PJ 3790
 * 
 * @param sessionI
 *            die Hibernate Session
 * @param iIdAngebotI
 *            PK des Angebots
 * @param bNurMengenbehafteteI
 *            nur mengenbehaftete Positionen beruecksichtigen
 * @param bNurPositiveMengenI
 *            nur positive Mengen beruecksichtigen; wird bei
 *            !bNurMengenbehafteteI nicht ausgewertet
 * @param bOhneAlternativenI
 *            alternative Positionen werden nicht beruecksichtigt
 * @return FLRAngebotpositionReport[] die berechnungsrelevanten Positionen
 * @throws EJBExceptionLP
 *             Ausnahme
 */
private FLRAngebotpositionReport[] holeAngebotpositionen(Session sessionI, Integer iIdAngebotI,
        boolean bNurMengenbehafteteI, boolean bNurPositiveMengenI, boolean bOhneAlternativenI)
        throws EJBExceptionLP {
    FLRAngebotpositionReport[] aFLRAngebotpositionReport = null;

    try {
        Criteria crit = sessionI.createCriteria(FLRAngebotpositionReport.class);

        crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_ANGEBOT_I_ID, iIdAngebotI));

        if (bNurMengenbehafteteI) {
            crit.add(Restrictions.isNotNull(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE));

            if (bNurPositiveMengenI) {
                crit.add(Restrictions.gt(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE, new BigDecimal(0)));
            }
        }

        // nur Positionen beruecksichtigen, die keine Alternative sind
        if (bOhneAlternativenI) {
            crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_B_ALTERNATIVE,
                    new Short((short) 0)));
        }

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

        // Liste aller Positionen, die behandelt werden sollen
        List<?> list = crit.list();
        aFLRAngebotpositionReport = new FLRAngebotpositionReport[list.size()];
        aFLRAngebotpositionReport = (FLRAngebotpositionReport[]) list.toArray(aFLRAngebotpositionReport);
    } catch (HibernateException he) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_HIBERNATE, new Exception(he));
    } catch (Throwable t) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER, new Exception(t));
    }

    return aFLRAngebotpositionReport;
}

From source file:com.lp.server.angebot.ejbfac.AngebotReportFacBean.java

License:Open Source License

/**
 * reportflr: 2 Diese Methode liefert eine Liste von allen
 * Angebotspositionen eines Mandanten, die nach den eingegebenen Kriterien
 * des Benutzers zusammengestellt wird. <br>
 * Achtung: Hibernate verwendet lazy initialization, d.h. der Zugriff auf
 * Collections muss innerhalb der Session erfolgen.
 * //from   w w  w.  ja v  a2  s  .c  om
 * @param kritDtoI
 *            die Filter- und Sortierkriterien
 * @param cAktuellerReport
 *            wird fuer alle und offene Angebote verwendet
 * @param theClientDto
 *            der aktuelle Benutzer
 * @return ReportAngebotpositionDto[] die Liste aller Positionen.
 * @throws EJBExceptionLP
 *             Ausnahme
 */
private ReportAngebotpositionJournalDto[] getListeAngebotpositionenJournal(
        ReportAngebotJournalKriterienDto kritDtoI, String erledigungsgrundCNr, String cAktuellerReport,
        TheClientDto theClientDto) throws EJBExceptionLP {

    ReportAngebotpositionJournalDto[] aResult = null;
    Session session = null;
    // es gilt das Locale des Benutzers
    Locale locDruck = theClientDto.getLocUi();
    try {
        SessionFactory factory = FLRSessionFactory.getFactory();
        session = factory.openSession();

        // Criteria duerfen keine Texts oder Blobs enthalten!

        // Criteria anlegen fuer alle referenzierten Objekte anlegen
        Criteria crit = session.createCriteria(FLRAngebotpositionReport.class);
        Criteria critAngebot = crit.createCriteria(AngebotpositionFac.FLR_ANGEBOTPOSITION_FLRANGEBOT);

        // Einschraenken nach Mandant
        critAngebot.add(Restrictions.eq("mandant_c_nr", theClientDto.getMandant()));

        // Einschraenken nach Status
        if (cAktuellerReport.equals(AngebotReportFac.REPORT_ANGEBOT_JOURNAL_ALLE)) {
            if (kritDtoI.getBNurErledigteAngebote()) {
                critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                        AngebotServiceFac.ANGEBOTSTATUS_ERLEDIGT));
                if (erledigungsgrundCNr != null) {
                    critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTERLEDIGUNGSGRUND_C_NR,
                            erledigungsgrundCNr));
                }
            } else {
                // PJ 07/0011040
                /*
                 * critAngebot.add(Restrictions.ne(
                 * AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                 * AngebotServiceFac.ANGEBOTSTATUS_ANGELEGT));
                 */
                critAngebot.add(Restrictions.ne(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                        AngebotServiceFac.ANGEBOTSTATUS_STORNIERT));
            }
        } else if (cAktuellerReport.equals(AngebotReportFac.REPORT_ANGEBOT_JOURNAL_OFFENE)) {
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_ANGEBOTSTATUS_C_NR,
                    AngebotServiceFac.ANGEBOTSTATUS_OFFEN));
        }

        // UW 22.03.06 alle nicht alternativen Positionen mit positiver
        // Menge
        crit.add(Restrictions.isNotNull(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE));
        crit.add(Restrictions.gt(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE, new BigDecimal(0)));
        crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_B_ALTERNATIVE, new Short((short) 0)));

        // Einschraenkung nach einer bestimmten Kostenstelle
        if (kritDtoI.kostenstelleIId != null) {
            critAngebot
                    .add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_KOSTENSTELLE_I_ID, kritDtoI.kostenstelleIId));
        }

        // Einschraenkung nach einem bestimmten Kunden
        if (kritDtoI.kundeIId != null) {
            critAngebot
                    .add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_KUNDE_I_ID_ANGEBOTSADRESSE, kritDtoI.kundeIId));
        }

        // Einschraenkung nach einem bestimmten Vertreter
        if (kritDtoI.vertreterIId != null) {
            critAngebot.add(Restrictions.eq(AngebotFac.FLR_ANGEBOT_VERTRETER_I_ID, kritDtoI.vertreterIId));
        }
        /*
         * // Belegdatum von bis: flrangebotposition >
         * flrangebot.t_belegdatum if (kritDtoI.dVon != null) {
         * critAngebot.add(Restrictions.ge(
         * AngebotFac.FLR_ANGEBOT_T_BELEGDATUM, kritDtoI.dVon)); }
         * 
         * if (kritDtoI.dBis != null) { critAngebot.add(Restrictions.le(
         * AngebotFac.FLR_ANGEBOT_T_BELEGDATUM, kritDtoI.dBis)); }
         */
        if (kritDtoI.dVon != null && kritDtoI.dBis != null) {
            Calendar cal = Calendar.getInstance();
            Timestamp von = null;
            cal.setTimeInMillis(kritDtoI.dVon.getTime());
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            cal.set(Calendar.HOUR_OF_DAY, 0);
            cal.set(Calendar.MILLISECOND, 0);
            von = new Timestamp(cal.getTimeInMillis());

            Timestamp bis = null;
            cal.setTimeInMillis(kritDtoI.dBis.getTime());
            cal.set(Calendar.MINUTE, 59);
            cal.set(Calendar.SECOND, 59);
            cal.set(Calendar.HOUR_OF_DAY, 23);
            bis = new Timestamp(cal.getTimeInMillis());
            critAngebot.add(Restrictions.between(AngebotFac.FLR_ANGEBOT_T_BELEGDATUM, von, bis));
        }

        // Einschraenkung nach Belegnummer von - bis
        LpBelegnummerFormat f = getBelegnummerGeneratorObj().getBelegnummernFormat(theClientDto.getMandant());

        Integer iGeschaeftsjahr = getParameterFac().getGeschaeftsjahr(theClientDto.getMandant());

        String sMandantKuerzel = getParameterFac().getMandantparameter(theClientDto.getMandant(),
                ParameterFac.KATEGORIE_ALLGEMEIN, ParameterFac.PARAMETER_BELEGNUMMER_MANDANTKENNUNG).getCWert();

        if (kritDtoI.sBelegnummerVon != null) {
            critAngebot.add(Restrictions.ge("c_nr", HelperServer.getBelegnummernFilterForHibernateCriterias(f,
                    iGeschaeftsjahr, sMandantKuerzel, kritDtoI.sBelegnummerVon)));
        }

        if (kritDtoI.sBelegnummerBis != null) {
            critAngebot.add(Restrictions.le("c_nr", HelperServer.getBelegnummernFilterForHibernateCriterias(f,
                    iGeschaeftsjahr, sMandantKuerzel, kritDtoI.sBelegnummerBis)));
        }

        // Sortierung nach Kostenstelle ist immer die erste Sortierung
        if (kritDtoI.bSortiereNachKostenstelle) {
            critAngebot.createCriteria(AngebotFac.FLR_ANGEBOT_FLRKOSTENSTELLE).addOrder(Order.asc("c_nr"));
        }

        // Sortierung nach Kunde, eventuell innerhalb der Kostenstelle
        if (kritDtoI.iSortierung == ReportJournalKriterienDto.KRIT_SORT_NACH_PARTNER) {
            critAngebot.createCriteria(AngebotFac.FLR_ANGEBOT_FLRKUNDE).createCriteria(KundeFac.FLR_PARTNER)
                    .addOrder(Order.asc(PartnerFac.FLR_PARTNER_NAME1NACHNAMEFIRMAZEILE1));
        }

        // Sortierung nach Vertreter, eventuell innerhalb der Kostenstelle
        if (kritDtoI.iSortierung == ReportAngebotJournalKriterienDto.KRIT_SORT_NACH_VERTRETER) {
            critAngebot.createCriteria(AngebotFac.FLR_ANGEBOT_FLRVERTRETER)
                    .addOrder(Order.asc(PersonalFac.FLR_PERSONAL_C_KURZZEICHEN));
        }

        if (cAktuellerReport.equals(AngebotReportFac.REPORT_ANGEBOT_JOURNAL_ALLE)) {
            if (kritDtoI.getBNurErledigteAngebote()) {
                critAngebot.addOrder(Order.asc(AngebotFac.FLR_ANGEBOT_ANGEBOTERLEDIGUNGSGRUND_C_NR));
            } else {
                critAngebot.addOrder(Order.asc("c_nr"));
            }
        } else {
            // es wird in jedem Fall nach der Belegnummer sortiert
            critAngebot.addOrder(Order.asc("c_nr"));
        }
        List<?> list = crit.list();
        aResult = new ReportAngebotpositionJournalDto[list.size()];
        int iIndex = 0;
        Iterator<?> it = list.iterator();
        ReportAngebotpositionJournalDto reportDto = null;

        while (it.hasNext()) {
            FLRAngebotpositionReport flrangebotposition = (FLRAngebotpositionReport) it.next();
            FLRAngebot flrangebot = flrangebotposition.getFlrangebot();
            FLRArtikel flrartikel = flrangebotposition.getFlrartikel();

            reportDto = new ReportAngebotpositionJournalDto();
            reportDto.setIId(flrangebot.getI_id());
            reportDto.setCNr(flrangebot.getC_nr());

            if (flrangebot.getAngeboterledigungsgrund_c_nr() != null) {
                AngeboterledigungsgrundDto angeboterledigungsgrundDto = getAngebotServiceFac()
                        .angeboterledigungsgrundFindByPrimaryKey(flrangebot.getAngeboterledigungsgrund_c_nr(),
                                theClientDto);
                reportDto.setAngeboterledigungsgrundCNr(angeboterledigungsgrundDto.getBezeichnung());
            }
            reportDto.setKundeCName1(flrangebot.getFlrkunde().getFlrpartner().getC_name1nachnamefirmazeile1());
            reportDto.setKundeCName2(flrangebot.getFlrkunde().getFlrpartner().getC_name2vornamefirmazeile2());
            reportDto.setKundeCName3(flrangebot.getFlrkunde().getFlrpartner().getC_name3vorname2abteilung());
            reportDto.setKundeStrasse(flrangebot.getFlrkunde().getFlrpartner().getC_strasse());
            if (flrangebot.getFlrkunde().getFlrpartner().getFlrlandplzort() != null) {
                reportDto.setKundePlz(flrangebot.getFlrkunde().getFlrpartner().getFlrlandplzort().getC_plz());
                reportDto.setKundeLkz(
                        flrangebot.getFlrkunde().getFlrpartner().getFlrlandplzort().getFlrland().getC_lkz());
                reportDto.setKundeOrt(
                        flrangebot.getFlrkunde().getFlrpartner().getFlrlandplzort().getFlrort().getC_name());
            }

            reportDto.setKundeEmail(flrangebot.getFlrkunde().getFlrpartner().getC_email());

            reportDto.setKundeFax(flrangebot.getFlrkunde().getFlrpartner().getC_fax());

            reportDto.setKundeTelefon(flrangebot.getFlrkunde().getFlrpartner().getC_telefon());

            AngebotDto angebotDto = getAngebotFac().angebotFindByPrimaryKey(flrangebot.getI_id(), theClientDto);
            if (angebotDto.getAnsprechpartnerIIdKunde() != null) {
                AnsprechpartnerDto ansprechpartnerDto = getAnsprechpartnerFac()
                        .ansprechpartnerFindByPrimaryKey(angebotDto.getAnsprechpartnerIIdKunde(), theClientDto);

                reportDto.setAnsprechpartnerNachname(
                        ansprechpartnerDto.getPartnerDto().getCName1nachnamefirmazeile1());
                reportDto.setAnsprechpartnerVorname(
                        ansprechpartnerDto.getPartnerDto().getCName2vornamefirmazeile2());
                reportDto.setAnsprechpartnerAnrede(ansprechpartnerDto.getPartnerDto().getAnredeCNr());
                reportDto.setAnsprechpartnerTitel(ansprechpartnerDto.getPartnerDto().getCTitel());

                reportDto.setAnsprechpartnerFax(ansprechpartnerDto.getCDirektfax());

                reportDto.setAnsprechpartnerFaxDw(ansprechpartnerDto.getCFax());

                reportDto.setAnsprechpartnerTelefon(ansprechpartnerDto.getCHandy());

                reportDto.setAnsprechpartnerTelefonDw(ansprechpartnerDto.getCTelefon());

                reportDto.setAnsprechpartnerEmail(ansprechpartnerDto.getCEmail());

            }

            reportDto.setKostenstelleCNr(flrangebot.getFlrkostenstelle().getC_nr());
            reportDto.setVertreterCName1(
                    getPersonalFac().personalFindByPrimaryKey(flrangebot.getVertreter_i_id(), theClientDto)
                            .getPartnerDto().formatFixName2Name1());
            reportDto.setProjektBez(flrangebot.getC_bez());
            reportDto.setRealisierungstermin(
                    Helper.formatDatum(flrangebot.getT_realisierungstermin(), theClientDto.getLocUi()));

            if (flrangebot.getAngeboterledigungsgrund_c_nr() != null)
                if (flrangebot.getAngeboterledigungsgrund_c_nr()
                        .equals(AngebotServiceFac.ANGEBOTERLEDIGUNGSGRUND_AUFTRAGERHALTEN)) {
                    AuftragDto[] auftrag = getAuftragFac().auftragFindByAngebotIId(flrangebot.getI_id(),
                            theClientDto);
                    if (auftrag != null && auftrag.length > 0) {
                        reportDto.setErledigungsgrundABNr(auftrag[0].getCNr());
                    }
                }

            // UW 08.03.06 Es kann sich um eine Ident, Handeingabe oder
            // AGStueckliste handeln
            String identCNr = null;
            String identCBez = null;

            if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_IDENT)) {
                identCNr = flrartikel.getC_nr();
                identCBez = getArtikelFac().formatArtikelbezeichnungEinzeiligOhneExc(flrartikel.getI_id(),
                        theClientDto.getLocUi());
            } else if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_AGSTUECKLISTE)) {
                identCBez = flrangebotposition.getFlragstkl().getC_bez();
            } else if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_HANDEINGABE)) {
                identCBez = getArtikelFac().formatArtikelbezeichnungEinzeiligOhneExc(flrartikel.getI_id(),
                        theClientDto.getLocUi());
            }

            reportDto.setArtikelCNr(identCNr);
            reportDto.setArtikelCBez(identCBez);

            reportDto.setNMenge(flrangebotposition.getN_menge());
            reportDto.setEinheitCNr(flrangebotposition.getEinheit_c_nr() == null ? ""
                    : flrangebotposition.getEinheit_c_nr().trim());
            reportDto.setDAuftragwahrscheinlichkeit(flrangebot.getF_auftragswahrscheinlichkeit());
            reportDto.setNWert(flrangebot.getN_gesamtangebotswertinangebotswaehrung());

            // Umrechnen in Mandantenwaehrung, Positionspreise sind in
            // Belegwaehrung abgelegt
            BigDecimal nPreisAmDruck = flrangebotposition
                    .getN_nettogesamtpreisplusversteckteraufschlagminusrabatte();

            nPreisAmDruck = getBetragMalWechselkurs(nPreisAmDruck, Helper.getKehrwert(new BigDecimal(
                    flrangebot.getF_wechselkursmandantwaehrungzuangebotswaehrung().doubleValue())));

            reportDto.setNPreis(nPreisAmDruck);

            aResult[iIndex] = reportDto;
            iIndex++;
        }
    } catch (Throwable t) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FLR, new Exception(t));
    } finally {
        try {
            session.close();
        } catch (HibernateException he) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER_HIBERNATE, he);
        }
    }

    return aResult;
}

From source file:com.lp.server.angebot.ejbfac.AngebotReportFacBean.java

License:Open Source License

/**
 * Die Vorkalkulation eines Angebots drucken. <br>
 * Beruecksichtigt werden nur preisbehaftete Positionen.
 * //  w  w  w.java  2 s  . com
 * @param iIdAngebotI
 *            PK des Angebots
 * @param theClientDto
 *            der aktuelle Benutzer
 * @return JasperPrint der Druck
 * @throws EJBExceptionLP
 *             Ausnahme
 */
public JasperPrintLP printAngebotVorkalkulation(Integer iIdAngebotI, TheClientDto theClientDto)
        throws EJBExceptionLP {
    JasperPrintLP oPrint = null;
    cAktuellerReport = AngebotReportFac.REPORT_VORKALKULATION;
    Session session = null;

    try {
        AngebotDto angebotDto = getAngebotFac().angebotFindByPrimaryKey(iIdAngebotI, theClientDto);

        // UW 29.03.06 Tiefe der Stuecklistenaufloeseung bestimmen
        ParametermandantDto parametermandantDto = getParameterFac().getMandantparameter(
                theClientDto.getMandant(), ParameterFac.KATEGORIE_ANGEBOT,
                ParameterFac.PARAMETER_ANGEBOT_AGVORKALK_STKL_AUFLOESUNG_TIEFE);

        ParametermandantDto parameterGestpreisBerechnung = null;
        parameterGestpreisBerechnung = (ParametermandantDto) getParameterFac().getMandantparameter(
                theClientDto.getMandant(), ParameterFac.KATEGORIE_ALLGEMEIN,
                ParameterFac.PARAMETER_GESTPREISBERECHNUNG_HAUPTLAGER);

        boolean bGestpreisberechnungHauptlager = ((Boolean) parameterGestpreisBerechnung.getCWertAsObject())
                .booleanValue();

        int iStuecklisteaufloesungTiefe = ((Integer) parametermandantDto.getCWertAsObject()).intValue();

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

        Criteria crit = session.createCriteria(FLRAngebotpositionReport.class);
        crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_FLRANGEBOT + ".i_id", iIdAngebotI));

        // UW 22.03.06 alle nicht alternativen Positionen mit positiver
        // Menge
        crit.add(Restrictions.isNotNull(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE));
        crit.add(Restrictions.gt(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE, new BigDecimal(0)));
        crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_B_ALTERNATIVE, new Short((short) 0)));

        crit.addOrder(Order.asc(AngebotpositionFac.FLR_ANGEBOTPOSITION_I_SORT));

        // Liste aller Positionen, die behandelt werden sollen
        List<?> list = crit.list();

        Iterator itListe = list.iterator();

        ArrayList<Object[]> alDaten = new ArrayList<Object[]>();

        // Der Index der aktuell verarbeiteten Angebotposition, Index laeuft
        // ueber die Unterpositionen!
        int row = 0;

        while (itListe.hasNext()) { // iterieren ueber die
            row++;
            // gesamte Datenmatrix
            FLRAngebotpositionReport flrangebotposition = (FLRAngebotpositionReport) itListe.next();

            if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_IDENT)) {

                boolean bSetArtikel = false;
                StuecklisteDto stuecklisteDto = getStuecklisteFac()
                        .stuecklisteFindByMandantCNrArtikelIIdOhneExc(flrangebotposition.getArtikel_i_id(),
                                theClientDto);

                // wenn die aktuelle Artikelposition eine Stueckliste ist
                if (stuecklisteDto != null && stuecklisteDto.getStuecklisteartCNr()
                        .equals(StuecklisteFac.STUECKLISTEART_SETARTIKEL)) {
                    bSetArtikel = true;
                }

                // PJ15141

                // zum Befuellen der Preisinformationen muss bekannt sein,
                // ob es Stuecklistenpositionen gibt
                StuecklisteInfoDto stuecklisteInfoDto = getStuecklisteFac().getStrukturdatenEinesArtikels(
                        flrangebotposition.getArtikel_i_id(), false, null, // in die Rekursion mit einer
                        // leeren Listen einsteigen
                        0, // in die Rekursion mit Ebene 0
                        // einsteigen
                        iStuecklisteaufloesungTiefe, // alle
                        // Stuecklisten
                        // lt.
                        // Parameter
                        // aufloesen
                        true, // Basis sind die Einheiten der
                        // Stueckliste
                        flrangebotposition.getN_menge(), // Basis
                        // sind
                        // n
                        // Einheiten
                        // der
                        // Stueckliste
                        false, // Fremdfertigung nicht aufloesen
                        theClientDto);

                if (bSetArtikel == false && stuecklisteInfoDto.getIiAnzahlPositionen().intValue() > 0
                        && (!Helper.short2boolean(stuecklisteInfoDto.getBIstFremdfertigung())
                                || iStuecklisteaufloesungTiefe != 0)) {
                    alDaten.add(befuelleZeileVKMitIdentMitSTKLAusAngebotposition(flrangebotposition,
                            angebotDto.getTRealisierungstermin(), theClientDto));

                    if (stuecklisteInfoDto.getIiAnzahlPositionen().intValue() > 0) {
                        ArrayList<?> alStuecklisteAufgeloest = stuecklisteInfoDto.getAlStuecklisteAufgeloest();
                        Iterator<?> it = alStuecklisteAufgeloest.iterator();

                        while (it.hasNext()) {
                            alDaten.add(befuelleZeileVorkalkulationMitStuecklistenposition(
                                    flrangebotposition.getArtikel_i_id(), // eine
                                    // Zwischensumme
                                    // fuer den
                                    // uebergeordneten
                                    // Artikel
                                    // bilden
                                    "", (StuecklisteMitStrukturDto) it.next(),
                                    flrangebotposition.getFlrangebot().getWaehrung_c_nr_angebotswaehrung(),
                                    flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                    iStuecklisteaufloesungTiefe, bGestpreisberechnungHauptlager,
                                    angebotDto.getTRealisierungstermin(), theClientDto));
                        }
                    }
                } else {
                    // UW 29.03.06 Eine STKL wird wie ein normaler Artikel
                    // angedruckt, wenn...
                    // ...es sich um eine Fremdfertigung handelt
                    // ...es keine Positionen gibt
                    // ...die gewuenschte Aufloesungstiefe lt. Parameter 0
                    // ist
                    alDaten.add(befuelleZeileVKMitIdentOhneSTKLAusAngebotposition(flrangebotposition,
                            angebotDto.getTRealisierungstermin(), theClientDto, angebotDto.getWaehrungCNr()));
                }

                // PJ 16216
                StuecklisteDto stklDto = getStuecklisteFac().stuecklisteFindByMandantCNrArtikelIIdOhneExc(
                        flrangebotposition.getArtikel_i_id(), theClientDto);
                if (stklDto != null && (!Helper.short2boolean(stklDto.getBFremdfertigung())
                        || iStuecklisteaufloesungTiefe != 0)) {

                    StuecklistearbeitsplanDto[] stuecklistearbeitsplanDtos = getStuecklisteFac()
                            .stuecklistearbeitsplanFindByStuecklisteIId(stklDto.getIId(), theClientDto);

                    for (int i = 0; i < stuecklistearbeitsplanDtos.length; i++) {
                        StuecklistearbeitsplanDto stuecklistearbeitsplanDto = stuecklistearbeitsplanDtos[i];

                        if (stklDto.getIErfassungsfaktor() != 0) {
                            stuecklistearbeitsplanDto.setLStueckzeit(stuecklistearbeitsplanDto.getLStueckzeit()
                                    / stklDto.getIErfassungsfaktor());
                        }

                        if (!Helper.short2boolean(stuecklistearbeitsplanDto.getBNurmaschinenzeit())) {

                            alDaten.add(befuelleZeileVorkalkulationMitStuecklistearbeitsplan(
                                    flrangebotposition.getArtikel_i_id(), // eine
                                    // Zwischensumme
                                    // fuer den
                                    // uebergeordneten
                                    // Artikel
                                    // bilden
                                    "", stuecklistearbeitsplanDto,
                                    flrangebotposition.getFlrangebot().getWaehrung_c_nr_angebotswaehrung(),
                                    flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                    iStuecklisteaufloesungTiefe, bGestpreisberechnungHauptlager,
                                    angebotDto.getTRealisierungstermin(), stklDto, theClientDto, false));
                        }
                        if (stuecklistearbeitsplanDto.getMaschineIId() != null) {

                            alDaten.add(befuelleZeileVorkalkulationMitStuecklistearbeitsplan(
                                    flrangebotposition.getArtikel_i_id(), // eine
                                    // Zwischensumme
                                    // fuer den
                                    // uebergeordneten
                                    // Artikel
                                    // bilden
                                    "", stuecklistearbeitsplanDto,
                                    flrangebotposition.getFlrangebot().getWaehrung_c_nr_angebotswaehrung(),
                                    flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                    iStuecklisteaufloesungTiefe, bGestpreisberechnungHauptlager,
                                    angebotDto.getTRealisierungstermin(), stklDto, theClientDto, true));
                        }

                    }

                }

            } else if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_HANDEINGABE)) {
                alDaten.add(befuelleZeileVKMitHandAusAngebotposition(flrangebotposition, theClientDto));

            } else if (flrangebotposition.getAngebotpositionart_c_nr()
                    .equals(AngebotServiceFac.ANGEBOTPOSITIONART_AGSTUECKLISTE)) {
                // jede Zeile muss als INDEX_GRUPPE die AGSTKL cNr haben!
                alDaten.add(befuelleZeileVKMitAGSTKLPosition(flrangebotposition, theClientDto));

                AgstklpositionDto[] aAgstklpositionDto = getAngebotstklpositionFac()
                        .agstklpositionFindByAgstklIIdOhneExc(flrangebotposition.getAgstkl_i_id(),
                                theClientDto);

                // Einrueckungsebene gegenueber der AGSTKL
                String cEinrueckung = "    ";

                for (int j = 0; j < aAgstklpositionDto.length; j++) {
                    // AGPosition ist dieselbe, aber die naechste Zeile
                    // im data[][] befuellen

                    ArtikelDto artikelDtoAgstklposition = getArtikelFac()
                            .artikelFindByPrimaryKeySmall(aAgstklpositionDto[j].getArtikelIId(), theClientDto);

                    if (artikelDtoAgstklposition.getArtikelartCNr().equals(ArtikelFac.ARTIKELART_HANDARTIKEL)) {

                        alDaten.add(befuelleZeileVKMitHandAusAGSTKLPosition(aAgstklpositionDto[j],
                                flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                theClientDto, cEinrueckung));
                    } else {
                        // jeder Artikel koennte selbst wieder ein
                        // Stueckliste mit Unterpositionen sein
                        StuecklisteInfoDto stuecklisteInfoDto = getStuecklisteFac()
                                .getStrukturdatenEinesArtikels(aAgstklpositionDto[j].getArtikelIId(), false,
                                        null, // in die Rekursion mit
                                        // einer
                                        // leeren Listen einsteigen
                                        0, // in die Rekursion mit Ebene 0
                                        // einsteigen
                                        iStuecklisteaufloesungTiefe, // alle
                                        // Stuecklisten
                                        // lt
                                        // .
                                        // Parameter
                                        // aufloesen
                                        true, // Basis sind die n Einheiten
                                        // der AGSTKL
                                        flrangebotposition.getN_menge()
                                                .multiply(aAgstklpositionDto[j].getNMenge()), // Basismenge
                                        false, // Fremdfertigung nicht
                                        // aufloesen
                                        theClientDto);

                        // wenn die Identposition selbst eine echte STKL ist
                        if (stuecklisteInfoDto.getIiAnzahlPositionen().intValue() > 0
                                && (!Helper.short2boolean(stuecklisteInfoDto.getBIstFremdfertigung())
                                        || iStuecklisteaufloesungTiefe != 0)) {
                            alDaten.add(befuelleZeileVKMitIdentMitSTKLAusAGSTKLPosition(aAgstklpositionDto[j],
                                    flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                    angebotDto.getTRealisierungstermin(), theClientDto, cEinrueckung));
                            ArrayList<?> alStuecklisteAufgeloest = stuecklisteInfoDto
                                    .getAlStuecklisteAufgeloest();
                            Iterator<?> it = alStuecklisteAufgeloest.iterator();

                            while (it.hasNext()) {
                                StuecklisteMitStrukturDto stuktDto = (StuecklisteMitStrukturDto) it.next();

                                alDaten.add(befuelleZeileVorkalkulationMitStuecklistenposition(
                                        flrangebotposition.getAgstkl_i_id(), cEinrueckung, stuktDto,
                                        flrangebotposition.getFlrangebot().getWaehrung_c_nr_angebotswaehrung(),
                                        aAgstklpositionDto[j].getNMenge(),
                                        aAgstklpositionDto[j].getEinheitCNr(), iStuecklisteaufloesungTiefe,
                                        bGestpreisberechnungHauptlager, angebotDto.getTRealisierungstermin(),
                                        theClientDto));
                            }

                        } else {
                            alDaten.add(befuelleZeileVKMitIdentOhneSTKLAusAGSTKLPosition(aAgstklpositionDto[j],
                                    flrangebotposition.getN_menge(), flrangebotposition.getEinheit_c_nr(),
                                    theClientDto, angebotDto.getTRealisierungstermin(), cEinrueckung));
                        }
                    }
                }

            }
        }
        data = new Object[alDaten.size()][AngebotReportFac.REPORT_ANGEBOT_ANZAHL_SPALTEN];
        data = (Object[][]) alDaten.toArray(data);

        // Erstellung des Report
        HashMap<String, Object> parameter = new HashMap<String, Object>();

        // es gilt das Locale des Benutzers
        Locale locDruck = theClientDto.getLocUi();

        KundeDto kundeDto = getKundeFac().kundeFindByPrimaryKey(angebotDto.getKundeIIdAngebotsadresse(),
                theClientDto);

        AnsprechpartnerDto ansprechpartnerDto = null;

        if (angebotDto.getAnsprechpartnerIIdKunde() != null) {
            ansprechpartnerDto = getAnsprechpartnerFac()
                    .ansprechpartnerFindByPrimaryKey(angebotDto.getAnsprechpartnerIIdKunde(), theClientDto);
        }

        MandantDto mandantDto = getMandantFac().mandantFindByPrimaryKey(theClientDto.getMandant(),
                theClientDto);

        parameter.put(LPReport.P_ADRESSBLOCK,
                formatAdresseFuerAusdruck(kundeDto.getPartnerDto(), ansprechpartnerDto, mandantDto, locDruck));
        parameter.put("P_ANGEBOTNUMMER", angebotDto.getCNr());

        parameter.put("P_KOMMENTAR_INTERN", angebotDto.getXInternerkommentar());
        parameter.put("P_KOMMENTAR_EXTERN", angebotDto.getXExternerkommentar());

        parameter.put("P_ANGEBOTCBEZ", angebotDto.getCBez() != null ? angebotDto.getCBez() : "");
        parameter.put("P_LIEFERART", getLocaleFac()
                .lieferartFindByIIdLocaleOhneExc(angebotDto.getLieferartIId(), locDruck, theClientDto));

        // Lieferzeit in hinterlegter Einheit
        Integer iiLieferzeit = getAngebotServiceFac().getLieferzeitInAngeboteinheit(angebotDto.getIId(),
                angebotDto.getAngeboteinheitCNr(), theClientDto);

        parameter.put("P_ANGEBOTEINHEIT",
                getSystemFac().formatEinheit(angebotDto.getAngeboteinheitCNr(), locDruck, theClientDto));

        parameter.put("P_LIEFERZEIT", iiLieferzeit);
        parameter.put("P_BELEGWAEHRUNG", angebotDto.getWaehrungCNr());
        parameter.put("P_MANDANTENWAEHRUNG", theClientDto.getSMandantenwaehrung());
        parameter.put("P_WECHSELKURSMANDANTZUBELEG",
                angebotDto.getFWechselkursmandantwaehrungzubelegwaehrung());

        // das Zahlungsziel
        parameter.put("P_ZAHLUNGSZIEL", getMandantFac()
                .zahlungszielFindByIIdLocaleOhneExc(angebotDto.getZahlungszielIId(), locDruck, theClientDto));
        parameter.put("P_BELEGDATUM", angebotDto.getTBelegdatum());
        parameter.put("P_ANGEBOTSGUELTIGKEIT", angebotDto.getTAngebotsgueltigkeitbis());

        parameter.put("P_ALLGEMEINERRABATT", angebotDto.getFAllgemeinerRabattsatz());
        parameter.put("P_ALLGEMEINERRABATT_STRING",
                Helper.formatZahl(angebotDto.getFAllgemeinerRabattsatz(), locDruck));
        parameter.put("P_PROJEKT_RABATT", angebotDto.getFProjektierungsrabattsatz());
        parameter.put("P_PROJEKT_RABATT_STRING",
                Helper.formatZahl(angebotDto.getFProjektierungsrabattsatz(), locDruck));
        parameter.put("P_VERSTECKTER_AUFSCHLAG", angebotDto.getFVersteckterAufschlag());
        parameter.put("P_VERSTECKTER_AUFSCHLAG_STRING",
                Helper.formatZahl(angebotDto.getFVersteckterAufschlag(), locDruck));
        parameter.put("P_REALISIERUNGSTERMIN", angebotDto.getTRealisierungstermin());

        initJRDS(parameter, AngebotReportFac.REPORT_MODUL, AngebotReportFac.REPORT_VORKALKULATION,
                theClientDto.getMandant(), theClientDto.getLocUi(), theClientDto);

        oPrint = getReportPrint();
    } catch (RemoteException ex) {
        throwEJBExceptionLPRespectOld(ex);
    } finally {
        try {
            session.close();
        } catch (HibernateException he) {
            throw new EJBExceptionLP(EJBExceptionLP.FEHLER_HIBERNATE, he);
        }
    }

    return oPrint;
}

From source file:com.lp.server.angebot.ejbfac.AngebotReportFacBean.java

License:Open Source License

/**
 * Ueber Hibernate alle berechnungsrelevanten Positionen eines Angebots
 * holen. <br>//  ww  w  .j a va  2s  .  c  om
 * Diese Methode mu&szlig; innerhalb einer offenen Hibernate Session aufgerufen
 * werden. <br>
 * 
 * @todo diese Methode muesste eigentlich in der AngebotpositionFac
 *       sitzen... PJ 3799
 * 
 * @param sessionI
 *            die Hibernate Session
 * @param iIdAngebotI
 *            PK des Angebots
 * @param bNurMengenbehafteteI
 *            nur mengenbehaftete Positionen beruecksichtigen
 * @param bNurPositiveMengenI
 *            nur positive Mengen beruecksichtigen; wird bei
 *            !bNurMengenbehafteteI nicht ausgewertet
 * @param bOhneAlternativenI
 *            alternative Positionen werden nicht beruecksichtigt
 * @return FLRAngebotpositionReport[] die berechnungsrelevanten Positionen
 * @throws EJBExceptionLP
 *             Ausnahme
 */
private FLRAngebotpositionReport[] holeAngebotpositionen(Session sessionI, Integer iIdAngebotI,
        boolean bNurMengenbehafteteI, boolean bNurPositiveMengenI, boolean bOhneAlternativenI)
        throws EJBExceptionLP {
    FLRAngebotpositionReport[] aFLRAngebotpositionReport = null;

    try {
        Criteria crit = sessionI.createCriteria(FLRAngebotpositionReport.class);

        crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_ANGEBOT_I_ID, iIdAngebotI));

        if (bNurMengenbehafteteI) {
            crit.add(Restrictions.isNotNull(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE));

            if (bNurPositiveMengenI) {
                crit.add(Restrictions.gt(AngebotpositionFac.FLR_ANGEBOTPOSITION_N_MENGE, new BigDecimal(0)));
            }
        }

        // nur Positionen beruecksichtigen, die keine Alternative sind
        if (bOhneAlternativenI) {
            crit.add(Restrictions.eq(AngebotpositionFac.FLR_ANGEBOTPOSITION_B_ALTERNATIVE,
                    new Short((short) 0)));
        }
        crit.addOrder(Order.asc("i_sort"));

        // Liste aller Positionen, die behandelt werden sollen
        java.util.List<?> list = crit.list();
        aFLRAngebotpositionReport = new FLRAngebotpositionReport[list.size()];
        aFLRAngebotpositionReport = (FLRAngebotpositionReport[]) list.toArray(aFLRAngebotpositionReport);
    } catch (HibernateException he) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER_HIBERNATE, new Exception(he));
    } catch (Throwable t) {
        throw new EJBExceptionLP(EJBExceptionLP.FEHLER, new Exception(t));
    }

    return aFLRAngebotpositionReport;
}