Esempio n. 1
0
        /// <summary>
        /// Gets the list.
        /// </summary>
        /// <param name="metaClass">The meta class.</param>
        /// <returns></returns>
        internal static MetaFieldCollection GetList(MetaClass metaClass)
        {
            #region ArgumentNullExceptions
            if (metaClass == null)
            {
                throw new ArgumentNullException("metaClass", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
            }
            #endregion

            MetaFieldCollection retVal = new MetaFieldCollection();

            using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldListByMetaClassId"),
                                                                  new SqlParameter("@MetaClassId", metaClass.Id)))
            {
                while (reader.Read())
                {
                    MetaField newItem = MetaField.Load(metaClass, reader);
                    newItem.SetOwnerMetaClass(metaClass);

                    retVal.Add(newItem);
                }
                reader.Close();
            }

            return(retVal);
        }
Esempio n. 2
0
 public void ReplaceUser(int oldUserId, int newUserId)
 {
     SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure,
                               AsyncResources.GetConstantValue("SP_ReplaceUser"),
                               new SqlParameter("@OldUserId", oldUserId),
                               new SqlParameter("@NewUserId", newUserId));
 }
Esempio n. 3
0
        /// <summary>
        /// Gets the list.
        /// </summary>
        /// <param name="NamespaceItems">The namespace items.</param>
        /// <returns></returns>
        public static MetaFieldCollection GetList(params string[] namespaceItems)
        {
            #region ArgumentNullExceptions
            if (namespaceItems == null)
            {
                throw new ArgumentNullException("NamespaceItems", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
            }
            #endregion

            MetaFieldCollection retVal = new MetaFieldCollection();

            foreach (string Namespace in namespaceItems)
            {
                using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldByNamespace"),
                                                                      new SqlParameter("@Namespace", Namespace), new SqlParameter("@Deep", false)))
                {
                    while (reader.Read())
                    {
                        retVal.Add(MetaField.Load(reader));
                    }
                }
            }

            return(retVal);
        }
Esempio n. 4
0
        /// <summary>
        /// Gets the data reader.
        /// </summary>
        /// <param name="metaClass">The meta class.</param>
        /// <returns></returns>
        public static IDataReader GetDataReader(MetaClass metaClass)
        {
            #region ArgumentNullExceptions
            if (metaClass == null)
            {
                throw new ArgumentNullException("metaClass", AsyncResources.GetConstantValue("ARG_NULL_ERR_MSG"));
            }
            #endregion

            return(GetDataReader(metaClass.Id));
        }
Esempio n. 5
0
        /// <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));
        }
Esempio n. 6
0
        /// <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);
        }
Esempio n. 7
0
        /// <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));
        }
Esempio n. 8
0
        /// <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);
        }
Esempio n. 9
0
        /// <summary>
        /// Deletes at.
        /// </summary>
        /// <param name="Index">The index.</param>
        public void DeleteAt(int index)
        {
            MetaDictionaryItem item = this[index];

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_DeleteMetaDictionary"),
                                      new SqlParameter("@MetaDictionaryId", item.Id)
                                      );

            this.InnerList.RemoveAt(index);

            // Decrease Index
            ReindexItems();
        }
