Example usage for org.joda.time DateTime withTimeAtStartOfDay

List of usage examples for org.joda.time DateTime withTimeAtStartOfDay

Introduction

In this page you can find the example usage for org.joda.time DateTime withTimeAtStartOfDay.

Prototype

public DateTime withTimeAtStartOfDay() 

Source Link

Document

Returns a copy of this datetime with the time set to the start of the day.

Usage

From source file:org.apache.tajo.util.datetime.DateTimeUtil.java

License:Apache License

public static long getDay(DateTime dateTime) {
    return convertToMicroSeconds(dateTime.withTimeAtStartOfDay());
}

From source file:org.apache.tajo.util.datetime.DateTimeUtil.java

License:Apache License

public static long getMonth(DateTime dateTime) {
    return convertToMicroSeconds(
            dateTime.withTimeAtStartOfDay().withDate(dateTime.getYear(), dateTime.getMonthOfYear(), 1));
}

From source file:org.apache.tajo.util.datetime.DateTimeUtil.java

License:Apache License

public static long getDayOfWeek(DateTime dateTime, int week) {
    return convertToMicroSeconds(dateTime.withTimeAtStartOfDay().withDayOfWeek(week));
}

From source file:org.apache.tajo.util.datetime.DateTimeUtil.java

License:Apache License

public static long getYear(DateTime dateTime) {
    return convertToMicroSeconds(dateTime.withTimeAtStartOfDay().withDate(dateTime.getYear(), 1, 1));
}

From source file:org.apache.unomi.plugins.baseplugin.conditions.PropertyConditionESQueryBuilder.java

License:Apache License

private QueryBuilder getIsSameDayRange(Object value, String name) {
    DateTime date = new DateTime(value);
    DateTime dayStart = date.withTimeAtStartOfDay();
    DateTime dayAfterStart = date.plusDays(1).withTimeAtStartOfDay();
    return QueryBuilders.rangeQuery(name).gte(dayStart.toDate()).lte(dayAfterStart.toDate());
}

From source file:org.cast.cwm.admin.EventLog.java

License:Open Source License

protected Date midnightStart(Date olddate) {
    DateTime dateTime = new DateTime(olddate);
    DateTime adjustedDateTime = dateTime.withTimeAtStartOfDay();
    return adjustedDateTime.toDate();
}

From source file:org.efaps.esjp.accounting.export.sc.JournalSC1617_Base.java

License:Apache License

