public ActionResult Inbound([FromBody] InboundRequest inboundRequest)
        {
            var             modelErrors     = new List <string>();
            InboundResponse inboundResponse = new InboundResponse();
            CacheHandler    cacheHandler    = new CacheHandler();

            var request = Request;
            var headers = request.Headers;

            headers.TryGetValue("Authorization", out authorizationToken);
            string token    = authorizationToken.FirstOrDefault().Substring("Basic ".Length).Trim();
            string userName = token.Split(':')[0];
            string authId   = token.Split(':')[1];

            try
            {
                if (!ModelState.IsValid)
                {
                    foreach (var modelState in ModelState.Values)
                    {
                        foreach (var modelError in modelState.Errors)
                        {
                            modelErrors.Add(modelError.ErrorMessage);
                        }
                    }

                    inboundResponse.Message = "";
                    inboundResponse.Error   = string.Join(",", modelErrors);
                }
                else
                {
                    long        accountId   = _context.Account.Where(x => x.Username == userName && x.AuthId == authId).FirstOrDefault().Id;
                    PhoneNumber phoneNumber = _context.PhoneNumber.Where(x => x.Number == inboundRequest.To && x.AccountId == accountId).FirstOrDefault();
                    if (phoneNumber != null)
                    {
                        if (inboundRequest.Text.Equals("STOP") || inboundRequest.Text.Equals("STOP\n") || inboundRequest.Text.Equals("STOP\r") || inboundRequest.Text.Equals("STOP\r\n"))
                        {
                            if (!cacheHandler.IsKeyPresentInInboundCache(inboundRequest.From, inboundRequest.To))
                            {
                                cacheHandler.SetInboundSMSCacheAsync(inboundRequest.From, inboundRequest.To);
                            }
                        }

                        inboundResponse.Message = "inbound sms ok";
                        inboundResponse.Error   = "";
                    }
                    else
                    {
                        inboundResponse.Message = "";
                        inboundResponse.Error   = "to parameter not found";
                    }
                }
            }
            catch
            {
                inboundResponse.Message = "";
                inboundResponse.Error   = "unknown failure";
            }

            return(CreatedAtAction("Inbound", inboundResponse));
        }
