Example usage for java.math BigDecimal abs

List of usage examples for java.math BigDecimal abs

Introduction

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

Prototype

public BigDecimal abs() 

Source Link

Document

Returns a BigDecimal whose value is the absolute value of this BigDecimal , and whose scale is this.scale() .

Usage

From source file:org.egov.ptis.service.es.CollectionIndexElasticSearchService.java

private void setCurrYearTillDateCollBreakUpForTableData(CollTableData collIndData, BigDecimal arrearColl,
        BigDecimal currentColl, BigDecimal penaltyColl, BigDecimal rebate, BigDecimal advanceColl) {
    collIndData.setCyArrearColl(arrearColl);
    collIndData.setCyCurrentColl(currentColl);
    collIndData.setCyPenaltyColl(penaltyColl);
    collIndData.setCyRebate(rebate.abs());
    collIndData.setCyAdvanceColl(advanceColl);
}

From source file:org.egov.ptis.service.es.CollectionIndexElasticSearchService.java

private void setLastYearTillDateCollBreakUpForTableData(CollTableData collIndData, BigDecimal arrearColl,
        BigDecimal currentColl, BigDecimal penaltyColl, BigDecimal rebate, BigDecimal advanceColl) {
    collIndData.setLyArrearColl(arrearColl);
    collIndData.setLyCurrentColl(currentColl);
    collIndData.setLyPenaltyColl(penaltyColl);
    collIndData.setLyRebate(rebate.abs());
    collIndData.setLyAdvanceColl(advanceColl);
}

From source file:org.egov.ptis.service.es.CollectionIndexElasticSearchService.java

private void setLastFinYearCollBreakUpForTableData(CollTableData collIndData, BigDecimal lyTotalArrearColl,
        BigDecimal lyTotalCurrentColl, BigDecimal lyTotalPenaltyColl, BigDecimal lyTotalRebate,
        BigDecimal lyTotalAdvanceColl) {
    collIndData.setLyTotalArrearsColl(lyTotalArrearColl);
    collIndData.setLyTotalCurrentColl(lyTotalCurrentColl);
    collIndData.setLyTotalPenaltyColl(lyTotalPenaltyColl);
    collIndData.setLyTotalRebate(lyTotalRebate.abs());
    collIndData.setLyTotalAdvanceColl(lyTotalAdvanceColl);
}

From source file:org.kuali.kpme.tklm.leave.calendar.validation.LeaveCalendarValidationUtil.java

