Example usage for java.math BigDecimal add

List of usage examples for java.math BigDecimal add

Introduction

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

Prototype

public BigDecimal add(BigDecimal augend) 

Source Link

Document

Returns a BigDecimal whose value is (this + augend) , and whose scale is max(this.scale(), augend.scale()) .

Usage

From source file:com.aoindustries.website.signup.SignupCustomizeManagementActionHelper.java

public static void setRequestAttributes(ServletContext servletContext, HttpServletRequest request,
        HttpServletResponse response, SignupSelectPackageForm signupSelectPackageForm,
        SignupCustomizeServerForm signupCustomizeServerForm,
        SignupCustomizeManagementForm signupCustomizeManagementForm) throws IOException, SQLException {
    AOServConnector rootConn = SiteSettings.getInstance(servletContext).getRootAOServConnector();
    PackageDefinition packageDefinition = rootConn.getPackageDefinitions()
            .get(signupSelectPackageForm.getPackageDefinition());
    if (packageDefinition == null)
        throw new SQLException(
                "Unable to find PackageDefinition: " + signupSelectPackageForm.getPackageDefinition());
    List<PackageDefinitionLimit> limits = packageDefinition.getLimits();

    // Get the total harddrive space in gigabytes
    int totalHardwareDiskSpace = SignupCustomizeServerActionHelper.getTotalHardwareDiskSpace(rootConn,
            signupCustomizeServerForm);//from  ww w.ja v  a2  s  .c  o m

    // Find all the options
    List<Option> backupOnsiteOptions = new ArrayList<Option>();
    List<Option> backupOffsiteOptions = new ArrayList<Option>();
    List<Option> distributionScanOptions = new ArrayList<Option>();
    List<Option> failoverOptions = new ArrayList<Option>();
    for (PackageDefinitionLimit limit : limits) {
        Resource resource = limit.getResource();
        String resourceName = resource.getName();
        if (resourceName.startsWith("backup_onsite_")) {
            int limitPower = limit.getHardLimit();
            if (limitPower == PackageDefinitionLimit.UNLIMITED || limitPower > 0) {
                // This is per gigabyte of physical space
                BigDecimal additionalRate = limit.getAdditionalRate();
                if (additionalRate == null)
                    additionalRate = BigDecimal.valueOf(0, 2);
                backupOnsiteOptions.add(new Option(limit.getPkey(), resource.toString(),
                        additionalRate.multiply(BigDecimal.valueOf(totalHardwareDiskSpace))));
            }
        } else if (resourceName.startsWith("backup_offsite_")) {
            int limitPower = limit.getHardLimit();
            if (limitPower == PackageDefinitionLimit.UNLIMITED || limitPower > 0) {
                // This is per gigabyte of physical space
                BigDecimal additionalRate = limit.getAdditionalRate();
                if (additionalRate == null)
                    additionalRate = BigDecimal.valueOf(0, 2);
                backupOffsiteOptions.add(new Option(limit.getPkey(), resource.toString(),
                        additionalRate.multiply(BigDecimal.valueOf(totalHardwareDiskSpace))));
            }
        }
    }
    // Distribution scan option
    {
        Resource resource = rootConn.getResources().get(Resource.DISTRIBUTION_SCAN);
        if (resource == null) {
            servletContext.log(null,
                    new SQLException("Unable to find Resource: " + Resource.DISTRIBUTION_SCAN));
        } else {
            PackageDefinitionLimit limit = packageDefinition.getLimit(resource);
            if (limit != null) {
                int hard = limit.getHardLimit();
                if (hard == PackageDefinitionLimit.UNLIMITED || hard > 0) {
                    BigDecimal additionalRate = limit.getAdditionalRate();
                    if (additionalRate == null)
                        additionalRate = BigDecimal.valueOf(0, 2);
                    distributionScanOptions
                            .add(new Option(limit.getPkey(), resource.toString(), additionalRate));
                }
            }
        }
    }
    // Failover option
    {
        Resource resource = rootConn.getResources().get(Resource.FAILOVER);
        if (resource == null) {
            servletContext.log(null, new SQLException("Unable to find Resource: " + Resource.FAILOVER));
        } else {
            PackageDefinitionLimit limit = packageDefinition.getLimit(resource);
            if (limit != null) {
                int hard = limit.getHardLimit();
                if (hard == PackageDefinitionLimit.UNLIMITED || hard > 0) {
                    // This is per gigabyte of physical space
                    BigDecimal additionalRate = limit.getAdditionalRate();
                    if (additionalRate == null)
                        additionalRate = BigDecimal.valueOf(0, 2);
                    additionalRate = additionalRate.multiply(BigDecimal.valueOf(totalHardwareDiskSpace));
                    failoverOptions.add(new Option(limit.getPkey(), resource.toString(), additionalRate));

                    // Only once the failover option is available will the MySQL replication option be available
                    Resource mrResource = rootConn.getResources().get(Resource.MYSQL_REPLICATION);
                    if (mrResource == null) {
                        servletContext.log(null,
                                new SQLException("Unable to find Resource: " + Resource.MYSQL_REPLICATION));
                    } else {
                        PackageDefinitionLimit mrLimit = packageDefinition.getLimit(mrResource);
                        if (mrLimit != null) {
                            int mrHard = mrLimit.getHardLimit();
                            if (mrHard == PackageDefinitionLimit.UNLIMITED || mrHard > 0) {
                                BigDecimal mrAdditionalRate = mrLimit.getAdditionalRate();
                                if (mrAdditionalRate == null)
                                    mrAdditionalRate = BigDecimal.valueOf(0, 2);
                                failoverOptions.add(new Option(mrLimit.getPkey(), mrResource.toString(),
                                        additionalRate.add(mrAdditionalRate)));
                            }
                        }
                    }
                }
            }
        }
    }

    if (!backupOnsiteOptions.isEmpty())
        backupOnsiteOptions.add(0, new Option(-1, "No On-Site Backup", BigDecimal.valueOf(0, 2)));
    if (!backupOffsiteOptions.isEmpty())
        backupOffsiteOptions.add(0, new Option(-1, "No Off-Site Backup", BigDecimal.valueOf(0, 2)));
    if (!distributionScanOptions.isEmpty())
        distributionScanOptions.add(0, new Option(-1, "No daily scans", BigDecimal.valueOf(0, 2)));
    if (!failoverOptions.isEmpty())
        failoverOptions.add(0, new Option(-1, "No Fail-Over Mirror", BigDecimal.valueOf(0, 2)));

    // Sort by price
    Collections.sort(backupOnsiteOptions, new Option.PriceComparator());
    Collections.sort(backupOffsiteOptions, new Option.PriceComparator());
    Collections.sort(distributionScanOptions, new Option.PriceComparator());
    Collections.sort(failoverOptions, new Option.PriceComparator());

    // Clear any customization settings that are not part of the current package definition (this happens when they
    // select a different package type)
    if (signupCustomizeManagementForm.getBackupOnsiteOption() != -1) {
        PackageDefinitionLimit pdl = rootConn.getPackageDefinitionLimits()
                .get(signupCustomizeManagementForm.getBackupOnsiteOption());
        if (pdl == null || !packageDefinition.equals(pdl.getPackageDefinition()))
            signupCustomizeManagementForm.setBackupOnsiteOption(-1);
    }
    if (signupCustomizeManagementForm.getBackupOffsiteOption() != -1) {
        PackageDefinitionLimit pdl = rootConn.getPackageDefinitionLimits()
                .get(signupCustomizeManagementForm.getBackupOffsiteOption());
        if (pdl == null || !packageDefinition.equals(pdl.getPackageDefinition()))
            signupCustomizeManagementForm.setBackupOffsiteOption(-1);
    }
    if (signupCustomizeManagementForm.getDistributionScanOption() != -1) {
        PackageDefinitionLimit pdl = rootConn.getPackageDefinitionLimits()
                .get(signupCustomizeManagementForm.getDistributionScanOption());
        if (pdl == null || !packageDefinition.equals(pdl.getPackageDefinition()))
            signupCustomizeManagementForm.setDistributionScanOption(-1);
    }
    if (signupCustomizeManagementForm.getFailoverOption() != -1) {
        PackageDefinitionLimit pdl = rootConn.getPackageDefinitionLimits()
                .get(signupCustomizeManagementForm.getFailoverOption());
        if (pdl == null || !packageDefinition.equals(pdl.getPackageDefinition()))
            signupCustomizeManagementForm.setFailoverOption(-1);
    }

    // Store to request
    request.setAttribute("packageDefinition", packageDefinition);
    request.setAttribute("hardwareRate", SignupCustomizeServerActionHelper.getHardwareMonthlyRate(rootConn,
            signupCustomizeServerForm, packageDefinition));
    request.setAttribute("backupOnsiteOptions", backupOnsiteOptions);
    request.setAttribute("backupOffsiteOptions", backupOffsiteOptions);
    request.setAttribute("distributionScanOptions", distributionScanOptions);
    request.setAttribute("failoverOptions", failoverOptions);
}