Esempio n. 10
0
        /// <summary>
        /// Adds the specified default value.
        /// </summary>
        /// <param name="DefaultValue">The default value.</param>
        /// <param name="Value">The value.</param>
        /// <param name="DefaultTag">The default tag.</param>
        /// <param name="Tag">The tag.</param>
        /// <returns></returns>
        internal void Insert(int index, string defaultValue, string value, object defaultTag, object tag)
        {
            if (index < 0 && index >= this.Count)
            {
                throw new ArgumentOutOfRangeException("index");
            }

            SqlParameter spDefaultTag = new SqlParameter("@DefaultTag", SqlDbType.Image);

            spDefaultTag.Value = SqlHelper.Null2DBNull(defaultTag);

            SqlParameter spTag = new SqlParameter("@Tag", SqlDbType.Image);

            spTag.Value = SqlHelper.Null2DBNull(tag);

            SqlParameter Retval = new SqlParameter("@Retval", SqlDbType.Int, 4);

            Retval.Direction = ParameterDirection.Output;

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_AddMetaDictionary"),
                                      new SqlParameter("@MetaFieldId", this.OwnerMetaFieldId),
                                      //new SqlParameter("@Language", SqlHelper.Null2DBNull(MetaDataContext.Current.Language)),
                                      //new SqlParameter("@DefaultValue", value),
                                      //spDefaultTag,
                                      new SqlParameter("@Value", value),
                                      spTag,
                                      new SqlParameter("@Index", index),
                                      Retval
                                      );

            MetaDictionaryItem retVal = new MetaDictionaryItem((int)Retval.Value, this.OwnerMetaFieldId, defaultValue, value, index);

            this.InnerList.Insert(index, retVal);

            ReindexItems();
        }
Esempio n. 11
0
        /// <summary>
        /// Reloads the meta dictionary.
        /// </summary>
        void ReloadMetaDictionary()
        {
            using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaDictionary"),
                                                                  new SqlParameter("@MetaFieldId", this.OwnerMetaFieldId)))
            {
                while (reader.Read())
                {
                    MetaDictionaryItem newItem = new MetaDictionaryItem(reader);
                    this.InnerList.Add(newItem);
                }
                reader.Close();
            }

            // ReIndex
            ReindexItems();
        }
Esempio n. 12
0
        /// <summary>
        /// Gets the name of the unique.
        /// </summary>
        /// <param name="Name">The name.</param>
        /// <returns></returns>
        public static string GetUniqueName(string name)
        {
            SqlParameter UniqueName = new SqlParameter("@UniqueName", SqlDbType.NVarChar, 256);

            UniqueName.Direction = ParameterDirection.Output;

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_GetUniqueFieldName"),
                                      new SqlParameter("@Name", name),
                                      UniqueName
                                      );

            return((string)UniqueName.Value);
        }
Esempio n. 13
0
        /// <summary>
        /// Adds the specified default value.
        /// </summary>
        /// <param name="DefaultValue">The default value.</param>
        /// <param name="Value">The value.</param>
        /// <param name="DefaultTag">The default tag.</param>
        /// <param name="Tag">The tag.</param>
        /// <returns></returns>
        internal int Add(string defaultValue, string value, object defaultTag, object tag)
        {
            SqlParameter spDefaultTag = new SqlParameter("@DefaultTag", SqlDbType.Image);

            spDefaultTag.Value = SqlHelper.Null2DBNull(defaultTag);

            SqlParameter spTag = new SqlParameter("@Tag", SqlDbType.Image);

            spTag.Value = SqlHelper.Null2DBNull(tag);

            SqlParameter Retval = new SqlParameter("@Retval", SqlDbType.Int, 4);

            Retval.Direction = ParameterDirection.Output;

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_AddMetaDictionary"),
                                      new SqlParameter("@MetaFieldId", this.OwnerMetaFieldId),
                                      //new SqlParameter("@Language", SqlHelper.Null2DBNull(MetaDataContext.Current.Language)),
                                      //new SqlParameter("@DefaultValue", value),
                                      //spDefaultTag,
                                      new SqlParameter("@Value", value),
                                      spTag,
                                      new SqlParameter("@Index", this.Count),
                                      Retval
                                      );

            MetaDictionaryItem retVal = new MetaDictionaryItem((int)Retval.Value, this.OwnerMetaFieldId, defaultValue, value, this.Count);

            return(this.InnerList.Add(retVal));
        }
Esempio n. 14
0
        public static void Save(Rule rule)
        {
            if (rule == null)
            {
                throw new ArgumentNullException("rule");
            }

            byte[] data        = Serialize(rule);
            int    MetaClassId = MetaClass.Load(rule._innerClassName).Id;

            SqlParameter retVal = new SqlParameter("@RetVal", SqlDbType.Int, 4);

            retVal.Direction = ParameterDirection.Output;

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_UpdateMetaRule"),
                                      new SqlParameter("@RuleId", rule._id),
                                      new SqlParameter("@MetaClassId", MetaClassId),
                                      new SqlParameter("@Data", data),
                                      retVal);

            rule._id = (int)retVal.Value;
        }
