public HttpResponseMessage RemoveField(int metaClassId, int fieldId)
{
MetaDataContext context = MetaDataContext.Instance;
Mediachase.MetaDataPlus.Configurator.MetaClass metaClass = Mediachase.MetaDataPlus.Configurator.MetaClass.Load(context, metaClassId);
if (metaClass == null)
{
HttpResponseMessage errorResponse = Request.CreateResponse <string>(HttpStatusCode.NotFound, "Meta Class with id " + metaClassId + " could not be loaded.", "application/json");
return(errorResponse);
}
MetaField field = MetaField.Load(MetaDataContext.Instance, fieldId);
if (field == null)
{
HttpResponseMessage errorResponse = Request.CreateResponse <string>(HttpStatusCode.NotFound, "Meta Class with id " + metaClassId + " could not be loaded.", "application/json");
return(errorResponse);
}
metaClass.DeleteField(field);
string message = JsonConvert.SerializeObject(new
{
Message = string.Format("Removed Meta Field '{0}' from Meta Class '{1}'", field.Name, metaClass.Name),
MetaClassName = metaClass.Name,
MetaFieldName = field.Name
});
HttpResponseMessage response = Request.CreateResponse <string>(HttpStatusCode.OK, "");
response.Content = new StringContent(message);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(response);
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="Description">The description.</param>
/// <param name="DataType">Type of the data.</param>
/// <returns></returns>
public static MetaField Create(
string name,
string friendlyName,
string description,
MetaDataType dataType)
{
return(MetaField.Create(MetaNamespace.UserRoot, name, friendlyName, description, dataType, 0));
}
public virtual void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = Mediachase.MetaDataPlus.Configurator.MetaClass.Load(mdContext, metaClassName);
if (IsMetaFieldConnected(field, cls) == false)
{
cls.AddField(field);
}
}
/// <summary>
/// Add field to meta class
/// </summary>
/// <param name="mdContext"></param>
/// <param name="field"></param>
/// <param name="metaClassName"></param>
private void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
/// <summary>
/// Loads the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public static MetaDictionary Load(MetaField field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
return(MetaDictionary.Load(field.Id));
}
public ColumnInfo(MetaField field, FillTypes fillType, bool isSystemDictionary)
{
if (field == null)
throw new ArgumentNullException("field");
_field = field;
_fillType = fillType;
_isSystemDictionary = isSystemDictionary & field.IsSystem;
}
private static void BackupMetaField(XmlNode root, MetaField mf)
{
if (root == null)
{
throw new ArgumentNullException("root");
}
if (mf == null)
{
throw new ArgumentNullException("mf");
}
XmlDocumentFragment xmlMetaField = root.OwnerDocument.CreateDocumentFragment();
xmlMetaField.InnerXml = "<MetaField><Namespace></Namespace><Name></Name><FriendlyName></FriendlyName><Description></Description><DataType></DataType><Length></Length><AllowNulls></AllowNulls><SaveHistory></SaveHistory><AllowSearch></AllowSearch><MultiLanguageValue></MultiLanguageValue><Tag></Tag></MetaField>";
xmlMetaField.SelectSingleNode("MetaField/Namespace").InnerXml = mf.Namespace;
xmlMetaField.SelectSingleNode("MetaField/Name").InnerXml = mf.Name;
xmlMetaField.SelectSingleNode("MetaField/FriendlyName").InnerXml = mf.FriendlyName;
xmlMetaField.SelectSingleNode("MetaField/Description").InnerXml = mf.Description;
xmlMetaField.SelectSingleNode("MetaField/DataType").InnerXml = mf.DataType.ToString();
xmlMetaField.SelectSingleNode("MetaField/Length").InnerXml = mf.Length.ToString(_culture);
xmlMetaField.SelectSingleNode("MetaField/AllowNulls").InnerXml = mf.AllowNulls.ToString();
xmlMetaField.SelectSingleNode("MetaField/SaveHistory").InnerXml = mf.SaveHistory.ToString();
xmlMetaField.SelectSingleNode("MetaField/AllowSearch").InnerXml = mf.AllowSearch.ToString();
xmlMetaField.SelectSingleNode("MetaField/MultiLanguageValue").InnerXml = mf.MultilanguageValue.ToString();
if (mf.Tag != null)
{
xmlMetaField.SelectSingleNode("MetaField/Tag").InnerXml = Convert.ToBase64String((byte[])mf.Tag);
}
if (mf.OwnerMetaClassIdList.Count > 0)
{
foreach (int MetaClassId in mf.OwnerMetaClassIdList)
{
MetaClass mc = MetaClass.Load(MetaClassId);
XmlNode xmlOwnerMetaClass = (XmlNode)root.OwnerDocument.CreateElement("OwnerMetaClass");
xmlOwnerMetaClass.InnerXml = mc.Name;
xmlMetaField.SelectSingleNode("MetaField").AppendChild(xmlOwnerMetaClass);
}
}
// Dictionary
if (mf.Dictionary != null)
{
foreach (MetaDictionaryItem dicItem in mf.Dictionary)
{
XmlNode xmlDictionaryItem = (XmlNode)root.OwnerDocument.CreateElement("Dictionary");
xmlDictionaryItem.InnerXml = dicItem.Value;
xmlMetaField.SelectSingleNode("MetaField").AppendChild(xmlDictionaryItem);
}
}
root.AppendChild((XmlNode)xmlMetaField);
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="Description">The description.</param>
/// <param name="DataType">Type of the data.</param>
/// <param name="Length">The length.</param>
/// <returns></returns>
public static MetaField Create(
string name,
string friendlyName,
string description,
MetaDataType dataType,
int length)
{
return(MetaField.Create(MetaNamespace.UserRoot, name, friendlyName, description, dataType, length,
true, false, false, false));
}
protected MetaField GetOrCreateCardField(MetaDataContext mdContext, string fieldName, MetaDataType metaDataType = MetaDataType.LongString)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
Logger.Debug($"Adding meta field '{fieldName}' for {IntegrationName} integration.");
f = MetaField.Create(mdContext, Common.Constants.OrderNamespace, fieldName, fieldName, string.Empty, metaDataType, Int32.MaxValue, true, false, false, false);
}
return(f);
}
/// <summary>
/// Loads the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public static MetaField Load(SqlDataReader reader)
{
#region ArgumentNullExceptions
if (reader == null)
{
throw new ArgumentNullException("reader", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
#endregion
return(MetaField.Load(null, reader));
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <param name="FriendlyName">Name of the friendly.</param>
/// <param name="Description">The description.</param>
/// <param name="DataType">Type of the data.</param>
/// <param name="AllowNulls">if set to <c>true</c> [allow nulls].</param>
/// <param name="SaveHistory">if set to <c>true</c> [save history].</param>
/// <param name="AllowSearch">if set to <c>true</c> [allow search].</param>
/// <returns></returns>
public static MetaField Create(string name,
string friendlyName,
string description,
MetaDataType dataType,
bool allowNulls,
bool saveHistory,
bool allowSearch)
{
return(MetaField.Create(MetaNamespace.UserRoot, name, friendlyName, description, dataType, 0,
allowNulls, saveHistory, false, allowSearch));
}
public virtual MetaField GetOrCreateMetaField(MetaDataContext mdContext, string metaNamespace, string fieldName, string friendlyName, MetaDataType metadataType, bool allowNulls, bool multiLanguage)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
f = MetaField.Create(mdContext, metaNamespace, fieldName, friendlyName, string.Empty, metadataType, 0, allowNulls, multiLanguage, false, false);
}
return(f);
}
/// <summary>
/// Get or create card field
/// </summary>
/// <param name="mdContext"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
private MetaField GetOrCreateCardField(MetaDataContext mdContext, string fieldName)
{
var f = MetaField.Load(mdContext, fieldName);
if (f == null)
{
Logger.Debug(string.Format("Adding meta field '{0}' for Netaxept integration.", fieldName));
f = MetaField.Create(mdContext, NetaxeptConstants.OrderNamespace, fieldName, fieldName, string.Empty, MetaDataType.LongString, Int32.MaxValue, true, false, false, false);
}
return(f);
}
public static void Backup(XmlNode destNode, params object[] selected)
{
if (destNode == null)
{
throw new ArgumentNullException("destNode");
}
if (selected == null)
{
throw new ArgumentNullException("selected");
}
XmlDocument ownerDocument = destNode as XmlDocument;
if (ownerDocument == null)
{
ownerDocument = destNode.OwnerDocument;
}
XmlNode xmlMetaDataPlusBackup = ownerDocument.CreateElement("MetaDataPlusBackup");
XmlAttribute xmlMDPBVersion = ownerDocument.CreateAttribute("version");
xmlMDPBVersion.Value = "1.0";
xmlMetaDataPlusBackup.Attributes.Append(xmlMDPBVersion);
#region -- Backup Meta Classes --
foreach (object metaElement in selected)
{
MetaClass mc = metaElement as MetaClass;
if (mc != null)
{
if (mc.Parent != null && xmlMetaDataPlusBackup.SelectSingleNode(string.Format(_culture, "MetaClass[Name='{0}']", mc.Parent.Name)) == null)
{
BackupMetaClass(xmlMetaDataPlusBackup, mc.Parent);
}
BackupMetaClass(xmlMetaDataPlusBackup, mc);
}
}
#endregion
#region -- Backup Meta Fields --
foreach (object metaElement in selected)
{
MetaField mf = metaElement as MetaField;
if (mf != null)
{
BackupMetaField(xmlMetaDataPlusBackup, mf);
}
}
#endregion
destNode.AppendChild(xmlMetaDataPlusBackup);
}
private void JoinField(MetaDataContext mdContext, MetaField field, IEnumerable<string> metaClassNames)
{
foreach (var metaClassName in metaClassNames)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
}
/// <summary>
/// Determines whether [contains] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns>
/// <c>true</c> if [contains] [the specified field]; otherwise, <c>false</c>.
/// </returns>
public bool Contains(MetaField field)
{
if (field == null)
throw new ArgumentNullException("field");
foreach (MetaField item in this)
{
if (item.Id == field.Id)
return true;
}
return false;
}
public RuleItem(string srcColumnName, Type srcColumnType, MetaField destColumn, FillTypes fillType, string customValue)
{
if (destColumn == null)
throw new ArgumentNullException("destColumn");
_srcColumnName = srcColumnName;
_srcColumnType = srcColumnType;
_destColumnName = destColumn.Name;
_destColumnType = destColumn.DataType;
_destColumnSystem = destColumn.IsSystem;
_fillType = fillType;
_customValue = customValue;
}
/// <summary>
/// Creates the virtual.
/// </summary>
/// <param name="metaNamespace">The namespace.</param>
/// <param name="name">The name.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="description">The description.</param>
/// <param name="dataType">Type of the data.</param>
/// <param name="length">The length.</param>
/// <param name="allowNulls">if set to <c>true</c> [allow nulls].</param>
/// <param name="saveHistory">if set to <c>true</c> [save history].</param>
/// <param name="multilanguageValue">if set to <c>true</c> [multi language value].</param>
/// <param name="allowSearch">if set to <c>true</c> [allow search].</param>
/// <returns></returns>
public static MetaField CreateVirtual(
string metaNamespace,
string name,
string friendlyName,
string description,
MetaDataType dataType,
int length,
bool allowNulls,
bool saveHistory,
bool multilanguageValue,
bool allowSearch)
{
#region ArgumentNullExceptions
if (metaNamespace == null)
{
throw new ArgumentNullException("Namespace", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
if (name == null)
{
throw new ArgumentNullException("Name", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
if (friendlyName == null)
{
throw new ArgumentNullException("FriendlyName", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
#endregion
MetaField retVal = new MetaField();
// Load MetaField Information [11/18/2004]
retVal._id = -1;
retVal._namespace = metaNamespace;
retVal._name = name;
retVal._friendlyName = friendlyName;
retVal._description = description;
retVal._dataType = dataType;
retVal._length = length;
retVal._allowNulls = allowNulls;
retVal._saveHistory = saveHistory;
retVal._multilanguageValue = multilanguageValue;
retVal._allowSearch = allowSearch;
retVal._systemMetaClassId = -1;
return(retVal);
}
/// <summary>
/// Gets the list.
/// </summary>
/// <returns></returns>
public static MetaFieldCollection GetList()
{
MetaFieldCollection retVal = new MetaFieldCollection();
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldList")))
{
while (reader.Read())
{
MetaField newItem = MetaField.Load(reader);
retVal.Add(newItem);
}
reader.Close();
}
return(retVal);
}
/// <summary>
/// Loads the specified meta field id.
/// </summary>
/// <param name="MetaFieldId">The meta field id.</param>
/// <returns></returns>
public static MetaField Load(int metaFieldId)
{
MetaField retVal = null;
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaField"),
new SqlParameter("@MetaFieldId", metaFieldId)))
{
if (reader.Read())
{
retVal = MetaField.Load(reader);
}
reader.Close();
}
return(retVal);
}
/// <summary>
/// Indexes the of.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public int IndexOf(MetaField field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
for (int Index = 0; Index < this.Count; Index++)
{
if (this[Index].Id == field.Id)
{
return(Index);
}
}
return(-1);
}
/// <summary>
/// Determines whether [contains] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns>
/// <c>true</c> if [contains] [the specified field]; otherwise, <c>false</c>.
/// </returns>
public bool Contains(MetaField field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
foreach (MetaField item in this)
{
if (item.Id == field.Id)
{
return(true);
}
}
return(false);
}
private static void RestoreFromVersion10(XmlNode root)
{
#region -- Restore Meta Classes --
XmlNodeList xmlMetaClassList = root.SelectNodes("MetaClass");
foreach (XmlNode xmlMetaClass in xmlMetaClassList)
{
string ParentClass = xmlMetaClass.SelectSingleNode("ParentClass").InnerXml;
MetaClass parent = null;
if (!string.IsNullOrEmpty(ParentClass))
{
parent = MetaClass.Load(ParentClass);
if (parent == null)
{
XmlNode xmlParentMetaClass = root.SelectSingleNode(string.Format(_culture, "MetaClass[Name='{0}']", ParentClass));
parent = LoadMetaClassVersion10(xmlParentMetaClass, null);
}
}
LoadMetaClassVersion10(xmlMetaClass, parent);
}
#endregion
#region -- Restore Meta Fields --
XmlNodeList xmlMetaFieldList = root.SelectNodes("MetaField");
foreach (XmlNode xmlMetaField in xmlMetaFieldList)
{
MetaField mf = LoadMetaFieldVersion10(xmlMetaField);
XmlNodeList xmlOwnerMetaClassList = xmlMetaField.SelectNodes("OwnerMetaClass");
foreach (XmlNode xmlOwnerMetaClass in xmlOwnerMetaClassList)
{
MetaClass ownerMC = MetaClass.Load(xmlOwnerMetaClass.InnerXml);
if (!ownerMC.MetaFields.Contains(mf))
{
ownerMC.AddField(mf);
}
}
}
#endregion
}
/// <summary>
/// Creates the specified namespace.
/// </summary>
/// <param name="metaNamespace">The namespace.</param>
/// <param name="name">The name.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="description">The description.</param>
/// <param name="dataType">Type of the data.</param>
/// <param name="length">The length.</param>
/// <param name="allowNulls">if set to <c>true</c> [allow nulls].</param>
/// <param name="saveHistory">if set to <c>true</c> [save history].</param>
/// <param name="multilanguageValue">if set to <c>true</c> [multilanguage value].</param>
/// <param name="allowSearch">if set to <c>true</c> [allow search].</param>
/// <returns></returns>
public static MetaField Create(
string metaNamespace,
string name,
string friendlyName,
string description,
MetaDataType dataType,
int length,
bool allowNulls,
bool saveHistory,
bool multilanguageValue,
bool allowSearch)
{
#region ArgumentNullExceptions
if (metaNamespace == null)
{
throw new ArgumentNullException("Namespace", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
if (name == null)
{
throw new ArgumentNullException("Name", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
if (friendlyName == null)
{
throw new ArgumentNullException("FriendlyName", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
#endregion
SqlParameter Retval = new SqlParameter("@Retval", SqlDbType.Int, 4);
Retval.Direction = ParameterDirection.Output;
SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_AddMetaField"),
new SqlParameter("@Namespace", metaNamespace),
new SqlParameter("@Name", name),
new SqlParameter("@FriendlyName", friendlyName),
new SqlParameter("@Description", description),
new SqlParameter("@DataTypeId", (int)dataType),
new SqlParameter("@Length", length),
new SqlParameter("@AllowNulls", allowNulls),
new SqlParameter("@SaveHistory", saveHistory),
//new SqlParameter("@MultiLanguageValue", multilanguageValue),
new SqlParameter("@AllowSearch", allowSearch),
Retval
);
return(MetaField.Load((int)Retval.Value));
}
public MetaField(Mediachase.MetaDataPlus.Configurator.MetaField metaField)
{
Id = metaField.Id;
IsSystem = metaField.IsSystem;
Name = metaField.Name;
Description = metaField.Description;
FriendlyName = metaField.FriendlyName;
IsUser = metaField.IsUser;
Namespace = metaField.Namespace;
MultiLanguageValue = metaField.MultiLanguageValue;
Tag = metaField.Tag;
Length = metaField.Length;
OwnerMetaClassIdList = metaField.OwnerMetaClassIdList;
SafeAllowSearch = metaField.SafeAllowSearch;
AllowNulls = metaField.AllowNulls;
DataType = metaField.DataType;
DataTypeName = metaField.DataType.ToString();
}
/// <summary>
/// Gets the list.
/// </summary>
/// <param name="Namespace">The namespace.</param>
/// <param name="Deep">if set to <c>true</c> [deep].</param>
/// <returns></returns>
public static MetaFieldCollection GetList(string metaNamespace, bool deep)
{
#region ArgumentNullExceptions
if (metaNamespace == null)
{
throw new ArgumentNullException("Namespace", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
#endregion
MetaFieldCollection retVal = new MetaFieldCollection();
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldByNamespace"),
new SqlParameter("@Namespace", metaNamespace), new SqlParameter("@Deep", deep)))
{
while (reader.Read())
{
retVal.Add(MetaField.Load(reader));
}
}
return(retVal);
}
/// <summary>
/// Loads the specified name.
/// </summary>
/// <param name="Name">The name.</param>
/// <returns></returns>
public static MetaField Load(string name)
{
#region ArgumentNullExceptions
if (name == null)
{
throw new ArgumentNullException("Name", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
}
#endregion
MetaField retVal = null;
using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldByName"),
new SqlParameter("@Name", name)))
{
if (reader.Read())
{
retVal = MetaField.Load(reader);
}
reader.Close();
}
return(retVal);
}
public Int32 GetInt32(MetaField field)
{
return (Int32)this[field];
}
private void JoinField(MetaDataContext mdContext, MetaField field, string metaClassName)
{
var cls = MetaClass.Load(mdContext, metaClassName);
if (MetaFieldIsNotConnected(field, cls))
{
cls.AddField(field);
}
}
/// <summary>
/// Creates the virtual.
/// </summary>
/// <param name="metaNamespace">The namespace.</param>
/// <param name="name">The name.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="description">The description.</param>
/// <param name="dataType">Type of the data.</param>
/// <param name="length">The length.</param>
/// <param name="allowNulls">if set to <c>true</c> [allow nulls].</param>
/// <param name="saveHistory">if set to <c>true</c> [save history].</param>
/// <param name="multilanguageValue">if set to <c>true</c> [multi language value].</param>
/// <param name="allowSearch">if set to <c>true</c> [allow search].</param>
/// <returns></returns>
public static MetaField CreateVirtual(
string metaNamespace,
string name,
string friendlyName,
string description,
MetaDataType dataType,
int length,
bool allowNulls,
bool saveHistory,
bool multilanguageValue,
bool allowSearch)
{
#region ArgumentNullExceptions
if (metaNamespace == null)
throw new ArgumentNullException("Namespace", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
if (name == null)
throw new ArgumentNullException("Name", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
if (friendlyName == null)
throw new ArgumentNullException("FriendlyName", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
MetaField retVal = new MetaField();
// Load MetaField Information [11/18/2004]
retVal._id = -1;
retVal._namespace = metaNamespace;
retVal._name = name;
retVal._friendlyName = friendlyName;
retVal._description = description;
retVal._dataType = dataType;
retVal._length = length;
retVal._allowNulls = allowNulls;
retVal._saveHistory = saveHistory;
retVal._multilanguageValue = multilanguageValue;
retVal._allowSearch = allowSearch;
retVal._systemMetaClassId = -1;
return retVal;
}
/// <summary>
/// Gets the field weight.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public int GetFieldWeight(MetaField field)
{
#region ArgumentNullExceptions
if (field == null)
throw new ArgumentNullException("field", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
return this.GetFieldWeight(field.Id);
}
public static bool IsMetaFieldConnected(MetaField field, Mediachase.MetaDataPlus.Configurator.MetaClass cls)
{
return(cls != null && cls.MetaFields.Contains(field));
}
public RuleItem(string srcColumnName, Type srcColumnType, MetaField destColumn, FillTypes fillType)
: this(srcColumnName, srcColumnType, destColumn, fillType, "")
{
}
/// <summary>
/// Sets the field width.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="Width">if set to <c>true</c> [width].</param>
public void SetFieldWidth(MetaField field, int width)
{
#region ArgumentNullExceptions
if (field == null)
throw new ArgumentNullException("field", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
SetFieldWidth(field.Id, width);
}
public MdpImportException(string message, DataRow row, int rowIndex, RuleItem colMapping, MetaField destField, object errorValue)
: base(message)
{
_row = row;
_rowIndex = rowIndex;
_colMapping = colMapping;
_destField = destField;
if (errorValue != null)
_errorValue = errorValue.ToString();
else _errorValue = "<null>";
_errorInfo = true;
}
private static MetaField LoadMetaFieldVersion10(XmlNode xmlMetaField)
{
string Name = xmlMetaField.SelectSingleNode("Name").InnerXml;
MetaField mf = MetaField.Load(Name);
if (mf == null)
{
mf = MetaField.Create(xmlMetaField.SelectSingleNode("Namespace").InnerXml,
Name,
xmlMetaField.SelectSingleNode("FriendlyName").InnerXml,
xmlMetaField.SelectSingleNode("Description").InnerXml,
(MetaDataType)Enum.Parse(typeof(MetaDataType), xmlMetaField.SelectSingleNode("DataType").InnerXml),
Int32.Parse(xmlMetaField.SelectSingleNode("Length").InnerXml, _culture),
bool.Parse(xmlMetaField.SelectSingleNode("AllowNulls").InnerXml),
bool.Parse(xmlMetaField.SelectSingleNode("SaveHistory").InnerXml),
bool.Parse(xmlMetaField.SelectSingleNode("AllowSearch").InnerXml),
xmlMetaField.SelectSingleNode("MultiLanguageValue") != null?
bool.Parse(xmlMetaField.SelectSingleNode("MultiLanguageValue").InnerXml):
false
);
}
else
{
if (mf.FriendlyName != xmlMetaField.SelectSingleNode("FriendlyName").InnerXml)
{
mf.FriendlyName = xmlMetaField.SelectSingleNode("FriendlyName").InnerXml;
}
if (mf.Description != xmlMetaField.SelectSingleNode("Description").InnerXml)
{
mf.Description = xmlMetaField.SelectSingleNode("Description").InnerXml;
}
if (mf.SaveHistory != bool.Parse(xmlMetaField.SelectSingleNode("SaveHistory").InnerXml))
{
mf.SaveHistory = bool.Parse(xmlMetaField.SelectSingleNode("SaveHistory").InnerXml);
}
if (mf.AllowSearch != bool.Parse(xmlMetaField.SelectSingleNode("AllowSearch").InnerXml))
{
mf.AllowSearch = bool.Parse(xmlMetaField.SelectSingleNode("AllowSearch").InnerXml);
}
}
string strTag = xmlMetaField.SelectSingleNode("Tag").InnerXml;
if (!string.IsNullOrEmpty(strTag))
{
mf.Tag = Convert.FromBase64String(strTag);
}
else
{
mf.Tag = null;
}
// Dictionary
if (mf.Dictionary != null)
{
foreach (XmlNode dicItem in xmlMetaField.SelectNodes("Dictionary"))
{
if (!mf.Dictionary.Contains(dicItem.InnerXml))
{
mf.Dictionary.Add(dicItem.InnerXml);
}
}
}
return(mf);
}
/// <summary>
/// Adds the specified new item.
/// </summary>
/// <param name="newItem">The new item.</param>
internal void Add(MetaField newItem)
{
this.InnerList.Add(newItem);
}
public string GetString(MetaField field)
{
return (string)this[field];
}
private static bool MetaFieldIsNotConnected(MetaField field, MetaClass cls)
{
return cls != null && !cls.MetaFields.Contains(field);
}
public ColumnInfo(MetaField field, FillTypes fillType)
{
_field = field;
_fillType = fillType;
}
public RuleItem(MetaField destColumn, FillTypes fillType)
: this("", typeof(string), destColumn, fillType, "")
{
}
public MetaDictionaryItem GetDictionaryItem(MetaField field)
{
return (MetaDictionaryItem)this[field];
}
/// <summary>
/// Deletes the field.
/// </summary>
/// <param name="field">The field.</param>
public virtual void DeleteField(MetaField field)
{
#region ArgumentNullExceptions
if (field == null)
throw new ArgumentNullException("field", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
this.DeleteField(field.Id);
}
public DateTime GetDateTime(MetaField field)
{
return (DateTime)this[field];
}
public object this[MetaField field]
{
get
{
if (field == null)
throw new ArgumentNullException("field");
return this[field.Name];
}
set
{
if (field == null)
throw new ArgumentNullException("field");
this[field.Name] = value;
}
}
/// <summary>
/// Adds the specified new item.
/// </summary>
/// <param name="newItem">The new item.</param>
internal void Add(MetaField newItem)
{
this.InnerList.Add(newItem);
}
/// <summary>
/// Loads the specified meta class.
/// </summary>
/// <param name="metaClass">The meta class.</param>
/// <param name="reader">The reader.</param>
/// <returns></returns>
protected static MetaField Load(MetaClass metaClass, SqlDataReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
MetaField retVal = new MetaField();
// Load MetaField Information [11/18/2004]
retVal._id = (int)reader["MetaFieldId"];
retVal._namespace = (string)reader["Namespace"];
retVal._name = (string)reader["Name"];
retVal._friendlyName = (string)reader["FriendlyName"];
if (reader["Description"] != DBNull.Value)
retVal._description = (string)reader["Description"];
retVal._dataType = (MetaDataType)reader["DataTypeId"];
retVal._length = (int)reader["Length"];
retVal._allowNulls = (bool)reader["AllowNulls"];
retVal._saveHistory = (bool)reader["SaveHistory"];
//retVal._multilanguageValue = (bool)reader["MultiLanguageValue"];
retVal._allowSearch = (bool)reader["AllowSearch"];
retVal._systemMetaClassId = (int)reader["SystemMetaClassId"];
retVal._tag = SqlHelper.DBNull2Null(reader["Tag"]);
return retVal;
}
/// <summary>
/// Adds the field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="Weight">The weight.</param>
public virtual void AddField(MetaField field, int weight)
{
#region ArgumentNullExceptions
if (field == null)
throw new ArgumentNullException("field", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
if (this.IsSystem)
throw new NotSupportedException(AsyncResources.GetConstantValue("SYS_CLASS_READ_ONLY_ERR_MSG"));
// Solve Meta Field Duplication Problem
MetaFieldCollection tmpCol = this.MetaFields;
SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_AddMetaFieldToMetaClass"),
new SqlParameter("@MetaClassId", this.Id),
new SqlParameter("@MetaFieldId", field.Id),
new SqlParameter("@Weight", weight));
tmpCol.Add(field);
field.SetOwnerMetaClass(this);
ExecuteFieldListChangedSqlScript();
}
protected void Page_Load(object sender, System.EventArgs e)
{
UtilHelper.RegisterCssStyleSheet(Page, "~/Styles/IbnFramework/windows.css");
UtilHelper.RegisterCssStyleSheet(Page, "~/Styles/IbnFramework/Theme.css");
UtilHelper.RegisterScript(Page, "~/Scripts/browser.js");
UtilHelper.RegisterScript(Page, "~/Scripts/buttons.js");
_field = MetaField.Load(GetFieldID());
ApplyLocalization();
if (!Page.IsPostBack)
BindDG();
}
/// <summary>
///
/// </summary>
/// <param name="field"></param>
/// <param name="cls"></param>
/// <returns></returns>
private static bool MetaFieldIsNotConnected(MetaField field, MetaClass cls)
{
return(cls != null && !cls.MetaFields.Contains(field));
}
/// <summary>
/// Loads the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public static MetaDictionary Load(MetaField field)
{
if (field == null)
throw new ArgumentNullException("field");
return MetaDictionary.Load(field.Id);
}
public MetaStringDictionary GetStringDictionary(MetaField field)
{
return (MetaStringDictionary)this[field];
}
/// <summary>
/// Indexes the of.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public int IndexOf(MetaField field)
{
if (field == null)
throw new ArgumentNullException("field");
for (int Index = 0; Index < this.Count; Index++)
{
if (this[Index].Id == field.Id)
return Index;
}
return -1;
}
public MetaFile GetFile(MetaField field)
{
return (MetaFile)this[field];
}
public MetaDictionaryItem[] GetDictionaryItems(MetaField field)
{
return (MetaDictionaryItem[])this[field];
}
public MetaObject GetMetaObject(MetaField field)
{
return (MetaObject)this[field];
}
public void SetFieldIsRequired(MetaField field, bool isRequired)
{
#region ArgumentNullExceptions
if (field == null)
throw new ArgumentNullException("field", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
#endregion
SetFieldIsRequired(field.Id, isRequired);
}
