/// <summary>
/// Checks if order contains e-product or membership product. If so generates a confirmation message.
/// </summary>
private string GetConfirmationMessage()
{
// Get order items for this order
var orderItems = OrderItemInfoProvider.GetOrderItems(Order.OrderID);
mShowMembershipWarning = orderItems.Any(i => i.OrderItemSKU.SKUProductType == SKUProductTypeEnum.Membership);
mShowEproductWarning = orderItems.Any(i => i.OrderItemSKU.SKUProductType == SKUProductTypeEnum.EProduct);
// If one of the rollback warnings should be shown
if (mShowEproductWarning || mShowMembershipWarning)
{
// Set standard warning message
string paidUncheckWarning = GetString("order_edit_billing.orderispaiduncheckwarning");
// Add memberships rollback warning message if required
if (mShowMembershipWarning)
{
paidUncheckWarning += "\\n\\n- " + GetString("order_edit_billing.orderispaiduncheckwarningmemberships");
}
// Add e-products rollback warning message if required
if (mShowEproductWarning)
{
paidUncheckWarning += "\\n\\n- " + GetString("order_edit_billing.orderispaiduncheckwarningeproducts");
}
return(paidUncheckWarning);
}
return("");
}
protected void RptCommandeItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
var itemRepeater = e.Item.FindControl("rptItem") as Repeater;
if (itemRepeater != null)
{
var commande = (DataRowView)e.Item.DataItem;
if (commande != null)
{
var commandeId = (int)commande["OrderID"];
var filtre = String.Format("OrderItemOrderID = {0}", commandeId);
var dsItem = OrderItemInfoProvider.GetOrderItems(filtre, "", 100, "");
itemRepeater.DataSource = dsItem.Tables[0];
itemRepeater.DataBind();
// OrderItemInfo oii = new OrderItemInfo();
var orderInfo = OrderInfoProvider.GetOrderInfo(commandeId);
var status = orderInfo.GetValue("OrderStatus") != null ? (string)orderInfo.GetValue("OrderStatus") :
String.Empty;
if (status == "0")
{
var button = e.Item.FindControl("lnkPayer") as LinkButton;
if (button != null)
{
button.Visible = true;
}
}
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Set default error message
var errorMessageResString = "getproductfile.existerror";
// Get order item SKU file
var token = QueryHelper.GetGuid("token", Guid.Empty);
var orderedFile = OrderItemSKUFileInfoProvider.GetOrderItemSKUFileInfo(token);
if (orderedFile != null)
{
// Get parent order item
var orderItem = OrderItemInfoProvider.GetOrderItemInfo(orderedFile.OrderItemID);
if (orderItem != null)
{
// If download is not expired
if ((orderItem.OrderItemValidTo.CompareTo(DateTimeHelper.ZERO_TIME) == 0) || (orderItem.OrderItemValidTo.CompareTo(DateTime.Now) > 0))
{
// Get SKU file
var skuFile = SKUFileInfoProvider.GetSKUFileInfo(orderedFile.FileID);
if (skuFile != null)
{
// Decide how to process the file based on file type
switch (skuFile.FileType.ToLowerCSafe())
{
case "metafile":
// Set parameters to current context
Context.Items["fileguid"] = skuFile.FileMetaFileGUID;
Context.Items["disposition"] = "attachment";
// Handle request using metafile handler
Response.Clear();
var handler = new GetMetaFileHandler();
handler.ProcessRequest(Context);
Response.End();
return;
}
}
}
else
{
// Set error message
errorMessageResString = "getproductfile.expirederror";
}
}
}
// Perform server side redirect to error page
Response.Clear();
Server.Transfer(UIHelper.GetErrorPageUrl("getproductfile.error", errorMessageResString));
Response.End();
}
private void NewOrderCreated_Execute(object sender, NewOrderCreatedEventArgs e)
{
var contact = ContactManagementContext.GetCurrentContact();
var service = new RecombeeClientService();
var order = e.NewOrder;
var orderItems = OrderItemInfoProvider.GetOrderItems(order.OrderID);
foreach (var orderItem in orderItems)
{
var product = GetProductForSKU(orderItem.OrderItemSKUID);
service.LogProductPurchase(contact.ContactGUID, product.DocumentGUID, orderItem.OrderItemUnitCount);
}
}
public void CartWithOneItem_CreateOrder_OrderItemIsSet(int unitsOrdered)
{
var cart = CreateCartWithCustomerInfo(Factory.CustomerAnonymous, Factory.CustomerAddressUSA);
cart.AddItem(Factory.SKUAvailable.SKUID, unitsOrdered);
var order = ShoppingService.CreateOrder(cart);
var orderItems = OrderItemInfoProvider.GetOrderItems(order.OrderID).ToList();
Assert.AreEqual(1, orderItems.Count, "Wrong number of order items created");
Assert.AreEqual(Factory.SKUAvailable.SKUID, orderItems[0].OrderItemSKUID, "Wrong product ordered");
Assert.AreEqual(unitsOrdered, orderItems[0].OrderItemUnitCount, "Wrong number of products ordered");
}
/// <summary>
/// Checks if order contains e-product or membership product. If so generates a confirmation message.
/// </summary>
private string GetConfirmationMessage()
{
// Get order items for this order
DataSet orderItems = OrderItemInfoProvider.GetOrderItems(Order.OrderID);
foreach (DataRow orderItemRow in orderItems.Tables[0].Rows)
{
// Get order item
var item = new OrderItemInfo(orderItemRow);
if (item.OrderItemSKU != null)
{
switch (item.OrderItemSKU.SKUProductType)
{
// If order item represents membership
case SKUProductTypeEnum.Membership:
showMembershipWarning = true;
break;
// If order item represents e-product
case SKUProductTypeEnum.EProduct:
showEproductWarning = true;
break;
}
}
}
// If one of the rollback warnings should be shown
if (showEproductWarning || showMembershipWarning)
{
// Set standard warning message
string paidUncheckWarning = GetString("order_edit_billing.orderispaiduncheckwarning");
// Add memberships rollback warning message if required
if (showMembershipWarning)
{
paidUncheckWarning += "\\n\\n- " + GetString("order_edit_billing.orderispaiduncheckwarningmemberships");
}
// Add e-products rollback warning message if required
if (showEproductWarning)
{
paidUncheckWarning += "\\n\\n- " + GetString("order_edit_billing.orderispaiduncheckwarningeproducts");
}
return(paidUncheckWarning);
}
return("");
}
public void CartWithItems_CreateOrder_OrderItemsAreSet(int firstProductUnits, int secondProductUnits)
{
var cart = CreateCartWithCustomerInfo(Factory.CustomerAnonymous, Factory.CustomerAddressUSA);
cart.AddItem(Factory.SKUAvailable.SKUID, firstProductUnits);
cart.AddItem(Factory.SKUWithoutShipping.SKUID, secondProductUnits);
var order = ShoppingService.CreateOrder(cart);
var orderItemsBySKUID = OrderItemInfoProvider.GetOrderItems(order.OrderID).ToDictionary(i => i.OrderItemSKUID);
CMSAssert.All(
() => Assert.AreEqual(2, orderItemsBySKUID.Count, "Wrong number of order items created"),
() => Assert.AreEqual(firstProductUnits, orderItemsBySKUID[Factory.SKUAvailable.SKUID].OrderItemUnitCount, "Wrong number of SKUAvailable ordered"),
() => Assert.AreEqual(secondProductUnits, orderItemsBySKUID[Factory.SKUWithoutShipping.SKUID].OrderItemUnitCount, "Wrong number of SKUWithoutShipping ordered")
);
}
public ActionResult OrderDetail(int?orderID)
{
if (orderID == null)
{
return(RedirectToAction("Index"));
}
var order = orderRepository.GetById(orderID.Value);
if ((order == null) || (order.OrderCustomerID != CurrentCustomer?.CustomerID))
{
return(RedirectToAction("Error", "HttpErrors", new { code = (int)HttpStatusCode.NotFound }));
}
var currency = currencyInfoProvider.Get(order.OrderCurrencyID);
return(View(new OrderDetailViewModel(currency.CurrencyFormatString)
{
InvoiceNumber = order.OrderInvoiceNumber,
TotalPrice = order.OrderTotalPrice,
StatusName = orderStatusInfoProvider.Get(order.OrderStatusID)?.StatusDisplayName,
OrderAddress = new OrderAddressViewModel(order.OrderBillingAddress, countryInfoProvider, stateInfoProvider),
OrderItems = OrderItemInfoProvider.GetOrderItems(order.OrderID).Select(orderItem =>
{
return new OrderItemViewModel
{
SKUID = orderItem.OrderItemSKUID,
SKUName = orderItem.OrderItemSKUName,
SKUImagePath = string.IsNullOrEmpty(orderItem.OrderItemSKU.SKUImagePath) ? null : new FileUrl(orderItem.OrderItemSKU.SKUImagePath, true).WithSizeConstraint(SizeConstraint.MaxWidthOrHeight(70)).RelativePath,
TotalPriceInMainCurrency = orderItem.OrderItemTotalPriceInMainCurrency,
UnitCount = orderItem.OrderItemUnitCount,
UnitPrice = orderItem.OrderItemUnitPrice
};
})
}));
}
public ActionResult OrderDetail(int?orderID)
{
if (orderID == null)
{
return(RedirectToAction("Index"));
}
var order = mOrderRepository.GetById(orderID.Value);
if ((order == null) || (order.OrderCustomerID != CurrentCustomer?.CustomerID))
{
return(RedirectToAction("NotFound", "HttpErrors"));
}
var currency = CurrencyInfoProvider.GetCurrencyInfo(order.OrderCurrencyID);
return(View(new OrderDetailViewModel(currency.CurrencyFormatString)
{
InvoiceNumber = order.OrderInvoiceNumber,
TotalPrice = order.OrderTotalPrice,
StatusName = OrderStatusInfoProvider.GetOrderStatusInfo(order.OrderStatusID)?.StatusDisplayName,
OrderAddress = new OrderAddressViewModel(order.OrderBillingAddress),
OrderItems = OrderItemInfoProvider.GetOrderItems(order.OrderID).Select(orderItem =>
{
return new OrderItemViewModel
{
SKUID = orderItem.OrderItemSKUID,
SKUName = orderItem.OrderItemSKUName,
SKUImagePath = orderItem.OrderItemSKU.SKUImagePath,
TotalPriceInMainCurrency = orderItem.OrderItemTotalPriceInMainCurrency,
UnitCount = orderItem.OrderItemUnitCount,
UnitPrice = orderItem.OrderItemUnitPrice
};
})
}));
}
protected void LoadData()
{
OrderInfo oi = OrderInfoProvider.GetOrderInfo(orderId);
EditedObject = oi;
if (oi != null)
{
// Check order site ID
CheckOrderSiteID(oi.OrderSiteID);
customerId = oi.OrderCustomerID;
string paymentResultValue = oi.OrderPaymentResult.GetFormattedPaymentResultString();
if (paymentResultValue.Trim() == String.Empty)
{
paymentResultValue = GetString("general.na");
}
lblPaymentResultValue.Text = paymentResultValue;
drpPayment.ShippingOptionID = oi.OrderShippingOptionID;
drpPayment.AddNoneRecord = true;
// If no shipping option selected
if (drpPayment.ShippingOptionID == 0)
{
drpPayment.DisplayOnlyAllowedIfNoShipping = true;
}
addressElem.CustomerID = customerId;
if (!URLHelper.IsPostback())
{
drpPayment.PaymentID = oi.OrderPaymentOptionID;
drpCurrency.CurrencyID = oi.OrderCurrencyID;
addressElem.AddressID = oi.OrderBillingAddressID;
chkOrderIsPaid.Checked = oi.OrderIsPaid;
}
// Get order items for this order
DataSet orderItems = OrderItemInfoProvider.GetOrderItems(orderId);
foreach (DataRow orderItem in orderItems.Tables[0].Rows)
{
// Get order item
OrderItemInfo oii = new OrderItemInfo(orderItem);
if ((oii != null) && (oii.OrderItemSKU != null))
{
switch (oii.OrderItemSKU.SKUProductType)
{
// If order item represents membership
case SKUProductTypeEnum.Membership:
showMembershipWarning = true;
break;
// If order item represents e-product
case SKUProductTypeEnum.EProduct:
showEproductWarning = true;
break;
}
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
string errorMessage = null;
// Get order item SKU file
OrderItemSKUFileInfo oiskufi = OrderItemSKUFileInfoProvider.GetOrderItemSKUFileInfo(token);
if (oiskufi != null)
{
// Get parent order item
OrderItemInfo oii = OrderItemInfoProvider.GetOrderItemInfo(oiskufi.OrderItemID);
if (oii != null)
{
// If download is not expired
if ((oii.OrderItemValidTo.CompareTo(DateTimeHelper.ZERO_TIME) == 0) || (oii.OrderItemValidTo.CompareTo(DateTime.Now) > 0))
{
// Get SKU file
SKUFileInfo skufi = SKUFileInfoProvider.GetSKUFileInfo(oiskufi.FileID);
if (skufi != null)
{
// Decide how to process the file based on file type
switch (skufi.FileType.ToLowerCSafe())
{
case "metafile":
// Set parameters to current context
Context.Items["fileguid"] = skufi.FileMetaFileGUID;
Context.Items["disposition"] = "attachment";
// Perform server side redirect to download
Response.Clear();
Server.Transfer(URLHelper.ResolveUrl("~/CMSPages/GetMetaFile.aspx"));
Response.End();
return;
}
}
}
else
{
// Set error message
errorMessage = ResHelper.GetString("getproductfile.expirederror");
}
}
}
// If error message not set
if (String.IsNullOrEmpty(errorMessage))
{
// Set default error message
errorMessage = ResHelper.GetString("getproductfile.existerror");
}
// Set error message to current context
Context.Items["title"] = ResHelper.GetString("getproductfile.error");
Context.Items["text"] = errorMessage;
// Perform server side redirect to error page
Response.Clear();
Server.Transfer(URLHelper.ResolveUrl("~/CMSMessages/Error.aspx"));
Response.End();
}
/// <summary>
/// Reloads repeater data.
/// </summary>
private void ReloadRepeaterData()
{
repeater.DataSource = OrderItemInfoProvider.GetDonations(GetCompleteWhereCondition(), OrderBy, TopN, Columns);
repeater.DataBind();
}
/// <summary>
/// Reloads repeater data.
/// </summary>
private void ReloadRepeaterData()
{
this.repeater.DataSource = OrderItemInfoProvider.GetDonations(this.GetCompleteWhereCondition(), this.OrderBy, this.TopN, this.Columns);
this.repeater.DataBind();
}
public async Task <IActionResult> Payment([FromBody] AcceptJSDataModel model)
{
ApiOperationBase <ANetApiRequest, ANetApiResponse> .RunEnvironment = AuthorizeNet.Environment.SANDBOX;
// define the merchant information (authentication / transaction id)
ApiOperationBase <ANetApiRequest, ANetApiResponse> .MerchantAuthentication = new merchantAuthenticationType()
{
name = AcceptJSOptions.AcceptJSApiLoginID(),
ItemElementName = ItemChoiceType.transactionKey,
Item = AcceptJSOptions.AcceptJSApiTransactionKey()
};
var opaqueData = new opaqueDataType()
{
dataDescriptor = model.DataDescriptor,
dataValue = model.DataValue
};
var paymentType = new paymentType()
{
Item = opaqueData
};
var order = (await OrderInfoProvider.Get().WhereEquals(nameof(OrderInfo.OrderGUID), model.OrderGUID).TopN(1).GetEnumerableTypedResultAsync()).FirstOrDefault();
var orderItems = await OrderItemInfoProvider.Get().WhereEquals(nameof(OrderItemInfo.OrderItemOrderID), order.OrderID).GetEnumerableTypedResultAsync();
var customer = await CustomerInfoProvider.GetAsync(order.OrderCustomerID);
var lineItems = new List <lineItemType>();
foreach (var item in orderItems)
{
lineItems.Add(new lineItemType()
{
itemId = item.OrderItemID.ToString(), name = item.OrderItemSKUName, unitPrice = item.OrderItemUnitPrice, quantity = item.OrderItemUnitCount
});
}
var state = await StateInfoProvider.GetAsync(order.OrderBillingAddress.AddressStateID);
var billingAddress = new customerAddressType
{
firstName = customer.CustomerFirstName,
lastName = customer.CustomerLastName,
address = order.OrderBillingAddress.AddressLine1,
city = order.OrderBillingAddress.AddressCity,
zip = order.OrderBillingAddress.AddressZip,
state = state.StateCode
};
state = await StateInfoProvider.GetAsync(order.OrderShippingAddress.AddressStateID);
var shippingAddress = new customerAddressType
{
firstName = customer.CustomerFirstName,
lastName = customer.CustomerLastName,
address = order.OrderShippingAddress.AddressLine1,
city = order.OrderShippingAddress.AddressCity,
zip = order.OrderShippingAddress.AddressZip,
state = state.StateCode
};
var mainCurrency = Service.Resolve <ISiteMainCurrencySource>().GetSiteMainCurrency(order.OrderSiteID);
var orderCurrency = await CurrencyInfoProvider.GetAsync(order.OrderCurrencyID);
var currencyConverter = Service.Resolve <ICurrencyConverterService>();
var rateToMainCurrency = currencyConverter.GetExchangeRate(orderCurrency.CurrencyCode, mainCurrency.CurrencyCode, order.OrderSiteID);
var roundingService = Service.Resolve <IRoundingServiceFactory>().GetRoundingService(order.OrderSiteID);
var shipping = roundingService.Round(currencyConverter.ApplyExchangeRate(order.OrderTotalShipping, rateToMainCurrency), mainCurrency);
var tax = roundingService.Round(currencyConverter.ApplyExchangeRate(order.OrderTotalTax, rateToMainCurrency), mainCurrency);
var transactionRequest = new transactionRequestType
{
transactionType = transactionTypeEnum.authCaptureTransaction.ToString(),
amount = order.OrderGrandTotalInMainCurrency,
shipping = new extendedAmountType()
{
amount = shipping, name = "Shipping", description = "Total Order Shipping"
},
tax = new extendedAmountType()
{
amount = tax, name = "Tax", description = "Total Order Tax"
},
payment = paymentType,
billTo = billingAddress,
shipTo = shippingAddress,
lineItems = lineItems.ToArray(),
poNumber = order.OrderID.ToString()
};
var request = new createTransactionRequest {
transactionRequest = transactionRequest
};
// instantiate the controller that will call the service
var controller = new createTransactionController(request);
controller.Execute();
// get the response from the service (errors contained if any)
var response = controller.GetApiResponse();
// validate response
if (response != null)
{
if (response.messages.resultCode == messageTypeEnum.Ok)
{
if (response.transactionResponse.messages != null)
{
if (order != null && response.transactionResponse.responseCode == "1")
{
// Creates a payment result object that will be viewable in Xperience
PaymentResultInfo result = new PaymentResultInfo
{
PaymentDate = DateTime.Now,
PaymentDescription = "Successfully created transaction with Transaction ID: " + response.transactionResponse.transId,
PaymentIsCompleted = response.transactionResponse.responseCode == "1",
PaymentTransactionID = response.transactionResponse.transId,
PaymentStatusValue = $"Response Code: {response.transactionResponse.responseCode}, Message Code: {response.transactionResponse.messages[0].code}, Description: { response.transactionResponse.messages[0].description}",
PaymentMethodName = "AcceptJS"
};
// Saves the payment result to the database
order.UpdateOrderStatus(result);
return(new JsonResult(new { PaymentSuccessful = true }));
}
else
{
return(new JsonResult(new { Message = $"Message Code: { response.transactionResponse.messages[0].code}, Description: {response.transactionResponse.messages[0].description}" }));
}
}
else
{
if (response.transactionResponse.errors != null)
{
return(new JsonResult(new { Message = $"Failed Transaction. {response.transactionResponse.errors[0].errorCode}: {response.transactionResponse.errors[0].errorText}" }));
}
return(new JsonResult(new { Message = "Failed Transaction." }));
}
}
else
{
if (response.transactionResponse != null && response.transactionResponse.errors != null)
{
return(new JsonResult(new { Message = $"Failed Transaction. {response.transactionResponse.errors[0].errorCode}: {response.transactionResponse.errors[0].errorText}" }));
}
else
{
return(new JsonResult(new { Message = $"Failed Transaction. {response.messages.message[0].code}: {response.messages.message[0].text}" }));
}
}
}
else
{
return(new JsonResult(new { Message = ResHelper.GetString("AcceptJS.ResponseNull") }));
}
}
