protected string GetMoveUrl(object dataItem, object dataItemId)
{
CatalogNodeType nodeType = (CatalogNodeType)dataItem;
int catalogNodeId = (int)dataItemId;
string url = "~/Admin/Catalog/MoveCatalogObjects.aspx";
url = Page.ResolveUrl(url);
switch (nodeType)
{
case CatalogNodeType.Category:
url += "?CategoryId=" + this.CurrentCategoryId.ToString() + string.Format("&Objects={0}:{1}", catalogNodeId, (byte)CatalogNodeType.Category);
break;
case CatalogNodeType.Product:
url += "?CategoryId=" + this.CurrentCategoryId.ToString() + string.Format("&Objects={0}:{1}", catalogNodeId, (byte)CatalogNodeType.Product);
break;
case CatalogNodeType.Webpage:
url += "?CategoryId=" + this.CurrentCategoryId.ToString() + string.Format("&Objects={0}:{1}", catalogNodeId, (byte)CatalogNodeType.Webpage);
break;
case CatalogNodeType.Link:
url += "?CategoryId=" + this.CurrentCategoryId.ToString() + string.Format("&Objects={0}:{1}", catalogNodeId, (byte)CatalogNodeType.Link);
break;
default:
url = "~/Admin/Catalog/Browse.aspx";
break;
}
return(url);
}
/// <summary>
/// Parses the display page comment header.
/// </summary>
/// <param name="filePath">The full path to the file to parse.</param>
/// <param name="virtualPath">The virtual path of the file to register with the DisplayPage instance.</param>
/// <returns>If the display page comment header is found, returns the DisplayPage instance. Returns null if the comment header is not found or the file does not exist.</returns>
public static DisplayPage ParseFromFile(string filePath, string virtualFilePath)
{
DisplayPage displayPage = null;
if (File.Exists(filePath))
{
try
{
string fileContent = File.ReadAllText(filePath);
Match headerMatch = Regex.Match(fileContent, "<DisplayPage>[^\x00]*?</DisplayPage>");
if (headerMatch.Success)
{
XmlDocument header = new XmlDocument();
header.LoadXml(headerMatch.Value);
string name = XmlUtility.GetElementValue(header.DocumentElement, "Name");
CatalogNodeType nodeType = (CatalogNodeType)Enum.Parse(typeof(CatalogNodeType), XmlUtility.GetElementValue(header.DocumentElement, "NodeType"));
string description = XmlUtility.GetElementValue(header.DocumentElement, "Description");
displayPage = new DisplayPage(virtualFilePath, name, nodeType, description);
}
}
catch (Exception ex)
{
displayPage = null;
Logger.Warn("Error while parsing file '" + filePath + "' for display page. ", ex);
}
}
return(displayPage);
}
protected string GetEditUrl(object dataItem, object dataItemId)
{
CatalogNodeType nodeType = (CatalogNodeType)dataItem;
int catalogNodeId = (int)dataItemId;
string url;
switch (nodeType)
{
case CatalogNodeType.Category:
url = "~/Admin/Catalog/EditCategory.aspx?CategoryId=" + catalogNodeId.ToString();
break;
case CatalogNodeType.Product:
url = "~/Admin/products/EditProduct.aspx?ProductId=" + catalogNodeId.ToString() + "&CategoryId=" + this.CurrentCategoryId.ToString();
break;
case CatalogNodeType.Webpage:
url = "~/Admin/Catalog/EditWebpage.aspx?WebpageId=" + catalogNodeId.ToString() + "&CategoryId=" + this.CurrentCategoryId.ToString();
break;
case CatalogNodeType.Link:
url = "~/Admin/Catalog/EditLink.aspx?LinkId=" + catalogNodeId.ToString() + "&CategoryId=" + this.CurrentCategoryId.ToString();
break;
default:
url = "~/Admin/Catalog/Browse.aspx";
break;
}
return(Page.ResolveUrl(url));
}
public DisplayPage(string displayPageFile, string name, CatalogNodeType nodeType, string description)
{
_DisplayPageFile = displayPageFile;
_Name = name;
_NodeType = nodeType;
_Description = description;
}
/// <summary>
/// Registers the catalog node that is primarily associated with this request
/// </summary>
/// <param name="nodeId">ID of the catalog node</param>
/// <param name="nodeType">Type of the catalog node</param>
/// <remarks>This is intended for use with page tracking</remarks>
public static void RegisterCatalogNode(int nodeId, CatalogNodeType nodeType)
{
HttpContext context = HttpContext.Current;
context.Items["PageTracking_CatalogNodeId"] = nodeId;
context.Items["PageTracking_CatalogNodeTypeId"] = (Int16)nodeType;
}
private static List <int> GetNonOrphanedCustomUrlIds(CatalogNodeType catalogNodeType)
{
StringBuilder sb = new StringBuilder();
sb.Append(" SELECT CU.CustomUrlId ");
sb.Append(" FROM ac_CustomUrls AS CU ");
switch (catalogNodeType)
{
case CatalogNodeType.Product:
sb.Append(" JOIN ac_Products AS P ON CU.CatalogNodeId = P.ProductId ");
break;
case CatalogNodeType.Category:
sb.Append(" JOIN ac_Categories AS C ON CU.CatalogNodeId = C.CategoryId ");
break;
case CatalogNodeType.Webpage:
sb.Append(" JOIN ac_Webpages AS WP ON CU.CatalogNodeId = WP.WebpageId ");
break;
case CatalogNodeType.Link:
sb.Append(" JOIN ac_Links AS L ON CU.CatalogNodeId = L.LinkId ");
break;
}
sb.Append(string.Format("WHERE CU.StoreId= {0} AND CatalogNodeTypeId = {1} ", Token.Instance.StoreId, (byte)catalogNodeType));
return(GetIdList(sb.ToString()));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="nodeId">Id of the node</param>
/// <param name="nodeType">node type</param>
/// <param name="url">Url of the node</param>
/// <param name="title">Node title</param>
/// <param name="description">Description of the node</param>
public CmsPathNode(int nodeId, CatalogNodeType nodeType, string url, string title, string description)
{
this._NodeId = nodeId;
this._NodeType = nodeType;
this._Url = url;
this._Title = title;
this._Description = description;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="categoryId">Category Id of this catalog node</param>
/// <param name="catalogNodeId">Catalog node Id of this catalog node</param>
/// <param name="catalogNodeType">Type of this catalog node</param>
/// <param name="orderBy">The value of OrderBy field</param>
/// <param name="isDirty">Does this catalog node need to be saved to database or not</param>
public CatalogNode(int categoryId, int catalogNodeId, CatalogNodeType catalogNodeType, Int16 orderBy, bool isDirty)
: base()
{
this.CategoryId = categoryId;
this.CatalogNodeId = catalogNodeId;
this.CatalogNodeType = catalogNodeType;
this.OrderBy = orderBy;
this.IsDirty = isDirty;
}
protected string GetPreviewUrl(object dataItem, object dataItemId, object dataItemName)
{
CatalogNodeType nodeType = (CatalogNodeType)dataItem;
int catalogNodeId = (int)dataItemId;
string nodeName = (string)dataItemName;
string url = UrlGenerator.GetBrowseUrl(catalogNodeId, nodeType, nodeName);
return(Page.ResolveUrl(url));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="categoryId">Category Id of this catalog node</param>
/// <param name="catalogNodeId">Catalog node Id of this catalog node</param>
/// <param name="catalogNodeType">Type of this catalog node</param>
/// <param name="orderBy">The value of OrderBy field</param>
/// <param name="isDirty">Does this catalog node need to be saved to database or not</param>
/// <param name="visibility">The visibility of this catalog node</param>
/// <param name="name">The name of this catalog node</param>
/// <param name="summary">The summary field of this catalog node</param>
/// <param name="thumbnailUrl">The thumbnail url of this catalog node</param>
/// <param name="thumbnailAltText">The alt text for the thumbnail of this catalog node</param>
public CatalogNode(int categoryId, int catalogNodeId, CatalogNodeType catalogNodeType, Int16 orderBy, bool isDirty, CatalogVisibility visibility, string name, string summary, string thumbnailUrl, string thumbnailAltText)
: this(categoryId, catalogNodeId, catalogNodeType, orderBy, isDirty)
{
this.Visibility = visibility;
this.Name = name;
this.Summary = summary;
this.ThumbnailUrl = thumbnailUrl;
this.ThumbnailAltText = thumbnailAltText;
this.m_ICatalogableInitialized = true;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="categoryId">Category Id for this path node</param>
/// <param name="catalogNodeId">CatalogNode Id for this path node</param>
/// <param name="catalogNodeType">CatalogNode type for this path node</param>
/// <param name="visibility">Visibility setting for this path node</param>
/// <param name="name">Name of this path node</param>
/// <param name="summary">Summary of this path node</param>
/// <param name="thumbnailUrl">Thumbnail URL for this path node</param>
/// <param name="thumbnailAltText">Alternate text for the thumbnail for this path node</param>
/// <param name="theme">The theme applied to this path node</param>
public CatalogPathNode(int categoryId, int catalogNodeId, CatalogNodeType catalogNodeType, CatalogVisibility visibility, string name, string summary, string thumbnailUrl, string thumbnailAltText, string theme)
{
this.CategoryId = categoryId;
this.CatalogNodeId = catalogNodeId;
this.CatalogNodeType = catalogNodeType;
this.Visibility = visibility;
this.Name = name;
this.Summary = summary;
this.ThumbnailUrl = thumbnailUrl;
this.ThumbnailAltText = thumbnailAltText;
this.Theme = theme;
}
public static void FindCatalogable(out ICatalogable catalogable, out CatalogNodeType catalogableType)
{
HttpContext context = HttpContext.Current;
if (context != null)
{
//CHECK FOR LINK
int linkId = AbleCommerce.Code.PageHelper.GetLinkId();
Link link = LinkDataSource.Load(linkId);
if (link != null)
{
catalogable = link;
catalogableType = CatalogNodeType.Link;
return;
}
//CHECK FOR WEBPAGE
int webpageId = AbleCommerce.Code.PageHelper.GetWebpageId();
Webpage webpage = WebpageDataSource.Load(webpageId);
if (webpage != null)
{
catalogable = webpage;
catalogableType = CatalogNodeType.Webpage;
return;
}
//CHECK FOR PRODUCT
int productId = AbleCommerce.Code.PageHelper.GetProductId();
Product product = ProductDataSource.Load(productId);
if (product != null)
{
catalogable = product;
catalogableType = CatalogNodeType.Product;
return;
}
//CHECK FOR CATEGORY
int categoryId = AlwaysConvert.ToInt(context.Request.QueryString["CategoryId"]);
Category category = CategoryDataSource.Load(categoryId);
if (category != null)
{
catalogable = category;
catalogableType = CatalogNodeType.Category;
return;
}
}
catalogable = null;
catalogableType = CatalogNodeType.Category;
return;
}
/// <summary>
/// Registers the catalog page visit
/// </summary>
/// <param name="nodeId">ID of the catalog node</param>
/// <param name="nodeType">Type of the catalog node</param>
/// <param name="pageTitle">Title of the page</param>
/// <remarks>This is intended for use with page tracking</remarks>
public static void RegisterPageVisit(int nodeId, CatalogNodeType nodeType, string pageTitle)
{
//REGISTER THE PAGEVIEW FOR PERSISTENT PAGE TRACKING
CommerceBuilder.Reporting.PageView.RegisterCatalogNode(nodeId, nodeType);
HttpContext context = HttpContext.Current;
string uriStem = context.Request.Url.AbsolutePath;
string uriQuery = context.Request.Url.Query.TrimStart("?".ToCharArray());
// CHECK IF ITS ALREADY IN LIST
IList <PageVisit> pageVisits = GetUserPageVisits();
PageVisit pageVisit = pageVisits.FirstOrDefault(p => (p.UriStem == uriStem && p.UriQuery == uriQuery));
if (pageVisit != null)
{
pageVisit.ActivityDate = LocaleHelper.LocalNow;
pageVisit.VisitCount++;
pageVisits.Sort();
}
else
{
// ADD THE NEW PAGE VISIT
pageVisit = new PageVisit();
pageVisit.ActivityDate = LocaleHelper.LocalNow;
pageVisit.CatalogNodeId = nodeId;
pageVisit.CatalogNodeType = nodeType;
pageVisit.PageTitle = pageTitle;
pageVisit.UriStem = uriStem;
pageVisit.UriQuery = uriQuery;
pageVisit.VisitCount = 1;
pageVisits.Sort();
// ADD IT TO COLLECTION
pageVisits.Add(pageVisit);
// ENSURE MAXIMUM SIZE, REMOVE FROM END IF IT EXCEEDS THE SIZE
if (pageVisits.Count > _cacheSize)
{
for (int i = _cacheSize; i < pageVisits.Count; i++)
{
pageVisits.RemoveAt(i);
}
}
}
}
protected string GetCatalogIconUrl(object dataItem)
{
CatalogNodeType nodeType = ((CustomUrl)dataItem).CatalogNodeType;
switch (nodeType)
{
case CatalogNodeType.Category:
return(_IconPath + "Category.gif");
case CatalogNodeType.Product:
return(_IconPath + "Product.gif");
case CatalogNodeType.Webpage:
return(_IconPath + "Webpage.gif");
case CatalogNodeType.Link:
return(_IconPath + "Link.gif");
}
return(string.Empty);
}
protected CatalogNode CreateSubNode(CatalogNodeType type, string nodePath, string nodeName, bool hasSubNodes)
{
switch (type)
{
case CatalogNodeType.DocTypeSynonymGroup:
return(new DocTypeSynonymGroupNode(nodePath, nodeName, hasSubNodes));
case CatalogNodeType.DocType:
return(new DocTypeNode(nodePath, nodeName, hasSubNodes));
case CatalogNodeType.Company:
return(new CompanyNode(nodePath, nodeName, hasSubNodes));
case CatalogNodeType.Person:
return(new PersonNode(nodePath, nodeName, hasSubNodes));
case CatalogNodeType.NoPerson:
return(new NoPersonNode(nodePath, nodeName, hasSubNodes));
}
return(null);
}
private bool MatchTypes(CatalogNodeType catalogNodeType, ICatalogable catalogItem)
{
Type catalogItemType = catalogItem.GetType();
if (catalogItemType == typeof(Category) && catalogNodeType == CatalogNodeType.Category)
{
return(true);
}
else if (catalogItemType == typeof(Product) && catalogNodeType == CatalogNodeType.Product)
{
return(true);
}
else if (catalogItemType == typeof(Webpage) && catalogNodeType == CatalogNodeType.Webpage)
{
return(true);
}
else if (catalogItemType == typeof(Link) && catalogNodeType == CatalogNodeType.Link)
{
return(true);
}
return(false);
}
protected void DoDelete(CatalogNodeType catalogNodeType, int catalogNodeId)
{
switch (catalogNodeType)
{
case CatalogNodeType.Category:
Category category = CategoryDataSource.Load(catalogNodeId);
if (category != null)
{
category.Delete();
}
break;
case CatalogNodeType.Product:
Product product = ProductDataSource.Load(catalogNodeId);
if (product != null)
{
product.Delete();
}
break;
case CatalogNodeType.Webpage:
Webpage webpage = WebpageDataSource.Load(catalogNodeId);
if ((webpage != null) && (webpage.Categories.Count < 2))
{
webpage.Delete();
}
break;
case CatalogNodeType.Link:
Link link = LinkDataSource.Load(catalogNodeId);
if ((link != null) && (link.Categories.Count < 2))
{
link.Delete();
}
break;
}
CGrid.DataBind();
}
/// <summary>
/// Gets a browsing URL for the given node
/// </summary>
/// <param name="categoryId">The category to which the node belongs</param>
/// <param name="nodeId">The Id of the node for which to get the browse URL</param>
/// <param name="nodeType">The type of node</param>
/// <param name="name">The name to use in the link</param>
/// <returns>A browsing URL for the given node</returns>
public string GetBrowseUrl(int categoryId, int nodeId, CatalogNodeType nodeType, string name)
{
switch (nodeType)
{
case CatalogNodeType.Category:
return(string.Format("~/{1}-C{0}.aspx", nodeId, SanitizeName(name)));
case CatalogNodeType.Product:
return(string.Format("~/{1}-P{0}C{2}.aspx", nodeId, SanitizeName(name), categoryId));
case CatalogNodeType.Webpage:
return(string.Format("~/{1}-W{0}C{2}.aspx", nodeId, SanitizeName(name), categoryId));
case CatalogNodeType.Link:
Link link = LinkDataSource.Load(nodeId);
if (link.DisplayPage.Length == 0)
{
return(link.TargetUrl);
}
return(string.Format("~/{1}-L{0}C{2}.aspx", nodeId, SanitizeName(name), categoryId));
}
return(String.Empty);
}
protected void DoDelete(CatalogNodeType catalogNodeType, int catalogNodeId)
{
switch (catalogNodeType)
{
case CatalogNodeType.Category:
Category category = CategoryDataSource.Load(catalogNodeId);
if (category != null)
{
category.Delete();
}
break;
case CatalogNodeType.Product:
Product product = ProductDataSource.Load(catalogNodeId);
if (product != null)
{
if (product.Categories.Count > 1)
{
product.Categories.Remove(CurrentCategory.Id);
product.Categories.Save();
}
else
{
product.Delete();
}
}
break;
case CatalogNodeType.Webpage:
Webpage webpage = WebpageDataSource.Load(catalogNodeId);
if (webpage != null)
{
if (webpage.Categories.Count > 1)
{
webpage.Categories.Remove(CurrentCategory.Id);
webpage.Categories.Save();
}
else
{
webpage.Delete();
}
}
break;
case CatalogNodeType.Link:
Link link = LinkDataSource.Load(catalogNodeId);
if (link != null)
{
if (link.Categories.Count > 1)
{
link.Categories.Remove(CurrentCategory.Id);
link.Categories.Save();
}
else
{
link.Delete();
}
}
break;
}
}
protected void CGrid_DataBound(object sender, EventArgs e)
{
List <string> categories = new List <string>();
List <string> products = new List <string>();
List <string> links = new List <string>();
List <string> webpages = new List <string>();
for (int i = 0; i < CGrid.Rows.Count; i++)
{
GridViewRow gvr = CGrid.Rows[i];
CheckBox cb = (CheckBox)gvr.FindControl("Selected");
DataKey dataKey = ((GridView)sender).DataKeys[gvr.DataItemIndex];
int catalogNodeId = (int)dataKey.Values[0];
CatalogNodeType catalogNodeType = (CatalogNodeType)dataKey.Values[1];
switch (catalogNodeType)
{
case CatalogNodeType.Category:
categories.Add(cb.ClientID);
break;
case CatalogNodeType.Product:
products.Add(cb.ClientID);
break;
case CatalogNodeType.Link:
links.Add(cb.ClientID);
break;
case CatalogNodeType.Webpage:
webpages.Add(cb.ClientID);
break;
}
}
if (categories.Count > 0)
{
string catsArray = "new Array('" + String.Join("','", categories.ToArray()) + "')";
SelectCategories.OnClientClick = "selectCatalogItems(" + catsArray + ");return false;";
}
else
{
SelectCategories.OnClientClick = "return false;";
}
if (products.Count > 0)
{
string productsArray = "new Array('" + String.Join("','", products.ToArray()) + "')";
SelectProducts.OnClientClick = "selectCatalogItems(" + productsArray + ");return false;";
}
else
{
SelectProducts.OnClientClick = "return false;";
}
if (links.Count > 0)
{
string linksArray = "new Array('" + String.Join("','", links.ToArray()) + "')";
SelectLinks.OnClientClick = "selectCatalogItems(" + linksArray + ");return false;";
}
else
{
SelectLinks.OnClientClick = "return false;";
}
if (webpages.Count > 0)
{
string catsArray = "new Array('" + String.Join("','", webpages.ToArray()) + "')";
SelectWebpages.OnClientClick = "selectCatalogItems(" + catsArray + ");return false;";
}
else
{
SelectWebpages.OnClientClick = "return false;";
}
}
protected void CGrid_RowCommand(object sender, System.Web.UI.WebControls.GridViewCommandEventArgs e)
{
if (e.CommandName.StartsWith("Do_"))
{
string[] args = e.CommandArgument.ToString().Split("|".ToCharArray());
CatalogNodeType catalogNodeType = (CatalogNodeType)AlwaysConvert.ToInt(args[0]);
int catalogNodeId = AlwaysConvert.ToInt(args[1]);
switch (e.CommandName)
{
case "Do_Open":
//IF CATEGORY, REBIND CURRENT PAGE,
//OTHERWISE REDIRECT TO CORRECT EDIT PAGE
switch (catalogNodeType)
{
case CatalogNodeType.Category:
//REBIND CURRENT CATEGORY
CurrentCategoryId = catalogNodeId;
//RESET PAGE INDEX
CGrid.PageIndex = 0;
break;
case CatalogNodeType.Product:
Response.Redirect("~/Admin/Products/EditProduct.aspx?CategoryId=" + CurrentCategoryId.ToString() + "&ProductId=" + catalogNodeId.ToString());
break;
case CatalogNodeType.Webpage:
Response.Redirect("~/Admin/Catalog/EditWebpage.aspx?CategoryId=" + CurrentCategoryId.ToString() + "&WebpageId=" + catalogNodeId.ToString());
break;
case CatalogNodeType.Link:
Response.Redirect("~/Admin/Catalog/EditLink.aspx?CategoryId=" + CurrentCategoryId.ToString() + "&LinkId=" + catalogNodeId.ToString());
break;
}
break;
case "Do_Copy":
// THIS WILL COPY THE PRODUCTS WITH THE ORIGNAL CATEGORY INFORMATION PRESERVED
CatalogDataSource.Copy(catalogNodeId, catalogNodeType, 0);
break;
case "Do_Delete":
DoDelete(catalogNodeType, catalogNodeId);
break;
case "Do_Pub":
ICatalogable pubNode = CatalogDataSource.Load(catalogNodeId, catalogNodeType);
if (pubNode != null)
{
//FOR CATEGORIES, WE MUST FIND OUT MORE INFORMATION
if (pubNode is Category)
{
Response.Redirect("ChangeVisibility.aspx?CategoryId=" + ((Category)pubNode).ParentId.ToString() + String.Format("&Objects={0}:{1}", ((Category)pubNode).Id, (byte)(CatalogNodeType.Category)));
}
//FOR OTHER OBJECTS, WE CAN ADJUST
switch (pubNode.Visibility)
{
case CatalogVisibility.Public:
pubNode.Visibility = CatalogVisibility.Hidden;
break;
case CatalogVisibility.Hidden:
pubNode.Visibility = CatalogVisibility.Private;
break;
default:
pubNode.Visibility = CatalogVisibility.Public;
break;
}
if (pubNode is Product)
{
((Product)pubNode).Save();
}
else if (pubNode is Webpage)
{
((Webpage)pubNode).Save();
}
else if (pubNode is Link)
{
((Link)pubNode).Save();
}
}
break;
}
}
CGrid.DataBind();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="categoryId">The category Id of this node</param>
/// <param name="catalogNodeId">The catalog node id of this node</param>
/// <param name="catalogNodeType">The type of this catalog node</param>
/// <param name="orderBy">The value of OrderBy field</param>
/// <param name="isDirty">Does this node need to be saved to the database?</param>
/// <param name="visibility">The visibility setting of this node</param>
/// <param name="name">The name of this node</param>
/// <param name="summary">The summary field of this node</param>
/// <param name="thumbnailUrl">The thumbnail url of this node</param>
/// <param name="thumbnailAltText">The alt text for the thumbnail of this node</param>
/// <param name="price">The Price of the associated product</param>
public CatalogProductNode(int categoryId, int catalogNodeId, CatalogNodeType catalogNodeType, Int16 orderBy, bool isDirty, CatalogVisibility visibility, string name, string summary, string thumbnailUrl, string thumbnailAltText, LSDecimal price)
: base(categoryId, catalogNodeId, catalogNodeType, orderBy, isDirty, visibility, name, summary, thumbnailUrl, thumbnailAltText)
{
this.Price = price;
}
protected void InitializeCatalogItems()
{
String items = Request.QueryString["Objects"];
if (String.IsNullOrEmpty(items))
{
return;
}
String[] itemsArray = items.Split(',');
List <String> categoryIds = new List <String>();
List <String> productIds = new List <String>();
List <String> linkIds = new List <String>();
List <String> webpageIds = new List <String>();
// Sort out items in saperate lists
foreach (String item in itemsArray)
{
String[] itemValues = item.Split(':');
int catalogNodeId = AlwaysConvert.ToInt(itemValues[0]);
CatalogNodeType catalogNodeType = (CatalogNodeType)AlwaysConvert.ToByte(itemValues[1]);
switch (catalogNodeType)
{
case CatalogNodeType.Category:
categoryIds.Add(catalogNodeId.ToString());
break;
case CatalogNodeType.Product:
productIds.Add(catalogNodeId.ToString());
break;
case CatalogNodeType.Link:
linkIds.Add(catalogNodeId.ToString());
break;
case CatalogNodeType.Webpage:
webpageIds.Add(catalogNodeId.ToString());
break;
}
}
trIncludeContents.Visible = (categoryIds.Count > 0);
if (categoryIds.Count > 0)
{
ICriteria criteria = CommerceBuilder.DomainModel.NHibernateHelper.CreateCriteria <Category>();
criteria.Add(Restrictions.In("Id", categoryIds.ToArray()));
_Categories = CategoryDataSource.LoadForCriteria(criteria);
if (_Categories != null && _Categories.Count > 0)
{
foreach (Category category in _Categories)
{
_CatalogItems.Add(category);
}
}
}
if (productIds.Count > 0)
{
ICriteria criteria = CommerceBuilder.DomainModel.NHibernateHelper.CreateCriteria <Product>();
criteria.Add(Restrictions.In("Id", productIds.ToArray()));
_Products = ProductDataSource.LoadForCriteria(criteria);
if (_Products != null && _Products.Count > 0)
{
foreach (Product product in _Products)
{
_CatalogItems.Add(product);
}
}
}
if (linkIds.Count > 0)
{
ICriteria criteria = CommerceBuilder.DomainModel.NHibernateHelper.CreateCriteria <Link>();
criteria.Add(Restrictions.In("Id", linkIds.ToArray()));
_Links = LinkDataSource.LoadForCriteria(criteria);
if (_Links != null && _Links.Count > 0)
{
foreach (Link link in _Links)
{
_CatalogItems.Add(link);
}
}
}
if (webpageIds.Count > 0)
{
ICriteria criteria = CommerceBuilder.DomainModel.NHibernateHelper.CreateCriteria <Webpage>();
criteria.Add(Restrictions.In("Id", webpageIds.ToArray()));
_Webpages = WebpageDataSource.LoadForCriteria(criteria);
if (_Webpages != null && _Webpages.Count > 0)
{
foreach (Webpage webpage in _Webpages)
{
_CatalogItems.Add(webpage);
}
}
}
if (!Page.IsPostBack)
{
if (_CatalogItems.Count == 1)
{
ICatalogable catalogable = _CatalogItems[0];
switch (catalogable.Visibility)
{
case CatalogVisibility.Public:
VisPublic.Checked = true;
break;
case CatalogVisibility.Private:
VisPrivate.Checked = true;
break;
case CatalogVisibility.Hidden:
VisHidden.Checked = true;
break;
default:
VisPrivate.Checked = true;
break;
}
}
else if (_CatalogItems.Count > 1)
{
VisPrivate.Checked = false;
VisPublic.Checked = false;
VisHidden.Checked = false;
}
}
}
private static void DeleteOrphanedCustomUrls(List <int> nonOrphanedCustomUrlIds, CatalogNodeType catalogNodeType)
{
StringBuilder sb = new StringBuilder();
sb.Append(" DELETE FROM ac_CustomUrls WHERE StoreId= @storeId ");
sb.Append(" AND CatalogNodeTypeId=@catalogNodeType ");
if (nonOrphanedCustomUrlIds.Count > 0)
{
sb.Append(string.Format(" AND CustomUrlId NOT IN ({0}) ", string.Join(",", nonOrphanedCustomUrlIds.ConvertAll <string>(delegate(int i) { return(i.ToString()); }).ToArray())));
}
Database database = Token.Instance.Database;
DbCommand dbCommand = database.GetSqlStringCommand(sb.ToString());
database.AddInParameter(dbCommand, "@storeId", DbType.Int32, Token.Instance.StoreId);
database.AddInParameter(dbCommand, "@catalogNodeType", DbType.Byte, (byte)catalogNodeType);
database.ExecuteNonQuery(dbCommand);
}
protected void CGrid_RowCommand(object sender, System.Web.UI.WebControls.GridViewCommandEventArgs e)
{
if (e.CommandName.StartsWith("Do_"))
{
string[] args = e.CommandArgument.ToString().Split("|".ToCharArray());
CatalogNodeType catalogNodeType = (CatalogNodeType)AlwaysConvert.ToInt(args[0]);
int catalogNodeId = AlwaysConvert.ToInt(args[1]);
int index;
switch (e.CommandName)
{
case "Do_Copy":
CatalogDataSource.Copy(catalogNodeId, catalogNodeType, CurrentCategory.Id);
break;
case "Do_Delete":
DoDelete(catalogNodeType, catalogNodeId);
break;
case "Do_Up":
index = CurrentCategory.CatalogNodes.IndexOf(CurrentCategory.Id, catalogNodeId, (byte)catalogNodeType);
if (index > 0)
{
CatalogNode tempNode = CurrentCategory.CatalogNodes[index - 1];
CurrentCategory.CatalogNodes[index - 1] = CurrentCategory.CatalogNodes[index];
CurrentCategory.CatalogNodes[index] = tempNode;
short newOrderBy = 0;
foreach (CatalogNode node in CurrentCategory.CatalogNodes)
{
node.OrderBy = newOrderBy;
node.Save();
newOrderBy++;
}
// recalculate orderby for impacted child products
RecalculateOrderBy(CurrentCategory.CatalogNodes[index - 1]);
RecalculateOrderBy(CurrentCategory.CatalogNodes[index]);
}
break;
case "Do_Down":
index = CurrentCategory.CatalogNodes.IndexOf(CurrentCategory.Id, catalogNodeId, (byte)catalogNodeType);
if (index < CurrentCategory.CatalogNodes.Count - 1)
{
CatalogNode tempNode = CurrentCategory.CatalogNodes[index + 1];
CurrentCategory.CatalogNodes[index + 1] = CurrentCategory.CatalogNodes[index];
CurrentCategory.CatalogNodes[index] = tempNode;
short newOrderBy = 0;
foreach (CatalogNode node in CurrentCategory.CatalogNodes)
{
node.OrderBy = newOrderBy;
node.Save();
newOrderBy++;
}
// recalculate orderby for impacted child products
RecalculateOrderBy(CurrentCategory.CatalogNodes[index + 1]);
RecalculateOrderBy(CurrentCategory.CatalogNodes[index]);
}
break;
case "Do_Pub":
index = CurrentCategory.CatalogNodes.IndexOf(CurrentCategory.Id, catalogNodeId, (byte)catalogNodeType);
if (index > -1)
{
CatalogNode node = CurrentCategory.CatalogNodes[index];
//FOR CATEGORIES, WE MUST FIND OUT MORE INFORMATION
if (node.CatalogNodeType == CatalogNodeType.Category)
{
Response.Redirect("ChangeVisibility.aspx?CategoryId=" + CurrentCategory.Id.ToString() + String.Format("&Objects={0}:{1}", node.CatalogNodeId, (byte)node.CatalogNodeType));
}
//FOR OTHER OBJECTS, WE CAN ADJUST
switch (node.Visibility)
{
case CatalogVisibility.Public:
node.Visibility = CatalogVisibility.Hidden;
break;
case CatalogVisibility.Hidden:
node.Visibility = CatalogVisibility.Private;
break;
default:
node.Visibility = CatalogVisibility.Public;
break;
}
node.ChildObject.Visibility = node.Visibility;
node.Save(true);
}
break;
}
}
}
/// <summary>
/// Gets cms path for the given node. Only supported for Category type catalog node objects
/// </summary>
/// <param name="categoryId">Id of the category</param>
/// <param name="currentNodeId">Id of the node</param>
/// <param name="currentNodeType">Type of node</param>
/// <returns>List of cms path nodes</returns>
public static List <CmsPathNode> GetCmsPath(int categoryId, int currentNodeId, CatalogNodeType currentNodeType)
{
List <CmsPathNode> path = new List <CmsPathNode>();
Database database = Token.Instance.Database;
StringBuilder selectQuery = new StringBuilder();
switch (currentNodeType)
{
case CatalogNodeType.Category:
selectQuery.Append("SELECT CP.ParentId AS NodeId, 0 As NodeType, C.Name, C.Summary, CP.ParentLevel, CP.ParentNumber");
selectQuery.Append(" FROM ac_CategoryParents AS CP INNER JOIN");
selectQuery.Append(" ac_Categories C ON CP.ParentId = C.CategoryId");
selectQuery.Append(" WHERE CP.CategoryId = @currentNodeId");
selectQuery.Append(" ORDER BY CP.ParentLevel");
break;
default:
throw new Exception("Not supported.");
}
DbCommand selectCommand = database.GetSqlStringCommand(selectQuery.ToString());
database.AddInParameter(selectCommand, "@currentNodeId", DbType.Int32, currentNodeId);
//EXECUTE THE COMMAND
using (IDataReader dr = database.ExecuteReader(selectCommand))
{
int nodeId;
CatalogNodeType nodeType;
String url;
String title;
String description;
while (dr.Read())
{
nodeId = dr.GetInt32(0);
nodeType = (CatalogNodeType)dr.GetInt32(1);
switch (nodeType)
{
case CatalogNodeType.Category:
url = "~/Admin/Catalog/Browse.aspx?CategoryId=" + nodeId.ToString();
break;
default:
url = string.Empty;
break;
}
title = dr.GetString(2);
description = NullableData.GetString(dr, 3);
path.Add(new CmsPathNode(nodeId, nodeType, url, title, description));
}
dr.Close();
}
if (path.Count == 0)
{
return(null);
}
return(path);
}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}