@Override
@SuppressWarnings("checkstyle:MethodLength")
public void buildDataSource(final Parameter _parameter, final Exporter _exporter) throws EFapsException {
    final String key = PropertiesUtil.getProperty(_parameter, "Key", "");

    final Properties props = PropertiesUtil.getProperties4Prefix(Accounting.EXPORT_SC1617.get(), key);

    final DateTime dateFrom = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617Form.dateFrom.name));
    final DateTime dateTo = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617Form.dateTo.name));
    final Instance purchaseRecordInst = Instance.get(_parameter
            .getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617RCForm.purchaseRecord.name));
    final Instance subJournalInst = Instance.get(
            _parameter.getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617Form.subJournal.name));
    final String marker = _parameter
            .getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617Form.marker.name);

    final String origin = _parameter
            .getParameterValue(CIFormAccounting.Accounting_ExportJournalSC1617Form.origin.name);

    final Properties oProps = PropertiesUtil.getProperties4Prefix(props, origin, true);
    //default as defined by an given orgin
    final boolean analyzeRemark = BooleanUtils.toBoolean(oProps.getProperty("AnalyzeRemark", "false"));
    final boolean useDate4Number = BooleanUtils.toBoolean(oProps.getProperty("UseDate4Number", "false"));
    final boolean useOrigDoc4Number = BooleanUtils.toBoolean(oProps.getProperty("UseOrigDoc4Number", "false"));
    final boolean concatenate = BooleanUtils.toBoolean(oProps.getProperty("Concatenate", "false"));

    final QueryBuilder queryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);
    final QueryBuilder transAttrQueryBldr = new QueryBuilder(CIAccounting.TransactionAbstract);

    // if a purchase record was selected use it as filter
    if (InstanceUtils.isValid(purchaseRecordInst)) {
        final QueryBuilder attrQueryBuilder = new QueryBuilder(CIAccounting.PurchaseRecord2Document);
        attrQueryBuilder.addWhereAttrEqValue(CIAccounting.PurchaseRecord2Document.FromLink, purchaseRecordInst);

        final QueryBuilder attrQueryBldr = new QueryBuilder(CIAccounting.Transaction2ERPDocument);
        attrQueryBldr.addWhereAttrInQuery(CIAccounting.Transaction2ERPDocument.ToLinkAbstract,
                attrQueryBuilder.getAttributeQuery(CIAccounting.PurchaseRecord2Document.ToLink));
        transAttrQueryBldr.addWhereAttrInQuery(CIAccounting.TransactionAbstract.ID,
                attrQueryBldr.getAttributeQuery(CIAccounting.Transaction2ERPDocument.FromLink));
    } else {/* w  ww  .  java2s. c  o  m*/
        transAttrQueryBldr.addWhereAttrLessValue(CIAccounting.TransactionAbstract.Date,
                dateTo.withTimeAtStartOfDay().plusDays(1));
        transAttrQueryBldr.addWhereAttrGreaterValue(CIAccounting.TransactionAbstract.Date,
                dateFrom.withTimeAtStartOfDay().minusSeconds(1));
    }
    if (InstanceUtils.isValid(subJournalInst)) {
        final QueryBuilder attrQueryBuilder = new QueryBuilder(CIAccounting.ReportSubJournal2Transaction);
        attrQueryBuilder.addWhereAttrEqValue(CIAccounting.ReportSubJournal2Transaction.FromLink,
                subJournalInst);
        transAttrQueryBldr.addWhereAttrInQuery(CIAccounting.TransactionAbstract.ID,
                attrQueryBuilder.getAttributeQuery(CIAccounting.ReportSubJournal2Transaction.ToLink));
    }
    final AttributeQuery transAttrQuery = transAttrQueryBldr
            .getAttributeQuery(CIAccounting.TransactionAbstract.ID);

    queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink, transAttrQuery);

    final MultiPrintQuery multi = queryBldr.getPrint();
    final SelectBuilder selAcc = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.AccountLink);
    final SelectBuilder selAccName = new SelectBuilder(selAcc).attribute(CIAccounting.AccountAbstract.Name);

    final SelectBuilder selTrans = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.TransactionLink);
    final SelectBuilder selTransInst = new SelectBuilder(selTrans).instance();
    final SelectBuilder selTransDescr = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Description);
    final SelectBuilder selTransIdentifier = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Identifier);
    final SelectBuilder selTransName = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Name);
    final SelectBuilder selTransDate = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Date);

    final SelectBuilder selDoc = SelectBuilder.get()
            .linkfrom(CIAccounting.TransactionPosition2ERPDocument.FromLinkAbstract)
            .linkto(CIAccounting.TransactionPosition2ERPDocument.ToLinkAbstract);
    final SelectBuilder selDocInst = new SelectBuilder(selDoc).instance();
    final SelectBuilder selDocName = new SelectBuilder(selDoc).attribute(CISales.DocumentSumAbstract.Name);
    final SelectBuilder selDocRev = new SelectBuilder(selDoc).attribute(CISales.DocumentSumAbstract.Revision);
    final SelectBuilder selDocDate = new SelectBuilder(selDoc).attribute(CISales.DocumentSumAbstract.Date);
    final SelectBuilder selDocDueDate = new SelectBuilder(selDoc)
            .attribute(CISales.DocumentSumAbstract.DueDate);
    final SelectBuilder selNetTotal = new SelectBuilder(selDoc)
            .attribute(CISales.DocumentSumAbstract.RateNetTotal);
    final SelectBuilder selCrossTotal = new SelectBuilder(selDoc)
            .attribute(CISales.DocumentSumAbstract.RateCrossTotal);

    final SelectBuilder selContact = new SelectBuilder(selDoc).linkto(CISales.DocumentAbstract.Contact);
    final SelectBuilder selContactName = new SelectBuilder(selContact).attribute(CIContacts.Contact.Name);
    final SelectBuilder selTaxNumber = new SelectBuilder(selContact).clazz(CIContacts.ClassOrganisation)
            .attribute(CIContacts.ClassOrganisation.TaxNumber);

    multi.addSelect(selAccName, selTransIdentifier, selTransInst, selTransName, selTransDescr, selTransDate,
            selDocInst, selDocName, selDocDate, selDocDueDate, selContactName, selTaxNumber, selNetTotal,
            selCrossTotal, selDocRev);
    multi.addAttribute(CIAccounting.TransactionPositionAbstract.RateAmount,
            CIAccounting.TransactionPositionAbstract.Position,
            CIAccounting.TransactionPositionAbstract.PositionType,
            CIAccounting.TransactionPositionAbstract.RateCurrencyLink,
            CIAccounting.TransactionPositionAbstract.Rate, CIAccounting.TransactionPositionAbstract.Remark);
    multi.execute();
    final List<DataBean> beans = new ArrayList<>();
    while (multi.next()) {
        final Instance transInst = multi.getSelect(selTransInst);
        final Instance posInst = multi.getCurrentInstance();
        final String remark = multi.getAttribute(CIAccounting.TransactionPositionAbstract.Remark);
        String descr = multi.<String>getSelect(selTransDescr);
        String contactName = multi.<String>getSelect(selContactName);
        String taxNumber = multi.<String>getSelect(selTaxNumber);
        Instance docInst = multi.<Instance>getSelect(selDocInst);
        String docName = multi.<String>getSelect(selDocName);
        String docRev = multi.<String>getSelect(selDocRev);
        if (StringUtils.isNotEmpty(remark)) {
            if (concatenate) {
                descr = descr + " " + remark;
            } else {
                descr = remark;
            }
            final boolean swap;
            final String debKey = InstanceUtils.isType(posInst, CIAccounting.TransactionPositionDebit)
                    ? ".Debit"
                    : ".Credit";
            if (InstanceUtils.isValid(docInst)
                    && oProps.containsKey(docInst.getType().getName() + debKey + ".AnalyzeRemark")) {
                swap = BooleanUtils
                        .toBoolean(oProps.getProperty(docInst.getType().getName() + debKey + ".AnalyzeRemark"));
            } else if (InstanceUtils.isValid(docInst)
                    && oProps.containsKey(docInst.getType().getName() + ".AnalyzeRemark")) {
                swap = BooleanUtils
                        .toBoolean(oProps.getProperty(docInst.getType().getName() + ".AnalyzeRemark"));
            } else {
                swap = analyzeRemark;
            }
            if (swap) {
                final QueryBuilder tr2docQueryBldr = new QueryBuilder(CIAccounting.Transaction2ERPDocument);
                tr2docQueryBldr.addWhereAttrEqValue(CIAccounting.Transaction2ERPDocument.FromLink, transInst);

                final QueryBuilder docQueryBldr = new QueryBuilder(CIERP.DocumentAbstract);
                docQueryBldr.addWhereAttrInQuery(CIERP.DocumentAbstract.ID,
                        tr2docQueryBldr.getAttributeQuery(CIAccounting.Transaction2ERPDocument.ToLinkAbstract));
                docQueryBldr.addWhereAttrEqValue(CIERP.DocumentAbstract.Name, remark);
                final MultiPrintQuery docMulti = docQueryBldr.getCachedPrint4Request();
                final SelectBuilder docSelContact = SelectBuilder.get()
                        .linkto(CISales.DocumentAbstract.Contact);
                final SelectBuilder docSelContactName = new SelectBuilder(docSelContact)
                        .attribute(CIContacts.Contact.Name);
                final SelectBuilder docSelTaxNumber = new SelectBuilder(docSelContact)
                        .clazz(CIContacts.ClassOrganisation).attribute(CIContacts.ClassOrganisation.TaxNumber);
                docMulti.addSelect(docSelContactName, docSelTaxNumber);
                docMulti.addAttribute(CIERP.DocumentAbstract.Revision);
                docMulti.execute();
                if (docMulti.getInstanceList().size() == 1) {
                    docMulti.next();
                    docInst = docMulti.getCurrentInstance();
                    contactName = docMulti.getSelect(docSelContactName);
                    taxNumber = docMulti.getSelect(docSelTaxNumber);
                    docRev = docMulti.getAttribute(CIERP.DocumentAbstract.Revision);
                    if (concatenate) {
                        descr = multi.<String>getSelect(selTransDescr) + " " + docName;
                    } else {
                        descr = docName;
                    }
                    docName = remark;
                }
            }
        }
        final DataBean bean = new DataBean().setReportKey(key).setTransInstance(transInst)
                .setPosInstance(posInst).setOrigin(oProps.getProperty("Value", "--")).setOriginKey(origin)
                .setMarker(marker).setTransDate(multi.<DateTime>getSelect(selTransDate))
                .setNumber(multi.getSelect(selTransIdentifier))
                .setPosition(multi.<Integer>getAttribute(CIAccounting.TransactionPositionAbstract.Position))
                .setAccName(multi.<String>getSelect(selAccName))
                .setAmount(multi.<BigDecimal>getAttribute(CIAccounting.TransactionPositionAbstract.RateAmount))
                .setTransDescr(descr)
                .setCurrencyId(
                        multi.<Long>getAttribute(CIAccounting.TransactionPositionAbstract.RateCurrencyLink))
                .setOrigDocInst(multi.<Instance>getSelect(selDocInst))
                .setOrigDocName(multi.<String>getSelect(selDocName))
                .setOrigDocRevision(multi.<String>getSelect(selDocRev)).setDocInst(docInst).setDocName(docName)
                .setDocRevision(docRev).setContactName(contactName).setTaxNumber(taxNumber)
                .setDocDate(multi.<DateTime>getSelect(selDocDate))
                .setDocDueDate(multi.<DateTime>getSelect(selDocDueDate))
                .setRate(multi.<Object[]>getAttribute(CIAccounting.TransactionPositionAbstract.Rate))
                .setNetTotal(multi.<BigDecimal>getSelect(selNetTotal))
                .setCrossTotal(multi.<BigDecimal>getSelect(selCrossTotal));
        beans.add(bean);
    }
    final ComparatorChain<DataBean> chain = new ComparatorChain<>();
    chain.addComparator((_o1, _o2) -> _o1.getTransDate().compareTo(_o2.getTransDate()));
    chain.addComparator((_o1, _o2) -> _o1.getNumber().compareTo(_o2.getNumber()));
    chain.addComparator((_o1, _o2) -> _o1.getPosition().compareTo(_o2.getPosition()));
    Collections.sort(beans, chain);

    int i = 1;
    String currentID = "";
    String currentVal = "";
    // it must be ensured that one transaction has all the time the same number, therefore the first value wins
    for (final DataBean bean : beans) {
        if (!currentID.equals(bean.getNumber())) {
            currentID = bean.getNumber();
            // first priority are the related documents
            if (useDate4Number) {
                currentVal = String.format("%05d", bean.getTransDate().getDayOfMonth());
            } else if (useOrigDoc4Number) {
                currentVal = bean.getOrigDocName();
                final String def;
                if (InstanceUtils.isValid(bean.getOrigDocInst())) {
                    if (oProps.containsKey(bean.getOrigDocInst().getType().getName() + ".Number")) {
                        def = oProps.getProperty(bean.getOrigDocInst().getType().getName() + ".Number");
                    } else if (props.containsKey(bean.getOrigDocInst().getType().getName() + ".Number")) {
                        def = props.getProperty(bean.getOrigDocInst().getType().getName() + ".Number");
                    } else {
                        def = "";
                    }
                } else {
                    def = "";
                }
                switch (def) {
                case "DocName":
                    currentVal = bean.getOrigDocName();
                    break;
                case "DocRevision":
                    currentVal = bean.getOrigDocRevision();
                    break;
                case "DocCode":
                    currentVal = bean.getOrigDocCode();
                    break;
                default:
                    currentVal = String.format("%05d", i);
                    i++;
                    break;
                }
            } else {
                final String def;
                if (InstanceUtils.isValid(bean.getDocInst())) {
                    if (oProps.containsKey(bean.getDocInst().getType().getName() + ".Number")) {
                        def = oProps.getProperty(bean.getDocInst().getType().getName() + ".Number");
                    } else if (props.containsKey(bean.getDocInst().getType().getName() + ".Number")) {
                        def = props.getProperty(bean.getDocInst().getType().getName() + ".Number");
                    } else {
                        def = "";
                    }
                } else {
                    def = "";
                }
                switch (def) {
                case "TransName":
                    currentVal = bean.getNumber();
                    break;
                case "DocName":
                    currentVal = bean.getDocName();
                    break;
                case "DocRevision":
                    currentVal = bean.getDocRevision();
                    break;
                case "DocCode":
                    currentVal = bean.getDocCode();
                    break;
                default:
                    currentVal = String.format("%05d", i);
                    i++;
                    break;
                }
            }
        }
        bean.setNumber(currentVal);
        _exporter.addBeanRows(bean);
    }
}

