Examples with GeneralLedgerEntry org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry used on opensource projects

Example 1 with GeneralLedgerEntry

use of org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry in project cu-kfs by CU-CommunityApps.

the class GlLineServiceImpl method createAssetPaymentDetails.

/**
 * Creates asset payment details based on accounting lines distributed
 * for the given capital asset.
 *
 * @param entry
 * @param document
 * @param seqNo
 * @param capitalAssetLineNumber
 * @return List<AssetPaymentDetail>
 */
protected List<AssetPaymentDetail> createAssetPaymentDetails(GeneralLedgerEntry entry, Document document, int seqNo, Integer capitalAssetLineNumber) {
    List<AssetPaymentDetail> appliedPayments = new ArrayList<AssetPaymentDetail>();
    CapitalAssetInformation capitalAssetInformation = findCapitalAssetInformation(entry.getDocumentNumber(), capitalAssetLineNumber);
    Collection<GeneralLedgerEntry> documentGlEntries = findAllGeneralLedgerEntry(entry.getDocumentNumber());
    if (ObjectUtils.isNotNull(capitalAssetInformation)) {
        List<CapitalAssetAccountsGroupDetails> groupAccountingLines = capitalAssetInformation.getCapitalAssetAccountsGroupDetails();
        Integer paymentSequenceNumber = 1;
        for (CapitalAssetAccountsGroupDetails accountingLine : groupAccountingLines) {
            AssetPaymentDetail detail = new AssetPaymentDetail();
            // find matching gl entry for asset accounting line
            for (GeneralLedgerEntry glEntry : documentGlEntries) {
                if (doesGeneralLedgerEntryMatchAssetAccountingDetails(glEntry, accountingLine)) {
                    entry = glEntry;
                }
            }
            // TODO
            // sub-object code, as well as sub-account, project code, and org ref id, shall not be populated from GL entry;
            // instead, they need to be passed from the original FP document for each individual accounting line to be stored in CapitalAssetAccountsGroupDetails,
            // and copied into each corresponding accounting line in Asset Payment here.
            detail.setDocumentNumber(document.getDocumentNumber());
            detail.setSequenceNumber(paymentSequenceNumber++);
            detail.setPostingYear(entry.getUniversityFiscalYear());
            detail.setPostingPeriodCode(entry.getUniversityFiscalPeriodCode());
            detail.setChartOfAccountsCode(accountingLine.getChartOfAccountsCode());
            detail.setAccountNumber(replaceFiller(accountingLine.getAccountNumber()));
            detail.setSubAccountNumber(replaceFiller(accountingLine.getSubAccountNumber()));
            detail.setFinancialObjectCode(replaceFiller(accountingLine.getFinancialObjectCode()));
            detail.setFinancialSubObjectCode(replaceFiller(accountingLine.getFinancialSubObjectCode()));
            detail.setProjectCode(replaceFiller(accountingLine.getProjectCode()));
            detail.setOrganizationReferenceId(replaceFiller(accountingLine.getOrganizationReferenceId()));
            // detail.setAmount(KFSConstants.GL_CREDIT_CODE.equals(debitCreditCode) ? accountingLine.getAmount().negated() : accountingLine.getAmount());
            detail.setAmount(getAccountingLineAmountForPaymentDetail(entry, accountingLine));
            detail.setExpenditureFinancialSystemOriginationCode(replaceFiller(entry.getFinancialSystemOriginationCode()));
            detail.setExpenditureFinancialDocumentNumber(entry.getDocumentNumber());
            detail.setExpenditureFinancialDocumentTypeCode(replaceFiller(entry.getFinancialDocumentTypeCode()));
            detail.setExpenditureFinancialDocumentPostedDate(entry.getTransactionDate());
            detail.setPurchaseOrderNumber(replaceFiller(entry.getReferenceFinancialDocumentNumber()));
            detail.setTransferPaymentIndicator(false);
            detail.refreshNonUpdateableReferences();
            appliedPayments.add(detail);
        }
    }
    return appliedPayments;
}