public static List<String> validateLeaveAccrualRuleMaxUsage(LeaveSummaryContract ls, String selectedEarnCode,
        String leaveStartDateString, String leaveEndDateString, BigDecimal leaveAmount,
        LeaveBlock updatedLeaveBlock) {//from   w w  w  .  j  av a2  s.  c  om
    List<String> errors = new ArrayList<String>();
    String principalId = HrContext.getTargetPrincipalId();
    long daysSpan = TKUtils.getDaysBetween(TKUtils.formatDateString(leaveStartDateString),
            TKUtils.formatDateString(leaveEndDateString));
    if (leaveAmount == null) {
        leaveAmount = TKUtils.getHoursBetween(TKUtils.formatDateString(leaveStartDateString).toDate().getTime(),
                TKUtils.formatDateString(leaveEndDateString).toDate().getTime());
    }
    if (ls != null && CollectionUtils.isNotEmpty(ls.getLeaveSummaryRows())) {
        BigDecimal oldLeaveAmount = null;
        boolean earnCodeChanged = false;
        if (updatedLeaveBlock != null) {
            if (!updatedLeaveBlock.getEarnCode().equals(selectedEarnCode)) {
                earnCodeChanged = true;
            }
            if (!updatedLeaveBlock.getLeaveAmount().equals(leaveAmount)) {
                oldLeaveAmount = updatedLeaveBlock.getLeaveAmount();
            }
        }
        LocalDate aDate = TKUtils.formatDateString(leaveEndDateString);
        EarnCodeContract earnCodeObj = HrServiceLocator.getEarnCodeService().getEarnCode(selectedEarnCode,
                aDate);
        if (earnCodeObj != null
                && StringUtils.equals(earnCodeObj.getAccrualBalanceAction(),
                        HrConstants.ACCRUAL_BALANCE_ACTION.USAGE)
                || StringUtils.equals(earnCodeObj.getUsageLimit(), "I")) {
            AccrualCategoryContract accrualCategory = HrServiceLocator.getAccrualCategoryService()
                    .getAccrualCategory(earnCodeObj.getAccrualCategory(), aDate);
            if (accrualCategory != null) {
                List<? extends LeaveSummaryRowContract> rows = ls.getLeaveSummaryRows();
                for (LeaveSummaryRowContract aRow : rows) {
                    if (aRow.getAccrualCategory().equals(accrualCategory.getAccrualCategory())) {
                        //Does employee have overrides in place?
                        List<? extends EmployeeOverrideContract> employeeOverrides = LmServiceLocator
                                .getEmployeeOverrideService().getEmployeeOverrides(principalId,
                                        TKUtils.formatDateString(leaveEndDateString));
                        String leavePlan = accrualCategory.getLeavePlan();
                        BigDecimal maxUsage = aRow.getUsageLimit();
                        for (EmployeeOverrideContract eo : employeeOverrides) {
                            if (eo.getLeavePlan().equals(leavePlan)
                                    && eo.getAccrualCategory().equals(aRow.getAccrualCategory())) {
                                if (eo.getOverrideType().equals("MU") && eo.isActive()) {
                                    if (eo.getOverrideValue() != null) {
                                        maxUsage = new BigDecimal(eo.getOverrideValue());
                                    } else { // no limit flag
                                        maxUsage = null;
                                    }
                                }
                            }
                        }
                        BigDecimal ytdUsage = aRow.getYtdApprovedUsage();
                        BigDecimal pendingLeaveBalance = aRow.getPendingLeaveRequests();
                        BigDecimal desiredUsage = new BigDecimal(0);
                        if (pendingLeaveBalance != null) {
                            if (oldLeaveAmount != null) {

                                if (!earnCodeChanged
                                        || StringUtils.equals(updatedLeaveBlock.getAccrualCategory(),
                                                accrualCategory.getAccrualCategory())) {
                                    pendingLeaveBalance = pendingLeaveBalance.subtract(oldLeaveAmount.abs());
                                }
                            }

                            desiredUsage = desiredUsage.add(pendingLeaveBalance);
                        }

                        desiredUsage = desiredUsage.add(leaveAmount.multiply(new BigDecimal(daysSpan + 1)));

                        if (ytdUsage != null) {
                            desiredUsage = desiredUsage.add(ytdUsage);
                        }
                        if (maxUsage != null) {
                            if (desiredUsage.compareTo(maxUsage) > 0) {
                                errors.add("This leave request would exceed the usage limit for "
                                        + aRow.getAccrualCategory()); //errorMessages
                            }
                        }
                    }
                }
            }
        }
    }
    return errors;
}

From source file:org.sakaiproject.tool.assessment.services.GradingService.java

public boolean getCalcQResult(ItemGradingData data, ItemDataIfc itemdata,
        Map<Integer, String> calculatedAnswersMap, int calcQuestionAnswerSequence) {
    boolean result = false;

    if (data.getAnswerText() == null)
        return result;

    if (!calculatedAnswersMap.containsKey(calcQuestionAnswerSequence)) {
        return result;
    }// www.ja  v  a 2 s  . c o  m
    // this variable should look something like this "42.1|2,2"
    String allAnswerText = calculatedAnswersMap.get(calcQuestionAnswerSequence).toString();

    // NOTE: this correctAnswer will already have been trimmed to the appropriate number of decimals
    BigDecimal correctAnswer = new BigDecimal(getAnswerExpression(allAnswerText));

    // Determine if the acceptable variance is a constant or a % of the answer
    String varianceString = allAnswerText.substring(allAnswerText.indexOf("|") + 1, allAnswerText.indexOf(","));
    BigDecimal acceptableVariance = BigDecimal.ZERO;
    if (varianceString.contains("%")) {
        double percentage = Double.valueOf(varianceString.substring(0, varianceString.indexOf("%")));
        acceptableVariance = correctAnswer.multiply(new BigDecimal(percentage / 100));
    } else {
        acceptableVariance = new BigDecimal(varianceString);
    }

    String userAnswerString = data.getAnswerText().replaceAll(",", "").trim();
    BigDecimal userAnswer;
    try {
        userAnswer = new BigDecimal(userAnswerString);
    } catch (NumberFormatException nfe) {
        return result;
    }

    // this compares the correctAnswer against the userAnsewr
    BigDecimal answerDiff = (correctAnswer.subtract(userAnswer));
    boolean closeEnough = (answerDiff.abs().compareTo(acceptableVariance.abs()) <= 0);
    if (closeEnough) {
        result = true;
    }
    return result;

}

