Ejemplo n.º 1
0
  @Override
  public void addNoteToPersonnel(Short personnelId, String comment) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    try {
      PersonnelBO personnel = this.personnelDao.findPersonnelById(personnelId);
      PersonnelBO loggedInUser = this.personnelDao.findPersonnelById(userContext.getId());
      if (personnel != null) {
        checkPermissionForAddingNotesToPersonnel(
            userContext, personnel.getOffice().getOfficeId(), personnel.getPersonnelId());
      }

      this.transactionHelper.startTransaction();
      PersonnelNotesEntity personnelNote =
          new PersonnelNotesEntity(comment, loggedInUser, personnel);
      personnel.addNotes(userContext.getId(), personnelNote);
      this.personnelDao.save(personnel);
      this.transactionHelper.commitTransaction();
    } catch (Exception e) {
      this.transactionHelper.rollbackTransaction();
      throw new MifosRuntimeException(e);
    } finally {
      this.transactionHelper.closeSession();
    }
  }
Ejemplo n.º 2
0
  @Override
  public void waiveChargesDue(Integer accountId, Integer waiveType) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    try {
      AccountBO account = new AccountBusinessService().getAccount(accountId);
      account.updateDetails(userContext);
      PersonnelBO loggedInUser = this.personnelDao.findPersonnelById(userContext.getId());

      WaiveEnum waiveEnum = WaiveEnum.fromInt(waiveType);
      if (account.getPersonnel() != null) {
        new AccountBusinessService()
            .checkPermissionForWaiveDue(
                waiveEnum,
                account.getType(),
                account.getCustomer().getLevel(),
                userContext,
                account.getOffice().getOfficeId(),
                account.getPersonnel().getPersonnelId());
      } else {
        new AccountBusinessService()
            .checkPermissionForWaiveDue(
                waiveEnum,
                account.getType(),
                account.getCustomer().getLevel(),
                userContext,
                account.getOffice().getOfficeId(),
                userContext.getId());
      }

      if (account.isLoanAccount()) {
        ((LoanBO) account).waiveAmountDue(waiveEnum);
      } else if (account.isSavingsAccount()) {
        ((SavingsBO) account).waiveNextDepositAmountDue(loggedInUser);
      } else {
        try {
          this.transactionHelper.startTransaction();
          ((CustomerAccountBO) account).waiveAmountDue();
          this.customerDao.save(account);
          this.transactionHelper.commitTransaction();
        } catch (Exception e) {
          this.transactionHelper.rollbackTransaction();
          throw new BusinessRuleException(account.getAccountId().toString(), e);
        } finally {
          this.transactionHelper.closeSession();
        }
      }
    } catch (ServiceException e) {
      throw new MifosRuntimeException(e);
    } catch (ApplicationException e) {
      throw new BusinessRuleException(e.getKey(), e);
    }
  }
Ejemplo n.º 3
0
  @Override
  public void removeAccountFee(Integer accountId, Short feeId) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    try {
      AccountBO account = new AccountBusinessService().getAccount(accountId);

      account.updateDetails(userContext);

      if (account.getPersonnel() != null) {
        new AccountBusinessService()
            .checkPermissionForRemoveFees(
                account.getType(),
                account.getCustomer().getLevel(),
                userContext,
                account.getOffice().getOfficeId(),
                account.getPersonnel().getPersonnelId());
      } else {
        new AccountBusinessService()
            .checkPermissionForRemoveFees(
                account.getType(),
                account.getCustomer().getLevel(),
                userContext,
                account.getOffice().getOfficeId(),
                userContext.getId());
      }

      this.transactionHelper.startTransaction();
      account.removeFeesAssociatedWithUpcomingAndAllKnownFutureInstallments(
          feeId, userContext.getId());
      this.customerDao.save(account);
      this.transactionHelper.commitTransaction();
    } catch (ServiceException e) {
      this.transactionHelper.rollbackTransaction();
      throw new MifosRuntimeException(e);
    } catch (AccountException e) {
      this.transactionHelper.rollbackTransaction();
      throw new BusinessRuleException(e.getKey(), e);
    } catch (ApplicationException e) {
      this.transactionHelper.rollbackTransaction();
      throw new BusinessRuleException(e.getKey(), e);
    } finally {
      this.transactionHelper.closeSession();
    }
  }
  private PersonnelBO createPersonnel(OfficeBO office, PersonnelLevel personnelLevel)
      throws Exception {
    List<CustomFieldDto> customFieldDto = new ArrayList<CustomFieldDto>();
    customFieldDto.add(
        new CustomFieldDto(Short.valueOf("9"), "123456", CustomFieldType.NUMERIC.getValue()));
    Address address = new Address("abcd", "abcd", "abcd", "abcd", "abcd", "abcd", "abcd", "abcd");
    Name name = new Name("XYZ", null, null, null);
    java.util.Date date = new java.util.Date();
    personnel =
        new PersonnelBO(
            personnelLevel,
            office,
            Integer.valueOf("1"),
            Short.valueOf("1"),
            "ABCD",
            "XYZ",
            "*****@*****.**",
            null,
            customFieldDto,
            name,
            "111111",
            date,
            Integer.valueOf("1"),
            Integer.valueOf("1"),
            date,
            date,
            address,
            userContext.getId());

    IntegrationTestObjectMother.createPersonnel(personnel);
    return IntegrationTestObjectMother.findPersonnelById(personnel.getPersonnelId());
  }
