Example #1
0
        /// <summary>
        ///     Executes the Use Case.
        /// </summary>
        /// <param name="input">Input Message.</param>
        /// <returns>Task.</returns>
        public async Task Execute(DepositInput input)
        {
            if (input is null)
            {
                this._depositGetAccountsOutputPort
                .WriteError(Messages.InputIsNull);
                return;
            }

            IAccount account = await this._accountRepository
                               .GetAccount(input.AccountId)
                               .ConfigureAwait(false);

            if (account is null)
            {
                this._depositGetAccountsOutputPort
                .NotFound($"The account {input.AccountId.ToGuid()} does not exist or is not processed yet.");
                return;
            }

            ICredit credit = await this._accountService
                             .Deposit(account, input.Amount)
                             .ConfigureAwait(false);

            await this._unitOfWork
            .Save()
            .ConfigureAwait(false);

            this.BuildOutput(credit, account);
        }
        public async Task Execute(DepositInput input)
        {
            IAccount account = await _accountRepository.Get(input.AccountId);

            if (account == null)
            {
                _outputHandler.Error($"The account {input.AccountId} does not exist or is already closed.");
                return;
            }

            ICredit credit = account.Deposit(_entityFactory, input.Amount);

            await _accountRepository.Update(account, credit);

            // Publish the event to the enterprice service bus
            await _serviceBus.PublishEventAsync(new Shared.Events.DepositCompleted()
            {
                AccountId = input.AccountId, Amount = input.Amount.ToMoney().ToDecimal()
            });

            await _unitOfWork.Save();

            DepositOutput output = new DepositOutput(
                credit,
                account.GetCurrentBalance()
                );

            _outputHandler.Default(output);
        }
Example #3
0
        private PaymentInfo PaymentWithBarcode(int paymentType)
        {
            PaymentInfo pi = null;

            switch (paymentType)
            {
            case 0:    //Continue selling
                break;

            case 1:    //Pay with cash
                pi = new CashPaymentInfo();
                break;

            case 2:    //Pay with check
                pi = new CheckPaymentInfo();
                break;

            default:     //between 3 and 9 is credit payment
                ICredit credit = cr.DataConnector.GetCredits()[paymentType - 2];
                if (credit != null)
                {
                    pi = new CreditPaymentInfo(credit);
                }
                else
                {
                    throw new Exception(PosMessage.PAYMENT_INVALID);
                }
                break;
            }

            return(pi);
        }
Example #4
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="DepositOutput" /> class.
 /// </summary>
 /// <param name="credit">Credit object.</param>
 /// <param name="updatedBalance">The updated balance.</param>
 public DepositOutput(
     ICredit credit,
     Money updatedBalance)
 {
     this.Transaction    = credit ?? throw new ArgumentNullException(nameof(credit));
     this.UpdatedBalance = updatedBalance;
 }
Example #5
0
 public CreditPaymentInfo()
 {
     credit          = null;
     amount          = 0;
     installments    = 0;
     this.sequenceNo = -1;
 }
Example #6
0
        public async Task Execute(Input input)
        {
            IAccount originAccount = await _accountRepository.Get(input.OriginAccountId);

            if (originAccount == null)
            {
                _outputHandler.Error($"The account {input.OriginAccountId} does not exist or is already closed.");
                return;
            }

            IAccount destinationAccount = await _accountRepository.Get(input.DestinationAccountId);

            if (destinationAccount == null)
            {
                _outputHandler.Error($"The account {input.DestinationAccountId} does not exist or is already closed.");
                return;
            }

            IDebit  debit  = originAccount.Withdraw(input.Amount);
            ICredit credit = destinationAccount.Deposit(input.Amount);

            await _accountRepository.Update(originAccount, debit);

            await _accountRepository.Update(destinationAccount, credit);

            await _unityOfWork.Save();

            Output output = new Output(
                debit,
                originAccount.GetCurrentBalance(),
                input.OriginAccountId,
                input.DestinationAccountId);

            _outputHandler.Handle(output);
        }
