/// <summary>
/// Prepare list of used images
/// Many be associated with products, as thumbnail, icon, or std. images
/// or as additional images
/// or to option swathces
/// </summary>
private void InitAssociatedImageUrls()
{
associatedImages = new List <string>();
// ADD PRODUCT IMAGES
ICriteria criteria = NHibernateHelper.CreateCriteria <Product>();
criteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
IList <Product> products = ProductDataSource.LoadForCriteria(criteria);
foreach (Product product in products)
{
if (product.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ImageUrl);
}
if (product.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ThumbnailUrl);
}
if (product.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.IconUrl);
}
}
// ADDITIONAL IMAGES
ICriteria imageCriteria = NHibernateHelper.CreateCriteria <ProductImage>();
imageCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <ProductImage> images = ProductImageDataSource.LoadForCriteria(imageCriteria);
foreach (ProductImage image in images)
{
associatedImages.Add(image.ImageUrl);
}
// OPTION SWATCHES
ICriteria choicesCriteria = NHibernateHelper.CreateCriteria <OptionChoice>();
choicesCriteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%")));
IList <OptionChoice> choices = OptionChoiceDataSource.LoadForCriteria(choicesCriteria);
foreach (OptionChoice choice in choices)
{
if (choice.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ImageUrl);
}
if (choice.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ThumbnailUrl);
}
}
// ADD CATEGORY IMAGES
ICriteria categoryCriteria = NHibernateHelper.CreateCriteria <Category>();
categoryCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
categoryCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Category> categories = CategoryDataSource.LoadForCriteria(categoryCriteria);
foreach (Category category in categories)
{
if (category.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(category.ThumbnailUrl);
}
}
// ADD LINK IMAGES
ICriteria linksCriteria = NHibernateHelper.CreateCriteria <Link>();
linksCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
linksCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Link> links = LinkDataSource.LoadForCriteria(linksCriteria);
foreach (Link link in links)
{
if (link.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(link.ThumbnailUrl);
}
}
// ADD GIFT WRAPING IMAGES
ICriteria wrapstylesCriteria = NHibernateHelper.CreateCriteria <WrapStyle>();
wrapstylesCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <WrapStyle> wrapStyles = WrapStyleDataSource.LoadForCriteria(wrapstylesCriteria);
foreach (WrapStyle ws in wrapStyles)
{
if (ws.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ImageUrl);
}
if (ws.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ThumbnailUrl);
}
}
// ADD VARIANT IMAGES
ICriteria variantsCriteria = NHibernateHelper.CreateCriteria <ProductVariant>();
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
int variantsCount = ProductVariantDataSource.CountForCriteria(variantsCriteria.Clone() as ICriteria);
int maxVariantsToCache = 500;
// avoid loading all variants at same time
for (int index = 0; index < variantsCount; index += maxVariantsToCache)
{
variantsCriteria.SetMaxResults(maxVariantsToCache);
variantsCriteria.SetFirstResult(index);
IList <ProductVariant> productVariants = ProductVariantDataSource.LoadForCriteria(variantsCriteria);
foreach (ProductVariant productVariant in productVariants)
{
if (productVariant.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ImageUrl);
}
if (productVariant.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ThumbnailUrl);
}
if (productVariant.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.IconUrl);
}
}
}
}
/// <summary>
/// Creates the google feed
/// </summary>
/// <param name="feedFile">The feed file to generate</param>
/// <param name="includeAllProducts">If true, product feed exclusion settings are ignored.</param>
/// <param name="defaultBrand">Default brand to use if one is not set for a prodcut</param>
/// <param name="defaultCategory">Default category to use if one is not set for a prodcut</param>
/// <returns>True if the generation succeeds, false otherwise.</returns>
private static bool CreateFeed(string feedFile, bool includeAllProducts, string defaultBrand, string defaultCategory)
{
// ensure the feed directory exists
FileInfo fi = new FileInfo(feedFile);
if (!fi.Directory.Exists)
{
try
{
fi.Directory.Create();
}
catch (Exception ex)
{
Logger.Error("Error generating Google feed: ~\\Feeds directory does not exist and could not be created.", ex);
return(false);
}
}
// write the header row to the feed file
try
{
using (StreamWriter feedWriter = File.CreateText(feedFile))
{
feedWriter.Write(GetHeaderRow());
feedWriter.Close();
}
}
catch (Exception ex)
{
Logger.Error("Error generating Google feed.", ex);
return(false);
}
try
{
ISession session = AbleContext.Current.Database.GetSession();
using (StreamWriter feedWriter = File.AppendText(feedFile))
{
IList <Product> products;
ICriteria countCriteria = NHibernateHelper.CreateCriteria <Product>()
.Add(Restrictions.Not(Restrictions.Eq("VisibilityId", (byte)CatalogVisibility.Private)));
if (!includeAllProducts)
{
countCriteria.Add(Restrictions.Eq("ExcludeFromFeed", false));
}
int count = countCriteria.SetProjection(Projections.RowCount())
.UniqueResult <int>();
int startIndex = 0;
while (startIndex < count)
{
// DETERMINE HOW MANY ROWS LEFT TO INCLUDE IN FEED
int rowsRemaining = count - startIndex;
// ONLY PROCESS 1000 ROWS AT A TIME
int maxRows = (rowsRemaining > 1000) ? 1000 : rowsRemaining;
// GET THE ROWS TO BE OUTPUT
ICriteria productCriteria = NHibernateHelper.CreateCriteria <Product>(maxRows, startIndex, string.Empty)
.Add(Restrictions.Not(Restrictions.Eq("VisibilityId", (byte)CatalogVisibility.Private)));
if (!includeAllProducts)
{
productCriteria.Add(Restrictions.Eq("ExcludeFromFeed", false));
}
products = productCriteria.List <Product>();
// GENERATE THE FEED DATA
string feedData = GetFeedData(products, defaultBrand, defaultCategory);
// WRITE DATA TO THE FEED FILE
feedWriter.Write(feedData);
feedWriter.Flush();
// REMOVE PRODUCTS FROM SESSION TO CONSERVE MEMORY
foreach (var product in products)
{
session.Evict(product);
}
// LOOP TO THE NEXT BLOCK OF DATA
startIndex += 1000;
}
// CLOSE THE FEED FILE
feedWriter.Close();
}
}
catch (Exception ex)
{
Logger.Error("Error generating Google feed.", ex);
return(false);
}
return(true);
}