From source file:de.appsolve.padelcampus.utils.BookingUtil.java

public OfferDurationPrice getOfferDurationPrice(List<CalendarConfig> configs, List<Booking> confirmedBookings,
        LocalDate selectedDate, LocalTime selectedTime, Offer selectedOffer) throws CalendarConfigException {
    List<TimeSlot> timeSlotsForDate = getTimeSlotsForDate(selectedDate, configs, confirmedBookings,
            Boolean.TRUE, Boolean.TRUE);
    boolean validStartTime = false;
    for (TimeSlot timeSlot : timeSlotsForDate) {
        if (timeSlot.getStartTime().equals(selectedTime)) {
            validStartTime = true;/* ww  w.  ja  v a 2  s. c om*/
            break;
        }
    }

    OfferDurationPrice offerDurationPrices = null;
    if (validStartTime) {
        //convert to required data structure
        Map<Offer, List<CalendarConfig>> offerConfigMap = new HashMap<>();
        for (CalendarConfig config : configs) {
            for (Offer offer : config.getOffers()) {
                if (offer.equals(selectedOffer)) {
                    List<CalendarConfig> list = offerConfigMap.get(offer);
                    if (list == null) {
                        list = new ArrayList<>();
                    }
                    list.add(config);

                    //sort by start time
                    Collections.sort(list);
                    offerConfigMap.put(offer, list);
                }
            }
        }

        Iterator<Map.Entry<Offer, List<CalendarConfig>>> iterator = offerConfigMap.entrySet().iterator();
        //for every offer
        while (iterator.hasNext()) {
            Map.Entry<Offer, List<CalendarConfig>> entry = iterator.next();
            Offer offer = entry.getKey();
            List<CalendarConfig> configsForOffer = entry.getValue();

            //make sure the first configuration starts before the requested booking time
            if (selectedTime.compareTo(configsForOffer.get(0).getStartTime()) < 0) {
                continue;
            }

            LocalDateTime endTime = null;
            Integer duration = configsForOffer.get(0).getMinDuration();
            BigDecimal pricePerMinute;
            BigDecimal price = null;
            CalendarConfig previousConfig = null;
            Map<Integer, BigDecimal> durationPriceMap = new TreeMap<>();
            Boolean isContiguous = true;
            for (CalendarConfig config : configsForOffer) {

                //make sure there is no gap between calendar configurations
                if (endTime == null) {
                    //first run
                    endTime = getLocalDateTime(selectedDate, selectedTime).plusMinutes(config.getMinDuration());
                } else {
                    //break if there are durations available and calendar configs are not contiguous
                    if (!durationPriceMap.isEmpty()) {
                        //we substract min interval before the comparison as it has been added during the last iteration
                        LocalDateTime configStartDateTime = getLocalDateTime(selectedDate,
                                config.getStartTime());
                        if (!endTime.minusMinutes(config.getMinInterval()).equals(configStartDateTime)) {
                            break;
                        }
                    }
                }

                Integer interval = config.getMinInterval();

                pricePerMinute = getPricePerMinute(config);

                //as long as the endTime is before the end time configured in the calendar
                LocalDateTime configEndDateTime = getLocalDateTime(selectedDate, config.getEndTime());
                while (endTime.compareTo(configEndDateTime) <= 0) {
                    TimeSlot timeSlot = new TimeSlot();
                    timeSlot.setDate(selectedDate);
                    timeSlot.setStartTime(selectedTime);
                    timeSlot.setEndTime(endTime.toLocalTime());
                    timeSlot.setConfig(config);
                    Long bookingSlotsLeft = getBookingSlotsLeft(timeSlot, offer, confirmedBookings);

                    //we only allow contiguous bookings for any given offer
                    if (bookingSlotsLeft < 1) {
                        isContiguous = false;
                        break;
                    }

                    if (price == null) {
                        //see if previousConfig endTime - minInterval matches the selected time. if so, take half of the previous config price as a basis
                        if (previousConfig != null && previousConfig.getEndTime()
                                .minusMinutes(previousConfig.getMinInterval()).equals(selectedTime)) {
                            BigDecimal previousConfigPricePerMinute = getPricePerMinute(previousConfig);
                            price = previousConfigPricePerMinute.multiply(
                                    new BigDecimal(previousConfig.getMinInterval()), MathContext.DECIMAL128);
                            price = price.add(pricePerMinute.multiply(
                                    new BigDecimal(duration - previousConfig.getMinInterval()),
                                    MathContext.DECIMAL128));
                        } else {
                            price = pricePerMinute.multiply(new BigDecimal(duration.toString()),
                                    MathContext.DECIMAL128);
                        }
                    } else {
                        //add price for additional interval
                        price = price.add(pricePerMinute.multiply(new BigDecimal(interval.toString()),
                                MathContext.DECIMAL128));
                    }
                    price = price.setScale(2, RoundingMode.HALF_EVEN);
                    durationPriceMap.put(duration, price);

                    //increase the duration by the configured minimum interval and determine the new end time for the next iteration
                    duration += interval;
                    endTime = endTime.plusMinutes(interval);
                }

                if (!durationPriceMap.isEmpty()) {
                    OfferDurationPrice odp = new OfferDurationPrice();
                    odp.setOffer(offer);
                    odp.setDurationPriceMap(durationPriceMap);
                    odp.setConfig(config);
                    offerDurationPrices = odp;
                }

                if (!isContiguous) {
                    //we only allow coniguous bookings for one offer. process next offer
                    break;
                }
                previousConfig = config;

            }
        }
    }
    return offerDurationPrices;
}

From source file:it.govpay.core.business.Rendicontazioni.java

