private FastTransaction CreateFastTransaction(CreateFastTransactionRequest request)
 {
     return(new FastTransaction()
     {
         AccountId = request.BankAccountId,
         BranchId = request.BranchId,
         RecipientName = request.RecipientName,
         RecipientIBAN = request.RecipientIBAN,
         CreatedBy = _httpContextAccessor.HttpContext.User.Identity.Name
     });
 }
Example #2
0
        public async Task <IActionResult> AddOrEditFastTransaction([FromRoute] int id,
                                                                   [FromRoute] string iban,
                                                                   [FromBody] CreateFastTransactionRequest request,
                                                                   CancellationToken cancellationToken = default)
        {
            var user = await _userManager.GetUserAsync(User);

            var customer = await _customerService.GetCustomerByIBANAsync(iban, cancellationToken);

            var apiResponse = new Response();

            if (customer == null)
            {
                apiResponse.AddError(ExceptionCreator.CreateNotFoundError(nameof(customer)));

                return(NotFound(apiResponse));
            }

            if (user.Id != customer?.Data?.UserId)
            {
                apiResponse.AddError(ExceptionCreator.CreateBadRequestError(nameof(user), "user is not authorized to complete this operation"));

                return(BadRequest(apiResponse));
            }

            try
            {
                apiResponse = await _fastTransactionsService.AddOrEditFastTransactionAsync(id, request, cancellationToken);

                if (apiResponse.Success)
                {
                    return(Ok(apiResponse));
                }

                else if (apiResponse.Errors[0].Code == StatusCodes.Status404NotFound)
                {
                    return(NotFound(apiResponse));
                }


                return(BadRequest(apiResponse));
            }
            catch (Exception exception)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, exception.ToString()));
            }
        }
        /// <summary>
        /// Add or edit existing fast transaction
        /// </summary>
        /// <param name="id"></param>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <Response> AddOrEditFastTransactionAsync(int id, CreateFastTransactionRequest request, CancellationToken cancellationToken = default)
        {
            var responseModel = new Response();

            if (id != 0)
            {
                var fastTransaction = await _fastTransactionsRepo.FindByIdAsync(id);

                if (fastTransaction != null)
                {
                    fastTransaction.AccountId      = request.BankAccountId;
                    fastTransaction.BranchId       = request.BranchId;
                    fastTransaction.RecipientName  = request.RecipientName;
                    fastTransaction.RecipientIBAN  = request.RecipientIBAN;
                    fastTransaction.LastModifiedBy = _httpContextAccessor.HttpContext.User.Identity.Name;
                    fastTransaction.LastModifiedOn = DateTime.UtcNow;

                    try
                    {
                        await _fastTransactionsRepo.UpdateAsync(fastTransaction);
                    }
                    catch (Exception ex)
                    {
                        responseModel.AddError(ExceptionCreator.CreateInternalServerError(ex.ToString()));
                    }
                }
                else
                {
                    responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(fastTransaction)));
                    return(responseModel);
                }
            }
            else
            {
                try
                {
                    await _fastTransactionsRepo.AddAsync(CreateFastTransaction(request));
                }
                catch (Exception ex)
                {
                    responseModel.AddError(ExceptionCreator.CreateInternalServerError(ex.ToString()));
                }
            }

            return(responseModel);
        }