//============================================================================*
        // AddTransaction()
        //============================================================================*

        public bool AddTransaction(cTransaction Transaction)
        {
            foreach (cTransaction CheckTransaction in this)
            {
                if (CheckTransaction.CompareTo(Transaction) == 0)
                {
                    return(false);
                }
            }

            Add(Transaction);

            return(true);
        }
Example #2
0
        public ActionResult Index(CheckTransaction viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(viewModel));
            }

            string error;

            viewModel.Transactions = HelpersUI.GetTransactionsByCNPAndToken(viewModel.CNP, viewModel.Token, out error);
            if (!string.IsNullOrEmpty(error))
            {
                ViewBag.Message = error;
            }

            return(View(viewModel));
        }
Example #3
0
        public IActionResult CreateCheckTransaction(CreateCheckTransactionViewModel model)
        {
            if (ModelState.IsValid)
            {
                model.AccountGuid = Constants.DefaultAccountGuid;
                long cost = Convert.ToInt64(model.Cost);

                Transaction transaction = new Transaction
                {
                    AccountGuid        = model.AccountGuid,
                    TypeCodeGuid       = model.TypeGuid,
                    StateCodeGuid      = model.StateGuid,
                    Title              = model.Title,
                    Cost               = cost,
                    AccountSide        = model.AccountSide,
                    Description        = model.Description,
                    IsCheckTransaction = true,
                    ReceiptDate        = PersianDateExtensionMethods.ToGeorgianDateTime(model.ReceiptDate)
                };

                CheckTransaction checkTransaction = new CheckTransaction
                {
                    Serial    = model.Serial,
                    IssueDate = PersianDateExtensionMethods.ToGeorgianDateTime(model.IssueDate)
                };

                checkTransaction.Transaction = transaction;

                if (model.AccountGuid.HasValue)
                {
                    if (model.StateGuid == Codes.PassedState)
                    {
                        var account = context.Account
                                      .Where(x => x.AccountGuid == model.AccountGuid)
                                      .SingleOrDefault();

                        if (account == null)
                        {
                            TempData["ToasterState"]   = ToasterState.Error;
                            TempData["ToasterType"]    = ToasterType.Message;
                            TempData["ToasterMessage"] = Messages.CreateTransactionFailedAccountNotValid;

                            return(RedirectToAction("Index"));
                        }

                        account.Credit       = model.TypeGuid == Codes.CreditorType ? account.Credit + cost : account.Credit - cost;
                        account.ModifiedDate = DateTime.Now;

                        var transactionBefore = context.Transaction
                                                .Where(x => !x.IsDelete && x.ReceiptDate < PersianDateExtensionMethods.ToGeorgianDateTime(model.ReceiptDate))
                                                .OrderByDescending(x => x.ReceiptDate)
                                                .FirstOrDefault();

                        if (transactionBefore == null)
                        {
                            transaction.Credit = model.TypeGuid == Codes.CreditorType ? transaction.Credit + cost : transaction.Credit - cost;
                        }
                        else
                        {
                            transaction.Credit = model.TypeGuid == Codes.CreditorType ? transactionBefore.Credit + cost : transactionBefore.Credit - cost;
                        }

                        var transactionsAfter = context.Transaction
                                                .Where(x => !x.IsDelete && x.ReceiptDate > PersianDateExtensionMethods.ToGeorgianDateTime(model.ReceiptDate))
                                                .OrderBy(x => x.ReceiptDate)
                                                .ToList();

                        if (transactionsAfter.Count > 0)
                        {
                            transactionsAfter[0].Credit = transactionsAfter[0].StateCodeGuid == Codes.PassedState ?
                                                          (transactionsAfter[0].TypeCodeGuid == Codes.CreditorType ? transaction.Credit + transactionsAfter[0].Cost : transaction.Credit - transactionsAfter[0].Cost) :
                                                          (transactionsAfter[0].Credit = transaction.Credit);

                            for (int i = 1; i < transactionsAfter.Count; i++)
                            {
                                transactionsAfter[i].Credit = transactionsAfter[i].StateCodeGuid == Codes.PassedState ?
                                                              (transactionsAfter[i].TypeCodeGuid == Codes.CreditorType ? transactionsAfter[i - 1].Credit + transactionsAfter[i].Cost : transactionsAfter[i - 1].Credit - transactionsAfter[i].Cost) :
                                                              (transactionsAfter[i].Credit = transactionsAfter[i - 1].Credit);
                            }
                        }
                    }
                    else
                    {
                        var transactionBefore = context.Transaction
                                                .Where(x => !x.IsDelete && x.ReceiptDate < PersianDateExtensionMethods.ToGeorgianDateTime(model.ReceiptDate))
                                                .OrderByDescending(x => x.ReceiptDate)
                                                .FirstOrDefault();

                        transaction.Credit = transactionBefore == null ? 0 : transactionBefore.Credit;
                    }
                }

                context.Transaction.Add(transaction);
                context.CheckTransaction.Add(checkTransaction);

                if (Convert.ToBoolean(context.SaveChanges() > 0))
                {
                    TempData["ToasterState"]   = ToasterState.Success;
                    TempData["ToasterType"]    = ToasterType.Message;
                    TempData["ToasterMessage"] = Messages.CreateTransactionSuccessful;
                }
                else
                {
                    TempData["ToasterState"]   = ToasterState.Error;
                    TempData["ToasterType"]    = ToasterType.Message;
                    TempData["ToasterMessage"] = Messages.CreateTransactionFailed;
                }

                return(RedirectToAction("Index"));
            }

            return(BadRequest());
        }