public bool Authorize(Transaction t, HotcakesApplication app)
{
try
{
var ppAPI = PaypalExpressUtilities.GetPaypalAPI(app.CurrentStore);
if (t.PreviousTransactionNumber != null)
{
var OrderNumber = t.MerchantInvoiceNumber + Guid.NewGuid();
var paymentResponse = ppAPI.DoExpressCheckoutPayment(t.PreviousTransactionNumber,
t.PreviousTransactionAuthCode,
t.Amount.ToString("N", CultureInfo.InvariantCulture),
PaymentActionCodeType.Order,
PayPalAPI.GetCurrencyCodeType(app.CurrentStore.Settings.PayPal.Currency),
OrderNumber);
if (paymentResponse.Ack == AckCodeType.Success ||
paymentResponse.Ack == AckCodeType.SuccessWithWarning)
{
var paymentInfo = paymentResponse.DoExpressCheckoutPaymentResponseDetails.PaymentInfo[0];
t.Result.Succeeded = true;
t.Result.ReferenceNumber = paymentInfo.TransactionID;
t.Result.ResponseCode = "OK";
t.Result.ResponseCodeDescription = "PayPal Express Payment Authorized Successfully.";
return(true);
}
t.Result.Succeeded = false;
t.Result.Messages.Add(new Message("PayPal Express Payment Authorization Failed.", string.Empty,
MessageType.Error));
foreach (var ppError in paymentResponse.Errors)
{
t.Result.Messages.Add(new Message(ppError.LongMessage, ppError.ErrorCode, MessageType.Error));
}
return(false);
}
}
catch (Exception ex)
{
HandleException(t, ex);
}
return(false);
}
public bool OrdersDeleteWithInventoryReturn(string orderBvin, HotcakesApplication app)
{
var o = Orders.FindForCurrentStore(orderBvin);
if (o == null)
{
return(true);
}
// return items to inventory
foreach (var li in o.Items)
{
// We need to unreserve items instead increase inventory
app.CatalogServices.InventoryLineItemUnreserveInventory(li);
}
return(OrdersDelete(o.bvin, app));
}
public override string FriendlyDescription(HotcakesApplication app)
{
var isDiscount = Amount < 0;
var result = (isDiscount ? "Decrease" : "Increase") + " Product Price by ";
switch (AdjustmentType)
{
case AmountTypes.MonetaryAmount:
result += Math.Abs(Amount).ToString("c");
break;
case AmountTypes.Percent:
result += (Math.Abs(Amount) / 100m).ToString("p");
break;
}
return(result);
}
// Use this VERY carefully
public bool DestroyAllCustomers(HotcakesApplication app)
{
var current = DateTime.UtcNow;
var availableUntil = app.CurrentStore.Settings.AllowApiToClearUntil;
var compareResult = DateTime.Compare(current, availableUntil);
if (compareResult >= 0)
{
return(false);
}
var all = Customers.FindAll();
foreach (var a in all)
{
Customers.Delete(a.Bvin);
}
return(true);
}
public object GetCategoryPerformanceData(HttpRequest request, HotcakesApplication hccApp)
{
var categoryId = request.Params["categoryId"];
var period = (SalesPeriod)Enum.Parse(typeof(SalesPeriod), request.Params["period"]);
// Update setting only if it is different
var performanceUserSelections = new PerformanceUserSelections();
if (performanceUserSelections.CategoriesPerformacePeriod != period)
{
performanceUserSelections.CategoriesPerformacePeriod = period;
}
var reportingService = Factory.CreateService <ReportingService>();
var performanceInfo = reportingService.GetCategoryPerformance(categoryId, period);
return(new PerformanceInfoJson(performanceInfo, period, Localization));
}
public DateTime GetEndDateUtc(HotcakesApplication hccApp)
{
DateTime result;
if (RangeType == DateRangeType.Custom)
{
var date = DateTime.Parse(radStartDate.Text.Trim());
result = date.MaxOutTime();
}
else
{
_range.RangeType = RangeType;
_range.CalculateDatesFromType(DateHelper.ConvertUtcToStoreTime(hccApp));
result = _range.EndDate;
}
return(DateHelper.ConvertStoreTimeToUtc(hccApp, result));
}
public DateTime GetEndDateUtc(HotcakesApplication hccApp)
{
DateTime result;
if (RangeType == DateRangeType.Custom)
{
var date = radEndDate.SelectedDate;
result = (date ?? radEndDate.MaxDate).MaxOutTime();
}
else
{
_range.RangeType = RangeType;
_range.CalculateDatesFromType(DateHelper.ConvertUtcToStoreTime(hccApp));
result = _range.EndDate;
}
return(DateHelper.ConvertStoreTimeToUtc(hccApp, result));
}
internal static ICartIntegration Create(HotcakesApplication hccApp)
{
var settings = hccApp.CurrentStore.Settings.Urls;
if (!string.IsNullOrEmpty(settings.CartIntegrationAssemblyAndType))
{
try
{
var type = Type.GetType(settings.CartIntegrationAssemblyAndType);
return (ICartIntegration) Activator.CreateInstance(type);
}
catch
{
settings.CartIntegrationAssemblyAndType = string.Empty;
hccApp.UpdateCurrentStore();
}
}
return new CartIntegration();
}
public static bool DownloadFile(ProductFile file, HotcakesApplication app)
{
var extension = Path.GetExtension(file.FileName);
var name = Path.GetFileName(file.FileName);
double fileSize = 0;
var storeId = app.CurrentRequestContext.CurrentStore.Id;
var diskFileName = file.Bvin + "_" + file.FileName + ".config";
if (!DiskStorage.FileVaultFileExists(storeId, diskFileName))
{
return(false);
}
var bytes = DiskStorage.FileVaultGetBytes(storeId, diskFileName);
var type = MimeTypes.FindTypeForExtension(extension);
fileSize = bytes.Length;
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.ClearContent();
HttpContext.Current.Response.ClearHeaders();
if (!string.IsNullOrEmpty(type))
{
HttpContext.Current.Response.ContentType = type;
}
HttpContext.Current.Response.AppendHeader("content-disposition", "attachment; filename=" + name);
if (fileSize > 0)
{
HttpContext.Current.Response.AddHeader("Content-Length", fileSize.ToString());
}
HttpContext.Current.Response.BinaryWrite(bytes);
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.End();
return(true);
}
public override bool Execute(OrderTaskContext context)
{
_app = context.HccApp;
switch (TaskMode)
{
case Mode.OrderStatusChanged:
HandleOrderStatusChanged(context);
break;
case Mode.PaymentChanged:
HandlePaymentChanged(context);
break;
default:
break;
}
return(true);
}
public List <HtmlTemplateTag> DefaultReplacementTags(HccRequestContext context)
{
var tags = new List <HtmlTemplateTag>();
var store = context.CurrentStore;
var hccApp = new HotcakesApplication(context);
var addressRepository = Factory.CreateRepo <AddressRepository>(context);
tags.Add(new HtmlTemplateTag("[[Store.Address]]", addressRepository.FindStoreContactAddress().ToHtmlString()));
tags.Add(new HtmlTemplateTag("[[Store.ContactEmail]]", store.Settings.MailServer.EmailForGeneral));
tags.Add(new HtmlTemplateTag("[[Store.Logo]]", HtmlRendering.Logo(hccApp, false)));
tags.Add(new HtmlTemplateTag("[[Store.SecureUrl]]", store.RootUrlSecure()));
tags.Add(new HtmlTemplateTag("[[Store.StoreName]]", store.Settings.FriendlyName));
tags.Add(new HtmlTemplateTag("[[Store.RawStoreName]]", store.StoreName));
tags.Add(new HtmlTemplateTag("[[Store.StandardUrl]]", store.RootUrl()));
tags.Add(new HtmlTemplateTag("[[Store.CurrentLocalTime]]", DateTime.Now.ToString()));
tags.Add(new HtmlTemplateTag("[[Store.CurrentUtcTime]]", DateTime.UtcNow.ToString()));
return(tags);
}
public static MenuItem GetByBaseUrl(HotcakesApplication hccApp, string url, int level = 1)
{
MenuItem item = null;
var items = GetFilteredMenuItems(hccApp);
while (level > 0)
{
item = items.FirstOrDefault(mi => IsCurrent(mi, url));
if (item == null)
{
return(null);
}
items = item.ChildItems;
level--;
}
return(item);
}
public static string HeaderLinks(HotcakesApplication app, string currentUserId)
{
var sb = new StringBuilder();
var rootUrl = app.StoreUrl(false, true);
var rootUrlSecure = app.StoreUrl(true, false);
sb.Append("<ul>");
sb.Append("<li><a class=\"myaccountlink\" href=\"" + rootUrlSecure + "account\"><span>");
sb.Append("My Account");
sb.Append("</span></a></li>");
sb.Append("<li><a class=\"signinlink\"");
if (currentUserId == string.Empty)
{
sb.Append(" href=\"" + rootUrlSecure + "SignIn\"><span>");
sb.Append("Sign In");
}
else
{
var name = string.Empty;
var a = app.MembershipServices.Customers.Find(currentUserId);
if (a != null)
{
name = a.Email;
}
sb.Append(" href=\"" + rootUrlSecure + "SignOut\" title=\"" + HttpUtility.HtmlEncode(name) + "\"><span>");
sb.Append("Sign Out");
}
sb.Append("</span></a></li>");
sb.Append("<li><a class=\"contactlink\" href=\"" + rootUrl + "Checkout\"><span>");
sb.Append("Checkout");
sb.Append("</span></a></li>");
sb.Append("</ul>");
return(sb.ToString());
}
/// <summary>
/// Set parameter values with provided product object
/// </summary>
/// <param name="p">Product information.</param>
/// <param name="hccApp">An instance of the Hotcakes Application context.</param>
public SingleProductViewModel(Product p, HotcakesApplication hccApp)
{
if (p == null)
{
throw new ArgumentNullException("Product");
}
if (hccApp == null)
{
throw new ArgumentNullException("HotcakesApplication");
}
UserPrice = hccApp.PriceProduct(p, hccApp.CurrentCustomer, null, hccApp.CurrentlyActiveSales);
Item = p;
ProductLink = UrlRewriter.BuildUrlForProduct(p);
ProductAddToCartLink = UrlRewriter.BuildUrlForProductAddToCart(p);
ImageUrls = new ProductImageUrls();
ImageUrls.LoadProductImageUrls(hccApp, p);
SwatchDisplay = ImageHelper.GenerateSwatchHtmlForProduct(p, hccApp);
}
private string CreateSku(string sku, HotcakesApplication hccApp)
{
// Try 10000 times to append to URL if in use
var skuInUse = hccApp.CatalogServices.Products.IsSkuExist(sku);
var baseSku = sku;
for (var i = 2; i < 10000; i++)
{
if (skuInUse)
{
sku = string.Concat(baseSku, "-", i.ToString());
skuInUse = hccApp.CatalogServices.Products.IsSkuExist(sku);
if (!skuInUse)
{
return(sku);
}
}
}
return(string.Empty);
}
private string CreateUrlSlug(string ulrSlug, HotcakesApplication hccApp)
{
// Try 10000 times to append to URL if in use
var rewriteUrlInUse = UrlRewriter.IsProductSlugInUse(ulrSlug, string.Empty, hccApp);
var baseRewriteUrl = ulrSlug;
for (var i = 2; i < 10000; i++)
{
if (rewriteUrlInUse)
{
ulrSlug = string.Concat(baseRewriteUrl, "-", i.ToString());
rewriteUrlInUse = UrlRewriter.IsProductSlugInUse(ulrSlug, string.Empty, hccApp);
if (!rewriteUrlInUse)
{
return(ulrSlug);
}
}
}
return(string.Empty);
}
public override string FriendlyDescription(HotcakesApplication app)
{
var result = "When Item Category Is ";
if (CategoryNot)
{
result += "Not ";
}
result += ":<ul>";
foreach (var bvin in CurrentCategoryIds())
{
var c = app.CatalogServices.Categories.Find(bvin);
if (c != null)
{
result += "<li>" + c.Name + "<br />";
result += "<em>" + c.RewriteUrl + "</em></li>";
}
}
result += "</ul>";
return(result);
}
public override string FriendlyDescription(HotcakesApplication app)
{
var allTypes = app.CatalogServices.ProductTypes.FindAll();
allTypes.Insert(0, new Catalog.ProductType {
Bvin = "0", ProductTypeName = "Generic"
});
var result = "When Product Type is" + (IsNotMode ? " not" : string.Empty) + " :<ul>";
foreach (var bvin in CurrentIds())
{
var p = allTypes.Where(y => y.Bvin == bvin).FirstOrDefault();
if (p != null)
{
result += "<li>" + p.ProductTypeName + "</li>";
}
}
result += "</ul>";
return(result);
}
public void UpdateGiftCardsStatus(Order o, bool enabled, HotcakesApplication app)
{
var payManager = new OrderPaymentManager(o, app);
foreach (var item in o.Items.Where(i => i.IsGiftCard))
{
var cards = app.CatalogServices.GiftCards.FindByLineItem(item.Id);
foreach (var card in cards)
{
if (enabled)
{
payManager.GiftCardActivate(card.CardNumber);
}
else
{
payManager.GiftCardDeactivate(card.CardNumber);
}
}
}
}
public static void MarkAllToBeShippedOrdersAsComplete(HotcakesApplication app)
{
var criteria = new OrderSearchCriteria();
criteria.IsPlaced = true;
criteria.StatusCode = OrderStatusCode.ReadyForShipping;
var pageSize = 1000;
var totalCount = 0;
var orders = app.OrderServices.Orders.FindByCriteriaPaged(criteria, 1, pageSize, ref totalCount);
if (orders != null)
{
foreach (var os in orders)
{
var o = app.OrderServices.Orders.FindForCurrentStore(os.bvin);
o.MoveToNextStatus();
app.OrderServices.Orders.Update(o);
}
}
}
// Mailing List Send Functions
public void SendToList(HtmlTemplate t, bool sendAsync, HotcakesApplication app)
{
if (t == null)
{
return;
}
foreach (var m in Members)
{
try
{
var copy = t.ReplaceTagsInTemplate(app.CurrentRequestContext, m);
var msg = copy.ConvertToMailMessage(m.EmailAddress);
MailServices.SendMail(msg, app.CurrentStore);
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
}
}
public void LoadPaymentInfo(HotcakesApplication app)
{
var o = app.OrderServices.Orders.FindForCurrentStore(_li.OrderBvin);
var payMan = new OrderPaymentManager(o, app);
var payments = payMan.RecurringPaymentsGetByLineItem(_li.Id);
TotalPayed = payments.Sum(t => t.Amount);
var paymentsCount = payments.Count;
StartsOn = o.TimeOfOrderUtc;
if (IntervalType == RecurringIntervalType.Days)
{
NextPaymentDate = StartsOn.AddDays(Interval * paymentsCount);
}
else if (IntervalType == RecurringIntervalType.Months)
{
NextPaymentDate = StartsOn.AddMonths(Interval * paymentsCount);
}
}
public override string FriendlyDescription(HotcakesApplication app)
{
var result = string.Empty;
var products = GetQuantities();
result = "Receive Free Product<ul>";
foreach (var bvin in products.Keys)
{
var p = app.CatalogServices.Products.FindWithCache(bvin);
if (p != null)
{
result += string.Format("<li>[{0}]{1} ({2})</li>", p.Sku, p.ProductName, products[bvin]);
}
}
result += "</ul>";
return(result);
}
public bool Refund(Transaction t, HotcakesApplication app)
{
try
{
var ppAPI = PaypalExpressUtilities.GetPaypalAPI(app.CurrentStore);
if (t.PreviousTransactionNumber != null)
{
var refundType = string.Empty;
//per paypal's request, the refund type should always be set to partial
refundType = "Partial";
var refundResponse = ppAPI.RefundTransaction(
t.PreviousTransactionNumber,
refundType,
t.Amount.ToString("N", CultureInfo.InvariantCulture),
PayPalAPI.GetCurrencyCodeType(app.CurrentStore.Settings.PayPal.Currency));
if (refundResponse.Ack == AckCodeType.Success ||
refundResponse.Ack == AckCodeType.SuccessWithWarning)
{
t.Result.Succeeded = true;
t.Result.Messages.Add(new Message("PayPal Express Payment Refunded Successfully.", "OK",
MessageType.Information));
return(true);
}
t.Result.Succeeded = false;
t.Result.Messages.Add(new Message("Paypal Express Payment Refund Failed.", string.Empty,
MessageType.Error));
foreach (var ppError in refundResponse.Errors)
{
t.Result.Messages.Add(new Message(ppError.LongMessage, ppError.ErrorCode, MessageType.Error));
}
return(false);
}
}
catch (Exception ex)
{
HandleException(t, ex);
}
return(false);
}
protected override object HandleAction(HttpRequest request, HotcakesApplication hccApp)
{
if (request.RequestContext.HttpContext.User.Identity.IsAuthenticated == false)
{
// not found
request.RequestContext.HttpContext.Response.StatusCode = 404;
request.RequestContext.HttpContext.Response.End();
return(null);
}
var method = request.Params["method"];
switch (method)
{
case "Slugify":
return(Slugify(request, hccApp));
case "ResortAdditionalImages":
return(ResortAdditionalImages(request, hccApp));
case "ResortRelatedProducts":
return(ResortRelatedProducts(request, hccApp));
case "ResortBundledProducts":
return(ResortBundledProducts(request, hccApp));
case "ResortProductPropertyChoices":
return(ResortProductPropertyChoices(request, hccApp));
case "ResortProductProperties":
return(ResortProductProperties(request, hccApp));
case "ResortChoiceItems":
return(ResortChoiceItems(request, hccApp));
default:
break;
}
return(true);
}
public bool OrdersDelete(string orderBvin, HotcakesApplication app)
{
var o = Orders.FindForCurrentStore(orderBvin);
if (o == null)
{
return(true);
}
var currentProvider = TaxProviders.CurrentTaxProvider(app.CurrentStore);
if (currentProvider != null)
{
currentProvider.CancelTaxDocument(o, app.CurrentRequestContext);
}
// Disables all giftcards associated with order
UpdateGiftCardsStatus(o, false, app);
return(Orders.Delete(o.bvin));
}
protected override object HandleAction(HttpContext context, HotcakesApplication hccApp)
{
if (context.User.Identity.IsAuthenticated == false)
{
// not found
context.Response.StatusCode = 404;
context.Response.End();
return(null);
}
var method = context.Request.Params["method"];
switch (method)
{
case "GetImportProgress":
return(GetImportProgress(context, hccApp));
default:
break;
}
return(true);
}
public void Register301(string requestedUrl, string redirectUrl, string objectId, CustomUrlType customUrlType,
HccRequestContext context, HotcakesApplication app)
{
var AlreadyInUse = UrlRewriter.IsUrlInUse(requestedUrl, string.Empty, context, app);
if (AlreadyInUse)
{
return;
}
var customUrl = new CustomUrl
{
IsPermanentRedirect = true,
RedirectToUrl = redirectUrl,
RequestedUrl = requestedUrl,
StoreId = app.CurrentRequestContext.CurrentStore.Id,
SystemData = objectId,
SystemDataType = customUrlType
};
Create(customUrl);
UpdateAllUrlsForObject(objectId, redirectUrl);
}
protected override object HandleAction(HttpRequest request, HotcakesApplication hccApp)
{
if (request.RequestContext.HttpContext.User.Identity.IsAuthenticated == false)
{
// not found
request.RequestContext.HttpContext.Response.StatusCode = 404;
request.RequestContext.HttpContext.Response.End();
return(null);
}
var method = request.Params["method"];
switch (method)
{
case "ResortPromotions":
return(ResortPromotions(request, hccApp));
default:
break;
}
return(true);
}
public static void CollectPaymentAndShipPendingOrders(HotcakesApplication app)
{
var criteria = new OrderSearchCriteria();
criteria.IsPlaced = true;
criteria.StatusCode = OrderStatusCode.ReadyForPayment;
var pageSize = 1000;
var totalCount = 0;
var orders = app.OrderServices.Orders.FindByCriteriaPaged(criteria, 1, pageSize, ref totalCount);
if (orders != null)
{
foreach (var os in orders)
{
var o = app.OrderServices.Orders.FindForCurrentStore(os.bvin);
var payManager = new OrderPaymentManager(o, app);
payManager.GiftCardCompleteAllGiftCards();
payManager.CreditCardCompleteAllCreditCards();
payManager.PayPalExpressCompleteAllPayments();
if (o.PaymentStatus == OrderPaymentStatus.Paid ||
o.PaymentStatus == OrderPaymentStatus.Overpaid)
{
if (o.ShippingStatus == OrderShippingStatus.FullyShipped)
{
o.StatusCode = OrderStatusCode.Completed;
o.StatusName = "Completed";
}
else
{
o.StatusCode = OrderStatusCode.ReadyForShipping;
o.StatusName = "Ready for Shipping";
}
app.OrderServices.Orders.Update(o);
}
}
}
}
