Java tutorial
/* * The Kuali Financial System, a comprehensive financial management system for higher education. * * Copyright 2005-2014 The Kuali Foundation * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, either version 3 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.kuali.kfs.sys.document.service.impl; import static org.kuali.kfs.sys.KFSConstants.GL_CREDIT_CODE; import static org.kuali.kfs.sys.KFSConstants.GL_DEBIT_CODE; import java.util.ArrayList; import java.util.List; import java.util.Properties; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.WordUtils; import org.kuali.kfs.coa.businessobject.ObjectCode; import org.kuali.kfs.pdp.PdpParameterConstants; import org.kuali.kfs.pdp.businessobject.PaymentNoteText; import org.kuali.kfs.pdp.businessobject.PurchasingPaymentDetail; import org.kuali.kfs.sys.KFSConstants; import org.kuali.kfs.sys.KFSKeyConstants; import org.kuali.kfs.sys.KFSPropertyConstants; import org.kuali.kfs.sys.batch.service.PaymentSourceToExtractService; import org.kuali.kfs.sys.businessobject.GeneralLedgerPendingEntry; import org.kuali.kfs.sys.businessobject.GeneralLedgerPendingEntrySequenceHelper; import org.kuali.kfs.sys.businessobject.WireCharge; import org.kuali.kfs.sys.document.PaymentSource; import org.kuali.kfs.sys.document.service.AccountingDocumentRuleHelperService; import org.kuali.kfs.sys.document.service.PaymentSourceHelperService; import org.kuali.kfs.sys.document.validation.impl.AccountingDocumentRuleBaseConstants.GENERAL_LEDGER_PENDING_ENTRY_CODE; import org.kuali.kfs.sys.service.BankService; import org.kuali.kfs.sys.service.GeneralLedgerPendingEntryService; import org.kuali.kfs.sys.service.HomeOriginationService; import org.kuali.kfs.sys.service.OptionsService; import org.kuali.kfs.sys.service.UniversityDateService; import org.kuali.kfs.sys.service.impl.KfsParameterConstants; import org.kuali.rice.core.api.config.property.ConfigurationService; import org.kuali.rice.core.api.util.type.KualiDecimal; import org.kuali.rice.core.api.util.type.KualiInteger; import org.kuali.rice.coreservice.framework.parameter.ParameterService; import org.kuali.rice.krad.service.BusinessObjectService; import org.kuali.rice.krad.service.DocumentService; import org.kuali.rice.krad.util.KRADConstants; import org.kuali.rice.krad.util.ObjectUtils; import org.kuali.rice.krad.util.UrlFactory; public class PaymentSourceHelperServiceImpl implements PaymentSourceHelperService { org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(PaymentSourceHelperServiceImpl.class); protected UniversityDateService universityDateService; protected BusinessObjectService businessObjectService; protected GeneralLedgerPendingEntryService generalLedgerPendingEntryService; protected BankService bankService; protected AccountingDocumentRuleHelperService accountingDocumentRuleHelperService; protected ParameterService parameterService; protected ConfigurationService configurationService; protected DocumentService documentService; protected OptionsService optionsService; protected HomeOriginationService homeOriginationService; /** * Retrieves the wire transfer information for the current fiscal year. * * @return <code>WireCharge</code> */ @Override public WireCharge retrieveCurrentYearWireCharge() { WireCharge wireCharge = new WireCharge(); wireCharge.setUniversityFiscalYear(getUniversityDateService().getCurrentFiscalYear()); wireCharge = (WireCharge) getBusinessObjectService().retrieve(wireCharge); if (wireCharge == null) { LOG.error("Wire charge information not found for current fiscal year."); throw new RuntimeException("Wire charge information not found for current fiscal year."); } return wireCharge; } /** * Retrieves the wire charge for fiscal year based on the given date or null if one cannot be found * @param date the date to find a wire charge for * @return the wire charge for the fiscal year of the given date, or null if the wire charge cannot be found */ @Override public WireCharge retrieveWireChargeForDate(java.sql.Date date) { final Integer dateFiscalYear = getUniversityDateService().getFiscalYear(date); if (dateFiscalYear == null) { return null; } WireCharge wireCharge = new WireCharge(); wireCharge.setUniversityFiscalYear(dateFiscalYear); wireCharge = (WireCharge) getBusinessObjectService().retrieve(wireCharge); return wireCharge; } /** * Builds an explicit and offset for the wire charge debit. The account associated with the first accounting is used for the * debit. The explicit and offset entries for the first accounting line and copied and customized for the wire charge. * * @param dvDocument submitted disbursement voucher document * @param sequenceHelper helper class to keep track of GLPE sequence * @param wireCharge wireCharge object from current fiscal year * @return GeneralLedgerPendingEntry generated wire charge debit */ @Override public GeneralLedgerPendingEntry processWireChargeDebitEntries(PaymentSource paymentSource, GeneralLedgerPendingEntrySequenceHelper sequenceHelper, WireCharge wireCharge) { LOG.debug("processWireChargeDebitEntries started"); // grab the explicit entry for the first accounting line and adjust for wire charge entry GeneralLedgerPendingEntry explicitEntry = new GeneralLedgerPendingEntry( paymentSource.getGeneralLedgerPendingEntry(0)); explicitEntry.setTransactionLedgerEntrySequenceNumber(new Integer(sequenceHelper.getSequenceCounter())); explicitEntry.setFinancialObjectCode(wireCharge.getExpenseFinancialObjectCode()); explicitEntry.setFinancialSubObjectCode(GENERAL_LEDGER_PENDING_ENTRY_CODE.getBlankFinancialSubObjectCode()); explicitEntry.setTransactionDebitCreditCode(GL_DEBIT_CODE); String objectTypeCode = getOptionsService().getCurrentYearOptions().getFinObjTypeExpenditureexpCd(); explicitEntry.setFinancialObjectTypeCode(objectTypeCode); String originationCode = getHomeOriginationService().getHomeOrigination().getFinSystemHomeOriginationCode(); explicitEntry.setFinancialSystemOriginationCode(originationCode); if (KFSConstants.COUNTRY_CODE_UNITED_STATES.equals(paymentSource.getWireTransfer().getBankCountryCode())) { explicitEntry.setTransactionLedgerEntryAmount(wireCharge.getDomesticChargeAmt()); } else { explicitEntry.setTransactionLedgerEntryAmount(wireCharge.getForeignChargeAmt()); } explicitEntry.setTransactionLedgerEntryDescription("Automatic debit for wire transfer fee"); explicitEntry.setFinancialBalanceTypeCode(wireCharge.getFiscalYear().getActualFinancialBalanceTypeCd()); paymentSource.addPendingEntry(explicitEntry); sequenceHelper.increment(); // handle the offset entry GeneralLedgerPendingEntry offsetEntry = new GeneralLedgerPendingEntry(explicitEntry); getGeneralLedgerPendingEntryService().populateOffsetGeneralLedgerPendingEntry( paymentSource.getPostingYear(), explicitEntry, sequenceHelper, offsetEntry); paymentSource.addPendingEntry(offsetEntry); sequenceHelper.increment(); return explicitEntry; } /** * Builds an explicit and offset for the wire charge credit. The account and income object code found in the wire charge table * is used for the entry. * * @param dvDocument submitted disbursement voucher document * @param sequenceHelper helper class to keep track of GLPE sequence * @param chargeEntry GLPE charge * @param wireCharge wireCharge object from current fiscal year */ @Override public void processWireChargeCreditEntries(PaymentSource paymentSource, GeneralLedgerPendingEntrySequenceHelper sequenceHelper, WireCharge wireCharge, GeneralLedgerPendingEntry chargeEntry) { LOG.debug("processWireChargeCreditEntries started"); // copy the charge entry and adjust for credit GeneralLedgerPendingEntry explicitEntry = new GeneralLedgerPendingEntry(chargeEntry); explicitEntry.setTransactionLedgerEntrySequenceNumber(new Integer(sequenceHelper.getSequenceCounter())); explicitEntry.setChartOfAccountsCode(wireCharge.getChartOfAccountsCode()); explicitEntry.setAccountNumber(wireCharge.getAccountNumber()); explicitEntry.setFinancialObjectCode(wireCharge.getIncomeFinancialObjectCode()); // retrieve object type ObjectCode objectCode = wireCharge.getIncomeFinancialObject(); explicitEntry.setFinancialObjectTypeCode(objectCode.getFinancialObjectTypeCode()); explicitEntry.setTransactionDebitCreditCode(GL_CREDIT_CODE); explicitEntry.setFinancialSubObjectCode(GENERAL_LEDGER_PENDING_ENTRY_CODE.getBlankFinancialSubObjectCode()); explicitEntry.setSubAccountNumber(GENERAL_LEDGER_PENDING_ENTRY_CODE.getBlankSubAccountNumber()); explicitEntry.setProjectCode(GENERAL_LEDGER_PENDING_ENTRY_CODE.getBlankProjectCode()); explicitEntry.setTransactionLedgerEntryDescription("Automatic credit for wire transfer fee"); explicitEntry.setFinancialBalanceTypeCode(wireCharge.getFiscalYear().getActualFinancialBalanceTypeCd()); paymentSource.addPendingEntry(explicitEntry); sequenceHelper.increment(); // handle the offset entry GeneralLedgerPendingEntry offsetEntry = new GeneralLedgerPendingEntry(explicitEntry); getGeneralLedgerPendingEntryService().populateOffsetGeneralLedgerPendingEntry( paymentSource.getPostingYear(), explicitEntry, sequenceHelper, offsetEntry); paymentSource.addPendingEntry(offsetEntry); sequenceHelper.increment(); } /** * If bank specification is enabled generates bank offsetting entries for the document amount * * @param sequenceHelper helper class to keep track of GLPE sequence * @param paymentMethodCode the payment method of this DV */ @Override public boolean generateDocumentBankOffsetEntries(PaymentSource paymentSource, GeneralLedgerPendingEntrySequenceHelper sequenceHelper, String wireTransferOrForeignDraftEntryDocumentType) { boolean success = true; if (!getBankService().isBankSpecificationEnabled()) { return success; } paymentSource.refreshReferenceObject(KFSPropertyConstants.BANK); final KualiDecimal bankOffsetAmount = getGeneralLedgerPendingEntryService() .getOffsetToCashAmount(paymentSource).negated(); GeneralLedgerPendingEntry bankOffsetEntry = new GeneralLedgerPendingEntry(); success &= getGeneralLedgerPendingEntryService().populateBankOffsetGeneralLedgerPendingEntry( paymentSource.getBank(), bankOffsetAmount, paymentSource, paymentSource.getPostingYear(), sequenceHelper, bankOffsetEntry, KRADConstants.DOCUMENT_PROPERTY_NAME + "." + KFSPropertyConstants.DISB_VCHR_BANK_CODE); if (success) { bankOffsetEntry.setTransactionLedgerEntryDescription(getAccountingDocumentRuleHelperService() .formatProperty(KFSKeyConstants.Bank.DESCRIPTION_GLPE_BANK_OFFSET)); bankOffsetEntry.setFinancialDocumentTypeCode(wireTransferOrForeignDraftEntryDocumentType); paymentSource.addPendingEntry(bankOffsetEntry); sequenceHelper.increment(); GeneralLedgerPendingEntry offsetEntry = new GeneralLedgerPendingEntry(bankOffsetEntry); success &= getGeneralLedgerPendingEntryService().populateOffsetGeneralLedgerPendingEntry( paymentSource.getPostingYear(), bankOffsetEntry, sequenceHelper, offsetEntry); bankOffsetEntry.setFinancialDocumentTypeCode(wireTransferOrForeignDraftEntryDocumentType); paymentSource.addPendingEntry(offsetEntry); sequenceHelper.increment(); } return success; } /** * @see org.kuali.kfs.sys.document.service.PaymentSourceHelperService#generateDocumentBankOffsetEntries(org.kuali.kfs.sys.document.PaymentSource, org.kuali.kfs.sys.businessobject.GeneralLedgerPendingEntrySequenceHelper, java.lang.String, org.kuali.rice.core.api.util.type.KualiDecimal) */ @Override public boolean generateDocumentBankOffsetEntries(PaymentSource paymentSource, GeneralLedgerPendingEntrySequenceHelper sequenceHelper, String wireTransferOrForeignDraftEntryDocumentType, KualiDecimal bankOffsetAmount) { boolean success = true; if (!getBankService().isBankSpecificationEnabled()) { return success; } paymentSource.refreshReferenceObject(KFSPropertyConstants.BANK); GeneralLedgerPendingEntry bankOffsetEntry = new GeneralLedgerPendingEntry(); success &= getGeneralLedgerPendingEntryService().populateBankOffsetGeneralLedgerPendingEntry( paymentSource.getBank(), bankOffsetAmount, paymentSource, paymentSource.getPostingYear(), sequenceHelper, bankOffsetEntry, KRADConstants.DOCUMENT_PROPERTY_NAME + "." + KFSPropertyConstants.DISB_VCHR_BANK_CODE); if (success) { bankOffsetEntry.setTransactionLedgerEntryDescription(getAccountingDocumentRuleHelperService() .formatProperty(KFSKeyConstants.Bank.DESCRIPTION_GLPE_BANK_OFFSET)); bankOffsetEntry.setFinancialDocumentTypeCode(wireTransferOrForeignDraftEntryDocumentType); paymentSource.addPendingEntry(bankOffsetEntry); sequenceHelper.increment(); GeneralLedgerPendingEntry offsetEntry = new GeneralLedgerPendingEntry(bankOffsetEntry); success &= getGeneralLedgerPendingEntryService().populateOffsetGeneralLedgerPendingEntry( paymentSource.getPostingYear(), bankOffsetEntry, sequenceHelper, offsetEntry); bankOffsetEntry.setFinancialDocumentTypeCode(wireTransferOrForeignDraftEntryDocumentType); paymentSource.addPendingEntry(offsetEntry); sequenceHelper.increment(); } return success; } /** * Builds a link to a PurchasingPaymentDetail object * @see org.kuali.kfs.sys.document.service.PaymentSourceHelperService#getDisbursementInfoUrl() */ @Override public String getDisbursementInfoUrl() { final String basePath = getConfigurationService() .getPropertyValueAsString(KFSConstants.APPLICATION_URL_KEY); Properties parameters = new Properties(); parameters.put(KFSConstants.DISPATCH_REQUEST_PARAMETER, KFSConstants.SEARCH_METHOD); parameters.put(KFSConstants.BACK_LOCATION, basePath + "/" + KFSConstants.MAPPING_PORTAL + ".do"); parameters.put(KFSConstants.BUSINESS_OBJECT_CLASS_ATTRIBUTE, PurchasingPaymentDetail.class.getName()); parameters.put(KFSConstants.HIDE_LOOKUP_RETURN_LINK, "true"); parameters.put(KFSConstants.SUPPRESS_ACTIONS, "false"); String lookupUrl = UrlFactory.parameterizeUrl(basePath + "/" + KFSConstants.LOOKUP_ACTION, parameters); return lookupUrl; } /** * * @see org.kuali.kfs.sys.batch.service.PaymentSourceExtractionService#buildNoteForCheckStubText(java.lang.String) */ @Override public PaymentNoteText buildNoteForCheckStubText(String text, int previousLineCount) { PaymentNoteText pnt = null; final String maxNoteLinesParam = parameterService.getParameterValueAsString( KfsParameterConstants.PRE_DISBURSEMENT_ALL.class, PdpParameterConstants.MAX_NOTE_LINES); int maxNoteLines; try { maxNoteLines = Integer.parseInt(maxNoteLinesParam); } catch (NumberFormatException nfe) { throw new IllegalArgumentException("Invalid Max Notes Lines parameter, value: " + maxNoteLinesParam + " cannot be converted to an integer"); } // The WordUtils should be sufficient for the majority of cases. This method will // word wrap the whole string based on the MAX_NOTE_LINE_SIZE, separating each wrapped // word by a newline character. The 'wrap' method adds line feeds to the end causing // the character length to exceed the max length by 1, hence the need for the replace // method before splitting. String wrappedText = WordUtils.wrap(text, KFSConstants.MAX_NOTE_LINE_SIZE); String[] noteLines = wrappedText.replaceAll("[\r]", "").split("\\n"); // Loop through all the note lines. for (String noteLine : noteLines) { if (previousLineCount < (maxNoteLines - 3) && !StringUtils.isEmpty(noteLine)) { // This should only happen if we encounter a word that is greater than the max length. // The only concern I have for this occurring is with URLs/email addresses. if (noteLine.length() > KFSConstants.MAX_NOTE_LINE_SIZE) { for (String choppedWord : chopWord(noteLine, KFSConstants.MAX_NOTE_LINE_SIZE)) { // Make sure we're still under the maximum number of note lines. if (previousLineCount < (maxNoteLines - 3) && !StringUtils.isEmpty(choppedWord)) { pnt = new PaymentNoteText(); pnt.setCustomerNoteLineNbr(new KualiInteger(previousLineCount++)); pnt.setCustomerNoteText(choppedWord.replaceAll("\\n", "").trim()); } // We can't add any additional note lines, or we'll exceed the maximum, therefore // just break out of the loop early - there's nothing left to do. else { break; } } } // This should be the most common case. Simply create a new PaymentNoteText, // add the line at the correct line location. else { pnt = new PaymentNoteText(); pnt.setCustomerNoteLineNbr(new KualiInteger(previousLineCount++)); pnt.setCustomerNoteText(noteLine.replaceAll("\\n", "").trim()); } } } return pnt; } /** * This method will take a word and simply chop into smaller * text segments that satisfy the limit requirements. All words * brute force chopped, with no regard to preserving whole words. * * For example: * * "Java is a fun programming language!" * * Might be chopped into: * * "Java is a fun prog" * "ramming language!" * * @param word The word that needs chopping * @param limit Number of character that should represent a chopped word * @return String [] of chopped words */ protected String[] chopWord(String word, int limit) { StringBuilder builder = new StringBuilder(); if (word != null && word.trim().length() > 0) { char[] chars = word.toCharArray(); int index = 0; // First process all the words that fit into the limit. for (int i = 0; i < chars.length / limit; i++) { builder.append(String.copyValueOf(chars, index, limit)); builder.append("\n"); index += limit; } // Not all words will fit perfectly into the limit amount, so // calculate the modulus value to determine any remaining characters. int modValue = chars.length % limit; if (modValue > 0) { builder.append(String.copyValueOf(chars, index, modValue)); } } // Split the chopped words into individual segments. return builder.toString().split("\\n"); } /** * @see org.kuali.kfs.sys.document.service.PaymentSourceHelperService#oppositifyAndSaveEntry(org.kuali.kfs.sys.businessobject.GeneralLedgerPendingEntry, org.kuali.kfs.sys.businessobject.GeneralLedgerPendingEntrySequenceHelper) */ @Override public void oppositifyAndSaveEntry(GeneralLedgerPendingEntry glpe, GeneralLedgerPendingEntrySequenceHelper glpeSeqHelper) { if (glpe.getTransactionDebitCreditCode().equals(KFSConstants.GL_CREDIT_CODE)) { glpe.setTransactionDebitCreditCode(KFSConstants.GL_DEBIT_CODE); } else if (glpe.getTransactionDebitCreditCode().equals(KFSConstants.GL_DEBIT_CODE)) { glpe.setTransactionDebitCreditCode(KFSConstants.GL_CREDIT_CODE); } if (glpeSeqHelper != null) { glpe.setTransactionLedgerEntrySequenceNumber(glpeSeqHelper.getSequenceCounter()); glpeSeqHelper.increment(); } glpe.setFinancialDocumentApprovedCode(KFSConstants.PENDING_ENTRY_APPROVED_STATUS_CODE.APPROVED); businessObjectService.save(glpe); } /** * * @see org.kuali.kfs.sys.document.service.PaymentSourceHelperService#handleEntryCancellation(org.kuali.kfs.sys.document.PaymentSource) */ @Override public void handleEntryCancellation(PaymentSource paymentSource, PaymentSourceToExtractService<?> extractionService) { if (ObjectUtils.isNull(paymentSource.getGeneralLedgerPendingEntries()) || paymentSource.getGeneralLedgerPendingEntries().size() == 0) { // generate all the pending entries for the document getGeneralLedgerPendingEntryService().generateGeneralLedgerPendingEntries(paymentSource); // for each pending entry, opposite-ify it and reattach it to the document for (GeneralLedgerPendingEntry glpe : paymentSource.getGeneralLedgerPendingEntries()) { if (extractionService.shouldRollBackPendingEntry(glpe)) { oppositifyAndSaveEntry(glpe, null); } } } else { List<GeneralLedgerPendingEntry> newGLPEs = new ArrayList<GeneralLedgerPendingEntry>(); GeneralLedgerPendingEntrySequenceHelper glpeSeqHelper = new GeneralLedgerPendingEntrySequenceHelper( paymentSource.getGeneralLedgerPendingEntries().size() + 1); for (GeneralLedgerPendingEntry glpe : paymentSource.getGeneralLedgerPendingEntries()) { glpe.refresh(); if (extractionService.shouldRollBackPendingEntry(glpe)) { if (glpe.getFinancialDocumentApprovedCode() .equals(KFSConstants.PENDING_ENTRY_APPROVED_STATUS_CODE.PROCESSED)) { // damn! it got processed! well, make a copy, oppositify, and save GeneralLedgerPendingEntry undoer = new GeneralLedgerPendingEntry(glpe); oppositifyAndSaveEntry(undoer, glpeSeqHelper); newGLPEs.add(undoer); } else { // just delete the GLPE before anything happens to it businessObjectService.delete(glpe); } } else { newGLPEs.add(glpe); } } paymentSource.setGeneralLedgerPendingEntries(newGLPEs); } } /** * @return the implementation of the UniversityDateService to use */ public UniversityDateService getUniversityDateService() { return universityDateService; } /** * Sets the implementation of the UniversityDateService to use * @param universityDateService the implementation of the UniversityDateService to use */ public void setUniversityDateService(UniversityDateService universityDateService) { this.universityDateService = universityDateService; } /** * @return the implementation of the BusinessObjectService to use */ public BusinessObjectService getBusinessObjectService() { return businessObjectService; } /** * Sets the implementation of the BusinessObjectService to use * @param businessObjectService the implementation of the BusinessObjectService to use */ public void setBusinessObjectService(BusinessObjectService businessObjectService) { this.businessObjectService = businessObjectService; } /** * @return the implementation of the GeneralLedgerPendingEntryService to use */ public GeneralLedgerPendingEntryService getGeneralLedgerPendingEntryService() { return generalLedgerPendingEntryService; } /** * Sets the implementation of the GeneralLedgerPendingEntryService to use * @param generalLedgerPendingEntryService the implementation of the GeneralLedgerPendingEntryService to use */ public void setGeneralLedgerPendingEntryService( GeneralLedgerPendingEntryService generalLedgerPendingEntryService) { this.generalLedgerPendingEntryService = generalLedgerPendingEntryService; } /** * @return the implementation of the BankService to use */ public BankService getBankService() { return bankService; } /** * Sets the implementation of the BankService to use * @param bankService the implementation of the BankService to use */ public void setBankService(BankService bankService) { this.bankService = bankService; } /** * @return the implementation of the AccountingDocumentRuleHelperService to use */ public AccountingDocumentRuleHelperService getAccountingDocumentRuleHelperService() { return accountingDocumentRuleHelperService; } /** * Sets the implementation of the AccountingDocumentRuleHelperService to use * @param accountingDocumentRuleService the implementation of the AccountingDocumentRuleHelperService to use */ public void setAccountingDocumentRuleHelperService( AccountingDocumentRuleHelperService accountingDocumentRuleService) { this.accountingDocumentRuleHelperService = accountingDocumentRuleService; } /** * @return the implementation of the ParameterService to use */ public ParameterService getParameterService() { return parameterService; } /** * Sets the implementation of the ParameterService to use * @param parameterService the implementation of the ParameterService to use */ public void setParameterService(ParameterService parameterService) { this.parameterService = parameterService; } /** * @return the implementation of the ConfigurationService to use */ public ConfigurationService getConfigurationService() { return configurationService; } /** * Sets the implementation of the ConfigurationService to use * @param configurationService the implementation of the ConfigurationService to use */ public void setConfigurationService(ConfigurationService configurationService) { this.configurationService = configurationService; } /** * @return the injected implementation of the DocumentService to use */ public DocumentService getDocumentService() { return documentService; } /** * Injects the implementation of DocumentService to use * @param documentService an implementation of DocumentService */ public void setDocumentService(DocumentService documentService) { this.documentService = documentService; } /** * @return the injected implementation of OptionsService to use */ public OptionsService getOptionsService() { return optionsService; } /** * Injects the implementation of OptionsService to use * @param optionsService an implementation of OptionsService */ public void setOptionsService(OptionsService optionsService) { this.optionsService = optionsService; } /** * @return the injected implementation of HomeOriginationSerice to use */ public HomeOriginationService getHomeOriginationService() { return homeOriginationService; } /** * Injects the implementation of HomeOriginationService to use * @param homeOriginationService an implementation of HomeOriginationService */ public void setHomeOriginationService(HomeOriginationService homeOriginationService) { this.homeOriginationService = homeOriginationService; } }