Example 2 with GeneralLedgerEntry

use of org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry in project cu-kfs by CU-CommunityApps.

the class CapitalAssetInformationAction method reload.

/**
 * reloads the capital asset information screen
 *
 * @param mapping
 * @param form
 * @param request
 * @param response
 * @return
 * @throws Exception
 */
public ActionForward reload(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    CapitalAssetInformationForm capitalAssetForm = (CapitalAssetInformationForm) form;
    GeneralLedgerEntry entry = capitalAssetForm.getGeneralLedgerEntry();
    // GeneralLedgerEntry entry = findGeneralLedgerEntry(request);
    // if (entry != null) {
    prepareRecordsForDisplay(capitalAssetForm, entry);
    return mapping.findForward(RiceConstants.MAPPING_BASIC);
}

Example 3 with GeneralLedgerEntry

use of org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry in project cu-kfs by CU-CommunityApps.

the class CapitalAssetInformationAction method showAllTabs.

/**
 * @see org.kuali.rice.kns.web.struts.action.KualiAction#showAllTabs(ActionMapping,
 * ActionForm, HttpServletRequest, HttpServletResponse)
 */
@Override
public ActionForward showAllTabs(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    CapitalAssetInformationForm capitalAssetForm = (CapitalAssetInformationForm) form;
    GeneralLedgerEntry generalLedgerEntry = capitalAssetForm.getGeneralLedgerEntry();
    generalLedgerEntry.setSelected(true);
    return super.showAllTabs(mapping, form, request, response);
}

Example 4 with GeneralLedgerEntry

use of org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry in project cu-kfs by CU-CommunityApps.

the class CuBatchExtractServiceImpl method savePOLines.

/**
 * @see org.kuali.kfs.module.cam.batch.service.BatchExtractService#savePOLines(List, ExtractProcessLog)
 */