Esempio n. 15
0
 /// <summary>
 /// Deletes the specified meta field id.
 /// </summary>
 /// <param name="MetaFieldId">The meta field id.</param>
 public static void Delete(int metaFieldId)
 {
     SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_DeleteMetaField"),
                               new SqlParameter("@MetaFieldId", metaFieldId)
                               );
 }
Esempio n. 16
0
        public static Rule[] GetList(int metaClassId)
        {
            List <Rule> list = new List <Rule>();

            using (IDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaRuleByMetaClassId"), new SqlParameter("@MetaClassId", metaClassId)))
            {
                while (reader.Read())
                {
                    byte[] data   = (byte[])reader["Data"];
                    int    ruleId = (int)reader["RuleId"];

                    Rule rule = Deserialize(data);
                    rule._id = ruleId;

                    list.Add(rule);
                }
                reader.Close();
            }
            return(list.ToArray());
        }
Esempio n. 17
0
        /// <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);
        }
Esempio n. 18
0
        /// <summary>
        /// Deletes the specified meta dictionary id.
        /// </summary>
        /// <param name="MetaDictionaryId">The meta dictionary id.</param>
        public void Delete(int metaDictionaryId)
        {
            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_DeleteMetaDictionary"),
                                      new SqlParameter("@MetaDictionaryId", metaDictionaryId)
                                      );
            foreach (MetaDictionaryItem item in this)
            {
                if (item.Id == metaDictionaryId)
                {
                    this.InnerList.Remove(item);
                    break;
                }
            }

            ReindexItems();
        }
Esempio n. 19
0
        public static void CleanupLocalDiskStorage()
        {
            if (MetaDataContext.Current.MetaFileDataStorageType == MetaFileDataStorageType.DataBase)
            {
                return;
            }

            string[] FileList = Directory.GetFiles(MetaDataContext.Current.LocalDiskStorage, "*.mdpdata");

            foreach (string fileName in FileList)
            {
                bool bGoodFile = false;

                try
                {
                    int MetaKey = int.Parse(System.IO.Path.GetFileNameWithoutExtension(fileName), _culture);

                    using (IDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_GetMetaKeyInfo"),
                                                                        new SqlParameter("@MetaKey", MetaKey)))
                    {
                        if (reader.Read())
                        {
                            bGoodFile = true;
                        }
                    }
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Trace.WriteLine(ex);
                }

                if (!bGoodFile)
                {
                    try
                    {
                        File.Delete(fileName);
                    }
                    catch (Exception ex)
                    {
                        System.Diagnostics.Trace.WriteLine(ex);
                    }
                }
            }
        }
Esempio n. 20
0
        /// <summary>
        /// Adds the specified key.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="value">The value.</param>
        public virtual void Add(string key, string value)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            key = key.ToLower(CultureInfo.InvariantCulture);

            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_AddMetaAttribute"),
                                      new SqlParameter("@AttrOwnerId", this._OwnerId),
                                      new SqlParameter("@AttrOwnerType", (int)this._OwnerType),
                                      new SqlParameter("@Key", key),
                                      new SqlParameter("@Value", value));

            this.contents.Add(key, value);
        }
Esempio n. 21
0
 /// <summary>
 /// Gets the data reader.
 /// </summary>
 /// <param name="MetaClassId">The meta class id.</param>
 /// <returns></returns>
 public static IDataReader GetDataReader(int metaClassId)
 {
     return((IDataReader)SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldListByMetaClassId"), new SqlParameter("@MetaClassId", metaClassId)));
 }
Esempio n. 22
0
        /// <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);
        }