From source file:org.sakaiproject.tool.assessment.services.GradingService.java

/**
 * CALCULATED_QUESTION//from w  w w  .j a  v a  2  s  . c  o m
 * Returns a double score value for the ItemGrading element being scored for a Calculated Question
 * 
 * @param calcQuestionAnswerSequence the order of answers in the list
 * @return score for the item.
 */
public double getCalcQScore(ItemGradingData data, ItemDataIfc itemdata,
        Map<Integer, String> calculatedAnswersMap, int calcQuestionAnswerSequence) {
    double totalScore = (double) 0;

    if (data.getAnswerText() == null)
        return totalScore; // zero for blank

    if (!calculatedAnswersMap.containsKey(calcQuestionAnswerSequence)) {
        return totalScore;
    }
    // this variable should look something like this "42.1|2,2"
    String allAnswerText = calculatedAnswersMap.get(calcQuestionAnswerSequence).toString();

    // NOTE: this correctAnswer will already have been trimmed to the appropriate number of decimals
    BigDecimal correctAnswer = new BigDecimal(getAnswerExpression(allAnswerText));

    // Determine if the acceptable variance is a constant or a % of the answer
    String varianceString = allAnswerText.substring(allAnswerText.indexOf("|") + 1, allAnswerText.indexOf(","));
    BigDecimal acceptableVariance = BigDecimal.ZERO;
    if (varianceString.contains("%")) {
        double percentage = Double.valueOf(varianceString.substring(0, varianceString.indexOf("%")));
        acceptableVariance = correctAnswer.multiply(new BigDecimal(percentage / 100));
    } else {
        acceptableVariance = new BigDecimal(varianceString);
    }

    String userAnswerString = data.getAnswerText().replaceAll(",", "").trim();
    BigDecimal userAnswer;
    try {
        userAnswer = new BigDecimal(userAnswerString);
    } catch (NumberFormatException nfe) {
        return totalScore; // zero because it's not even a number!
    }
    //double userAnswer = Double.valueOf(userAnswerString);

    // this compares the correctAnswer against the userAnsewr
    BigDecimal answerDiff = (correctAnswer.subtract(userAnswer));
    boolean closeEnough = (answerDiff.abs().compareTo(acceptableVariance.abs()) <= 0);
    if (closeEnough) {
        totalScore += itemdata.getScore();
    }
    return totalScore;

}

From source file:org.efaps.esjp.accounting.transaction.Recalculate_Base.java

/**
 * Method to recalculate rate./*from w w w.jav  a2s  . co m*/
 *
 * @param _parameter Parameter as passed from the eFaps API.
 * @return new Return.
 * @throws EFapsException on error.
 */