From source file:org.efaps.esjp.accounting.report.CashReport11DS_Base.java

License:Apache License

/**
 * {@inheritDoc}//from   w  ww  .j a  v  a2 s .  c o  m
 */
@Override
public void init(final JasperReport _jasperReport, final Parameter _parameter, final JRDataSource _parentSource,
        final Map<String, Object> _jrParameters) throws EFapsException {
    super.init(_jasperReport, _parameter, _parentSource, _jrParameters);

    final DateTime dateFrom = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportCash11ReportForm.dateFrom.name));
    final DateTime dateTo = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportCash11ReportForm.dateTo.name));

    final QueryBuilder queryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);

    final QueryBuilder transAttrQueryBldr = new QueryBuilder(CIAccounting.TransactionAbstract);
    transAttrQueryBldr.addWhereAttrLessValue(CIAccounting.TransactionAbstract.Date,
            dateTo.withTimeAtStartOfDay().plusDays(1));
    queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink,
            transAttrQueryBldr.getAttributeQuery(CIAccounting.TransactionAbstract.ID));

    final List<Instance> accInsts = getAccountInst(_parameter, AccountingSettings.PERIOD_REPORT11ACCOUNT);
    if (accInsts.isEmpty()) {
        LOG.error("Missing configuration '{}' for this report.", AccountingSettings.PERIOD_REPORT11ACCOUNT);
    } else {
        final QueryBuilder attrQueryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);
        attrQueryBldr.addWhereAttrEqValue(CIAccounting.TransactionPositionAbstract.AccountLink,
                accInsts.toArray());

        queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink,
                attrQueryBldr.getAttributeQuery(CIAccounting.TransactionPositionAbstract.TransactionLink));
        queryBldr.addWhereAttrNotEqValue(CIAccounting.TransactionPositionAbstract.AccountLink,
                accInsts.toArray());
    }

    final MultiPrintQuery multi = queryBldr.getPrint();
    final SelectBuilder selAcc = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.AccountLink);
    final SelectBuilder selAccName = new SelectBuilder(selAcc).attribute(CIAccounting.AccountAbstract.Name);
    final SelectBuilder selAccDescr = new SelectBuilder(selAcc)
            .attribute(CIAccounting.AccountAbstract.Description);

    final SelectBuilder selTrans = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.TransactionLink);
    final SelectBuilder selTransDescr = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Description);
    final SelectBuilder selTransDate = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Date);

    multi.addSelect(selAccName, selAccDescr, selTransDescr, selTransDate);
    multi.addAttribute(CIAccounting.TransactionPositionAbstract.Amount);
    multi.execute();
    final List<DataBean> values = new ArrayList<>();
    final DataBean411 carryOver = new DataBean411();
    carryOver.setAmount(BigDecimal.ZERO);
    carryOver.setTransDescr(DBProperties.getProperty(CashReport11DS.class.getName() + ".CarryOver"));
    while (multi.next()) {
        final DateTime date = multi.<DateTime>getSelect(selTransDate);
        final BigDecimal amount = multi
                .<BigDecimal>getAttribute(CIAccounting.TransactionPositionAbstract.Amount);
        if (date.isBefore(dateFrom)) {
            carryOver.setAmount(carryOver.getAmount().add(amount));
        } else {
            final DataBean411 bean = new DataBean411();
            bean.setTransDate(date);
            bean.setTransDescr(multi.<String>getSelect(selTransDescr));
            bean.setAccName(multi.<String>getSelect(selAccName));
            bean.setAccDescr(multi.<String>getSelect(selAccDescr));
            bean.setAmount(amount);
            values.add(bean);
        }
    }
    final ComparatorChain<DataBean> chain = new ComparatorChain<>();
    chain.addComparator(new Comparator<DataBean>() {

        @Override
        public int compare(final DataBean _arg0, final DataBean _arg1) {
            return _arg0.getTransDate().compareTo(_arg1.getTransDate());
        }

    });
    Collections.sort(values, chain);
    if (carryOver.getAmount().compareTo(BigDecimal.ZERO) != 0) {
        values.add(0, carryOver);
    }
    setData(values);
}

