public async Task <IActionResult> Create(VirtualAccountForm virtualAccount)
        {
            var viewModel = new VirtualAccountViewModel()
            {
                VirtualAccounts = new List <VirtualAccountModel>()
            };

            try
            {
                await _virtualAccountService.Create(virtualAccount);

                var virtualAccs = await _virtualAccountService.GetAll(virtualAccount.BankAccountId);

                var virtualAcc = virtualAccs.FirstOrDefault();
                if (virtualAcc == null)
                {
                    return(RedirectToAction("Index", "BankAccount", new { area = "BankAccount" }));
                }
                viewModel.SelectedVirtualAccount = await _virtualAccountService.Get(virtualAcc.Id);

                viewModel.VirtualAccounts = virtualAccs;
            }
            catch (Exception e)
            {
                viewModel.Error = new Shared.Models.GackoError(e);
            }
            return(RedirectToAction("Index", "VirtualAccount", new { bankAccountId = virtualAccount.BankAccountId, area = "VirtualAccount" }));

            return(View("Index", viewModel));
        }
        public IActionResult Create(int bankAccountId)
        {
            var bankAccountViewModel = new VirtualAccountForm()
            {
                BankAccountId = bankAccountId
            };

            return(View("Create", bankAccountViewModel));
        }
        public IActionResult Update(int bankAccountId, int virtualAccountId)
        {
            var bankAccountViewModel = new VirtualAccountForm()
            {
                Id            = virtualAccountId,
                BankAccountId = bankAccountId
            };

            return(View("Update", bankAccountViewModel));
        }
        public async void IsVirtualAccountCreatePossible()
        {
            var form = new VirtualAccountForm()
            {
                Name                = "",
                Balance             = 50.01,
                Limit               = 70,
                BankAccountId       = 1,
                NotificationBalance = 20.02
            };
            var result = await _virtualAccountService.Create(form);

            Assert.NotEqual(0, result);
        }
Example #5
0
        public async Task <int> Create(VirtualAccountForm form)
        {
            try
            {
                var newEntity    = _mapper.Map <DaoVirtualAccount>(form);
                var createdEntry = _context.VirtualAccounts.Add(newEntity);
                await _context.SaveChangesAsync();

                return(createdEntry.Entity.Id);
            }
            catch (Exception e)
            {
                throw new RepositoryException(typeof(DaoVirtualAccount).Name, eRepositoryExceptionType.Create);
            }
        }
Example #6
0
        public async Task <int> Update(VirtualAccountForm form)
        {
            try
            {
                var updateEntity = this._mapper.Map <DaoVirtualAccount>(form);

                var updated = await _context.VirtualAccounts.FirstOrDefaultAsync(_ => _.Id == updateEntity.Id);

                _context.Entry(updated).CurrentValues.SetValues(updateEntity);

                await _context.SaveChangesAsync();

                return(updated.Id);
            }
            catch (Exception e)
            {
                throw new RepositoryException(typeof(DaoVirtualAccount).Name, eRepositoryExceptionType.Update);
            }
        }
        public async Task <IActionResult> Index(int bankAccountId)
        {
            var viewModel = new VirtualAccountViewModel()
            {
                VirtualAccounts = new List <VirtualAccountModel>()
            };

            try
            {
                var virtualAccs = await _virtualAccountService.GetAll(bankAccountId);

                var virtualAcc = virtualAccs.FirstOrDefault();
                if (virtualAcc == null)
                {
                    var bankAccountViewModel = new VirtualAccountForm()
                    {
                        BankAccountId = bankAccountId
                    };
                    return(View("Create", bankAccountViewModel));
                }
                viewModel.SelectedVirtualAccount = await _virtualAccountService.Get(virtualAcc.Id);

                viewModel.VirtualAccounts = virtualAccs;
            }
            catch (Exception e)
            {
                viewModel.Error = new Shared.Models.GackoError(e);
            }

            viewModel.SelectedVirtualAccount.Expenses = await _expenseService.GetAll(viewModel.SelectedVirtualAccount.Id);

            viewModel.expSum = viewModel.SelectedVirtualAccount.Expenses != null?viewModel.SelectedVirtualAccount.Expenses.Sum(_ => _.Amount) : (0.00);

            viewModel.SelectedVirtualAccount.Subscriptions = await _subscriptionService.GetAll(viewModel.SelectedVirtualAccount.Id);

            viewModel.subSum = viewModel.SelectedVirtualAccount.Subscriptions != null?viewModel.SelectedVirtualAccount.Subscriptions.Sum(_ => _.Amount) : (0.00);

            return(View("Index", viewModel));
        }
        public async Task <IActionResult> Update(VirtualAccountForm virtualAccount)
        {
            var viewModel = new VirtualAccountViewModel()
            {
                VirtualAccounts = new List <VirtualAccountModel>()
            };

            try
            {
                await _virtualAccountService.Update(virtualAccount);

                if (virtualAccount.Id != null)
                {
                    int virtualAccountId = (int)virtualAccount.Id;
                    viewModel.SelectedVirtualAccount = await _virtualAccountService.Get(virtualAccountId);
                }
                viewModel.VirtualAccounts = await _virtualAccountService.GetAll(virtualAccount.BankAccountId);
            }
            catch (Exception e)
            {
                viewModel.Error = new Shared.Models.GackoError(e);
            }
            return(RedirectToAction("Index", "VirtualAccount", new { bankAccountId = virtualAccount.BankAccountId, area = "VirtualAccount" }));
        }
Example #9
0
 public async Task <int> Update(VirtualAccountForm form)
 {
     return(await _virtualAccountRepository.Update(form));
 }