public void it_should_produce_a_statement() { var henry = new Customer("Henry"). openAccount(new Account(AccountType.Checking, "checking")). openAccount(new Account(AccountType.Savings, "savings")); henry.deposit("checking", 100.0); henry.withdraw("checking", 80.0); henry.deposit("savings", 4000.0); henry.withdraw("savings", 200.0); var result = new AccountStatement().getStatement(henry.getName(), henry.getAccounts()); Assert.AreEqual("Statement for Henry\n" + "\n" + "Checking Account\n" + " deposit $100.00\n" + " withdrawal $80.00\n" + "Total $20.00\n" + "\n" + "Savings Account\n" + " deposit $4,000.00\n" + " withdrawal $200.00\n" + "Total $3,800.00\n" + "\n" + "Total In All Accounts $3,820.00", result); }
public async Task <AccountStatement> Statement(int accountNumber, StatementDate statementDate) { var accountSummary = await GetAccountSummary(accountNumber); await accountSummary.Validate(accountNumber); var accountTransactionEntity = await _accountTransactionRepository .Get(accountNumber, statementDate.StartDate, statementDate.EndDate); var currency = accountSummary.Balance.Currency; var accountStatement = new AccountStatement() { AccountNumber = accountSummary.AccountNumber, Currency = currency, Date = statementDate, TransactionDetails = accountTransactionEntity.Select(txn => new StatementTransaction() { TransactionType = txn.TransactionType.TryParseEnum <TransactionType>(), Date = txn.Date, Description = txn.Description, Amount = new Money(txn.Amount, currency), CurrentBalance = new Money(txn.CurrentBalance, currency) }) }; return(accountStatement); }
public List <InternalTransferDto> GetAsInternalTransfer(FilterAsTableSelected filter) { List <InternalTransferDto> internalTransferDtos = new List <InternalTransferDto>(); var date = Convert.ToDateTime($"01/{filter.MonthYear.Month.Id}/{filter.MonthYear.Year}"); var dateMin = DateHelper.GetFirstDayOfMonth(date); var dateMax = DateHelper.GetLastDayOfMonth(date); var accountStatements = _accountStatementRepository.GetAsInternalTransfer(filter.User.IdUserGroup, filter.IdAccount, dateMin, dateMax); var asDtos = _mapper.Map <List <AsForTableDto> >(accountStatements); foreach (var asDtoFirst in asDtos) { AsForTableDto asDtoSecond = null; // = new AsForTableDto(); AccountStatement asCouple = _accountStatementRepository.GetAsInternalTransferCouple(filter.User.IdUserGroup, asDtoFirst.Id); if (asCouple != null) { var account = _referentialService.AccountService.GetFullById(asCouple.IdAccount); asCouple.Account = account; asDtoSecond = _mapper.Map <AsForTableDto>(asCouple); } InternalTransferDto internalTransferDto = new InternalTransferDto() { AsFirst = asDtoFirst, AsSecond = asDtoSecond }; internalTransferDtos.Add(internalTransferDto); } return(internalTransferDtos); }
public async Task <IActionResult> Create(AccountStatementViewModel model) { if (ModelState.IsValid) { IFileUpload upload; try { upload = await context.SaveFileUploadAsync(model.Attachment); } catch (Exception ex) { throw new Exception("Failed to save uploaded file. Please upload it again later.", ex); } var statement = new AccountStatement { BankAccountId = model.BankAccountId.Value, FileUploadId = upload.Id, ProcessedAt = DateTimeOffset.Now }; context.AccountStatements.Add(statement); await context.SaveChangesAsync(); statementProcessor.StartProcessing(statement.Id); return(RedirectToAction("Index")); } ViewData["BankAccountId"] = new SelectList(context.BankAccounts, "Id", "Name", model.BankAccountId); return(View(model)); }
public DataSet GetAccountStatementForAccountDetail(AccountStatement prefix1) { Connect(); DataSet dsAccountStatementDetails = null; try { SqlCommand cmd = new SqlCommand("GetAccountStatementForAccountDetail", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@HospitalID", HospitalID); cmd.Parameters.AddWithValue("@LocationID", LocationID); cmd.Parameters.AddWithValue("@FromDate", prefix1.FromDate); cmd.Parameters.AddWithValue("@ToDate", prefix1.ToDate); cmd.Parameters.AddWithValue("@AccountsID", prefix1.AccountsID); con.Open(); SqlDataAdapter da = new SqlDataAdapter(); da.SelectCommand = cmd; dsAccountStatementDetails = new DataSet(); da.Fill(dsAccountStatementDetails); con.Close(); return(dsAccountStatementDetails); } catch (Exception) { return(dsAccountStatementDetails); } }
public DisplayableAccountStatement(AccountStatement x) { SerialNumber = x.SerialNumber; Description = x.Description; Date = x.Date; Credit = x.GetCreditValueOrNull(); Debit = x.GetDebitValueOrNull(); Balance = x.RunningTotaledValue; }
public async Task <IActionResult> DeleteConfirmed(int id) { AccountStatement accountStatement = await context.AccountStatements.SingleAsync(m => m.Id == id); context.AccountStatements.Remove(accountStatement); await context.SaveChangesAsync(); return(RedirectToAction("Index")); }
private async Task UpdateDocument(AccountStatement document) { await _documentRepository.UpdateAsync(document.Key, document); if (_cacheRepository.KeyExistsAsync(document.Key).Result) { await _cacheRepository.SetAsync(document.Key, document, TimeSpan.FromSeconds(_cacheExpiryInSeconds)); } }
public ActionResult DuePayments() // Forfallsoversikt { //Session["LoggedIn"] = true; // TODO: REMEMBER TO COMMENT OUT. ONLY USED DURING TESTING PHASE //Session["UserId"] = "01018912345"; // TODO: REMEMBER TO COMMENT OUT. ONLY USED DURING TESTING PHASE if (Session["LoggedIn"] != null) { bool loggedIn = (bool)Session["LoggedIn"]; if (!loggedIn) { return(RedirectToAction("LoginBirth", "Home", new { area = "" })); } if (!ModelState.IsValid) { return(View()); } string userBirthNo = Session["UserId"] as string; // Get accounts to user: List <Account> accounts = bankService.getAccountsByBirthNo(userBirthNo); var model = new AccountStatement(); var accountViewModels = new List <AccountViewModel>(); // Populate AccountViewModel list with accounts: foreach (var a in accounts) { AccountViewModel viewModel = new AccountViewModel() { Type = a.Type, AccountNo = a.AccountNo, Balance = a.Balance }; accountViewModels.Add(viewModel); } // Set initial dates for the datepickers: DateTime currDatePlusOne = DateTime.Today.AddDays(1); // Current day plus one DateTime oneMonthAgo = DateTime.Today.AddMonths(-1); // Date one month ago at 0:00am var duePayments = new DuePayments() { Accounts = accountViewModels, fromDate = oneMonthAgo, toDate = currDatePlusOne }; return(View(duePayments)); } else { return(RedirectToAction("LoginBirth", "Home", new { area = "" })); } }
public string GetAccountStatement(Stream Parameterdetails) { string JsonStringForSerialized = ""; try { AccountStatement objAccountStatement = new AccountStatement(); JsonStringForSerialized = objAccountStatement.GetAccountStatement(Parameterdetails); } catch { } return(JsonStringForSerialized); }
public async Task <IActionResult> Edit(AccountStatement accountStatement) { if (ModelState.IsValid) { context.Update(accountStatement); await context.SaveChangesAsync(); return(RedirectToAction("Index")); } ViewData["BankAccountId"] = new SelectList(context.BankAccounts, "Id", "BankAccount", accountStatement.BankAccountId); ViewData["FileUploadId"] = new SelectList(context.FileUploads, "Id", "FileUpload", accountStatement.FileUploadId); return(View(accountStatement)); }
public JsonResult LoadGrid(string sidx, string sord, int rows, int page = 1) { string getSearchby = Request["_searchby"]; string getVal = Request["_val"]; string getStartDate = Request["_startDate"]; string getEndDate = Request["_endDate"]; Params param = new Params() { Parameter = new Dictionary <string, string>() }; param.RequestTransType = "AccountStatement"; param.Parameter.Add("acctNo", getVal); param.Parameter.Add("startDate", getStartDate.Replace("/", "").Trim()); param.Parameter.Add("endDate", getEndDate.Replace("/", "").Trim()); AllChannelTransaction data = AccountStatement.Mutasi(param, Session["isSuperAdmin"].ToString()); var trx = data.Transactions.ToList().Select(x => new { Number = x.Number, displayTransactionDate = x.displayTransactionDate, TransactionDate = x.TransactionDate, TransactionType = x.TransactionType, TransactionDescription = x.TransactionDescription, Branch = x.Branch, Amount = x.Amount }); int pageIndex = Convert.ToInt32(page) - 1; int pageSize = rows; int totalRecords = trx.Count(); int totalPages = (int)Math.Ceiling((float)totalRecords / (float)pageSize); trx = trx.Skip((page - 1) * pageSize).Take(pageSize); var recordCount = trx.Count(); JSONTable jTable = new JSONTable(); jTable.total = totalPages; jTable.page = page; jTable.records = totalRecords; jTable.rows = trx.ToArray(); string restricted = "Y".Equals(Session["isSuperAdmin"].ToString())? string.Empty : data.RestrictedAccount ? "Restricted Account" : string.Empty; jTable.additional = data.Name + "<@z>" + data.Currency + "<@z>" + restricted; return(Json(jTable, JsonRequestBehavior.AllowGet)); }
/// <exception cref="GPClientException"></exception> public byte[] GetStatement(AccountStatement accountStatement) { var restRequest = CreateRestRequest(@"/accounts/account-statement", "application/json"); var jsonData = serializeToJson(accountStatement); restRequest.AddParameter("application/json", jsonData, ParameterType.RequestBody); var response = Client.Execute(restRequest); string content = response.Content.ToString(); if (content.Contains("error_code")) { Deserialize <APIError>(content); } return(System.Text.Encoding.UTF8.GetBytes(content)); }
public void BalanceStatementsShouldBeImmutable() { DateTime today = DateTime.Now; var firstStatement = new AccountStatement(today, 100, 100); var secondStatement = new AccountStatement(today, 100, 100); List <AccountStatement> statements = new List <AccountStatement> { firstStatement, secondStatement }; var balance = new Balance(statements); var currentStatements = balance.GetAccountStatements(); currentStatements.RemoveAt(0); Check.That(statements.Count).IsEqualTo(2); }
// GET: AccountStatements/Details/5 public async Task <IActionResult> Details(int?id) { if (id == null) { return(HttpNotFound()); } AccountStatement accountStatement = await context.AccountStatements.SingleAsync(m => m.Id == id); if (accountStatement == null) { return(HttpNotFound()); } return(View(accountStatement)); }
public string ValidateAccountStatement(AccountStatement accountStatement) { if (accountStatement.StartBalance.Currency != accountStatement.EndBalance.Currency) { return($"Startbalance currency ({accountStatement.StartBalance.Currency}) does not match endbalance currency ({accountStatement.EndBalance.Currency})"); } var transactionSum = Math.Round(accountStatement.Transactions.Sum(t => t.Value), 2); var end = accountStatement.StartBalance.Value + transactionSum; if (end != accountStatement.EndBalance.Value) { return($"Enbalance ({accountStatement.EndBalance.Value}) does not match startbalance ({accountStatement.StartBalance.Value}) + transactions ({transactionSum})"); } return(string.Empty); }
// GET: AccountStatements/Edit/5 public async Task <IActionResult> Edit(int?id) { if (id == null) { return(HttpNotFound()); } AccountStatement accountStatement = await context.AccountStatements.SingleAsync(m => m.Id == id); if (accountStatement == null) { return(HttpNotFound()); } ViewData["BankAccountId"] = new SelectList(context.BankAccounts, "Id", "BankAccount", accountStatement.BankAccountId); ViewData["FileUploadId"] = new SelectList(context.FileUploads, "Id", "FileUpload", accountStatement.FileUploadId); return(View(accountStatement)); }
public ActionResult AccountName(string prefix) { BL_AccountStatement objAcc = new BL_AccountStatement(); List <AccountStatement> searchlist = new List <AccountStatement>(); DataSet ds = objAcc.BindAccountStatement(prefix); int i = 0; foreach (DataRow dr in ds.Tables[0].Rows) { AccountStatement AccStat = new AccountStatement(); AccStat.AccountsID = dr["AccountsID"].ToString(); AccStat.AccountName = dr["AccountName"].ToString(); searchlist.Add(AccStat); } return(new JsonResult { Data = searchlist, JsonRequestBehavior = JsonRequestBehavior.AllowGet }); }
public static string GetRedboxAccountStatementPayload(AccountStatement accountstatement) { string channel = ConfigurationManager.AppSettings["channel"]; string payload = ""; Random reqTranId = new Random(); try { payload = "<soapenv:Envelope xmlns: soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns: soap =\"http://soap.request.manager.redbox.stanbic.com/\">" + "<soapenv:Header/>" + "<soapenv:Body>" + "<soap:request>" + "<channel>" + channel + "</channel>" + "<type>ACCOUNT_STATEMENT</type>" + "<customerId>" + accountstatement.CustomerId + "</customerId>" + "<customerIdType>" + accountstatement.CustomerIdType + "</customerIdType>" + "<submissionTime>" + accountstatement.SubmissionTime + "</submissionTime>" + "<reqTranId>" + reqTranId.Next(100000, 999999) + "</reqTranId>" + "<body>" + "<![CDATA[" + "<otherRequestDetails>" + "<sessionId>" + accountstatement.SessionId + "</sessionId>" + "<accountNumber>" + accountstatement.AccountNumber + "</accountNumber>" + "<startDate>" + accountstatement.StartDate + "</startDate>" + "<endDate>" + accountstatement.EndDate + "</endDate>" + "<fileType>" + accountstatement.FileType + "</fileType>" + "<passId>" + accountstatement.PassId + "</passId>" + "<passIdType>" + accountstatement.PassIdType + "</passIdType>" + "<passCodeType>" + accountstatement.PassCodeType + "</passCodeType>" + "<passCode>" + accountstatement.PassCode + "</passCode>" + "</otherRequestDetails>" + "]]>" + "</body>" + "</soap:request>" + "</soapenv:Body>"; } catch { throw; } return(payload); }
public ActionResult Overview() // Total oversikt { if (Session["LoggedIn"] != null) { string birthID = Session["UserId"] as string; List <Account> accounts = bankService.getAccountsByBirthNo(birthID); var model = new AccountStatement(); var accountViewModels = new List <AccountViewModel>(); // Populate AccountViewModel list with accounts: foreach (var a in accounts) { AccountViewModel viewModel = new AccountViewModel() { Type = a.Type, AccountNo = a.AccountNo, Balance = a.Balance, Name = a.Name }; accountViewModels.Add(viewModel); } var accountStatement = new AccountStatement() { Accounts = accountViewModels, }; bool loggedIn = (bool)Session["LoggedIn"]; if (!loggedIn) { return(RedirectToAction("LoginBirth", "Home", new { area = "" })); } else { var kundeDb = new BankService(); Customer enKunde = kundeDb.getCustomerByBirthNo(birthID); List <Account> alleKonto = kundeDb.getAccountsByBirthNo(birthID); return(View(accountStatement)); } } return(RedirectToAction("LoginBirth", "Home", new { area = "" })); }
public void GPConnectorTestStatementGenerating() { var connector = new GPConnector(TestUtils.API_URL, TestUtils.CLIENT_ID, TestUtils.CLIENT_SECRET); var accountStatement = new AccountStatement { DateFrom = new DateTime(2017, 1, 1), DateTo = new DateTime(2017, 2, 27), GoID = TestUtils.GOID, Currency = Currency.CZK, Format = StatementGeneratingFormat.CSV_A }; try { var statement = connector.GetAppToken().GetStatement(accountStatement); Assert.NotNull(statement); var content = Encoding.UTF8.GetString(statement); Console.WriteLine("Content of Array to string: {0}", content); Console.WriteLine( "----------------------------------------------------------------------------------------"); Console.Write("Byte content: "); for (var i = 0; i < statement.Length; i++) { Console.Write(" {0}", statement[i]); } } catch (GPClientException ex) { Console.WriteLine("Generating account statement ERROR"); var err = ex.Error; var date = err.DateIssued; foreach (var element in err.ErrorMessages) { // } } }
static void Main(string[] args) { ApiExplorer explorer = new ApiExplorer("YOUR_TOKEN_MUST_BE_PRESENT_HERE"); // get new transactions from last check AccountStatement newTransactions = explorer.Last(); // change last check date explorer.SetLastDownloadDate(DateTime.UtcNow.AddMonths(-1)); // get account statement AccountStatement statement = explorer.Periods(TransactionFilter.LastMonth()); // browse transactions foreach (var transaction in statement.TransactionList.Transactions) { Console.WriteLine(transaction + " - " + transaction.Amount.Value); } // get data in specific format string data = explorer.Periods(TransactionFilter.LastDays(10), Format.Html); }
protected override async Task <AccountStatement> ProcessAsync(ICommand command) { var qMessage = (StatementMessage)command; var monthlyStatement = await _transactionClient.GetStatement(qMessage.AccountNumber, qMessage.Month); var statementDate = new StatementDate(qMessage.Month); const string DateFormat = "dd/MM/yyyy"; var accountStatement = new AccountStatement() { Key = $"{monthlyStatement.AccountNumber}-{qMessage.Month}", Name = qMessage.Name, AccountNumber = monthlyStatement.AccountNumber, Currency = qMessage.Currency, StartDate = statementDate.StartDate.ToString(DateFormat), EndDate = statementDate.EndDate.ToString(DateFormat), // Logic used here to calculate opening & closing balance is not accurate and needs improvement OpeningBalance = monthlyStatement.TransactionDetails.OrderBy(i => i.Date).Select(i => i.CurrentBalance).FirstOrDefault(), ClosingBalance = monthlyStatement.TransactionDetails.OrderByDescending(i => i.Date).Select(i => i.TransactionType == TransactionType.Deposit.ToString() ? (i.CurrentBalance + i.Amount) : (i.CurrentBalance - i.Amount) ).FirstOrDefault(), TransactionDetails = monthlyStatement.TransactionDetails.Select(i => new AccountTransaction() { Date = i.Date.ToString(DateFormat), TransactionDetail = i.Description, Withdrawal = i.TransactionType == TransactionType.Withdrawal.ToString() ? i.Amount.ToString() : string.Empty, Deposit = i.TransactionType == TransactionType.Deposit.ToString() ? i.Amount.ToString() : string.Empty, Balance = i.TransactionType == TransactionType.Deposit.ToString() ? (i.CurrentBalance + i.Amount) : (i.CurrentBalance - i.Amount) }) }; return(accountStatement); }
public string ValidateAccountStatement(AccountStatement accountStatement) { if (accountStatement.StartBalance.Currency != accountStatement.EndBalance.Currency) { return($"Startbalance currency ({accountStatement.StartBalance.Currency}) does not match endbalance currency ({accountStatement.EndBalance.Currency})"); } if (accountStatement.CreditTransactionSummary != null && accountStatement.DebitTransactionSummary != null) { var transactionSum = Math.Round(accountStatement.Transactions.Sum(t => (decimal)t.Value), 2); var totalNumber = accountStatement.Transactions.Count; var transactionSumValidation = accountStatement.CreditTransactionSummary.Sum - accountStatement.DebitTransactionSummary.Sum; var totalNumberValidation = accountStatement.CreditTransactionSummary.NumberOfTransaction + accountStatement.DebitTransactionSummary.NumberOfTransaction; if (transactionSum != transactionSumValidation) { return($"Transaction sum ({transactionSum}) does not match validation sum ({transactionSumValidation})"); } if (totalNumber != totalNumberValidation) { return($"Transaction count ({totalNumber}) does not match validation count ({totalNumberValidation})"); } } else if (accountStatement.StartBalance != null && accountStatement.EndBalance != null) { var transactionSum = Math.Round(accountStatement.Transactions.Sum(t => t.Value), 2); var end = accountStatement.StartBalance.Value + transactionSum; if (end != accountStatement.EndBalance.Value) { return($"Enbalance ({accountStatement.EndBalance.Value}) does not match startbalance ({accountStatement.StartBalance.Value}) + transactions ({transactionSum})"); } } return(string.Empty); }
public async Task <ActionResult> TenDollarPromo() { try { var accountStatement = new AccountStatementRepository(); var promo = new AccountStatement { User = User.Identity.Name, Credit = 10, CurrentBalance = 10, TransactionDate = Helper.SetDateForMongo(DateTime.Now), Description = "Early adopter $10 promo" }; accountStatement.Create(promo); return(Json(new { success = true, responseText = "Added." }, JsonRequestBehavior.AllowGet)); } catch (Exception ex) { Response.StatusCode = (int)HttpStatusCode.InternalServerError; return(Json(new { success = false, responseText = ex.Message }, JsonRequestBehavior.AllowGet)); } }
public IHttpActionResult AccountStatement([FromBody] AccountStatement accountStatement) { try { //accountStatement.startDate = new DateTime.Now(); if (!ModelState.IsValid) { return(BadRequest("Invalid data.")); } string accountStatementReq = App.GetRedboxAccountStatementPayload(accountStatement); string accountStatementRes = App.CallRedbox(accountStatementReq); LogWorker logworker = new LogWorker("AccountStatementController", "AccountStatement", "Ok"); return(Ok(accountStatementRes)); } catch (Exception ex) { LogWorker logworker = new LogWorker("AccountStatementController", "AccountStatement", ex.ToString()); return(InternalServerError()); } }
public AccountStatementResult(AccountStatement accountStatement, string error) { AccountStatement = accountStatement; Error = error; IsSuccess = string.IsNullOrEmpty(error); }
private List <AccountStatement> GetAccountStement(List <UserTransaction> lstTransaction, User LoginUser) { List <AccountStatement> lstAccountStatement = new List <AccountStatement>(); if (lstTransaction != null && lstTransaction.Count > 0) { ViewBag.AccountBalance = lstTransaction.Sum(ut => ut.TransactionAmount); foreach (UserTransaction tran in lstTransaction) { AccountStatement statement = new AccountStatement(); if (tran.TransactionMode == TransactionMode.ADDFUND) { statement.PaymentAmount = tran.TransactionAmount; statement.OrderDetailID = 0; statement.InvoiceID = 0; statement.TransactionDate = tran.AuditDetails.DateCreated; if (tran.PaymentID != null && tran.PaymentID > 0) { statement.TransactionDetail = "Fund Added By " + LoginUser.FirstName + " " + LoginUser.LastName; statement.PaymentMode = tran.Payment.PaymentMode; } else { statement.TransactionDetail = "Fund Added By Admin" + "<br />" + tran.ReceipientInstrumentDetails; statement.PaymentMode = null; } statement.TransactionMode = TransactionMode.ADDFUND; statement.UserTransactionID = tran.ID; } else if (tran.TransactionMode == TransactionMode.REFUND) { statement.PaymentAmount = tran.TransactionAmount; statement.OrderDetailID = 0; statement.InvoiceID = 0; statement.TransactionDate = tran.AuditDetails.DateCreated; statement.TransactionDetail = "Credit given against cancelled order #" + InvoicePrefix + tran.OrderDetail.OrderID; statement.TransactionMode = TransactionMode.REFUND; statement.UserTransactionID = tran.ID; } else if (tran.TransactionMode == TransactionMode.ORDER) { if (lstAccountStatement.Where(ut => ut.OrderDetailID == tran.OrderDetailID).FirstOrDefault() == null) { statement.OrderDetailID = Convert.ToInt32(tran.OrderDetailID); statement.InvoiceID = tran.OrderDetail.OrderID; statement.TransactionDate = tran.AuditDetails.DateCreated; statement.TransactionDetail = "Order Placed for #" + InvoicePrefix + tran.OrderDetail.OrderID; statement.TransactionMode = TransactionMode.ORDER; statement.UserTransactionID = tran.ID; int ordCount = lstTransaction.Select(ut => ut.OrderDetailID == tran.OrderDetailID).Count(); UserTransaction ordCredit = lstTransaction.Where(ut => (ut.PaymentID ?? 0) <= 0 && ut.OrderDetailID == tran.OrderDetailID).FirstOrDefault(); UserTransaction ordPayment = lstTransaction.Where(ut => (ut.PaymentID ?? 0) > 0 && ut.OrderDetailID == tran.OrderDetailID).FirstOrDefault(); if (ordPayment != null) { statement.PaymentMode = ordPayment.Payment.PaymentMode; statement.PaymentAmount = (ordCredit != null ? ordPayment.OrderDetail.Price + ordCredit.TransactionAmount : ordPayment.OrderDetail.Price); } if (ordCredit != null) { statement.CreditAmount = ordCredit.TransactionAmount * -1; } } } else if (tran.TransactionMode == TransactionMode.REISSUE) { statement.PaymentAmount = tran.TransactionAmount * -1; statement.OrderDetailID = 0; statement.InvoiceID = 0; statement.TransactionDate = tran.AuditDetails.DateCreated; statement.TransactionDetail = tran.ReceipientInstrumentDetails; statement.TransactionMode = TransactionMode.REISSUE; statement.UserTransactionID = tran.ID; } if (statement.UserTransactionID > 0) { lstAccountStatement.Add(statement); } } } else { ViewBag.AccountBalance = 0; } return(lstAccountStatement); }
public List <AccountStatement> ReadFile(string filePath, Encoding encoding) { var accountStatements = new List <AccountStatement>(); var serializer = new XmlSerializer(typeof(Document)); using (var fileStream = new FileStream(filePath, FileMode.Open)) { using (var reader = new StreamReader(fileStream, encoding)) { var document = (Document)serializer.Deserialize(reader); foreach (var stmt in document.BkToCstmrStmt.Stmt) { var accountStatement = new AccountStatement(); accountStatements.Add(accountStatement); accountStatement.AccountNumber = stmt.Acct.Id.Item.ToString(); accountStatement.Currency = stmt.Acct.Ccy; foreach (var balance in stmt.Bal) { // var balanceAmount = balance.Amt.Value; // var balanceCurrency = balance.Amt.Ccy; // var balanceDate = balance.Dt.Item; // var creditDebit = balance.CdtDbtInd; var balanceType = (BalanceType12Code)balance.Tp.CdOrPrtry.Item; if (balanceType == BalanceType12Code.OPBD) { accountStatement.StartBalance = new Balance { BookingDate = balance.Dt.Item, Value = (double)balance.Amt.Value, }; } else if (balanceType == BalanceType12Code.CLBD) { accountStatement.EndBalance = new Balance { BookingDate = balance.Dt.Item, Value = (double)balance.Amt.Value, }; } } if (stmt.TxsSummry != null) { if (stmt.TxsSummry.TtlCdtNtries != null) { accountStatement.CreditTransactionSummary = new TransactionSummary { NumberOfTransaction = int.Parse(stmt.TxsSummry.TtlCdtNtries.NbOfNtries), Sum = stmt.TxsSummry.TtlCdtNtries.Sum }; } else { accountStatement.CreditTransactionSummary = new TransactionSummary(); } if (stmt.TxsSummry.TtlDbtNtries != null) { accountStatement.DebitTransactionSummary = new TransactionSummary { NumberOfTransaction = int.Parse(stmt.TxsSummry.TtlDbtNtries.NbOfNtries), Sum = stmt.TxsSummry.TtlDbtNtries.Sum }; } else { accountStatement.DebitTransactionSummary = new TransactionSummary(); } } accountStatement.Transactions = new List <Transaction>(); if (stmt.Ntry != null) { foreach (var entry in stmt.Ntry) { (var text, var debtor, var creditor) = ParseEntry(entry); var transaction = new Transaction(); transaction.Id = stmt.Id + entry.NtryRef; transaction.BookingDate = entry.BookgDt.Item; transaction.Text = text; transaction.Debtor = debtor; transaction.Creditor = creditor; transaction.Value = (double)entry.Amt.Value; transaction.ValueDate = entry.ValDt.Item; if (entry.CdtDbtInd == CreditDebitCode.DBIT) { transaction.Value *= -1; } accountStatement.Transactions.Add(transaction); } } } } } return(accountStatements); }
private string GetPreviosBalance(AccountStatement accountStatements) { if (accountStatements != null) { var prevBalance = accountStatements.PrevBalance; var accountStatementCurrency = accountStatements.Currency.ConvertToCurrencyDto(); return string.Format("{0}{1} ", accountStatementCurrency.CurrencySymbol, prevBalance); } return string.Empty; }
public List <AccountStatement> ReadFile(string filePath, Encoding encoding) { var accountList = new List <AccountStatement>(); AccountStatement account = null; Transaction currentTransaction = null; List <string> transactionTexts = null; foreach (var line in File.ReadLines(filePath, encoding)) { if (line.Length < 3) { continue; } var codeValue = ParseLine(line); switch (codeValue.Item1) { // Account case ":25:": account = new AccountStatement(); accountList.Add(account); account.AccountNumber = codeValue.Item2; break; // Start balance case ":60F:": account.StartBalance = ParseBalance(codeValue.Item2); break; // End balance case ":62F:": account.EndBalance = ParseBalance(codeValue.Item2); break; // Transaction case ":61:": // have we an old transaction if (currentTransaction != null && transactionTexts.Any()) { currentTransaction.Text = string.Join(", ", transactionTexts); } transactionTexts = new List <string>(); currentTransaction = ParseTransaction(codeValue.Item2); account.Transactions.Add(currentTransaction); break; // Transaction text case ":NS:": //if (currentTransaction != null) currentTransaction.Text = codeValue.Item2; break; } if (codeValue.Item1.IndexOf(':') == -1 && currentTransaction != null) { if (transactionTexts.Contains(codeValue.Item2) == false) { transactionTexts.Add(codeValue.Item2); } } } // have we an old transaction if (currentTransaction != null && transactionTexts.Any()) { currentTransaction.Text = string.Join(", ", transactionTexts); } return(accountList); }
private string GetAccountStatementItemString(AccountStatement accountStatement, EntityDto[] entities) { var itemIdAndName = accountStatement.GetItemIdAndName(); var entityName = accountStatement.GetEntityName(entities); var isCoupon = accountStatement.Coupon != null; var itemString = string.Empty; if (isCoupon) { var coupon = accountStatement.Coupon; var idAndName = coupon.GetCouponItemIdAndName(); var couponItemEntityName = coupon.GetItemEntityName(entities); var sb = new StringBuilder(); sb.AppendFormat("{0} {1}", entityName, itemIdAndName.Key); sb.AppendFormat(" {0} {1} {2} {3}", MyMentorResources.itemFor, couponItemEntityName, idAndName.Value, idAndName.Key); itemString = sb.ToString(); } else { itemString = string.Format("{0} {1} {2}", entityName, itemIdAndName.Key, itemIdAndName.Value); } return itemString; }