public Return recalculateRate(final Parameter _parameter) throws EFapsException {
    final Instance docInst = Instance.get(_parameter.getParameterValue("docInst"));
    final PrintQuery print = new PrintQuery(docInst);
    print.addAttribute(CISales.DocumentSumAbstract.RateCrossTotal, CISales.DocumentSumAbstract.CrossTotal,
            CISales.DocumentSumAbstract.RateCurrencyId, CISales.DocumentSumAbstract.CurrencyId,
            CISales.DocumentSumAbstract.Date, CISales.DocumentSumAbstract.Name);
    print.execute();

    final BigDecimal rateCross = print.<BigDecimal>getAttribute(CISales.DocumentSumAbstract.RateCrossTotal);
    final BigDecimal crossTotal = print.<BigDecimal>getAttribute(CISales.DocumentSumAbstract.CrossTotal);
    final DateTime dateDoc = print.<DateTime>getAttribute(CISales.DocumentSumAbstract.Date);
    final String nameDoc = print.<String>getAttribute(CISales.DocumentSumAbstract.Name);
    final Instance targetCurrInst = Instance.get(CIERP.Currency.getType(),
            print.<Long>getAttribute(CISales.DocumentSumAbstract.RateCurrencyId));
    final Instance currentInst = Instance.get(CIERP.Currency.getType(),
            print.<Long>getAttribute(CISales.DocumentSumAbstract.CurrencyId));
    final CurrencyInst tarCurr = new CurrencyInst(targetCurrInst);
    final CurrencyInst curr = new CurrencyInst(currentInst);

    final PriceUtil priceUtil = new PriceUtil();
    final BigDecimal[] rates = priceUtil.getRates(_parameter, targetCurrInst, currentInst);
    final BigDecimal rate = rates[2];

    final BigDecimal newCrossTotal = rateCross.compareTo(BigDecimal.ZERO) == 0 ? BigDecimal.ZERO
            : rateCross.divide(rate, BigDecimal.ROUND_HALF_UP);
    final BigDecimal gainloss = newCrossTotal.subtract(crossTotal);
    final Map<String, String[]> map = validateInfo(_parameter, gainloss);
    final String[] accs = map.get("accs");
    final String[] check = map.get("check");
    if (checkAccounts(accs, 0, check).length() > 0 && checkAccounts(accs, 1, check).length() > 0) {
        if (gainloss.compareTo(BigDecimal.ZERO) != 0) {
            if (!tarCurr.equals(curr)) {
                final String[] accOids = map.get("accountOids");

                final Insert insert = new Insert(CIAccounting.Transaction);
                final StringBuilder description = new StringBuilder();
                final DateTimeFormatter formater = DateTimeFormat.mediumDate();
                final String dateStr = dateDoc.withChronology(Context.getThreadContext().getChronology())
                        .toString(formater.withLocale(Context.getThreadContext().getLocale()));
                description
                        .append(DBProperties
                                .getProperty("Accounting_TransactionRecalculateForm.TxnRecalculate.Label"))
                        .append(" ").append(nameDoc).append(" ").append(dateStr);
                insert.add(CIAccounting.Transaction.Description, description);
                insert.add(CIAccounting.Transaction.Date, _parameter.getParameterValue("date"));
                insert.add(CIAccounting.Transaction.PeriodLink, _parameter.getInstance().getId());
                insert.add(CIAccounting.Transaction.Status,
                        Status.find(CIAccounting.TransactionStatus.uuid, "Open").getId());
                insert.execute();

                final Instance instance = insert.getInstance();
                new Create().connectDocs2Transaction(_parameter, instance, docInst);

                final Insert insert2 = new Insert(CIAccounting.TransactionPositionCredit);
                insert2.add(CIAccounting.TransactionPositionCredit.TransactionLink, instance.getId());
                insert2.add(CIAccounting.TransactionPositionCredit.AccountLink,
                        Instance.get(accOids[1]).getId());
                insert2.add(CIAccounting.TransactionPositionCredit.CurrencyLink, curr.getInstance().getId());
                insert2.add(CIAccounting.TransactionPositionCredit.RateCurrencyLink,
                        curr.getInstance().getId());
                insert2.add(CIAccounting.TransactionPositionCredit.Rate, new Object[] { 1, 1 });
                insert2.add(CIAccounting.TransactionPositionCredit.RateAmount, gainloss.abs());
                insert2.add(CIAccounting.TransactionPositionCredit.Amount, gainloss.abs());
                insert2.execute();

                final Insert insert3 = new Insert(CIAccounting.TransactionPositionDebit);
                insert3.add(CIAccounting.TransactionPositionDebit.TransactionLink, instance.getId());
                insert3.add(CIAccounting.TransactionPositionDebit.AccountLink,
                        Instance.get(accOids[0]).getId());
                insert3.add(CIAccounting.TransactionPositionDebit.CurrencyLink, curr.getInstance().getId());
                insert3.add(CIAccounting.TransactionPositionDebit.RateCurrencyLink, curr.getInstance().getId());
                insert3.add(CIAccounting.TransactionPositionDebit.Rate, new Object[] { 1, 1 });
                insert3.add(CIAccounting.TransactionPositionDebit.RateAmount, gainloss.abs().negate());
                insert3.add(CIAccounting.TransactionPositionDebit.Amount, gainloss.abs().negate());
                insert3.execute();

                _parameter.put(ParameterValues.INSTANCE, docInst);
                new Accounting4DocSum().recalculateRate(_parameter);
            }
        }
    }
    return new Return();
}