public String downloadRendicontazioni(boolean deep) throws GovPayException {
    boolean errori = false;
    List<String> response = new ArrayList<String>();
    try {// w  w w.j  av  a  2s. c om
        GpThreadLocal.get().log("rendicontazioni.acquisizione");
        DominiBD dominiBD = new DominiBD(this);

        StazioniBD stazioniBD = new StazioniBD(this);
        List<Stazione> lstStazioni = stazioniBD.getStazioni();

        PspBD pspBD = new PspBD(this);
        List<Psp> lstPsp = pspBD.getPsp();
        closeConnection();

        for (Stazione stazione : lstStazioni) {

            List<TipoIdRendicontazione> flussiDaAcquisire = new ArrayList<TipoIdRendicontazione>();

            setupConnection(GpThreadLocal.get().getTransactionId());
            Intermediario intermediario = stazione.getIntermediario(this);
            NodoClient client = new NodoClient(intermediario, this);
            closeConnection();

            if (deep) {
                DominioFilter filter = dominiBD.newFilter();
                filter.setCodStazione(stazione.getCodStazione());
                List<Dominio> lstDomini = dominiBD.findAll(filter);

                for (Dominio dominio : lstDomini) {
                    List<String> sids = new ArrayList<String>();
                    for (Psp psp : lstPsp) {
                        if (sids.contains(psp.getCodPsp()))
                            continue;
                        sids.add(psp.getCodPsp());
                        log.debug("Acquisizione dei flussi di rendicontazione dal psp [" + psp.getCodPsp()
                                + "] per il dominio [" + dominio.getCodDominio() + "] in corso.");
                        flussiDaAcquisire.addAll(chiediListaFr(client, psp, stazione, dominio));
                    }
                }
            } else {
                log.debug("Acquisizione dei flussi di rendicontazione per la stazione ["
                        + stazione.getCodStazione() + "] in corso.");
                flussiDaAcquisire.addAll(chiediListaFr(client, null, stazione, null));
            }

            // Scarto i flussi gia acquisiti
            setupConnection(GpThreadLocal.get().getTransactionId());

            FrBD frBD = new FrBD(this);
            for (TipoIdRendicontazione idRendicontazione : flussiDaAcquisire) {
                if (frBD.exists(idRendicontazione.getIdentificativoFlusso()))
                    flussiDaAcquisire.remove(idRendicontazione);
            }
            closeConnection();

            for (TipoIdRendicontazione idRendicontazione : flussiDaAcquisire) {
                log.debug("Acquisizione flusso di rendicontazione "
                        + idRendicontazione.getIdentificativoFlusso());
                boolean hasFrAnomalia = false;
                String idTransaction2 = null;
                try {
                    idTransaction2 = GpThreadLocal.get().openTransaction();
                    GpThreadLocal.get().getContext().getRequest()
                            .addGenericProperty(new Property("codStazione", stazione.getCodStazione()));
                    GpThreadLocal.get().getContext().getRequest().addGenericProperty(
                            new Property("idFlusso", idRendicontazione.getIdentificativoFlusso()));
                    GpThreadLocal.get().setupNodoClient(stazione.getCodStazione(), null,
                            Azione.nodoChiediFlussoRendicontazione);
                    NodoChiediFlussoRendicontazione richiestaFlusso = new NodoChiediFlussoRendicontazione();
                    richiestaFlusso.setIdentificativoIntermediarioPA(
                            stazione.getIntermediario(this).getCodIntermediario());
                    richiestaFlusso.setIdentificativoStazioneIntermediarioPA(stazione.getCodStazione());
                    richiestaFlusso.setPassword(stazione.getPassword());
                    richiestaFlusso.setIdentificativoFlusso(idRendicontazione.getIdentificativoFlusso());

                    NodoChiediFlussoRendicontazioneRisposta risposta;
                    try {
                        risposta = client.nodoChiediFlussoRendicontazione(richiestaFlusso,
                                stazione.getIntermediario(this).getDenominazione());
                    } catch (Exception e) {
                        // Errore nella richiesta. Loggo e continuo con il prossimo flusso
                        response.add(idRendicontazione.getIdentificativoFlusso()
                                + "#Richiesta al nodo fallita: " + e + ".");
                        log.error("Richiesta flusso  rendicontazione ["
                                + idRendicontazione.getIdentificativoFlusso() + "] fallita: " + e);
                        GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoFail", e.getMessage());
                        errori = true;
                        continue;
                    }

                    if (risposta.getFault() != null) {
                        // Errore nella richiesta. Loggo e continuo con il prossimo flusso
                        response.add(idRendicontazione.getIdentificativoFlusso()
                                + "#Richiesta al nodo fallita: " + risposta.getFault().getFaultCode() + " "
                                + risposta.getFault().getFaultString() + ".");
                        log.error("Richiesta flusso rendicontazione ["
                                + idRendicontazione.getIdentificativoFlusso() + "] fallita: "
                                + risposta.getFault().getFaultCode() + " "
                                + risposta.getFault().getFaultString());
                        GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoKo",
                                risposta.getFault().getFaultCode(), risposta.getFault().getFaultString(),
                                risposta.getFault().getDescription());
                    } else {
                        byte[] tracciato = null;
                        try {
                            ByteArrayOutputStream output = new ByteArrayOutputStream();
                            DataHandler dh = risposta.getXmlRendicontazione();
                            dh.writeTo(output);
                            tracciato = output.toByteArray();
                        } catch (IOException e) {
                            response.add(idRendicontazione.getIdentificativoFlusso()
                                    + "#Lettura del flusso fallita: " + e + ".");
                            log.error("Errore durante la lettura del flusso di rendicontazione", e);
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoFail",
                                    "Lettura del flusso fallita: " + e);
                            errori = true;
                            continue;
                        }

                        CtFlussoRiversamento flussoRendicontazione = null;
                        try {
                            flussoRendicontazione = JaxbUtils.toFR(tracciato);
                        } catch (Exception e) {
                            response.add(idRendicontazione.getIdentificativoFlusso()
                                    + "#Parsing del flusso fallita: " + e + ".");
                            log.error("Errore durante il parsing del flusso di rendicontazione", e);
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoFail",
                                    "Errore durante il parsing del flusso di rendicontazione: " + e);
                            errori = true;
                            continue;
                        }

                        log.info("Ricevuto flusso rendicontazione per "
                                + flussoRendicontazione.getDatiSingoliPagamenti().size()
                                + " singoli pagamenti");

                        setupConnection(GpThreadLocal.get().getTransactionId());

                        GpThreadLocal.get().log("rendicontazioni.acquisizioneFlusso");
                        GpThreadLocal.get().getContext().getRequest().addGenericProperty(new Property("trn",
                                flussoRendicontazione.getIdentificativoUnivocoRegolamento()));

                        Fr fr = new Fr();
                        fr.setCodBicRiversamento(flussoRendicontazione.getCodiceBicBancaDiRiversamento());
                        fr.setCodFlusso(idRendicontazione.getIdentificativoFlusso());
                        fr.setIur(flussoRendicontazione.getIdentificativoUnivocoRegolamento());
                        fr.setDataAcquisizione(new Date());
                        fr.setDataFlusso(flussoRendicontazione.getDataOraFlusso());
                        fr.setDataRegolamento(flussoRendicontazione.getDataRegolamento());
                        fr.setNumeroPagamenti(flussoRendicontazione.getNumeroTotalePagamenti().longValue());
                        fr.setImportoTotalePagamenti(flussoRendicontazione.getImportoTotalePagamenti());

                        fr.setXml(tracciato);

                        String codPsp = null, codDominio = null;
                        try {
                            codPsp = idRendicontazione.getIdentificativoFlusso().substring(10,
                                    idRendicontazione.getIdentificativoFlusso().indexOf("-", 10));
                            fr.setCodPsp(codPsp);
                            log.debug("Identificativo PSP estratto dall'identificativo flusso: " + codPsp);
                            AnagraficaManager.getPsp(this, codPsp);
                            GpThreadLocal.get().getContext().getRequest()
                                    .addGenericProperty(new Property("codPsp", codPsp));
                        } catch (Exception e) {
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoPspNonCensito",
                                    codPsp == null ? "null" : codPsp);
                            GpThreadLocal.get().getContext().getRequest().addGenericProperty(
                                    new Property("codPsp", codPsp == null ? "null" : codPsp));
                            fr.addAnomalia("007108", "L'identificativo PSP [" + codPsp
                                    + "] ricavato dal codice flusso non riferisce un PSP censito");
                        }

                        Dominio dominio = null;
                        try {
                            codDominio = flussoRendicontazione.getIstitutoRicevente()
                                    .getIdentificativoUnivocoRicevente().getCodiceIdentificativoUnivoco();
                            fr.setCodDominio(codDominio);
                            GpThreadLocal.get().getContext().getRequest()
                                    .addGenericProperty(new Property("codDominio", codDominio));
                            dominio = AnagraficaManager.getDominio(this, codDominio);
                        } catch (Exception e) {
                            if (codDominio == null) {
                                codDominio = "????";
                                GpThreadLocal.get().getContext().getRequest()
                                        .addGenericProperty(new Property("codDominio", "null"));
                            }
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoDominioNonCensito");
                            fr.addAnomalia("007109", "L'indentificativo ricevente [" + codDominio
                                    + "] del flusso non riferisce un Dominio censito");
                        }

                        BigDecimal totaleImportiRendicontati = BigDecimal.ZERO;

                        PagamentiBD pagamentiBD = new PagamentiBD(this);
                        VersamentiBD versamentiBD = new VersamentiBD(this);
                        IuvBD iuvBD = new IuvBD(this);
                        for (CtDatiSingoliPagamenti dsp : flussoRendicontazione.getDatiSingoliPagamenti()) {

                            String iur = dsp.getIdentificativoUnivocoRiscossione();
                            String iuv = dsp.getIdentificativoUnivocoVersamento();
                            BigDecimal importoRendicontato = dsp.getSingoloImportoPagato();

                            log.debug("Rendicontato (Esito " + dsp.getCodiceEsitoSingoloPagamento()
                                    + ") per un importo di (" + dsp.getSingoloImportoPagato()
                                    + ") [CodDominio: " + codDominio + "] [Iuv: "
                                    + dsp.getIdentificativoUnivocoVersamento() + "][Iur: " + iur + "]");

                            it.govpay.bd.model.Rendicontazione rendicontazione = new it.govpay.bd.model.Rendicontazione();

                            // Gestisco un codice esito non supportato
                            try {
                                rendicontazione.setEsito(
                                        EsitoRendicontazione.toEnum(dsp.getCodiceEsitoSingoloPagamento()));
                            } catch (Exception e) {
                                GpThreadLocal.get().log("rendicontazioni.esitoSconosciuto", iuv, iur,
                                        dsp.getCodiceEsitoSingoloPagamento() == null ? "null"
                                                : dsp.getCodiceEsitoSingoloPagamento());
                                rendicontazione.addAnomalia("007110", "Codice esito ["
                                        + dsp.getCodiceEsitoSingoloPagamento() + "] sconosciuto");
                            }

                            rendicontazione.setData(dsp.getDataEsitoSingoloPagamento());
                            rendicontazione.setIur(dsp.getIdentificativoUnivocoRiscossione());
                            rendicontazione.setIuv(dsp.getIdentificativoUnivocoVersamento());
                            rendicontazione.setImporto(dsp.getSingoloImportoPagato());

                            totaleImportiRendicontati = totaleImportiRendicontati.add(importoRendicontato);

                            // Cerco il pagamento riferito
                            it.govpay.bd.model.Pagamento pagamento = null;
                            try {
                                pagamento = pagamentiBD.getPagamento(codDominio, iuv, iur);

                                // Pagamento trovato. Faccio i controlli semantici
                                rendicontazione.setIdPagamento(pagamento.getId());

                                // Verifico l'importo
                                if (rendicontazione.getEsito().equals(EsitoRendicontazione.REVOCATO)) {
                                    if (pagamento.getImportoRevocato()
                                            .compareTo(importoRendicontato.abs()) != 0) {
                                        GpThreadLocal.get().log("rendicontazioni.importoStornoErrato", iuv,
                                                iur);
                                        log.info("Revoca [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: "
                                                + iur + "] rendicontato con errore: l'importo rendicontato ["
                                                + importoRendicontato.doubleValue()
                                                + "] non corrisponde a quanto stornato ["
                                                + pagamento.getImportoRevocato().doubleValue() + "]");
                                        rendicontazione.addAnomalia("007112",
                                                "L'importo rendicontato [" + importoRendicontato.doubleValue()
                                                        + "] non corrisponde a quanto stornato ["
                                                        + pagamento.getImportoRevocato().doubleValue() + "]");
                                    }

                                    // Verifico che il pagamento non sia gia' rendicontato
                                    if (pagamento.isPagamentoRendicontato(this)) {
                                        GpThreadLocal.get().log("rendicontazioni.giaStornato", iuv, iur);
                                        log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: "
                                                + iur
                                                + "] rendicontato con errore: storno gia' rendicontato da altri flussi");
                                        rendicontazione.addAnomalia("007113",
                                                "Lo storno riferito dalla rendicontazione risulta gia' rendicontato da altri flussi");
                                    }

                                } else {
                                    if (pagamento.getImportoPagato().compareTo(importoRendicontato) != 0) {
                                        GpThreadLocal.get().log("rendicontazioni.importoErrato", iuv, iur);
                                        log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: "
                                                + iur + "] rendicontato con errore: l'importo rendicontato ["
                                                + importoRendicontato.doubleValue()
                                                + "] non corrisponde a quanto pagato ["
                                                + pagamento.getImportoPagato().doubleValue() + "]");
                                        rendicontazione.addAnomalia("007104",
                                                "L'importo rendicontato [" + importoRendicontato.doubleValue()
                                                        + "] non corrisponde a quanto pagato ["
                                                        + pagamento.getImportoPagato().doubleValue() + "]");
                                    }

                                    // Verifico che il pagamento non sia gia' rendicontato
                                    if (pagamento.isPagamentoRendicontato(this)) {
                                        GpThreadLocal.get().log("rendicontazioni.giaRendicontato", iuv, iur);
                                        log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: "
                                                + iur
                                                + "] rendicontato con errore: pagamento gia' rendicontato da altri flussi");
                                        rendicontazione.addAnomalia("007103",
                                                "Il pagamento riferito dalla rendicontazione risulta gia' rendicontato da altri flussi");
                                    }
                                }

                            } catch (NotFoundException e) {
                                // Pagamento non trovato. Devo capire se ce' un errore.

                                // Controllo che sia per uno IUV generato da noi
                                if (!isInterno(dominio, iuv)) {
                                    rendicontazione.setStato(StatoRendicontazione.ALTRO_INTERMEDIARIO);
                                    continue;
                                }

                                // Controllo se e' un pagamento senza RPT
                                if (rendicontazione.getEsito()
                                        .equals(EsitoRendicontazione.ESEGUITO_SENZA_RPT)) {

                                    //Recupero il versamento, internamente o dall'applicazione esterna
                                    it.govpay.bd.model.Versamento versamento = null;
                                    String erroreVerifica = null;
                                    String codApplicazione = null;
                                    try {
                                        try {
                                            it.govpay.model.Iuv iuvModel = iuvBD.getIuv(dominio.getId(), iuv);
                                            versamento = versamentiBD.getVersamento(
                                                    iuvModel.getIdApplicazione(),
                                                    iuvModel.getCodVersamentoEnte());
                                        } catch (NotFoundException nfe) {
                                            codApplicazione = it.govpay.bd.GovpayConfig.getInstance()
                                                    .getDefaultCustomIuvGenerator().getCodApplicazione(dominio,
                                                            iuv, dominio.getApplicazioneDefault(this));
                                            if (codApplicazione == null) {
                                                response.add(idRendicontazione.getIdentificativoFlusso()
                                                        + "#Acquisizione flusso fallita. Impossibile individuare l'applicativo gestore del versamento per acquisirne i dati [Dominio:"
                                                        + codDominio + " Iuv:" + iuv + "].");
                                                log.error(
                                                        "Errore durante il processamento del flusso di Rendicontazione [Flusso:"
                                                                + idRendicontazione.getIdentificativoFlusso()
                                                                + "]: Impossibile individuare l'applicativo gestore del versamento per acquisirne i dati [Dominio:"
                                                                + codDominio + " Iuv:" + iuv
                                                                + "]. Flusso non acquisito.");
                                                GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoKo",
                                                        idRendicontazione.getIdentificativoFlusso(),
                                                        "Impossibile individuare l'applicativo gestore del versamento per acquisirne i dati [Dominio:"
                                                                + codDominio + " Iuv:" + iuv
                                                                + "].  Flusso non acquisito.");
                                                throw new GovPayException(EsitoOperazione.INTERNAL,
                                                        "Impossibile individuare l'applicativo gestore del versamento per acquisirne i dati [Dominio:"
                                                                + codDominio + " Iuv:" + iuv
                                                                + "].  Flusso non acquisito.");
                                            }
                                            versamento = VersamentoUtils.acquisisciVersamento(
                                                    AnagraficaManager.getApplicazione(this, codApplicazione),
                                                    null, null, null, codDominio, iuv, this);
                                        }
                                    } catch (VersamentoScadutoException e1) {
                                        erroreVerifica = "Versamento non acquisito dall'applicazione gestrice perche' SCADUTO.";
                                    } catch (VersamentoAnnullatoException e1) {
                                        erroreVerifica = "Versamento non acquisito dall'applicazione gestrice perche' ANNULLATO.";
                                    } catch (VersamentoDuplicatoException e1) {
                                        erroreVerifica = "Versamento non acquisito dall'applicazione gestrice perche' DUPLICATO.";
                                    } catch (VersamentoSconosciutoException e1) {
                                        erroreVerifica = "Versamento non acquisito dall'applicazione gestrice perche' SCONOSCIUTO.";
                                    } catch (ClientException ce) {
                                        response.add(idRendicontazione.getIdentificativoFlusso()
                                                + "#Acquisizione flusso fallita. Riscontrato errore nell'acquisizione del versamento dall'applicazione gestrice [Transazione: "
                                                + idTransaction2 + "].");
                                        log.error(
                                                "Errore durante il processamento del flusso di Rendicontazione [Flusso:"
                                                        + idRendicontazione.getIdentificativoFlusso()
                                                        + "]: impossibile acquisire i dati del versamento [Dominio:"
                                                        + codDominio + " Iuv:" + iuv
                                                        + "]. Flusso non acquisito.");
                                        GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoKo",
                                                idRendicontazione.getIdentificativoFlusso(),
                                                "Impossibile acquisire i dati di un versamento dall'applicativo gestore [Applicazione:"
                                                        + codApplicazione + " Dominio:" + codDominio + " Iuv:"
                                                        + iuv + "].  Flusso non acquisito.");
                                        throw new GovPayException(ce);
                                    }

                                    if (versamento == null) {
                                        // non ho trovato il versamento 
                                        GpThreadLocal.get().log("rendicontazioni.senzaRptNoVersamento", iuv,
                                                iur);
                                        log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: "
                                                + iur
                                                + "] rendicontato con errore: Pagamento senza RPT di versamento sconosciuto.");
                                        rendicontazione.addAnomalia("007111",
                                                "Il versamento risulta sconosciuto: " + erroreVerifica);
                                        continue;
                                    } else {

                                        if (versamento.getSingoliVersamenti(this).size() != 1) {
                                            // Un pagamento senza rpt DEVE riferire un pagamento tipo 3 con un solo singolo versamento
                                            GpThreadLocal.get().log(
                                                    "rendicontazioni.senzaRptVersamentoMalformato", iuv, iur);
                                            log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv
                                                    + " Iur: " + iur
                                                    + "] rendicontato con errore: Pagamento senza RPT di versamento sconosciuto.");
                                            rendicontazione.addAnomalia("007114",
                                                    "Il versamento presenta piu' singoli versamenti");
                                            continue;
                                        }

                                        // Trovato versamento. Creo il pagamento senza rpt 
                                        pagamento = new it.govpay.bd.model.Pagamento();
                                        pagamento.setCodDominio(codDominio);
                                        pagamento.setDataAcquisizione(rendicontazione.getData());
                                        pagamento.setDataPagamento(rendicontazione.getData());
                                        pagamento.setImportoPagato(rendicontazione.getImporto());
                                        pagamento.setIur(rendicontazione.getIur());
                                        pagamento.setIuv(rendicontazione.getIuv());
                                        pagamento.setCodDominio(fr.getCodDominio());
                                        pagamento.setSingoloVersamento(
                                                versamento.getSingoliVersamenti(this).get(0));

                                        rendicontazione.setPagamento(pagamento);
                                        rendicontazione.setPagamentoDaCreare(true);
                                        continue;
                                    }
                                }

                                GpThreadLocal.get().log("rendicontazioni.noPagamento", iuv, iur);
                                log.info("Pagamento [Dominio:" + codDominio + " Iuv:" + iuv + " Iur: " + iur
                                        + "] rendicontato con errore: il pagamento non risulta presente in base dati.");
                                rendicontazione.addAnomalia("007101",
                                        "Il pagamento riferito dalla rendicontazione non risulta presente in base dati.");
                                continue;
                            } catch (MultipleResultException e) {
                                // Individuati piu' pagamenti riferiti dalla rendicontazione
                                GpThreadLocal.get().log("rendicontazioni.poliPagamento", iuv, iur);
                                log.info("Pagamento rendicontato duplicato: [CodDominio: " + codDominio
                                        + "] [Iuv: " + iuv + "] [Iur: " + iur + "]");
                                rendicontazione.addAnomalia("007102",
                                        "La rendicontazione riferisce piu di un pagamento gestito.");
                            } finally {
                                if (!StatoRendicontazione.ALTRO_INTERMEDIARIO.equals(rendicontazione.getStato())
                                        && rendicontazione.getAnomalie().isEmpty()) {
                                    rendicontazione.setStato(StatoRendicontazione.OK);
                                } else if (!StatoRendicontazione.ALTRO_INTERMEDIARIO
                                        .equals(rendicontazione.getStato())
                                        && !rendicontazione.getAnomalie().isEmpty()) {
                                    rendicontazione.setStato(StatoRendicontazione.ANOMALA);
                                    hasFrAnomalia = true;
                                }
                                fr.addRendicontazione(rendicontazione);
                            }
                        }

                        // Singole rendicontazioni elaborate.
                        // Controlli di quadratura generali

                        if (totaleImportiRendicontati
                                .compareTo(flussoRendicontazione.getImportoTotalePagamenti()) != 0) {
                            GpThreadLocal.get().log("rendicontazioni.importoTotaleErrato");
                            log.info("La somma degli importi rendicontati [" + totaleImportiRendicontati
                                    + "] non corrisponde al totale indicato nella testata del flusso ["
                                    + flussoRendicontazione.getImportoTotalePagamenti() + "]");
                            fr.addAnomalia("007106",
                                    "La somma degli importi rendicontati [" + totaleImportiRendicontati
                                            + "] non corrisponde al totale indicato nella testata del flusso ["
                                            + flussoRendicontazione.getImportoTotalePagamenti() + "]");
                        }

                        try {
                            if (flussoRendicontazione.getDatiSingoliPagamenti().size() != flussoRendicontazione
                                    .getNumeroTotalePagamenti().longValueExact()) {
                                GpThreadLocal.get().log("rendicontazioni.numeroRendicontazioniErrato");
                                log.info("Il numero di pagamenti rendicontati ["
                                        + flussoRendicontazione.getDatiSingoliPagamenti().size()
                                        + "] non corrisponde al totale indicato nella testata del flusso ["
                                        + flussoRendicontazione.getNumeroTotalePagamenti().longValueExact()
                                        + "]");
                                fr.addAnomalia("007107", "Il numero di pagamenti rendicontati ["
                                        + flussoRendicontazione.getDatiSingoliPagamenti().size()
                                        + "] non corrisponde al totale indicato nella testata del flusso ["
                                        + flussoRendicontazione.getNumeroTotalePagamenti().longValueExact()
                                        + "]");
                            }
                        } catch (Exception e) {
                            GpThreadLocal.get().log("rendicontazioni.numeroRendicontazioniErrato");
                            log.info("Il numero di pagamenti rendicontati ["
                                    + flussoRendicontazione.getDatiSingoliPagamenti().size()
                                    + "] non corrisponde al totale indicato nella testata del flusso [????]");
                            fr.addAnomalia("007107", "Il numero di pagamenti rendicontati ["
                                    + flussoRendicontazione.getDatiSingoliPagamenti().size()
                                    + "] non corrisponde al totale indicato nella testata del flusso [????]");
                        }

                        // Decido lo stato del FR
                        if (fr.getAnomalie().isEmpty()) {
                            fr.setStato(StatoFr.ACCETTATA);
                        } else {
                            fr.setStato(StatoFr.ANOMALA);
                            hasFrAnomalia = true;
                        }

                        // Procedo al salvataggio
                        RendicontazioniBD rendicontazioniBD = new RendicontazioniBD(this);

                        // Tutte le operazioni di salvataggio devono essere in transazione.
                        setAutoCommit(false);
                        frBD.insertFr(fr);
                        for (Rendicontazione r : fr.getRendicontazioni(this)) {
                            r.setIdFr(fr.getId());

                            // controllo se c'e' un pagamento da creare relativo alla rendicontazione
                            // deve anche essere creato il pagamento.
                            if (r.isPagamentoDaCreare()) {
                                pagamentiBD.insertPagamento(r.getPagamento(this));
                                r.setIdPagamento(r.getPagamento(this).getId());
                            }
                            rendicontazioniBD.insert(r);
                        }
                        this.commit();
                        if (!hasFrAnomalia) {
                            log.info("Flusso di rendicontazione acquisito senza anomalie.");
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoOk");
                        } else {
                            log.info("Flusso di rendicontazione acquisito con anomalie.");
                            GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussoOkAnomalia");
                        }
                    }
                } catch (GovPayException ce) {
                    log.error("Flusso di rendicontazione non acquisito", ce);
                    errori = true;
                } finally {
                    GpThreadLocal.get().closeTransaction(idTransaction2);
                }
            }
        }
    } catch (Exception e) {
        GpThreadLocal.get().log("rendicontazioni.acquisizioneFlussiFail", e.getMessage());
        throw new GovPayException(e);
    } finally {
        try {
            if (isClosed())
                setupConnection(GpThreadLocal.get().getTransactionId());
        } catch (Exception e) {
            log.error("Errore nel ripristino della connessione", e);
        }
    }

    GpThreadLocal.get().log("rendicontazioni.acquisizioneOk");

    String rspTxt = "";
    if (errori)
        rspTxt = "WARNING#Processo di acquisizione completato parzialmente: uno o piu' flussi non sono stati acquisiti.|";
    else
        rspTxt = "OK#Processo di acquisizione completato con successo|";

    if (response.isEmpty()) {
        return rspTxt + "Processo di acquisizione completato con successo. #Nessun flusso acquisito.";
    } else {
        return rspTxt + StringUtils.join(response, "|");
    }
}