Example #7
0
        public void AskCredit_AmountExceeded()
        {
            IClientManager clientManager  = new ClientManager();
            FinanceManager financeManager = new FinanceManager(clientManager, new EmailSenderMock());

            ShoppingClient.Clients.Clear();
            clientManager.RegisterUser("Marko", "Sinisic", "*****@*****.**", "markos123", "Novi Sad", new DateTime(1990, 5, 25), new List <IAccount>());
            IClient client = ShoppingClient.Clients[0];

            financeManager.CreateAccount("f231rf34f34f3f4", new Bank(), 10000, 0, false);
            IAccount account = FinantialDB.Accounts.Values.ToList()[0];

            financeManager.CreateBank("Raiffeisen", "Cara Lazara 55", new List <ICredit>(), "din", new List <IAccount>()
            {
                account
            }, 1000, 10000, 100);
            IBank bank = FinantialDB.Banks.Values.ToList()[0];

            financeManager.CreateCredit("kredit", 0.05, FinantialDB.Currency["EUR"], bank, 10);
            ICredit credit = FinantialDB.Credits.Values.ToList()[0];

            bank.ListOfCredits.Add(credit);

            Assert.Throws <Exception>(() => financeManager.AskCredit(client.ID, credit.ID, 123, 50000), "Credit amount exceeds bank's maximum credit amount.");
        }
Example #8
0
 public void Show(ICredit credit)
 {
     if ((mode & Target.Cashier) == Target.Cashier)
     {
         touchForm.Show(credit);
     }
 }
Example #9
0
 public async Task Add(IAccount account, ICredit credit)
 {
     this._context.Accounts.Add((Account)account);
     this._context.Credits.Add((Credit)credit);
     await Task.CompletedTask
     .ConfigureAwait(false);
 }
        public async Task Execute(Input input)
        {
            if (input == null)
            {
                _outputHandler.Error("Input is null.");
                return;
            }

            var customer = _entityFactory.NewCustomer(input.SSN, input.Name);
            var account  = _entityFactory.NewAccount(customer.Id);

            ICredit credit = account.Deposit(input.InitialAmount);

            if (credit == null)
            {
                _outputHandler.Error("An error happened when depositing the amount.");
                return;
            }

            customer.Register(account.Id);

            await _customerRepository.Add(customer);

            await _accountRepository.Add(account, credit);

            Output output = new Output(customer, account);

            _outputHandler.Handle(output);
        }
Example #11
0
 public void Show(ICredit credit)
 {
     if ((mode & Target.Customer) == Target.Customer || showCashierMessage)
     {
         customerForm.Show(credit);
     }
 }
Example #12
0
        public async Task Execute(Input input)
        {
            Guid AccountId;
            var  result = CommonAccess.GetAccessAccount(input.AccountId, _accountRepository, _loginUserService).Result.ToString();

            if (!Guid.TryParse(result, out AccountId))
            {
                _outputHandler.Error(result);
                return;
            }
            IAccount account = await _accountRepository.Get(AccountId);

            if (account == null)
            {
                _outputHandler.Error($"The account {input.AccountId} does not exists or is already closed.");
                return;
            }

            ICredit credit = account.Deposit(input.Amount);

            await _accountRepository.Update(account, credit);

            Output output = new Output(
                credit,
                account.GetCurrentBalance());

            _outputHandler.Handle(output);
        }
Example #13
0
        /// <summary>
        ///     ///     Executes the Use Case.
        /// </summary>
        /// <param name="input">Input Message.</param>
        /// <returns>Task.</returns>
        public async Task Execute(DepositInput input)
        {
            if (input is null)
            {
                this._depositOutputPort
                .WriteError(Messages.InputIsNull);
                return;
            }

            IAccount account = await this._accountRepository
                               .GetAccount(input.AccountId)
                               .ConfigureAwait(false);

            if (account is null)
            {
                this._depositOutputPort
                .NotFound(Messages.AccountDoesNotExist);
                return;
            }

            PositiveMoney amountConverted = await this._currencyExchange
                                            .ConvertToUSD(input.Amount)
                                            .ConfigureAwait(false);

            ICredit credit = await this._accountService
                             .Deposit(account, amountConverted)
                             .ConfigureAwait(false);

            await this._unitOfWork
            .Save()
            .ConfigureAwait(false);

            this.BuildOutput(credit, account);
        }