Esempio n. 23
0
 /// <summary>
 /// Gets the data reader.
 /// </summary>
 /// <returns></returns>
 public static IDataReader GetDataReader()
 {
     return(SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaFieldList")));
 }
Esempio n. 24
0
        /// <summary>
        /// Clears this instance.
        /// </summary>
        public virtual void Clear()
        {
            SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_DeleteMetaAttribute"),
                                      new SqlParameter("@AttrOwnerId", _OwnerId),
                                      new SqlParameter("@AttrOwnerType", (int)_OwnerType));

            this.contents.Clear();
        }
Esempio n. 25
0
        public static void MetaFileCopyToLocalDisk(string path)
        {
            using (IDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("mdpsp_sys_LoadMetaFileList")))
            {
                while (reader.Read())
                {
                    byte[] Data = (byte[])(SqlHelper.DBNull2Null(reader["Data"]));

                    using (FileStream stream = File.OpenWrite(System.IO.Path.Combine(path, string.Format(_culture, "{0}.mdpdata", (int)reader["MetaKey"]))))
                    {
                        stream.Write(Data, 0, Data.Length);
                        stream.Flush();
                    }
                }
            }
        }
Esempio n. 26
0
        public static MetaTypeCollection GetSqlMetaTypes()
        {
            MetaTypeCollection retVal = new MetaTypeCollection();

            using (SqlDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaTypeList")))
            {
                while (reader.Read())
                {
                    MetaType newType = MetaType.Load(reader);
                    if (newType.IsSqlCommonType)
                    {
                        retVal.Add(newType);
                    }
                }
                reader.Close();
            }

            return(retVal);
        }
Esempio n. 27
0
        public static void MetaFileCopyToDataBase(string path)
        {
            foreach (string fileName in Directory.GetFiles(path, "*.mdpdata"))
            {
                try
                {
                    int MetaKey = int.Parse(System.IO.Path.GetFileNameWithoutExtension(fileName), _culture);

                    string FilePath = System.IO.Path.Combine(path, fileName);

                    using (FileStream stream = File.OpenRead(FilePath))
                    {
                        using (IDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_GetMetaKeyInfo"),
                                                                            new SqlParameter("@MetaKey", MetaKey)))
                        {
                            if (reader.Read())
                            {
                                byte[] Buffer = new byte[stream.Length];
                                stream.Read(Buffer, 0, Buffer.Length);

                                //int MetaClassId = (int)reader["MetaClassId"];
                                //int MetaFieldId = (int)reader["MetaFieldId"];
                                //int MetaObjectId = (int)reader["MetaObjectId"];

                                SqlParameter spData = new SqlParameter("@Data", SqlDbType.Image);
                                spData.Value = SqlHelper.Null2DBNull(Buffer);

                                // Step 3. Save new values [11/30/2004]
                                SqlHelper.ExecuteNonQuery(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_UpdateMetaFile"),
                                                          new SqlParameter("@MetaKey", MetaKey),
                                                          new SqlParameter("@FileName", fileName),
                                                          new SqlParameter("@ContentType", string.Empty),
                                                          new SqlParameter("@Size", stream.Length),
                                                          spData,
                                                          new SqlParameter("@CreationTime", File.GetCreationTime(FilePath)),
                                                          new SqlParameter("@LastReadTime", File.GetLastAccessTime(FilePath)),
                                                          new SqlParameter("@LastWriteTime", File.GetLastWriteTime(FilePath)));
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Trace.WriteLine(ex);
                }
            }
        }
Esempio n. 28
0
        public static Rule Load(int ruleId)
        {
            Rule retVal = null;

            using (IDataReader reader = SqlHelper.ExecuteReader(MetaDataContext.Current, CommandType.StoredProcedure, AsyncResources.GetConstantValue("SP_LoadMetaRuleById"),
                                                                new SqlParameter("@RuleId", ruleId)))
            {
                if (reader.Read())
                {
                    byte[] data = (byte[])reader["Data"];

                    retVal = Deserialize(data);

                    retVal._id = (int)reader["RuleId"];
                }
                reader.Close();
            }
            return(retVal);
        }