From source file:com.turborep.turbotracker.sales.service.Salesserviceimpl.java

@Override
public Map<String, BigDecimal> getTemplatePriceDetails(int CusoID, int cuSODetailID, int prMasterID) {
    Session aSession = null;/*from w  ww .ja va  2s .c  o m*/
    BigDecimal margin = new BigDecimal(0);

    BigDecimal cost = new BigDecimal(0);
    Map<String, BigDecimal> aPrice = new HashMap<String, BigDecimal>();
    String Query = null;
    try {
        itsLogger.info("cuSODetailID::" + cuSODetailID + "::CusoID::" + CusoID);
        Query = "SELECT prMaster.prMasterID,prMaster.SalesPrice00,prMaster.LastCost,template.QuantityOrdered,template.cuSODetailID,IFNULL(template.whseCost,0.0000) FROM cuSODetail AS template,prMaster WHERE template.cuSOID= :cuSoid AND prMaster.prMasterID = template.prMasterID";
        aSession = itsSessionFactory.openSession();
        Query aQuery = aSession.createSQLQuery(Query);
        aQuery.setParameter("cuSoid", CusoID);
        List aList = aQuery.list();
        if (!aList.isEmpty()) {
            Iterator<?> aIterator = aList.iterator();
            while (aIterator.hasNext()) {
                Object[] aObj = (Object[]) aIterator.next();
                // BigDecimal salesPrice00 = (BigDecimal)aObj[1] == null ?
                // new BigDecimal(0.00) : (BigDecimal)aObj[1];
                // BigDecimal lastCost = (BigDecimal)aObj[2]== null ? new
                // BigDecimal(0.00) : (BigDecimal)aObj[2];
                BigDecimal qty = (BigDecimal) aObj[3] == null ? new BigDecimal(0.00) : (BigDecimal) aObj[3];
                // margin = margin.add(salesPrice00.multiply(qty));
                BigDecimal whseCost = BigDecimal.ZERO;
                if (cuSODetailID == (Integer) aObj[4]) {
                    aPrice.put("product",
                            itsInventoryService.getWarehouseCost((Integer) aObj[0]).multiply(qty));
                    aPrice.put("productnqty", itsInventoryService.getWarehouseCost((Integer) aObj[0]));
                }
                cost = cost.add(itsInventoryService.getWarehouseCost((Integer) aObj[0]).multiply(qty));
                // itsLogger.info("Quantityz::"+qty);

                /*
                 * Commented By Velmurugan Date:17-7-2015 Issue:BID #622
                 * 
                 * if(cuSODetailID == (Integer)aObj[4]){
                 * if(whseCost.compareTo(new BigDecimal("0.0000"))==0){
                 * aPrice.put("product",
                 * itsInventoryService.getWarehouseCost((Integer)aObj[0]).
                 * multiply(qty)); whseCost = new BigDecimal("0.0000"); }
                 * else{ aPrice.put("product", whseCost); } }
                 * 
                 * if(whseCost.compareTo(new BigDecimal("0.0000"))==0){ cost
                 * = cost.add(itsInventoryService.getWarehouseCost((Integer)
                 * aObj[0]).multiply(qty)); }else{ cost =
                 * cost.add(whseCost); }
                 */

                // cost =
                // cost.add(itsInventoryService.getWarehouseCost((Integer)aObj[0]).multiply(qty));
            }
            // BigDecimal percentage =
            // margin.subtract(cost).divide(margin).multiply(new
            // BigDecimal(100));

            aPrice.put("cost", cost);
            aPrice.put("percentage", new BigDecimal(0.00));
        } else {
            aPrice.put("productnqty", new BigDecimal(0.00));
            aPrice.put("product", new BigDecimal(0.00));
            aPrice.put("margin", new BigDecimal(0.00));
            aPrice.put("cost", new BigDecimal(0.00));
            aPrice.put("percentage", new BigDecimal(0.00));
        }
    } catch (Exception excep) {
        itsLogger.error(excep.getMessage(), excep);

    } finally {
        aSession.flush();
        aSession.close();
        Query = null;
    }
    return aPrice;
}