Example #14
0
        public void AskCredit_Success()
        {
            IClientManager clientManager  = new ClientManager();
            FinanceManager financeManager = new FinanceManager(clientManager, new EmailSenderMock());

            ShoppingClient.Clients.Clear();
            clientManager.RegisterUser("Marko", "Sinisic", "*****@*****.**", "markos123", "Novi Sad", new DateTime(1990, 5, 25), new List <IAccount>());
            IClient client = ShoppingClient.Clients[0];

            financeManager.CreateAccount("f231rf34f34f3f4", new Bank(), 10000, 0, true);
            IAccount account = FinantialDB.Accounts.Values.ToList()[0];

            client.ListOfAccounts.Add(account);

            financeManager.CreateBank("Raiffeisen", "Cara Lazara 55", new List <ICredit>(), "din", new List <IAccount>()
            {
                account
            }, 1000, 100000, 100);
            IBank bank = FinantialDB.Banks.Values.ToList()[0];

            financeManager.CreateCredit("kredit", 0.05, FinantialDB.Currency["EUR"], bank, 10);
            ICredit credit = FinantialDB.Credits.Values.ToList()[0];

            bank.ListOfCredits.Add(credit);

            financeManager.AskCredit(client.ID, credit.ID, 20, 50000);

            Assert.IsTrue(account.CreditPayment > 0);
        }
Example #15
0
        private void BuildOutput(ICredit credit, IAccount account)
        {
            var output = new DepositOutput(
                credit,
                account.GetCurrentBalance());

            this._depositOutputPort.Standard(output);
        }
        public T Credit <T>(ICredit credit) where T : IPayment
        {
            var request = _context.Create();

            request.ApiAction = RequestAction.Credit;
            request.Credit(credit);
            return((T)_context.Send(request));
        }
Example #17
0
        public async Task Add(IAccount account, ICredit credit)
        {
            await _context.Accounts.AddAsync((Account)account);

            await _context.Credits.AddAsync((Credit)credit);

            await _context.SaveChangesAsync();
        }
Example #18
0
 public void Show(ICredit credit)
 {
     primaryDisplay.Show(credit);
     foreach (IDisplay d in auxilaryDisplays)
     {
         d.Show(credit);
     }
 }
Example #19
0
 public CardController([FromServices] ICredit credit,
                       [FromServices] IDebit debit,
                       [FromServices] IGetBonusCard getBonusCard)
 {
     _credit       = credit;
     _debit        = debit;
     _getBonusCard = getBonusCard;
 }
Example #20
0
        public static IState ApplyPointDiscount(Decimal discountAmount)
        {
            if (discountAmount == 0)
            {
                discountAmount = cr.Document.PointPrices(cr.Document.Customer.Points);
            }

            if (discountAmount > cr.Document.TotalAmount)
            {
                discountAmount = cr.Document.TotalAmount;
            }

            long usingPoint = cr.Document.PriceToPoint(discountAmount * -1);

            if (Math.Abs(usingPoint) > cr.Document.Customer.Points)
            {
                throw new InvalidProgramException("YETERSÝZ PUAN");
            }

            //cr.Document.AddPoint(usingPoint);
            cr.Document.State = DocumentPaying.Instance();

            CreditPaymentInfo cpi = null;

            List <ICredit> creditList = new List <ICredit>(cr.DataConnector.GetCredits().Values);
            ICredit        crd        = creditList.Find(delegate(ICredit c)
            {
                return(c.IsPointPayment);
            });

            if (crd != null)
            {
                cpi = new CreditPaymentInfo(crd, discountAmount);
            }
            else
            {
                throw new InvalidPaymentException();
            }

            state.Pay((CreditPaymentInfo)cpi);

            if (cr.Document.IsEmpty && cr.Document.TotalAmount == Decimal.Zero)
            {
                return(States.Start.Instance());
            }

            TempPaymentMethod = new CashPaymentInfo();
            input             = new Number();
            //TODO Tell promoserver that the points are used iff document is closed
            //return PayAfterPointDiscount();

            if (cr.Document.TotalAmount == 0m)
            {
                cr.State.Enter();
            }

            return(cr.State);
        }
