Esempio n. 1
0
        public async Task <IActionResult> ProcessPayment([FromBody] CardInfoDTO cardInfo)
        {
            try
            {
                if (cardInfo == null)
                {
                    _logger.LogError("CardInfo object sent from client is null.");
                    return(BadRequest("CardInfo object is null"));
                }

                if (!ModelState.IsValid)
                {
                    return(BadRequest("Invalid model object"));
                }

                var response = await _processPaymentService.ProcessPayment(cardInfo);

                return(Ok(response));
            }
            catch (Exception ex)
            {
                _logger.LogError($"Something went wrong inside ProcessPayment action: {ex.Message}");
                return(StatusCode(500, "Internal Server Error"));
            }
        }
        public ActionResult Post([FromBody] ProcessPaymentRequest request)
        {
            if (request == null)
            {
                return(StatusCode(StatusCodes.Status400BadRequest));
            }

            var rsp = _processPaymentService.ProcessPayment(request);

            var result = JsonConvert.SerializeObject(rsp, Formatting.None);

            return(new JsonResult(result, new JsonSerializerOptions
            {
                WriteIndented = true,
            }));

            //if (rsp.Success)
            //{
            //    return StatusCode(StatusCodes.Status200OK);
            //}
            //else
            //{
            //    return StatusCode(StatusCodes.Status500InternalServerError);
            //}

            //return new JsonResult(new { id = rsp.Success, message = rsp.Message });
        }
Esempio n. 3
0
        private async Task ConsumePayment(CancellationToken stoppingToken)
        {
            _consumerPayment.Subscribe(_configuration["Kafka:TopicPayment"]);
            try
            {
                while (!stoppingToken.IsCancellationRequested)
                {
                    try
                    {
                        var result = _consumerPayment.Consume(stoppingToken);
                        await _processPaymentService.ProcessPayment(result.Message.Value);

                        //_consumerPayment.Commit(result);
                        _consumerPayment.StoreOffset(result);
                        await Task.Delay(1000, stoppingToken);
                    }
                    catch (ConsumeException e)
                    {
                        _logger.LogError(e, "Error consuming");
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            finally
            {
                _consumerPayment.Close();
            }
        }
        public async Task <PaymentResult> Process([FromBody] PaymentRequest request)
        {
            var result = await _paymentService.ProcessPayment(request);

            await _historyService.SaveHistory(request, result);

            return(result);
        }
Esempio n. 5
0
        public async Task <bool> ProcessPayment(PaymentRequest paymentRequest)
        {
            var result = await _processPaymentService.ProcessPayment(paymentRequest, GatewayName);

            return(result);
        }
        public async Task <ActionResult <ProcessPaymentViewModel> > ProcessPayment(ProcessPaymentViewModel paymentViewModel)
        {
            var result = await _processPaymentService.ProcessPayment(paymentViewModel);

            return(result);
        }