From source file:com.iskyshop.manage.buyer.action.OrderBuyerAction.java

private List<Object> dataProcess(List<OrderForm> resultList) {
    List<Object> result = new ArrayList<Object>();
    if (resultList != null) {
        for (OrderForm form : resultList) {
            BigDecimal totleAmount = BigDecimal.ZERO;
            BigDecimal totleShipPrice = BigDecimal.ZERO;
            List<Object> list = new ArrayList<Object>();
            //??/*from w ww  .  j  a va 2s  .  com*/
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("id", form.getId());
            map.put("order_id", form.getOrder_id());
            map.put("addTime", form.getAddTime());
            map.put("order_status", form.getOrder_status());
            map.put("ship_price", form.getShip_price());
            map.put("order_cat", form.getOrder_cat());
            if (form.getPayment() != null) {
                map.put("mark", form.getPayment().getMark());
            }

            //??
            Map<String, Object> mainstorinfo = new HashMap<String, Object>();
            mainstorinfo.put("receiver_Name", form.getReceiver_Name());
            mainstorinfo.put("id", form.getId());
            mainstorinfo.put("totalPrice", form.getTotalPrice());
            mainstorinfo.put("goods_amount", form.getGoods_amount());
            mainstorinfo.put("shipCode", form.getShipCode());
            mainstorinfo.put("order_id", form.getOrder_id());
            mainstorinfo.put("order_cat", form.getOrder_cat());
            mainstorinfo.put("ship_price", form.getShip_price());
            mainstorinfo.put("order_status", form.getOrder_status());

            totleAmount = totleAmount.add(form.getTotalPrice());
            totleShipPrice = totleShipPrice.add(form.getShip_price());

            //?????
            List<Map> maps = this.orderFormTools.queryGoodsInfo(form.getGoods_info());
            Map<String, Object> temmap = new HashMap<String, Object>();
            List<Object> temList = new ArrayList<Object>();
            for (Map tem : maps) {
                temmap = new HashMap<String, Object>();
                temmap.put("goods_mainphoto_path", tem.get("goods_mainphoto_path"));
                temmap.put("goods_domainPath", tem.get("goods_domainPath"));
                temmap.put("goods_name", tem.get("goods_name"));
                temList.add(temmap);
            }
            mainstorinfo.put("goods_info", temList);
            list.add(mainstorinfo);

            //????
            List<Map> maps2 = this.orderFormTools.queryGoodsInfo(form.getChild_order_detail());
            for (Map tem : maps2) {
                OrderForm orderForm = this.orderFormService
                        .getObjById(Long.parseLong((tem.get("order_id")).toString()));
                Map<String, Object> childstorInfo = new HashMap<String, Object>();
                childstorInfo.put("receiver_Name", form.getReceiver_Name());
                childstorInfo.put("totalPrice", orderForm.getTotalPrice());
                childstorInfo.put("id", orderForm.getId());
                childstorInfo.put("shipCode", orderForm.getShipCode());
                childstorInfo.put("goods_amount", orderForm.getGoods_amount());
                childstorInfo.put("order_id", orderForm.getOrder_id());
                childstorInfo.put("order_cat", orderForm.getOrder_cat());
                childstorInfo.put("ship_price", orderForm.getShip_price());
                childstorInfo.put("order_status", orderForm.getOrder_status());
                //????
                List<Map> maps_child_order_info = this.orderFormTools.queryGoodsInfo(orderForm.getGoods_info());
                Map<String, Object> temmap2 = null;
                List<Object> temList2 = new ArrayList<Object>();
                for (Map tem3 : maps_child_order_info) {//???
                    temmap2 = new HashMap<String, Object>();
                    temmap2.put("goods_mainphoto_path", tem3.get("goods_mainphoto_path"));
                    temmap2.put("goods_domainPath", tem3.get("goods_domainPath"));
                    temmap2.put("goods_name", tem3.get("goods_name"));
                    temList2.add(temmap2);
                }
                childstorInfo.put("goods_info", temList2);
                list.add(childstorInfo);
                totleAmount = totleAmount.add(orderForm.getTotalPrice());
                totleShipPrice = totleShipPrice.add(orderForm.getShip_price());
            }
            map.put("lists", list);
            map.put("totleAmount", totleAmount);
            map.put("totleShipPrice", totleShipPrice);
            result.add(map);
        }
    }
    return result;
}