示例#2
0
        public async Task <IActionResult> Inbound(string paymentId, string actiontype)
        {
            string responseCode       = string.Empty;
            string responseMessage    = string.Empty;
            string responseStatusCode = string.Empty;
            string responseBody       = string.Empty;

            string         privateKey     = HttpContext.Request.Headers[AffirmConstants.PrivateKeyHeader];
            string         publicKey      = HttpContext.Request.Headers[AffirmConstants.PublicKeyHeader];
            var            bodyAsText     = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
            InboundRequest inboundRequest = null;

            try
            {
                inboundRequest = JsonConvert.DeserializeObject <InboundRequest>(bodyAsText);
            }
            catch (Exception ex)
            {
                responseMessage = ex.Message;
                _context.Vtex.Logger.Error("Inbound", null, $"Error parsing InboundRequest {bodyAsText}", ex);
            }

            dynamic inboundRequestBody = null;

            try
            {
                inboundRequestBody = JsonConvert.DeserializeObject(inboundRequest.requestData.body);
            }
            catch (Exception ex)
            {
                responseMessage = ex.Message;
                _context.Vtex.Logger.Error("Inbound", null, $"Error parsing InboundRequestBody {bodyAsText}", ex);
            }

            paymentId = inboundRequest.paymentId;
            string requestId = inboundRequest.requestId;

            if (inboundRequestBody == null)
            {
                responseStatusCode = StatusCodes.Status400BadRequest.ToString();
            }
            else if (string.IsNullOrWhiteSpace(privateKey) || string.IsNullOrWhiteSpace(publicKey))
            {
                responseStatusCode = StatusCodes.Status400BadRequest.ToString();
                responseMessage    = "Missing keys.";
            }
            else
            {
                try
                {
                    switch (actiontype)
                    {
                    case AffirmConstants.Inbound.ActionAuthorize:
                        string token         = inboundRequestBody.token;
                        string callbackUrl   = inboundRequestBody.callbackUrl;
                        int    amount        = inboundRequestBody.orderTotal;
                        string orderId       = inboundRequestBody.orderId;
                        bool   sandboxMode   = inboundRequest.sandboxMode;
                        string transactionId = inboundRequest.transactionId;
                        if (string.IsNullOrEmpty(paymentId) || string.IsNullOrEmpty(token) || string.IsNullOrEmpty(callbackUrl))
                        {
                            responseStatusCode = StatusCodes.Status400BadRequest.ToString();
                            responseMessage    = "Missing parameters.";
                        }
                        else
                        {
                            var paymentRequest = await this._affirmPaymentService.Authorize(paymentId, token, publicKey, privateKey, callbackUrl, amount, orderId, sandboxMode, transactionId);

                            _context.Vtex.Logger.Info("Inbound", null, $"{paymentId} {JsonConvert.SerializeObject(paymentRequest)}");
                            Response.Headers.Add("Cache-Control", "private");

                            responseBody       = JsonConvert.SerializeObject(paymentRequest);
                            responseStatusCode = StatusCodes.Status200OK.ToString();
                        }

                        break;

                    default:
                        responseStatusCode = StatusCodes.Status405MethodNotAllowed.ToString();
                        responseMessage    = $"Action '{actiontype}' is not supported.";
                        break;
                    }
                }
                catch (Exception ex)
                {
                    _context.Vtex.Logger.Error("Inbound", null, $"Error processing request {bodyAsText}", ex);
                }
            }

            InboundResponse response = null;

            try
            {
                response = new InboundResponse
                {
                    code         = responseCode,
                    message      = responseMessage,
                    paymentId    = paymentId,
                    requestId    = requestId,
                    responseData = new ResponseData
                    {
                        body       = responseBody,
                        statusCode = responseStatusCode
                    }
                };
            }
            catch (Exception ex)
            {
                _context.Vtex.Logger.Error("Inbound", null, $"Error creating Response {responseBody}", ex);
            }

            return(Json(response));
        }
        public async Task <IActionResult> Inbound(string actiontype)
        {
            Console.WriteLine($"InboundAsync action = {actiontype}");

            string responseCode       = string.Empty;
            string responseMessage    = string.Empty;
            string responseStatusCode = string.Empty;
            string responseBody       = string.Empty;

            var            bodyAsText         = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
            InboundRequest inboundRequest     = JsonConvert.DeserializeObject <InboundRequest>(bodyAsText);
            dynamic        inboundRequestBody = null;

            try
            {
                inboundRequestBody = JsonConvert.DeserializeObject(inboundRequest.requestData.body);
            }
            catch (Exception ex)
            {
                responseMessage = ex.Message;
            }

            string paymentId = inboundRequest.paymentId;
            string requestId = inboundRequest.requestId;

            if (inboundRequestBody == null)
            {
                responseStatusCode = StatusCodes.Status400BadRequest.ToString();
            }
            else
            {
                switch (actiontype)
                {
                case FlowFinanceConstants.Inbound.ActionLoanAcceptance:
                    Models.SignLoanRequest.RootObject signLoanRequest = new Models.SignLoanRequest.RootObject
                    {
                        signature = new Models.SignLoanRequest.Signature
                        {
                            date      = DateTime.Now,
                            userAgent = inboundRequestBody.userAgent,
                            ip        = await this._flowFinancePaymentService.GetShopperIp()
                        }
                    };

                    string loanId    = inboundRequestBody.loanId;
                    int    accountId = inboundRequestBody.accountId;

                    //Console.WriteLine($"loanId = [{loanId}]   accountId = [{accountId}]");

                    responseBody = await this._flowFinancePaymentService.SignLoan(signLoanRequest, loanId, accountId);

                    //if (responseBody.Equals(FlowFinanceConstants.Success))
                    //{
                    string callbackUrl = inboundRequestBody.callbackUrl;
                    //decimal amount = inboundRequestBody.amount;

                    responseStatusCode = StatusCodes.Status200OK.ToString();
                    // Verify that the loan is signed and update the status with Vtex Payment
                    CreatePaymentResponse verifyPaymentResponse = await this._flowFinancePaymentService.VerifyLoanAsync(paymentId, loanId, accountId, callbackUrl);

                    //}
                    responseMessage = verifyPaymentResponse.message;
                    break;

                default:
                    responseStatusCode = StatusCodes.Status405MethodNotAllowed.ToString();
                    responseMessage    = $"Action '{actiontype}' is not supported.";
                    break;
                }
            }

            InboundResponse response = new InboundResponse
            {
                code         = responseCode,
                message      = responseMessage,
                paymentId    = paymentId,
                requestId    = requestId,
                responseData = new ResponseData
                {
                    body       = responseBody,
                    statusCode = responseStatusCode
                }
            };

            return(Json(response));
        }