Ejemplo n.º 5
0
  @Override
  public void createCustomerNote(CustomerNoteFormDto customerNoteForm) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    CustomerBO customer = this.customerDao.findCustomerBySystemId(customerNoteForm.getGlobalNum());
    customer.updateDetails(userContext);

    PersonnelBO loggedInUser = this.personnelDao.findPersonnelById(userContext.getId());

    CustomerNoteEntity customerNote =
        new CustomerNoteEntity(
            customerNoteForm.getComment(),
            new DateTimeService().getCurrentJavaSqlDate(),
            loggedInUser,
            customer);
    customer.addCustomerNotes(customerNote);

    try {
      this.transactionHelper.startTransaction();
      this.customerDao.save(customer);
      this.transactionHelper.commitTransaction();
    } catch (Exception e) {
      this.transactionHelper.rollbackTransaction();
      throw new BusinessRuleException(customer.getCustomerAccount().getAccountId().toString(), e);
    } finally {
      this.transactionHelper.closeSession();
    }
  }
Ejemplo n.º 6
0
  @Override
  public boolean isPaymentPermitted(Integer accountId) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    try {
      AccountBO account = new AccountBusinessService().getAccount(accountId);

      CustomerLevel customerLevel = null;
      if (account.getType().equals(AccountTypes.CUSTOMER_ACCOUNT)) {
        customerLevel = account.getCustomer().getLevel();
      }

      Short personnelId = userContext.getId();
      if (account.getPersonnel() != null) {
        personnelId = account.getPersonnel().getPersonnelId();
      }

      return ActivityMapper.getInstance()
          .isPaymentPermittedForAccounts(
              account.getType(),
              customerLevel,
              userContext,
              account.getOffice().getOfficeId(),
              personnelId);
    } catch (ServiceException e) {
      throw new MifosRuntimeException(e);
    }
  }
Ejemplo n.º 7
0
  @Override
  public void revertLastChargesPayment(String globalCustNum, String adjustmentNote) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    PersonnelBO loggedInUser = this.personnelDao.findPersonnelById(userContext.getId());
    CustomerBO customerBO = this.customerDao.findCustomerBySystemId(globalCustNum);
    customerBO.updateDetails(userContext);

    if (customerBO.getCustomerAccount().findMostRecentNonzeroPaymentByPaymentDate() != null) {
      customerBO.getCustomerAccount().updateDetails(userContext);

      try {
        if (customerBO.getPersonnel() != null) {
          new AccountBusinessService()
              .checkPermissionForAdjustment(
                  AccountTypes.CUSTOMER_ACCOUNT,
                  customerBO.getLevel(),
                  userContext,
                  customerBO.getOffice().getOfficeId(),
                  customerBO.getPersonnel().getPersonnelId());
        } else {
          new AccountBusinessService()
              .checkPermissionForAdjustment(
                  AccountTypes.CUSTOMER_ACCOUNT,
                  customerBO.getLevel(),
                  userContext,
                  customerBO.getOffice().getOfficeId(),
                  userContext.getId());
        }

        this.transactionHelper.startTransaction();
        customerBO.adjustPmnt(adjustmentNote, loggedInUser);
        this.customerDao.save(customerBO);
        this.transactionHelper.commitTransaction();
      } catch (SystemException e) {
        this.transactionHelper.rollbackTransaction();
        throw new MifosRuntimeException(e);
      } catch (ApplicationException e) {
        this.transactionHelper.rollbackTransaction();
        throw new BusinessRuleException(e.getKey(), e);
      }
    }
  }