From source file:com.lp.server.lieferschein.ejbfac.LieferscheinFacBean.java

public BigDecimal berechneOffenenLieferscheinwert(Integer kundeIId, TheClientDto theClientDto) {
    String queryString = "SELECT ls FROM FLRLieferschein AS ls WHERE ls.b_verrechenbar=1 AND ls.lieferscheinstatus_status_c_nr IN ('"
            + LocaleFac.STATUS_OFFEN + "','" + LocaleFac.STATUS_GELIEFERT + "') ";

    if (kundeIId != null) {
        queryString += " AND ls.kunde_i_id_rechnungsadresse=" + kundeIId;
    }/*  w  w  w .ja v a  2 s .c  om*/

    Session session = FLRSessionFactory.getFactory().openSession();
    org.hibernate.Query query = session.createQuery(queryString);
    List<?> results = query.list();
    Iterator<?> resultListIterator = results.iterator();

    BigDecimal wert = new BigDecimal(0);
    while (resultListIterator.hasNext()) {
        FLRLieferschein ls = (FLRLieferschein) resultListIterator.next();

        if (ls.getN_gesamtwertinlieferscheinwaehrung() != null) {
            wert = wert.add(ls.getN_gesamtwertinlieferscheinwaehrung().divide(
                    new BigDecimal(ls.getF_wechselkursmandantwaehrungzulieferscheinwaehrung()), 4,
                    BigDecimal.ROUND_HALF_EVEN));
        }

    }
    return wert;

}

