public SearchParameterSet[] GetParameterValues()
        {
            List <SearchParameterSet> parmValList = new List <SearchParameterSet>(this.ParameterDefs.Length);
            String parmValStr = txtParm.Text;

            String[] parmValStrArr = parmValStr.Split(new Char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

            for (Int32 i = 0; i < parmValStrArr.Length; ++i)
            {
                String       parmVal    = parmValStrArr[i];
                QueryParmDef qryParmDef = this.ParameterDefs[i];
                Int32        splitIdx   = parmVal.IndexOf(':');

                if (splitIdx > 0)
                {
                    String nameStr  = parmVal.Substring(0, splitIdx).Trim();
                    String valueStr = parmVal.Substring(splitIdx + 1);

                    if (String.Equals(nameStr, qryParmDef.Name, StringComparison.Ordinal) &&
                        !String.IsNullOrEmpty(valueStr))
                    {
                        SearchParameterSet parmSet = ParseParmVal(qryParmDef, valueStr);

                        if (!parmSet.IsEmpty)
                        {
                            parmValList.Add(parmSet);
                        }
                    }
                }
            }

            return(parmValList.ToArray());
        }
Beispiel #2
0
        public SearchParameterSet ParseParameter(QueryParmDef qryParmDef, String parmStr)
        {
            SearchParameterSet parmSet = new SearchParameterSet(qryParmDef);
            Match m = mS_ParmStrWithPat.Match(parmStr);

            if (!String.IsNullOrEmpty(parmStr))
            {
                if (m.Success)
                {
                    Group g = null;

                    g = (m.Groups[1].Success ? m.Groups[1] : m.Groups[3]);
                    if (g.Success)
                    {
                        parmSet.AddSearchParameter(ParseParameterValue(qryParmDef, g.Value));
                    }

                    g = (m.Groups[2].Success ? m.Groups[2] : m.Groups[4]);
                    if (g.Success)
                    {
                        foreach (Capture c in g.Captures)
                        {
                            parmSet.AddSearchParameter(ParseParameterValue(qryParmDef, c.Value));
                        }
                    }
                }
                else
                {
                    throw new Exception(String.Format("Cannot parse {0} for parameter {1}!", parmStr, qryParmDef.Name));
                }
            }

            return(parmSet);
        }
        public static ISearchQuery CreateSearchQuery(IQueryCollection queryCollection, ISearchFunction searchFunction)
        {
            List <SearchParameterSet> sets = new List <SearchParameterSet>();

            List <ISearchParameter> parameters = new List <ISearchParameter>();

            foreach (var kvp in queryCollection)
            {
                foreach (var value in kvp.Value)
                {
                    if (string.IsNullOrEmpty(value))
                    {
                        continue;
                    }
                    ISearchParameter parameter = CreateParameter(kvp.Key, kvp.Value, searchFunction.SearchCriterionSet);
                    if (parameter != null)
                    {
                        parameters.Add(parameter);
                    }
                }
            }
            SearchParameterSet set = new SearchParameterSet(parameters);

            sets.Add(set);

            return(new SearchQuery(sets.LastOrDefault()));
        }
        private SearchParameterSet ParseParmVal(QueryParmDef qryParmDef, String parmValStr)
        {
            SearchParameterSet parmSet       = null;
            BaseQueryParameter qryParmParser = null;

            try
            {
                qryParmParser = QueryParameter.GetQueryParameter(qryParmDef);
                parmSet       = qryParmParser.ParseParameter(qryParmDef, parmValStr);
            }
            catch (Exception ex)
            {
                String exMsg = String.Format("Fail to parse '{0}'. \n{1}", parmValStr, ex.Message);

                System.Diagnostics.Debug.WriteLine(exMsg); // TODO

                //throw new Exception(exMsg, ex);
            }

            return(parmSet);
        }