/// <summary>
        /// Only support the ComboBox control from WinForm/Visual WebGUI
        /// </summary>
        /// <param name="ddList">the ComboBox control from WinForm/Visual WebGUI</param>
        /// <param name="TextField">e.g. new string[]{"FieldName1", "FieldName2", ...}</param>
        /// <param name="TextFormatString">e.g. "{0} - {1}"</param>
        /// <param name="SwitchLocale">Can be localized, if the FieldName has locale suffix, e.g. '_chs'</param>
        /// <param name="BlankLine">add blank label text to ComboBox or not</param>
        /// <param name="BlankLineText">the blank label text</param>
        /// <param name="ParentFilter">e.g. "ForeignFieldName = 'value'"</param>
        /// <param name="WhereClause">Where Clause for SQL Statement. e.g. "FieldName = 'SomeCondition'"</param>
        /// <param name="OrderBy">Sorting order, string array, e.g. {"FieldName1", "FiledName2"}</param>
        public static void LoadCombo(ref ComboBox ddList, string [] TextField, string TextFormatString, bool SwitchLocale, bool BlankLine, string BlankLineText, string ParentFilter, string WhereClause, string[] OrderBy)
        {
            if (SwitchLocale)
            {
                TextField = GetSwitchLocale(TextField);
            }
            ddList.Items.Clear();

            ProductPeriodicSummaryCollection source;

            if (OrderBy == null || OrderBy.Length == 0)
            {
                OrderBy = TextField;
            }

            if (WhereClause.Length > 0)
            {
                source = ProductPeriodicSummary.LoadCollection(WhereClause, OrderBy, true);
            }
            else
            {
                source = ProductPeriodicSummary.LoadCollection(OrderBy, true);
            }

            Common.ComboList sourceList = new Common.ComboList();

            if (BlankLine)
            {
                sourceList.Add(new Common.ComboItem(BlankLineText, Guid.Empty));
            }

            foreach (ProductPeriodicSummary item in source)
            {
                bool filter = false;
                if (ParentFilter.Trim() != String.Empty)
                {
                    filter = true;
                    if (item.ProductId != Guid.Empty)
                    {
                        filter = IgnorThis(item, ParentFilter);
                    }
                }
                if (!(filter))
                {
                    string code = GetFormatedText(item, TextField, TextFormatString);
                    sourceList.Add(new Common.ComboItem(code, item.PeriodicSummaryId));
                }
            }

            ddList.DataSource    = sourceList;
            ddList.DisplayMember = "Code";
            ddList.ValueMember   = "Id";

            if (ddList.Items.Count > 0)
            {
                ddList.SelectedIndex = 0;
            }
        }
 private static string GetFormatedText(ProductPeriodicSummary target, string [] textField, string textFormatString)
 {
     for (int i = 0; i < textField.Length; i++)
     {
         PropertyInfo pi = target.GetType().GetProperty(textField[i]);
         textFormatString = textFormatString.Replace("{" + i.ToString() + "}", pi != null ? pi.GetValue(target, null).ToString() : string.Empty);
     }
     return(textFormatString);
 }
        /// <summary>
        /// Loads a collection of ProductPeriodicSummary objects from the database.
        /// </summary>
        /// <returns>A collection containing all of the ProductPeriodicSummary objects in the database.</returns>
        public static ProductPeriodicSummaryCollection LoadCollection(string spName, SqlParameter[] parms)
        {
            ProductPeriodicSummaryCollection result = new ProductPeriodicSummaryCollection();

            using (SqlDataReader reader = SqlHelper.Default.ExecuteReader(spName, parms))
            {
                while (reader.Read())
                {
                    ProductPeriodicSummary tmp = new ProductPeriodicSummary();
                    tmp.LoadFromReader(reader);
                    result.Add(tmp);
                }
            }
            return(result);
        }
 /// <summary>
 /// Loads a ProductPeriodicSummary object from the database using the given where clause
 /// </summary>
 /// <param name="whereClause">The filter expression for the query</param>
 /// <returns>A ProductPeriodicSummary object</returns>
 public static ProductPeriodicSummary LoadWhere(string whereClause)
 {
     SqlParameter[] parameterValues = new SqlParameter[] { new SqlParameter("@WhereClause", whereClause) };
     using (SqlDataReader reader = SqlHelper.Default.ExecuteReader("spProductPeriodicSummary_SelAll", parameterValues))
     {
         if (reader.Read())
         {
             ProductPeriodicSummary result = new ProductPeriodicSummary();
             result.LoadFromReader(reader);
             return(result);
         }
         else
         {
             return(null);
         }
     }
 }
 /// <summary>
 /// Loads a ProductPeriodicSummary object from the database using the given PeriodicSummaryId
 /// </summary>
 /// <param name="periodicSummaryId">The primary key value</param>
 /// <returns>A ProductPeriodicSummary object</returns>
 public static ProductPeriodicSummary Load(Guid periodicSummaryId)
 {
     SqlParameter[] parameterValues = new SqlParameter[] { new SqlParameter("@PeriodicSummaryId", periodicSummaryId) };
     using (SqlDataReader reader = SqlHelper.Default.ExecuteReader("spProductPeriodicSummary_SelRec", parameterValues))
     {
         if (reader.Read())
         {
             ProductPeriodicSummary result = new ProductPeriodicSummary();
             result.LoadFromReader(reader);
             return(result);
         }
         else
         {
             return(null);
         }
     }
 }
        private static bool IgnorThis(ProductPeriodicSummary target, string parentFilter)
        {
            bool result = true;

            parentFilter = parentFilter.Replace(" ", "");                       // remove spaces
            parentFilter = parentFilter.Replace("'", "");                       // remove '
            string [] parsed = parentFilter.Split('=');                         // parse

            if (target.ProductId == Guid.Empty)
            {
                PropertyInfo pi          = target.GetType().GetProperty(parsed[0]);
                string       filterField = (string)pi.GetValue(target, null);
                if (filterField.ToLower() == parsed[1].ToLower())
                {
                    result = false;
                }
            }
            else
            {
                ProductPeriodicSummary parentTemplate = ProductPeriodicSummary.Load(target.ProductId);
                result = IgnorThis(parentTemplate, parentFilter);
            }
            return(result);
        }