Example #21
0
        public async Task Update(IAccount account, ICredit credit)
        {
            Domain.Accounts.Account accountOld = this._context.Accounts
                                                 .Where(e => e.Id.Equals(account.Id))
                                                 .SingleOrDefault();

            accountOld = (Domain.Accounts.Account)account;
            await Task.CompletedTask;
        }
Example #22
0
        public async Task Update(IAccount account, ICredit credit)
        {
            Account accountOld = _context.Accounts
                                 .Where(e => e.Id == account.Id)
                                 .SingleOrDefault();

            accountOld = (Account)account;
            await Task.CompletedTask;
        }
Example #23
0
        private void BuildOutput(ICredit credit, IAccount account)
        {
            var output = new DepositOutput(
                credit,
                account.GetCurrentBalance()
                );

            _outputHandler.Standard(output);
        }
Example #24
0
        public IPrinterResponse Pay(Decimal amount, ICredit credit, int installments)
        {
            String label = credit.Name + (installments == 0 ? String.Empty : "/" + installments.ToString());

            guiDocument.AddLines(Formatter.FormatPayment(amount, label));

            WriteCurrentLog("Credit=" + amount);
            return(toResponse);
        }
Example #25
0
        public void AskCredit(Guid clientID, Guid creditID, int years, double amount)
        {
            IClient client = clientManager.GetClientByID(clientID);

            if (client == null)
            {
                throw new KeyNotFoundException();
            }

            var accounts = client.ListOfAccounts;

            if (accounts == null)
            {
                throw new KeyNotFoundException();
            }

            ICredit credit = FinantialDB.Credits.Values.FirstOrDefault(x => x.ID == creditID);

            if (credit == null)
            {
                throw new KeyNotFoundException();
            }

            IAccount account = accounts.FirstOrDefault(x => x.CreditAvailable == true);

            if (account == null)
            {
                emailSender.SendEmail((client as IUser).Email, "Credit declined", "Credit not available on any account.");
                throw new Exception("Credit not available on any account.");
            }

            IBank bank = FinantialDB.Banks.Values.FirstOrDefault(x => x.ListOfCredits.Contains(credit));

            if (bank == null)
            {
                emailSender.SendEmail((client as IUser).Email, "Credit declined", "No bank offers that credit.");
                throw new Exception("No bank offers that credit.");
            }

            if (bank.MaximumCreditYear < years)
            {
                emailSender.SendEmail((client as IUser).Email, "Credit declined", "Payment period too long.");
                throw new Exception("Payment period too long.");
            }

            if (amount > bank.MaximumCreditAmount)
            {
                emailSender.SendEmail((client as IUser).Email, "Credit declined", "Credit amount exceeds bank's maximum credit amount.");
                throw new Exception("Credit amount exceeds bank's maximum credit amount.");
            }

            emailSender.SendEmail((client as IUser).Email, "Credit aproved", "Congratulations. You have succesfully applied for credit.");

            account.Balance += amount;

            account.CreditPayment += amount * 1.05;
        }
        public async Task Execute(Input input)
        {
            if (input == null)
            {
                _outputHandler.Error("Input is null.");
                return;
            }
            var isEmailExist = await _registerUserService.GetEmailUser(input.Email.ToString());

            var isPhoneExist    = _registerUserService.GetMobileUser(input.Mobile.ToString()).Result;
            var isUserNameExist = await _registerUserService.GetNameUser(input.Name.ToString());

            if (isEmailExist != null)
            {
                _outputHandler.Error("Email Already Exist");
            }
            else if (isPhoneExist != null)
            {
                _outputHandler.Error("MobileNumber Already Exist");
            }
            else if (isUserNameExist != null)
            {
                _outputHandler.Error("UserName Already Exist");
            }
            //var customerId = _registerUserService.Execute(input.Name.ToString(), input.Password.ToString()); //add
            //if (customerId == null || customerId == Guid.Empty) //add
            else if (isEmailExist == null && isPhoneExist == null && isUserNameExist == null)
            {
                var registerOutput = _registerUserService.Execute(input.Name.ToString(), input.Password.ToString()
                                                                  , input.Email.ToString(), input.Mobile.ToString());
                if (registerOutput == null)
                {
                    _outputHandler.Error("An error throw when registering user ID"); //add
                    return;                                                          //add
                }

                var customer = _entityFactory.NewCustomer(registerOutput.CustomerId, input.SSN, input.Name);
                var account  = _entityFactory.NewAccount(customer.Id);

                ICredit credit = account.Deposit(input.InitialAmount);
                if (credit == null)
                {
                    _outputHandler.Error("An error happened when depositing the amount.");
                    return;
                }

                customer.Register(account.Id);

                await _customerRepository.Add(customer);

                await _accountRepository.Add(account, credit);

                Output output = new Output(customer, account, registerOutput.Token);
                _outputHandler.Handle(output);
            }
        }
