private Guid GetMerchantId(string merchant)
{
CatalogEntryDto merchants = CatalogContext.Current.GetMerchantsDto();
if (merchants.Merchant != null)
{
DataRow[] drws = null;
Guid merchantId = new Guid();
try
{
merchantId = new Guid(merchant);
}
catch {}
if (merchantId != Guid.Empty)
{
drws = merchants.Merchant.Select(String.Format("MerchantId = '{0}'", merchantId));
if (drws.Length > 0)
{
return(merchantId);
}
}
else
{
drws = merchants.Merchant.Select(String.Format("Name LIKE '{0}'", merchant.Replace("'", "''")));
if (drws.Length > 0)
{
return(((CatalogEntryDto.MerchantRow)drws[0]).MerchantId);
}
}
}
return(Guid.Empty);
}
/// <summary>
/// Gets the total records.
/// </summary>
/// <returns></returns>
private int GetTotalRecords()
{
int numRecords = 0;
ICatalogSystem system = CatalogContext.Current;
// Get catalog lists
CatalogDto catalogs = system.GetCatalogDto();
foreach (CatalogDto.CatalogRow catalog in catalogs.Catalog)
{
string catalogName = catalog.Name;
// Get Catalog Nodes
CatalogSearchParameters pars = new CatalogSearchParameters();
CatalogSearchOptions options = new CatalogSearchOptions();
options.CacheResults = false;
pars.CatalogNames.Add(catalogName);
options.RecordsToRetrieve = 1;
options.StartingRecord = 0;
int totalCount = 0;
CatalogEntryDto entryDto = CatalogContext.Current.FindItemsDto(pars, options, ref totalCount);
numRecords += totalCount;
}
return(numRecords);
}
private void BindTargetItems()
{
if (!String.IsNullOrEmpty(CatalogEntryIds))
{
string[] ids = CatalogEntryIds.Split(',');
Items.Clear();
for (int i = 0; i < ids.Length; i++)
{
CatalogEntryDto ent = CatalogContext.Current.GetCatalogEntryDto(int.Parse(ids[i]));
if (ent != null && ent.CatalogEntry.Count > 0)
{
CatalogEntryDto.CatalogEntryRow row = ent.CatalogEntry[0];
Items.Add(new ListItem(row.Name, row.Code));
}
}
}
if (Items != null && Items.Count > 0)
{
lbTarget.Items.Clear();
foreach (ListItem li in Items)
{
lbTarget.Items.Add(li);
li.Selected = true;
ltlSelector.Items.Add(li);
}
}
}
public string[] GetEntryList(string prefixText, int count)
{
if (count == 0)
{
count = 10;
}
CatalogEntryDto dto = CatalogContext.Current.GetCatalogEntriesDto(String.Format("%{0}%", prefixText), String.Empty);
List <string> items = new List <string>(count);
int newCount = 0;
foreach (CatalogEntryDto.CatalogEntryRow row in dto.CatalogEntry)
{
string name = row.Name;
name = name.Replace('|', '-');
//name = name.Replace(']', '-');
items.Add(String.Format("{0}|{1}", name, row.CatalogEntryId));
newCount++;
if (newCount == count)
{
break;
}
}
return(items.ToArray());
}
/// <summary>
/// Binds the value.
/// </summary>
/// <param name="entryCode">The entry code.</param>
private void BindValue(string entryCode)
{
if (String.IsNullOrEmpty(entryCode))
{
return;
}
ComboBoxItem item = EntriesFilter.Items.FindByValue(entryCode);
if (item != null)
{
EntriesFilter.SelectedItem = item;
}
else
{
CatalogEntryDto entryDto = CatalogContext.Current.GetCatalogEntryDto(entryCode);
if (entryDto.CatalogEntry.Count > 0)
{
ComboBoxItem newItem = new ComboBoxItem();
newItem.Text = entryDto.CatalogEntry[0].Name;
newItem.Value = entryDto.CatalogEntry[0].Code;
EntriesFilter.Items.Add(newItem);
EntriesFilter.SelectedItem = newItem;
}
}
}
private IEnumerable <CatalogEntryDto.CatalogEntryRow> GetCatalogEntrys(IEnumerable <string> catalogNames)
{
// Changed to return all entries here
string entryType = String.Empty; //Mediachase.Commerce.Catalog.Objects.EntryType.Product.ToString();
CatalogSearchParameters pars = new CatalogSearchParameters();
CatalogSearchOptions options = new CatalogSearchOptions();
options.RecordsToRetrieve = int.MaxValue;
options.Namespace = "Mediachase.Commerce.Catalog";
options.StartingRecord = 0;
options.ReturnTotalCount = true;
//pars.SqlWhereClause = String.Format("[CatalogEntry].Name like '%{0}%' OR [CatalogEntry].Code like '%{0}%'", sFilter);
// Add catalogs
pars.CatalogNames.AddRange(catalogNames.ToArray());
//CatalogDto catalogDto = CatalogContext.Current.GetCatalogDto();
//foreach (CatalogDto.CatalogRow catalogRow in catalogDto.Catalog)
//{
// pars.CatalogNames.Add(catalogRow.Name);
//}
int totalRecords = 0;
CatalogEntryDto dto = CatalogContext.Current.FindItemsDto(pars, options, ref totalRecords);
foreach (CatalogEntryDto.CatalogEntryRow entryRow in dto.CatalogEntry)
{
//ComboBoxItem item = new ComboBoxItem(entryRow.Name + " [" + entryRow.Code.ToString() + "]");
//item.Value = entryRow.Code.ToString();
//item["icon"] = Page.ResolveClientUrl(String.Format("~/app_themes/Default/images/icons/{0}.gif", entryRow.ClassTypeId));
//EntriesFilter.Items.Add(item);
yield return(entryRow);
}
}
private void CheckOnStringDict(MyPackage currentContent)
{
var stuff = currentContent.GetPropertyValue("StringDictDemo"); // nope
CatalogEntryDto dto = catSys.Service.GetCatalogEntryDto(currentContent.Code);
var row = dto.CatalogEntry.FirstOrDefault();
MetaObject metaObject = MetaObject.Load(MetaDataContext.Instance, row.CatalogEntryId, row.MetaClassId);
var x = metaObject["StringDictDemo"];
System.Collections.Hashtable hash = ObjectHelper.GetMetaFieldValues(dto.CatalogEntry.FirstOrDefault());
Dictionary <int, string> keyValuePairs = new Dictionary <int, string>();
if (hash.Contains("StringDictDemo"))
{
foreach (var item in hash.Keys)
{
}
}
foreach (var item in hash)
{
}
}
private void WalkCatalogNodes(ICatalogSystem catalogSystem, CatalogNodeDto nodes, CatalogDto.CatalogRow catalog, Dictionary <int, CatalogEntryDto.CatalogEntryRow> catalogEntryRows)
{
foreach (CatalogNodeDto.CatalogNodeRow node in nodes.CatalogNode)
{
CatalogSearchParameters pars = new CatalogSearchParameters();
CatalogSearchOptions options = new CatalogSearchOptions {
CacheResults = false
};
pars.CatalogNames.Add(catalog.Name);
pars.CatalogNodes.Add(node.Code);
//CatalogEntryDto entries = CatalogContext.Current.FindItemsDto(
// pars,
// options,
// ref count,
// new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.CatalogEntryFull));
CatalogEntryDto entries = catalogSystem.GetCatalogEntriesDto(catalog.CatalogId, node.CatalogNodeId,
new CatalogEntryResponseGroup(
CatalogEntryResponseGroup.ResponseGroup.CatalogEntryInfo));
_log.DebugFormat("Entries in Node: {0} (Count: {1})", node.Name, entries.CatalogEntry.Rows.Count);
foreach (CatalogEntryDto.CatalogEntryRow entry in entries.CatalogEntry)
{
// _log.DebugFormat("{3}: {0} ({1} - {2})", entry.Name, entry.Code, entry.CatalogEntryId, entry.ClassTypeId);
if (catalogEntryRows.ContainsKey(entry.CatalogEntryId) == false)
{
catalogEntryRows.Add(entry.CatalogEntryId, entry);
}
}
// Get Subnodes
CatalogNodeDto subNodes = catalogSystem.GetCatalogNodesDto(catalog.CatalogId, node.CatalogNodeId);
WalkCatalogNodes(catalogSystem, subNodes, catalog, catalogEntryRows);
}
}
/// <summary>
/// Finds the items dto.
/// </summary>
/// <param name="search">The search.</param>
/// <param name="recordsCount">The records count.</param>
/// <param name="responseGroup">The response group.</param>
/// <returns></returns>
internal static CatalogEntryDto FindItemsDto(CatalogSearch search, ref int recordsCount, CatalogEntryResponseGroup responseGroup)
{
// Assign new cache key, specific for site guid and response groups requested
string cacheKey = String.Empty;
// Only cache results if specified
if (search.SearchOptions.CacheResults)
{
cacheKey = CatalogCache.CreateCacheKey("catalog-entriesdto", responseGroup.CacheKey, search.CacheKey);
// check cache first
object cachedObject = CatalogCache.Get(cacheKey);
if (cachedObject != null)
{
return((CatalogEntryDto)cachedObject);
}
}
CatalogEntryDto dto = FindItemsDto2(search, ref recordsCount, responseGroup);
if (!String.IsNullOrEmpty(cacheKey)) // cache results
{
// Insert to the cache collection
CatalogCache.Insert(cacheKey, dto, search.SearchOptions.CacheTimeout);
}
return(dto);
}
/// <summary>
/// Raises the entry updating event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="Mediachase.Commerce.Catalog.Events.EntryEventArgs"/> instance containing the event data.</param>
public void RaiseEntryUpdatingEvent(CatalogEntryDto sender, EntryEventArgs args)
{
if (EntryUpdating != null)
{
EntryUpdating(sender, args);
}
}
/// <summary>
/// Moves the catalog node.
/// </summary>
/// <param name="catalogId">The catalog id.</param>
/// <param name="catalogNodeId">The catalog node id.</param>
/// <param name="targetCatalogId">The target catalog id.</param>
/// <param name="targetCatalogNodeId">The target catalog node id.</param>
private void MoveCatalogNode(int catalogId, int catalogNodeId, int targetCatalogId, int targetCatalogNodeId)
{
if (catalogId != targetCatalogId || catalogNodeId != targetCatalogNodeId)
{
if (catalogNodeId > 0)
{
CatalogNodeDto catalogNodeDto = CatalogContext.Current.GetCatalogNodeDto(catalogNodeId);
if (catalogNodeDto.CatalogNode.Count > 0)
{
catalogNodeDto.CatalogNode[0].CatalogId = targetCatalogId;
catalogNodeDto.CatalogNode[0].ParentNodeId = targetCatalogNodeId;
CatalogContext.Current.SaveCatalogNode(catalogNodeDto);
CatalogNodeDto childCatalogNodesDto = CatalogContext.Current.GetCatalogNodesDto(catalogId, catalogNodeDto.CatalogNode[0].CatalogNodeId);
if (childCatalogNodesDto.CatalogNode.Count > 0)
{
for (int i = 0; i < childCatalogNodesDto.CatalogNode.Count; i++)
{
MoveCatalogNode(catalogId, childCatalogNodesDto.CatalogNode[i].CatalogNodeId, targetCatalogId, catalogNodeDto.CatalogNode[0].CatalogNodeId);
}
}
CatalogEntryDto catalogEntriesDto = CatalogContext.Current.GetCatalogEntriesDto(catalogId, catalogNodeDto.CatalogNode[0].CatalogNodeId);
if (catalogEntriesDto.CatalogEntry.Count > 0)
{
for (int i = 0; i < catalogEntriesDto.CatalogEntry.Count; i++)
{
MoveNodeEntry(catalogId, catalogNodeDto.CatalogNode[0].CatalogNodeId, catalogEntriesDto.CatalogEntry[i].CatalogEntryId, targetCatalogId, catalogNodeDto.CatalogNode[0].CatalogNodeId);
}
}
}
}
}
}
/// <summary>
/// Gets the catalog entry by URI dto.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="languageCode">The language code.</param>
/// <param name="responseGroup">The response group.</param>
/// <returns></returns>
internal static CatalogEntryDto GetCatalogEntryByUriDto(string uri, string languageCode, CatalogEntryResponseGroup responseGroup)
{
// Assign new cache key, specific for site guid and response groups requested
string cacheKey = CatalogCache.CreateCacheKey("catalogentry-uri-", responseGroup.CacheKey, uri, languageCode);
CatalogEntryDto dto = null;
// check cache first
object cachedObject = CatalogCache.Get(cacheKey);
if (cachedObject != null)
{
dto = (CatalogEntryDto)cachedObject;
}
// Load the object
if (dto == null)
{
CatalogEntryAdmin catalog = new CatalogEntryAdmin();
catalog.LoadByUri(uri, languageCode);
dto = catalog.CurrentDto;
if (dto.CatalogEntry.Count > 0)
{
LoadEntry(catalog, dto.CatalogEntry[0], responseGroup);
}
// Insert to the cache collection
CatalogCache.Insert(cacheKey, dto, CatalogConfiguration.Instance.Cache.CatalogEntryTimeout);
}
//dto.AcceptChanges();
return(dto);
}
/// <summary>
/// Gets the catalog entries by catalog dto.
/// </summary>
/// <returns></returns>
internal static CatalogEntryDto GetMerchants()
{
// Assign new cache key, specific for site guid and response groups requested
string cacheKey = CatalogCache.CreateCacheKey("catalogentry-merchants");
CatalogEntryDto dto = null;
// check cache first
object cachedObject = CatalogCache.Get(cacheKey);
if (cachedObject != null)
{
dto = (CatalogEntryDto)cachedObject;
}
// Load the object
if (dto == null)
{
CatalogEntryAdmin catalog = new CatalogEntryAdmin();
catalog.LoadMerchants();
dto = catalog.CurrentDto;
// Insert to the cache collection
CatalogCache.Insert(cacheKey, dto, CatalogConfiguration.Instance.Cache.CatalogCollectionTimeout);
}
//dto.AcceptChanges();
return(dto);
}
/// <summary>
/// Creates the empty dtos.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="relation">The relation.</param>
/// <param name="association">The association.</param>
/// <param name="persistInSession">if set to <c>true</c> [persist in session].</param>
private void CreateEmptyDtos(ref CatalogEntryDto entry, ref CatalogRelationDto relation, ref CatalogAssociationDto association, bool persistInSession)
{
if (relation == null)
{
relation = new CatalogRelationDto();
if (persistInSession)
{
Session[_CatalogRelationDtoString] = relation;
}
}
if (association == null)
{
association = new CatalogAssociationDto();
if (persistInSession)
{
Session[_CatalogAssociationDtoString] = association;
}
}
if (entry == null)
{
entry = new CatalogEntryDto();
if (persistInSession)
{
Session[_CatalogEntryDtoString] = entry;
}
}
}
private void PopulateVariationInfo(CatalogEntryDto.CatalogEntryRow entryRow, LineItem lineItem)
{
CatalogEntryDto.VariationRow variationRow = entryRow.GetVariationRows().FirstOrDefault();
if (variationRow != null)
{
lineItem.MaxQuantity = variationRow.MaxQuantity;
lineItem.MinQuantity = variationRow.MinQuantity;
CustomerContact customerContact = CustomerContext.Current.GetContactById(lineItem.Parent.Parent.CustomerId);
Money? newListPrice = GetItemPrice(entryRow, lineItem, customerContact);
if (newListPrice.HasValue)
{
Money oldListPrice = new Money(Math.Round(lineItem.ListPrice, 2), lineItem.Parent.Parent.BillingCurrency);
if (oldListPrice != newListPrice.Value)
{
AddWarningSafe(Warnings,
"LineItemPriceChange-" + lineItem.Parent.LineItems.IndexOf(lineItem).ToString(),
string.Format("Price for \"{0}\" has been changed from {1} to {2}.", lineItem.DisplayName, oldListPrice.ToString(), newListPrice.ToString()));
// Set new price on line item.
lineItem.ListPrice = newListPrice.Value.Amount;
if (lineItem.Parent.Parent.ProviderId.ToLower().Equals("frontend"))
{
lineItem.PlacedPrice = newListPrice.Value.Amount;
}
}
}
}
}
/// <summary>
/// Gets the entry name by id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
private string GetEntryNameById(int id)
{
string name = String.Empty;
bool found = false; // shows whether name was found
// try to look up name using items in AssociationItemsFilter dropdown; if item with specified id is not there, get it from the db
if (AssociataionItemsFilter.ItemCount > 0)
{
ComboBoxItem item = AssociataionItemsFilter.Items.FindByValue(id.ToString());
if (item != null)
{
name = item.Text;
found = true;
}
}
if (!found)
{
CatalogEntryDto dto = CatalogContext.Current.GetCatalogEntryDto(id);
if (dto.CatalogEntry.Rows.Count > 0)
{
name = ((CatalogEntryDto.CatalogEntryRow)dto.CatalogEntry.Rows[0]).Name;
}
}
return(name);
}
/// <summary>
/// Gets a list of data from the underlying data storage.
/// </summary>
/// <param name="arguments">A <see cref="T:System.Web.UI.DataSourceSelectArguments"/> that is used to request operations on the data beyond basic data retrieval.</param>
/// <returns>
/// An <see cref="T:System.Collections.IEnumerable"/> list of data from the underlying data storage.
/// </returns>
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
{
Options.RecordsToRetrieve = arguments.MaximumRows;
Options.StartingRecord = arguments.StartRowIndex;
if (!String.IsNullOrEmpty(arguments.SortExpression))
{
Parameters.OrderByClause = arguments.SortExpression;
}
if (DataMode == CatalogSearchDataMode.Objects)
{
Entries entries = CatalogContext.Current.FindItems(Parameters, Options, ResponseGroup);
arguments.TotalRowCount = entries.TotalResults;
return(entries.Entry);
}
else
{
int totalRecordsCount = 0;
CatalogEntryDto entries = CatalogContext.Current.FindItemsDto(Parameters, Options, ref totalRecordsCount, ResponseGroup);
if (totalRecordsCount > 0)
{
arguments.TotalRowCount = totalRecordsCount;
return(entries.CatalogEntry.Rows);
}
else
{
arguments.TotalRowCount = 0;
return(null);
}
}
}
public IEnumerable <ContentReference> AllCategories()
{
List <ContentReference> localList = new List <ContentReference>();
List <int> nodeIds = new List <int>();
CatalogEntryDto dto = CatalogContext.Current.GetCatalogEntriesDto("Fashion");
CatalogRelationDto relDto = CatalogContext.Current.GetCatalogRelationDto(1, 0, 0, null,
new CatalogRelationResponseGroup(CatalogRelationResponseGroup.ResponseGroup.NodeEntry));
foreach (CatalogRelationDto.NodeEntryRelationRow item in relDto.NodeEntryRelation)
{
if (!nodeIds.Contains(item.CatalogNodeId))
{
nodeIds.Add(item.CatalogNodeId);
}
}
ReferenceConverter refConv = ServiceLocator.Current.GetInstance <ReferenceConverter>();
foreach (int item in nodeIds)
{
localList.Add(refConv.GetContentLink(item, CatalogContentType.CatalogNode, 0));
}
return(localList);
}
/// <summary>
/// Binds the lists.
/// </summary>
private void BindLists()
{
// bind shipment packages
if (PackageList.Items.Count <= 1)
{
ShippingMethodDto shippingDto = ShippingManager.GetShippingPackages();
if (shippingDto.Package != null)
{
foreach (ShippingMethodDto.PackageRow row in shippingDto.Package.Rows)
{
PackageList.Items.Add(new ListItem(row.Name, row.PackageId.ToString()));
}
}
PackageList.DataBind();
}
// bind warehouses
if (WarehouseList.Items.Count <= 1)
{
WarehouseDto dto = WarehouseManager.GetWarehouseDto();
if (dto.Warehouse != null)
{
foreach (WarehouseDto.WarehouseRow row in dto.Warehouse.Rows)
{
WarehouseList.Items.Add(new ListItem(row.Name, row.WarehouseId.ToString()));
}
}
WarehouseList.DataBind();
}
// bind merchants
if (MerchantList.Items.Count <= 1)
{
CatalogEntryDto merchants = CatalogContext.Current.GetMerchantsDto();
if (merchants.Merchant != null)
{
foreach (CatalogEntryDto.MerchantRow row in merchants.Merchant.Rows)
{
MerchantList.Items.Add(new ListItem(row.Name, row.MerchantId.ToString()));
}
}
MerchantList.DataBind();
}
// bind tax categories
if (TaxList.Items.Count <= 1)
{
CatalogTaxDto taxes = CatalogTaxManager.GetTaxCategories();
if (taxes.TaxCategory != null)
{
foreach (CatalogTaxDto.TaxCategoryRow row in taxes.TaxCategory.Rows)
{
TaxList.Items.Add(new ListItem(row.Name, row.TaxCategoryId.ToString()));
}
}
TaxList.DataBind();
}
}
/// <summary>
/// Called when a catalog entry is indexed.
/// We use this method to load the prices for the variants of a product and store
/// the highest variant price on the product for optimal retrieval in the product listing.
/// </summary>
protected override void OnCatalogEntryIndex(ref SearchDocument document, CatalogEntryDto.CatalogEntryRow entry, string language)
{
if (!entry.ClassTypeId.Equals(EntryType.Product))
{
return;
}
UpdateSearchDocument(ref document, entry, language);
}
/// <summary>
/// Get entry row from a line item
/// </summary>
/// <param name="lineItem">line item</param>
protected static CatalogEntryDto.CatalogEntryRow GetEntryRowForLineItem(LineItem lineItem)
{
var responseGroup = new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.Variations);
CatalogEntryDto entryDto = CatalogContext.Current.GetCatalogEntryDto(lineItem.Code, responseGroup);
return(entryDto.CatalogEntry.FirstOrDefault());
}
private static CatalogEntryDto.CatalogEntryRow GetCatalogEntry(CatalogEntryDto entryDto)
{
if (entryDto == null)
{
throw new ArgumentNullException("entryDto");
}
return(entryDto.CatalogEntry.FirstOrDefault());
}
/// <summary>
/// Pre processes item record adding additional LineItems if needed.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="record">The record.</param>
private void PreProcessItemRecord(OrderGroup order, PromotionItemRecord record)
{
// We do special logic for the gift promotion reward
if (record.PromotionReward is GiftPromotionReward)
{
// Check if item already in the cart, if not add
if (((GiftPromotionReward)record.PromotionReward).AddStrategy == GiftPromotionReward.Strategy.AddWhenNeeded)
{
// We assume that all affected entries are the gifts that need to be added to the cart
foreach (PromotionEntry entry in record.AffectedEntriesSet.Entries)
{
LineItem giftLineItem = FindGiftLineItemInOrder(order, entry.CatalogEntryCode, record);
if (!IsOrderHaveSpecifiedGiftPromotion(order, record))
{
// Didn't find, add it
if (giftLineItem == null)
{
// we should some kind of delegate or common implementation here so we can use the same function in both discount and front end
CatalogEntryResponseGroup responseGroup = new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.Variations);
Entry catEntry = CatalogContext.Current.GetCatalogEntry(entry.CatalogEntryCode, responseGroup);
giftLineItem = AddNewGiftLineItemToOrder(order, catEntry, entry.Quantity);
AddGiftItemToAShipment(giftLineItem, giftLineItem.Parent.LineItems.Count - 1);
CatalogEntryDto entryDto = CatalogContext.Current.GetCatalogEntryDto(giftLineItem.Code, responseGroup);
CatalogEntryDto.CatalogEntryRow entryRow = entryDto.CatalogEntry[0];
Money?price = GetItemPrice(entryRow, giftLineItem, CustomerContext.Current.CurrentContact);
giftLineItem.ListPrice = price.HasValue ? price.Value.Amount : 0m;
giftLineItem.PlacedPrice = giftLineItem.ListPrice;
// populate inventory information for giftLineItem
var aggregateInventory = ServiceLocator.Current.GetInstance <IInventoryService>().QueryByEntry(new [] { entryRow.Code });
foreach (var inventoryRecord in aggregateInventory)
{
PopulateInventoryInfo(inventoryRecord, giftLineItem);
}
}
else
{
giftLineItem.Quantity = Math.Max(entry.Quantity, giftLineItem.Quantity);
var index = giftLineItem.Parent.LineItems.IndexOf(giftLineItem);
if (!giftLineItem.Parent.Shipments.SelectMany(x => x.LineItemIndexes).Contains(index.ToString()))
{
AddGiftItemToAShipment(giftLineItem, index);
}
}
}
else
{
entry.Quantity = giftLineItem != null?Math.Min(entry.Quantity, giftLineItem.Quantity) : entry.Quantity;
}
entry.Owner = giftLineItem;
entry.CostPerEntry = giftLineItem != null ? giftLineItem.ListPrice : 0m;
}
}
}
}
/// <summary>
/// Loads the fresh entry.
/// </summary>
/// <returns></returns>
private CatalogEntryDto LoadFreshEntry()
{
CatalogEntryDto entry = LoadEntry();
// persist in session
Session[_CatalogEntryDtoString] = entry;
return(entry);
}
/// <summary>
/// Loads the items.
/// </summary>
/// <param name="iStartIndex">Start index of the i.</param>
/// <param name="iNumItems">The i num items.</param>
/// <param name="sFilter">The s filter.</param>
private void LoadItems(int iStartIndex, int iNumItems, string sFilter)
{
// This method filters which entries to display in the search results.
// By default the system displays only variations for product variations. So for instance
// product can not have sub products and any entry for all other types of products. So
// for instance package can have other packages and related items.
// This behaviour can be customized by modifying the following IF statement.
string entryType = EntryType.Variation.ToString();
if (RelationTypeId == EntryRelationType.ProductVariation.ToString())
{
entryType = EntryType.Variation.ToString();
}
else
{
entryType = String.Empty;
}
CatalogSearchParameters pars = new CatalogSearchParameters();
CatalogSearchOptions options = new CatalogSearchOptions();
options.RecordsToRetrieve = iNumItems;
options.Namespace = "Mediachase.Commerce.Catalog";
options.StartingRecord = iStartIndex;
options.ReturnTotalCount = true;
pars.SqlWhereClause = String.Format("[CatalogEntry].Name like '%{0}%' OR [CatalogEntry].Code like '%{0}%'", sFilter);
if (!String.IsNullOrEmpty(entryType))
{
pars.SqlWhereClause = pars.SqlWhereClause + String.Format(" AND ClassTypeId='{0}'", entryType);
}
// Add catalogs
CatalogDto catalogDto = CatalogContext.Current.GetCatalogDto();
foreach (CatalogDto.CatalogRow catalogRow in catalogDto.Catalog)
{
pars.CatalogNames.Add(catalogRow.Name);
}
int totalRecords = 0;
CatalogEntryDto dto = CatalogContext.Current.FindItemsDto(pars, options, ref totalRecords);
//CatalogEntryDto dto = CatalogContext.Current.GetCatalogEntriesDto(String.Format("%{0}%", sFilter), entryType);
ItemsFilter.Items.Clear();
foreach (CatalogEntryDto.CatalogEntryRow row in dto.CatalogEntry)
{
ComboBoxItem item = new ComboBoxItem(row.Name);
item.Value = row.CatalogEntryId.ToString();
item["icon"] = Page.ResolveClientUrl(String.Format("~/app_themes/Default/images/icons/{0}.gif", row.ClassTypeId));
ItemsFilter.Items.Add(item);
}
ItemsFilter.ItemCount = totalRecords;
}
/// <summary>
/// Moves the node entry.
/// </summary>
/// <param name="catalogId">The catalog id.</param>
/// <param name="catalogNodeId">The catalog node id.</param>
/// <param name="catalogEntryId">The catalog entry id.</param>
/// <param name="targetCatalogId">The target catalog id.</param>
/// <param name="targetCatalogNodeId">The target catalog node id.</param>
private void MoveNodeEntry(int catalogId, int catalogNodeId, int catalogEntryId, int targetCatalogId, int targetCatalogNodeId)
{
if (catalogId != targetCatalogId)
{
CatalogEntryDto catalogEntryDto = CatalogContext.Current.GetCatalogEntryDto(catalogEntryId);
if (catalogEntryDto.CatalogEntry.Count > 0)
{
catalogEntryDto.CatalogEntry[0].CatalogId = targetCatalogId;
CatalogContext.Current.SaveCatalogEntry(catalogEntryDto);
}
}
bool addNewRow = false;
if (catalogId != targetCatalogId || catalogNodeId != targetCatalogNodeId)
{
if (catalogNodeId > 0)
{
CatalogRelationDto catalogRelationDto = CatalogContext.Current.GetCatalogRelationDto(catalogId, catalogNodeId, catalogEntryId, String.Empty, new CatalogRelationResponseGroup(CatalogRelationResponseGroup.ResponseGroup.NodeEntry));
if (catalogRelationDto.NodeEntryRelation.Count > 0)
{
if (targetCatalogNodeId > 0)
{
catalogRelationDto.NodeEntryRelation[0].CatalogId = targetCatalogId;
catalogRelationDto.NodeEntryRelation[0].CatalogNodeId = targetCatalogNodeId;
}
else
{
catalogRelationDto.NodeEntryRelation[0].Delete();
}
CatalogContext.Current.SaveCatalogRelationDto(catalogRelationDto);
}
else if (targetCatalogNodeId > 0)
{
addNewRow = true;
}
}
else if (targetCatalogNodeId > 0)
{
addNewRow = true;
}
if (addNewRow)
{
CatalogRelationDto newCatalogRelationDto = new CatalogRelationDto();
CatalogRelationDto.NodeEntryRelationRow row = newCatalogRelationDto.NodeEntryRelation.NewNodeEntryRelationRow();
row.CatalogId = targetCatalogId;
row.CatalogNodeId = targetCatalogNodeId;
row.CatalogEntryId = catalogEntryId;
row.SortOrder = 0;
newCatalogRelationDto.NodeEntryRelation.AddNodeEntryRelationRow(row);
CatalogContext.Current.SaveCatalogRelationDto(newCatalogRelationDto);
}
}
}
/// <summary>
/// Creates a line item.
/// Code copied from OrderHelper.cs.
/// </summary>
/// <param name="random">A Random object seeded from the start of test method.</param>
/// <returns></returns>
private LineItem createLineItem(Random random, Guid shippingMethod, String shippingMethodName)
{
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto();
CatalogEntryDto.CatalogEntryRow entry = null;
bool found = false;
string catalogName = String.Empty;
int seed = 0;
while (!found)
{
seed = random.Next(catalogs.Catalog.Count - 1);
CatalogDto.CatalogRow catalog = catalogs.Catalog[seed];
catalogName = catalog.Name;
// Get Catalog Nodes
CatalogNodeDto nodes = CatalogContext.Current.GetCatalogNodesDto(catalogName);
// Pick random node
if (nodes.CatalogNode.Count > 0)
{
seed = random.Next(nodes.CatalogNode.Count - 1);
CatalogNodeDto.CatalogNodeRow node = nodes.CatalogNode[seed];
CatalogEntryDto entryDto = CatalogContext.Current.GetCatalogEntriesDto(catalogName, node.CatalogNodeId);
if (entryDto.CatalogEntry.Count > 0)
{
seed = random.Next(entryDto.CatalogEntry.Count - 1);
entry = entryDto.CatalogEntry[seed];
if (entry.IsActive)
{
found = true;
}
}
}
}
LineItem lineItem = new LineItem();
lineItem.DisplayName = entry.Name;
lineItem.CatalogEntryId = entry.Code;
lineItem.ShippingMethodId = shippingMethod;
lineItem.ShippingMethodName = shippingMethodName;
lineItem.ShippingAddressId = "Home";
// Choose a random quantity for chosen product.
int quantity = random.Next(1, 7);
lineItem.Quantity = quantity;
lineItem.CatalogNode = catalogName;
lineItem.Discounts.Add(OrderHelper.CreateLineItemDiscount());
return(lineItem);
}
/// <summary>
/// Loads the context.
/// </summary>
private void LoadContext()
{
CatalogEntryDto entry = null;
CatalogRelationDto relation = null;
CatalogAssociationDto association = null;
if (!this.IsPostBack && (!this.Request.QueryString.ToString().Contains("Callback=yes"))) // load fresh on initial load
{
entry = LoadFreshEntry();
relation = LoadFreshRelation();
association = LoadFreshAssociation();
// if Dtos not loaded, create empty Dtos
CreateEmptyDtos(ref entry, ref relation, ref association, true);
}
else // load from session
{
entry = (CatalogEntryDto)Session[_CatalogEntryDtoString];
if (entry == null)
{
entry = LoadFreshEntry();
}
association = (CatalogAssociationDto)Session[_CatalogAssociationDtoString];
if (association == null)
{
association = LoadFreshAssociation();
}
relation = (CatalogRelationDto)Session[_CatalogRelationDtoString];
if (relation == null)
{
relation = LoadFreshRelation();
}
}
if (CatalogEntryId > 0 && entry.CatalogEntry.Count == 0)
{
Response.Redirect("ContentFrame.aspx?_a=Catalog&_v=Catalog-List");
}
// Put a dictionary key that can be used by other tabs
IDictionary dic = new ListDictionary();
dic.Add(_CatalogEntryDtoString, entry);
dic.Add(_CatalogRelationDtoString, relation);
dic.Add(_CatalogAssociationDtoString, association);
// Call tabs load context
ViewControl.LoadContext(dic);
}
public IEnumerable <CatalogEntryDto.VariationRow> GetVariations(int productId)
{
ICatalogSystem catalog = EPiServer.ServiceLocation.ServiceLocator.Current.GetInstance <ICatalogSystem>();
CatalogEntryResponseGroup responseGroup = new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.CatalogEntryFull);
CatalogEntryDto variationEntries = catalog.GetCatalogEntriesDto(productId,
string.Empty,
string.Empty,
responseGroup);
return(variationEntries.Variation.ToList());
}
/// <summary>
/// Creates the line item.
/// </summary>
/// <returns></returns>
public static LineItem CreateLineItem()
{
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto();
CatalogEntryDto.CatalogEntryRow entry = null;
bool found = false;
string catalogName = String.Empty;
Random random = new Random();
int seed = 0;
while (!found)
{
seed = random.Next(catalogs.Catalog.Count - 1);
CatalogDto.CatalogRow catalog = catalogs.Catalog[seed];
catalogName = catalog.Name;
// Get Catalog Nodes
CatalogNodeDto nodes = CatalogContext.Current.GetCatalogNodesDto(catalogName);
// Pick random node
if (nodes.CatalogNode.Count > 0)
{
seed = random.Next(nodes.CatalogNode.Count - 1);
CatalogNodeDto.CatalogNodeRow node = nodes.CatalogNode[seed];
CatalogEntryDto entryDto = CatalogContext.Current.GetCatalogEntriesDto(catalogName, node.CatalogNodeId);
if (entryDto.CatalogEntry.Count > 0)
{
seed = random.Next(entryDto.CatalogEntry.Count - 1);
entry = entryDto.CatalogEntry[seed];
if (entry.IsActive)
{
found = true;
}
}
}
}
LineItem lineItem = new LineItem();
lineItem.DisplayName = entry.Name;
lineItem.CatalogEntryId = entry.Code;
lineItem.ShippingMethodId = new Guid("17995798-a2cc-43ad-81e8-bb932f6827e4");
lineItem.ShippingMethodName = "Online Download";
lineItem.ShippingAddressId = "Home";
lineItem.ListPrice = 100;
lineItem.Quantity = 2;
lineItem.CatalogNode = catalogName;
lineItem.Discounts.Add(CreateLineItemDiscount());
return(lineItem);
}
/// <summary>
/// Loads the context.
/// </summary>
/// <param name="context">The context.</param>
public void LoadContext(IDictionary context)
{
_CatalogEntryDto = (CatalogEntryDto)context[_CatalogEntryDtoString];
_CatalogCurrency = (string)context[_CatalogCurrencyString];
if (String.IsNullOrEmpty(_CatalogCurrency))
{
_CatalogCurrency = CommonSettingsManager.GetDefaultCurrency();
}
_CatalogCurrency = _CatalogCurrency.ToUpper();
}
/// <summary>
/// Handles the BookmarkNavigation event of the MyReportViewer control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.Reporting.WebForms.BookmarkNavigationEventArgs"/> instance containing the event data.</param>
protected void MyReportViewer_BookmarkNavigation(object sender, BookmarkNavigationEventArgs e)
{
CatalogEntryDto dto = CatalogContext.Current.GetCatalogEntryDto(e.BookmarkId);
if (dto.CatalogEntry.Count > 0)
{
e.Cancel = true;
Response.Redirect(ManagementHelper.GetEntryUrl(dto.CatalogEntry[0].CatalogEntryId, dto.CatalogEntry[0].ClassTypeId));
}
e.Cancel = true;
}
public void UpdateSearchDocument(ref SearchDocument document, CatalogEntryDto.CatalogEntryRow entry, string language)
{
var sw = new Stopwatch();
sw.Start();
var contentLink = _referenceConverter.GetContentLink(entry.Code);
var productContent = _contentLoader.Get<FashionProduct>(contentLink);
var variants = _contentLoader.GetItems(productContent.GetVariants(_relationRepository), CultureInfo.GetCultureInfo(language)).OfType<FashionVariant>().ToList();
AddPrices(document, variants);
AddColors(document, variants);
AddSizes(document, variants);
AddCodes(document, variants);
document.Add(new SearchField("code", productContent.Code, new[] { SearchField.Store.YES, SearchField.IncludeInDefaultSearch.YES }));
document.Add(new SearchField("displayname", productContent.DisplayName));
document.Add(new SearchField("image_url", _assetUrlResolver.GetAssetUrl<IContentImage>(productContent)));
document.Add(new SearchField("content_link", productContent.ContentLink.ToString()));
document.Add(new SearchField("created", productContent.Created.ToString("yyyyMMddhhmmss")));
document.Add(new SearchField("brand", productContent.Brand));
document.Add(new SearchField("top_category_name", GetTopCategory(productContent).DisplayName));
sw.Stop();
_log.Debug(string.Format("Indexing of {0} for {1} took {2}", productContent.Code, language, sw.Elapsed.Milliseconds));
}
protected override void OnCatalogEntryIndex(ref SearchDocument document, CatalogEntryDto.CatalogEntryRow entry, string language)
{
if (entry.ClassTypeId != "Product")
{
return;
}
var result = GetDocument(language, entry.Code).Result;
if (result == null)
{
throw new Exception(String.Format("could not connect to {0}, please make sure site is active",
_url + String.Format("referenceapi/searchdocuments/{0}/{1}", language, entry.Code)));
}
foreach (var field in result.Fields.Where(field => field.Values.Any()))
{
document.Add
(
field.IsDecimal ?
new SearchField(field.Name, Decimal.Parse(field.Values.First(), CultureInfo.InvariantCulture), field.Attributes.ToArray()) :
new SearchField(field.Name, field.Values.First(), field.Attributes.ToArray())
);
}
}
private static bool CheckNeedEntryTracking(CatalogEntryDto.CatalogEntryRow catalogEntry)
{
if (catalogEntry == null)
{
throw new ArgumentNullException("catalogEntry");
}
var retVal = false;
var entryVariations = GetEntryVariations(catalogEntry);
var variation = entryVariations.FirstOrDefault();
if (variation != null)
{
retVal = variation.TrackInventory;
}
return retVal;
}
private static CatalogEntryDto.CatalogEntryRow GetCatalogEntry(CatalogEntryDto entryDto)
{
if (entryDto == null)
{
throw new ArgumentNullException("entryDto");
}
return entryDto.CatalogEntry.FirstOrDefault();
}
private static IEnumerable<CatalogEntryDto.VariationRow> GetEntryVariations(CatalogEntryDto.CatalogEntryRow catalogEntry)
{
if (catalogEntry == null)
{
throw new ArgumentNullException("catalogEntry");
}
return catalogEntry.GetVariationRows();
}
protected Money? GetItemPrice(CatalogEntryDto.CatalogEntryRow entry, LineItem lineItem, CustomerContact customerContact)
{
List<CustomerPricing> customerPricing = new List<CustomerPricing>();
customerPricing.Add(CustomerPricing.AllCustomers);
if (customerContact != null)
{
var userKey = _mapUserKey.ToUserKey(customerContact.UserId);
if (userKey != null && !string.IsNullOrWhiteSpace(userKey.ToString()))
{
customerPricing.Add(new CustomerPricing(CustomerPricing.PriceType.UserName, userKey.ToString()));
}
if (!string.IsNullOrEmpty(customerContact.EffectiveCustomerGroup))
{
customerPricing.Add(new CustomerPricing(CustomerPricing.PriceType.PriceGroup, customerContact.EffectiveCustomerGroup));
}
}
IPriceService priceService = ServiceLocator.Current.GetInstance<IPriceService>();
PriceFilter priceFilter = new PriceFilter()
{
Currencies = new List<Currency>() { new Currency(lineItem.Parent.Parent.BillingCurrency) },
Quantity = lineItem.Quantity,
CustomerPricing = customerPricing,
ReturnCustomerPricing = false // just want one value
};
// Get the lowest price among all the prices matching the parameters
IPriceValue priceValue = priceService
.GetPrices(lineItem.Parent.Parent.MarketId, FrameworkContext.Current.CurrentDateTime, new CatalogKey(entry), priceFilter)
.OrderBy(pv => pv.UnitPrice)
.FirstOrDefault();
if (priceValue == null)
{
return null;
}
else
{
return priceValue.UnitPrice;
}
}
/// <summary>
/// Check catalog entry's tracking inventory was enable or not.
/// </summary>
/// <param name="catalogEntry">Catalog entry.</param>
private bool InventoryTrackingEnabled(CatalogEntryDto.CatalogEntryRow catalogEntry)
{
var entryVariations = catalogEntry.GetVariationRows();
var variation = entryVariations.FirstOrDefault();
return variation != null && variation.TrackInventory;
}