Ejemplo n.º 8
0
 @CloseSession
 @TransactionDemarcate(validateAndResetToken = true)
 public ActionForward create(
     ActionMapping mapping,
     ActionForm form,
     HttpServletRequest request,
     HttpServletResponse response)
     throws Exception {
   logger.debug("In CustomerNotesAction::create()");
   ActionForward forward = null;
   CustomerNotesActionForm notesActionForm = (CustomerNotesActionForm) form;
   CustomerBO customerBO =
       getCustomerBusinessService()
           .getCustomer(Integer.valueOf(((CustomerNotesActionForm) form).getCustomerId()));
   UserContext uc = getUserContext(request);
   if (customerBO.getPersonnel() != null) {
     checkPermissionForAddingNotes(
         AccountTypes.CUSTOMER_ACCOUNT,
         customerBO.getLevel(),
         uc,
         customerBO.getOffice().getOfficeId(),
         customerBO.getPersonnel().getPersonnelId());
   } else {
     checkPermissionForAddingNotes(
         AccountTypes.CUSTOMER_ACCOUNT,
         customerBO.getLevel(),
         uc,
         customerBO.getOffice().getOfficeId(),
         uc.getId());
   }
   PersonnelBO personnelBO = new PersonnelPersistence().getPersonnel(uc.getId());
   CustomerNoteEntity customerNote =
       new CustomerNoteEntity(
           notesActionForm.getComment(),
           new DateTimeService().getCurrentJavaSqlDate(),
           personnelBO,
           customerBO);
   customerBO.addCustomerNotes(customerNote);
   customerBO.setUserContext(uc);
   customerBO.update();
   forward = mapping.findForward(getDetailCustomerPage(notesActionForm));
   customerBO = null;
   return forward;
 }
Ejemplo n.º 9
0
  @Override
  public CenterDto retrieveCenterDetailsForUpdate(Integer centerId) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    CustomerBO center = customerDao.findCustomerById(centerId);

    Short officeId = center.getOffice().getOfficeId();
    String searchId = center.getSearchId();
    Short loanOfficerId = extractLoanOfficerId(center);

    CenterCreation centerCreation =
        new CenterCreation(
            officeId,
            userContext.getId(),
            userContext.getLevelId(),
            userContext.getPreferredLocale());
    List<PersonnelDto> activeLoanOfficersForBranch =
        personnelDao.findActiveLoanOfficersForOffice(centerCreation);

    List<CustomerDto> customerList =
        customerDao.findClientsThatAreNotCancelledOrClosed(searchId, officeId);

    List<CustomerPositionDto> customerPositionDtos =
        generateCustomerPositionViews(center, userContext.getLocaleId());

    DateTime mfiJoiningDate = new DateTime();
    String mfiJoiningDateAsString = "";
    if (center.getMfiJoiningDate() != null) {
      mfiJoiningDate = new DateTime(center.getMfiJoiningDate());
      mfiJoiningDateAsString =
          DateUtils.getUserLocaleDate(
              userContext.getPreferredLocale(), center.getMfiJoiningDate().toString());
    }

    AddressDto address = null;
    if (center.getAddress() != null) {
      address = Address.toDto(center.getAddress());
    }
    return new CenterDto(
        loanOfficerId,
        center.getCustomerId(),
        center.getGlobalCustNum(),
        mfiJoiningDate,
        mfiJoiningDateAsString,
        center.getExternalId(),
        address,
        customerPositionDtos,
        customerList,
        activeLoanOfficersForBranch,
        true);
  }
Ejemplo n.º 10
0
 @Override
 protected void setUp() throws Exception {
   super.setUp();
   userContext = TestUtils.makeUser();
   request.getSession().setAttribute(Constants.USERCONTEXT, userContext);
   addRequestParameter("recordLoanOfficerId", "1");
   addRequestParameter("recordOfficeId", "1");
   ActivityContext ac =
       new ActivityContext(
           (short) 0, userContext.getBranchId().shortValue(), userContext.getId().shortValue());
   request.getSession(false).setAttribute("ActivityContext", ac);
   flowKey = createFlow(request, CollectionSheetEntryAction.class);
 }
