public static RESTSearchResultsSerialized ProcessResults(RESTSearchResults res, SearchInputs inputs)
        {
            RESTSearchResultsSerialized SerializedResults = new RESTSearchResultsSerialized();

            SerializedResults.Inputs = inputs;

            if (res != null)
            {
                SerializedResults.ExecutionTime = res.ElapsedTime;

                if (res.PrimaryQueryResult != null && res.PrimaryQueryResult.RelevantResults != null)
                {
                    SerializedResults.TotalRows = res.PrimaryQueryResult.RelevantResults.TotalRows;

                    SerializedResults.ResultRows = res.PrimaryQueryResult.RelevantResults.RowCount;

                    SerializedResults.ResultTitle    = res.PrimaryQueryResult.RelevantResults.ResultTitle;
                    SerializedResults.SearchResults  = res.PrimaryQueryResult.RelevantResults.Table;
                    SerializedResults.ResultTitleUrl = res.PrimaryQueryResult.RelevantResults.ResultTitleUrl;
                }
                else
                {
                    SerializedResults.TotalRows = 0;

                    SerializedResults.ResultRows = 0;
                }

                SerializedResults.SpellingSuggestions = res.SpellingSuggestion;


                // set SourceId from execution results
                Guid sid = Guid.Empty;

                SearchProperty SourceId = res.Properties.Where(p => p.Key.Equals("sourceid", StringComparison.InvariantCultureIgnoreCase)).First();
                if (SourceId != null && Guid.TryParse(SourceId.Value, out sid))
                {
                    SerializedResults.Inputs.SourceId = sid;
                }
            }

            return(SerializedResults);
        }
        public static RESTSearchResultsSerialized ExecuteSearch(SearchInputs inputs, Configuration Configuration, ServiceAssemblyBase serviceBroker)
        {
            RESTSearchResults res = Utilities.BrokerUtils.ExecuteRESTRequest(Utilities.BrokerUtils.BuildSearchText(inputs, Configuration), serviceBroker);

            return(ProcessResults(res, inputs));
        }
        public static RESTSearchResults ExecuteRESTRequest(string RequestUri, ServiceAssemblyBase serviceBroker)
        {
            var               res           = string.Empty;
            HttpWebRequest    request       = null;
            RESTSearchResults searchResults = null;

            try
            {
                request        = (HttpWebRequest)WebRequest.Create(RequestUri);
                request.Method = "GET";
                request.Accept = "application/json";
                //                request.Expect = "100-continue";
                request.Headers.Add("Accept-Encoding", "gzip, deflate");

                if (serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.AuthenticationMode == AuthenticationMode.Impersonate || serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.AuthenticationMode == AuthenticationMode.ServiceAccount)
                {
                    request.UseDefaultCredentials = true;
                }
                if (serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.AuthenticationMode == AuthenticationMode.OAuth)
                {
                    string accessToken  = serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.OAuthToken;
                    string headerBearer = String.Format(CultureInfo.InvariantCulture, "Bearer {0}", accessToken);

                    request.Headers.Add("Authorization", headerBearer.ToString());
                }
                if (serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.AuthenticationMode == AuthenticationMode.Static)
                {
                    char[]   sp   = { '\\' };
                    string[] user = serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.UserName.Split(sp);
                    if (user.Length > 1)
                    {
                        request.Credentials = new NetworkCredential(user[1], serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.Password, user[0]);
                    }
                    else
                    {
                        request.Credentials = new NetworkCredential(serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.UserName, serviceBroker.Service.ServiceConfiguration.ServiceAuthentication.Password);
                    }
                }

                request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;

                using (HttpWebResponse Response = (HttpWebResponse)request.GetResponse())
                {
                    using (Stream st = Response.GetResponseStream())
                    {
                        using (StreamReader sr = new StreamReader(st))
                        {
                            res = sr.ReadToEnd();
                        }

                        searchResults = Newtonsoft.Json.JsonConvert.DeserializeObject <RESTSearchResults>(res);
                    }
                }
            }
            catch (WebException wex)
            {
                // should throw exception to force reauth
                throw;
            }
            catch (Exception ex)
            {
                throw;
            }
            finally
            {
                request = null;
            }
            return(searchResults);
        }