From source file:com.turborep.turbotracker.banking.service.BankingServiceImpl.java

@Override
public int addTransactionDetails(Motransaction theMotransaction, Session aTransactionSession,
        String insertStatus) throws BankingException {

    Transaction aTransaction;//from w  w  w. j a  va  2 s.co m
    int motransid = 0;
    MoAccount aMoaccount = new MoAccount();
    Motransaction amot = new Motransaction();
    try {

        if (insertStatus.equals("rollback")) {

            amot = (Motransaction) aTransactionSession.get(Motransaction.class,
                    theMotransaction.getMoTransactionId());
            theMotransaction.setRxMasterId(amot.getRxMasterId());
            theMotransaction.setDescription(amot.getDescription());
            theMotransaction.setReference(amot.getReference());
            motransid = (Integer) aTransactionSession.save(theMotransaction);

        } else if (insertStatus.equals("rollbackfromvoid")) {
            amot = (Motransaction) aTransactionSession.get(Motransaction.class,
                    theMotransaction.getMoTransactionId());
            theMotransaction.setRxMasterId(amot.getRxMasterId());
            theMotransaction.setReference(amot.getReference());
            motransid = (Integer) aTransactionSession.save(theMotransaction);
        } else {
            if (theMotransaction.getMoTransactionTypeId() == 2) {
                aMoaccount = (MoAccount) aTransactionSession.get(MoAccount.class,
                        theMotransaction.getMoAccountId());

                /*if(aMoaccount.getNextCheckNumber()!=Integer.parseInt(theMotransaction.getReference()))   
                {
                aMoaccount.setNextCheckNumber(Integer.parseInt(theMotransaction.getReference())+1);   
                theMotransaction.setReference(""+Integer.parseInt(theMotransaction.getReference()));
                }
                else
                {
                aMoaccount.setNextCheckNumber(Integer.parseInt(theMotransaction.getReference())+1);
                theMotransaction.setReference(""+Integer.parseInt(theMotransaction.getReference()));
                }*/

                aMoaccount.setNextCheckNumber(Integer.parseInt(theMotransaction.getReference()) + 1);
                theMotransaction.setReference("" + Integer.parseInt(theMotransaction.getReference()));

                motransid = (Integer) aTransactionSession.save(theMotransaction);

                BigDecimal substractions = aMoaccount.getSubtractions();
                substractions = substractions.add(theMotransaction.getAmount());
                aMoaccount.setSubtractions(substractions);
                aTransactionSession.update(aMoaccount);
            } else {
                motransid = (Integer) aTransactionSession.save(theMotransaction);
            }
        }

    } catch (Exception excep) {
        itsLogger.error(excep.getMessage(), excep);
        BankingException aBankingException = new BankingException(excep.getMessage(), excep);
        throw aBankingException;
    } finally {
        aTransactionSession.flush();
        aTransactionSession.clear();
    }
    return motransid;
}