From source file:org.kuali.kpme.tklm.leave.calendar.validation.LeaveCalendarValidationUtil.java

public static List<String> validateAvailableLeaveBalanceForUsage(String earnCode, String leaveStartDateString,
        String leaveEndDateString, BigDecimal leaveAmount, LeaveBlock updatedLeaveBlock) {
    List<String> errors = new ArrayList<String>();
    boolean earnCodeChanged = false;
    BigDecimal oldAmount = null;

    if (leaveAmount == null) {
        leaveAmount = TKUtils.getHoursBetween(TKUtils.formatDateString(leaveStartDateString).toDate().getTime(),
                TKUtils.formatDateString(leaveEndDateString).toDate().getTime());
    }//from w ww.j av a 2  s. c  o m
    if (updatedLeaveBlock != null) {
        if (!updatedLeaveBlock.getEarnCode().equals(earnCode)) {
            earnCodeChanged = true;
        }
        if (!updatedLeaveBlock.getLeaveAmount().equals(leaveAmount)) {
            oldAmount = updatedLeaveBlock.getLeaveAmount();
        }
    }
    LocalDate startDate = TKUtils.formatDateString(leaveStartDateString);
    LocalDate endDate = TKUtils.formatDateString(leaveEndDateString);
    long daysSpan = TKUtils.getDaysBetween(startDate, endDate);
    EarnCodeContract earnCodeObj = HrServiceLocator.getEarnCodeService().getEarnCode(earnCode, endDate);
    if (earnCodeObj != null && earnCodeObj.getAllowNegativeAccrualBalance().equals("N")) {
        AccrualCategoryContract accrualCategory = HrServiceLocator.getAccrualCategoryService()
                .getAccrualCategory(earnCodeObj.getAccrualCategory(), endDate);
        if (accrualCategory != null) {
            AccrualEarnInterval accrualEarnInterval = AccrualEarnInterval
                    .fromCode(accrualCategory.getAccrualEarnInterval());
            DateTime nextIntervalDate;
            if (accrualEarnInterval != null && AccrualEarnInterval.PAY_CAL.equals(accrualEarnInterval)) {
                RateRangeAggregateContract rrAggregate = LmServiceLocator.getAccrualService()
                        .buildRateRangeAggregate(HrContext.getTargetPrincipalId(),
                                startDate.toDateTimeAtStartOfDay(), endDate.toDateTimeAtStartOfDay());
                PrincipalHRAttributesContract phra = rrAggregate.getRateOnDate(endDate.toDateTimeAtStartOfDay())
                        .getPrincipalHRAttributes();
                nextIntervalDate = LmServiceLocator.getAccrualService().getNextIntervalDate(
                        endDate.toDateTimeAtStartOfDay(), accrualEarnInterval.getCode(), phra.getPayCalendar(),
                        rrAggregate.getCalEntryMap());
            } else {
                nextIntervalDate = LmServiceLocator.getAccrualService().getNextAccrualIntervalDate(
                        accrualCategory.getAccrualEarnInterval(), endDate.toDateTimeAtStartOfDay());
            }
            // get the usage checking cut off Date, normally it's the day before the next interval date
            DateTime usageEndDate = nextIntervalDate;
            if (nextIntervalDate.compareTo(endDate.toDateTimeAtCurrentTime()) > 0) {
                usageEndDate = nextIntervalDate.minusDays(1);
            }
            // use the end of the year as the interval date for usage checking of no-accrual hours,
            // normally no-accrual hours are from banked/transferred system scheduled time offs
            if (accrualCategory.getAccrualEarnInterval().equals(AccrualEarnInterval.NO_ACCRUAL.getCode())) {
                usageEndDate = endDate.toDateTimeAtStartOfDay().withMonthOfYear(DateTimeConstants.DECEMBER)
                        .withDayOfMonth(31);
            }
            BigDecimal availableBalance = LmServiceLocator.getLeaveSummaryService()
                    .getLeaveBalanceForAccrCatUpToDate(HrContext.getTargetPrincipalId(), startDate, endDate,
                            accrualCategory.getAccrualCategory(), usageEndDate.toLocalDate());

            if (oldAmount != null) {
                if (!earnCodeChanged || (updatedLeaveBlock.getAccrualCategory() != null && updatedLeaveBlock
                        .getAccrualCategory().equals(accrualCategory.getAccrualCategory()))) {
                    availableBalance = availableBalance.add(oldAmount.abs());
                }
            }
            //multiply by days in span in case the user has also edited the start/end dates.
            // daySpan for the same start/end dates is 0 so we need to add 1 to it
            BigDecimal desiredUsage = leaveAmount.multiply(new BigDecimal(daysSpan + 1));
            //            BigDecimal desiredUsage =null;
            //            if(!HrConstants.EARN_CODE_TIME.equals(earnCodeObj.getRecordMethod())) {
            //               desiredUsage = leaveAmount.multiply(new BigDecimal(daysSpan+1));
            //            } else {
            //               desiredUsage = leaveAmount.multiply(new BigDecimal(daysSpan));
            //            }

            if (desiredUsage.compareTo(availableBalance) > 0) {
                errors.add("Requested leave amount " + desiredUsage.toString()
                        + " is greater than available leave balance " + availableBalance.toString()); //errorMessages
            }
        }
    }

    return errors;
}

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 {/*  ww  w.  j av a2s.  co m*/
        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:org.efaps.esjp.accounting.transaction.Recalculate_Base.java

/**
 * @param _parameter Parameter as passed by the eFasp API
 * @return new Return//w  w w .j  av  a 2s.  c  o m
 * @throws EFapsException on error
 */
public Return createGainLoss4SimpleAccount(final Parameter _parameter) throws EFapsException {
    final PrintQuery printPer = new PrintQuery(_parameter.getInstance());
    final SelectBuilder selCurrInst = SelectBuilder.get().linkto(CIAccounting.Period.CurrencyLink).instance();
    printPer.addSelect(selCurrInst);
    printPer.addAttribute(CIAccounting.Period.FromDate, CIAccounting.Period.CurrencyLink);
    printPer.execute();
    final DateTime dateFrom = printPer.<DateTime>getAttribute(CIAccounting.Period.FromDate);
    final Instance currencyInst = printPer.<Instance>getSelect(selCurrInst);

    final String[] relOIDs = (String[]) Context.getThreadContext()
            .getSessionAttribute(CIFormAccounting.Accounting_GainLoss4SimpleAccountForm.config2period.name);
    final DateTime dateTo = new DateTime(_parameter
            .getParameterValue(CIFormAccounting.Accounting_GainLoss4SimpleAccountForm.transactionDate.name));
    final DateTime dateEx = new DateTime(_parameter
            .getParameterValue(CIFormAccounting.Accounting_GainLoss4SimpleAccountForm.exchangeDate.name));
    Insert insert = null;
    BigDecimal totalSum = BigDecimal.ZERO;

    for (final String oid : relOIDs) {
        Instance tarCurInst = null;
        final Instance relInst = Instance.get(oid);
        final PrintQuery print = new PrintQuery(relInst);
        final SelectBuilder selAccount = new SelectBuilder()
                .linkto(CIAccounting.AccountConfigSimple2Period.FromLink).oid();
        print.addSelect(selAccount);
        print.addAttribute(CIAccounting.AccountConfigSimple2Period.IsSale);
        if (print.execute()) {
            final Instance instAcc = Instance.get(print.<String>getSelect(selAccount));
            final boolean isSale = print.<Boolean>getAttribute(CIAccounting.AccountConfigSimple2Period.IsSale);
            final QueryBuilder attrQuerBldr = new QueryBuilder(CIAccounting.Transaction);
            attrQuerBldr.addWhereAttrEqValue(CIAccounting.Transaction.PeriodLink, _parameter.getInstance());
            attrQuerBldr.addWhereAttrGreaterValue(CIAccounting.Transaction.Date, dateFrom.minusMinutes(1));
            attrQuerBldr.addWhereAttrLessValue(CIAccounting.Transaction.Date, dateTo.plusDays(1));
            final AttributeQuery attrQuery = attrQuerBldr.getAttributeQuery(CIAccounting.Transaction.ID);

            final QueryBuilder queryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);
            queryBldr.addWhereAttrEqValue(CIAccounting.TransactionPositionAbstract.AccountLink, instAcc);
            queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink, attrQuery);
            final MultiPrintQuery multi = queryBldr.getPrint();
            final SelectBuilder selTRInst = SelectBuilder.get()
                    .linkto(CIAccounting.TransactionPositionAbstract.RateCurrencyLink).instance();
            multi.addSelect(selTRInst);
            multi.addAttribute(CIAccounting.TransactionPositionAbstract.Amount,
                    CIAccounting.TransactionPositionAbstract.RateAmount);
            BigDecimal gainlossSum = BigDecimal.ZERO;
            multi.execute();
            while (multi.next()) {
                final BigDecimal oldRateAmount = multi
                        .<BigDecimal>getAttribute(CIAccounting.TransactionPositionAbstract.RateAmount);
                final BigDecimal oldAmount = multi
                        .<BigDecimal>getAttribute(CIAccounting.TransactionPositionAbstract.Amount);
                final Instance targetCurrInst = multi.<Instance>getSelect(selTRInst);
                final BigDecimal rate = evaluateRate(_parameter, dateEx, currencyInst, targetCurrInst, isSale);
                final BigDecimal newAmount = oldRateAmount.divide(rate, BigDecimal.ROUND_HALF_UP);

                BigDecimal gainloss = BigDecimal.ZERO;
                if (!currencyInst.equals(targetCurrInst)) {
                    gainloss = newAmount.subtract(oldAmount);
                    tarCurInst = targetCurrInst;
                } else {
                    gainloss = newAmount;
                }
                gainlossSum = gainlossSum.add(gainloss);
            }
            totalSum = totalSum.add(gainlossSum);

            final Map<String, String[]> map = validateInfo(_parameter, gainlossSum);
            final String[] accs = map.get("accs");
            final String[] check = map.get("check");

            if (checkAccounts(accs, 0, check).length() > 0) {
                if (gainlossSum.compareTo(BigDecimal.ZERO) != 0) {
                    final String[] accOids = map.get("accountOids");
                    if (insert == null) {
                        final String descr = DBProperties.getFormatedDBProperty(
                                Recalculate.class.getName() + ".gainLoss4SimpleAccountTransDesc",
                                dateTo.toDate());
                        insert = new Insert(CIAccounting.Transaction);
                        insert.add(CIAccounting.Transaction.Description, descr);
                        insert.add(CIAccounting.Transaction.Date, dateTo);
                        insert.add(CIAccounting.Transaction.PeriodLink, _parameter.getInstance());
                        insert.add(CIAccounting.Transaction.Status,
                                Status.find(CIAccounting.TransactionStatus.Open));
                        insert.execute();
                    }

                    Insert insertPos = new Insert(CIAccounting.TransactionPositionDebit);
                    insertPos.add(CIAccounting.TransactionPositionDebit.TransactionLink, insert.getInstance());
                    if (gainlossSum.signum() > 0) {
                        insertPos.add(CIAccounting.TransactionPositionDebit.AccountLink,
                                Instance.get(accOids[0]));
                    } else {
                        insertPos.add(CIAccounting.TransactionPositionDebit.AccountLink, instAcc);
                    }
                    insertPos.add(CIAccounting.TransactionPositionDebit.Amount, gainlossSum.abs().negate());
                    insertPos.add(CIAccounting.TransactionPositionDebit.RateAmount, BigDecimal.ZERO);
                    insertPos.add(CIAccounting.TransactionPositionDebit.CurrencyLink, currencyInst);
                    insertPos.add(CIAccounting.TransactionPositionDebit.RateCurrencyLink, tarCurInst);
                    insertPos.add(CIAccounting.TransactionPositionDebit.Rate,
                            new Object[] { BigDecimal.ONE, BigDecimal.ONE });
                    insertPos.execute();

                    insertPos = new Insert(CIAccounting.TransactionPositionCredit);
                    insertPos.add(CIAccounting.TransactionPositionCredit.TransactionLink, insert.getInstance());
                    if (gainlossSum.signum() > 0) {
                        insertPos.add(CIAccounting.TransactionPositionCredit.AccountLink, instAcc);
                    } else {
                        insertPos.add(CIAccounting.TransactionPositionCredit.AccountLink,
                                Instance.get(accOids[0]));
                    }
                    insertPos.add(CIAccounting.TransactionPositionCredit.Amount, gainlossSum.abs());
                    insertPos.add(CIAccounting.TransactionPositionCredit.RateAmount, BigDecimal.ZERO);
                    insertPos.add(CIAccounting.TransactionPositionCredit.CurrencyLink, currencyInst);
                    insertPos.add(CIAccounting.TransactionPositionCredit.RateCurrencyLink, tarCurInst);
                    insertPos.add(CIAccounting.TransactionPositionCredit.Rate,
                            new Object[] { BigDecimal.ONE, BigDecimal.ONE });
                    insertPos.execute();
                }
            }
        }
    }
    if (insert != null) {
        final Instance instance = insert.getInstance();
        // create classifications
        final Classification classification1 = (Classification) CIAccounting.TransactionClass.getType();
        final Insert relInsert1 = new Insert(classification1.getClassifyRelationType());
        relInsert1.add(classification1.getRelLinkAttributeName(), instance);
        relInsert1.add(classification1.getRelTypeAttributeName(), classification1.getId());
        relInsert1.execute();

        final Insert classInsert1 = new Insert(classification1);
        classInsert1.add(classification1.getLinkAttributeName(), instance);
        classInsert1.execute();

        final Classification classification = (Classification) CIAccounting.TransactionClassGainLoss.getType();
        final Insert relInsert = new Insert(classification.getClassifyRelationType());
        relInsert.add(classification.getRelLinkAttributeName(), instance);
        relInsert.add(classification.getRelTypeAttributeName(), classification.getId());
        relInsert.execute();

        final Insert classInsert = new Insert(classification);
        classInsert.add(classification.getLinkAttributeName(), instance);
        classInsert.add(CIAccounting.TransactionClassGainLoss.Amount, totalSum);
        classInsert.add(CIAccounting.TransactionClassGainLoss.RateAmount, totalSum);
        classInsert.add(CIAccounting.TransactionClassGainLoss.CurrencyLink, currencyInst);
        classInsert.add(CIAccounting.TransactionClassGainLoss.RateCurrencyLink, currencyInst);
        classInsert.add(CIAccounting.TransactionClassGainLoss.Rate,
                new Object[] { BigDecimal.ONE, BigDecimal.ONE });
        classInsert.execute();
    }
    // clean up
    Context.getThreadContext()
            .removeSessionAttribute(CIFormAccounting.Accounting_GainLoss4SimpleAccountForm.config2period.name);
    return new Return();
}