C# ISavingsContract.GetBalance方法代码示例

        public void _compareSavings(ISavingsContract originalSaving, ISavingsContract retrievedSaving)
        {
            Assert.AreEqual(originalSaving.Id, retrievedSaving.Id);
            Assert.AreEqual(originalSaving.InterestRate, retrievedSaving.InterestRate);
            Assert.AreEqual(originalSaving.Product.Id, retrievedSaving.Product.Id);
            Assert.AreEqual(originalSaving.GetBalance(), retrievedSaving.GetBalance());
            Assert.AreEqual(originalSaving.Code, retrievedSaving.Code);
            Assert.AreEqual(originalSaving.CreationDate, retrievedSaving.CreationDate);
            Assert.AreEqual(originalSaving.Status, retrievedSaving.Status);

            Assert.AreEqual(((SavingBookContract)originalSaving).FlatWithdrawFees.HasValue, ((SavingBookContract)retrievedSaving).FlatWithdrawFees.HasValue);
            if (((SavingBookContract)originalSaving).FlatWithdrawFees.HasValue)
                Assert.AreEqual(((SavingBookContract)originalSaving).FlatWithdrawFees.Value, ((SavingBookContract)retrievedSaving).FlatWithdrawFees.Value);
            Assert.AreEqual(((SavingBookContract)originalSaving).RateWithdrawFees.HasValue, ((SavingBookContract)retrievedSaving).RateWithdrawFees.HasValue);
            if (((SavingBookContract)originalSaving).RateWithdrawFees.HasValue)
                Assert.AreEqual(((SavingBookContract)originalSaving).RateWithdrawFees.Value, ((SavingBookContract)retrievedSaving).RateWithdrawFees.Value);

            Assert.AreEqual(((SavingBookContract)originalSaving).FlatTransferFees.HasValue, ((SavingBookContract)retrievedSaving).FlatTransferFees.HasValue);
            if (((SavingBookContract)originalSaving).FlatTransferFees.HasValue)
                Assert.AreEqual(((SavingBookContract)originalSaving).FlatTransferFees.Value, ((SavingBookContract)retrievedSaving).FlatTransferFees.Value);
            Assert.AreEqual(((SavingBookContract)originalSaving).RateTransferFees.HasValue, ((SavingBookContract)retrievedSaving).RateTransferFees.HasValue);
            if (((SavingBookContract)originalSaving).RateTransferFees.HasValue)
                Assert.AreEqual(((SavingBookContract) originalSaving).RateTransferFees.Value,
                                ((SavingBookContract) retrievedSaving).RateTransferFees.Value);
        }

        public SavingDebitOperationEvent SpecialOperationDebit(ISavingsContract pSaving, DateTime pDate, OCurrency debitAmount,
                string pDescription, User pUser, OSavingsMethods savingsMethod)
        {
            using (SqlConnection conn = _savingManager.GetConnection())
              using (SqlTransaction sqlTransaction = conn.BeginTransaction())
              {
                  try
                  {
                      if (pSaving is SavingBookContract)
                      {
                          decimal vBalance = CheckVirtualBalance((SavingBookContract) pSaving, debitAmount);

                          if (vBalance > 0)
                          {
                              List<string> messages = new List<string>
                                                          {
                                                              ServicesHelper.ConvertDecimalToString(
                                                                  ((SavingBookContract) pSaving).GetBalance().Value),
                                                              ServicesHelper.ConvertDecimalToString(vBalance),
                                                              ((SavingBookContract) pSaving).Loans.Count.ToString(),
                                                              ServicesHelper.ConvertDecimalToString(
                                                                  ((SavingBookContract) pSaving).GetBalance().Value -
                                                                  vBalance)
                                                          };
                              throw new OpenCbsSavingException(
                                  OpenCbsSavingExceptionEnum.BalanceOnCurrentSavingAccountForTransfer, messages);
                          }
                      }

                      //// Create a fake Saving object
                      ISavingsContract savingSimulation = (ISavingsContract) pSaving.Clone();
                      // Do deposit to the fake Saving object
                      savingSimulation.SpecialOperationDebit(debitAmount, pDate, pDescription, pUser);
                      // Check balance simulation
                      if (!IsSavingBalanceCorrect(savingSimulation))
                          throw new OpenCbsSavingException(OpenCbsSavingExceptionEnum.BalanceIsInvalid);

                      SavingDebitOperationEvent events = pSaving.SpecialOperationDebit(debitAmount, pDate, pDescription,
                                                                                        pUser);

                      _ePS.FireEvent(events, pSaving, sqlTransaction);

                      // Change overdraft state
                      if (pSaving is SavingBookContract)
                      {
                          if (pSaving.GetBalance() > 0)
                          {
                              ((SavingBookContract) pSaving).InOverdraft = false;
                              UpdateOverdraftStatus(pSaving.Id, false);
                          }
                      }
                      sqlTransaction.Commit();
                      return events;
                  }
                  catch (Exception)
                  {
                      sqlTransaction.Rollback();
                      throw;
                  }
              }
        }

        public void SavingServicesAccountAtMaturity(ISavingsContract savingContract, DateTime date, User user)
        {
            if (savingContract.Rollover == OSavingsRollover.None)
            {
                CloseAndTransfer(savingContract, savingContract.TransferAccount, date, user,
                                 savingContract.GetBalance(date), true, Teller.CurrentTeller);
            }

            if (savingContract.Rollover == OSavingsRollover.Principal)
            {
                DateTime lastMaturity = DateCalculationStrategy.GetLastMaturity(date,
                                                                                savingContract.Product.Periodicity,
                                                                                savingContract.NumberOfPeriods);

                OCurrency interests = savingContract.Events.Where(
                                                                     item => item is SavingInterestsPostingEvent &&
                                                                     item.Date.Date > lastMaturity &&
                                                                     item.Date.Date <= date
                                                                     ).
                                                            Sum(item => item.Amount.Value);

                // TODO: replace the fee of zero with a meaningful value
                Transfer(TransferAccount, interests, 0, date, "Transfer interests");
            }
        }

        public List<SavingEvent> LoanDisbursement(ISavingsContract savings, Loan loan, DateTime date, string description, User user, bool disableFees)
        {
            using(SqlConnection conn =  _savingManager.GetConnection())
            using (SqlTransaction sqlTransaction = conn.BeginTransaction())
            {
                try
                {
                    bool isPending = false;
                    OSavingsMethods savingsMethod = OSavingsMethods.Cash;

                    int? pendingEventId = null;
                    Teller teller = Teller.CurrentTeller;

                    if (date.Hour == 0 && date.Minute == 0 && date.Second == 0)
                        date = new DateTime(date.Year, date.Month, date.Day, TimeProvider.Now.Hour,
                                            TimeProvider.Now.Minute,
                                            TimeProvider.Now.Second);

                    ISavingsContract savingSimulation = (ISavingsContract) savings.Clone();

                    savingSimulation.LoanDisbursement(loan, date, description, user, disableFees, isPending,
                                                      savingsMethod,
                                                      pendingEventId, teller);

                    List<SavingEvent> events = savings.LoanDisbursement(loan, date, description,
                                                                        user, false, isPending, savingsMethod,
                                                                        pendingEventId, teller);

                    foreach (SavingEvent savingEvent in events)
                    {
                        _ePS.FireEvent(savingEvent, savings, sqlTransaction);
                    }

                    // Change overdraft state
                    if (savings is SavingBookContract)
                    {
                        if (savings.GetBalance() > 0)
                        {
                            ((SavingBookContract) savings).InOverdraft = false;
                            UpdateOverdraftStatus(savings.Id, false);
                        }
                    }

                    sqlTransaction.Commit();
                    return events;
                }
                catch (Exception)
                {
                    sqlTransaction.Rollback();
                    throw;
                }
            }
        }

        public List<SavingEvent> RepayLoanFromSaving(Loan loan,
                                                     RepaymentEvent repaymentEvent, 
                                                     ISavingsContract savingsContract, 
                                                     DateTime date, 
                                                     OCurrency amount, 
                                                     string description, 
                                                     SqlTransaction sqlTransaction)
        {
            if (savingsContract.GetBalance() - amount < 0)
                throw new OpenCbsSavingException(OpenCbsSavingExceptionEnum.WithdrawAmountIsInvalid);

            User user = User.CurrentUser;
            Teller teller = Teller.CurrentTeller;

            if (date.Hour == 0
                && date.Minute == 0
                && date.Second == 0)
            {
                date = new DateTime(date.Year, date.Month, date.Day, TimeProvider.Now.Hour, TimeProvider.Now.Minute,
                                    TimeProvider.Now.Second);
            }

            ISavingsContract savingSimulation = (ISavingsContract) savingsContract.Clone();
            savingSimulation.RepayLoanFromSaving(loan, repaymentEvent.Id, date, amount, description, user, teller);

            List<SavingEvent> events = savingsContract.RepayLoanFromSaving(loan, repaymentEvent.Id, date, amount,
                                                                           description, user, teller);
            foreach (SavingEvent savingEvent in events)
            {
                _ePS.FireEvent(savingEvent, savingsContract, sqlTransaction);
            }

            return events;
        }

        private void SavingServicesAccountAtMaturity(ISavingsContract savingContract, DateTime date, User user)
        {
            if (savingContract.Rollover == OSavingsRollover.None)
                CloseAndTransfer(
                                    savingContract,
                                    savingContract.TransferAccount,
                                    date,
                                    user,
                                    savingContract.GetBalance(date),
                                    true,
                                    Teller.CurrentTeller);

            if (savingContract.Rollover == OSavingsRollover.Principal)
            {
                DateTime lastMaturity = DateCalculationStrategy.GetLastMaturity(date,
                                                                                savingContract.Product.Periodicity,
                                                                                savingContract.NumberOfPeriods);
                OCurrency interests = savingContract.Events.Where(
                    item => item is SavingInterestsPostingEvent && item.Date > lastMaturity && item.Date <= date).
                    Sum(item => item.Amount.Value);
                if (decimal.Parse(interests.GetFormatedValue(savingContract.Product.Currency.UseCents)) == 0m)
                    return;

                // TODO: replace the fee of zero with a meaningful value

                savingContract.Events.AddRange(
                    Transfer(savingContract, savingContract.TransferAccount, date, interests, 0, "Transfer interests", user, true));
            }
        }

        public List<SavingEvent> Deposit(ISavingsContract saving, DateTime dateTime, OCurrency depositAmount,
            string description, User user, bool isPending, OSavingsMethods savingsMethod, int? pendingEventId, Teller teller)
        {
            using (SqlConnection conn = _savingManager.GetConnection())
            using (SqlTransaction sqlTransaction = conn.BeginTransaction())
            {
                try
                {
                    if (!IsDepositAmountCorrect(depositAmount, saving, savingsMethod))
                        throw new OpenCbsSavingException(OpenCbsSavingExceptionEnum.DepositAmountIsInvalid);

                    ISavingsContract savingSimulation = (ISavingsContract) saving.Clone();
                        // Create a fake Saving object

                    // Do deposit to the fake Saving object
                    savingSimulation.Deposit(depositAmount, dateTime, description, user, false, isPending, savingsMethod,
                                             pendingEventId, teller);

                    if (!IsSavingBalanceCorrect(savingSimulation)) // Check balance simulation
                        throw new OpenCbsSavingException(OpenCbsSavingExceptionEnum.BalanceIsInvalid);

                    List<SavingEvent> events = saving.Deposit(depositAmount, dateTime, description, user, false,
                                                              isPending,
                                                              savingsMethod, pendingEventId, teller);

                    foreach (SavingEvent savingEvent in events)
                    {
                        _ePS.FireEvent(savingEvent, saving, sqlTransaction);
                    }

                    // Change overdraft state
                    if (saving is SavingBookContract)
                    {
                        if (saving.GetBalance() > 0)
                        {
                            ((SavingBookContract) saving).InOverdraft = false;
                            UpdateOverdraftStatus(saving.Id, false);
                        }
                    }
                    sqlTransaction.Commit();
                    return events;
                }
                catch (Exception)
                {
                    sqlTransaction.Rollback();
                    throw;
                }
            }
        }

 private static bool IsSavingBalanceCorrect(ISavingsContract pSaving)
 {
     // Check balance simulation
     return ServicesHelper.CheckIfValueBetweenMinAndMax(pSaving.Product.BalanceMin, pSaving.Product.BalanceMax, pSaving.GetBalance());
 }

        private static bool IsCompulsorySavingBalanceOk(ISavingsContract saving, OCurrency amount)
        {
            decimal totalLoansAmount = 0;
            decimal balance = saving.GetBalance().Value;

            foreach (Loan assosiatedLoan in ((SavingBookContract)saving).Loans)
            {
                if (assosiatedLoan.ContractStatus == OContractStatus.Active)
                {
                    if (assosiatedLoan.CompulsorySavingsPercentage != null)
                        totalLoansAmount += (assosiatedLoan.Amount.Value*
                                             ((decimal) assosiatedLoan.CompulsorySavingsPercentage/100));
                }
            }

            if ((balance - amount) < totalLoansAmount)
                 return false;
            return true;
        }

        /// <summary>
        /// Checks DepositAmount and balance simulation
        /// </summary>
        /// <param name="pSaving"></param>
        /// <param name="pDate"></param>
        /// <param name="pWithdrawAmount"></param>
        /// <param name="pDescription"></param>
        /// <param name="pUser"></param>
        /// <returns></returns>
        public List<SavingEvent> Withdraw(ISavingsContract pSaving, DateTime pDate, OCurrency pWithdrawAmount, string pDescription, User pUser, Teller teller)
        {
            ValidateWithdrawal(pWithdrawAmount, pSaving, pDate, pDescription, pUser, teller);

            List<SavingEvent> events = pSaving.Withdraw(pWithdrawAmount, pDate, pDescription, pUser, false, teller);
            using (SqlConnection conn = _savingManager.GetConnection())
            using (SqlTransaction sqlTransaction = conn.BeginTransaction())
            {
                try
                {
                    foreach (SavingEvent savingEvent in events)
                    {
                        _ePS.FireEvent(savingEvent, pSaving, sqlTransaction);
                    }

                    // Charge overdraft fees if the balance is negative
                    if (pSaving is SavingBookContract)
                    {
                        if (pSaving.GetBalance() < 0 && !((SavingBookContract) pSaving).InOverdraft)
                        {
                            SavingEvent overdraftFeeEvent = pSaving.ChargeOverdraftFee(pDate, pUser);
                            _ePS.FireEvent(overdraftFeeEvent, pSaving, sqlTransaction);

                            ((SavingBookContract) pSaving).InOverdraft = true;
                            UpdateOverdraftStatus(pSaving.Id, true);
                        }
                    }

                    sqlTransaction.Commit();
                    return events;
                }
                catch (Exception)
                {
                    sqlTransaction.Rollback();
                    throw;
                }
            }
        }

        public List<SavingEvent> Withdraw(ISavingsContract pSaving, DateTime pDate, OCurrency pWithdrawAmount,
                                          string pDescription, User pUser, Teller teller, SqlTransaction sqlTransaction, PaymentMethod paymentMethod)
        {
            ValidateWithdrawal(pWithdrawAmount, pSaving, pDate, pDescription, pUser, teller, paymentMethod);

            List<SavingEvent> events = pSaving.Withdraw(pWithdrawAmount, pDate, pDescription, pUser, false, teller, paymentMethod);
            foreach (SavingEvent savingEvent in events)
            {
                _ePS.FireEvent(savingEvent, pSaving, sqlTransaction);
            }

            // Charge overdraft fees if the balance is negative
            if (pSaving is SavingBookContract)
            {
                if (pSaving.GetBalance() < 0 && !((SavingBookContract)pSaving).InOverdraft)
                {
                    SavingEvent overdraftFeeEvent = pSaving.ChargeOverdraftFee(pDate, pUser);
                    _ePS.FireEvent(overdraftFeeEvent, pSaving, sqlTransaction);

                    ((SavingBookContract)pSaving).InOverdraft = true;
                    UpdateOverdraftStatus(pSaving.Id, true);
                }
            }

            return events;
        }