Ejemplo n.º 11
0
 private void checkPermissionForAdjustment(AccountBO accountBO) throws ServiceException {
   AccountPaymentEntity lastPmntToBeAdjusted = accountBO.getLastPmntToBeAdjusted();
   if (lastPmntToBeAdjusted == null) return;
   UserContext userContext = accountBO.getUserContext();
   Date lastPaymentDate = lastPmntToBeAdjusted.getPaymentDate();
   PersonnelBO personnel = accountBO.getPersonnel();
   Short personnelId = personnel != null ? personnel.getPersonnelId() : userContext.getId();
   Short officeId = accountBO.getOfficeId();
   accountBusinessService.checkPermissionForAdjustment(
       AccountTypes.LOAN_ACCOUNT, null, userContext, officeId, personnelId);
   accountBusinessService.checkPermissionForAdjustmentOnBackDatedPayments(
       lastPaymentDate, userContext, officeId, personnelId);
 }
Ejemplo n.º 12
0
  @Override
  public CustomerNoteFormDto retrieveCustomerNote(String globalCustNum) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    CustomerBO customer = this.customerDao.findCustomerBySystemId(globalCustNum);
    PersonnelBO loggedInUser = this.personnelDao.findPersonnelById(userContext.getId());

    Integer customerLevel = customer.getCustomerLevel().getId().intValue();
    String globalNum = customer.getGlobalCustNum();
    String displayName = customer.getDisplayName();
    LocalDate commentDate = new LocalDate();
    String commentUser = loggedInUser.getDisplayName();

    return new CustomerNoteFormDto(
        globalNum, displayName, customerLevel, commentDate, commentUser, "");
  }
Ejemplo n.º 13
0
 @TransactionDemarcate(joinToken = true)
 public ActionForward load(
     ActionMapping mapping,
     ActionForm form,
     HttpServletRequest request,
     HttpServletResponse response)
     throws Exception {
   logger.debug("In CustomerNotesAction::load()");
   clearActionForm(form);
   UserContext userContext = getUserContext(request);
   CustomerBO customerBO =
       getCustomerBusinessService()
           .getCustomer(Integer.valueOf(((CustomerNotesActionForm) form).getCustomerId()));
   customerBO.setUserContext(userContext);
   setFormAttributes(userContext, form, customerBO);
   PersonnelBO personnelBO = new PersonnelPersistence().getPersonnel(userContext.getId());
   SessionUtils.removeAttribute(Constants.BUSINESS_KEY, request);
   SessionUtils.setAttribute(Constants.BUSINESS_KEY, customerBO, request);
   SessionUtils.setAttribute(
       CustomerConstants.PERSONNEL_NAME, personnelBO.getDisplayName(), request);
   return mapping.findForward(ActionForwards.load_success.toString());
 }
