public CreateSaleResponse MakeCreditCardTransaction(CreateSaleRequest createSaleRequest)
{
var client = new RestClient("http://localhost:50976");
var request = new RestRequest("/v1/api/Acquiries/Stone/CreditCard", Method.POST);
var json = JsonConvert.SerializeObject(createSaleRequest);
request.AddParameter("text/json", json, ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
CreateSaleResponse createSaleResponse = null;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
try
{
createSaleResponse = JsonConvert.DeserializeObject <CreateSaleResponse>(response.Content);
}
catch (Exception ex)
{
}
}
else
{
}
return(createSaleResponse);
}
public void QueueSale(CreateSaleRequest request)
{
#region Mapping
var queueItem = new NixQueueItem();
queueItem.RequestKey = Guid.NewGuid().ToString();
queueItem.CreateDate = DateTime.UtcNow;
queueItem.AffiliationData.Email = request.Email;
queueItem.AffiliationData.MerchantName = "Imasters";
queueItem.AmountInCents = Convert.ToInt32(request.Amount * 100);
queueItem.Card.CreditCardBrand = "Mastercard";
queueItem.Card.CreditCardNumber = request.CreditCard.Number;
queueItem.Card.ExpMonth = request.CreditCard.ExpirationMonth.ToString();
queueItem.Card.ExpYear = request.CreditCard.ExpirationYear.ToString();
queueItem.Card.HolderName = request.CreditCard.HolderName;
queueItem.Card.SecurityCode = request.CreditCard.Cvv;
string queueItemJson = JsonConvert.SerializeObject(queueItem);
#endregion
#region Send to queue
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
QueueClient Client = QueueClient.CreateFromConnectionString(connectionString, CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.QueueName"));
Client.Send(new BrokeredMessage(queueItemJson));
#endregion
}
/// <summary>Cria requisição.</summary>
private CreateSaleRequest GenerateSaleRequest(IOrder order, Collection <CreditCardTransaction> cardTransictions, Collection <BoletoTransaction> boletoTransaction)
{
if (cardTransictions.IsNullOrEmpty() && boletoTransaction.IsNullOrEmpty())
{
throw new InvalidOperationException("É necessario enviar uma transação");
}
var createSaleRequest = new CreateSaleRequest()
{
Order = new GatewayApiClient.DataContracts.Order()
{
OrderReference = order.TransactionReference
}
};
if (!cardTransictions.IsNullOrEmpty())
{
createSaleRequest.CreditCardTransactionCollection = cardTransictions;
}
if (!boletoTransaction.IsNullOrEmpty())
{
createSaleRequest.BoletoTransactionCollection = boletoTransaction;
}
return(createSaleRequest);
}
public void ItShouldCreateATransactionWithInstantBuyKey()
{
// Cria o cliente para retentar a transação.
IGatewayServiceClient serviceClient = this.GetGatewayServiceClient();
// Cria transação de cartão de crédito para ser retentada
HttpResponse <CreateSaleResponse> saleResponse = serviceClient.Sale.Create(this._createCreditCardSaleRequest);
Assert.AreEqual(saleResponse.HttpStatusCode, HttpStatusCode.Created);
var instantBuyKey = saleResponse.Response.CreditCardTransactionResultCollection.Select(x => x.CreditCard.InstantBuyKey);
// Cria requisição com instant buy key
CreateSaleRequest createSale = new CreateSaleRequest {
CreditCardTransactionCollection = new Collection <CreditCardTransaction>
{
new CreditCardTransaction
{
AmountInCents = 10000,
CreditCard = new CreditCard
{
InstantBuyKey = instantBuyKey.FirstOrDefault()
}
}
}
};
// Faz a requisição
HttpResponse <CreateSaleResponse> httpResponse = serviceClient.Sale.Create(createSale);
Assert.AreEqual(HttpStatusCode.Created, httpResponse.HttpStatusCode);
}
public void Create(ref AcquirerSale acquirerSale)
{
// Arrange post
CreateSaleRequest RequestObject = new CreateSaleRequest();
// Call endpoint
NameValueCollection headers = new NameValueCollection();
headers.Add("MerchantKey", acquirerSale.Store.MerchantKey);
headers.Add("Content-Type", "application/json");
HttpResponse <CreateSaleResponse> Response = this.HttpUtility.SubmitRequest <CreateSaleRequest, CreateSaleResponse>(RequestObject,
acquirerSale.Acquirer.ServiceUri, HttpVerbEnum.Post, HttpContentTypeEnum.Json, headers);
// Arrange return
if (Response.HttpStatusCode == HttpStatusCode.Created)
{
acquirerSale.AcquirerSuccess = true;
acquirerSale.AcquirerRawResponse = Response.RawResponse;
acquirerSale.StatusCode = Response.HttpStatusCode.ToString();
}
else
{
acquirerSale.AcquirerSuccess = false;
}
}
public SalesTable CreateSale(CreateSaleRequest saleRequest)
{
var result = _saleService.CreateSaleAsync(saleRequest).Result;
result.SaleDetails.ForEach(u => u.Sale = null);
return(result);
}
public static CreateSaleRequest GenerateSaleRequest()
{
CreditCard card = GenerateCreditCard();
// Cria a transação.
var transaction = new CreditCardTransaction()
{
AmountInCents = 10000,
CreditCard = card,
InstallmentCount = 1
};
// Cria requisição.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(
new CreditCardTransaction[] { transaction }
),
Order = new Order()
{
OrderReference = "NumeroDoPedido"
}
};
return(createSaleRequest);
}
public string CartaoDeCredito(Pedido pedido)
{
string retorno = string.Empty;
try
{
// Cria a transação.
var transaction = new CreditCardTransaction()
{
AmountInCents = 10000,
CreditCard = new CreditCard()
{
//CreditCardBrand = CreditCardBrandEnum.Visa,
CreditCardBrand = ((CreditCardBrandEnum)(pedido.Cliente.CartaoDeCredito.Bandeira)),
CreditCardNumber = pedido.Cliente.CartaoDeCredito.Numero,
ExpMonth = int.Parse(pedido.Cliente.CartaoDeCredito.Validade.Split('/')[0]),
ExpYear = int.Parse(pedido.Cliente.CartaoDeCredito.Validade.Split('/')[1]),
HolderName = pedido.Cliente.CartaoDeCredito.Nome,
SecurityCode = pedido.Cliente.CartaoDeCredito.CodigoSeguranca
},
InstallmentCount = 1
};
// Cria requisição.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transaction }),
Order = new Order()
{
OrderReference = pedido.Id.ToString()
}
};
// Coloque a sua MerchantKey aqui.
Guid merchantKey = pedido.TokenLoja;
// Cria o client que enviará a transação.
var serviceClient = new GatewayServiceClient(merchantKey, new Uri("https://transaction.stone.com.br"));
// Autoriza a transação e recebe a resposta do gateway.
var httpResponse = serviceClient.Sale.Create(createSaleRequest);
Console.WriteLine("Código retorno: {0}", httpResponse.HttpStatusCode);
Console.WriteLine("Chave do pedido: {0}", httpResponse.Response.OrderResult.OrderKey);
if (httpResponse.Response.CreditCardTransactionResultCollection != null)
{
//retorno = httpResponse.Response.CreditCardTransactionResultCollection.FirstOrDefault().CreditCardTransactionStatus.ToString();
retorno = CreditCardTransactionStatusEnum.AuthorizedPendingCapture.ToString();
}
}
catch (Exception ex)
{
retorno = CreditCardTransactionStatusEnum.WithError.ToString();
}
return(retorno);
}
public void ShouldCreateExactlyOneTransaction()
{
CreateSaleRequest createSaleRequest = ModelFactory.GenerateSaleRequest();
var httpResponse = serviceClient.Sale.Create(createSaleRequest);
Assert.AreEqual(HttpStatusCode.Created, httpResponse.HttpStatusCode);
Assert.IsTrue(httpResponse.Response.CreditCardTransactionResultCollection.Count == 1);
}
public async Task <IActionResult> Pay()
{
StringBuilder console = new StringBuilder();
// Cria a transação.
var transaction = new CreditCardTransaction()
{
AmountInCents = 10000,
CreditCard = new CreditCard()
{
CreditCardBrand = CreditCardBrandEnum.Visa,
CreditCardNumber = "4111111111111111",
ExpMonth = 10,
ExpYear = 22,
HolderName = "LUKE SKYWALKER",
SecurityCode = "123"
},
InstallmentCount = 1
};
// Cria requisição.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transaction }),
Order = new Order()
{
OrderReference = "NumeroDoPedido"
}
};
// Coloque a sua MerchantKey aqui.
Guid merchantKey = Guid.Parse("0d96500c-fe5e-4454-bd3a-d2a6b83e81a3");
// Cria o client que enviará a transação.
var serviceClient = new GatewayServiceClient(merchantKey, new Uri("https://sandbox.mundipaggone.com"));
// Autoriza a transação e recebe a resposta do gateway.
var httpResponse = await serviceClient.CreateSale(createSaleRequest);
console.AppendLine(string.Format("Código retorno: {0}", httpResponse.HttpStatusCode));
console.AppendLine(string.Format("Chave do pedido: {0}", httpResponse.Response.OrderResult.OrderKey));
if (httpResponse.Response.CreditCardTransactionResultCollection != null)
{
console.AppendLine(string.Format("Status transação: {0}", httpResponse.Response.CreditCardTransactionResultCollection.FirstOrDefault().CreditCardTransactionStatus));
}
ViewBag.Result = console.ToString();
return(View());
}
/// <summary>
/// Cria uma venda, contendo transações de boleto e/ou cartão de crédito
/// </summary>
/// <param name="createSaleRequest">Dados da venda</param>
/// <returns></returns>
public HttpResponse <CreateSaleResponse> Create(CreateSaleRequest createSaleRequest)
{
// Configura MerchantKey e o header
NameValueCollection headers = this.GetHeaders();
headers.Add("MerchantKey", this.MerchantKey.ToString());
// Envia requisição
return(this.HttpUtility.SubmitRequest <CreateSaleRequest, CreateSaleResponse>(createSaleRequest,
string.Concat(this.HostUri, this.ResourceName), HttpVerbEnum.Post, HttpContentTypeEnum.Json, headers));
}
public void ShouldCancelCreatedTransaction()
{
CreateSaleRequest createSaleRequest = ModelFactory.GenerateSaleRequest();
var creationResponse = serviceClient.Sale.Create(createSaleRequest);
Guid orderKey = creationResponse.Response.OrderResult.OrderKey;
var httpResponse = serviceClient.Sale.Manage(ManageOperationEnum.Cancel, orderKey);
Assert.AreEqual(HttpStatusCode.OK, httpResponse.HttpStatusCode);
Assert.IsTrue(httpResponse.Response.CreditCardTransactionResultCollection.Count == 1);
}
public JsonResult CreateSale([FromBody] CreateSaleRequest request)
{
string unitPrice = string.Empty;
if (request.SalePrice.Substring(request.SalePrice.Length - 3).Contains(','))
{
unitPrice = request.SalePrice;
}
else
{
unitPrice = request.SalePrice.Replace(',', ';').Replace('.', ',').Replace(';', '.');
}
BaseResponse baseResponse = new BaseResponse();
AdminSale sale = new AdminSale();
sale.AdminId = 2;
sale.ProductId = request.ProductId;
sale.DateOfSale = request.SaleTime.Replace('/', '-');
sale.DealerId = request.DealerId;
sale.Quantity = Convert.ToInt32(request.Quantity);
sale.UnitPrice = Convert.ToDecimal(unitPrice);
sale.TotalPrice = sale.UnitPrice * sale.Quantity;
sale.IsActive = true;
_adminSaleService.Add(sale);
Product product = _productService.GetById(request.ProductId);
int int32 = Convert.ToInt32(request.Quantity);
product.Stock -= int32;
this._productService.Update(product);
DealerProduct dealerProduct = this._dealerProductService.IsExists(request.DealerId, request.ProductId);
if (dealerProduct == null)
{
this._dealerProductService.Add(new DealerProduct()
{
DealerId = request.DealerId,
Stock = int32,
DealerBuyPrice = product.AdminSalePrice,
IsActive = true,
ProductId = request.ProductId
});
}
else
{
dealerProduct.Stock += int32;
this._dealerProductService.Update(dealerProduct);
}
baseResponse.Number = 1;
baseResponse.Message = "Satış başarılı bir şekilde yapılmıştır..";
return(this.Json((object)baseResponse));
}
/// /// <summary>
/// Cria uma venda com uma coleção de boletos
/// </summary>
/// <param name="boletoTransactionCollection">Coleção de boletos</param>
/// <returns></returns>
public HttpResponse <CreateSaleResponse> Create(Collection <BoletoTransaction> boletoTransactionCollection)
{
CreateSaleRequest createSaleRequest = new CreateSaleRequest();
createSaleRequest.BoletoTransactionCollection = boletoTransactionCollection;
// Se não for informado o comprador nem o carrinho de compras não será possível utilizar o serviço de anti fraude.
createSaleRequest.Options = new SaleOptions()
{
IsAntiFraudEnabled = false
};
return(this.Create(createSaleRequest));
}
private DataContracts.LocalDb.Transaction StonePayment(PaymentRequest pPaymentRequest, Acquirer pAcquirer)
{
//Create transaction.
var transaction = new CreditCardTransaction()
{
AmountInCents = 10000,
CreditCard = new CreditCard()
{
CreditCardBrand = CreditCardBrandEnum.Mastercard,
CreditCardNumber = pPaymentRequest.CreditCardNumber,
ExpMonth = Convert.ToInt32(pPaymentRequest.ExpMonth),
ExpYear = Convert.ToInt32(pPaymentRequest.ExpYear),
HolderName = pPaymentRequest.HolderName,
SecurityCode = pPaymentRequest.SecurityCode
},
InstallmentCount = 1,
Options = new CreditCardTransactionOptions {
PaymentMethodCode = 1
}
};
//Create request.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transaction }),
Order = new StonePaymentGateway.DataContracts.Order()
{
OrderReference = "Simulador"
}
};
Guid merchantKey = Guid.Parse(pAcquirer.MerchanteKey);
var serviceClient = new GatewayServiceClient(merchantKey, new Uri("https://transaction.stone.com.br"));
var httpResponse = serviceClient.Sale.Create(createSaleRequest);
var result = httpResponse.Response.CreditCardTransactionResultCollection.FirstOrDefault();
var transactionDb = new DataContracts.LocalDb.Transaction();
transactionDb.Authorization = result.AuthorizationCode;
transactionDb.AuthAmountInCents = result.AuthorizedAmountInCents.ToString();
transactionDb.CardExpiration = pPaymentRequest.ExpYear + pPaymentRequest.ExpMonth;
transactionDb.CardNumber = pPaymentRequest.CreditCardNumber;
transactionDb.Date = (DateTime)result.CapturedDate;
transactionDb.MerchanteKey = pAcquirer.MerchanteKey;
transactionDb.Message = result.AcquirerMessage;
transactionDb.CardName = pPaymentRequest.HolderName;
transactionDb.CardSecurityCode = pPaymentRequest.SecurityCode;
return(transactionDb);
}
public static void test()
{
var transaction = new CreditCardTransaction()
{
AmountInCents = 10000,
CreditCard = new CreditCard()
{
CreditCardBrand = CreditCardBrandEnum.Visa,
CreditCardNumber = "4111111111111111",
ExpMonth = 10,
ExpYear = 22,
HolderName = "LUKE SKYWALKER",
SecurityCode = "123"
},
InstallmentCount = 1
};
// Cria requisição.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new CreditCardTransactionCollection(new CreditCardTransaction[] { transaction }),
Order = new Order()
{
OrderReference = "NumeroDoPedido"
}
};
// Coloque a sua MerchantKey.
Guid merchantKey = Guid.Parse("F2A1F485-CFD4-49F5-8862-0EBC438AE923");
// Cria o client que enviará a transação.
var serviceClient = new MockGatewayServiceClient(merchantKey);
// Autoriza a transação e recebe a resposta do gateway.
var httpResponse = serviceClient.Sale.Create(createSaleRequest);
Console.WriteLine("Código retorno: {0}", httpResponse.HttpStatusCode);
Console.WriteLine("Chave do pedido: {0}", httpResponse.Response.OrderResult.OrderKey);
if (httpResponse.Response.CreditCardTransactionResultCollection != null)
{
Console.WriteLine("Status transação: {0}", httpResponse.Response.CreditCardTransactionResultCollection.FirstOrDefault().CreditCardTransactionStatus);
}
}
/// <summary>
/// Cria uma venda com uma coleção de transações de cartão de crédito
/// </summary>
/// <param name="creditCardTransactionCollection">Coleção de transações de cartão de crédito</param>
/// <param name="orderReference">Identificação do pedido na loja</param>
/// <returns></returns>
public HttpResponse <CreateSaleResponse> Create(Collection <CreditCardTransaction> creditCardTransactionCollection, string orderReference)
{
CreateSaleRequest createSaleRequest = new CreateSaleRequest();
createSaleRequest.CreditCardTransactionCollection = creditCardTransactionCollection;
// Se não for informado o comprador nem o carrinho de compras não será possível utilizar o serviço de anti fraude.
createSaleRequest.Options = new SaleOptions()
{
IsAntiFraudEnabled = false
};
if (string.IsNullOrWhiteSpace(orderReference) == false)
{
createSaleRequest.Order = new Order()
{
OrderReference = orderReference
};
}
return(this.Create(createSaleRequest));
}
/// <summary>
/// Cria e envia uma transação de cartão de crédito.
/// </summary>
/// <param name="transactionModel">Transação no modelo genérico de entrada no sistema.</param>
public HttpResponse <CreateSaleResponse> CreateCreditCardTransaction(TransactionModel transactionModel)
{
try
{
// Cria a transação.
var transaction = TransformTransactionClassToStone(transactionModel);
// Cria requisição.
var createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transaction }),
Order = new Order()
{
OrderReference = transactionModel.TransactionIDText
}
};
// Coloque a sua MerchantKey aqui.
Guid merchantKey = Guid.Parse("f2a1f485-cfd4-49f5-8862-0ebc438ae923");
// Cria o client que enviará a transação.
var serviceClient = new GatewayServiceClient(merchantKey, _endpoint);
// Autoriza a transação e recebe a resposta do gateway.
var httpResponse = serviceClient.Sale.Create(createSaleRequest);
//Console.WriteLine("Código retorno: {0}", httpResponse.HttpStatusCode);
//Console.WriteLine("Chave do pedido: {0}", httpResponse.Response.OrderResult.OrderKey);
if (httpResponse.Response.CreditCardTransactionResultCollection != null)
{
Console.WriteLine("Status transação: {0}", httpResponse.Response.CreditCardTransactionResultCollection.FirstOrDefault().CreditCardTransactionStatus);
}
return(httpResponse);
}
catch (Exception)
{
throw;
}
}
public HttpResponseMessage CreateSale(CreateSaleRequest request)
{
try
{
if (ModelState.IsValid)
{
var manager = new SalesManager();
manager.QueueSale(request);
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public override HttpResponse <CreateSaleResponse> Create(CreateTransactionForm form)
{
// Converts string into one of CreditCardBrandEnum options
CreditCardBrandEnum card = (CreditCardBrandEnum)Enum.Parse(typeof(CreditCardBrandEnum), form.CreditCardBrand);
// Creates Transaction
CreditCardTransaction transaction = new CreditCardTransaction()
{
AmountInCents = form.AmountInCents,
CreditCard = new CreditCard()
{
CreditCardBrand = card,
CreditCardNumber = form.CreditCardNumber,
ExpMonth = form.ExpMonth,
ExpYear = form.ExpYear,
HolderName = form.HolderName,
SecurityCode = form.SecurityCode.ToString()
},
InstallmentCount = form.InstallmentCount
};
// Cria requisição.
CreateSaleRequest createSaleRequest = new CreateSaleRequest()
{
// Adiciona a transação na requisição.
CreditCardTransactionCollection = new Collection <CreditCardTransaction>
(
new CreditCardTransaction[] { transaction }
),
Order = new Order()
{
OrderReference = "NumeroDoPedido"
}
};
// Autoriza a transação e recebe a resposta do gateway.
HttpResponse <CreateSaleResponse> httpResponse = serviceClient.Sale.Create(createSaleRequest);
return(httpResponse);
}
public CreateSaleRequest MapSaleRequest(Partner partner)
{
var buyer = new Buyer();
var transaction = new CreditCardTransaction();
var createSaleRequest = new CreateSaleRequest();
buyer.Email = partner.Email;
buyer.Name = partner.Name;
ExpiryDateStruct expiryDate = new ExpiryDateStruct();
expiryDate.Month = partner.CreditCard.ExpiryDate.Substring(0, 2); // MONTH_LENTH = 2
expiryDate.Year = partner.CreditCard.ExpiryDate.Substring(2 + 3); // MONTH_LENTH+1 + space + /
var computedBrand = CreditCardUtility.GetBrandByNumber(partner.CreditCard.Number);
// Cria a transação
transaction.AmountInCents = partner.Plan;
transaction.CreditCard = new GatewayApiClient.DataContracts.CreditCard();
transaction.CreditCard.CreditCardBrand = computedBrand;
transaction.CreditCard.CreditCardNumber = partner.CreditCard.Number;
transaction.CreditCard.ExpMonth = Convert.ToInt16(expiryDate.Month);
transaction.CreditCard.ExpYear = Convert.ToInt16(expiryDate.Year);
transaction.CreditCard.HolderName = partner.Name;
transaction.CreditCard.SecurityCode = partner.CreditCard.Cvv;
transaction.InstallmentCount = 1;
transaction.Recurrency = new Recurrency()
{
DateToStartBilling = DateTime.Now,
Frequency = FrequencyEnum.Monthly,
Interval = 1,
Recurrences = 0
};
// Adiciona a transação na requisição.
createSaleRequest.CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transaction });
createSaleRequest.Order = new Order();
return(createSaleRequest);
}
public async Task <HttpResponse <CreateSaleResponse> > CreateSale(CreateSaleRequest createSaleRequest)
{
using (var client = new HttpClient())
{
HttpContent content = new StringContent(Serialize(createSaleRequest), Encoding.UTF8);
content.Headers.Add("MerchantKey", MerchantKey.ToString());
content.Headers.Remove("Content-type");
content.Headers.Add("Content-type", "application/json");
//content.Headers.Add("Accept", "application/json");
var result = await client.PostAsync(SalesEndPointUrl, content);
var stream = await result.Content.ReadAsStreamAsync();
var rawContent = await result.Content.ReadAsStringAsync();
return(new HttpResponse <CreateSaleResponse>(Deserialize <CreateSaleResponse>(stream), rawContent, result.StatusCode));
}
}
public JsonResult SaveSale(List <SaleDetailRequest> saleRequests)
{
try
{
WCF.Service1Client client = new WCF.Service1Client();
if (saleRequests == null)
{
saleRequests = new List <SaleDetailRequest>();
return(Json(new { Success = false, ErrorMessage = "Sipariş satıları alınamadı" }));
}
var createSaleRequest = new CreateSaleRequest()
{
CustomerId = 1,//default
Quantity = saleRequests.Sum(u => u.Quantity),
SaleDate = DateTime.Now,
SalesPrice = saleRequests.Sum(u => u.SalesPrice),
SaleDetails = saleRequests.ToArray()
};
var response = client.CreateSale(createSaleRequest);
if (response != null)
{
return(Json(new { Success = true }));
}
else
{
return(Json(new { Success = false, ErrorMessage = "Bir hata oluştu" }));
}
}
catch (Exception _ex)
{
return(Json(new { Success = false, ErrorMessage = "Bir hata oluştu" }));
}
}
public PaymentResult PayWithCreditCard(BillingWithCreditCardBase billingData)
{
Contract.Requires(billingData != null);
Contract.Ensures(Contract.Result <PaymentResult>() != null);
ValidatorHelper.ThrowesIfHasDataAnnotationError(nameof(billingData), billingData);
Log.Information("Iniciada cobrança no Cartao de Credito");
var mundpaggCreditCardTransaction = Mapper.Map <CreditCardTransaction>(billingData);
mundpaggCreditCardTransaction.CreditCard.BillingAddress = Mapper.Map <BillingAddress>((billingData as BillingWithNewCreditCard)?.BillingAddress);
var requestData = new CreateSaleRequest()
{
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new[] { mundpaggCreditCardTransaction }),
Order = new Order()
{
OrderReference = billingData.Id.ToString()
}
};
Log.Debug("Dados Cartao de Credito. {dadosDaCobranca}", billingData);
try
{
Log.Debug("Criando Client do Gateway de Pagamentos");
var client = new GatewayServiceClient();
Log.Debug("Enviando dados de Cobrança para o Gateway");
var response = client.Sale.Create(requestData);
Log.Debug("Enviando dados de Cobrança para o Gateway - Finaliazado");
var orderGenerated = response.HttpStatusCode == HttpStatusCode.Created;
var succeful = orderGenerated && (response.Response?.CreditCardTransactionResultCollection.All(t => t.Success) ?? false);
var orderId = response.Response?.OrderResult?.OrderKey.ToString();
var message = GetMessage(errorWasValidation: orderGenerated == false, gatewayResponse: response.Response); //TODO
var rawData = response.RawResponse;
var savedCc = response.Response?.CreditCardTransactionResultCollection?.SingleOrDefault()?.CreditCard;
var savedCreditCard = savedCc == null ? null : new SavedCreditCard(savedCc.InstantBuyKey.ToString(), Mapper.Map <CreditCardBrand>(savedCc.CreditCardBrand), savedCc.MaskedCreditCardNumber);
var result = new PaymentResult(succeful, orderId, message, rawData, savedCreditCard);
Log.Debug("Resultado da Cobranca, {ResultadoDoPagamento}", result);
if (result.PaymentBilledSuccessful)
{
Log.Information("Cobrança no Cartao de Credito realizada com Sucesso.");
}
else
{
Log.Error("Erro durante a cobrança de cartão de credito. Cobrança não realizada. {mensagem}", message);
}
return(result);
}
catch (Exception ex)
{
Log.Error(ex, "Erro GRAVE INTERNO durante a cobrança de cartão de credito. Cobrança não realizada. {Exception}", ex);
return(new PaymentResult(false, null, "ERRO Interno do Sistema", ex.Message, null));
}
}
public static async Task <CreateSaleResponse> EnviarTransacao(CartaoCredito cartaoCredito)
{
var model = new CreateSaleResponse();
try
{
var transacao = new CreditCardTransaction()
{
AmountInCents = Convert.ToInt64(cartaoCredito.ValorVenda.ToString("N2").Replace(",", "")),
CreditCard = new CreditCard()
{
CreditCardBrand = cartaoCredito.CreditCardBrand,
CreditCardNumber = cartaoCredito.Numero,
ExpMonth = cartaoCredito.Validade.Substring(0, 2).DefaultInt(),
ExpYear = cartaoCredito.Validade.Substring(5, 2).DefaultInt(),
HolderName = cartaoCredito.Titular, //O nome do portador deve conter mais de um caracter
SecurityCode = cartaoCredito.CVV
},
InstallmentCount = cartaoCredito.NumeroParcelas,
Options = new CreditCardTransactionOptions()
{
//0 - PRODUÇÃO
//1 - HOMOLOGAÇÃO (TESTE)
PaymentMethodCode = 1,
CurrencyIso = CurrencyIsoEnum.BRL,
SoftDescriptorText = "Obraki" //Texto da fatura do cartão
},
CreditCardOperation = CreditCardOperationEnum.AuthAndCapture //Autorização e Captura Instantânea
};
var saleRequest = new CreateSaleRequest()
{
CreditCardTransactionCollection = new Collection <CreditCardTransaction>(new CreditCardTransaction[] { transacao }),
Order = new Order()
{
//Um dos campos que não é obrigatório, mas que é de extrema importância é o OrderReference.
//Aconselhamos que sempre envie essa informação, pois assim, facilitara a sua gestão!
OrderReference = cartaoCredito.OrderReference.ToString()
}
};
var data = JsonConvert.SerializeObject(saleRequest);
//HttpContent content = new StringContent(data, Encoding.UTF8, "application/json");
//content.Headers.Add("Keep-Alive", "true");
var request = (HttpWebRequest)WebRequest.Create(new Uri($"{Utils.STONE_BASE_URL}/Sale"));
request.ContentType = Utils.CONTENT_TYPE;
request.Accept = Utils.CONTENT_TYPE;
request.Method = "POST";
request.Headers["MerchantKey"] = Utils.STONE_MERCHANT_KEY;
using (var writer = new StreamWriter(await request.GetRequestStreamAsync()))
{
writer.Write(data);
writer.Flush();
writer.Dispose();
}
using (var response = await request.GetResponseAsync())
{
using (var stream = response.GetResponseStream())
{
var streamReader = new StreamReader(stream);
var result = streamReader.ReadToEnd();
if (!string.IsNullOrEmpty(result))
{
model = JsonConvert.DeserializeObject <CreateSaleResponse>(result);
}
else
{
model.ErrorReport = new ErrorReport()
{
ErrorItemCollection = new Collection <ErrorItem>()
{
new ErrorItem()
{
ErrorCode = 999,
Description = TransactionResult.Message("c999")
}
}
};
}
}
}
return(model);
}
catch (WebException ex)
{
using (WebResponse response = ex.Response)
{
HttpWebResponse httpResponse = (HttpWebResponse)response;
model.ErrorReport = new ErrorReport()
{
ErrorItemCollection = new Collection <ErrorItem>()
{
new ErrorItem()
{
ErrorCode = ((int)httpResponse.StatusCode),
Description = TransactionResult.Message(((int)httpResponse.StatusCode).ToString())
}
}
};
}
return(model);
//await Application.Current.MainPage.DisplayAlert("Informação", ex.Message, "OK");
}
}
public ServiceResponse <Sale> Create(Sale sale)
{
var request = new CreateSaleRequest(Merchant, Environment);
return(request.Execute(sale));
}
public async Task <ActionResult> CreateOrder([FromBody] CreateSaleRequest request)
{
try
{
if (request == null)
{
return(BadRequest("Invalid reqeust"));
}
if (request.MedicineId == 0 && request.RecipeId == 0)
{
return(BadRequest("Either MedicineId or RecipeId must be provided"));
}
if (request.RecipeId != 0)
{
var recipe = await _saleService.GetRecipeById(request.RecipeId);
if (recipe == null)
{
return(BadRequest("Recipe from request doesn't exist"));
}
if (request.MedicineId != 0 && recipe.MedicineId != request.MedicineId)
{
return(BadRequest("Medicine id doesn't match to recipe medicine id"));
}
var _sale = new SaleDTO();
_mapper.Map(request, _sale);
var _httpClient = _httpClientFactory.CreateClient("Pharmacy");
//communication with other microservice
var response = await _httpClient.GetAsync("account/getAccountById?id=2");
if (response.IsSuccessStatusCode)
{
var account = response.Content.ReadAsStringAsync();
}
_sale.AccountId = 2;
await _saleService.SaveSale(_sale);
return(Ok());
}
var medicine = await _pharmacyService.GetMedicineById(request.MedicineId);
if (medicine == null)
{
return(BadRequest("Medicine with provided id doesn't exist"));
}
if (medicine.IsRecipeRequired)
{
return(BadRequest("This medicine cannot be order without recipe"));
}
var sale = new SaleDTO();
_mapper.Map(request, sale);
//communication with other microservice
sale.AccountId = 2;
await _saleService.SaveSale(sale);
return(Ok());
}
catch (Exception e)
{
throw e;
}
}
public HttpResponse Create(CreateSaleRequest service)
{
// retornos
return(new HttpResponse());
}
public async Task <IActionResult> CreateSale([FromBody] CreateSaleRequest request)
{
var customerFilter = Builders <Customer> .Filter.Where(x => x.Id.Equals(request.CustomerId));
var validCustomer = await _mongoDbService.GetCollection <Customer>(Collections.Customers)
.Find(customerFilter).AnyAsync();
if (!validCustomer)
{
throw new CustomException("Invalid customer specified.");
}
var productFilter = Builders <Product> .Filter.In(x => x.Id, request.Details.Select(d => d.ProductId));
var products = await _mongoDbService.GetCollection <Product>(Collections.Products)
.Find(productFilter).ToListAsync();
var validProducts = request.Details
.All(d => products.Any(p => p.Id.Equals(d.ProductId) && p.Stock >= d.Quantity));
if (!validProducts)
{
throw new CustomException("Invalid products specified.");
}
var session = await _mongoDbService.StartTransactionAsync();
var newSale = new Sale()
{
CustomerId = request.CustomerId,
ReceiptType = request.ReceiptType.Trim().ToLowerInvariant(),
Tax = request.Tax,
Total = Math.Round(request.Details.Sum(d => d.Quantity * d.UnitPrice * (1 - (d.Discount / 100))) * (1 + (request.Tax / 100)), 2),
Date = DateTime.Now,
Approved = true,
Details = request.Details.Select(d => new SaleDetail()
{
ProductId = d.ProductId,
Quantity = d.Quantity,
UnitPrice = d.UnitPrice,
Discount = d.Discount
})
.ToList()
};
await _mongoDbService.GetCollection <Sale>(Collections.Sales).InsertOneAsync(session, newSale);
await request.Details.ForEachAsync(async item =>
{
var productFilter = Builders <Product> .Filter.Where(p => p.Id.Equals(item.ProductId));
var stockUpdateDefinition = new UpdateDefinitionBuilder <Product>()
.Inc(x => x.Stock, -item.Quantity);
await _mongoDbService.GetCollection <Product>(Collections.Products)
.UpdateOneAsync(session, productFilter, stockUpdateDefinition);
});
await _mongoDbService.CommitTransactionAsync();
return(new SuccessResult());
}
public void ItShouldCreateSaleWithAllFields()
{
CreateSaleRequest saleRequest = new CreateSaleRequest();
// Dados da transação de cartão de crédito.
saleRequest.CreditCardTransactionCollection = new Collection <CreditCardTransaction>()
{
new CreditCardTransaction()
{
AmountInCents = 100,
CreditCardOperation = CreditCardOperationEnum.AuthAndCapture,
CreditCard = new CreditCard()
{
CreditCardBrand = CreditCardBrandEnum.Visa,
CreditCardNumber = "4111111111111111",
ExpMonth = 10,
ExpYear = 2018,
HolderName = "Somebody",
SecurityCode = "123"
},
// Opcional.
Options = new CreditCardTransactionOptions()
{
// Indica que a transação é de simulação.
PaymentMethodCode = 1
}
}
};
// Dados do comprador.
saleRequest.Buyer = new Buyer()
{
DocumentNumber = "11111111111",
DocumentType = DocumentTypeEnum.CPF,
Email = "*****@*****.**",
EmailType = EmailTypeEnum.Personal,
Gender = GenderEnum.M,
HomePhone = "(21) 12345678",
Name = "Somebody",
PersonType = PersonTypeEnum.Person,
AddressCollection = new Collection <BuyerAddress>()
{
new BuyerAddress()
{
AddressType = AddressTypeEnum.Residential,
City = "Rio de Janeiro",
Complement = "10º floor",
Country = CountryEnum.Brazil.ToString(),
District = "Centro",
Number = "199",
State = "RJ",
Street = "Rua da Quitanda",
ZipCode = "20091005"
}
}
};
// Dados do carrinho de compras.
saleRequest.ShoppingCartCollection = new Collection <ShoppingCart>()
{
new ShoppingCart()
{
FreightCostInCents = 0,
ShoppingCartItemCollection = new Collection <ShoppingCartItem>()
{
new ShoppingCartItem()
{
Description = "Teclado Padrão",
ItemReference = "#1234",
Name = "Teclado",
Quantity = 3,
TotalCostInCents = 60,
UnitCostInCents = 20
}
}
}
};
// Indica que o pedido usará anti fraude.
saleRequest.Options.IsAntiFraudEnabled = true;
// Cria o cliente que enviará a transação para o gateway.
IGatewayServiceClient serviceClient = this.GetGatewayServiceClient();
// Autoriza a transação de cartão de crédito e recebe a resposta do gateway.
HttpResponse <CreateSaleResponse> httpResponse = serviceClient.Sale.Create(saleRequest);
Assert.AreEqual(HttpStatusCode.Created, httpResponse.HttpStatusCode);
}
