/// <summary>
/// Binds the available fields.
/// </summary>
private void BindAvailableFields()
{
DataTable dt = new DataTable();
dt.Columns.Add("MetaFieldId", typeof(int));
dt.Columns.Add("FriendlyName", typeof(string));
// Fields
MetaFieldCollection mfc = MetaField.GetList(MDContext);
foreach (MetaField field in mfc)
{
if (field.IsUser)
{
DataRow row = dt.NewRow();
row["MetaFieldId"] = field.Id;
row["FriendlyName"] = field.FriendlyName;
dt.Rows.Add(row);
}
}
/*
* ItemsGrid.DataSource = new DataView(dt);
* ItemsGrid.DataBind();
* */
}
private void BindAvailableFields()
{
DataTable dt = new DataTable();
dt.Columns.Add("FieldId", typeof(int));
dt.Columns.Add("FriendlyName", typeof(string));
dt.Columns.Add("Description", typeof(string));
dt.Columns.Add("DataType", typeof(string));
dt.Columns.Add("DataTypeId", typeof(int));
dt.Columns.Add("sortDataType", typeof(int));
dt.Columns.Add("CanDelete", typeof(bool));
MetaFieldCollection mfc = MetaField.GetList(MetaDataPlus.MetaNamespace.UserRoot, true);
DataRow row;
foreach (MetaField field in mfc)
{
bool fl = true;
if (ddlShow.SelectedValue == "1" && field.OwnerMetaClassIdList.Count == 0)
fl = false;
if (ddlShow.SelectedValue == "-1" && field.OwnerMetaClassIdList.Count != 0)
fl = false;
if (fl)
{
row = dt.NewRow();
row["FieldId"] = field.Id;
row["FriendlyName"] = field.FriendlyName;
row["Description"] = field.Description;
MetaType mdType = MetaType.Load(field.DataType);
row["DataType"] = mdType.FriendlyName;
int iType = mdType.Id;
if (mdType.MetaDataType == MetaDataType.DictionaryMultivalue ||
mdType.MetaDataType == MetaDataType.DictionarySingleValue ||
mdType.MetaDataType == MetaDataType.EnumMultivalue ||
mdType.MetaDataType == MetaDataType.EnumSingleValue ||
mdType.MetaDataType == MetaDataType.StringDictionary)
iType = 0;
row["DataTypeId"] = iType;
row["sortDataType"] = GetSortDataType(mdType);
row["CanDelete"] = (field.OwnerMetaClassIdList.Count == 0);
dt.Rows.Add(row);
}
}
DataView dv = dt.DefaultView;
if (pc["Cust_AvailableFields_Sort"] == null)
pc["Cust_AvailableFields_Sort"] = "sortDataType";
dv.Sort = pc["Cust_AvailableFields_Sort"];
if (int.Parse(ddlType.SelectedValue) >= 0)
dv.RowFilter = "DataTypeId = " + ddlType.SelectedValue;
dgAvailableFields.DataSource = dv;
dgAvailableFields.DataBind();
foreach (DataGridItem dgi in dgAvailableFields.Items)
{
ImageButton ib = (ImageButton)dgi.FindControl("ibDelete");
if (ib != null)
ib.Attributes.Add("onclick", "return confirm('" + LocRM.GetString("DeleteWarning") + "')");
}
}
private static Type GetMetaFieldType(string fieldName, out MetaField field)
{
var metaContext = OrderContext.MetaDataContext;
field = MetaField.GetList(metaContext).FirstOrDefault(x => x.Name == fieldName);
if (field == null)
{
return(null);
}
var metaDataType = field.DataType;
switch (metaDataType)
{
case MetaDataType.BigInt:
case MetaDataType.Decimal:
case MetaDataType.Money:
case MetaDataType.SmallMoney:
return(typeof(decimal));
case MetaDataType.Bit:
case MetaDataType.Char:
case MetaDataType.Int:
case MetaDataType.SmallInt:
case MetaDataType.TinyInt:
case MetaDataType.Integer:
return(typeof(int));
case MetaDataType.DateTime:
case MetaDataType.SmallDateTime:
case MetaDataType.Date:
return(typeof(DateTime));
case MetaDataType.Float:
case MetaDataType.Real:
return(typeof(double));
case MetaDataType.NChar:
case MetaDataType.NText:
case MetaDataType.NVarChar:
case MetaDataType.Text:
case MetaDataType.VarChar:
case MetaDataType.LongString:
case MetaDataType.Email:
case MetaDataType.URL:
case MetaDataType.ShortString:
case MetaDataType.LongHtmlString:
return(typeof(string));
case MetaDataType.Boolean:
return(typeof(bool));
default:
return(null);
}
}
/// <summary>
/// Binds the items grid.
/// </summary>
/// <param name="id">The id.</param>
private void BindItemsGrid(int id)
{
DataTable dt = new DataTable();
dt.Columns.Add("MetaFieldId", typeof(int));
dt.Columns.Add("FriendlyName", typeof(string));
// Fields
MetaFieldCollection mfc = MetaField.GetList(MDContext /*Namespace, true*/); // allow sharing meta fields
foreach (MetaField field in mfc)
{
if (field.IsUser)
{
DataRow row = dt.NewRow();
row["MetaFieldId"] = field.Id;
row["FriendlyName"] = field.FriendlyName;
dt.Rows.Add(row);
}
}
ItemsGrid.DataSource = new DataView(dt);
ItemsGrid.DataBind();
if (id > 0)
{
ArrayList list = new ArrayList();
MetaFieldCollection mfc2 = MetaField.GetList(MDContext, id);
foreach (MetaField mf in mfc2)
{
if (mf.IsUser)
{
for (int i = 0; i < ItemsGrid.Items.Count; i++)
{
if ((int)ItemsGrid.DataKeys[i] == mf.Id)
{
list.Add(i);
TextBox box = (TextBox)ItemsGrid.Items[i].FindControl("Weight");
box.Text = mf.Weight.ToString();
}
}
}
}
((Mediachase.Web.Console.Controls.RowSelectorColumn)ItemsGrid.Columns[0]).SelectedIndexes = (int[])list.ToArray(typeof(int));
}
}
/// <summary>
/// Backups the meta data.
/// </summary>
private static void BackupMetaData()
{
ArrayList list = new ArrayList();
foreach (MetaClass cl in MetaClass.GetList(OrderContext.MetaDataContext))
{
list.Add(cl);
}
foreach (MetaField field in MetaField.GetList(OrderContext.MetaDataContext))
{
if (!field.IsSystem)
{
list.Add(field);
}
}
MetaInstaller.Backup("OrderSystem.mdp", list.ToArray());
}
private void CreateMetaField(MetaFieldInfo fieldInfo)
{
var metaContext = OrderContext.MetaDataContext;
if (MetaField.GetList(metaContext).Any(x => x.Name == fieldInfo.Name))
{
return;
}
MetaField.Create(
metaContext,
fieldInfo.MetaNamespace,
fieldInfo.Name,
fieldInfo.FriendlyName,
fieldInfo.Description,
fieldInfo.MetaFieldType,
fieldInfo.Length,
fieldInfo.IsNullable,
fieldInfo.IsMultiLanguage,
fieldInfo.IsSearchable,
fieldInfo.IsEncrypted);
}
/// <summary>
/// Loads the data and data bind.
/// </summary>
/// <param name="sortExpression">The sort expression.</param>
private void LoadDataAndDataBind(string sortExpression)
{
MyListView.CurrentListView.PrimaryKeyId = EcfListView.MakePrimaryKeyIdString("Id");
MyListView.DataSource = MetaField.GetList(ProfileContext.MetaDataContext, FieldNamespace);
MyListView.DataBind();
}
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);
}
}
}
private MetaField GetMetaField(string name)
{
var metaContext = OrderContext.MetaDataContext;
return(MetaField.GetList(metaContext).FirstOrDefault(x => x.Name == name));
}
/// <summary>
/// Creates the child controls internal.
/// </summary>
private void CreateChildControlsInternal()
{
//if (this.ObjectId > 0)
{
MetaControls.EnableViewState = false;
if (MetaControls.Controls.Count > 0)
{
return;
}
MetaControls.Controls.Clear();
MetaClass mc = MetaClass.Load(this.MDContext, MetaClassId);
if (mc == null)
{
return;
}
Dictionary <string, MetaObject> metaObjects = new Dictionary <string, MetaObject>();
if (_metaObjects != null)
{
metaObjects = _metaObjects;
}
else
{
// cycle through each language and get meta objects
MDContext.UseCurrentUICulture = false;
foreach (string language in Languages)
{
MDContext.UseCurrentUICulture = false;
MDContext.Language = language;
MetaObject metaObj = null;
if (ObjectId > 0)
{
metaObj = MetaObject.Load(MDContext, ObjectId, mc);
if (metaObj == null)
{
metaObj = MetaObject.NewObject(MDContext, ObjectId, MetaClassId, FrameworkContext.Current.Profile.UserName);
metaObj.AcceptChanges(MDContext);
}
}
metaObjects[language] = metaObj;
}
MDContext.UseCurrentUICulture = true;
}
MetaFieldCollection metaFieldsColl = MetaField.GetList(MDContext, MetaClassId);
foreach (MetaField mf in metaFieldsColl)
{
if (mf.IsUser)
{
int index = 0;
foreach (string language in Languages)
{
string controlName = ResolveMetaControl(mc, mf);
Control ctrl = MetaControls.FindControl(mf.Name);
if (ctrl == null)
{
ctrl = Page.LoadControl(controlName);
MetaControls.Controls.Add(ctrl);
}
CoreBaseUserControl coreCtrl = ctrl as CoreBaseUserControl;
if (coreCtrl != null)
{
coreCtrl.MDContext = this.MDContext;
}
//ctrl.ID = String.Format("{0}-{1}", mf.Name, index.ToString());
((IMetaControl)ctrl).MetaField = mf;
if (metaObjects[language] != null && metaObjects[language][mf] != null)
{
((IMetaControl)ctrl).MetaObject = metaObjects[language];
}
((IMetaControl)ctrl).LanguageCode = language;
((IMetaControl)ctrl).ValidationGroup = ValidationGroup;
ctrl.DataBind();
if (!mf.MultiLanguageValue)
{
break;
}
index++;
}
}
}
}
}