@Transactional
@Override
public HashSet<PurchasingAccountsPayableDocument> savePOLines(List<Entry> poLines, ExtractProcessLog processLog) {
    HashSet<PurchasingAccountsPayableDocument> purApDocuments = new HashSet<PurchasingAccountsPayableDocument>();
    // This is a list of pending GL entries created after last GL process and Cab Batch extract
    // PurAp Account Line history comes from PURAP module
    Collection<PurApAccountingLineBase> purapAcctLines = findPurapAccountRevisions();
    // Pass the records to reconciliation service method
    reconciliationService.reconcile(poLines, purapAcctLines);
    // for each valid GL entry there is a collection of valid PO Doc and Account Lines
    Collection<GlAccountLineGroup> matchedGroups = reconciliationService.getMatchedGroups();
    // Keep track of unique item lines
    HashMap<String, PurchasingAccountsPayableItemAsset> assetItems = new HashMap<String, PurchasingAccountsPayableItemAsset>();
    // Keep track of unique account lines
    HashMap<String, PurchasingAccountsPayableLineAssetAccount> assetAcctLines = new HashMap<String, PurchasingAccountsPayableLineAssetAccount>();
    // Keep track of asset lock
    HashMap<String, Object> assetLockMap = new HashMap<String, Object>();
    // Keep track of purchaseOrderDocument
    HashMap<Integer, PurchaseOrderDocument> poDocMap = new HashMap<Integer, PurchaseOrderDocument>();
    // KFSMI-7214, add document map for processing multiple items from the same AP doc
    HashMap<String, PurchasingAccountsPayableDocument> papdMap = new HashMap<String, PurchasingAccountsPayableDocument>();
    for (GlAccountLineGroup group : matchedGroups) {
        Entry entry = group.getTargetEntry();
        GeneralLedgerEntry generalLedgerEntry = new GeneralLedgerEntry(entry);
        GeneralLedgerEntry debitEntry = null;
        GeneralLedgerEntry creditEntry = null;
        KualiDecimal transactionLedgerEntryAmount = generalLedgerEntry.getTransactionLedgerEntryAmount();
        List<PurApAccountingLineBase> matchedPurApAcctLines = group.getMatchedPurApAcctLines();
        boolean hasPositiveAndNegative = hasPositiveAndNegative(matchedPurApAcctLines);
        boolean nonZero = ObjectUtils.isNotNull(transactionLedgerEntryAmount) && transactionLedgerEntryAmount.isNonZero();
        // generally for non-zero transaction ledger amount we should create a single GL entry with that amount,
        if (nonZero && !hasPositiveAndNegative) {
            businessObjectService.save(generalLedgerEntry);
        } else // but if there is FO revision or negative amount lines such as discount, create and save the set of debit(positive) and credit(negative) entries initialized with zero transaction amounts
        {
            debitEntry = createPositiveGlEntry(entry);
            businessObjectService.save(debitEntry);
            creditEntry = createNegativeGlEntry(entry);
            businessObjectService.save(creditEntry);
        }
        // KFSMI-7214, create an active document reference map
        boolean newApDoc = false;
        // KFSMI-7214, find from active document reference map first
        PurchasingAccountsPayableDocument cabPurapDoc = papdMap.get(entry.getDocumentNumber());
        if (ObjectUtils.isNull(cabPurapDoc)) {
            // find from DB
            cabPurapDoc = findPurchasingAccountsPayableDocument(entry);
        }
        // if document is found already, update the active flag
        if (ObjectUtils.isNull(cabPurapDoc)) {
            cabPurapDoc = createPurchasingAccountsPayableDocument(entry);
            newApDoc = true;
        }
        if (cabPurapDoc != null) {
            // KFSMI-7214, add to the cached document map
            papdMap.put(entry.getDocumentNumber(), cabPurapDoc);
            // we only deal with PREQ or CM, so isPREQ = !isCM, isCM = !PREQ
            boolean isPREQ = CamsConstants.PREQ.equals(entry.getFinancialDocumentTypeCode());
            boolean hasRevisionWithMixedLines = isPREQ && hasRevisionWithMixedLines(matchedPurApAcctLines);
            for (PurApAccountingLineBase purApAccountingLine : matchedPurApAcctLines) {
                // KFSMI-7214,tracking down changes on CAB item.
                boolean newAssetItem = false;
                PurApItem purapItem = purApAccountingLine.getPurapItem();
                String itemAssetKey = cabPurapDoc.getDocumentNumber() + "-" + purapItem.getItemIdentifier();
                // KFSMI-7214, search CAB item from active object reference map first
                PurchasingAccountsPayableItemAsset itemAsset = assetItems.get(itemAssetKey);
                if (ObjectUtils.isNull(itemAsset)) {
                    itemAsset = findMatchingPurapAssetItem(cabPurapDoc, purapItem);
                }
                // if new item, create and add to the list
                if (ObjectUtils.isNull(itemAsset)) {
                    itemAsset = createPurchasingAccountsPayableItemAsset(cabPurapDoc, purapItem);
                    cabPurapDoc.getPurchasingAccountsPayableItemAssets().add(itemAsset);
                    newAssetItem = true;
                }
                assetItems.put(itemAssetKey, itemAsset);
                Long generalLedgerAccountIdentifier = generalLedgerEntry.getGeneralLedgerAccountIdentifier();
                KualiDecimal purapAmount = purApAccountingLine.getAmount();
                // note that PurAp Doc accounting lines won't have zero amount, so !isPositive = isNegative
                boolean isPositive = purapAmount.isPositive();
                // trade-in and discount items on PREQ usually have negative amount (unless it's a revision)
                boolean usuallyNegative = isItemTypeUsuallyOfNegativeAmount(purapItem.getItemTypeCode());
                // decide if current accounting line should be consolidated into debit or credit entry based on the above criteria
                boolean isDebitEntry = hasRevisionWithMixedLines ? // case 2.2
                (usuallyNegative ? !isPositive : isPositive) : // case 1.1/1.2/2.1
                (isPREQ ? isPositive : !isPositive);
                GeneralLedgerEntry currentEntry = isDebitEntry ? debitEntry : creditEntry;
                if (ObjectUtils.isNull(generalLedgerAccountIdentifier)) {
                    generalLedgerAccountIdentifier = currentEntry.getGeneralLedgerAccountIdentifier();
                }
                String acctLineKey = cabPurapDoc.getDocumentNumber() + "-" + itemAsset.getAccountsPayableLineItemIdentifier() + "-" + itemAsset.getCapitalAssetBuilderLineNumber() + "-" + generalLedgerAccountIdentifier;
                PurchasingAccountsPayableLineAssetAccount assetAccount = assetAcctLines.get(acctLineKey);
                if (ObjectUtils.isNull(assetAccount) && nonZero && !hasPositiveAndNegative) {
                    // if new unique account line within GL, then create a new account line
                    assetAccount = createPurchasingAccountsPayableLineAssetAccount(generalLedgerEntry, cabPurapDoc, purApAccountingLine, itemAsset);
                    assetAcctLines.put(acctLineKey, assetAccount);
                    itemAsset.getPurchasingAccountsPayableLineAssetAccounts().add(assetAccount);
                } else if (!nonZero || hasPositiveAndNegative) {
                    // if amount is zero, means canceled doc, then create a copy and retain the account line
                    /*
                         * KFSMI-9760 / KFSCNTRB-???(FSKD-5097)
                         * 1.   Usually, we consolidate matched accounting lines (for the same account) based on positive/negative amount, i.e.
                         * 1.1  For PREQ, positive -> debit, negative -> credit;
                         *      That means charges (positive amount) are debit, trade-ins/discounts (negative amount) are credit.
                         * 1.2. For CM, the opposite, positive -> credit, negative -> debit
                         *      That means payments (positive amount) are credit, Less Restocking Fees (negative amount) are debit.
                         * 2.   However when there is a FO revision on PREQ (CMs don't have revisions), it's more complicated:
                         * 2.1  If the matched accounting lines are either all for non trade-in/discount items, or all for trade-in/discount items,
                         *      then we still could base the debit/credit on positive/negative amount;
                         *      That means reverse of charges (negative amount) are credit, reverse of trade-ins/discounts (positive amount) are debit.
                         * 2.2  Otherwise, i.e. the matched accounting lines cover both non trade-in/discount items and trade-in/discount items,
                         *      In this case we prefer to consolidate based on revision,
                         *      that means the original charges and trade-in/discounts are combined together,
                         *      while the reversed charges and trade-in/discounts are combined together;
                         *      So: original charge + original trade-in/discount -> debit, reversed charge + reversed trade-in/discount -> credit
                         * 3.   On top of these, we ensure that the final capital asset GL entries created is a debit if the consolidated amount is positive, and vice versa.
                         *      Note: In general, the consolidated amount for debit entry should already be positive, and vice versa. But there could be special cases,
                         *      for ex, in the case of 2.2, if the revision is only on discount, then the credit entry for the reverse would come out as positive, so we need
                         *      to swap it into a debit entry. This means, we will have 2 debit entries, one for the original lines, the other for the reversed discount line.
                         */
                    // during calculation, regard D/C code as a +/- sign in front of the amount
                    KualiDecimal oldAmount = currentEntry.getTransactionLedgerEntryAmount();
                    oldAmount = isDebitEntry ? oldAmount : oldAmount.negated();
                    KualiDecimal newAmount = oldAmount.add(purapAmount);
                    newAmount = isDebitEntry ? newAmount : newAmount.negated();
                    currentEntry.setTransactionLedgerEntryAmount(newAmount);
                    if (ObjectUtils.isNotNull(assetAccount)) {
                        // if account line key matches within same GL Entry, combine the amount
                        assetAccount.setItemAccountTotalAmount(assetAccount.getItemAccountTotalAmount().add(purApAccountingLine.getAmount()));
                    } else {
                        assetAccount = createPurchasingAccountsPayableLineAssetAccount(currentEntry, cabPurapDoc, purApAccountingLine, itemAsset);
                        assetAcctLines.put(acctLineKey, assetAccount);
                        itemAsset.getPurchasingAccountsPayableLineAssetAccounts().add(assetAccount);
                    }
                } else if (ObjectUtils.isNotNull(assetAccount)) {
                    // if account line key matches within same GL Entry, combine the amount
                    assetAccount.setItemAccountTotalAmount(assetAccount.getItemAccountTotalAmount().add(purApAccountingLine.getAmount()));
                }
                // KFSMI-7214: fixed OJB auto-update object issue.
                if (!newAssetItem) {
                    businessObjectService.save(itemAsset);
                }
                businessObjectService.save(cabPurapDoc);
                // Add to the asset lock table if purap has asset number information
                addAssetLocks(assetLockMap, cabPurapDoc, purapItem, itemAsset.getAccountsPayableLineItemIdentifier(), poDocMap);
            }
            // since the real amount being positive/negative shall be solely indicated by the D/C code.
            if (debitEntry != null) {
                KualiDecimal amount = debitEntry.getTransactionLedgerEntryAmount();
                if (amount.isNegative()) {
                    debitEntry.setTransactionDebitCreditCode(KFSConstants.GL_CREDIT_CODE);
                    debitEntry.setTransactionLedgerEntryAmount(amount.negated());
                }
                businessObjectService.save(debitEntry);
            }
            if (creditEntry != null) {
                KualiDecimal amount = creditEntry.getTransactionLedgerEntryAmount();
                if (amount.isNegative()) {
                    creditEntry.setTransactionDebitCreditCode(KFSConstants.GL_DEBIT_CODE);
                    creditEntry.setTransactionLedgerEntryAmount(amount.negated());
                }
                businessObjectService.save(creditEntry);
            }
            // batch.
            if (newApDoc) {
                purApDocuments.add(cabPurapDoc);
            }
        } else {
            LOG.error("Could not create a valid PurchasingAccountsPayableDocument object for document number " + entry.getDocumentNumber());
        }
    }
    updateProcessLog(processLog, reconciliationService);
    return purApDocuments;
}

