/// <summary>
/// Binds the element.
/// </summary>
private void BindElement()
{
ddlElement.Items.Clear();
MetaClassCollection coll = MetaClass.GetList(MDContext, Namespace, true);
foreach (MetaClass mc in coll)
{
if (mc.Parent == null)
{
if (String.Compare(mc.TableName, "customeraccount", true) != 0 &&
String.Compare(mc.TableName, "address", true) != 0)
{
ddlElement.Items.Add(new ListItem(mc.FriendlyName, mc.Id.ToString()));
}
}
}
if (ddlElement.Items.Count > 0)
{
MetaClass mc = null;
if (MetaClassId > 0 && !IsPostBack)
{
mc = MetaClass.Load(MDContext, MetaClassId);
}
if (mc != null)
{
ManagementHelper.SelectListItem(ddlElement, mc.Parent.Id.ToString());
}
else
{
ManagementHelper.SelectListItem(ddlElement, ddlElement.Items[0].Value);
}
}
BindType();
}
private void BindSelectedType()
{
lblSelectedType.Visible = false;
ddlSelectedType.Visible = false;
if (ddlSelectedElement.Items.Count > 0)
{
int SelectedClassId = int.Parse(ddlSelectedElement.SelectedItem.Value);
MetaClass mc = MetaClass.Load(SelectedClassId);
if (mc.ChildClasses != null && mc.ChildClasses.Count > 0)
{
lblSelectedType.Visible = true;
ddlSelectedType.Visible = true;
ddlSelectedType.Items.Clear();
MetaClassCollection children = mc.ChildClasses;
foreach (MetaClass child in children)
{
ddlSelectedType.Items.Add(new ListItem(child.FriendlyName, child.Id.ToString()));
}
if (!IsPostBack && pc["cust_SelectedElement"] != null)
{
Util.CommonHelper.SafeSelect(ddlSelectedType, pc["cust_SelectedElement"]);
}
}
}
BindSelectedFields();
}
/// <summary>
/// Binds the data.
/// </summary>
private void BindData()
{
SearchFilter.Items.Clear();
SearchFilter.Items.Add(new ListItem(RM.GetString("GENERAL_ALL_PRODUCTS"), ""));
string cacheKey = CatalogCache.CreateCacheKey("mc-catalogentry-list");
// check cache first
object cachedObject = CatalogCache.Get(cacheKey);
MetaClassCollection metaClasses = null;
MetaClass catalogEntry = MetaHelper.LoadMetaClassCached(CatalogContext.MetaDataContext, "CatalogEntry");
if (catalogEntry != null)
{
metaClasses = catalogEntry.ChildClasses;
}
if (metaClasses != null)
{
foreach (MetaClass metaClass in metaClasses)
{
SearchFilter.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Name));
}
}
SearchFilter.DataBind();
Search.Text = Request.QueryString["search"];
CommonHelper.SelectListItem(SearchFilter, Request.QueryString["filter"]);
}
/// <summary>
/// Binds the form.
/// </summary>
private void BindForm()
{
// Bind Meta classes
MetaClass catalogEntry = MetaClass.Load(CatalogContext.MetaDataContext, "CatalogEntry");
MetaClassList.Items.Clear();
if (catalogEntry != null)
{
MetaClassCollection metaClasses = catalogEntry.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
MetaClassList.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Id.ToString()));
}
MetaClassList.DataBind();
}
// Bind Templates
TemplateDto templates = DictionaryManager.GetTemplateDto();
if (templates.main_Templates.Count > 0)
{
DataView view = templates.main_Templates.DefaultView;
view.RowFilter = "TemplateType = 'entry'";
DisplayTemplate.DataSource = view;
DisplayTemplate.DataBind();
}
if (CatalogEntryId > 0)
{
if (_CatalogEntryDto.CatalogEntry.Count > 0)
{
Name.Text = _CatalogEntryDto.CatalogEntry[0].Name;
AvailableFrom.Value = ManagementHelper.GetUserDateTime(_CatalogEntryDto.CatalogEntry[0].StartDate);
ExpiresOn.Value = ManagementHelper.GetUserDateTime(_CatalogEntryDto.CatalogEntry[0].EndDate);
CodeText.Text = _CatalogEntryDto.CatalogEntry[0].Code;
IsActive.IsSelected = _CatalogEntryDto.CatalogEntry[0].IsActive;
ManagementHelper.SelectListItem(DisplayTemplate, _CatalogEntryDto.CatalogEntry[0].TemplateName);
ManagementHelper.SelectListItem(MetaClassList, _CatalogEntryDto.CatalogEntry[0].MetaClassId);
// Bind Sort order
foreach (CatalogRelationDto.NodeEntryRelationRow row in _CatalogRelationDto.NodeEntryRelation)
{
if (row.CatalogEntryId == _CatalogEntryDto.CatalogEntry[0].CatalogEntryId &&
row.CatalogId == this.ParentCatalogId &&
row.CatalogNodeId == this.ParentCatalogNodeId)
{
SortOrder.Text = row.SortOrder.ToString();
}
}
}
}
else
{
this.AvailableFrom.Value = ManagementHelper.GetUserDateTime(DateTime.UtcNow);
this.ExpiresOn.Value = ManagementHelper.GetUserDateTime(DateTime.UtcNow).AddYears(1);
}
}
// GET api/<controller>
public IEnumerable <MetaClass> Get()
{
MetaClassCollection classCollection = Mediachase.MetaDataPlus.Configurator.MetaClass.GetList(MetaDataContext.Instance);
var mciList = from Mediachase.MetaDataPlus.Configurator.MetaClass mc in classCollection
select new MetaClass(mc);
return(mciList.ToList());
}
public IEnumerable <MetaClass> Get(string @namespace)
{
MetaClassCollection classCollection = Mediachase.MetaDataPlus.Configurator.MetaClass.GetList(MetaDataContext.Instance);
var mciList = from Mediachase.MetaDataPlus.Configurator.MetaClass mc in classCollection
where mc.Namespace.CompareTo(@namespace) == 0
select new MetaClass(mc);
return(mciList.ToList());
}
/// <summary>
/// Binds the form.
/// </summary>
private void BindForm()
{
// Bind Meta classes
MetaClass catalogNode = MetaClass.Load(CatalogContext.MetaDataContext, "CatalogNode");
MetaClassList.Items.Clear();
if (catalogNode != null)
{
MetaClassCollection metaClasses = catalogNode.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
MetaClassList.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Id.ToString()));
}
MetaClassList.DataBind();
}
// Bind Templates
TemplateDto templates = DictionaryManager.GetTemplateDto();
if (templates.main_Templates.Count > 0)
{
DataView view = templates.main_Templates.DefaultView;
view.RowFilter = "TemplateType = 'node'";
DisplayTemplate.DataSource = view;
DisplayTemplate.DataBind();
}
if (CatalogNodeId > 0)
{
if (_CatalogNodeDto.CatalogNode.Count > 0)
{
Name.Text = _CatalogNodeDto.CatalogNode[0].Name;
AvailableFrom.Value = ManagementHelper.GetUserDateTime(_CatalogNodeDto.CatalogNode[0].StartDate);
ExpiresOn.Value = ManagementHelper.GetUserDateTime(_CatalogNodeDto.CatalogNode[0].EndDate);
CodeText.Text = _CatalogNodeDto.CatalogNode[0].Code;
SortOrder.Text = _CatalogNodeDto.CatalogNode[0].SortOrder.ToString();
IsCatalogNodeActive.IsSelected = _CatalogNodeDto.CatalogNode[0].IsActive;
ManagementHelper.SelectListItem(DisplayTemplate, _CatalogNodeDto.CatalogNode[0].TemplateName);
ManagementHelper.SelectListItem(MetaClassList, _CatalogNodeDto.CatalogNode[0].MetaClassId);
}
}
else
{
this.AvailableFrom.Value = DateTime.Now;
this.ExpiresOn.Value = DateTime.Now.AddYears(1);
this.SortOrder.Text = "0";
}
}
/// <summary>
/// Binds the meta classes.
/// </summary>
private void BindMetaclass(string metaClassName)
{
// Bind Meta classes
MetaClass catalogEntry = MetaClass.Load(CatalogContext.MetaDataContext, metaClassName);
ddlMetaClass.Items.Clear();
if (catalogEntry != null)
{
ddlMetaClass.Items.Add(new ListItem("", ""));
MetaClassCollection metaClasses = catalogEntry.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
ddlMetaClass.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Name));
}
ddlMetaClass.DataBind();
}
}
/// <summary>
/// Binds the meta classes.
/// </summary>
private void BindMetaclassList()
{
// Bind Meta classes
MetaClass catalogEntry = MetaClass.Load(CatalogContext.MetaDataContext, "CatalogEntry");
ddlMetaClassList.Items.Clear();
if (catalogEntry != null)
{
//ddlMetaClassList.Items.Add(new ListItem("", "[all]"));
MetaClassCollection metaClasses = catalogEntry.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
ddlMetaClassList.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Id.ToString()));
}
ddlMetaClassList.DataBind();
}
BindFieldList();
}
/// <summary>
/// Binds the type.
/// </summary>
private void BindType()
{
LblType.Visible = false;
ddlType.Visible = false;
if (ddlElement.Items.Count > 0)
{
int SelectedClassId = int.Parse(ddlElement.SelectedValue);
MetaClass mclass = MetaClass.Load(MDContext, SelectedClassId);
if (mclass.ChildClasses != null && mclass.ChildClasses.Count > 0)
{
LblType.Visible = true;
ddlType.Visible = true;
ddlType.Items.Clear();
MetaClassCollection children = mclass.ChildClasses;
foreach (MetaClass child in children)
{
ddlType.Items.Add(new ListItem(child.FriendlyName, child.Id.ToString()));
}
}
if (ddlType.Items.Count > 0)
{
MetaClass mc = null;
if (MetaClassId > 0 && !IsPostBack)
{
mc = MetaClass.Load(MDContext, MetaClassId);
}
if (mc != null)
{
ManagementHelper.SelectListItem(ddlType, MetaClassId.ToString());
BindFields(mc);
}
else
{
ManagementHelper.SelectListItem(ddlType, ddlType.Items[0].Value);
BindFields(MetaClass.Load(MDContext, int.Parse(ddlType.SelectedValue)));
}
}
}
}
/// <summary>
/// Binds the meta classes.
/// </summary>
/// <param name="grid">The grid.</param>
/// <param name="mcNamespace">The mc namespace.</param>
/// <param name="mdpContext">The MDP context.</param>
private void BindMetaClasses(DataGrid grid, string mcNamespace, MetaDataContext mdpContext)
{
if (grid != null)
{
// bind meta data
MetaClassCollection coll = MetaClass.GetList(mdpContext, mcNamespace, true);
string metaClassIdColumn = "MetaClassId";
string metaClassSystemNameColumn = "SystemName";
string metaClassFriendlyNameColumn = "FriendlyName";
DataTable dt = new DataTable();
dt.Columns.Add(metaClassIdColumn, typeof(int));
dt.Columns.Add(metaClassSystemNameColumn, typeof(string));
dt.Columns.Add(metaClassFriendlyNameColumn, typeof(string));
List <int> listIndices = new List <int>();
foreach (MetaClass mc in coll)
{
if (mc.Parent != null)
{
DataRow row = dt.NewRow();
row[metaClassIdColumn] = mc.Id;
row[metaClassFriendlyNameColumn] = mc.FriendlyName;
row[metaClassSystemNameColumn] = mc.Name;
dt.Rows.Add(row);
listIndices.Add(listIndices.Count);
}
}
grid.DataSource = new DataView(dt);
grid.DataBind();
// select all classes
if (grid.Items.Count > 0)
{
((Mediachase.Web.Console.Controls.RowSelectorColumn)grid.Columns[0]).SelectedIndexes = listIndices.ToArray();
}
}
}
/// <summary>
/// Binds the element.
/// </summary>
private void BindElement()
{
DdlObjectType.Items.Clear();
MetaClassCollection coll = MetaClass.GetList(MDContext, Namespace, true);
foreach (MetaClass mc in coll)
{
if (mc.Parent == null)
{
/*if(String.Compare(mc.TableName, "category", true)==0 ||
* String.Compare(mc.TableName, "product", true)==0 ||
* String.Compare(mc.TableName, "sku", true)==0)*/
DdlObjectType.Items.Add(new ListItem(mc.FriendlyName, mc.Id.ToString()));
}
}
/*
* if(DdlObjectType.Items.Count>0)
* Util.CommonHelper.SelectListItem(DdlObjectType, DdlObjectType.Items[0].Value);
* */
}
/// <summary>
/// Checks if entered meta class friendly name is unique for parent meta class.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="System.Web.UI.WebControls.ServerValidateEventArgs"/> instance containing the event data.</param>
public void MetaClassFriendlyNameCheck(object sender, ServerValidateEventArgs args)
{
int parentId = int.Parse(DdlObjectType.SelectedValue);
// load parent meta class
MetaClass mclass = MetaClass.Load(MDContext, parentId);
// check if children meta classes with specified friendly name is loaded
if (mclass.ChildClasses != null && mclass.ChildClasses.Count > 0)
{
MetaClassCollection children = mclass.ChildClasses;
foreach (MetaClass child in children)
{
if (String.Compare(child.FriendlyName, args.Value) == 0)
{
args.IsValid = false;
return;
}
}
}
args.IsValid = true;
}
/// <summary>
/// Loads the specified node uid.
/// </summary>
/// <param name="NodeUid">The node uid.</param>
/// <param name="ControlUid">The control uid.</param>
void IPropertyPage.Load(string NodeUid, string ControlUid)
{
ControlSettings settings = new ControlSettings();
DynamicNode dNode = PageDocument.Current.DynamicNodes.LoadByUID(NodeUid);
if (dNode != null)
{
settings = dNode.GetSettings(NodeUid);
}
// Bind Meta Types
// Bind Meta classes
// MetaDataContext.Current = CatalogContext.MetaDataContext;
MetaClass catalogEntry = MetaClass.Load(CatalogContext.MetaDataContext, "CatalogEntry");
MetaClassList.Items.Clear();
if (catalogEntry != null)
{
MetaClassCollection metaClasses = catalogEntry.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
MetaClassList.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Name));
}
MetaClassList.DataBind();
}
// Bind templates
DisplayTemplate.Items.Clear();
DisplayTemplate.Items.Add(new ListItem("(use default)", ""));
TemplateDto templates = DictionaryManager.GetTemplateDto();
if (templates.main_Templates.Count > 0)
{
DataView view = templates.main_Templates.DefaultView;
view.RowFilter = "TemplateType = 'search-index'";
foreach (DataRowView row in view)
{
DisplayTemplate.Items.Add(new ListItem(row["FriendlyName"].ToString(), row["Name"].ToString()));
}
DisplayTemplate.DataBind();
}
// Bind Types
EntryTypeList.Items.Clear();
EntryTypeList.Items.Add(new ListItem(EntryType.Product, EntryType.Product));
EntryTypeList.Items.Add(new ListItem(EntryType.Package, EntryType.Package));
EntryTypeList.Items.Add(new ListItem(EntryType.Bundle, EntryType.Bundle));
EntryTypeList.Items.Add(new ListItem(EntryType.DynamicPackage, EntryType.DynamicPackage));
EntryTypeList.Items.Add(new ListItem(EntryType.Variation, EntryType.Variation));
EntryTypeList.DataBind();
// Bind catalogs
CatalogList.Items.Clear();
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto(CMSContext.Current.SiteId);
if (catalogs.Catalog.Count > 0)
{
foreach (CatalogDto.CatalogRow row in catalogs.Catalog)
{
if (row.IsActive && row.StartDate <= FrameworkContext.Current.CurrentDateTime && row.EndDate >= FrameworkContext.Current.CurrentDateTime)
{
CatalogList.Items.Add(new ListItem(row.Name, row.Name));
}
}
CatalogList.DataBind();
}
//Bind Depositories
this.ddlDepository.DataSource = Enum.GetNames(typeof(NWTD.InfoManager.Depository));
this.ddlDepository.DataBind();
if (settings != null && settings.Params != null)
{
Param prm = settings.Params;
CommonHelper.LoadTextBox(settings, "NodeCode", NodeCode);
CommonHelper.LoadTextBox(settings, "RecordsPerPage", NumberOfRecords);
/*
* CommonHelper.LoadTextBox(settings, "FTSPhrase", FTSPhrase);
* CommonHelper.LoadTextBox(settings, "AdvancedFTSPhrase", AdvancedFTSPhrase);
* CommonHelper.LoadTextBox(settings, "MetaSQLClause", MetaSQLClause);
* CommonHelper.LoadTextBox(settings, "SQLClause", SQLClause);
* */
if ((prm["DisplayTemplate"] != null) && (prm["DisplayTemplate"] is string))
{
CommonHelper.SelectListItem(DisplayTemplate, prm["DisplayTemplate"].ToString());
}
CommonHelper.SelectList(settings, "Catalogs", CatalogList);
CommonHelper.SelectList(settings, "EntryClasses", MetaClassList);
CommonHelper.SelectList(settings, "EntryTypes", EntryTypeList);
// Orderby
if ((prm["OrderBy"] != null) && (prm["OrderBy"] is string))
{
string orderBy = prm["OrderBy"].ToString();
bool isDesc = orderBy.Contains("DESC");
string listOrderBy = orderBy.Replace(" DESC", "");
listOrderBy = listOrderBy.Replace(" ASC", "");
CommonHelper.SelectListItem(OrderByList, listOrderBy);
if (!String.IsNullOrEmpty(OrderByList.SelectedValue))
{
if (OrderByList.SelectedValue == "custom")
{
OrderBy.Text = orderBy;
}
else
{
OrderDesc.Checked = isDesc;
}
}
}
if (prm[DEPOSITORY_KEY] == null)
{
prm[DEPOSITORY_KEY] = NWTD.InfoManager.Depository.NWTD.ToString();
}
this.ddlDepository.SelectedValue = settings.Params[DEPOSITORY_KEY].ToString();
}
}
/// <summary>
/// Binds the form.
/// </summary>
/// <param name="reset">if set to <c>true</c> [reset].</param>
private void BindForm(bool reset)
{
if (String.IsNullOrEmpty(SelectedPaymentStatusField.Value))
{
SelectedPaymentStatusField.Value = PaymentStatus.SelectedValue;
}
// Bind Meta classes
if (!IsPostBack || reset)
{
MetaClass paymentMetaClass = MetaClass.Load(OrderContext.MetaDataContext, "OrderFormPayment");
PaymentType.Items.Clear();
if (paymentMetaClass != null)
{
MetaClassCollection metaClasses = paymentMetaClass.ChildClasses;
foreach (MetaClass metaClass in metaClasses)
{
PaymentType.Items.Add(new ListItem(metaClass.FriendlyName, metaClass.Id.ToString()));
}
//PaymentType.DataBind();
PaymentType.Items[0].Selected = true;
}
}
PaymentMethodList.DataSource = PaymentManager.GetPaymentMethods(CommonSettingsManager.GetDefaultLanguage());
PaymentMethodList.DataBind();
if (SelectedPayment != null)
{
if (reset)
{
Amount.Text = SelectedPayment.Amount.ToString("#0.00");
Name.Text = SelectedPayment.PaymentMethodName;
//SelectedPaymentStatusField.Value = selectedPayment.Status;
}
ManagementHelper.SelectListItem(PaymentStatus, SelectedPayment.Status);
ManagementHelper.SelectListItem(PaymentType, SelectedPayment.MetaClass.Id);
ManagementHelper.SelectListItem(PaymentMethodList, SelectedPayment.PaymentMethodId);
MetaDataTab.ObjectId = SelectedPayment.PaymentId;
}
else if (reset)
{
Amount.Text = 0.ToString("#0.00");
Name.Text = "";
//SelectedPaymentStatusField.Value = PaymentStatus.SelectedValue;
}
if (String.IsNullOrEmpty(SelectedPaymentTypeField.Value))
{
SelectedPaymentTypeField.Value = PaymentType.SelectedValue;
}
if (String.IsNullOrEmpty(SelectedPaymentMethodField.Value))
{
SelectedPaymentMethodField.Value = PaymentMethodList.SelectedValue;
}
// Bind Meta Form
BindMetaForm();
}
private void DeleteAllMetaClasses(bool doDelete, ClearCatalogAndModelsResult result)
{
MetaDataContext metaDataContext = new MetaDataContext();
MetaClassCollection metaClassCollection = MetaClass.GetList(metaDataContext);
List <string> logList = new List <string>();
foreach (MetaClass metaClass in metaClassCollection)
{
if (doDelete && metaClass.IsSystem == false)
{
_log.DebugFormat("Deleting class: {0} - {1} (System: {2})",
metaClass.Name,
metaClass.Id,
metaClass.IsSystem);
try
{
MetaClass.Delete(metaDataContext, metaClass.Id);
result.MetaClassesDeleted++;
}
catch (Exception ex)
{
result.MetaClassesSkipped++;
_log.Error(string.Format("Cannot delete Class: {0} - {1} ({2})", metaClass.Name,
metaClass.Id, ex.Message),
ex);
}
}
else
{
result.MetaClassesSkipped++;
_log.DebugFormat("NOT deleting system class: {0} - {1} (System: {2})",
metaClass.Name,
metaClass.Id,
metaClass.IsSystem);
}
}
// List of meta data fields to keep.
List <string> filterFields = new List <string>()
{
"TrackingNumber",
"AddYourOwn"
};
MetaFieldCollection fields = MetaField.GetList(metaDataContext);
foreach (MetaField field in fields)
{
// Do not delete: System fields, filtered fields and fields starting with underscore
if (doDelete &&
field.IsSystem == false &&
filterFields.Contains(field.Name) == false &&
field.Name.StartsWith("_") == false)
{
_log.DebugFormat("Deleting field: {0} - {1} (System: {2})",
field.Name,
field.Id,
field.IsSystem);
try
{
MetaField.Delete(metaDataContext, field.Id);
result.MetaFieldsDeleted++;
}
catch (Exception ex)
{
result.MetaFieldsSkipped++;
_log.Error(string.Format("Cannot delete Field: {0} - {1} ({2})",
field.Name,
field.Id, ex.Message),
ex);
}
}
else
{
result.MetaFieldsSkipped++;
_log.DebugFormat("NOT deleting field: {0} - {1} (System: {2})",
field.Name,
field.Id,
field.IsSystem);
}
}
}
