public async Task <ActionResult> PostBudgets(ExpenseService.DataAccess.Model.Budgets budgets)
        {
            var newBudgets = Mapper.MapBudgets(budgets);

            _ = _repo.AddBudgetAsync(newBudgets);

            await _repo.SaveAsync();

            return(CreatedAtAction("GetBudgets", new { id = budgets.Id }, budgets));
        }
        public async Task <Guid> Handle(CreateNewBudgetForProjectCommand command, CancellationToken cancellationToken)
        {
            var budgetId = Guid.NewGuid();

            _logger.LogInformation("Adding new budget {budgetId} for {projectId}", budgetId, command.ProjectId);

            var budget = new Budget(
                budgetId,
                command.ProjectId);

            await _budgetRepository.AddBudgetAsync(budget);

            await _budgetRepository.SaveChangesAsync(cancellationToken);

            return(budgetId);
        }
Esempio n. 3
0
        protected override async Task Execute(CreateUserModel parameter, ClaimsPrincipal principal, CancellationToken cancellationToken)
        {
            var userExists = await _userRepository.ExistsAsync(parameter.Email);

            if (userExists)
            {
                throw new OperationErrorException(StatusCodes.Status409Conflict);
            }

            if (string.IsNullOrWhiteSpace(parameter.FirstName) || string.IsNullOrWhiteSpace(parameter.LastName))
            {
                throw new OperationErrorException(StatusCodes.Status400BadRequest);
            }

            var user = new User
            {
                FirstName  = parameter.FirstName.Trim(),
                LastName   = parameter.LastName.Trim(),
                Username   = parameter.Email,
                IsAdmin    = parameter.IsAdmin,
                IsSuperior = parameter.IsSuperior,
                IsViewer   = parameter.IsViewer,
                SuperiorId = parameter.Superior,
                State      = parameter.State
            };

            await _userRepository.AddUserAsync(user);

            if (parameter.State == UserState.Active)
            {
                var budget = new Budget
                {
                    UserId = user.Id,
                    User   = user,
                    Amount = parameter.Amount,
                    Year   = parameter.Year
                };
                await _budgetRepository.AddBudgetAsync(budget);
            }

            await _unitOfWork.SaveChanges(cancellationToken);
        }
        public async Task <ActionResult> PostBudget(ApiBudget budget)
        {
            try
            {
                var resource = new CoreBudget
                {
                    BudgetId      = budget.BudgetId,
                    TotalAmtBills = budget.TotalAmtBills,
                    User          = (await _userRepo.GetUserById(budget.UserId))
                };

                await _repo.AddBudgetAsync(resource);

                return(Ok("Budget has been added!"));
            }
            catch (Exception e)
            {
                return(BadRequest(e));
            }
        }