Example #27
0
        /// <summary>
        /// Refunds the transaction that matches the specified transaction id.
        /// </summary>
        /// <param name="transactionId">The transaction id.</param>
        /// <param name="amount">The amount.</param>
        /// <param name="cardNumber">The card number.</param>
        /// <returns></returns>
        public override void Credit(ICredit credit)
        {
            var c = (Credit)credit;

            SetApiAction(RequestAction.Credit);
            Queue(AuthorizeDotNetApi.TransactionId, c.Id);
            Queue(AuthorizeDotNetApi.CreditCardNumber, c.CardNumber);
            Queue(AuthorizeDotNetApi.CreditCardExpiration, c.ExpirationDate);
            Queue(AuthorizeDotNetApi.Amount, c.Amount.ToString());
        }
        public CreditViewModel(ICredit creditStore, IPageService pageService)
        {
            _creditStore = creditStore;
            _pageService = pageService;

            LoadDataCommand = new Command(async() => await LoadData());
            AddCredit       = new Command(async() => await AddCredits());
            SelectCredit    = new Command <CreditTableViewModel>(async c => await SelectCredits(c));
            DeleteCredit    = new Command <CreditTableViewModel>(async c => await DeleteCredits(c));
        }
Example #29
0
        /// <summary>
        ///     Open Checking Account.
        /// </summary>
        /// <param name="customerId">Customer Id.</param>
        /// <param name="amount">Amount.</param>
        /// <returns>IAccount created.</returns>
        public async Task <IAccount> OpenCheckingAccount(CustomerId customerId, PositiveMoney amount)
        {
            IAccount account = this._accountFactory.NewAccount(customerId);
            ICredit  credit  = account.Deposit(this._accountFactory, amount);

            await this._accountRepository.Add(account, credit)
            .ConfigureAwait(false);

            return(account);
        }
Example #30
0
        public bool payCreditBeforeTime(ICredit credit)
        {
            bool isPaid = credit.PayCreditImmediately();

            if (isPaid)
            {
                creditsTaken.Remove(credit);
            }
            return(isPaid);
        }
 public ICredit CreateCredit(int SubscriptionID, ICredit Credit)
 {
     throw new NotImplementedException();
 }
Example #32
0
 public bool IsSmallerThan(ICredit credit)
 {
     return credit.isLargerThan(number);
 }
Example #33
0
 public int compareTo(ICredit credit)
 {
     throw new NotImplementedException();
 }