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> /// 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); }