Example 5 with GeneralLedgerEntry

use of org.kuali.kfs.module.cam.businessobject.GeneralLedgerEntry in project cu-kfs by CU-CommunityApps.

the class GlLineServiceImpl method setupMissingCapitalAssetInformation.

/**
 * Setup shell Capital Asset Information where it doesn't already exist (for
 * example for a PRNC that is in Process and has already generated some
 * capital asset information in a previous processing)
 *
 * @param entry
 */
@Override
public void setupMissingCapitalAssetInformation(String documentNumber) {
    List<CapitalAccountingLines> capitalAccountingLines;
    // get all related entries and create capital asset record for each
    Collection<GeneralLedgerEntry> glEntries = findAllGeneralLedgerEntry(documentNumber);
    Collection<CapitalAssetInformation> allCapitalAssetInformation = findAllCapitalAssetInformation(documentNumber);
    int nextCapitalAssetLineNumber = findMaximumCapitalAssetLineNumber(allCapitalAssetInformation) + 1;
    for (GeneralLedgerEntry glEntry : glEntries) {
        // check if it has capital Asset Info
        List<CapitalAssetInformation> entryCapitalAssetInfo = findCapitalAssetInformationForGLLineMatchLineType(glEntry);
        if (entryCapitalAssetInfo.isEmpty()) {
            capitalAccountingLines = new ArrayList<CapitalAccountingLines>();
            createCapitalAccountingLine(capitalAccountingLines, glEntry, null);
            createNewCapitalAsset(capitalAccountingLines, documentNumber, null, nextCapitalAssetLineNumber);
            nextCapitalAssetLineNumber++;
        }
    }
}