Ejemplo n.º 14
0
  @TransactionDemarcate(validateAndResetToken = true)
  @CloseSession
  public ActionForward update(
      final ActionMapping mapping,
      final ActionForm form,
      final HttpServletRequest request,
      @SuppressWarnings("unused") final HttpServletResponse response)
      throws Exception {

    LoanDisbursementActionForm actionForm = (LoanDisbursementActionForm) form;

    UserContext uc = getUserContext(request);
    Date trxnDate = getDateFromString(actionForm.getTransactionDate(), uc.getPreferredLocale());
    trxnDate = DateUtils.getDateWithoutTimeStamp(trxnDate.getTime());
    Date receiptDate = getDateFromString(actionForm.getReceiptDate(), uc.getPreferredLocale());

    Integer loanAccountId = Integer.valueOf(actionForm.getAccountId());
    AccountBO accountBO = new AccountBusinessService().getAccount(loanAccountId);

    createGroupQuestionnaire.saveResponses(request, actionForm, loanAccountId);

    try {
      String paymentTypeIdStringForDisbursement = actionForm.getPaymentTypeId();
      Short paymentTypeIdForDisbursement =
          StringUtils.isEmpty(paymentTypeIdStringForDisbursement)
              ? PaymentTypes.CASH.getValue()
              : Short.valueOf(paymentTypeIdStringForDisbursement);

      Short paymentTypeId = Short.valueOf(paymentTypeIdForDisbursement);
      final String comment = "";
      final BigDecimal disbursalAmount = new BigDecimal(actionForm.getLoanAmount());
      CustomerDto customerDto = null;

      PaymentTypeDto paymentType = null;
      AccountPaymentParametersDto loanDisbursement =
          new AccountPaymentParametersDto(
              new UserReferenceDto(uc.getId()),
              new AccountReferenceDto(loanAccountId),
              disbursalAmount,
              new LocalDate(trxnDate),
              paymentType,
              comment,
              new LocalDate(receiptDate),
              actionForm.getReceiptId(),
              customerDto);

      monthClosingServiceFacade.validateTransactionDate(trxnDate);

      // GLIM
      List<LoanBO> individualLoans = this.loanDao.findIndividualLoans(loanAccountId);
      for (LoanBO individual : individualLoans) {
        if (!loanAccountServiceFacade.isTrxnDateValid(
            Integer.valueOf(individual.getAccountId()), trxnDate)) {
          throw new BusinessRuleException("errors.invalidTxndateOfDisbursal");
        }
      }

      this.loanAccountServiceFacade.disburseLoan(loanDisbursement, paymentTypeId);

      for (LoanBO individual : individualLoans) {
        loanDisbursement =
            new AccountPaymentParametersDto(
                new UserReferenceDto(uc.getId()),
                new AccountReferenceDto(individual.getAccountId()),
                individual.getLoanAmount().getAmount(),
                new LocalDate(trxnDate),
                paymentType,
                comment,
                new LocalDate(receiptDate),
                actionForm.getReceiptId(),
                customerDto);

        this.loanAccountServiceFacade.disburseLoan(loanDisbursement, paymentTypeId);
      }
    } catch (BusinessRuleException e) {
      throw new AccountException(e.getMessage());
    } catch (MifosRuntimeException e) {
      if (e.getCause() != null && e.getCause() instanceof AccountException) {
        throw new AccountException(e.getCause().getMessage());
      }
      String msg = "errors.cannotDisburseLoan.because.disburseFailed";
      logger.error(msg, e);
      throw new AccountException(msg);
    } catch (Exception e) {
      String msg = "errors.cannotDisburseLoan.because.disburseFailed";
      logger.error(msg, e);
      throw new AccountException(msg);
    }

    return mapping.findForward(Constants.UPDATE_SUCCESS);
  }
Ejemplo n.º 15
0
  @Override
  public void applyCharge(Integer accountId, Short feeId, Double chargeAmount) {

    MifosUser user =
        (MifosUser) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    UserContext userContext = toUserContext(user);

    try {
      AccountBO account = new AccountBusinessService().getAccount(accountId);

      if (account instanceof LoanBO) {
        List<LoanBO> individualLoans = this.loanDao.findIndividualLoans(account.getAccountId());

        if (individualLoans != null && individualLoans.size() > 0) {
          for (LoanBO individual : individualLoans) {
            individual.updateDetails(userContext);

            FeeBO fee = this.feeDao.findById(feeId);

            if (fee instanceof RateFeeBO) {
              individual.applyCharge(feeId, chargeAmount);
            } else {
              Double radio =
                  individual.getLoanAmount().getAmount().doubleValue()
                      / ((LoanBO) account).getLoanAmount().getAmount().doubleValue();

              individual.applyCharge(feeId, chargeAmount * radio);
            }
          }
        }
      }

      account.updateDetails(userContext);

      CustomerLevel customerLevel = null;
      if (account.isCustomerAccount()) {
        customerLevel = account.getCustomer().getLevel();
      }
      if (account.getPersonnel() != null) {
        checkPermissionForApplyCharges(
            account.getType(),
            customerLevel,
            userContext,
            account.getOffice().getOfficeId(),
            account.getPersonnel().getPersonnelId());
      } else {
        checkPermissionForApplyCharges(
            account.getType(),
            customerLevel,
            userContext,
            account.getOffice().getOfficeId(),
            userContext.getId());
      }

      this.transactionHelper.startTransaction();
      account.applyCharge(feeId, chargeAmount);
      this.transactionHelper.commitTransaction();
    } catch (ServiceException e) {
      this.transactionHelper.rollbackTransaction();
      throw new MifosRuntimeException(e);
    } catch (ApplicationException e) {
      this.transactionHelper.rollbackTransaction();
      throw new BusinessRuleException(e.getKey(), e);
    }
  }