/*
    * Copyright 2005 The Kuali Foundation
    * 
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    * http://www.opensource.org/licenses/ecl2.php
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.ole.fp.document.web.struts;
  
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.util.ArrayList;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  import org.kuali.ole.coa.businessobject.BalanceType;
  import org.kuali.ole.coa.service.BalanceTypeService;
  import org.kuali.ole.fp.businessobject.VoucherAccountingLineHelper;
  import org.kuali.ole.fp.businessobject.VoucherAccountingLineHelperBase;
  import org.kuali.ole.fp.businessobject.VoucherSourceAccountingLine;
  import org.kuali.ole.fp.document.JournalVoucherDocument;
  import org.kuali.ole.fp.document.VoucherDocument;
  import org.kuali.ole.sys.OLEConstants;
  import org.kuali.ole.sys.OLEKeyConstants;
  import org.kuali.ole.sys.OLEPropertyConstants;
  import org.kuali.ole.sys.businessobject.SourceAccountingLine;
  import org.kuali.ole.sys.context.SpringContext;
  import org.kuali.rice.core.api.config.property.ConfigurationService;
  import org.kuali.rice.core.api.util.type.KualiDecimal;
  import org.kuali.rice.core.web.format.CurrencyFormatter;
  import org.kuali.rice.kew.api.exception.WorkflowException;
  import org.kuali.rice.kns.question.ConfirmationQuestion;
  import org.kuali.rice.kns.util.KNSGlobalVariables;
  import org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase;
  
  /**
   * This class piggy backs on all of the functionality in the FinancialSystemTransactionalDocumentActionBase but is necessary for
   * this document type. The Journal Voucher is unique in that it defines several fields that aren't typically used by the other
   * financial transaction processing eDocs (i.e. external system fields, object type override, credit and debit amounts).
   */
  public class JournalVoucherAction extends VoucherAction {
  
      // used to determine which way the change balance type action is switching these are local constants only used within this
      // action class these should not be used outside of this class
      protected static final int CREDIT_DEBIT_TO_SINGLE_AMT_MODE = 0;
      protected static final int SINGLE_AMT_TO_CREDIT_DEBIT_MODE = 1;
      protected static final int EXT_ENCUMB_TO_NON_EXT_ENCUMB = 0;
      protected static final int NON_EXT_ENCUMB_TO_EXT_ENCUMB = 1;
      protected static final int NO_MODE_CHANGE = -1;
  
      /**
       * Overrides the parent and then calls the super method after building the array lists for valid accounting periods and balance
       * types.
       * 
       * @see org.kuali.rice.kns.web.struts.action.KualiAction#execute(ActionMapping mapping, ActionForm form, HttpServletRequest
       *      request, HttpServletResponse response)
       */
      @Override
      public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
          JournalVoucherForm journalVoucherForm = (JournalVoucherForm) form;
  
          populateBalanceTypeOneDocument(journalVoucherForm);
  
          // now check to see if the balance type was changed and if so, we want to
          // set the method to call so that the appropriate action can be invoked
          // had to do it this way b/c the changing of the drop down causes the page to re-submit
          // and couldn't use a hidden field called "methodToCall" b/c it screwed everything up
          ActionForward returnForward;
          if (StringUtils.isNotBlank(journalVoucherForm.getOriginalBalanceType()) && !journalVoucherForm.getSelectedBalanceType().getCode().equals(journalVoucherForm.getOriginalBalanceType())) {
              returnForward = super.dispatchMethod(mapping, form, request, response, OLEConstants.CHANGE_JOURNAL_VOUCHER_BALANCE_TYPE_METHOD);
              // must call this here, because execute in the super method will never have control for this particular action
              // this is called in the parent by super.execute()
              this.populateAuthorizationFields(journalVoucherForm);
          }
          else { // otherwise call the super
              returnForward = super.execute(mapping, journalVoucherForm, request, response);
          }
          return returnForward;
      }
  
      /**
       * Overrides the parent to first prompt the user appropriately to make sure that they want to submit and out of balance
       * document, then calls super's route method.
       * 
       * @see org.kuali.rice.kns.web.struts.action.KualiDocumentActionBase#route(org.apache.struts.action.ActionMapping,
       *      org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
      */
     @Override
     public ActionForward route(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
         // process the question but we need to make sure there are lines and then check to see if it's not balanced
         VoucherDocument vDoc = ((VoucherForm) form).getVoucherDocument();
 
         KualiDecimal balance = vDoc.getCreditTotal().subtract(vDoc.getDebitTotal());
         if (vDoc.getSourceAccountingLines().size() > 0 && balance.compareTo(KualiDecimal.ZERO) != 0) {
             // it's not in "balance"
             ActionForward returnForward = processRouteOutOfBalanceDocumentConfirmationQuestion(mapping, form, request, response);
 
             // if not null, then the question component either has control of the flow and needs to ask its questions
             // or the person chose the "cancel" or "no" button
             // otherwise we have control
             if (returnForward != null) {
                 return returnForward;
             }
         }
         // now call the route method
         return super.route(mapping, form, request, response);
     }
 
     /**
      * This method handles grabbing the values from the form and pushing them into the document appropriately.
      * 
      * @param journalVoucherForm
      */
     protected void populateBalanceTypeOneDocument(JournalVoucherForm journalVoucherForm) {
         String selectedBalanceTypeCode = journalVoucherForm.getSelectedBalanceType().getCode();
         BalanceType selectedBalanceType = getPopulatedBalanceTypeInstance(selectedBalanceTypeCode);
         journalVoucherForm.getJournalVoucherDocument().setBalanceTypeCode(selectedBalanceTypeCode);
         journalVoucherForm.getJournalVoucherDocument().setBalanceType(selectedBalanceType); // set the fully populated balance type
         // object into the form's selected
         // balance type
         journalVoucherForm.setSelectedBalanceType(selectedBalanceType);
     }
 
 
     /**
      * Overrides to call super, and then to repopulate the credit/debit amounts b/c the credit/debit code might change during a JV
      * error correction.
      * 
      * @see org.kuali.ole.fp.document.web.struts.VoucherAction#correct(org.apache.struts.action.ActionMapping,
      *      org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
      */
     @Override
     public ActionForward correct(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
         ActionForward actionForward = super.correct(mapping, form, request, response);
 
         JournalVoucherDocument jvDoc = (JournalVoucherDocument) ((JournalVoucherForm) form).getDocument();
 
         jvDoc.refreshReferenceObject(OLEPropertyConstants.BALANCE_TYPE);
         // only repopulate if this is a JV that was entered in debit/credit mode
         if (jvDoc.getBalanceType().isFinancialOffsetGenerationIndicator()) {
             // now make sure to repopulate credit/debit amounts
             populateAllVoucherAccountingLineHelpers((JournalVoucherForm) form);
         }
 
         return actionForward;
     }
 
     /**
      * This method processes a change in the balance type for a Journal Voucher document - from either a offset generation balance
      * type to a non-offset generation balance type or visa-versa.
      * 
      * @param mapping
      * @param form
      * @param request
      * @param response
      * @return ActionForward
      * @throws Exception
      */
     public ActionForward changeBalanceType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
         JournalVoucherForm journalVoucherForm = (JournalVoucherForm) form;
 
         // figure out which way the balance type is changing
         int balanceTypeAmountChangeMode = determineBalanceTypeAmountChangeMode(journalVoucherForm);
         int balanceTypeExternalEncumbranceChangeMode = determineBalanceTypeEncumbranceChangeMode(journalVoucherForm);
 
         // process the question
         if (balanceTypeAmountChangeMode != NO_MODE_CHANGE || balanceTypeExternalEncumbranceChangeMode != NO_MODE_CHANGE) {
             ActionForward returnForward = processChangeBalanceTypeConfirmationQuestion(mapping, form, request, response);
 
             // if not null, then the question component either has control of the flow and needs to ask its questions
             // or the person choose the "cancel" or "no" button otherwise we have control
             if (returnForward != null) {
                 return returnForward;
             }
             else {
                 // deal with balance type changes first amount change
                 if (balanceTypeAmountChangeMode == CREDIT_DEBIT_TO_SINGLE_AMT_MODE) {
                     switchFromCreditDebitModeToSingleAmountMode(journalVoucherForm);
                 }
                 else if (balanceTypeAmountChangeMode == SINGLE_AMT_TO_CREDIT_DEBIT_MODE) {
                     switchFromSingleAmountModeToCreditDebitMode(journalVoucherForm);
                 }
 
                 // then look to see if the external encumbrance was involved
                 if (balanceTypeExternalEncumbranceChangeMode == EXT_ENCUMB_TO_NON_EXT_ENCUMB) {
                     switchFromExternalEncumbranceModeToNonExternalEncumbrance(journalVoucherForm);
                 }
             }
         }
 
         return mapping.findForward(OLEConstants.MAPPING_BASIC);
     }
 
     /**
      * This method will determine which balance type amount mode to switch to. A change in the balance type selection will
      * eventually invoke this mechanism, which looks at the old balance type value, and the new balance type value to determine what
      * the next mode is.
      * 
      * @param journalVoucherForm
      * @throws Exception
      */
     protected int determineBalanceTypeAmountChangeMode(JournalVoucherForm journalVoucherForm) throws Exception {
         int balanceTypeAmountChangeMode = NO_MODE_CHANGE;
 
         // retrieve fully populated balance type instances
         BalanceType origBalType = getPopulatedBalanceTypeInstance(journalVoucherForm.getOriginalBalanceType());
         BalanceType newBalType = getPopulatedBalanceTypeInstance(journalVoucherForm.getSelectedBalanceType().getCode());
 
         // figure out which ways we are switching the modes first deal with amount changes
         if (origBalType.isFinancialOffsetGenerationIndicator() && !newBalType.isFinancialOffsetGenerationIndicator()) { // credit/debit
             balanceTypeAmountChangeMode = CREDIT_DEBIT_TO_SINGLE_AMT_MODE;
         }
         else if (!origBalType.isFinancialOffsetGenerationIndicator() && newBalType.isFinancialOffsetGenerationIndicator()) { // single
             balanceTypeAmountChangeMode = SINGLE_AMT_TO_CREDIT_DEBIT_MODE;
         }
 
         return balanceTypeAmountChangeMode;
     }
 
     /**
      * This method will determine which balance type encumbrance mode to switch to. A change in the balance type selection will
      * eventually invoke this mechanism, which looks at the old balance type value, and the new balance type value to determine what
      * the next mode is.
      * 
      * @param journalVoucherForm
      * @throws Exception
      */
     protected int determineBalanceTypeEncumbranceChangeMode(JournalVoucherForm journalVoucherForm) throws Exception {
         int balanceTypeExternalEncumbranceChangeMode = NO_MODE_CHANGE;
 
         // retrieve fully populated balance type instances
         BalanceType origBalType = getPopulatedBalanceTypeInstance(journalVoucherForm.getOriginalBalanceType());
         BalanceType newBalType = getPopulatedBalanceTypeInstance(journalVoucherForm.getSelectedBalanceType().getCode());
 
         // then deal with external encumbrance changes
         if (origBalType.getCode().equals(OLEConstants.BALANCE_TYPE_EXTERNAL_ENCUMBRANCE) && !newBalType.getCode().equals(OLEConstants.BALANCE_TYPE_EXTERNAL_ENCUMBRANCE)) {
             balanceTypeExternalEncumbranceChangeMode = EXT_ENCUMB_TO_NON_EXT_ENCUMB;
         }
         else if (!origBalType.getCode().equals(OLEConstants.BALANCE_TYPE_EXTERNAL_ENCUMBRANCE) && newBalType.getCode().equals(OLEConstants.BALANCE_TYPE_EXTERNAL_ENCUMBRANCE)) {
             balanceTypeExternalEncumbranceChangeMode = NON_EXT_ENCUMB_TO_EXT_ENCUMB;
         }
 
         return balanceTypeExternalEncumbranceChangeMode;
     }
 
     /**
      * This method takes control from the changeBalanceType action method in order to present a question prompt to the user so that
      * they can confirm the change in balance type.
      * 
      * @param mapping
      * @param form
      * @param request
      * @param response
      * @return ActionForward
      * @throws Exception
      */
     protected ActionForward processChangeBalanceTypeConfirmationQuestion(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
         JournalVoucherForm jvForm = (JournalVoucherForm) form;
         JournalVoucherDocument jvDoc = jvForm.getJournalVoucherDocument();
 
         // only want to present the confirmation question to the user if there are any
         // accouting lines, because that is the only impact
         if (jvDoc.getSourceAccountingLines().size() != 0) {
             String question = request.getParameter(OLEConstants.QUESTION_INST_ATTRIBUTE_NAME);
             ConfigurationService kualiConfiguration = SpringContext.getBean(ConfigurationService.class);
 
             if (question == null) { // question hasn't been asked
                 String message = buildBalanceTypeChangeConfirmationMessage(jvForm, kualiConfiguration);
 
                 // now transfer control over to the question component
                 return this.performQuestionWithoutInput(mapping, form, request, response, OLEConstants.JOURNAL_VOUCHER_CHANGE_BALANCE_TYPE_QUESTION, message, OLEConstants.CONFIRMATION_QUESTION, OLEConstants.CHANGE_JOURNAL_VOUCHER_BALANCE_TYPE_METHOD, "");
             }
             else {
                 String buttonClicked = request.getParameter(OLEConstants.QUESTION_CLICKED_BUTTON);
                 if ((OLEConstants.JOURNAL_VOUCHER_CHANGE_BALANCE_TYPE_QUESTION.equals(question)) && ConfirmationQuestion.NO.equals(buttonClicked)) {
                     // if no button clicked keep the old value and reload doc
                     BalanceType origBalType = getPopulatedBalanceTypeInstance(jvForm.getOriginalBalanceType());
                     jvForm.setSelectedBalanceType(origBalType);
                     jvDoc.setBalanceType(origBalType);
                     jvDoc.setBalanceTypeCode(origBalType.getCode());
                     return mapping.findForward(OLEConstants.MAPPING_BASIC);
                 }
             }
         }
         return null;
     }
 
     /**
      * This method will setup the message that will get displayed to the user when they are asked to confirm the balance type
      * change. The message is tuned to the particular context, the value chosen, and also the previous value. It also combines with
      * the core part of the message which is part of the ApplicationResources.properties file.
      * 
      * @param jvForm
      * @param kualiConfiguration
      * @return The message to display to the user in the question prompt window.
      * @throws Exception
      */
     protected String buildBalanceTypeChangeConfirmationMessage(JournalVoucherForm jvForm, ConfigurationService kualiConfiguration) throws Exception {
         String message = new String("");
 
         // figure out which way the balance type is changing
         int balanceTypeAmountChangeMode = determineBalanceTypeAmountChangeMode(jvForm);
         int balanceTypeExternalEncumbranceChangeMode = determineBalanceTypeEncumbranceChangeMode(jvForm);
 
         // grab the right message from the ApplicationResources.properties file depending upon the balance type switching mode
         if (balanceTypeAmountChangeMode == SINGLE_AMT_TO_CREDIT_DEBIT_MODE) {
             message = kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_SINGLE_AMT_TO_CREDIT_DEBIT_MODE);
             // see if we need the extra bit about the external encumbrance
             String newMessage = new String("");
             if (balanceTypeExternalEncumbranceChangeMode == NON_EXT_ENCUMB_TO_EXT_ENCUMB) {
                 newMessage = StringUtils.replace(message, "{3}", kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_SINGLE_AMT_TO_EXT_ENCUMB_CREDIT_DEBIT_MODE));
             }
             else {
                 newMessage = StringUtils.replace(message, "{3}", "");
             }
             message = new String(newMessage);
         }
         else if (balanceTypeAmountChangeMode == CREDIT_DEBIT_TO_SINGLE_AMT_MODE) {
             message = kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_CREDIT_DEBIT_TO_SINGLE_AMT_MODE);
             // see if we need the extra bit about the external encumbrance
             String newMessage = new String("");
             if (balanceTypeExternalEncumbranceChangeMode == EXT_ENCUMB_TO_NON_EXT_ENCUMB) {
                 newMessage = StringUtils.replace(message, "{3}", kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_EXT_ENCUMB_CREDIT_DEBIT_TO_SINGLE_AMT_MODE));
             }
             else {
                 newMessage = StringUtils.replace(message, "{3}", "");
             }
             message = new String(newMessage);
         }
         else if (balanceTypeExternalEncumbranceChangeMode == EXT_ENCUMB_TO_NON_EXT_ENCUMB) {
             message = kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_EXT_ENCUMB_TO_NON_EXT_ENCUMB);
         }
         else if (balanceTypeExternalEncumbranceChangeMode == NON_EXT_ENCUMB_TO_EXT_ENCUMB) {
             message = kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_CHANGE_JV_BAL_TYPE_FROM_NON_EXT_ENCUMB_TO_EXT_ENCUMB);
         }
 
         // retrieve fully populated balance type instances
         BalanceType origBalType = getPopulatedBalanceTypeInstance(jvForm.getOriginalBalanceType());
         BalanceType newBalType = getPopulatedBalanceTypeInstance(jvForm.getSelectedBalanceType().getCode());
 
         // now complete building of the message
         String replacement = "\"" + origBalType.getCode() + "-" + origBalType.getName() + "\"";
         String newMessage = StringUtils.replace(message, "{0}", replacement);
 
         replacement = "\"" + newBalType.getCode() + "-" + newBalType.getName() + "\"";
         String finalMessage = StringUtils.replace(newMessage, "{1}", replacement);
 
         return finalMessage;
     }
 
     /**
      * This method will fully populate a balance type given the passed in code, by calling the business object service that
      * retrieves the rest of the instances' information.
      * 
      * @param balanceTypeCode
      * @return BalanceTyp
      */
     protected BalanceType getPopulatedBalanceTypeInstance(String balanceTypeCode) {
         // now we have to get the code and the name of the original and new balance types
         return SpringContext.getBean(BalanceTypeService.class).getBalanceTypeByCode(balanceTypeCode);
     }
 
     /**
      * This method will clear out the source line values that aren't needed for the "Single Amount" mode.
      * 
      * @param journalVoucherForm
      */
     protected void switchFromSingleAmountModeToCreditDebitMode(JournalVoucherForm journalVoucherForm) {
         // going from single amount to credit/debit view so we want to blank out the amount and the extra "reference" fields
         // that the single amount view uses
         JournalVoucherDocument jvDoc = (JournalVoucherDocument) journalVoucherForm.getTransactionalDocument();
         ArrayList sourceLines = (ArrayList) jvDoc.getSourceAccountingLines();
         ArrayList helperLines = (ArrayList) journalVoucherForm.getVoucherLineHelpers();
         helperLines.clear(); // reset so we can add in fresh empty ones
 
         // make sure that there is enough space in the list
         helperLines.ensureCapacity(sourceLines.size());
 
         for (int i = 0; i < sourceLines.size(); i++) {
             VoucherSourceAccountingLine sourceLine = (VoucherSourceAccountingLine) sourceLines.get(i);
             sourceLine.setAmount(KualiDecimal.ZERO);
             sourceLine.setDebitCreditCode(OLEConstants.GL_DEBIT_CODE); // default to debit
 
             helperLines.add(new VoucherAccountingLineHelperBase()); // populate with a fresh new empty object
         }
     }
 
     /**
      * This method will clear out the extra "reference" fields that the external encumbrance balance type uses, but will leave the
      * amounts since we aren't changing the offset generation code stuff.
      * 
      * @param journalVoucherForm
      */
     protected void switchFromExternalEncumbranceModeToNonExternalEncumbrance(JournalVoucherForm journalVoucherForm) {
         // going from external encumbrance view to non external encumbrance view, so we want to blank out the extra "reference"
         // fields
         JournalVoucherDocument jvDoc = (JournalVoucherDocument) journalVoucherForm.getTransactionalDocument();
         ArrayList sourceLines = (ArrayList) jvDoc.getSourceAccountingLines();
 
         for (int i = 0; i < sourceLines.size(); i++) {
             VoucherSourceAccountingLine sourceLine = (VoucherSourceAccountingLine) sourceLines.get(i);
             sourceLine.setReferenceOriginCode(null); // won't be needed in this mode
             sourceLine.setReferenceNumber(null); // won't be needed in this mode
             sourceLine.setReferenceTypeCode(null); // won't be needed in this mode
         }
     }
 
     /**
      * This method will clear out the source line values that aren't needed for the "Credit/Debit" mode.
      * 
      * @param journalVoucherForm
      */
     protected void switchFromCreditDebitModeToSingleAmountMode(JournalVoucherForm journalVoucherForm) {
         // going from credit/debit view to single amount view so we don't need the debit and credit
         // indicator set any more and we need to blank out the amount values to zero
         JournalVoucherDocument jvDoc = journalVoucherForm.getJournalVoucherDocument();
         ArrayList sourceLines = (ArrayList) jvDoc.getSourceAccountingLines();
         ArrayList helperLines = (ArrayList) journalVoucherForm.getVoucherLineHelpers();
 
         KualiDecimal ZERO = new KualiDecimal("0.00");
         for (int i = 0; i < sourceLines.size(); i++) {
             VoucherAccountingLineHelper helperLine = (VoucherAccountingLineHelper) helperLines.get(i);
             SourceAccountingLine sourceLine = (SourceAccountingLine) sourceLines.get(i);
             sourceLine.setAmount(ZERO);
             sourceLine.setDebitCreditCode(OLEConstants.GL_DEBIT_CODE); // single sided is always debit
 
             helperLine.setCredit(null); // won't be needed in this mode
             helperLine.setDebit(null); // won't be needed in this mode
         }
     }
 
     /**
      * Overrides the parent to make sure that the JV specific accounting line helper forms are properly populated when the document
      * is first loaded. This first calls super, then populates the helper objects.
      * 
      * @see org.kuali.rice.kns.web.struts.action.KualiDocumentActionBase#loadDocument(org.kuali.rice.kns.web.struts.form.KualiDocumentFormBase)
      */
     @Override
     protected void loadDocument(KualiDocumentFormBase kualiDocumentFormBase) throws WorkflowException {
         super.loadDocument(kualiDocumentFormBase);
         JournalVoucherForm journalVoucherForm = (JournalVoucherForm) kualiDocumentFormBase;
 
         // if the balance type is an offset generation balance type, then the user is able to enter the amount
         // as either a debit or a credit, otherwise, they only need to deal with the amount field
         JournalVoucherDocument journalVoucherDocument = (JournalVoucherDocument) journalVoucherForm.getTransactionalDocument();
         if (journalVoucherDocument.getBalanceType().isFinancialOffsetGenerationIndicator()) {
             populateAllVoucherAccountingLineHelpers(journalVoucherForm);
             KualiDecimal ZERO = new KualiDecimal("0.00");
             journalVoucherForm.setNewSourceLineCredit(ZERO);
             journalVoucherForm.setNewSourceLineDebit(ZERO);
         }
 
         // always wipe out the new source line
         journalVoucherForm.setNewSourceLine(null);
 
         // reload the balance type and accounting period selections since now we have data in the document bo
         populateSelectedJournalBalanceType(journalVoucherDocument, journalVoucherForm);
         populateSelectedAccountingPeriod(journalVoucherDocument, journalVoucherForm);
     }
 
     /**
      * This method grabs the value from the document bo and sets the selected balance type appropriately.
      * 
      * @param journalVoucherDocument
      * @param journalVoucherForm
      */
     protected void populateSelectedJournalBalanceType(JournalVoucherDocument journalVoucherDocument, JournalVoucherForm journalVoucherForm) {
         journalVoucherForm.setSelectedBalanceType(journalVoucherDocument.getBalanceType());
         if (StringUtils.isNotBlank(journalVoucherDocument.getBalanceTypeCode())) {
             journalVoucherForm.setOriginalBalanceType(journalVoucherDocument.getBalanceTypeCode());
         }
     }
 
     /**
      * This helper method determines from the request object instance whether or not the user has been prompted about the journal
      * being out of balance. If they haven't, then the method will build the appropriate message given the state of the document and
      * return control to the question component so that the user receives the "yes"/"no" prompt. If the question has been asked, the
      * we evaluate the user's answer and direct the flow appropriately. If they answer with a "No", then we build out a message
      * stating that they chose that value and return an ActionForward of a MAPPING_BASIC which keeps them at the same page that they
      * were on. If they choose "Yes", then we return a null ActionForward, which the calling action method recognizes as a "Yes" and
      * continues on processing the "Route."
      * 
      * @param mapping
      * @param form
      * @param request
      * @param response
      * @return ActionForward
      * @throws Exception
      */
     @Override
     protected ActionForward processRouteOutOfBalanceDocumentConfirmationQuestion(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
         JournalVoucherForm jvForm = (JournalVoucherForm) form;
         JournalVoucherDocument jvDoc = jvForm.getJournalVoucherDocument();
 
         String question = request.getParameter(OLEConstants.QUESTION_INST_ATTRIBUTE_NAME);
         ConfigurationService kualiConfiguration = SpringContext.getBean(ConfigurationService.class);
 
         if (question == null) { // question hasn't been asked
             String currencyFormattedDebitTotal = (String) new CurrencyFormatter().format(jvDoc.getDebitTotal());
             String currencyFormattedCreditTotal = (String) new CurrencyFormatter().format(jvDoc.getCreditTotal());
             String currencyFormattedTotal = (String) new CurrencyFormatter().format(jvDoc.getTotalDollarAmount());
             String message = "";
             jvDoc.refreshReferenceObject(OLEPropertyConstants.BALANCE_TYPE);
             if (jvDoc.getBalanceType().isFinancialOffsetGenerationIndicator()) {
                 message = StringUtils.replace(kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_ROUTE_OUT_OF_BALANCE_JV_DOC), "{0}", currencyFormattedDebitTotal);
                 message = StringUtils.replace(message, "{1}", currencyFormattedCreditTotal);
             }
             else {
                 message = StringUtils.replace(kualiConfiguration.getPropertyValueAsString(OLEKeyConstants.QUESTION_ROUTE_OUT_OF_BALANCE_JV_DOC_SINGLE_AMT_MODE), "{0}", currencyFormattedTotal);
             }
 
             // now transfer control over to the question component
             return this.performQuestionWithoutInput(mapping, form, request, response, OLEConstants.JOURNAL_VOUCHER_ROUTE_OUT_OF_BALANCE_DOCUMENT_QUESTION, message, OLEConstants.CONFIRMATION_QUESTION, OLEConstants.ROUTE_METHOD, "");
         }
         else {
             String buttonClicked = request.getParameter(OLEConstants.QUESTION_CLICKED_BUTTON);
             if ((OLEConstants.JOURNAL_VOUCHER_ROUTE_OUT_OF_BALANCE_DOCUMENT_QUESTION.equals(question)) && ConfirmationQuestion.NO.equals(buttonClicked)) {
                 KNSGlobalVariables.getMessageList().add(OLEKeyConstants.MESSAGE_JV_CANCELLED_ROUTE);
                 return mapping.findForward(OLEConstants.MAPPING_BASIC);
             }
         }
         return null;
     }
 
     /**
      * This action executes a call to upload CSV accounting line values as SourceAccountingLines for a given transactional document.
      * The "uploadAccountingLines()" method handles the multi-part request.
      * 
      * @param mapping
      * @param form
      * @param request
      * @param response
      * @return ActionForward
      * @throws FileNotFoundException
      * @throws IOException
      */
     @Override
     public ActionForward uploadSourceLines(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws FileNotFoundException, IOException {
         // call method that sourceform and destination list
         uploadAccountingLines(true, form);
 
         return mapping.findForward(OLEConstants.MAPPING_BASIC);
     }
 
     /**
      * This method determines whether we are uploading source or target lines, and then calls uploadAccountingLines directly on the
      * document object. This method handles retrieving the actual upload file as an input stream into the document.
      * 
      * @param isSource
      * @param form
      * @throws FileNotFoundException
      * @throws IOException
      */
     @Override
     protected void uploadAccountingLines(boolean isSource, ActionForm form) throws FileNotFoundException, IOException {
         JournalVoucherForm jvForm = (JournalVoucherForm) form;
         // JournalVoucherAccountingLineParser needs a fresh BalanceType BO in the JournalVoucherDocument.
         jvForm.getJournalVoucherDocument().refreshReferenceObject(OLEPropertyConstants.BALANCE_TYPE);
         super.uploadAccountingLines(isSource, jvForm);
     }
 
 }