private void OpenAndSetupSalePopup()
{
salePopup.Open();
salePopup.OnSaleClick =
creditCardTransaction =>
{
SaleRequest request = new SaleRequest()
{
MerchantKey = currentMerchant.MerchantKey,
CreditCardTransactionCollection = new CreditCardTransaction[] { creditCardTransaction }
};
MundiPaggClientAPI.Sale(request,
result =>
{
salePopup.Close();
float transactionCost = creditCardTransaction.AmountInCents / 100f;
CreditCardTransactionResult transactionResult = result.CreditCardTransactionResultCollection[0];
if (transactionResult.Success)
{
MessagePopup.Open("Sucesso", string.Format("Compra de R$ {0:0.00} efetuada com sucesso!", transactionCost));
}
else
{
MessagePopup.Open("Erro", transactionResult.AcquirerMessage);
}
},
error =>
{
MessagePopup.Open(error.ErrorCode.ToString(), error.GetErrorMessage());
}
);
};
}
public SaleResponse Sale(string deviceUuid, SaleRequest saleRequest)
{
var request = new RestRequest("sale", Method.POST);
request.AddQueryParameter("uuid", deviceUuid);
request.AddJsonBody(saleRequest);
var response = _clientHttp.Execute(request);
if (response.ErrorException != null)
{
throw new SmartPaymentException(response.ErrorException.Message);
}
var content = response.Content;
if (response.StatusCode == HttpStatusCode.OK)
{
return(JsonUtils.DecodeJson <SaleResponse>(content));
}
else
{
throw ProcessWebServiceException(content);
}
}
public Task <Sale> UploadETicketUrlsAsync(
int saleId,
IEnumerable <string> eticketUrls,
SaleRequest request)
{
return(UploadETicketUrlsAsync(saleId, eticketUrls, request, CancellationToken.None));
}
public Task <Sale> UploadTransferConfirmationNumberAsync(
int saleId,
string transferConfirmationNumber,
SaleRequest request)
{
return(UploadTransferConfirmationNumberAsync(saleId, transferConfirmationNumber, request, CancellationToken.None));
}
static void Main(string[] args)
{
cloverConnector = CloverConnectorFactory.createICloverConnector(SampleUtils.GetNetworkConfiguration());
var ccl = new ExampleCloverConnectionListener(cloverConnector);
cloverConnector.AddCloverConnectorListener(ccl);
cloverConnector.InitializeConnection();
while (!ccl.deviceReady)
{
Thread.Sleep(1000);
}
var pendingSale = new SaleRequest();
pendingSale.ExternalId = ExternalIDUtil.GenerateRandomString(13);
pendingSale.Amount = 1000;
pendingSale.AutoAcceptSignature = true;
pendingSale.AutoAcceptPaymentConfirmations = true;
pendingSale.DisableDuplicateChecking = true;
cloverConnector.Sale(pendingSale);
while (!ccl.saleDone)
{
Thread.Sleep(1000);
}
Console.ReadKey();
}
public async Task <IActionResult> AddSale(SaleRequest sale)
{
DataResponse response = new DataResponse();
try
{
if (!ModelState.IsValid)
{
response.Message = string.Join("", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(response));
}
var client = await _clientService.GetById(sale.IdClient);
if (client == null)
{
response.Message = "The id client is not found.";
return(NotFound(response));
}
await _saleService.Add(sale);
response.Success = 1;
response.Message = "The sale has been added.";
return(Ok(response));
}
catch (Exception ex)
{
response.Message = ex.Message;
return(StatusCode(500, response));
}
}
// POST: api/BankSale
public HttpResponseMessage Post([FromBody] SaleRequest saleRequest)
{
//json formatında data gelcek
//formatlıcak
//dbye token oluşturup kayıt atcak
SaleResponse saleResponse = new SaleResponse();
SalePersistence sp = new SalePersistence();
long bankguid = 0;
bankguid = sp.insertTransaction(saleRequest);
//token algorihm
string token_data = new Utilities().generateToken(saleRequest, bankguid.ToString());
sp.updateTransactionTokenByGuid(token_data, bankguid);
saleResponse.token_data = token_data;
JObject payLoad = new JObject(
new JProperty("error_code", "0000000"),
new JProperty("error_desc", "Basarili"),
new JProperty("token_data", saleResponse.token_data),
new JProperty("bank_transaction_guid", bankguid)
);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(payLoad.ToString())
});
}
/// <summary>
/// Returns a sample sale request
/// </summary>
/// <returns>
/// A sample sale request
/// </returns>
private SaleRequest GetSaleRequest()
{
var request = new SaleRequest();
request.Configuration = new Configuration();
request.Address = new Address();
request.Address.BillingAddress1 = "123 Sample Street";
request.Address.BillingAddress2 = "Suite 101";
request.Address.BillingCity = "Chandler";
request.Address.BillingState = "AZ";
request.Address.BillingPostalCode = "85224";
request.ClerkNumber = "Clerk101";
request.Configuration.CurrencyCode = "Usd";
request.EmvFallbackReason = "None";
request.LaneId = 9999;
request.Configuration.MarketCode = "Retail";
request.Configuration.AllowPartialApprovals = false;
request.Configuration.CheckForDuplicateTransactions = true;
request.ReferenceNumber = "Ref000001";
request.ShiftId = "ShiftA";
request.TicketNumber = "T0000001";
request.TransactionAmount = 3.25M;
return(request);
}
public async Task <HttpResult <Loja> > CreateTransactionStoneAsync(SaleRequest request, int lojaId)
{
var retorno = new HttpResult <Loja>();
var response = await _serviceClient.TransacitonAsync(request);
if (response.ErrorReport != null && response.ErrorReport.ErrorItemCollection.FirstOrDefault().ErrorCode.GetHashCode() >= 400)
{
return(retorno.Set(response.ErrorReport.ErrorItemCollection.FirstOrDefault().ErrorCode, $"{response.ErrorReport.ErrorItemCollection.FirstOrDefault().ErrorCode} - {response.ErrorReport.ErrorItemCollection.FirstOrDefault().Description}"));
}
var loja = await RegistrarTransacao(lojaId);
loja.Response.RegistroTransacaoStone = new Collection <RegistroTransacaoStone>();
foreach (var item in response.CreditCardTransactionResultCollection)
{
loja.Response.RegistroTransacaoStone.Add(new RegistroTransacaoStone
{
AuthorizationCode = item.AuthorizationCode,
AcquirerMessage = item.AcquirerMessage,
TransactionIdentifier = item.TransactionIdentifier,
TransactionKey = item.TransactionKey,
UniqueSequentialNumber = item.UniqueSequentialNumber,
OrderReference = response.OrderResult.OrderReference
});
}
_dbContext.SaveChanges();
retorno.Response = loja.Response;
return(retorno);
}
public void Sale(HttpListenerContext context)
{
SaleRequest message = ParseRequest <SaleRequest>(context);
GetServer.CloverConnector.Sale(message);
this.SendTextResponse(context, "");
}
public void Add(SaleRequest req)
{
using var transaction = _context.Database.BeginTransaction();
try
{
var sale = new Sale();
sale.Total = req.Total;
sale.Date = DateTime.Now;
_context.Sale.Add(sale);
_context.SaveChanges();
foreach (var reqConcept in req.Concepts)
{
Concept concept = new Concept
{
IdSale = sale.Id,
IdProduct = reqConcept.IdProduct,
Amount = reqConcept.Amount,
};
_context.Concept.Add(concept);
_context.SaveChanges();
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw new Exception("Error on the transaction");
}
}
// Credit Card Sale
public async Task <SaleResponse> Sale(SaleRequest req)
{
string jsonRequest = CommonService.JsonSerializer <SaleRequest>(req);
string jsonResponse = await PostRequest(jsonRequest, "authorize");
return(CommonService.JsonDeSerializer <SaleResponse>(jsonResponse));
}
public SaleRequest SetSaleRequest(SaleRequest request)
{
var newRequest = Context.SaleRequests.Add(request);
Context.SaveChanges();
return(newRequest);
}
public Task <SaleResponse> AuthorizeAndCaptureAmountAsync(SaleRequest saleRequest)
{
var request = new RestRequest(Urls.TransactionsApiV1Sale, Method.POST);
request.AddJsonBody(saleRequest);
return(MakeRestRequest <SaleResponse>(request));
}
public Task <Sale> ChangeTicketTypeAsync(
int saleId,
ApiTicketType ticketType,
SaleRequest request)
{
return(ChangeTicketTypeAsync(saleId, ticketType, request, CancellationToken.None));
}
public async Task <SaleResponse> ProccessSale(SaleRequest saleRequest)
{
SaleResponse saleResponse = null;
try
{
var order = new Orders()
{
Custid = saleRequest.Custid,
Empid = saleRequest.Empid,
Freight = saleRequest.Freight,
Orderdate =
saleRequest.Orderdate,
Requireddate = saleRequest.Requireddate,
Shipaddress = saleRequest.Shipaddress,
Shipcity = saleRequest.Shipcity,
Shipcountry = saleRequest.Shipcountry,
Shipname = saleRequest.Shipname,
Shippeddate = saleRequest.Shippeddate,
Shipperid = saleRequest.Shipperid,
Shippostalcode = saleRequest.Shippostalcode,
Shipregion = saleRequest.Shipregion,
};
_shopContext.Orders.Add(order);
saleRequest.OrderDetails.ForEach((orderDetails) =>
{
order.OrderDetails.Add(new OrderDetails()
{
Orderid = order.Orderid,
Discount = orderDetails.Discount,
Productid = orderDetails.Productid,
Qty = orderDetails.Qty,
Unitprice = orderDetails.Unitprice
});
});
await _shopContext.SaveChangesAsync();
saleResponse = new SaleResponse()
{
Success = true, Message = "Sales Proccess.."
};
}
catch (Exception ex)
{
string message = "Error procesing the sale";
_logger.LogError($"{message} {ex.Message}", ex);
saleResponse = new SaleResponse()
{
Message = "Error procesing the sale", Success = false
};
}
return(saleResponse);
}
//TODO: AutoMapper
public static TransactionDto ConvertToTransactionDto(this SaleRequest saleRequest)
{
return(new TransactionDto
{
RequestId = saleRequest.RequestId,
MerchantOrderId = saleRequest.MerchantOrderId,
Customer = new CustomerDto
{
BirthDate = saleRequest.Customer?.BirthDate,
Email = saleRequest.Customer?.Email,
IpAddress = saleRequest.Customer?.IpAddress,
PhoneAreaCode = saleRequest.Customer?.PhoneAreaCode,
PhoneNumber = saleRequest.Customer?.PhoneNumber,
Identity = saleRequest.Customer?.Identity,
IdentityType = saleRequest.Customer?.IdentityType,
Name = saleRequest.Customer?.Name,
BillingAddress = new BillingAddressDto
{
City = saleRequest.Customer?.BillingAddress?.City,
Complement = saleRequest.Customer?.BillingAddress?.Complement,
Country = saleRequest.Customer?.BillingAddress?.Country,
District = saleRequest.Customer?.BillingAddress?.District,
Number = saleRequest.Customer?.BillingAddress?.Number,
State = saleRequest.Customer?.BillingAddress?.State,
Street = saleRequest.Customer?.BillingAddress?.Street,
ZipCode = saleRequest.Customer?.BillingAddress?.ZipCode
},
ShippingAddress = new ShippingAddressDto
{
City = saleRequest.Customer?.ShippingAddress?.City,
Complement = saleRequest.Customer?.ShippingAddress?.Complement,
Country = saleRequest.Customer?.ShippingAddress?.Country,
District = saleRequest.Customer?.ShippingAddress?.District,
Number = saleRequest.Customer?.ShippingAddress?.Number,
State = saleRequest.Customer?.ShippingAddress?.State,
Street = saleRequest.Customer?.ShippingAddress?.Street,
ZipCode = saleRequest.Customer?.ShippingAddress?.ZipCode
}
},
Payment = new PaymentDto
{
Amount = saleRequest.Payment.Amount.Value,
CreditCard = new CreditCardDto
{
Number = saleRequest.Payment.CreditCard.Number,
ExpirationMonth = saleRequest.Payment.CreditCard.ExpirationMonth,
ExpirationYear = saleRequest.Payment.CreditCard.ExpirationYear,
Brand = saleRequest.Payment.CreditCard.Brand,
Holder = saleRequest.Payment.CreditCard.Holder,
SecurityCode = saleRequest.Payment.CreditCard.SecurityCode
},
Type = Domain.Enums.PaymentType.CreditCard,
Currency = saleRequest.Payment.Currency,
Installments = saleRequest.Payment.Installments,
SoftDescriptor = saleRequest.Payment.SoftDescriptor
},
Status = Domain.Enums.TransactionStatus.Captured,
});
}
private bool ProcessAntiFraud(Store store, SaleRequest request)
{
if (store.HasAntiFraudAgreement)
{
return(_antiFraudProvider.IsSecure(request));
}
return(true);
}
public async override Task <HttpResponseMessage> SendRequest(Store store, SaleRequest saleRequest)
{
HttpClient client = new HttpClient();
var jsonInString = ""; //JsonConvert.SerializeObject(transactionToSend);
var result = await client.PostAsync("https://transaction.stone.com.br", new StringContent(jsonInString, Encoding.UTF8, "application/json"));
return(result);
}
public void Sale(SaleRequest request)
{
if (websocket != null)
{
SaleRequestMessage message = new SaleRequestMessage();
message.payload = request;
websocket.Send(JsonUtils.serialize(message));
}
}
public long insertTransaction(SaleRequest saleRequest)
{
string sqlStringInsert = "Insert into BANK_TRANSACTION (merchant_no, terminal_no, amount, transaction_status, merchant_transaction_guid)values('" + saleRequest.merchant_no + "','" + saleRequest.terminal_no + "'," + saleRequest.amount + ", 'P', " + saleRequest.merchant_transaction_guid + ")";
MySql.Data.MySqlClient.MySqlCommand cmd = new MySql.Data.MySqlClient.MySqlCommand(sqlStringInsert, conn);
cmd.ExecuteNonQuery();
long guidTokenless = cmd.LastInsertedId;
return(guidTokenless);
}
private async Task <Sale> UpdateAsync(
int saleId,
SaleUpdate update,
SaleRequest request,
CancellationToken cancellationToken)
{
var saleLink = await _linkFactory.CreateLinkAsync($"sales/{saleId}").ConfigureAwait(_halClient);
return(await _halClient.PatchAsync <Sale>(saleLink, update, request, cancellationToken));
}
public Response <SaleResponse> Sale(SaleRequest item)
{
var uid = this.GetUserIdOrDefault() ?? 0;
var res = this.Reply(() => {
var multiple = false;
if (item.Tipo == SaleType.Sale)
{
var response = _process.Sale(item, uid);
if (response.Multiple)
{
item.Tipo = SaleType.Note;
multiple = true;
}
else
{
return(response);
}
}
if (item.Tipo == SaleType.Note)
{
var xml = BusinessLogic.Helpers.Serializer.Serialize(item);
var ctx = new DataAccess.SirCoPOSDataContext();
var eitem = new DataAccess.SirCoPOS.Nota
{
Date = DateTime.Now,
CajeroId = uid,
Sucursal = item.Sucursal,
Data = xml,
Multiple = multiple
};
ctx.Notas.Add(eitem);
ctx.SaveChanges();
return(new SaleResponse
{
Folio = $"Nota-{eitem.Id}"
});
}
return(null);
});
//if (res.Success)
//{
// //var txt = System.Web.HttpUtility.UrlEncode($"Gracias por tu compra, folio: {res.Item.Folio}");
// //var url = $"http://dev.itnnovation.net:81/FCM/api/sendMessage?number={8112123587}&txt={txt}";
// var url = $"http://dev.itnnovation.net:81/FCM/api/sendMessage";
// var client = new WebClient();
// client.QueryString.Add("number", "8112123587");
// client.QueryString.Add("txt", $"Gracias por tu compra, folio: {res.Item.Folio}");
// var reqparm = new System.Collections.Specialized.NameValueCollection();
// //var response = client.UploadValues(url, "POST", reqparm);
//}
return(res);
}
public async Task <ChangedResources <Sale> > GetAllChangesAsync(
Link nextLink,
SaleRequest request,
CancellationToken cancellationToken)
{
var changedResources = await _halClient.GetChangedResourcesAsync <Sale>(nextLink, request, cancellationToken);
return(new ChangedResources <Sale>(
changedResources.NewOrUpdatedResources.GroupBy(l => l.Id).Select(l => l.OrderByDescending(o => o.UpdatedAt ?? o.CreatedAt).First()).ToList(),
changedResources.DeletedResources.GroupBy(l => l.Id).Select(l => l.First()).ToList(),
changedResources.NextLink));
}
public async Task <SaleResponse> CreateSaleAsync(SaleRequest request, MerchantCredentials credentials = null)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (_credentials == null && credentials == null)
{
throw new InvalidOperationException("Credentials are null");
}
var currentCredentials = credentials ?? _credentials;
if (string.IsNullOrWhiteSpace(currentCredentials.MerchantId))
{
throw new InvalidOperationException("Invalid credentials: MerchantId is null");
}
if (string.IsNullOrWhiteSpace(currentCredentials.MerchantKey))
{
throw new InvalidOperationException("Invalid credentials: MerchantKey is null");
}
var httpRequest = new RestRequest(@"v2/sales/", Method.POST)
{
RequestFormat = DataFormat.Json
};
httpRequest.AddHeader("Content-Type", "application/json");
httpRequest.AddHeader("MerchantId", currentCredentials.MerchantId);
httpRequest.AddHeader("MerchantKey", currentCredentials.MerchantKey);
httpRequest.AddHeader("RequestId", Guid.NewGuid().ToString());
httpRequest.AddBody(new { request.MerchantOrderId, request.Customer, request.Payment });
var cancellationTokenSource = new CancellationTokenSource();
var httpResponse = await RestClientApi.ExecuteTaskAsync(httpRequest, cancellationTokenSource.Token);
if (httpResponse.StatusCode != HttpStatusCode.Created)
{
return(new SaleResponse
{
HttpStatus = httpResponse.StatusCode,
ErrorDataCollection = httpResponse.StatusCode != HttpStatusCode.Forbidden ? JsonDeserializer.Deserialize <List <ErrorData> >(httpResponse) : null
});
}
var jsonResponse = JsonDeserializer.Deserialize <SaleResponse>(httpResponse);
jsonResponse.HttpStatus = httpResponse.StatusCode;
return(jsonResponse);
}
protected override void Execute(CodeActivityContext context)
{
ITracingService = context.GetExtension <ITracingService>();
IWorkflowContext = context.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory = context.GetExtension <IOrganizationServiceFactory>();
IOrganizationService = IOrganizationServiceFactory.CreateOrganizationService(IWorkflowContext.UserId);
EntityReference Sale = SaleReference.Get(context);
try
{
string WebServiceURL = WebServiceURLReference.Get(context);
unitIDValue = UnitID.Get(context);
destinationValue = Destination.Get(context);
projectValue = Project.Get(context);
if (Sale != null)
{
SaleRequest SaleRequest = ConstructSaleRequest(Sale);
//ITracingService.Trace("before calling web service");
Response WebServiceResponse = CallPostWebSevice(WebServiceURL, SaleRequest);
IsWeServiceExecuted.Set(context, WebServiceResponse.ResponseStatus);
if (!WebServiceResponse.ResponseStatus || WebServiceResponse.IGounaWebServiceStatusCode.Equals("-1"))
{
//Logger.LogException(new ArgumentNullException(), PriorityLevel.CRITICAL, "Web Service Excepion " + WebServiceResponse.Exception, IOrganizationService);
Entity failedEntityUpdate = new Entity("new_contracting");
failedEntityUpdate.Id = Sale.Id;
failedEntityUpdate["ldv_igounasynced"] = new OptionSetValue(2);
IOrganizationService.Update(failedEntityUpdate);
}
else
{
Entity successSaleSyncEntity = new Entity("new_contracting");
successSaleSyncEntity.Id = Sale.Id;
successSaleSyncEntity["ldv_igounasynced"] = new OptionSetValue(1);
IOrganizationService.Update(successSaleSyncEntity);
}
}
else
{
//Logger.LogException(new ArgumentNullException(), PriorityLevel.CRITICAL, "Sale doesn't conatains a value", IOrganizationService);
}
}
catch (Exception exception)
{
Entity failedEntityUpdate = new Entity("new_contracting");
failedEntityUpdate.Id = Sale.Id;
failedEntityUpdate["ldv_igounasynced"] = new OptionSetValue(2);
IOrganizationService.Update(failedEntityUpdate);
//throw;
//throw new InvalidPluginExecutionException(exception.Message);
//Logger.LogException(exception, PriorityLevel.CRITICAL, exception.Message, IOrganizationService);
}
}
public void do_save()
{
try
{
if (do_Validation())
{
return;
}
if (_parameters.SaleProductEndDate.GetValueOrDefault())
{
foreach (var item in __dl_List_SaleTrans)
{
if (item.ProductDate == DateTime.Now)
{
DevExpress.XtraEditors.XtraMessageBox.Show("Son Kullanma Tarihi Geçmiş Ürün " + item.ProductName, "Uyarı", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
}
__dl_SaleOwner.UserCode = AppMain.User.username;
__dl_SaleOwner.CompanyRecId = AppMain.CompanyRecId;
var req = new SaleRequest
{
List_SaleTrans = __dl_List_SaleTrans,
SaleOwnerDTO = __dl_SaleOwner
};
var response = _repository.Run <SaleService, ActionResponse <SaleRequest> >(x => x.Save_Sale(req));
if (response.ResponseType != ResponseType.Ok)
{
DevExpress.XtraEditors.XtraMessageBox.Show(response.Message, "HATA", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
else
{
if (_parameters.SaleNewRecord.GetValueOrDefault())
{
__dl_SaleOwner = new SaleOwnerDTO();
__dl_List_SaleTrans.Clear();
__dl_List_SaleTrans = new List <SaleTransDTO>();
//txt_CustomerName.Text = "";
txt_Total.EditValue = __dl_SaleOwner.TotalPriceText = "₺ 0.00";
//txt_OdemeTipi.EditValue = "";
gridControl1.RefreshDataSource();
TopTotal();
}
}
}
catch (Exception)
{
throw;
}
}
public ActionResult Create([FromBody] SaleRequest request)
{
var sale = request.Sale;
_context.Sales.Add(sale);
_context.SaveChanges();
var format = request.TableFormat;
return(Ok(new Message(true,
"Success",
GetSales(format.TableSize, format.SortColumn, format.Asc, format.CurrentPage)
)));
}
public async Task <IActionResult> Post([FromBody] SaleRequest request)
{
var transactionDto = request.ConvertToTransactionDto();
transactionDto.MerchantId = Guid.Parse(Request.Headers["MerchantId"]);
var processResult = await SaleService.Process(transactionDto);
var response = transactionDto.ConvertToSaleResponse();
response.Links = GetLinks(response.Id);
return(Created($"Sale/{response.Id}", response));
}
public IActionResult Add(SaleRequest model)
{
var response = new Response();
try
{
using var db = new salesSystemContext();
using var transaction = db.Database.BeginTransaction();
try
{
var sale = new Models.Sale
{
Total = model.Concepts.Sum(d => d.Amount * d.PriceUnit),
CreatedAt = DateTime.Now,
FkClientId = model.IdClient
};
db.Sales.Add(sale);
db.SaveChanges();
foreach (var concept in model.Concepts.Select(rowConcept => new Concept
{
FkProductId = rowConcept.IdProduct,
PriceUnit = rowConcept.PriceUnit,
Amount = rowConcept.Amount,
Total = rowConcept.Total,
FkSaleId = sale.Id
}))
{
db.Concepts.Add(concept);
db.SaveChanges();
}
response.Success = true;
transaction.Commit();
}
catch (Exception e)
{
Console.WriteLine(e);
transaction.Rollback();
}
}
catch (Exception e)
{
Console.WriteLine(e);
response.Message = e.Message;
return(BadRequest(response));
}
return(Ok(response));
}