internal static OrderNote CreateOrderNote(string comment)
{
//return new OrderNote(Platform.Time, TestStaffFactory.CreateStaff(StaffType.STEC), comment);
OrderNote note = new OrderNote();
note.CreationTime = Platform.Time;
note.Author = TestStaffFactory.CreateStaff(new StaffTypeEnum("STEC", null, null));
note.Body = comment;
return note;
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
if(!string.IsNullOrEmpty(txtNote.Text)) {
try {
OrderNote orderNote = new OrderNote();
orderNote.OrderId = orderId;
orderNote.Note = txtNote.Text.Trim();
orderNote.Save(WebUtility.GetUserName());
LoadOrderNotes();
txtNote.Text = string.Empty;
base.MasterPage.MessageCenter.DisplaySuccessMessage(LocalizationUtility.GetText("lblOrderNoteSaved"));
}
catch(Exception ex) {
Logger.Error(typeof(notes).Name + ".btnSave_Click", ex);
base.MasterPage.MessageCenter.DisplayCriticalMessage(ex.Message);
}
}
}
public void Can_save_and_load_orderNote()
{
var on = new OrderNote
{
Order = GetTestOrder(),
Note = "Note1",
DownloadId = 1,
DisplayToCustomer = true,
CreatedOnUtc = new DateTime(2010, 01, 01),
};
var fromDb = SaveAndLoadEntity(on);
fromDb.ShouldNotBeNull();
fromDb.Note.ShouldEqual("Note1");
fromDb.DownloadId.ShouldEqual(1);
fromDb.DisplayToCustomer.ShouldEqual(true);
fromDb.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.Order.ShouldNotBeNull();
}
public static async Task SubmitToISAMAsync(this Order order)
{
var isamOrderService = EngineContext.Current.Resolve <IIsamOrderService>();
await isamOrderService.InsertOrderAsync(order);
order.CardNumber = null;
order.CardCvv2 = null;
order.CardName = null;
var orderService = EngineContext.Current.Resolve <IOrderService>();
var orderNote = new OrderNote
{
OrderId = order.Id,
DisplayToCustomer = false,
Note = "Submitted to ISAM",
CreatedOnUtc = DateTime.UtcNow,
};
await orderService.InsertOrderNoteAsync(orderNote);
await orderService.UpdateOrderAsync(order);
}
private void ProcessVendorManufacturer(OrderTaskContext context, VendorManufacturer vendorOrManufacturer)
{
if (vendorOrManufacturer != null)
{
var n = new OrderNote();
n.IsPublic = false;
if (!SendEmail(context, vendorOrManufacturer, context.Order))
{
n.Note = "Drop shipper notices for " + vendorOrManufacturer.DisplayName +
" were not able to send correctly.";
}
else
{
n.Note = "Drop shipper notices for " + vendorOrManufacturer.DisplayName + " were sent successfully.";
}
context.Order.Notes.Add(n);
context.HccApp.OrderServices.Orders.Upsert(context.Order);
}
}
public async Task <Result <bool> > CreateOrderNote([FromBody] ManageOrderNoteModel orderNoteModel)
{
if (!Validate(orderNoteModel))
{
return(false);
}
var orderNote = new OrderNote()
{
Title = orderNoteModel.Title,
Description = orderNoteModel.Description,
CustomerTypes = orderNoteModel.CustomerTypes?.Select(x => new OrderNoteToCustomerType()
{
IdCustomerType = x
}).ToList(),
};
await _orderNoteService.AddOrderNoteAsync(orderNote, Convert.ToInt32(_userManager.GetUserId(User)));
return(true);
}
private void CannotAddProducts(PromotionContext context, List <LineItem> productIds)
{
var flag =
context.Order.CustomProperties
.FirstOrDefault(s => s.DeveloperId == HCC_KEY && s.Key == "sendflag");
if (flag == null || flag.Value != ONE)
{
var itemF = new CustomProperty(HCC_KEY, "sendflag", ONE);
context.Order.CustomProperties.Add(itemF);
foreach (var product in productIds)
{
var note = new OrderNote();
note.IsPublic = false;
note.Note = string.Format(GlobalLocalization.GetString("SkippingReceiveFreeProduct"),
product.ProductName, product.ProductSku);
context.Order.Notes.Add(note);
}
// sent mail to the store
var epio = new EmailProductIsOut();
epio.Execute(context.HccApp, context.Order);
}
var skus = string.Join(",", productIds.Select(p => p.ProductId).ToList());
var item =
context.Order.CustomProperties
.FirstOrDefault(s => s.DeveloperId == HCC_KEY && s.Key == "outfreeitems");
if (item == null)
{
item = new CustomProperty(HCC_KEY, "outfreeitems", skus);
context.Order.CustomProperties.Add(item);
}
else
{
item.Value = skus;
}
}
public LiquidOrder(Order order, string languageId = "", OrderNote orderNote = null, string vendorId = "", decimal refundedAmount = 0)
{
this._addressAttributeFormatter = EngineContext.Current.Resolve <IAddressAttributeFormatter>();
this._paymentService = EngineContext.Current.Resolve <IPaymentService>();
this._localizationService = EngineContext.Current.Resolve <ILocalizationService>();
this._priceFormatter = EngineContext.Current.Resolve <IPriceFormatter>();
this._currencyService = EngineContext.Current.Resolve <ICurrencyService>();
this._downloadService = EngineContext.Current.Resolve <IDownloadService>();
this._productAttributeParser = EngineContext.Current.Resolve <IProductAttributeParser>();
this._storeService = EngineContext.Current.Resolve <IStoreService>();
this._languageService = EngineContext.Current.Resolve <ILanguageService>();
this._dateTimeHelper = EngineContext.Current.Resolve <IDateTimeHelper>();
this._templatesSettings = EngineContext.Current.Resolve <MessageTemplatesSettings>();
this._catalogSettings = EngineContext.Current.Resolve <CatalogSettings>();
this._taxSettings = EngineContext.Current.Resolve <TaxSettings>();
this._order = order;
this._languageId = languageId;
this._orderNote = orderNote;
this._refundedAmount = refundedAmount;
this._language = _languageService.GetLanguageById(_languageId);
this._currency = _currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
this._orderItems = new List <LiquidOrderItem>();
var tempItems = order.OrderItems.ToList();
if (!string.IsNullOrEmpty(vendorId))
{
tempItems = tempItems.Where(x => x.VendorId == vendorId).ToList();
}
foreach (var orderItem in tempItems)
{
this._orderItems.Add(new LiquidOrderItem(orderItem, order, languageId));
}
CalculateSubTotals();
AdditionalTokens = new Dictionary <string, string>();
}
public void Execute()
{
CultureInfo culture = new CultureInfo("he-IL");
culture.DateTimeFormat.ShortDatePattern = "dd/MM/yyyy";
System.Threading.Thread.CurrentThread.CurrentCulture = culture;
System.Threading.Thread.CurrentThread.CurrentUICulture = culture;
using (Db _db = new Db())
{
DateTime date = DateTime.Now.AddMinutes(-10);
var orders = _db.Orders.Where(x => x.OrderStatus == OrderStatus.New &&
(x.PaymentMethod == PaymentMethod.Credit || x.PaymentMethod == PaymentMethod.CreditShopOwner) &&
x.CreateOn < date).ToList();
if (orders.Count > 0)
{
var messService = new MessageService(_db);
foreach (var order in orders)
{
messService.SendOrderUserCantPayToUser(order);
var shop = ShoppingService.GetShopByID(order.ShopID);
messService.SendOrderUserCantPayToMember(order, shop);
messService.SendOrderUserCantPayToAdmin(order);
order.OrderStatus = OrderStatus.Canceled;
var logrecord = new OrderNote()
{
CreateDate = DateTime.Now,
OrderID = order.ID,
Note = RP.S("Task.Order.Canceled.NotPaid"),
};
_db.OrderNotes.Add(logrecord);
// messService.OrderCanceledEmailToUser(order); //no need, already sended
}
_db.SaveChanges();
}
}
}
public override bool Execute(OrderTaskContext context)
{
var result = true;
if (context.Order != null)
{
var d = new FraudCheckData();
PopulateFraudData(d, context);
var scorer = new FraudScorer(context.HccApp.CurrentRequestContext);
context.Order.FraudScore = scorer.ScoreData(d);
if (context.Order.FraudScore >= 5)
{
var s = OrderStatusCode.FindByBvin(OrderStatusCode.OnHold);
context.Order.StatusCode = s.Bvin;
context.Order.StatusName = s.StatusName;
context.HccApp.OrderServices.Orders.Update(context.Order);
}
if (d.Messages.Count > 0)
{
var n = new OrderNote();
n.IsPublic = false;
n.Note = "Fraud Check Failed";
foreach (var m in d.Messages)
{
n.Note += " | " + m;
}
context.Order.Notes.Add(n);
}
context.HccApp.OrderServices.Orders.Update(context.Order);
}
return(result);
}
protected void OrderNotesGrid_RowCommand(object sender, GridViewCommandEventArgs e)
{
int orderNoteId = AlwaysConvert.ToInt(e.CommandArgument);
if (e.CommandName == "EditNote")
{
OrderNote n = OrderNoteDataSource.Load(orderNoteId);
EditComment.Text = n.Comment;
EditIsPrivate.Checked = n.IsPrivate;
EditIsRead.Checked = n.IsRead;
EditId.Value = orderNoteId.ToString();
EditPopup.Show();
}
else if (e.CommandName == "DeleteNote")
{
int index = _Order.Notes.IndexOf(orderNoteId);
if (index > -1)
{
_Order.Notes.DeleteAt(index);
}
BindOrderNotes();
}
}
protected void SubmitRefundButton_Click(object sender, EventArgs e)
{
//GET THE REFUND AMOUNT
string originalRefundAmount = string.Format("{0:F2}", _Payment.Amount);
decimal refundAmount = AlwaysConvert.ToDecimal(RefundAmount.Text);
// AC8-2854, AC8-3117: IF amount is not changed by merchant then
// to avoid rounding issues, restore the original amount upto 4 decimal digits
if (originalRefundAmount == RefundAmount.Text)
{
refundAmount = _Payment.Amount;
}
if (refundAmount > 0 && _Payment.PaymentStatus == PaymentStatus.Captured)
{
RefundTransactionRequest refundRequest = new RefundTransactionRequest(_Payment, Request.UserHostAddress);
if (CreditCardFields.Visible)
{
SetRequestForCreditCard(refundRequest);
}
else if (CheckFields.Visible)
{
SetRequestForCheck(refundRequest);
}
refundRequest.Amount = refundAmount;
PaymentEngine.DoRefund(refundRequest);
//_Payment.Refund(refundRequest);
if (!string.IsNullOrEmpty(CustomerNote.Text))
{
OrderNote note = new OrderNote(_Order.Id, AbleContext.Current.UserId, DateTime.UtcNow, CustomerNote.Text, NoteType.Public);
note.Save();
}
}
Response.Redirect("Default.aspx?OrderNumber=" + _Order.OrderNumber.ToString());
}
/// <summary>
/// Processes an order-note-added event
/// </summary>
/// <param name="note">Order note that has been added</param>
public static void OrderNoteAdded(OrderNote note)
{
//PROCESSING ONLY REQUIRED FOR PUBLIC NOTES
if (note.NoteType == NoteType.Public)
{
User author = note.User;
Order order = note.Order;
if ((author != null) && (order != null))
{
Hashtable parameters = new Hashtable();
parameters["order"] = order;
parameters["customer"] = order.User;
parameters["note"] = note;
if (author.UserId != order.UserId)
{
ProcessEmails(StoreEvent.OrderNoteAddedByMerchant, parameters);
}
else
{
ProcessEmails(StoreEvent.OrderNoteAddedByCustomer, parameters);
}
}
}
}
private bool ValidateSession(CheckoutViewModel model)
{
//If session is timeout (DNN User) dont allow to see anything.
if (model.IsLoggedIn == false || SessionManager.IsUserAuthenticated(this.HccApp) == false)
{
//model.Violations.Add(new RuleViolation("Session expired", "", "Oops! It looks like your shopping session has expired. Your order has not been placed. You'll need to place your order again. We're sorry for the inconvenience."));
string bvin = SessionManager.GetCurrentPaymentPendingCartId(HccApp.CurrentStore);
if (bvin.Trim().Length < 1)
{
Response.Redirect(Url.RouteHccUrl(HccRoute.Cart));
}
Order currentOrder = HccApp.OrderServices.Orders.FindForCurrentStore(bvin);
if (currentOrder != null)
{
currentOrder.StatusCode = OrderStatusCode.Cancelled;
currentOrder.StatusName = "Cancelled";
currentOrder.IsPlaced = false;
OrderNote n = new OrderNote();
n.IsPublic = true;
n.Note = "Order cancelled by the system due to a session timeout";
currentOrder.Notes.Add(n);
HccApp.OrderServices.Orders.Update(currentOrder);
//currentOrder.StatusCode = OrderStatusCode.SessionTimeout;
SessionManager.SetCurrentCartId(HccApp.CurrentStore, currentOrder.bvin);
SessionManager.SetCurrentPaymentPendingCartId(HccApp.CurrentStore, string.Empty);
SessionManager.SetSessionObject("SessionError_" + currentOrder.bvin, bool.TrueString);
}
return(true);
//return Redirect(Url.RouteHccUrl(HccRoute.Cart));
}
return(false);
}
public JsonResult CreateOrderNote(int id, OrderNoteViewModel orderNoteViewModel, [DataSourceRequest] DataSourceRequest dataSourceRequest)
{
// TODO: Use the current windows identity instead of hard coding.
User user = _userRepository.GetUserById(1);
OrderNote orderNote = new OrderNote
{
Note = orderNoteViewModel.Note,
PostedDate = DateTime.UtcNow,
UserId = user.UserId,
OrderId = id
};
orderNoteViewModel.Author = user.FullName;
_orderNotesRepository.Add(orderNote);
_orderNotesRepository.SaveChanges();
orderNoteViewModel.OrderNoteId = orderNote.OrderNoteId;
var resultData = new[] { orderNoteViewModel };
return(Json(resultData.AsQueryable().ToDataSourceResult(dataSourceRequest)));
}
public OrderNoteDetail CreateOrderNoteDetail(OrderNote orderNote, IPersistenceContext context)
{
return(CreateOrderNoteDetail(orderNote, null, context));
}
/// <summary>
/// Refunds the specified transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
/// <param name="refundedOrder">The refunded order.</param>
/// <param name="userName">Name of the user.</param>
public static void RefundStandard(Transaction transaction, Order refundedOrder, string userName)
{
Order order = new Order(transaction.OrderId);
Transaction refundTransaction = new Transaction();
//refundTransaction.OrderId = transaction.OrderId;
refundTransaction.TransactionTypeDescriptorId = (int)TransactionType.Refund;
refundTransaction.PaymentMethod = PAYPAL;
refundTransaction.GatewayName = PAYPAL_STANDARD;
refundTransaction.GatewayResponse = SUCCESS;
refundTransaction.GatewayTransactionId = CoreUtility.GenerateRandomString(16);
refundTransaction.GrossAmount = refundedOrder.Total;
refundTransaction.NetAmount = 0.00M;
refundTransaction.FeeAmount = 0.00M;
refundTransaction.TransactionDate = DateTime.Now;
//refundTransaction.Save(userName);
refundedOrder.Save(userName);
//set the orderid for the refund
foreach(OrderItem orderItem in refundedOrder.OrderItemCollection) {
orderItem.OrderId = refundedOrder.OrderId;
}
refundedOrder.OrderItemCollection.SaveAll(userName);
//set the orderId to the refunded orderId
refundTransaction.OrderId = refundedOrder.OrderId;
refundTransaction.Save(userName);
Guid userGuid = new Guid(Membership.GetUser(order.UserName).ProviderUserKey.ToString());
DownloadCollection downloadCollection;
foreach(OrderItem orderItem in refundedOrder.OrderItemCollection) {
//put the stock back
Sku sku = new Sku(Sku.Columns.SkuX, orderItem.Sku);
sku.Inventory = sku.Inventory + orderItem.Quantity;
sku.Save(userName);
ProductCache.RemoveSKUFromCache(orderItem.Sku);
//remove the access control
downloadCollection = new ProductController().FetchAssociatedDownloadsByProductIdAndForPurchase(orderItem.ProductId);
if (downloadCollection.Count > 0) {
foreach (Download download in downloadCollection) {
new DownloadAccessControlController().Delete(userGuid, download.DownloadId);
}
}
}
if(refundedOrder.Total == order.Total) {
order.OrderStatusDescriptorId = (int)OrderStatus.OrderFullyRefunded;
}
else {
order.OrderStatusDescriptorId = (int)OrderStatus.OrderPartiallyRefunded;
}
order.Save(userName);
//Add an OrderNote
OrderNote orderNote = new OrderNote();
orderNote.OrderId = order.OrderId;
orderNote.Note = Strings.ResourceManager.GetString(ORDER_REFUNDED);
orderNote.Save(userName);
//send off the notifications
MessageService messageService = new MessageService();
messageService.SendOrderRefundToCustomer(refundedOrder);
}
public bool ProcessCallBackRequest(string payment, string signature)
{
LogMessage(string.Format("payment={0}", payment));
LogMessage(string.Format("signature={0}", signature));
string password = payment + _privat24PaymentSettings.MerchantSignature;
string text = Sh1(Md5(password));
LogMessage(string.Format("signaturemy={0}", text));
if (!string.Equals(text, signature))
{
LogMessage("signature!=signaturemy");
return(false);
}
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Privat24 IPN:");
string order = null;
string state = null;
string amount = null;
string reference = null;
string currency = null;
string[] array = payment.Split(new[]
{
'&'
});
foreach (string value in array)
{
string param = value.Trim();
stringBuilder.AppendLine(param);
if (param.StartsWith("order="))
{
order = param.Substring(6).Trim();
}
if (param.StartsWith("state="))
{
state = param.Substring(6).Trim();
}
if (param.StartsWith("amt="))
{
amount = param.Substring(4).Trim();
}
if (param.StartsWith("ref="))
{
reference = param.Substring(4).Trim();
}
if (param.StartsWith("ccy="))
{
currency = param.Substring(4).Trim();
}
}
if (state == null)
{
state = string.Empty;
}
if (reference == null)
{
reference = string.Empty;
}
if (currency == null)
{
currency = string.Empty;
}
int orderId = 0;
int.TryParse(order, out orderId);
Order orderById = _orderService.GetOrderById(orderId);
if (orderById == null)
{
LogMessage(string.Format("bad order == null, nopOrderId={0}, nopOrderIdStr={1}", orderId, order));
return(false);
}
if (orderById.PaymentStatus == PaymentStatus.Paid)
{
LogMessage(string.Format("Order is paid, nopOrderId={0}, order.PaymentStatus={1}", orderId, orderById.PaymentStatus));
return(true);
}
decimal orderTotal = 0m;
decimal.TryParse(amount, out orderTotal);
if (_privat24PaymentSettings.IsTestMode)
{
orderTotal = orderById.OrderTotal;
}
if (orderById.OrderTotal != orderTotal)
{
LogMessage(string.Format("Bad OrderTotal orderid={0}, order.OrderTotal={1}, Privat24.amt={2}", orderId, orderById.OrderTotal, orderTotal));
return(false);
}
string currencyCode = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode;
if (string.IsNullOrEmpty(currencyCode))
{
currencyCode = "UAH";
}
var currencies = _privat24PaymentSettings.Currencies.Split(new[] { ",", " " }, StringSplitOptions.RemoveEmptyEntries);;
if (!currencies.Contains(currencyCode))
{
currencyCode = "UAH";
}
if (!string.Equals(currencyCode, currency))
{
LogMessage(string.Format("Bad OrderTotal currency orderid={0}, currency={1}, payment_ccy={2}", orderId, currencyCode, currency));
return(false);
}
ICollection <OrderNote> orderNotes = orderById.OrderNotes;
var orderNote = new OrderNote
{
Note = stringBuilder.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
};
orderNotes.Add(orderNote);
_orderService.UpdateOrder(orderById);
PaymentStatus paymentStatus = GetPaymentStatus(state);
PaymentStatus paymentStatus2 = paymentStatus;
if (paymentStatus2 <= PaymentStatus.Authorized)
{
if (paymentStatus2 != PaymentStatus.Pending)
{
if (paymentStatus2 == PaymentStatus.Authorized)
{
if (_orderProcessingService.CanMarkOrderAsAuthorized(orderById))
{
_orderProcessingService.MarkAsAuthorized(orderById);
}
}
}
}
else
{
if (paymentStatus2 != PaymentStatus.Paid)
{
if (paymentStatus2 != PaymentStatus.Refunded)
{
if (paymentStatus2 == PaymentStatus.Voided)
{
if (_orderProcessingService.CanVoidOffline(orderById))
{
_orderProcessingService.VoidOffline(orderById);
}
}
}
else
{
if (_orderProcessingService.CanRefundOffline(orderById))
{
_orderProcessingService.RefundOffline(orderById);
}
}
}
else
{
if (_orderProcessingService.CanMarkOrderAsPaid(orderById) &&
orderById.PaymentStatus != PaymentStatus.Paid)
{
_orderProcessingService.MarkOrderAsPaid(orderById);
}
}
}
return(true);
}
public IActionResult AcceptPaymenyByLink(string a, string status, string paymentId, string paymentToken)
{
var endpoint = _gestPayPaymentSettings.UseSandbox ? "https://sandbox.gestpay.net/api/v1/payment/detail/" + paymentId : "https://ecomms2s.sella.it/api/v1/payment/detail/" + paymentId;
var responseStr = string.Empty;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(endpoint);
request.ContentType = "application/json";
request.Headers.Add("Authorization", "apikey " + _gestPayPaymentSettings.ApiKey);
request.Headers.Add("paymentToken", paymentToken);
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Stream dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
responseStr = reader.ReadToEnd();
reader.Close();
dataStream.Close();
PaymentDetailResponseModel paymentDetailResponse = JsonConvert.DeserializeObject <PaymentDetailResponseModel>(responseStr);
Guid orderGuid;
Guid.TryParse(paymentDetailResponse.payload.shopTransactionID, out orderGuid);
var order = _orderService.GetOrderByGuid(orderGuid);
if (order != null)
{
var sb = new StringBuilder();
sb.AppendLine("GestPay s2s:");
sb.AppendLine("Res = " + paymentDetailResponse.payload.risk.riskResponseDescription);
sb.AppendLine("GestPay response:");
sb.AppendLine("ErrorCode: " + paymentDetailResponse.error.code);
sb.AppendLine("ErrorDesc: " + paymentDetailResponse.error.description);
sb.AppendLine("TrxResult: " + paymentDetailResponse.payload.transactionResult);
sb.AppendLine("BankTrxID: " + paymentDetailResponse.payload.bankTransactionID);
sb.AppendLine("AuthCode: " + paymentDetailResponse.payload.authorizationCode);
sb.AppendLine("Amount: " + paymentDetailResponse.payload.automaticOperation.amount);
var amount = Convert.ToDecimal(paymentDetailResponse.payload.automaticOperation.amount);
if (!Math.Round(amount, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
sb.AppendLine(String.Format("Amount difference: {0}-{1}", Math.Round(amount, 2), Math.Round(order.OrderTotal, 2)));
}
sb.AppendLine("BuyerName: " + paymentDetailResponse.payload.buyer.name);
sb.AppendLine("BuyerEmail: " + paymentDetailResponse.payload.buyer.email);
// Inserisco la nota sull'ordine
var orderNote = new OrderNote
{
OrderId = order.Id,
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
};
_orderService.InsertOrderNote(orderNote);
order.AuthorizationTransactionId = paymentDetailResponse.payload.bankTransactionID;
order.AuthorizationTransactionCode = paymentDetailResponse.payload.authorizationCode;
_orderService.UpdateOrder(order);
if (!_gestPayPaymentSettings.EnableGuaranteedPayment && paymentDetailResponse.payload.transactionResult == "APPROVED")
{
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
}
return(Redirect("/"));
}
catch (WebException ex)
{
using (var stream = ex.Response.GetResponseStream())
using (var reader = new StreamReader(stream))
{
responseStr = reader.ReadToEnd();
}
PaymentDetailResponseModel paymentDetailResponse = JsonConvert.DeserializeObject <PaymentDetailResponseModel>(responseStr);
_logger.Error("Gestpay Pay Link Verify Error = " + paymentDetailResponse.error.code + " " + paymentDetailResponse.error.description, ex);
return(RedirectToAction("GeneralError", "PaymentGestPay", new { type = "1", errc = HttpUtility.UrlEncode(paymentDetailResponse.error.code), errd = HttpUtility.UrlEncode(paymentDetailResponse.error.description) }));
}
}
public ActionResult SaveCell(int ID, string Field, string Value, string OrderNote)
{
//if(string.IsNullOrEmpty(OrderNote))
//{
// return Json(new { result = "error", message = "Note required", value = Value });
//}
var order = _db.Orders.FirstOrDefault(x => x.ID == ID);
if (order != null)
{
var property = order.GetType().GetProperty(Field);
if (property != null)
{
var oldValue = property.GetValue(order);
order.SetValueFromString(Field, Value);
var newValue = property.GetValue(order);
var oldValueStr = oldValue.ToString();
var newValueStr = newValue.ToString();
if (property.PropertyType.Name == "Double")
{
oldValueStr = ((decimal)oldValue).ToString("0.00");
newValueStr = ((decimal)newValue).ToString("0.00");
}
if (Field != "Total" && Field != "TotalCash")
{
//fix totals
if (order.ShippingMethod == ShippingMethod.Manual)
{
order.ShipCost = 0;
}
order.Total = order.SubTotal + order.ShipCost + order.Fee - order.TotalDiscountAmount;
}
if (newValueStr != oldValueStr)
{
_db.SaveChanges();
//adding note
if (string.IsNullOrEmpty(OrderNote))
{
OrderNote = RP.S("Member.OrderNote.DefaultMessage");
}
var note = new OrderNote()
{
CreateDate = DateTime.Now,
Field = RP.M("Order", Field),
OrderID = order.ID,
Note = OrderNote,
NewValue = newValueStr,
OldValue = oldValueStr
};
_db.OrderNotes.Add(note);
_db.SaveChanges();
return(Json(new { result = "ok", value = Value }));
}
return(Json(new { result = "error", message = "Value not changed", value = Value }));
}
return(Json(new { result = "error", message = "no property", value = Value }));
}
return(Json(new { result = "error", message = "not found", value = Value }));
}
/// <summary>
/// Adds the new gift card.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="lineItem">The line item.</param>
private static void AddNewGiftCard(OrderTaskContext context, LineItem lineItem)
{
var paymentManager = new OrderPaymentManager(context.Order, context.HccApp);
var store = context.HccApp.CurrentStore;
var giftCard = new GiftCardData
{
LineItemId = lineItem.Id,
CardNumber = context.HccApp.CatalogServices.GenerateGiftCardNumber(),
Amount = Money.RoundCurrency(lineItem.AdjustedPricePerItem),
RecipientEmail = lineItem.CustomPropGiftCardEmail,
RecipientName = lineItem.CustomPropGiftCardName,
ExpirationDate = DateTime.UtcNow.AddMonths(store.Settings.GiftCard.ExpirationPeriodMonths)
};
var gcNumber = paymentManager.GiftCardCreate(giftCard);
if (string.IsNullOrEmpty(gcNumber))
{
var message = new WorkflowMessage(
"Gift Certificate Insert Failed",
"Gift Certificate for line item " + lineItem.Id + " in order " + context.Order.OrderNumber +
" failed.", false);
context.Errors.Add(message);
}
else
{
if (string.IsNullOrEmpty(lineItem.CustomPropGiftCardNumber))
{
lineItem.CustomPropGiftCardNumber = gcNumber;
}
else
{
lineItem.CustomPropGiftCardNumber = lineItem.CustomPropGiftCardNumber + "<br/>" + gcNumber;
}
context.HccApp.OrderServices.Orders.Update(context.Order);
var gc = new GiftCard(giftCard, lineItem.CustomPropGiftCardMessage);
if (string.IsNullOrEmpty(gc.RecipientEmail))
{
gc.RecipientEmail = context.Order.UserEmail;
if (string.IsNullOrEmpty(gc.RecipientName))
{
gc.RecipientName = context.Order.ShippingAddress.FirstName;
}
}
try
{
context.HccApp.ContentServices.SendGiftCardNotification(gc, context.Order, lineItem);
}
catch (Exception ex)
{
context.Errors.Add(new WorkflowMessage("Exception Sending Gift Card", ex.Message + ex.StackTrace,
false));
var note = new OrderNote();
note.IsPublic = false;
note.Note = "EXCEPTION: " + ex.Message + " | " + ex.StackTrace;
context.Order.Notes.Add(note);
EventLog.LogEvent(ex);
}
}
}
/// <summary>
/// Charges the specified order.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="userName">Name of the user.</param>
/// <returns></returns>
public static Transaction Charge(Order order, string userName)
{
//update the order with IP
order.IPAddress = HttpContext.Current.Request.UserHostAddress;
PaymentService paymentService = new PaymentService();
Transaction transaction = paymentService.Charge(order);
order.OrderStatusDescriptorId = (int)OrderStatus.ReceivedPaymentProcessingOrder;
order.OrderTypeId = (int)OrderType.Purchase;
order.Save(userName);
Guid userGuid = new Guid(Membership.GetUser(userName).ProviderUserKey.ToString());
try {
//Add an OrderNote
OrderNote orderNote = new OrderNote();
orderNote.OrderId = order.OrderId;
orderNote.Note = Strings.ResourceManager.GetString(ORDER_CHARGED);
orderNote.Save(userName);
Sku sku;
DownloadCollection downloadCollection;
DownloadAccessControlCollection downloadAccessControlCollection;
DownloadAccessControl downloadAccessControl;
foreach (OrderItem orderItem in order.OrderItemCollection) {
//Adjust the Inventory
sku = new Sku(SKU, orderItem.Sku);
sku.Inventory = sku.Inventory - orderItem.Quantity;
sku.Save(SYSTEM);
ProductCache.RemoveSKUFromCache(orderItem.Sku);
//Add access control for orderitems
downloadCollection = new ProductController().FetchAssociatedDownloadsByProductIdAndForPurchase(orderItem.ProductId);
if (downloadCollection.Count > 0) {
foreach (Download download in downloadCollection) {
Query query = new Query(DownloadAccessControl.Schema).
AddWhere(DownloadAccessControl.Columns.UserId, Comparison.Equals, userGuid).
AddWhere(DownloadAccessControl.Columns.DownloadId, Comparison.Equals, download.DownloadId);
downloadAccessControlCollection = new DownloadAccessControlController().FetchByQuery(query);
if (downloadAccessControlCollection.Count == 0) {
downloadAccessControl = new DownloadAccessControl();
downloadAccessControl.DownloadId = download.DownloadId;
downloadAccessControl.UserId = userGuid;
downloadAccessControl.Save(SYSTEM);
}
}
}
}
//Send out the messages
//Send these last in case something happens with the email
MessageService messageService = new MessageService();
messageService.SendOrderReceivedNotificationToCustomer(order);
messageService.SendOrderReceivedNotificationToMerchant(order);
}
catch (Exception ex) {
//swallow the exception here because the transaction is saved
//and, while this is an inconvenience, it's not critical
Logger.Error(typeof(OrderController).Name + ".Charge", ex);
}
return transaction;
}
public async Task AddOrderTokens(LiquidObject liquidObject, Order order, Customer customer, Store store, OrderNote orderNote = null, Vendor vendor = null, decimal refundedAmount = 0)
{
var language = await _languageService.GetLanguageById(order.CustomerLanguageId);
var currency = await _currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
var productService = _serviceProvider.GetRequiredService <IProductService>();
var downloadService = _serviceProvider.GetRequiredService <IDownloadService>();
var vendorService = _serviceProvider.GetRequiredService <IVendorService>();
var liquidOrder = new LiquidOrder(order, customer, language, currency, store, orderNote, vendor);
foreach (var item in order.OrderItems.Where(x => x.VendorId == vendor?.Id || vendor == null))
{
var product = await productService.GetProductById(item.ProductId);
var vendorItem = await vendorService.GetVendorById(item.VendorId);
var liqitem = new LiquidOrderItem(item, product, order, language, currency, store, vendorItem);
#region Download
liqitem.IsDownloadAllowed = downloadService.IsDownloadAllowed(order, item, product);
liqitem.IsLicenseDownloadAllowed = downloadService.IsLicenseDownloadAllowed(order, item, product);
#endregion
#region Unit price
string unitPriceStr;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.UnitPriceInclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.UnitPriceExclTax, order.CurrencyRate);
unitPriceStr = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, currency, language, false);
}
liqitem.UnitPrice = unitPriceStr;
#endregion
#region total price
string priceStr;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.PriceInclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(item.PriceExclTax, order.CurrencyRate);
priceStr = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, currency, language, false);
}
liqitem.TotalPrice = priceStr;
#endregion
string sku = "";
if (product != null)
{
sku = product.FormatSku(item.AttributesXml, _productAttributeParser);
}
liqitem.ProductSku = WebUtility.HtmlEncode(sku);
liqitem.ShowSkuOnProductDetailsPage = _catalogSettings.ShowSkuOnProductDetailsPage;
liqitem.ProductOldPrice = _priceFormatter.FormatPrice(product.OldPrice, true, currency, language, true);
liquidOrder.OrderItems.Add(liqitem);
}
liquidOrder.BillingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(order.BillingAddress?.CustomAttributes);
liquidOrder.BillingCountry = order.BillingAddress != null && !string.IsNullOrEmpty(order.BillingAddress.CountryId) ? (await _countryService.GetCountryById(order.BillingAddress.CountryId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.BillingStateProvince = !string.IsNullOrEmpty(order.BillingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(order.BillingAddress.StateProvinceId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingCountry = order.ShippingAddress != null && !string.IsNullOrEmpty(order.ShippingAddress.CountryId) ? (await _countryService.GetCountryById(order.ShippingAddress.CountryId))?.GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingStateProvince = order.ShippingAddress != null && !string.IsNullOrEmpty(order.ShippingAddress.StateProvinceId) ? (await _stateProvinceService.GetStateProvinceById(order.ShippingAddress.StateProvinceId)).GetLocalized(x => x.Name, order.CustomerLanguageId) : "";
liquidOrder.ShippingCustomAttributes = await _addressAttributeFormatter.FormatAttributes(order.ShippingAddress != null?order.ShippingAddress.CustomAttributes : "");
var paymentMethod = _serviceProvider.GetRequiredService <IPaymentService>().LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
liquidOrder.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, language.Id) : order.PaymentMethodSystemName;
liquidOrder.AmountRefunded = _priceFormatter.FormatPrice(refundedAmount, true, currency, language, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var item in order.TaxRatesDictionary)
{
string taxRate = string.Format(_localizationService.GetResource("Messages.Order.TaxRateLine"), _priceFormatter.FormatTaxRate(item.Key));
string taxValue = _priceFormatter.FormatPrice(item.Value, true, currency, language, false);
dict.Add(taxRate, taxValue);
}
liquidOrder.TaxRates = dict;
Dictionary <string, string> cards = new Dictionary <string, string>();
var servicegiftCard = _serviceProvider.GetRequiredService <IGiftCardService>();
var gcuhC = await servicegiftCard.GetAllGiftCardUsageHistory(order.Id);
foreach (var gcuh in gcuhC)
{
var giftCard = await servicegiftCard.GetGiftCardById(gcuh.GiftCardId);
string giftCardText = string.Format(_localizationService.GetResource("Messages.Order.GiftCardInfo", language.Id), WebUtility.HtmlEncode(giftCard.GiftCardCouponCode));
string giftCardAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, currency, language, false);
cards.Add(giftCardText, giftCardAmount);
}
liquidOrder.GiftCards = cards;
if (order.RedeemedRewardPointsEntry != null)
{
liquidOrder.RPTitle = string.Format(_localizationService.GetResource("Messages.Order.RewardPoints", language.Id), -order.RedeemedRewardPointsEntry?.Points);
liquidOrder.RPAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, currency, language, false);
}
void CalculateSubTotals()
{
string _cusSubTotal;
bool _displaySubTotalDiscount;
string _cusSubTotalDiscount;
string _cusShipTotal;
string _cusPaymentMethodAdditionalFee;
bool _displayTax;
string _cusTaxTotal;
bool _displayTaxRates;
bool _displayDiscount;
string _cusDiscount;
string _cusTotal;
_displaySubTotalDiscount = false;
_cusSubTotalDiscount = string.Empty;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal)
{
//including tax
//subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, currency, language, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, currency, language, true);
_displaySubTotalDiscount = true;
}
}
else
{
//exсluding tax
//subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
_cusSubTotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, currency, language, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
_cusSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, currency, language, false);
_displaySubTotalDiscount = true;
}
}
//shipping, payment method fee
_cusTaxTotal = string.Empty;
_cusDiscount = string.Empty;
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
//shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, currency, language, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, currency, language, true);
}
else
{
//excluding tax
//shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
_cusShipTotal = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, currency, language, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
_cusPaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, currency, language, false);
}
//shipping
bool displayShipping = order.ShippingStatus != ShippingStatus.ShippingNotRequired;
//payment method fee
bool displayPaymentMethodFee = order.PaymentMethodAdditionalFeeExclTax > decimal.Zero;
//tax
_displayTax = true;
_displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
if (order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
_displayTax = false;
_displayTaxRates = false;
}
else
{
var _taxRates = new SortedDictionary <decimal, decimal>();
foreach (var tr in order.TaxRatesDictionary)
{
_taxRates.Add(tr.Key, _currencyService.ConvertCurrency(tr.Value, order.CurrencyRate));
}
_displayTaxRates = _taxSettings.DisplayTaxRates && _taxRates.Any();
_displayTax = !_displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
string taxStr = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_cusTaxTotal = taxStr;
}
}
//discount
_displayDiscount = false;
if (order.OrderDiscount > decimal.Zero)
{
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
_cusDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
_displayDiscount = true;
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
_cusTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, currency, language, order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax, false);
liquidOrder.SubTotal = _cusSubTotal;
liquidOrder.DisplaySubTotalDiscount = _displaySubTotalDiscount;
liquidOrder.SubTotalDiscount = _cusSubTotalDiscount;
liquidOrder.Shipping = _cusShipTotal;
liquidOrder.Discount = _cusDiscount;
liquidOrder.PaymentMethodAdditionalFee = _cusPaymentMethodAdditionalFee;
liquidOrder.Tax = _cusTaxTotal;
liquidOrder.Total = _cusTotal;
liquidOrder.DisplayTax = _displayTax;
liquidOrder.DisplayDiscount = _displayDiscount;
liquidOrder.DisplayTaxRates = _displayTaxRates;
}
CalculateSubTotals();
liquidObject.Order = liquidOrder;
await _mediator.EntityTokensAdded(order, liquidOrder, liquidObject);
}
public void Insert(int OrderId,string Note,string CreatedBy,DateTime CreatedOn,string ModifiedBy,DateTime ModifiedOn)
{
OrderNote item = new OrderNote();
item.OrderId = OrderId;
item.Note = Note;
item.CreatedBy = CreatedBy;
item.CreatedOn = CreatedOn;
item.ModifiedBy = ModifiedBy;
item.ModifiedOn = ModifiedOn;
item.Save(UserName);
}
public LiquidOrder(Order order, Customer customer, Language language, Currency currency, Store store, OrderNote orderNote = null, Vendor vendor = null)
{
_order = order;
_customer = customer;
_language = language;
_orderNote = orderNote;
_currency = currency;
_store = store;
_vendor = vendor;
_orderItems = new List <LiquidOrderItem>();
AdditionalTokens = new Dictionary <string, string>();
}
public void Process()
{
string googleOrderNum = N1.googleordernumber;
Order order = OrderDataSource.LoadForGoogleOrderNumber(googleOrderNum);
if (order == null)
{
Logger.Warn("Unknown Google Order Number Order State Changed. GoogleOrderNumber=" + googleOrderNum);
}
else
{
//update financial order payment status
Payment payment = AcHelper.GetGCPayment(order, GatewayInstance, true);
switch (N1.newfinancialorderstate)
{
case FinancialOrderState.CHARGEABLE:
//authorized
payment.PaymentStatusReason = N1.reason;
if (payment.PaymentStatus == PaymentStatus.AuthorizationPending)
{
PaymentEngine.ProcessAuthorizePending(payment, GatewayInstance.PaymentGatewayId, true);
}
break;
case FinancialOrderState.CHARGING:
//capture pending
break;
case FinancialOrderState.CANCELLED:
case FinancialOrderState.CANCELLED_BY_GOOGLE:
//cancel the order
//if the order has been paid order cancellation will be preceeded by a refund notification
//so that aspect will be handled in refund handler
//TODO: Do we need to force void the remaining payments?
//payment.PaymentStatusReason = N1.reason;
//PaymentEngine.ForceVoid(payment, GatewayInstance.PaymentGatewayId, true);
if (order.OrderStatus.IsValid)
{
if (!string.IsNullOrEmpty(N1.reason))
{
OrderNote on = new OrderNote();
on.Comment = "Order Cancelled : " + N1.reason;
on.OrderId = order.OrderId;
order.Notes.Add(on);
}
order.Cancel();
}
break;
case FinancialOrderState.CHARGED:
//charge the payment
//we will handle this in charge amount notification handler only
//otherwise it can result in double charge transactions
/*payment.PaymentStatusReason = N1.reason;
* if (payment.PaymentStatus == PaymentStatus.CapturePending)
* {
* PaymentEngine.ProcessCapturePending(payment, GatewayInstance.PaymentGatewayId, true);
* }*/
break;
case FinancialOrderState.PAYMENT_DECLINED:
//payment declined
payment.PaymentStatusReason = N1.reason;
if (payment.PaymentStatus == PaymentStatus.CapturePending)
{
PaymentEngine.ProcessCapturePending(payment, GatewayInstance.PaymentGatewayId, false);
}
else if (payment.PaymentStatus == PaymentStatus.AuthorizationPending)
{
PaymentEngine.ProcessAuthorizePending(payment, GatewayInstance.PaymentGatewayId, false);
}
else
{
PaymentEngine.ForceCapture(payment, GatewayInstance.PaymentGatewayId, false);
}
break;
case FinancialOrderState.REVIEWING:
//No AC equivalent
default:
break;
}
//TODO : order statuses are custom defined in AC
//update order shipment status
switch (N1.newfulfillmentorderstate)
{
case FulfillmentOrderState.NEW:
//do nothing
break;
case FulfillmentOrderState.DELIVERED:
//order has been shipped
foreach (OrderShipment os in order.Shipments)
{
if (!os.IsShipped)
{
os.Ship(false);
}
}
break;
case FulfillmentOrderState.PROCESSING:
//no equivalent in AC
break;
case FulfillmentOrderState.WILL_NOT_DELIVER:
//this may happen if order is cancelled
//order cancelled event will take care of this
break;
default:
break;
}
}
}
public ActionResult PayGateReturnHandler(FormCollection form)
{
string[] keys = Request.Form.AllKeys;
String transaction_status = "";
String pay_request_id = "";
String transaction_status_desc = "";
Order order = _orderService.GetOrderById(Int32.Parse(Request.QueryString["pgnopcommerce"]));
var sBuilder = new StringBuilder();
var query_status = PaymentStatus.Pending;
for (int i = 0; i < keys.Length; i++)
{
if (keys[i] == "TRANSACTION_STATUS")
{
transaction_status = Request.Form[keys[i]];
}
if (keys[i] == "PAY_REQUEST_ID")
{
pay_request_id = Request.Form[keys[i]];
}
}
using (var client = new System.Net.WebClient())
{
var queryData = new NameValueCollection();
queryData["PAYGATE_ID"] = _payGatePaymentSettings.PayGateID;
queryData["PAY_REQUEST_ID"] = pay_request_id;
queryData["REFERENCE"] = Request.QueryString["pgnopcommerce"];
string queryValues = string.Join("", queryData.AllKeys.Select(key => queryData[key]));
queryData["CHECKSUM"] = new PayGateHelper().CalculateMD5Hash(queryValues + _payGatePaymentSettings.EncryptionKey);
var response = client.UploadValues("https://secure.paygate.co.za/payweb3/query.trans", queryData);
var responseString = Encoding.Default.GetString(response);
if (responseString != null)
{
Dictionary <string, string> dict =
responseString.Split('&')
.Select(x => x.Split('='))
.ToDictionary(y => y[0], y => y[1]);
try
{
String trans_id = dict["TRANSACTION_STATUS"].ToString();
String query_status_desc = "";
switch (trans_id)
{
case "1":
query_status = PaymentStatus.Paid;
query_status_desc = "Approved";
break;
case "2":
query_status_desc = "Declined";
break;
case "4":
query_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
query_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Transaction_Id: " + dict["TRANSACTION_ID"]);
sBuilder.AppendLine("PayGate Status Desc: " + query_status_desc);
sBuilder.AppendLine("");
} catch (Exception e)
{
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Query Response: " + responseString);
sBuilder.AppendLine("");
}
}
}
var new_payment_status = PaymentStatus.Pending;
switch (transaction_status)
{
case "1":
new_payment_status = PaymentStatus.Paid;
transaction_status_desc = "Approved";
break;
case "2":
transaction_status_desc = "Declined";
break;
case "4":
transaction_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
transaction_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Return Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate PayRequestId: " + pay_request_id);
sBuilder.AppendLine("PayGate Status Desc: " + transaction_status_desc);
//order note
order.OrderNotes.Add(new OrderNote
{
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSetting <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = pay_request_id;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else if (new_payment_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = pay_request_id;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
order.AuthorizationTransactionId = pay_request_id;
OrderNote _note = new OrderNote();
_note.CreatedOnUtc = DateTime.Now;
_note.DisplayToCustomer = true;
_note.Note = "Payment failed with the following description: " + transaction_status_desc;
_orderProcessingService.CancelOrder(order, false);
order.OrderNotes.Add(_note);
_orderService.UpdateOrder(order);
return(RedirectToAction(order.Id.ToString().Trim(), "orderdetails"));
}
//return RedirectToAction("Index", "Home", new { area = "" });
}
public IActionResult PayGateReturnHandler(IFormCollection form)
{
var reference = Request.Query["pgnopcommerce"];
var isPaid = false;
var isqueried = false;
_logger.Information("PayGateReturnHandler start. Order no.: " + reference);
string[] keys = Request.Form.Keys.ToArray();
var verified = false;
var testMode = _payGatePaymentSettings.TestMode;
var paygateId = "10011072130";
var encryptionKey = "secret";
if (!testMode)
{
paygateId = _payGatePaymentSettings.PayGateID;
encryptionKey = _payGatePaymentSettings.EncryptionKey;
}
//Process form data into name value collection
var formData = new NameValueCollection();
var formDataJS = "";
for (int i = 0; i < keys.Length; i++)
{
formData[keys[i]] = Request.Form[keys[i]];
formDataJS += keys[i] + "=" + formData[keys[i]] + "&";
}
var order = _orderService.GetOrderById(Int32.Parse(Request.Query["pgnopcommerce"]));
isPaid = order.PaymentStatus == PaymentStatus.Paid ? true : false;
_logger.Information("PayGateReturnHandler: Order Payment Status: " + order.PaymentStatus);
_logger.Information("PayGateReturnHandler: POST: " + formDataJS);
/**
* Enable Redirect if set, or as deafult if neither is set
*/
if (_payGatePaymentSettings.EnableRedirect || (!_payGatePaymentSettings.EnableRedirect && !_payGatePaymentSettings.EnableIpn))
{
//First check that returned checksum is correct before proceeding any further
var transactionStatus = formData["TRANSACTION_STATUS"];
var payrequestId = formData["PAY_REQUEST_ID"];
var checksum = formData["CHECKSUM"];
var checkstring = paygateId + payrequestId + transactionStatus + reference + encryptionKey;
var ourChecksum = new PayGateHelper().CalculateMD5Hash(checkstring);
if (ourChecksum.Equals(checksum, StringComparison.OrdinalIgnoreCase))
{
verified = true;
}
_logger.Information("PayGateReturnHandler: Order " + reference + " Checksum Status: " + (verified ? "matched" : "not matched"));
if (order.PaymentStatus == PaymentStatus.Paid)
{
_logger.Information("PayGateReturnHandler: Order no. " + reference + " is already paid");
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
if (verified)
{
var sBuilder = new StringBuilder();
var query_status = PaymentStatus.Pending;
using (var client = new System.Net.WebClient())
{
var queryData = new NameValueCollection();
queryData["PAYGATE_ID"] = paygateId;
queryData["PAY_REQUEST_ID"] = payrequestId;
queryData["REFERENCE"] = reference;
string queryValues = string.Join("", queryData.AllKeys.Select(key => queryData[key]));
queryData["CHECKSUM"] = new PayGateHelper().CalculateMD5Hash(queryValues + _payGatePaymentSettings.EncryptionKey);
var cnt = 0;
Dictionary <string, string> dict = null;
var responseString = "";
if (!isqueried && cnt < 5)
{
var response = client.UploadValues("https://secure.paygate.co.za/payweb3/query.trans", queryData);
responseString = Encoding.Default.GetString(response);
dict =
responseString.Split('&')
.Select(x => x.Split('='))
.ToDictionary(y => y[0], y => y[1]);
if (dict.Count > 0 && dict.ContainsKey("TRANSACTION_STATUS"))
{
isqueried = true;
}
cnt++;
}
var dictJS = "";
foreach (var item in dict)
{
dictJS += item.Key + "=" + item.Value + "&";
}
_logger.Information("PayGateReturnHandler: QUERY: " + dictJS);
if (isqueried)
{
try
{
String trans_status = dict["TRANSACTION_STATUS"].ToString();
String query_status_desc = "";
switch (trans_status)
{
case "1":
query_status = PaymentStatus.Paid;
query_status_desc = "Approved";
break;
case "2":
query_status = PaymentStatus.Voided;
query_status_desc = "Declined";
break;
case "4":
query_status = PaymentStatus.Voided;
query_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
query_status = PaymentStatus.Voided;
query_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Return Handler");
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Transaction_Id: " + dict["TRANSACTION_ID"]);
sBuilder.AppendLine("PayGate Status Desc: " + query_status_desc);
sBuilder.AppendLine("");
}
catch (Exception e)
{
sBuilder.AppendLine("PayGate Return Handler");
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Query Response: " + responseString);
sBuilder.AppendLine("");
}
}
else
{
sBuilder.AppendLine("PayGate Return Handler");
sBuilder.AppendLine("PayGate Return Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate PayRequestId: " + payrequestId);
sBuilder.AppendLine("PayGate Status Desc: " + transactionStatus);
sBuilder.AppendLine("PayGate Query Desc: Failed to get a response from the query");
}
}
//order note
order.OrderNotes.Add(new OrderNote
{
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSetting <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = payrequestId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
_logger.Information("PayGateReturnHandler: Order marked paid");
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
order.AuthorizationTransactionId = payrequestId;
OrderNote note = new OrderNote();
note.CreatedOnUtc = DateTime.Now;
note.DisplayToCustomer = true;
note.Note = "Payment failed with the following description: " + transactionStatus;
_logger.Error("PayGateReturnHandler: Payment failed with the following description: " + transactionStatus);
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, false);
}
order.OrderNotes.Add(note);
_orderService.UpdateOrder(order);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() }));
}
}
else
{
_logger.Error("PayGateReturnHandler: Checksum mismatch: " + ourChecksum + " : " + checksum);
OrderNote note = new OrderNote();
note.CreatedOnUtc = DateTime.Now;
note.DisplayToCustomer = true;
note.Note = "Payment failed: The checksum could not be verified";
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, false);
}
order.OrderNotes.Add(note);
_orderService.UpdateOrder(order);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() }));
}
}
return(RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() }));
}
public void Add(OrderNote orderNote)
{
_salesHubDbContext.OrderNotes.Add(orderNote);
}
//public IActionResult PayGateNotifyHandler(IFormCollection form)
public void PayGateNotifyHandler(IFormCollection form)
{
/**
* Enable IPN if it is set
*/
if (_payGatePaymentSettings.EnableIpn)
{
Response.WriteAsync("OK");
var reference = Request.Query["pgnopcommerce"];
bool isPaid;
_logger.Information("PayGateNotifyHandler start. Order no.: " + reference);
//var order = _orderService.GetOrderById(Int32.Parse(Request.Query["pgnopcommerce"]));
var order = _orderService.GetOrderById(Int32.Parse(Request.Form["USER1"]));
_logger.Information("PayGateNotifyHandler: Order Payment Status: " + order.PaymentStatus);
isPaid = order.PaymentStatus == PaymentStatus.Paid ? true : false;
if (!isPaid)
{
var sBuilder = new StringBuilder();
var query_status = PaymentStatus.Pending;
var payrequestId = "";
var transactionStatus = "";
var testMode = _payGatePaymentSettings.TestMode;
var paygateId = "10011072130";
var encryptionKey = "secret";
if (!testMode)
{
paygateId = _payGatePaymentSettings.PayGateID;
encryptionKey = _payGatePaymentSettings.EncryptionKey;
}
//Validate checksum for the posted form fields
var formData = new NameValueCollection();
var formDataJS = "";
string[] keys = Request.Form.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
formData[keys[i]] = Request.Form[keys[i]];
formDataJS += keys[i] + "=" + formData[keys[i]] + "&";
}
_logger.Information("PayGateNotifyHandler: POST: " + formDataJS);
var checksum = formData["CHECKSUM"];
var checkstring = "";
for (var i = 0; i < formData.Count - 1; i++)
{
checkstring += formData[i];
}
checkstring += encryptionKey;
var ourChecksum = new PayGateHelper().CalculateMD5Hash(checkstring);
if (ourChecksum.Equals(checksum, StringComparison.OrdinalIgnoreCase))
{
var trans_status = formData["TRANSACTION_STATUS"];
transactionStatus = trans_status;
var query_status_desc = "";
payrequestId = formData["PAY_REQUEST_ID"];
switch (trans_status)
{
case "1":
query_status = PaymentStatus.Paid;
query_status_desc = "Approved";
break;
case "2":
query_status = PaymentStatus.Voided;
query_status_desc = "Declined";
break;
case "4":
query_status = PaymentStatus.Voided;
query_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
query_status = PaymentStatus.Voided;
query_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Notify Handler");
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Transaction_Id: " + formData["TRANSACTION_ID"]);
sBuilder.AppendLine("PayGate Status Desc: " + query_status_desc);
sBuilder.AppendLine("");
//order note
order.OrderNotes.Add(new OrderNote
{
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSetting <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = payrequestId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
RedirectToRoute("CheckoutCompleted", new { orderId = order.Id });
}
else
{
order.AuthorizationTransactionId = payrequestId;
OrderNote note = new OrderNote();
note.CreatedOnUtc = DateTime.Now;
note.DisplayToCustomer = true;
note.Note = "Payment failed with the following description: " + transactionStatus;
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, false);
}
order.OrderNotes.Add(note);
_orderService.UpdateOrder(order);
RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() });
}
}
else
{
_logger.Error("PayGateNotifyHandler: Checksum mismatch: " + ourChecksum + " : " + checksum);
}
}
}
}
/// <summary>
/// Refunds the specified transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
/// <param name="refundedOrder">The order the refund should be applied to.</param>
/// <param name="userName">Name of the user.</param>
public static void Refund(Transaction transaction, Order refundedOrder, string userName)
{
Order order = new Order(transaction.OrderId);
PaymentService paymentService = new PaymentService();
Transaction refundTransaction = paymentService.Refund(transaction, refundedOrder);
refundedOrder.Save(userName);
//set the orderid for the refund
foreach(OrderItem orderItem in refundedOrder.OrderItemCollection) {
orderItem.OrderId = refundedOrder.OrderId;
}
refundedOrder.OrderItemCollection.SaveAll(userName);
//set the orderId to the refunded orderId
refundTransaction.OrderId = refundedOrder.OrderId;
refundTransaction.Save(userName);
Guid userGuid = new Guid(Membership.GetUser(order.UserName).ProviderUserKey.ToString());
foreach(OrderItem orderItem in refundedOrder.OrderItemCollection) {
new Product(orderItem.ProductId);
//put the stock back
Sku sku = new Sku(Sku.Columns.SkuX, orderItem.Sku);
sku.Inventory = sku.Inventory + orderItem.Quantity;
sku.Save(userName);
ProductCache.RemoveSKUFromCache(orderItem.Sku);
//remove the access control
DownloadCollection downloadCollection = new ProductController().FetchAssociatedDownloadsByProductIdAndForPurchase(orderItem.ProductId);
if (downloadCollection.Count > 0) {
foreach (Download download in downloadCollection) {
new DownloadAccessControlController().Delete(userGuid, download.DownloadId);
}
}
}
if(refundedOrder.Total == order.Total) {
order.OrderStatusDescriptorId = (int)OrderStatus.OrderFullyRefunded;
}
else {
order.OrderStatusDescriptorId = (int)OrderStatus.OrderPartiallyRefunded;
}
order.Save(userName);
//Add an OrderNote
OrderNote orderNote = new OrderNote();
orderNote.OrderId = order.OrderId;
orderNote.Note = Strings.ResourceManager.GetString(ORDER_REFUNDED);
orderNote.Save(userName);
//send off the notifications
MessageService messageService = new MessageService();
messageService.SendOrderRefundToCustomer(refundedOrder);
}
/// <summary>
/// 处理订单 支持多次支付/合并支付
/// </summary>
/// <param name="payment"></param>
private void Async(Payment payment)
{
var now = DateTime.Now;
if (payment.Status && payment.Type == 0)
{
var fail = 0m; //更新失败
var remain = payment.Amount; //单独或合并支付总金额
var oids = payment.RelatedId.Split(','); //可能为多个订单号
foreach (var oid in oids)
{
if (remain <= 0)
{
break;
}
var order = DefaultStorage.OrderMiniGet(oid, payment.UserId); //获取订单
if (order != null)
{
//订单为在线支付 状态为待付款
if (order.PaymentType.IsOnlinePay() && order.Status == OrderStatus.WaitBuyerPay)
{
var status = false; //更新订单结果
var amount = order.Unpaid; //待支付金额
if (remain - amount >= 0)
{
//付清(付清后如果是在线支付订单则会更新订单状态为已付款待发货并更新订单有效期)
status = DefaultStorage.OrderPaid(oid, amount, true); //更新订单已付金额及状态
if (status)
{
remain -= amount;
}
else
{
fail += amount;
}
}
else
{
//剩余金额不足 需多次支付
status = DefaultStorage.OrderPaid(oid, remain, false);
if (status)
{
remain = 0;
}
else
{
fail += remain;
}
}
if (!status)
{
Logger.LogWarning(2, "更新订单({orderId})已付金额及状态失败", oid);
var note = new OrderNote();
note.Type = 1;
note.UserId = payment.UserId;
note.OrderId = oid;
note.Subject = "更新订单已付金额/状态失败";
note.Message = string.Format("支付单({0})更新订单({1})已付金额/状态失败", payment.Id, oid);
note.Extra = (remain - amount >= 0 ? amount : remain).ToString("F2");
note.CreatedBy = "sys";
note.CreatedOn = now;
if (DefaultStorage.OrderNoteCreate(note) == 0)
{
Logger.LogError(2, "生成OrderNote失败 支付单({paymentId}) 订单({orderId}", payment.Id, oid);
}
}
}
}
else
{
Logger.LogWarning(1, "支付单({paymentId})未匹配到订单({orderId})", payment.Id, oid);
var note = new PaymentNote();
note.PayId = payment.Id;
note.PayNo = payment.No;
note.UserId = payment.UserId;
note.Subject = "支付单未匹配到订单";
note.Message = string.Format("支付单({0})未匹配到订单({1})", payment.Id, oid);
note.RawData = string.Empty;
note.Extra = oid;
note.CreatedBy = "sys";
note.CreatedOn = now;
if (DefaultStorage.PaymentNoteCreate(note) == 0)
{
Logger.LogError(1, "生成PaymentNote失败 支付单({paymentId}) 订单({orderId})", payment.Id, oid);
}
}
}
if (remain - fail > 0)
{
//用户在支付平台支付成功 但未能及时收到通知或成功处理 造成用户多次支付 需把用户多支付的金额 退到用户钱包
}
}
}
public IActionResult s2sHandler()
{
string errorCode = "", errorDesc = "";
string strRequest = Request.QueryString.ToString().Replace("?", "");
Dictionary <string, string> values;
var processor = _paymentPluginManager.LoadPluginBySystemName("Payments.GestPay") as GestPayPaymentProcessor;
if (processor == null ||
!_paymentPluginManager.IsPluginActive(processor))
{
throw new NopException("GestPay module cannot be loaded");
}
processor.GetResponseDetails(strRequest, out values);
if (values != null && values.Count > 0)
{
if (values.Count == 4)
{
return(RedirectToRoute("Plugin.Payments.GestPay.AcceptPaymenyByLink", new { a = values["a"], status = values["Status"], paymentId = values["paymentID"], paymentToken = values["paymentToken"] }));
}
var shopLogin = values["a"];
var encString = values["b"];
string shopTransactionId = "", authorizationCode = "", bankTransactionId = "";
string transactionResult = "", buyerName = "", buyerEmail = "", riskified = "", authorizationcode = "", threeDSAuthenticationLevel = "";
var acceptedThreeDSAuthLevels = new List <string> {
"1H", "1F", "2F", "2C", "2E"
};
var checkAmount = decimal.Zero;
var sb = new StringBuilder();
sb.AppendLine("GestPay s2s:");
if (processor.IsShopLoginChecked(shopLogin) && encString != null)
{
var endpoint = _gestPayPaymentSettings.UseSandbox ? WSCryptDecryptSoapClient.EndpointConfiguration.WSCryptDecryptSoap12Test : WSCryptDecryptSoapClient.EndpointConfiguration.WSCryptDecryptSoap12;
var objDecrypt = new WSCryptDecryptSoapClient(endpoint);
string xmlResponse = objDecrypt.DecryptAsync(shopLogin, encString, _gestPayPaymentSettings.ApiKey).Result.OuterXml;
XmlDocument XMLReturn = new XmlDocument();
XMLReturn.LoadXml(xmlResponse.ToLower());
//_logger.Information(xmlResponse.ToLower());
//Id transazione inviato
errorCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/errorcode")?.InnerText;
errorDesc = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/errordescription")?.InnerText;
//authorizationCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/authorizationcode")?.InnerText;
shopTransactionId = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/shoptransactionid")?.InnerText;
//_____ Messaggio OK _____//
if (errorCode == "0")
{
//Codice autorizzazione
authorizationCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/authorizationcode")?.InnerText;
//Codice transazione
bankTransactionId = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/banktransactionid")?.InnerText;
//Ammontare della transazione
var amount = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/amount")?.InnerText;
//Risultato transazione
transactionResult = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/transactionresult")?.InnerText;
//Nome dell'utente
buyerName = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/buyer/buyername")?.InnerText;
//Email utilizzata nella transazione
buyerEmail = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/buyer/buyeremail")?.InnerText;
//__________ ?validare il totale? __________//
riskified = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/riskresponsedescription")?.InnerText;
// 3DS authentication level (1H,1F,2F,2C,2E)
threeDSAuthenticationLevel = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/threeds/authenticationresult/authenticationlevel")?.InnerText?.ToUpper();
try
{
checkAmount = decimal.Parse(amount, new CultureInfo("en-US"));
}
catch (Exception exc)
{
_logger.Error("GestPay s2s. Error getting Amount", exc);
}
sb.AppendLine("GestPay success.");
}
else
{
sb.AppendLine("GestPay failed.");
_logger.Error("GestPay S2S. Transaction not found", new NopException(sb.ToString()));
}
}
//________ Inizio composizione messaggio dal server _________//
foreach (var kvp in values)
{
sb.AppendLine(kvp.Key + ": " + kvp.Value);
}
//Recupero lo stato del pagamento
var newPaymentStatus = GestPayHelper.GetPaymentStatus(transactionResult, "");
sb.AppendLine("New payment status: " + newPaymentStatus);
sb.AppendLine("Riskified = " + riskified);
sb.AppendLine("3DS Level = " + threeDSAuthenticationLevel);
//Cerco di recuperare l'ordine
var orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(shopTransactionId);
}
catch { }
var order = _orderService.GetOrderByGuid(orderNumberGuid);
//_________ aggiorno lo stato dell'ordine _________//
if (order != null)
{
switch (newPaymentStatus)
{
case PaymentStatus.Pending:
{
}
break;
case PaymentStatus.Authorized:
{
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
}
break;
case PaymentStatus.Paid:
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = bankTransactionId;
order.AuthorizationTransactionCode = authorizationCode;
_orderService.UpdateOrder(order);
if (!_gestPayPaymentSettings.EnableGuaranteedPayment || acceptedThreeDSAuthLevels.Contains(threeDSAuthenticationLevel))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
}
break;
case PaymentStatus.Refunded:
{
if (_orderProcessingService.CanRefundOffline(order))
{
_orderProcessingService.RefundOffline(order);
}
}
break;
case PaymentStatus.Voided:
{
/*_ Visto che non si può impostare il pagamento ad Annullato
* _orderProcessingService.CanVoidOffline allora cancello l'ordine.
* C'è da decidere se avvisare o meno l'utente _*/
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
}
break;
}
//__________________ salvo i valori restituiti __________________//
sb.AppendLine("GestPay response:");
//Codice Errore
sb.AppendLine("ErrorCode: " + errorCode);
//Descrizione Errore
sb.AppendLine("ErrorDesc: " + errorDesc);
sb.AppendLine("TrxResult: " + transactionResult);
sb.AppendLine("BankTrxID: " + bankTransactionId);
sb.AppendLine("AuthCode: " + authorizationCode);
sb.AppendLine("Amount: " + checkAmount);
if (!Math.Round(checkAmount, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//__________ ?validare il totale? __________//
sb.AppendLine(String.Format("Amount difference: {0}-{1}", Math.Round(checkAmount, 2), Math.Round(order.OrderTotal, 2)));
}
sb.AppendLine("BuyerName: " + buyerName);
sb.AppendLine("BuyerEmail: " + buyerEmail);
//Inserisco la nota sull'ordine
var orderNote = new OrderNote
{
OrderId = order.Id,
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
};
_orderService.InsertOrderNote(orderNote);
}
else
{
_logger.Error("GestPay S2S. Order is not found", new NopException(sb.ToString()));
}
}
else
{
_logger.Error("GestPay S2S failed.", new NopException(strRequest));
}
//_________ Imposto il risultato __________//
var s2SResponse = "KO";
if (errorCode == "0")
{
s2SResponse = "OK";
}
//nothing should be rendered to visitor
return(Content(String.Format("<html>{0}</html>", s2SResponse)));
}
/// <summary>
/// auto generate id for all entities in Asowell Database
/// all id type is 10 character and the sign is depend on the type of entity
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
private TEntity AutoGeneteId_DBAsowell(TEntity entity)
{
string sign = "";
if (entity is Employee)
{
sign = "EMP";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
Employee emp = entity as Employee;
emp.EmpId = result;
}
else if (entity is AdminRe)
{
sign = "AD";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
AdminRe admin = entity as AdminRe;
admin.AdId = result;
}
else if (entity is Customer)
{
sign = "CUS";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
Customer cus = entity as Customer;
cus.CusId = result;
}
else if (entity is WareHouse)
{
sign = "WAH";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
WareHouse wh = entity as WareHouse;
wh.WarehouseId = result;
}
else if (entity is Ingredient)
{
sign = "IGD";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
Ingredient ign = entity as Ingredient;
ign.IgdId = result;
}
else if (entity is Product)
{
sign = "P";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
Product p = entity as Product;
p.ProductId = result;
}
else if (entity is ProductDetail)
{
sign = "PD";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
ProductDetail pd = entity as ProductDetail;
pd.PdetailId = result;
}
else if (entity is OrderNote)
{
sign = "ORD";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
OrderNote ord = entity as OrderNote;
ord.OrdernoteId = result;
}
else if (entity is ReceiptNote)
{
sign = "RN";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
ReceiptNote rcn = entity as ReceiptNote;
rcn.RnId = result;
}
else if (entity is SalaryNote)
{
sign = "SAN";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
SalaryNote sln = entity as SalaryNote;
sln.SnId = result;
}
else if (entity is WorkingHistory)
{
sign = "WOH";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
WorkingHistory wh = entity as WorkingHistory;
wh.WhId = result;
}
else if (entity is StockOut)
{
sign = "STO";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
StockOut stkout = entity as StockOut;
stkout.StockOutId = result;
}
else if (entity is StockIn)
{
sign = "STI";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
StockIn stkIn = entity as StockIn;
stkIn.Si_id = result;
}
else if (entity is APWareHouse)
{
sign = "APW";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
APWareHouse wh = entity as APWareHouse;
wh.APWarehouseId = result;
}
else if (entity is Stock)
{
sign = "STK";
// lấy số thứ tự mới nhất
string numberWantToset = (this.Get().Count() + 1).ToString();
int blank = ID_SIZE_DBASOWELL - (sign.Length + numberWantToset.Length);
string result = sign;
for (int i = 0; i < blank; i++)
{
result += "0";
}
result += numberWantToset;
Stock stock = entity as Stock;
stock.StoId = result;
}
return(entity);
}
public async Task AddOrderTokens(LiquidObject liquidObject, Order order, Customer customer, Store store, OrderNote orderNote = null, Vendor vendor = null, decimal refundedAmount = 0)
{
var liquidOrder = await _mediator.Send(new GetOrderTokensCommand()
{
Order = order,
Customer = customer,
Vendor = vendor,
Store = store,
OrderNote = orderNote,
RefundedAmount = refundedAmount
});
liquidObject.Order = liquidOrder;
await _mediator.EntityTokensAdded(order, liquidOrder, liquidObject);
}
public override bool Execute(OrderTaskContext context)
{
bool result = true;
if (context.HccApp.OrderServices.PaymentSummary(context.Order).AmountDueWithAuth > 0)
{
//Use the last transaction entered by customer first
List <OrderTransaction> transactions = context.HccApp.OrderServices.Transactions
.FindForOrder(context.Order.bvin)
.OrderByDescending(x => x.TimeStampUtc)
.ToList();
decimal dueAmount = context.HccApp.OrderServices.PaymentSummary(context.Order).AmountDueWithAuth;
foreach (OrderTransaction p in transactions)
{
if (p.Action == ActionType.CreditCardInfo)
{
// if we already have an auth or charge on the card, skip
if (p.HasSuccessfulLinkedAction(ActionType.CreditCardCharge, transactions) ||
p.HasSuccessfulLinkedAction(ActionType.CreditCardHold, transactions))
{
OrderNote note = new OrderNote();
note.IsPublic = false;
note.Note = "Skipping receive for credit card info because auth or charge already exists. Transaction " + p.Id;
context.Order.Notes.Add(note);
continue;
}
result &= ProcessTransaction(context, p);
if (result == true)
{
dueAmount = context.HccApp.OrderServices.PaymentSummary(context.Order).AmountDueWithAuth;
//Due amount is already charged, no need to charge other cards
if (dueAmount <= 0)
{
break;
}
}
}
}
}
else
{
OrderNote note = new OrderNote();
note.IsPublic = false;
note.Note = "Amount due was less than zero. Skipping receive credit cards";
context.Order.Notes.Add(note);
}
if (!result)
{
string errorString = "An error occurred while attempting to process your credit card. Please check your payment information and try again";
context.Errors.Add(new WorkflowMessage("Receive Card Failed", errorString, true));
string failCode = OrderStatusCode.OnHold;
OrderStatusCode c = OrderStatusCode.FindByBvin(failCode);
if (c != null)
{
context.Order.StatusCode = c.Bvin;
context.Order.StatusName = c.StatusName;
}
}
return(result);
}
){kind=link}
){kind=link}