/// <summary>
/// Page load event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
try
{
Cart = ShoppingCartInfoProvider.GetShoppingCartInfo(CartID);
var capmaigns = DIContainer.Resolve<IKenticoCampaignsProvider>();
GetItems();
BindBusinessUnit();
if (InventoryType == (Int32)ProductType.GeneralInventory)
{
BindShippingOptions();
ddlShippingOption.SelectedValue = ValidationHelper.GetString(Cart.ShoppingCartShippingOptionID, default(string));
}
else
{
OpenCampaignID = capmaigns.GetOpenCampaignID();
}
ValidCart = true;
BindRepeaterData();
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_DistributorCartDetails", "Page_Load", ex.Message);
}
}
/// <summary>
/// Removing Shopping Cart and cart items by cart id
/// </summary>
/// <param name="shoppingCartID"></param>
private void RemovingProductFromShoppingCart(SKUInfo product, int shoppingCartID)
{
try
{
if (!DataHelper.DataSourceIsEmpty(product))
{
ShoppingCartItemInfo item = null;
ShoppingCartInfo cart = ShoppingCartInfoProvider.GetShoppingCartInfo(shoppingCartID);
cart.User = CurrentUser;
item = cart.CartItems.Where(g => g.SKUID == product.SKUID).FirstOrDefault();
if (!DataHelper.DataSourceIsEmpty(item))
{
ShoppingCartInfoProvider.RemoveShoppingCartItem(cart, item.CartItemID);
ShoppingCartItemInfoProvider.DeleteShoppingCartItemInfo(item);
if (cart.CartItems.Count == 0)
{
ShoppingCartInfoProvider.DeleteShoppingCartInfo(shoppingCartID);
}
cart.InvalidateCalculations();
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("CustomerCartOperations.ascx.cs", "RemovingProductFromShoppingCart()", ex);
}
}
/// <summary>
/// Removes the current cart item and the associated product options from the shopping cart.
/// </summary>
protected void Remove(object sender, EventArgs e)
{
try
{
cart = ShoppingCartInfoProvider.GetShoppingCartInfo(CartID);
foreach (ShoppingCartItemInfo scii in cart.CartItems)
{
if ((scii.CartItemBundleGUID == ShoppingCartItemInfoObject.CartItemGUID) ||
(scii.CartItemParentGUID == ShoppingCartItemInfoObject.CartItemGUID))
{
ShoppingCartItemInfoProvider.DeleteShoppingCartItemInfo(scii);
}
}
ShoppingCartItemInfoProvider.DeleteShoppingCartItemInfo(ShoppingCartItemInfoObject.CartItemGUID);
ShoppingCartInfoProvider.RemoveShoppingCartItem(cart, ShoppingCartItemInfoObject.CartItemGUID);
if (cart.CartItems.Count == 0)
{
ShoppingCartInfoProvider.DeleteShoppingCartInfo(cart.ShoppingCartID);
}
mActivityLogger.LogProductRemovedFromShoppingCartActivity(ShoppingCartItemInfoObject.SKU,
ShoppingCartItemInfoObject.CartItemUnits, ContactID);
ShoppingCartInfoProvider.EvaluateShoppingCart(cart);
ComponentEvents.RequestEvents.RaiseEvent(sender, e, SHOPPING_CART_CHANGED);
URLHelper.Redirect($"{Request.RawUrl}?status={QueryStringStatus.Deleted}");
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_RemoveItemFromCart", "Remove", ex.Message);
}
}
public int GetShoppingCartId(int userId, int siteId)
{
var siteName = SiteInfoProvider.GetSiteInfo(siteId)?.SiteName ?? string.Empty;
if (string.IsNullOrEmpty(siteName))
{
return(0);
}
return(ShoppingCartInfoProvider.GetShoppingCartInfo(userId, siteName)?.ShoppingCartID ?? 0);
}
/// <summary>
/// Initializes the control.
/// </summary>
protected override void OnLoad(EventArgs e)
{
try
{
base.OnLoad(e);
cart = ShoppingCartInfoProvider.GetShoppingCartInfo(CartID);
if (!StopProcessing)
{
btnRemoveItem.Visible = true;
}
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_RemoveItemFromCart", "OnLoad", ex.Message);
}
}
private void TryReplaceCartWithNewOneUsingGuidInUrl()
{
try
{
Guid cartGuid = Guid.Parse(CartGuidQueryString);
ShoppingCartInfo abandonedCart = ShoppingCartInfoProvider.GetShoppingCartInfo(cartGuid);
if ((abandonedCart != null) && (ECommerceContext.CurrentShoppingCart.ShoppingCartGUID != abandonedCart.ShoppingCartGUID))
{
ECommerceContext.CurrentShoppingCart = CloneShoppingCartInfo(abandonedCart);
}
}
catch (FormatException)
{
EventLogProvider.LogException("Load abandoned cart", "LOADABANDONEDCART", null, CurrentSite.SiteID, "Invalid format of GUID");
}
}
/// <summary>
/// Handle the visibility of the control.
/// </summary>
protected override void OnPreRender(EventArgs e)
{
try
{
base.OnPreRender(e);
cart = ShoppingCartInfoProvider.GetShoppingCartInfo(CartID);
bool ItemIsProductOption =
(ShoppingCartItemInfoObject != null) && ShoppingCartItemInfoObject.IsProductOption;
bool CartContentIsReadOnly =
ValidationHelper.GetBoolean(ShoppingCartContent.GetValue("ReadOnlyMode"), false);
btnRemoveItem.Visible = !(ItemIsProductOption || CartContentIsReadOnly);
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_RemoveItemFromCart", "OnPreRender", ex.Message);
}
}
private void TryReplaceCartWithNewOneUsingGuidInUrl()
{
try
{
// Try to restore abandoned cart from DB and set its clone as CurrentShoppingCart
Guid cartGuid = Guid.Parse(CartGuidQueryString);
ShoppingCartInfo abandonedCart = ShoppingCartInfoProvider.GetShoppingCartInfo(cartGuid);
if ((abandonedCart != null) && (Service.Resolve <IShoppingService>().GetCurrentShoppingCart().ShoppingCartGUID != abandonedCart.ShoppingCartGUID))
{
Service.Resolve <ICurrentShoppingCartService>().SetCurrentShoppingCart(CloneShoppingCartInfo(abandonedCart));
}
}
catch (FormatException)
{
EventLogProvider.LogException("Load abandoned cart", "LOADABANDONEDCART", null, CurrentSite.SiteID, "Invalid format of GUID");
}
}
/// <summary>
/// Updating the unit count of shopping cart Item
/// </summary>
private void Updatingtheunitcountofcartitem(SKUInfo product, int shoppinCartID, int unitCount, int customerAddressID, double skuPrice)
{
try
{
var customerAddress = AddressInfoProvider.GetAddressInfo(customerAddressID);
if (!DataHelper.DataSourceIsEmpty(product))
{
ShoppingCartItemInfo item = null;
ShoppingCartInfo cart = ShoppingCartInfoProvider.GetShoppingCartInfo(shoppinCartID);
cart.User = CurrentUser;
cart.ShoppingCartShippingAddress = customerAddress;
if (cart.ShoppingCartCurrencyID <= 0)
{
cart.ShoppingCartCurrencyID = CurrencyInfoProvider.GetMainCurrency(CurrentSite.SiteID).CurrencyID;
cart.Update();
}
var campaingnID = ValidationHelper.GetInteger(cart.GetValue("ShoppingCartCampaignID"), default(int));
var programID = ValidationHelper.GetInteger(cart.GetValue("ShoppingCartProgramID"), default(int));
item = cart.CartItems.Where(g => g.SKUID == product.SKUID).FirstOrDefault();
if (!DataHelper.DataSourceIsEmpty(item))
{
item.CartItemPrice = skuPrice;
ShoppingCartItemInfoProvider.UpdateShoppingCartItemUnits(item, unitCount);
cart.InvalidateCalculations();
}
else
{
ShoppingCartItemParameters parameters = new ShoppingCartItemParameters(product.SKUID, unitCount);
parameters.CustomParameters.Add("CartItemCustomerID", customerAddressID);
ShoppingCartItemInfo cartItem = cart.SetShoppingCartItem(parameters);
cartItem.SetValue("CartItemPrice", skuPrice);
cartItem.SetValue("CartItemDistributorID", customerAddressID);
cartItem.SetValue("CartItemCampaignID", cartItem.SetValue("CartItemCampaignID", campaingnID));
cartItem.SetValue("CartItemProgramID", programID);
ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem);
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("CustomerCartOperations.ascx.cs", "Updatingtheunitcountofcartitem()", ex);
}
}
/// <summary>
/// Updates the Shipping option selected by the user
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ddlBusinessUnits_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
var businessUnitID = ValidationHelper.GetLong(ddlBusinessUnits.SelectedValue, default(long));
if (CartID != default(int) && businessUnitID > 0)
{
Cart = ShoppingCartInfoProvider.GetShoppingCartInfo(CartID);
if (Cart != null)
{
Cart.SetValue("BusinessUnitIDForDistributor", businessUnitID);
Cart.Update();
}
}
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_DistributorCartDetails", "ddlBusinessUnits_SelectedIndexChanged", ex.Message);
}
}
public static object GetCartTotalByInventoryType(EvaluationContext context, params object[] parameters)
{
try
{
int userID = ValidationHelper.GetInteger(parameters[1], default(int));
int inventoryType = ValidationHelper.GetInteger(parameters[2], default(int));
int openCampaignID = ValidationHelper.GetInteger(parameters[3], default(int));
if (inventoryType == (Int32)ProductType.PreBuy)
{
var query = new DataQuery(SQLQueries.getShoppingCartTotal);
QueryDataParameters queryParams = new QueryDataParameters();
queryParams.Add("@ShoppingCartUserID", userID);
queryParams.Add("@ShoppingCartInventoryType", inventoryType);
queryParams.Add("@ShoppingCartCampaignID", openCampaignID);
var cartTotal = ConnectionHelper.ExecuteScalar(query.QueryText, queryParams, QueryTypeEnum.SQLQuery, true);
return(ValidationHelper.GetDecimal(cartTotal, default(decimal)));
}
else
{
var loggedInUSerCartIDs = ShoppingCartHelper.GetCartsByUserID(userID, ProductType.GeneralInventory, openCampaignID);
decimal cartTotal = 0;
loggedInUSerCartIDs.ForEach(cartID =>
{
var Cart = ShoppingCartInfoProvider.GetShoppingCartInfo(cartID);
if (Cart.ShippingOption != null && Cart.ShippingOption.ShippingOptionCarrierServiceName.ToLower() != ShippingOption.Ground)
{
EstimateDeliveryPriceRequestDto estimationdto = ShoppingCartHelper.GetEstimationDTO(Cart);
var estimation = ShoppingCartHelper.CallEstimationService(estimationdto);
cartTotal += ValidationHelper.GetDecimal(estimation?.Payload?.Cost, default(decimal));
}
});
return(ValidationHelper.GetDecimal(cartTotal, default(decimal)));
}
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena Macro methods", "BindPrograms", ex.Message);
return(default(double));
}
}
/// <summary>
/// This method will do order processing
/// </summary>
/// <param name="openCampaignID"></param>
/// <param name="campaignClosingUserID"></param>
/// <returns></returns>
private string GenerateOrder(int openCampaignID, int campaignClosingUserID)
{
try
{
var shoppingCartInfo = DIContainer.Resolve <IShoppingCartProvider>();
var addrerss = DIContainer.Resolve <IAddressBookService>();
var userInfo = DIContainer.Resolve <IKenticoUserProvider>();
var kenticoResourceService = DIContainer.Resolve <IKenticoResourceService>();
var usersWithShoppingCartItems = shoppingCartInfo.GetUserIDsWithShoppingCart(openCampaignID, Convert.ToInt32(ProductsType.PreBuy));
var orderTemplateSettingKey = kenticoResourceService.GetSettingsKey("KDA_OrderReservationEmailTemplate");
var failedOrderTemplateSettingKey = kenticoResourceService.GetSettingsKey("KDA_FailedOrdersEmailTemplate");
var failedOrdersUrl = kenticoResourceService.GetSettingsKey("KDA_FailedOrdersPageUrl");
var unprocessedDistributorIDs = new List <Tuple <int, string> >();
usersWithShoppingCartItems.ForEach(shoppingCartUser =>
{
var salesPerson = userInfo.GetUserByUserId(shoppingCartUser);
var loggedInUserCartIDs = ShoppingCartHelper.GetCartsByUserID(shoppingCartUser, ProductType.PreBuy, openCampaignID);
loggedInUserCartIDs.ForEach(cart =>
{
var shippingCost = default(decimal);
Cart = ShoppingCartInfoProvider.GetShoppingCartInfo(cart);
OrderDTO ordersDTO = ShoppingCartHelper.CreateOrdersDTO(Cart, Cart.ShoppingCartUserID, OrderType.prebuy, shippingCost);
var response = ShoppingCartHelper.ProcessOrder(Cart, Cart.ShoppingCartUserID, OrderType.prebuy, ordersDTO, shippingCost);
if (response != null && response.Success)
{
ordersDTO.OrderID = response.Payload;
ProductEmailNotifications.SendMail(salesPerson, ordersDTO, orderTemplateSettingKey);
InBoundFormHelper.InsertIBFForm(ordersDTO);
ShoppingCartInfoProvider.DeleteShoppingCartInfo(Cart);
ShoppingCartHelper.UpdateRemainingBudget(ordersDTO, salesPerson.UserId);
DIContainer.Resolve <IIBTFService>().InsertIBTFAdjustmentRecord(ordersDTO);
}
else
{
unprocessedDistributorIDs.Add(new Tuple <int, string>(Cart.GetIntegerValue("ShoppingCartDistributorID", default(int)), response.ErrorMessages));
}
});
});
var distributors = addrerss.GetAddressesByAddressIds(unprocessedDistributorIDs.Select(x => x.Item1).ToList()).Select(x =>
{
return(new { AddressID = x?.Id, AddressPersonalName = x?.AddressPersonalName });
}).ToList();
var listofFailedOrders = unprocessedDistributorIDs.Select(x =>
{
var distributor = distributors.Where(y => y.AddressID == x.Item1).FirstOrDefault();
return(new
{
Name = distributor.AddressPersonalName,
Reason = x.Item2
});
}).ToList();
var user = userInfo.GetUserByUserId(campaignClosingUserID);
if (user?.Email != null && listofFailedOrders.Count > 0)
{
Dictionary <string, object> failedOrderData = new Dictionary <string, object>();
failedOrderData.Add("failedorderurl", URLHelper.AddHTTPToUrl($"{SiteContext.CurrentSite.DomainName}{failedOrdersUrl}?campid={openCampaignID}"));
failedOrderData.Add("failedordercount", listofFailedOrders.Count);
failedOrderData.Add("failedorders", listofFailedOrders);
ProductEmailNotifications.SendEmailNotification(failedOrderTemplateSettingKey, user.Email, listofFailedOrders, "failedOrders", failedOrderData);
UpdatetFailedOrders(openCampaignID, true);
}
return(ResHelper.GetString("KDA.OrderSchedular.TaskSuccessfulMessage"));
}
catch (Exception ex)
{
EventLogProvider.LogException("GeneratePrebuyOrderTask", "GenerateOrder", ex, SiteContext.CurrentSiteID, ex.Message);
return(ex.Message);
}
}
public ShoppingCartInfo GetShoppingCartByID(int cartID)
{
return(ShoppingCartInfoProvider.GetShoppingCartInfo(cartID));
}
private ShoppingCartInfo GetShoppingCart(int shoppingCartId = 0)
{
return(shoppingCartId > 0
? ShoppingCartInfoProvider.GetShoppingCartInfo(shoppingCartId)
: ECommerceContext.CurrentShoppingCart);
}
/// <summary>
/// Chekcou click event for order processing
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void lnkCheckout_Click(object sender, EventArgs e)
{
try
{
if (!DIContainer.Resolve <IShoppingCartProvider>().ValidateAllCarts(userID: CurrentUser.UserID))
{
Response.Cookies["status"].Value = QueryStringStatus.InvalidCartItems;
Response.Cookies["status"].HttpOnly = false;
return;
}
var loggedInUserCartIDs = GetCartsByUserID(CurrentUser.UserID, ProductType.GeneralInventory, OpenCampaign?.CampaignID); settingKeys = DIContainer.Resolve <IKenticoResourceService>();
var orderTemplateSettingKey = settingKeys.GetSettingsKey("KDA_OrderReservationEmailTemplateGI");
var unprocessedDistributorIDs = new List <Tuple <int, string> >();
var userInfo = DIContainer.Resolve <IKenticoUserProvider>();
var salesPerson = userInfo.GetUserByUserId(CurrentUser.UserID);
loggedInUserCartIDs.ForEach(distributorCart =>
{
Cart = ShoppingCartInfoProvider.GetShoppingCartInfo(distributorCart);
decimal shippingCost = default(decimal);
if (Cart.ShippingOption != null && Cart.ShippingOption.ShippingOptionName.ToLower() != ShippingOption.Ground)
{
var shippingResponse = GetOrderShippingTotal(Cart);
if (shippingResponse != null && shippingResponse.Success)
{
shippingCost = ValidationHelper.GetDecimal(shippingResponse?.Payload?.Cost, default(decimal));
}
else
{
unprocessedDistributorIDs.Add(new Tuple <int, string>(Cart.GetIntegerValue("ShoppingCartDistributorID", default(int)), shippingResponse.ErrorMessages));
return;
}
}
OrderDTO ordersDTO = CreateOrdersDTO(Cart, Cart.ShoppingCartUserID, OrderType.generalInventory, shippingCost);
var response = ProcessOrder(Cart, CurrentUser.UserID, OrderType.generalInventory, ordersDTO, shippingCost);
if (response != null && response.Success)
{
UpdateAvailableSKUQuantity(Cart);
UpdateAllocatedProductQuantity(Cart, salesPerson.UserId);
ProductEmailNotifications.SendMail(salesPerson, ordersDTO, orderTemplateSettingKey);
ShoppingCartInfoProvider.DeleteShoppingCartInfo(Cart);
ShoppingCartHelper.UpdateRemainingBudget(ordersDTO, CurrentUser.UserID);
}
else
{
unprocessedDistributorIDs.Add(new Tuple <int, string>(Cart.GetIntegerValue("ShoppingCartDistributorID", default(int)), response.ErrorMessages));
}
});
if (unprocessedDistributorIDs.Count == 0)
{
Response.Cookies["status"].Value = QueryStringStatus.OrderSuccess;
Response.Cookies["status"].HttpOnly = false;
URLHelper.Redirect(Request.RawUrl);
}
else
{
if (loggedInUserCartIDs.Count > unprocessedDistributorIDs.Count)
{
Response.Cookies["status"].Value = QueryStringStatus.OrderSuccess;
Response.Cookies["status"].HttpOnly = false;
}
Response.Cookies["error"].Value = QueryStringStatus.OrderFail;
Response.Cookies["error"].HttpOnly = false;
ShowOrderErrorList(unprocessedDistributorIDs);
divErrorDailogue.Attributes.Add("class", "dialog active");
}
}
catch (Exception ex)
{
EventLogProvider.LogInformation("Kadena_CMSWebParts_Kadena_Cart_CartCheckout", "lnkCheckout_Click", ex.Message);
}
}
