public static UriParamList FromQueryString(string query)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            var result = new UriParamList();

            if (query == String.Empty)
            {
                return(result);
            }

            var q = query.TrimStart('?');

            var querySegments = q.Split(new string[] { "&" }, StringSplitOptions.RemoveEmptyEntries);

            foreach (var segment in querySegments)
            {
                var kv = SplitParam(segment);
                result.Add(kv);
            }

            return(result);
        }
        public UriParamList WithKey(string key)
        {
            var match = MatchParam(key);

            var result = new UriParamList();

            result.AddRange(this.Where(par => match(par)));
            return(result);
        }
        public UriParamList ToUriParamList()
        {
            var result = new UriParamList();

            if (!String.IsNullOrEmpty(Query))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_QUERY, Query));
            }
            if (!String.IsNullOrEmpty(Text))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_TEXT, Text));
            }
            if (!String.IsNullOrEmpty(Content))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTENT, Content));
            }
            if (Count != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_COUNT, Count.Value.ToString()));
            }
            if (Include.Any())
            {
                result.AddRange(Include.Select(i => Tuple.Create(SEARCH_PARAM_INCLUDE, i)));
            }
            if (RevInclude.Any())
            {
                result.AddRange(RevInclude.Select(i => Tuple.Create(SEARCH_PARAM_REVINCLUDE, i)));
            }
            if (Sort.Any())
            {
                result.AddRange(Sort.Select(s => Tuple.Create(createSortParamName(s.Item2), s.Item1)));
            }
            if (Summary != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_SUMMARY, Summary.Value.ToString().ToLower()));
            }
            if (!String.IsNullOrEmpty(Filter))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_FILTER, Filter));
            }
            if (Contained != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTAINED, Contained.Value.ToString().ToLower()));
            }
            if (ContainedType != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTAINEDTYPE, ContainedType.Value.ToString().ToLower()));
            }
            if (Elements.Any())
            {
                result.Add(Tuple.Create(SEARCH_PARAM_ELEMENTS, String.Join(",", Elements)));
            }

            result.AddRange(Parameters);
            return(result);
        }
Beispiel #4
0
        public RestUrl(Uri url)
        {
            if (!url.IsAbsoluteUri)
            {
                throw Error.Argument(nameof(url), "Must be an absolute url");
            }

            if (url.Scheme != "http" && url.Scheme != "https")
            {
                Error.Argument(nameof(url), "RestUrl must be a http(s) url");
            }

            _builder = new UriBuilder(url);

            if (!String.IsNullOrEmpty(_builder.Query))
            {
                _parameters = UriParamList.FromQueryString(_builder.Query);
            }
        }
Beispiel #5
0
        public UriParamList ToUriParamList()
        {
            var result = new UriParamList();

            if (!String.IsNullOrEmpty(Query))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_QUERY, Query));
            }
            if (!String.IsNullOrEmpty(Text))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_TEXT, Text));
            }
            if (!String.IsNullOrEmpty(Content))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTENT, Content));
            }
            if (Count != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_COUNT, Count.Value.ToString()));
            }
            if (Include.Any())
            {
                result.AddRange(Include.Select(i => Tuple.Create(SEARCH_PARAM_INCLUDE, i)));
            }
            if (RevInclude.Any())
            {
                result.AddRange(RevInclude.Select(i => Tuple.Create(SEARCH_PARAM_REVINCLUDE, i)));
            }
            if (Sort.Any())
            {
                result.Add(createSortParam(Sort));
            }
            if (Summary != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_SUMMARY, Summary.Value.ToString().ToLower()));
            }
            if (!String.IsNullOrEmpty(Filter))
            {
                result.Add(Tuple.Create(SEARCH_PARAM_FILTER, Filter));
            }
            if (Contained != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTAINED, Contained.Value.ToString().ToLower()));
            }
            if (ContainedType != null)
            {
                result.Add(Tuple.Create(SEARCH_PARAM_CONTAINEDTYPE, ContainedType.Value.ToString().ToLower()));
            }
            if (Elements.Any())
            {
                result.Add(Tuple.Create(SEARCH_PARAM_ELEMENTS, String.Join(",", Elements)));
            }

            result.AddRange(Parameters);
            return(result);

            Tuple <string, string> createSortParam(IList <Tuple <string, SortOrder> > sorts)
            {
                var values =
                    from s in sorts
                    let orderPrefix = s.Item2 == SortOrder.Descending ? "-" : ""
                                      select orderPrefix + s.Item1;

                return(new Tuple <string, string>(SEARCH_PARAM_SORT, String.Join(",", values)));
            }
        }