public bool CreateTransaction(CreateTransactionRequest createTransactionRequest, dynamic viewBag)
{
bool success = false;
string jsonRequest = JsonConvert.SerializeObject(createTransactionRequest);
StringContent stringContent = new StringContent(jsonRequest, UnicodeEncoding.UTF8, "application/json");
string transactionUrl = ConfigurationManager.AppSettings["TransactionUrl"];
string requestUri = string.Concat(transactionUrl, "/v2/sales");
var response = RequestHttp("Post", requestUri, stringContent);
var contents = response.Content?.ReadAsStringAsync().Result;
viewBag.ServiceResponse = contents;
if (response?.IsSuccessStatusCode == true)
{
CreateTransactionResponse createTransactionResponse = JsonConvert.DeserializeObject <CreateTransactionResponse>(contents);
viewBag.PaymentId = createTransactionResponse.Payment.PaymentId;
viewBag.ReturnMessage = "Transação criada com sucesso";
success = true;
}
return(success);
}
public ActionResult Subscription(string id)
{
int ID = Int32.Parse(id);
var token = "";
//Check if token exist otherwise send details to Shared Payment Gateway
using (AimyEntities db = new AimyEntities()) {
var checktokenexist = (from sub in db.CssSubscriptions
join org in db.Orgs on sub.OrgId equals org.Id
join pay in db.CssPaymentSetups on org.Id equals pay.OrgId
where sub.Id == ID
select new
{
token = pay.CustomerId,
orgid = org.Id
}
).FirstOrDefault();
//check if token exits
if (checktokenexist.token != "")
{
// token = checktokenexist.token;
token = "910287958561"; //only because this hasn't been save to db ..
CreateTransactionResponse response = UseTokenRet(token);
ViewBag.response = response;
}
else //send to sharepayment gateway
{
}
}
return(View());
}
public static CreateTransactionResponse Unmarshall(UnmarshallerContext context)
{
CreateTransactionResponse createTransactionResponse = new CreateTransactionResponse();
createTransactionResponse.HttpResponse = context.HttpResponse;
createTransactionResponse.Code = context.StringValue("CreateTransaction.Code");
createTransactionResponse.Message = context.StringValue("CreateTransaction.Message");
createTransactionResponse.RequestId = context.StringValue("CreateTransaction.RequestId");
createTransactionResponse.Action = context.StringValue("CreateTransaction.Action");
CreateTransactionResponse.CreateTransaction_Transaction transaction = new CreateTransactionResponse.CreateTransaction_Transaction();
CreateTransactionResponse.CreateTransaction_Transaction.CreateTransaction_Upload upload = new CreateTransactionResponse.CreateTransaction_Transaction.CreateTransaction_Upload();
upload.Bucket = context.StringValue("CreateTransaction.Transaction.Upload.Bucket");
upload.FileId = context.StringValue("CreateTransaction.Transaction.Upload.FileId");
upload.OssEndpoint = context.StringValue("CreateTransaction.Transaction.Upload.OssEndpoint");
upload.ObjectKey = context.StringValue("CreateTransaction.Transaction.Upload.ObjectKey");
upload.SessionId = context.StringValue("CreateTransaction.Transaction.Upload.SessionId");
upload.AccessKeyId = context.StringValue("CreateTransaction.Transaction.Upload.AccessKeyId");
upload.AccessKeySecret = context.StringValue("CreateTransaction.Transaction.Upload.AccessKeySecret");
upload.StsToken = context.StringValue("CreateTransaction.Transaction.Upload.StsToken");
transaction.Upload = upload;
createTransactionResponse.Transaction = transaction;
return(createTransactionResponse);
}
public override async Task <CreateTransactionResponse> CreateTransaction(CreateTransactionRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var account = await _accountService.FindAccountOrNullAsync(userId);
if (account == null)
{
throw context.NotFoundRpcException("User account not found.");
}
var result = await CreateTransactionByOneofCaseAsync();
if (result.IsValid)
{
var response = new CreateTransactionResponse
{
Transaction = _mapper.Map <TransactionDto>(result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
async Task <DomainValidationResult <ITransaction> > CreateTransactionByOneofCaseAsync()
{
switch (request.TransactionCase)
{
case CreateTransactionRequest.TransactionOneofCase.Bundle:
{
return(await _accountService.CreateTransactionAsync(account !, request.Bundle, new TransactionMetadata(request.Metadata)));
}
case CreateTransactionRequest.TransactionOneofCase.Custom:
{
return(await _accountService.CreateTransactionAsync(
account !,
request.Custom.Currency.Amount,
request.Custom.Currency.Type.ToEnumeration <CurrencyType>(),
request.Custom.Type.ToEnumeration <TransactionType>(),
new TransactionMetadata(request.Metadata)));
}
default:
{
throw context.RpcException(
new Status(
StatusCode.InvalidArgument,
$"The case ({request.TransactionCase}) is not supported for {nameof(this.CreateTransaction)}."));
}
}
}
}
public ActionResult UseToken(string token)
{
IRapidClient ewayClient = RapidClientFactory.NewRapidClient(apiKey, password, rapidEndpoint);
//1. Charging the customer with token ... note refer to https://eway.io/api-v3/#token-payments
// tokenpayment method is not used in rapid sdk Api
Transaction transaction = new Transaction()
{
Customer = new Customer()
{
TokenCustomerID = token,
},
PaymentDetails = new PaymentDetails()
{
TotalAmount = 10000,
InvoiceNumber = "14632"
},
RedirectURL = "http://localhost:53738/Home/Ewayresponse",
TransactionType = TransactionTypes.Recurring
};
CreateTransactionResponse response = ewayClient.Create(PaymentMethod.Direct, transaction);
if (response.Errors != null)
{
foreach (string errorCode in response.Errors)
{
Console.WriteLine("Error Message: " + RapidClientFactory.UserDisplayMessage(errorCode, "EN"));
}
}
ViewBag.token = token;
ViewBag.response = response;
//ViewBag.totalamount =
int totalamount = response.Transaction.PaymentDetails.TotalAmount / 100;
ViewBag.totalamount = totalamount;
return(View());
}
private PaymentResponse ProcessPayResponse(CreateTransactionResponse parResponse)
{
var response = new PaymentResponse();
response.Result = ServiceResult.Error;
if (parResponse == null)
{
return(response);
}
if (parResponse.TransactionStatus == null)
{
return(response);
}
if (!parResponse.TransactionStatus.Status.HasValue)
{
return(response);
}
if (parResponse.TransactionStatus.Status.Value)
{
response.Result = ServiceResult.Success;
return(response);
}
var errorCodes = new[]
{
"S5000", "S5085", "S5086", "S5087", "S5099", "F9023", "F7000", "D4403", "D4406", "D4459", "D4496",
"S9996", "S9902", "S9992"
};
var codes = parResponse.TransactionStatus.ProcessingDetails.ResponseMessage.Split(new[] { ", " },
StringSplitOptions.None);
foreach (var code in codes)
{
if (errorCodes.Contains(code))
{
response.Result = ServiceResult.Error;
}
response.Errors.Add(RapidClientFactory.UserDisplayMessage(code, "EN"));
}
return(response);
}
public ActionResult TokenWithPayment()
{
IRapidClient ewayClient = RapidClientFactory.NewRapidClient(apiKey, password, rapidEndpoint);
Customer customer = new Customer()
{
Title = "Ms.",
FirstName = "Jane",
LastName = "Smith",
Address = new Address()
{
Country = "nz"
},
CompanyName = "SKIDS HO[DisableForTesting]",
Url = "http://localhost:53738",
RedirectURL = "http://localhost:53738/Home/Ewayresponse"
};
Transaction transaction = new Transaction()
{
Customer = customer,
PaymentDetails = new PaymentDetails()
{
TotalAmount = 10000,
InvoiceDescription = "Parent subscription",
InvoiceNumber = "4536",
},
RedirectURL = "http://localhost:53738/Home/Ewayresponse",
TransactionType = TransactionTypes.Purchase,
SaveCustomer = true,
};
CreateTransactionResponse transactionresponse = ewayClient.Create(PaymentMethod.ResponsiveShared, transaction);
if (transactionresponse.Errors != null)
{
foreach (string errorCode in transactionresponse.Errors)
{
Console.WriteLine("Error Message: " + RapidClientFactory.UserDisplayMessage(errorCode, "EN"));
}
}
return(Redirect(transactionresponse.SharedPaymentUrl));
}
public IHttpActionResult CreateSale(CreateTransactionRequest createTransactionRequest)
{
try
{
// Verifica se há erros
if (!this.ModelState.IsValid)
{
var message = string.Join(
" | ", this.ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
// Retorna a lista de erros
return(this.BadRequest(message));
}
// Conecta no barramento de servios
var bus = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
sbc.Host(
new Uri("rabbitmq://localhost/"),
h =>
{
h.Username("guest");
h.Password("guest");
});
});
// Inicia o barramento
bus.Start();
var task = bus.Publish(createTransactionRequest);
task.Wait();
bus.Stop();
// Cria a resposta
var createSaleResponse = new CreateTransactionResponse()
{
TransactionKey = createTransactionRequest.TransactionKey
};
return(this.Ok(createSaleResponse));
}
catch (Exception ex)
{
return(this.InternalServerError(ex));
}
}
public void Multithread_CreatingMultipleClientsInManyThreads_ReturnsValidData()
{
RunInMultipleThreads(20, () =>
{
IRapidClient client = CreateRapidApiClient();
Transaction transaction = new Transaction()
{
Customer = TestUtil.CreateCustomer(),
PaymentDetails = new PaymentDetails()
{
TotalAmount = 200
},
TransactionType = TransactionTypes.MOTO,
};
CreateTransactionResponse response =
client.Create(PaymentMethod.Direct, transaction);
});
}
public ActionResult Checkout()
{
var order = new Order(_randomOrderId, 4700.00m, DateTime.Now, "Goku e GokuSSJ");
//Crédito - A vista
var paymentMethod = new PaymentMethod(CreditCard.MasterCard, PurchaseType.Credit);
var options = new CreateTransactionOptions(AuthorizationType.AuthorizeSkippingAuthentication, capture: true);
//Crédito - Parcelado Loja
//var paymentMethod = new PaymentMethod(CreditCard.MasterCard, PurchaseType.StoreInstallmentPayment, 5);
//var options = new CreateTransactionOptions(AuthorizationType.AuthorizeSkippingAuthentication, capture: true);
//Débito
//var paymentMethod = new PaymentMethod(CreditCard.MasterCard, PurchaseType.Debit);
//var options = new CreateTransactionOptions(AuthorizationType.AuthorizeAuthenticatedOrNot, capture: true);
var createTransactionRequest = new CreateTransactionRequest(order, paymentMethod, options, configuration: _configuration);
CreateTransactionResponse response = _cieloService.CreateTransaction(createTransactionRequest);
Session["tid"] = response.Tid;
return(Redirect(response.AuthenticationUrl));
}
public async Task <IActionResult> Post([FromBody] CreateTransactionRequest request)
{
var command = new CreateTransactionCommand(request.Amount, request.CurrencyCode, request.CardId, request.UniqueId, request.ChargeDate);
var result = await commandDispatcher.Dispatch(command);
if (result.Success)
{
var response = new CreateTransactionResponse()
{
Amount = result.Amount,
CardId = result.CardId,
ChargeDate = result.ChargeDate,
CurrencyCode = result.CurrencyCode,
Id = result.Id,
UniqueId = result.UniqueId
};
return(Ok(response));
}
return(BadRequest(request));
}
public void SetUp()
{
_createTransactionResponse = new CreateTransactionResponse(ExpectedResponse);
}
public ActionResult DonatingDetails(DirectPay directPayModel)
{
IRapidClient ewayClient = RapidClientFactory.NewRapidClient(APIKEY, PASSWORD, ENDPOINT);
Transaction transaction = new Transaction()
{
Customer = new Customer()
{
Title = directPayModel.Title,
FirstName = directPayModel.FirstName,
LastName = directPayModel.LastName,
Email = directPayModel.Email,
CardDetails = new CardDetails()
{
Name = directPayModel.CardName,
Number = directPayModel.CardNumber,
ExpiryMonth = directPayModel.CardExpiryMonth,
ExpiryYear = directPayModel.CardExpiryYear,
CVN = directPayModel.CVN,
}
},
PaymentDetails = new PaymentDetails()
{
TotalAmount = directPayModel.TotalAmount
},
TransactionType = TransactionTypes.Purchase,
};
CreateTransactionResponse response = ewayClient.Create(PaymentMethod.Direct, transaction);
if (response.Errors != null)
{
foreach (string errorCode in response.Errors)
{
if (errorCode == "V6100")
{
Message = "Error message: Invalid Credit card name entered, please check the name and try again!!!.";
}
else if (errorCode == "V6101" || errorCode == "V6102")
{
Message = "Error message: Invalid Expiryd Date entered,please check the date and try again!!!.";
}
else if (errorCode == "V6106")
{
Message = "Error message: Invalid CVN entered,please check the CVN and try again!!!.";
}
else if (errorCode == "V6110")
{
Message = "Error message: Invalid card number entered,please check the cardnumber and try again!!!.";
}
resultModel = new Result {
Status = "Payment Failure!!!", Description = Message
};
}
}
else
{
if ((bool)response.TransactionStatus.Status)
{
Message = ("Thanks for donating to Charity. Please note your transaction ID: " + response.TransactionStatus.TransactionID);
resultModel = new Result {
Status = "Payment Success!!!", Description = Message
};
}
}
return(RedirectToAction("Result", "Results", resultModel));
}
public void SetUp()
{
_createTransactionResponse = new CreateTransactionResponse(ExpectedResponse);
}