From source file:com.lp.server.auftrag.ejbfac.AuftragFacBean.java

@Override
public BigDecimal berechneSummeSplittbetragAuftrag(Integer iIdAuftrag) throws EJBExceptionLP, RemoteException {
    EingangsrechnungAuftragszuordnungDto[] azDtos = getEingangsrechnungFac()
            .eingangsrechnungAuftragszuordnungFindByAuftragIId(iIdAuftrag);

    BigDecimal summe = new BigDecimal(0);

    if (azDtos == null)
        return summe;

    for (EingangsrechnungAuftragszuordnungDto az : azDtos) {
        if (az.getNBetrag() != null)
            summe = summe.add(az.getNBetrag());
    }/*from  w  w  w . j  av  a  2  s  .co m*/

    return summe;
}

From source file:com.ibm.soatf.component.soap.builder.SampleXmlUtil.java

private String formatDecimal(String start, SchemaType sType) {
    BigDecimal result = new BigDecimal(start);
    XmlDecimal xmlD;//w w  w.  j  a  va  2 s .  c o m
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
    BigDecimal min = xmlD != null ? xmlD.getBigDecimalValue() : null;
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
    BigDecimal max = xmlD != null ? xmlD.getBigDecimalValue() : null;
    boolean minInclusive = true, maxInclusive = true;
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
    if (xmlD != null) {
        BigDecimal minExcl = xmlD.getBigDecimalValue();
        if (min == null || min.compareTo(minExcl) < 0) {
            min = minExcl;
            minInclusive = false;
        }
    }
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
    if (xmlD != null) {
        BigDecimal maxExcl = xmlD.getBigDecimalValue();
        if (max == null || max.compareTo(maxExcl) > 0) {
            max = maxExcl;
            maxInclusive = false;
        }
    }
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_TOTAL_DIGITS);
    int totalDigits = -1;
    if (xmlD != null) {
        totalDigits = xmlD.getBigDecimalValue().intValue();

        StringBuilder sb = new StringBuilder(totalDigits);
        for (int i = 0; i < totalDigits; i++)
            sb.append('9');
        BigDecimal digitsLimit = new BigDecimal(sb.toString());
        if (max != null && max.compareTo(digitsLimit) > 0) {
            max = digitsLimit;
            maxInclusive = true;
        }
        digitsLimit = digitsLimit.negate();
        if (min != null && min.compareTo(digitsLimit) < 0) {
            min = digitsLimit;
            minInclusive = true;
        }
    }

    int sigMin = min == null ? 1 : result.compareTo(min);
    int sigMax = max == null ? -1 : result.compareTo(max);
    boolean minOk = sigMin > 0 || sigMin == 0 && minInclusive;
    boolean maxOk = sigMax < 0 || sigMax == 0 && maxInclusive;

    // Compute the minimum increment
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_FRACTION_DIGITS);
    int fractionDigits = -1;
    BigDecimal increment;
    if (xmlD == null)
        increment = new BigDecimal(1);
    else {
        fractionDigits = xmlD.getBigDecimalValue().intValue();
        if (fractionDigits > 0) {
            StringBuilder sb = new StringBuilder("0.");
            for (int i = 1; i < fractionDigits; i++)
                sb.append('0');
            sb.append('1');
            increment = new BigDecimal(sb.toString());
        } else
            increment = new BigDecimal(1);
    }

    if (minOk && maxOk) {
        // OK
    } else if (minOk && !maxOk) {
        // TOO BIG
        if (maxInclusive)
            result = max;
        else
            result = max.subtract(increment);
    } else if (!minOk && maxOk) {
        // TOO SMALL
        if (minInclusive)
            result = min;
        else
            result = min.add(increment);
    } else {
        // MIN > MAX!!
    }

    // We have the number
    // Adjust the scale according to the totalDigits and fractionDigits
    int digits = 0;
    BigDecimal ONE = new BigDecimal(BigInteger.ONE);
    for (BigDecimal n = result; n.abs().compareTo(ONE) >= 0; digits++)
        n = n.movePointLeft(1);

    if (fractionDigits > 0)
        if (totalDigits >= 0)
            result.setScale(Math.max(fractionDigits, totalDigits - digits));
        else
            result.setScale(fractionDigits);
    else if (fractionDigits == 0)
        result.setScale(0);

    return result.toString();
}

From source file:com.lp.server.auftrag.ejbfac.AuftragFacBean.java

@Override
public void berechneBeleg(Integer iIdAuftragI, TheClientDto theClientDto)
        throws EJBExceptionLP, RemoteException {
    Auftrag oAuftrag = em.find(Auftrag.class, iIdAuftragI);
    myLogger.entry();/*www .ja v a2  s  .  c  o  m*/

    if (oAuftrag.getAuftragstatusCNr().equals(AuftragServiceFac.AUFTRAGSTATUS_ANGELEGT)) {

        BigDecimal bdAuftragswertInAuftragswaehrung = berechneNettowertGesamt(oAuftrag.getIId(), theClientDto); // Berechnung in
        // Auftragswaehrung

        if (oAuftrag.getNKorrekturbetrag() != null) {
            bdAuftragswertInAuftragswaehrung = bdAuftragswertInAuftragswaehrung
                    .add(oAuftrag.getNKorrekturbetrag());
        }

        BigDecimal bdWechselkurs = Helper.getKehrwert(
                new BigDecimal(oAuftrag.getFWechselkursmandantwaehrungzuauftragswaehrung().doubleValue()));
        BigDecimal bdAuftragswertInMandantenwaehrung = bdAuftragswertInAuftragswaehrung.multiply(bdWechselkurs);
        bdAuftragswertInMandantenwaehrung = Helper.rundeKaufmaennisch(bdAuftragswertInMandantenwaehrung, 4);
        checkNumberFormat(bdAuftragswertInMandantenwaehrung);

        BigDecimal bdMaterialwertInMandantenwaehrung = berechneMaterialwertGesamt(oAuftrag.getIId(),
                theClientDto); // in
        // Mandantenwaehrung

        oAuftrag.setNGesamtauftragswertinauftragswaehrung(bdAuftragswertInAuftragswaehrung);
        oAuftrag.setNMaterialwertinmandantenwaehrung(bdMaterialwertInMandantenwaehrung);

        BigDecimal bdRohdeckungInMandantenwaehrung = bdAuftragswertInMandantenwaehrung
                .subtract(bdMaterialwertInMandantenwaehrung);

        bdRohdeckungInMandantenwaehrung = Helper.rundeKaufmaennisch(bdRohdeckungInMandantenwaehrung, 4);
        checkNumberFormat(bdRohdeckungInMandantenwaehrung);
        if (oAuftrag.getNRohdeckungaltinmandantenwaehrung() == null) {
            oAuftrag.setNRohdeckunginmandantenwaehrung(bdRohdeckungInMandantenwaehrung);
            oAuftrag.setNRohdeckungaltinmandantenwaehrung(bdRohdeckungInMandantenwaehrung);
        }
        em.merge(oAuftrag);
        em.flush();

    }
}