From source file:org.efaps.esjp.accounting.report.CashReport12DS_Base.java

License:Apache License

/**
 * {@inheritDoc}/*from w  w w . j a va 2 s . com*/
 */
@Override
public void init(final JasperReport _jasperReport, final Parameter _parameter, final JRDataSource _parentSource,
        final Map<String, Object> _jrParameters) throws EFapsException {
    super.init(_jasperReport, _parameter, _parentSource, _jrParameters);

    final DateTime dateFrom = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportCash12ReportForm.dateFrom.name));
    final DateTime dateTo = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportCash12ReportForm.dateTo.name));

    final QueryBuilder queryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);

    final QueryBuilder transAttrQueryBldr = new QueryBuilder(CIAccounting.TransactionAbstract);
    transAttrQueryBldr.addWhereAttrLessValue(CIAccounting.TransactionAbstract.Date,
            dateTo.withTimeAtStartOfDay().plusDays(1));

    final AttributeQuery transAttrQuery = transAttrQueryBldr
            .getAttributeQuery(CIAccounting.TransactionAbstract.ID);
    queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink, transAttrQuery);

    final Instance relinst = Instance.get(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportCash12ReportForm.account.name));
    final PrintQuery print = new PrintQuery(relinst);
    final SelectBuilder selAccInst = SelectBuilder.get()
            .linkto(CIAccounting.Period2Account.FromAccountAbstractLink).instance();
    final SelectBuilder selSalesAccInst = SelectBuilder.get()
            .linkto(CIAccounting.Period2Account.SalesAccountLink).instance();
    final SelectBuilder selSalesAccName = SelectBuilder.get()
            .linkto(CIAccounting.Period2Account.SalesAccountLink).attribute(CISales.AccountAbstract.Name);
    print.addSelect(selAccInst, selSalesAccInst, selSalesAccName);
    print.execute();
    final Instance accInst = print.<Instance>getSelect(selAccInst);
    final Instance salesAccInst = print.<Instance>getSelect(selSalesAccInst);
    _jrParameters.put("AccountName", print.getSelect(selSalesAccName));

    if (salesAccInst.getType().isKindOf(CISales.AccountCashDesk.getType())) {
        final SelectBuilder selSalesAccFIValue = SelectBuilder.get()
                .linkto(CISales.AccountCashDesk.FinancialInstitute)
                .attribute(CISales.AttributeDefinitionFinancialInstitute.Value);
        final SelectBuilder selSalesAccFImapKey = SelectBuilder.get()
                .linkto(CISales.AccountCashDesk.FinancialInstitute)
                .attribute(CISales.AttributeDefinitionFinancialInstitute.MappingKey);

        final PrintQuery salesAccPrint = new PrintQuery(salesAccInst);
        salesAccPrint.addSelect(selSalesAccFIValue, selSalesAccFImapKey);
        salesAccPrint.execute();
        final String fiMapKey = salesAccPrint.getSelect(selSalesAccFImapKey);
        final String fiValue = salesAccPrint.getSelect(selSalesAccFIValue);
        _jrParameters.put("Banc", fiMapKey + " - " + fiValue);
    }

    final QueryBuilder attrQueryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);
    attrQueryBldr.addWhereAttrEqValue(CIAccounting.TransactionPositionAbstract.AccountLink, accInst);

    queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink,
            attrQueryBldr.getAttributeQuery(CIAccounting.TransactionPositionAbstract.TransactionLink));
    queryBldr.addWhereAttrNotEqValue(CIAccounting.TransactionPositionAbstract.AccountLink, accInst);

    final MultiPrintQuery multi = queryBldr.getPrint();
    final SelectBuilder selAcc = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.AccountLink);
    final SelectBuilder selAccName = new SelectBuilder(selAcc).attribute(CIAccounting.AccountAbstract.Name);
    final SelectBuilder selAccDescr = new SelectBuilder(selAcc)
            .attribute(CIAccounting.AccountAbstract.Description);

    final SelectBuilder selTrans = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.TransactionLink);
    final SelectBuilder selTransInst = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.TransactionLink).instance();
    final SelectBuilder selTransDescr = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Description);
    final SelectBuilder selTransDate = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Date);

    multi.addSelect(selAccName, selAccDescr, selTransInst, selTransDescr, selTransDate);
    multi.addAttribute(CIAccounting.TransactionPositionAbstract.Amount);
    multi.execute();
    final List<DataBean> values = new ArrayList<>();
    final Map<Instance, Set<DataBean412>> map = new HashMap<>();
    final DataBean412 carryOver = new DataBean412();
    carryOver.setAmount(BigDecimal.ZERO);
    carryOver.setTransDescr(DBProperties.getProperty(CashReport12DS.class.getName() + ".CarryOver"));
    while (multi.next()) {
        final DateTime date = multi.<DateTime>getSelect(selTransDate);
        final BigDecimal amount = multi
                .<BigDecimal>getAttribute(CIAccounting.TransactionPositionAbstract.Amount);
        if (date.isBefore(dateFrom)) {
            carryOver.setAmount(carryOver.getAmount().add(amount));
        } else {
            final Instance transInst = multi.getSelect(selTransInst);
            final DataBean412 bean = new DataBean412();
            bean.setTransDate(date);
            bean.setTransDescr(multi.<String>getSelect(selTransDescr));
            bean.setAccName(multi.<String>getSelect(selAccName));
            bean.setAccDescr(multi.<String>getSelect(selAccDescr));
            bean.setAmount(amount);
            values.add(bean);
            Set<DataBean412> beans;
            if (!map.containsKey(transInst)) {
                map.put(transInst, new HashSet<DataBean412>());
            }
            beans = map.get(transInst);
            beans.add(bean);
        }
    }

    final QueryBuilder relQueryBldr = new QueryBuilder(CIAccounting.Transaction2ERPDocument);
    relQueryBldr.addWhereAttrInQuery(CIAccounting.Transaction2ERPDocument.FromLink, transAttrQuery);
    final MultiPrintQuery relMulti = relQueryBldr.getPrint();
    final SelectBuilder transSel = SelectBuilder.get().linkto(CIAccounting.Transaction2ERPDocument.FromLink)
            .instance();
    final SelectBuilder docContactNameSel = SelectBuilder.get()
            .linkto(CIAccounting.Transaction2ERPDocument.ToLinkAbstract).linkto(CIERP.DocumentAbstract.Contact)
            .attribute(CIContacts.ContactAbstract.Name);
    final SelectBuilder docNameSel = SelectBuilder.get()
            .linkto(CIAccounting.Transaction2ERPDocument.ToLinkAbstract).attribute(CIERP.DocumentAbstract.Name);
    relMulti.addSelect(transSel, docNameSel, docContactNameSel);
    relMulti.execute();
    while (relMulti.next()) {
        final Instance transInst = relMulti.getSelect(transSel);
        if (map.containsKey(transInst)) {
            final String docContactName = relMulti.getSelect(docContactNameSel);
            final String docName = relMulti.getSelect(docNameSel);
            final Set<DataBean412> beans = map.get(transInst);
            for (final DataBean412 bean : beans) {
                bean.addDocContactName(docContactName);
                bean.addCode(docName);
            }
        }
    }
    final ComparatorChain<DataBean> chain = new ComparatorChain<>();
    chain.addComparator(new Comparator<DataBean>() {

        @Override
        public int compare(final DataBean _arg0, final DataBean _arg1) {
            return _arg0.getTransDate().compareTo(_arg1.getTransDate());
        }

    });
    Collections.sort(values, chain);
    if (carryOver.getAmount().compareTo(BigDecimal.ZERO) != 0) {
        values.add(0, carryOver);
    }
    setData(values);
}

From source file:org.efaps.esjp.accounting.report.JournalReport51DS_Base.java

License:Apache License

@Override
public void init(final JasperReport _jasperReport, final Parameter _parameter, final JRDataSource _parentSource,
        final Map<String, Object> _jrParameters) throws EFapsException {
    super.init(_jasperReport, _parameter, _parentSource, _jrParameters);

    final DateTime dateFrom = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportJournal51Form.dateFrom.name));
    final DateTime dateTo = new DateTime(
            _parameter.getParameterValue(CIFormAccounting.Accounting_PReportJournal51Form.dateTo.name));

    final Instance periodInstance = Period.evalCurrent(_parameter);

    final QueryBuilder queryBldr = new QueryBuilder(CIAccounting.TransactionPositionAbstract);
    final QueryBuilder transAttrQueryBldr = new QueryBuilder(CIAccounting.TransactionAbstract);
    transAttrQueryBldr.addWhereAttrLessValue(CIAccounting.TransactionAbstract.Date,
            dateTo.withTimeAtStartOfDay().plusDays(1));
    transAttrQueryBldr.addWhereAttrGreaterValue(CIAccounting.TransactionAbstract.Date,
            dateFrom.withTimeAtStartOfDay().minusSeconds(1));
    transAttrQueryBldr.addWhereAttrEqValue(CIAccounting.TransactionAbstract.PeriodLink, periodInstance);

    final AttributeQuery transAttrQuery = transAttrQueryBldr
            .getAttributeQuery(CIAccounting.TransactionAbstract.ID);

    queryBldr.addWhereAttrInQuery(CIAccounting.TransactionPositionAbstract.TransactionLink, transAttrQuery);

    final MultiPrintQuery multi = queryBldr.getPrint();
    final SelectBuilder selAcc = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.AccountLink);
    final SelectBuilder selAccName = new SelectBuilder(selAcc).attribute(CIAccounting.AccountAbstract.Name);
    final SelectBuilder selAccDescr = new SelectBuilder(selAcc)
            .attribute(CIAccounting.AccountAbstract.Description);

    final SelectBuilder selTrans = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.TransactionLink);
    final SelectBuilder selTransOID = new SelectBuilder(selTrans).oid();
    final SelectBuilder selTransDescr = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Description);
    final SelectBuilder selTransIdentifier = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Identifier);
    final SelectBuilder selTransName = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Name);
    final SelectBuilder selTransDate = new SelectBuilder(selTrans)
            .attribute(CIAccounting.TransactionAbstract.Date);

    final SelectBuilder selCurInst = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.CurrencyLink).instance();
    final SelectBuilder selRateCurInst = SelectBuilder.get()
            .linkto(CIAccounting.TransactionPositionAbstract.RateCurrencyLink).instance();
    multi.addSelect(selAccName, selAccDescr, selTransIdentifier, selTransOID, selTransName, selTransDescr,
            selTransDate, selCurInst, selRateCurInst);
    multi.addAttribute(CIAccounting.TransactionPositionAbstract.Amount,
            CIAccounting.TransactionPositionAbstract.Position,
            CIAccounting.TransactionPositionAbstract.RateAmount);
    multi.execute();//from   www.j av a2  s  . c  o m
    final List<DataBean> values = new ArrayList<>();
    final Map<String, DataBean> map = new HashMap<>();
    while (multi.next()) {
        final String transOID = multi.getSelect(selTransOID);
        final DataBean bean;
        if (map.containsKey(transOID)) {
            bean = map.get(transOID);
        } else {
            bean = new DataBean().setParameter(_parameter).setTransOID(transOID)
                    .setTransName(multi.getSelect(selTransName)).setTransDate(multi.getSelect(selTransDate))
                    .setTransDescr(multi.getSelect(selTransDescr))
                    .setTransIdentifier(multi.getSelect(selTransIdentifier));
            values.add(bean);
            map.put(transOID, bean);
        }
        final DetailBean detailBean = new DetailBean().setAccName(multi.getSelect(selAccName))
                .setAccDescr(multi.getSelect(selAccDescr))
                .setAmount(multi.getAttribute(CIAccounting.TransactionPositionAbstract.Amount))
                .setCurrencyInstance(multi.getSelect(selCurInst))
                .setRateAmount(multi.getAttribute(CIAccounting.TransactionPositionAbstract.RateAmount))
                .setCurrencyInstance(multi.getSelect(selCurInst))
                .setPosition(multi.getAttribute(CIAccounting.TransactionPositionAbstract.Position))
                .setRateCurrencyInstance(multi.getSelect(selRateCurInst));
        bean.addDetail(detailBean);
    }

    final QueryBuilder relQueryBldr = new QueryBuilder(CIAccounting.Transaction2ERPDocument);
    relQueryBldr.addWhereAttrInQuery(CIAccounting.Transaction2ERPDocument.FromLink, transAttrQuery);
    final MultiPrintQuery relMulti = relQueryBldr.getPrint();
    final SelectBuilder transSel = SelectBuilder.get().linkto(CIAccounting.Transaction2ERPDocument.FromLink)
            .instance();
    final SelectBuilder docNameSel = SelectBuilder.get()
            .linkto(CIAccounting.Transaction2ERPDocument.ToLinkAbstract).attribute(CIERP.DocumentAbstract.Name);
    relMulti.addSelect(transSel, docNameSel);
    relMulti.execute();
    while (relMulti.next()) {
        final Instance transInst = relMulti.getSelect(transSel);
        final DataBean bean = map.get(transInst.getOid());
        bean.addDoc(relMulti.<String>getSelect(docNameSel));
    }

    final QueryBuilder subJAttrQueryBldr = new QueryBuilder(CIAccounting.ReportSubJournal);
    subJAttrQueryBldr.addWhereAttrEqValue(CIAccounting.ReportSubJournal.Config,
            Accounting.SubJournalConfig.OFFICIAL);
    final QueryBuilder subJQueryBldr = new QueryBuilder(CIAccounting.ReportSubJournal2Transaction);
    subJQueryBldr.addWhereAttrInQuery(CIAccounting.ReportSubJournal2Transaction.FromLink,
            subJAttrQueryBldr.getAttributeQuery(CIAccounting.ReportSubJournal.ID));
    subJQueryBldr.addWhereAttrInQuery(CIAccounting.ReportSubJournal2Transaction.ToLink, transAttrQuery);
    final MultiPrintQuery subJMulti = subJQueryBldr.getPrint();
    final SelectBuilder transSel2 = SelectBuilder.get().linkto(CIAccounting.ReportSubJournal2Transaction.ToLink)
            .instance();
    final SelectBuilder subJNameSel = SelectBuilder.get()
            .linkto(CIAccounting.ReportSubJournal2Transaction.FromLink)
            .attribute(CIAccounting.ReportSubJournal.Name);
    subJMulti.addSelect(transSel2, subJNameSel);
    subJMulti.addAttribute(CIAccounting.ReportSubJournal2Transaction.Number);
    subJMulti.execute();
    while (subJMulti.next()) {
        final Instance transInst = subJMulti.getSelect(transSel2);
        map.get(transInst.getOid()).addDocReg(subJMulti.<String>getSelect(subJNameSel))
                .addDocNum(subJMulti.<String>getAttribute(CIAccounting.ReportSubJournal2Transaction.Number));
    }

    final ComparatorChain<DataBean> chain = new ComparatorChain<>();
    chain.addComparator(new Comparator<DataBean>() {

        @Override
        public int compare(final DataBean _arg0, final DataBean _arg1) {
            final String arg0 = _arg0.getTransName().isEmpty() ? "XXXXXXXX" : _arg0.getTransName();
            final String arg1 = _arg1.getTransName().isEmpty() ? "XXXXXXXX" : _arg1.getTransName();
            return arg0.compareTo(arg1);
        }
    });
    chain.addComparator(new Comparator<DataBean>() {

        @Override
        public int compare(final DataBean _arg0, final DataBean _arg1) {
            return _arg0.getTransDate().compareTo(_arg1.getTransDate());
        }
    });
    chain.addComparator(new Comparator<DataBean>() {

        @Override
        public int compare(final DataBean _o1, final DataBean _o2) {
            return _o1.getTransIdentifier().compareTo(_o2.getTransIdentifier());
        }
    });

    Collections.sort(values, chain);
    setData(values);
}