protected void AddQueryParameterIfNotNull <T>(QueryParamCollection queryParams, string name, T value)
 {
     if (value != null)
     {
         queryParams.Add(name, value);
     }
 }
Example #2
0
        internal HttpListenerWebSocketContext(
            Uri requestUri,
            QueryParamCollection headers,
            CookieCollection cookieCollection,
            IPrincipal user,
            bool isAuthenticated,
            bool isLocal,
            bool isSecureConnection,
            string origin,
            IEnumerable <string> secWebSocketProtocols,
            string secWebSocketVersion,
            string secWebSocketKey,
            WebSocket webSocket)
        {
            _cookieCollection = new CookieCollection();
            _cookieCollection.Add(cookieCollection);

            //_headers = new NameValueCollection(headers);
            _headers = headers;
            _user    = CopyPrincipal(user);

            _requestUri            = requestUri;
            _isAuthenticated       = isAuthenticated;
            _isLocal               = isLocal;
            _isSecureConnection    = isSecureConnection;
            _origin                = origin;
            _secWebSocketProtocols = secWebSocketProtocols;
            _secWebSocketVersion   = secWebSocketVersion;
            _secWebSocketKey       = secWebSocketKey;
            _webSocket             = webSocket;
        }
        /// <summary>
        /// Queries the database for a list of results that contains the employee name result and computed Levenshtein distance to the search string.
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="searchEmpName"></param>
        /// <param name="empNameColumn"></param>
        /// <param name="empNumColumn"></param>
        /// <returns></returns>
        private static List <SmartEmpSearchInfo> GetEmpSearchResults(string tableName, string searchEmpName, string empNameColumn, string empNumColumn)
        {
            var tmpResults   = new List <SmartEmpSearchInfo>();
            var searchParams = new QueryParamCollection();

            // Parameterize the input.
            searchParams.Add(empNameColumn, searchEmpName, false);

            // Query the DB for the search value.
            using (DataTable data = DBFactory.GetDatabase().DataTableFromParameters("SELECT * FROM " + tableName + " WHERE", searchParams.Parameters))
            {
                foreach (DataRow row in data.Rows)
                {
                    var searchValue = searchEmpName.ToUpper();
                    var dbValue     = row[empNameColumn].ToString().ToUpper();

                    // Get the distance between the search value and DB value.
                    var distance = Fastenshtein.Levenshtein.Distance(searchValue, dbValue);
                    var employee = new MunisEmployee(row[empNameColumn].ToString(), row[empNumColumn].ToString());

                    // Add new entry to the list.
                    tmpResults.Add(new SmartEmpSearchInfo(employee, searchEmpName, distance));
                }
            }
            return(tmpResults);
        }
        private async void EmpNameSearch(string name)
        {
            try
            {
                string columns = "a_employee_number,a_name_last,a_name_first,a_org_primary,a_object_primary,a_location_primary,a_location_p_desc,a_location_p_short";
                string query   = "SELECT TOP " + maxResults + " " + columns + " FROM pr_employee_master";

                var searchParams = new QueryParamCollection();
                searchParams.Add("a_name_last", name.ToUpper(), false, "OR");
                searchParams.Add("a_name_first", name.ToUpper(), false, "OR");

                SetWorking(true);

                var comms = new MunisComms();
                using (var cmd = comms.GetSqlCommandFromParams(query, searchParams.Parameters))
                    using (var results = await comms.ReturnSqlTableFromCmdAsync(cmd))
                    {
                        if (results.Rows.Count > 0)
                        {
                            MunisResults.DataSource = null;
                            MunisResults.DataSource = results;
                            MunisResults.ClearSelection();
                        }
                    }
            }
            catch (Exception ex)
            {
                ErrorHandling.ErrHandle(ex, System.Reflection.MethodBase.GetCurrentMethod());
            }
            finally
            {
                SetWorking(false);
            }
        }
        private static async Task <DataTable> GetReqLineItemsFromReqNum(string reqNumber, string fiscalYr)
        {
            if (reqNumber == "" || fiscalYr == "")
            {
                return(null);
            }
            var vendorNum = await GetVendorNumberFromReqNumber(reqNumber, fiscalYr);

            if ((string)vendorNum == "")
            {
                return(null);
            }
            string nendorName = await munisComms.ReturnSqlValueAsync("ap_vendor", "a_vendor_number", vendorNum, "a_vendor_name");

            string query = "SELECT TOP " + intMaxResults + @" dbo.rq_gl_info.rg_fiscal_year, dbo.rq_gl_info.a_requisition_no, dbo.rq_gl_info.rg_org, dbo.rq_gl_info.rg_object, dbo.rq_gl_info.a_org_description, dbo.rq_gl_info.a_object_desc,
'" + nendorName + "' AS a_vendor_name, '" + vendorNum + @"' AS a_vendor_number, dbo.rqdetail.rqdt_pur_no, dbo.rqdetail.rqdt_pur_dt, dbo.rqdetail.rqdt_lin_no, dbo.rqdetail.rqdt_uni_pr, dbo.rqdetail.rqdt_net_pr, dbo.rqdetail.rqdt_qty_no, dbo.rqdetail.rqdt_des_ln, dbo.rqdetail.rqdt_vdr_part_no
FROM dbo.rq_gl_info INNER JOIN
dbo.rqdetail ON dbo.rq_gl_info.rg_line_number = dbo.rqdetail.rqdt_lin_no AND dbo.rq_gl_info.a_requisition_no = dbo.rqdetail.rqdt_req_no AND dbo.rq_gl_info.rg_fiscal_year = dbo.rqdetail.rqdt_fsc_yr";

            QueryParamCollection searchParams = new QueryParamCollection();

            searchParams.Add("dbo.rq_gl_info.a_requisition_no", reqNumber, true);
            searchParams.Add("dbo.rq_gl_info.rg_fiscal_year", fiscalYr, true);

            var reqTable = await munisComms.ReturnSqlTableFromCmdAsync(munisComms.GetSqlCommandFromParams(query, searchParams.Parameters));

            if (reqTable.Rows.Count > 0)
            {
                return(reqTable);
            }
            else
            {
                return(null);
            }
        }
Example #6
0
        public object ReturnSqlValue(string table, object fieldIn, object valueIn, string fieldOut, object fieldIn2 = null, object valueIn2 = null)
        {
            string query = "";
            QueryParamCollection queryParams = new QueryParamCollection();

            if (fieldIn2 != null && valueIn2 != null)
            {
                query = "SELECT TOP 1 " + fieldOut + " FROM " + table;

                queryParams.Add(fieldIn.ToString(), valueIn.ToString(), true);
                queryParams.Add(fieldIn2.ToString(), valueIn2.ToString(), true);
            }
            else
            {
                query = "SELECT TOP 1 " + fieldOut + " FROM " + table;

                queryParams.Add(fieldIn.ToString(), valueIn.ToString(), true);
            }
            using (var cmd = GetSqlCommandFromParams(query, queryParams.Parameters))
                using (var conn = cmd.Connection)
                {
                    cmd.Connection.Open();
                    return(cmd.ExecuteScalar());
                }
        }
Example #7
0
        public async Task <string> ReturnSqlValueAsync(string table, object fieldIn, object valueIn, string fieldOut, object fieldIn2 = null, object valueIn2 = null)
        {
            string query = "";

            QueryParamCollection queryParams = new QueryParamCollection();

            if (fieldIn2 != null && valueIn2 != null)
            {
                query = "SELECT TOP 1 " + fieldOut + " FROM " + table;

                queryParams.Add(fieldIn.ToString(), valueIn.ToString(), true);
                queryParams.Add(fieldIn2.ToString(), valueIn2.ToString(), true);
            }
            else
            {
                query = "SELECT TOP 1 " + fieldOut + " FROM " + table;

                queryParams.Add(fieldIn.ToString(), valueIn.ToString(), true);
            }

            using (var cmd = GetSqlCommandFromParams(query, queryParams.Parameters))
                using (var conn = cmd.Connection)
                {
                    await cmd.Connection.OpenAsync();

                    var Value = await cmd.ExecuteScalarAsync();

                    if (Value != null)
                    {
                        return(Value.ToString());
                    }
                }
            return(string.Empty);
        }
Example #8
0
        void CreateQueryString(string query)
        {
            if (query == null || query.Length == 0)
            {
                query_string = new QueryParamCollection();
                return;
            }

            query_string = new QueryParamCollection();
            if (query[0] == '?')
            {
                query = query.Substring(1);
            }
            string[] components = query.Split('&');
            foreach (string kv in components)
            {
                int pos = kv.IndexOf('=');
                if (pos == -1)
                {
                    query_string.Add(null, WebUtility.UrlDecode(kv));
                }
                else
                {
                    string key = WebUtility.UrlDecode(kv.Substring(0, pos));
                    string val = WebUtility.UrlDecode(kv.Substring(pos + 1));

                    query_string.Add(key, val);
                }
            }
        }
Example #9
0
 /// <summary>
 /// Builds a query from the populated search controls.
 /// </summary>
 public void DynamicSearch()
 {
     try
     {
         QueryParamCollection searchParams = BuildSearchList();
         string query;
         if (HistoricalCheckBox.Checked)
         {
             query = "SELECT * FROM " + HistoricalDevicesCols.TableName + " WHERE";
             var searchCommand = DBFactory.GetDatabase().GetCommandFromParams(query, searchParams.Parameters);
             searchCommand.CommandText += " GROUP BY " + DevicesCols.DeviceGuid;
             StartBigQuery(searchCommand);
         }
         else
         {
             query = "SELECT * FROM " + DevicesCols.TableName + " WHERE";
             var searchCommand = DBFactory.GetDatabase().GetCommandFromParams(query, searchParams.Parameters);
             StartBigQuery(searchCommand);
         }
     }
     catch (Exception ex)
     {
         ErrorHandling.ErrHandle(ex, System.Reflection.MethodBase.GetCurrentMethod());
     }
 }
Example #10
0
File: Url.cs Project: llenroc/Flurl
		/// <summary>
		/// Constructs a Url object from a string.
		/// </summary>
		/// <param name="baseUrl">The URL to use as a starting point (required)</param>
		public Url(string baseUrl) {
			if (baseUrl == null)
				throw new ArgumentNullException("baseUrl");

			var parts = baseUrl.Split('?');
			Path = parts[0];
			QueryParams = QueryParamCollection.Parse(parts.Length > 1 ? parts[1] : "");
		}
Example #11
0
        private static CookieCollection GetCookies(QueryParamCollection headers, bool response)
        {
            var name = response ? "Set-Cookie" : "Cookie";

            return(headers == null || !headers.Contains(name)
                   ? new CookieCollection()
                   : CookieHelper.Parse(headers[name], response));
        }
Example #12
0
        public async Task <ProductViewModel> GetProductByIdAsync(GetProductByIdRequest getProductByIdRequest, CancellationToken cancellationToken)
        {
            var qpc = new QueryParamCollection
            {
                { "id", getProductByIdRequest.Id },
            }.ToQueryString();

            var response = await _httpClient.SendAsync <ProductViewModel>(HttpMethod.Get, $"v1/Product/GetProductById?{qpc}", null, cancellationToken);

            return(response);
        }
Example #13
0
        private static int?GetIntValue(QueryParamCollection values, string name)
        {
            var value = values.Get(name);

            if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
            {
                return(result);
            }

            return(null);
        }
Example #14
0
        private static long GetLongValue(QueryParamCollection values, string name)
        {
            var value = values.Get(name);

            if (long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
            {
                return(result);
            }

            return(0);
        }
        /// <summary>
        /// Serializes the specified object.
        /// </summary>
        /// <param name="obj">The object.</param>
        public string Serialize(object obj)
        {
            if (obj == null)
            {
                return(null);
            }

            var qp = new QueryParamCollection();

            qp.Merge(obj, NullValueHandling.Ignore);
            return(qp.ToString(true));
        }
Example #16
0
        public async Task <ProductsViewModel> GetProductsAsync(GetProductsRequest getProductsRequest, CancellationToken cancellationToken)
        {
            var qpc = new QueryParamCollection
            {
                { "pageSize", getProductsRequest.PageSize },
                { "page", getProductsRequest.Page }
            }.ToQueryString();

            var response = await _httpClient.SendAsync <ProductsViewModel>(HttpMethod.Get, $"v1/Product/GetProducts?{qpc}", null, cancellationToken);

            return(response);
        }
Example #17
0
        /// <summary>
        /// Converts an object's public properties to a collection of string-based key-value pairs. If the object happens
        /// to be an IDictionary, the IDictionary's keys and values converted to strings and returned.
        /// </summary>
        /// <param name="obj">The object to parse into key-value pairs</param>
        /// <returns></returns>
        public static IEnumerable <KeyValuePair <string, object> > ToKeyValuePairs(this object obj)
        {
            if (obj == null)
            {
                throw new ArgumentNullException("obj");
            }

            return
                ((obj is string) ? QueryParamCollection.Parse((string)obj) :
                 (obj is IEnumerable) ? CollectionToKV((IEnumerable)obj) :
                 ObjectToKV(obj));
        }
        public static async void NewOrgObjView(string org, string obj, string fy, ExtendedForm parentForm)
        {
            try
            {
                parentForm.Waiting();
                GridForm newGridForm = new GridForm(parentForm, "Org/Obj Info");
                string   glColumns   = " glma_org, glma_obj, glma_desc, glma_seg5, glma_bud_yr, glma_orig_bud_cy, glma_rev_bud_cy, glma_encumb_cy, glma_memo_bal_cy, glma_rev_bud_cy-glma_encumb_cy-glma_memo_bal_cy AS 'Funds Available' ";
                string   glMasterQry = "Select TOP " + intMaxResults + " " + glColumns + "FROM glmaster";

                QueryParamCollection glParams = new QueryParamCollection();
                glParams.Add("glma_org", org, true);

                if (!string.IsNullOrEmpty(obj)) //Show Rollup info for Object
                {
                    glParams.Add("glma_obj", obj, true);

                    string rollUpCode = await munisComms.ReturnSqlValueAsync("gl_budget_rollup", "a_org", org, "a_rollup_code");

                    string rollUpByCodeQry = "SELECT TOP " + intMaxResults + " * FROM gl_budget_rollup WHERE a_rollup_code = '" + rollUpCode + "'";
                    string budgetQry       = "SELECT TOP " + intMaxResults + " a_projection_no,a_org,a_object,db_line,db_bud_desc_line1,db_bud_reason_desc,db_bud_req_qty5,db_bud_unit_cost,db_bud_req_amt5,a_account_id FROM gl_budget_detail_2"; // WHERE a_projection_no='" & FY & "' AND a_org='" & Org & "' AND a_object='" & Obj & "'"

                    QueryParamCollection budgetParams = new QueryParamCollection();
                    budgetParams.Add("a_projection_no", fy, true);
                    budgetParams.Add("a_org", org, true);
                    budgetParams.Add("a_object", obj, true);

                    newGridForm.AddGrid("OrgGrid", "GL Info:", await munisComms.ReturnSqlTableFromCmdAsync(munisComms.GetSqlCommandFromParams(glMasterQry, glParams.Parameters)));
                    newGridForm.AddGrid("RollupGrid", "Rollup Info:", await munisComms.ReturnSqlTableAsync(rollUpByCodeQry));
                    newGridForm.AddGrid("BudgetGrid", "Budget Info:", await munisComms.ReturnSqlTableFromCmdAsync(munisComms.GetSqlCommandFromParams(budgetQry, budgetParams.Parameters)));
                }
                else // Show Rollup info for all Objects in Org
                {
                    string rollUpAllQry = "SELECT TOP " + intMaxResults + " * FROM gl_budget_rollup";

                    QueryParamCollection rollUpParams = new QueryParamCollection();
                    rollUpParams.Add("a_org", org, true);

                    newGridForm.AddGrid("OrgGrid", "GL Info:", await munisComms.ReturnSqlTableFromCmdAsync(munisComms.GetSqlCommandFromParams(glMasterQry, glParams.Parameters)));             //MunisComms.Return_MSSQLTableAsync(Qry))
                    newGridForm.AddGrid("RollupGrid", "Rollup Info:", await munisComms.ReturnSqlTableFromCmdAsync(munisComms.GetSqlCommandFromParams(rollUpAllQry, rollUpParams.Parameters))); //MunisComms.Return_MSSQLTableAsync("SELECT TOP " & intMaxResults & " * FROM gl_budget_rollup WHERE a_org = '" & Org & "'"))
                }
                newGridForm.Show();
            }
            catch (Exception ex)
            {
                ErrorHandling.ErrHandle(ex, System.Reflection.MethodBase.GetCurrentMethod());
            }
            finally
            {
                parentForm.DoneWaiting();
            }
        }
Example #19
0
        public Request Parse(string requestData)
        {
            var lines       = requestData.Split(Environment.NewLine);
            var requestLine = lines.First();
            var match       = RequestLineRegex.Match(requestLine);

            if (!match.Success)
            {
                throw new ApplicationException("Unable to process request");
            }
            var method = ParseHelper.ParseMethod(match.Groups[1].Value);

            if (method == Method.None)
            {
                throw new ApplicationException($"Unable to match {match.Groups[1].Value} to an available method");
            }

            var path  = match.Groups[2].Value;
            var query = new QueryParamCollection(match.Groups[3].Value);
            // to-do: map headers, querystring, body, etc...

            var headerLines = lines.Skip(1).TakeWhile(line => !string.IsNullOrEmpty(line));
            var headerDict  = new Dictionary <string, string>();

            foreach (var line in headerLines)
            {
                var hmatch = HeaderRegex.Match(line);
                if (!hmatch.Success)
                {
                    throw new ApplicationException($"Unable to process header line {line}");
                }
                var headerName  = hmatch.Groups[1].Value;
                var headerValue = hmatch.Groups[2].Value;
                headerDict.Add(headerName, headerValue);
            }

            HeaderCollection headers = new HeaderCollection(headerDict);

            var bodyLines = lines.SkipWhile(line => !string.IsNullOrEmpty(line)).Skip(1);
            var body      = string.Join(Environment.NewLine, bodyLines);

            return(new Request
            {
                Method = method,
                Path = path,
                Query = query,
                Headers = headers,
                Body = body
            });
        }
        /// <summary>
        /// Serializes the specified object.
        /// </summary>
        /// <param name="obj">The object.</param>
        public string Serialize(object obj)
        {
            if (obj == null)
            {
                return(null);
            }

            var qp = new QueryParamCollection();

            foreach (var kv in obj.ToKeyValuePairs())
            {
                qp.AddOrReplace(kv.Key, kv.Value, false, NullValueHandling.Ignore);
            }
            return(qp.ToString(true));
        }
Example #21
0
    public static Url RelativeProxyForArtwork(string artwork)
    {
        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
        if (split.Length != 2)
        {
            return(artwork);
        }

        string pathSegment         = split[0];
        QueryParamCollection query = Url.ParseQueryParams(split[1]);

        return(Url.Parse("jellyfin")
               .AppendPathSegment(pathSegment)
               .SetQueryParams(query));
    }
        public void Get()
        {
            var urlBase = "http://www.google.com";

            // var url = "http://www.google.com/api/search?a=123&b=qwe&c=6643";
            var url = urlBase.AppendPathSegment("api")
                      .AppendPathSegment("search")
                      .SetQueryParam("a", "123")
                      .SetQueryParam("b", "qwe")
                      .SetQueryParam("c", "6643");

            QueryParamCollection queryParams = url.QueryParams;
            var queryParam = queryParams["a"];

            Url newUrl = url.RemoveQueryParam("c");
        }
            public static StreamParams ParseFromUrl(string url, ILibraryManager libraryManager, IMediaSourceManager mediaSourceManager)
            {
                if (string.IsNullOrEmpty(url))
                {
                    throw new ArgumentNullException("url");
                }

                var request = new StreamParams
                {
                    ItemId = GetItemId(url)
                };

                Guid parsedId;

                if (string.IsNullOrWhiteSpace(request.ItemId) || !Guid.TryParse(request.ItemId, out parsedId))
                {
                    return(request);
                }

                var index = url.IndexOf('?');

                if (index == -1)
                {
                    return(request);
                }

                var query = url.Substring(index + 1);
                QueryParamCollection values = MyHttpUtility.ParseQueryString(query);

                request.DeviceProfileId = values.Get("DeviceProfileId");
                request.DeviceId        = values.Get("DeviceId");
                request.MediaSourceId   = values.Get("MediaSourceId");
                request.LiveStreamId    = values.Get("LiveStreamId");
                request.IsDirectStream  = string.Equals("true", values.Get("Static"), StringComparison.OrdinalIgnoreCase);

                request.AudioStreamIndex    = GetIntValue(values, "AudioStreamIndex");
                request.SubtitleStreamIndex = GetIntValue(values, "SubtitleStreamIndex");
                request.StartPositionTicks  = GetLongValue(values, "StartPositionTicks");

                request.Item = string.IsNullOrEmpty(request.ItemId)
                    ? null
                    : libraryManager.GetItemById(parsedId);

                request._mediaSourceManager = mediaSourceManager;

                return(request);
            }
Example #24
0
        private static void ValidateNameValueCollection(string name, QueryParamCollection coll)
        {
            if (coll == null)
            {
                return;
            }

            foreach (var pair in coll)
            {
                var key = pair.Name;
                var val = pair.Value;
                if (val != null && val.Length > 0 && IsInvalidString(val))
                {
                    ThrowValidationException(name, key, val);
                }
            }
        }
Example #25
0
        private Task <SessionInfo> GetSession(QueryParamCollection queryString, string remoteEndpoint)
        {
            if (queryString == null)
            {
                throw new ArgumentNullException("queryString");
            }

            var token = queryString["api_key"];

            if (string.IsNullOrWhiteSpace(token))
            {
                return(Task.FromResult <SessionInfo>(null));
            }
            var deviceId = queryString["deviceId"];

            return(_sessionManager.GetSessionByAuthenticationToken(token, deviceId, remoteEndpoint));
        }
Example #26
0
        public async Task <int> GetCartsCountAsync(string userId, CancellationToken cancellationToken)
        {
            var savedToken = await _localStorage.GetItemAsync <string>("authToken");

            if (!string.IsNullOrWhiteSpace(savedToken))
            {
                _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", savedToken);
            }

            var qpc = new QueryParamCollection
            {
                { "userId", userId }
            }.ToQueryString();

            var response = await _httpClient.SendAsync <int>(HttpMethod.Get, $"v1/Cart/GetCartsCount?{qpc}", null, cancellationToken);

            return(response);
        }
        public static string GetSqlValue(string table, string fieldIn, string valueIn, string fieldOut)
        {
            string sqlQRY = "SELECT " + fieldOut + " FROM " + table + " WHERE ";

            QueryParamCollection searchParam = new QueryParamCollection();

            searchParam.Add(fieldIn, valueIn, true);
            var result = DBFactory.GetDatabase().ExecuteScalarFromCommand(DBFactory.GetDatabase().GetCommandFromParams(sqlQRY, searchParam.Parameters));

            if (result != null)
            {
                return(result.ToString());
            }
            else
            {
                return(string.Empty);
            }
        }
Example #28
0
    public static Url ForArtwork(Option <JellyfinMediaSource> maybeJellyfin, string artwork)
    {
        string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
                         .Flatten()
                         .IfNone("jellyfin://");

        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
        if (split.Length != 2)
        {
            return(artwork);
        }

        string pathSegment         = split[0];
        QueryParamCollection query = Url.ParseQueryParams(split[1]);

        return(Url.Parse(address)
               .AppendPathSegment(pathSegment)
               .SetQueryParams(query));
    }
Example #29
0
        private QueryParamCollection BuildSearchList()
        {
            var searchParams = new QueryParamCollection();

            using (var controlParser = new DBControlParser(this))
            {
                foreach (var ctl in controlParser.GetDBControls(this))
                {
                    var ctlValue = controlParser.GetDBControlValue(ctl);
                    if (ctlValue != DBNull.Value && !string.IsNullOrEmpty(ctlValue.ToString()))
                    {
                        var  dbInfo  = (DBControlInfo)ctl.Tag;
                        bool isExact = false;
                        switch (dbInfo.ColumnName)
                        {
                        //case DevicesCols.OSVersion:
                        //    IsExact = true;
                        //    break;

                        case DevicesCols.EQType:
                            isExact = true;
                            break;

                        case DevicesCols.Location:
                            isExact = true;
                            break;

                        case DevicesCols.Status:
                            isExact = true;
                            break;

                        default:
                            isExact = false;
                            break;
                        }

                        searchParams.Add(dbInfo.ColumnName, ctlValue, isExact);
                    }
                }
                return(searchParams);
            }
        }
Example #30
0
        /// <summary>
        /// Serializes the specified object.
        /// </summary>
        /// <param name="obj">The object.</param>
        public string Serialize(object obj)
        {
            if (obj == null)
            {
                return(null);
            }

            var qp = new QueryParamCollection();

            foreach (var kv in obj.ToKeyValuePairs())
            {
                // if value is null, the serializer shouldn't add this key-value pair.
                if (kv.Value == null)
                {
                    continue;
                }
                qp[kv.Key] = new QueryParameter(kv.Key, kv.Value);
            }
            return(qp.ToString(encodeSpaceAsPlus: true));
        }
Example #31
0
    public static Url ProxyForArtwork(string scheme, string host, string artwork, ArtworkKind artworkKind)
    {
        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
        if (split.Length != 2)
        {
            return(artwork);
        }

        string pathSegment         = split[0];
        QueryParamCollection query = Url.ParseQueryParams(split[1]);

        string artworkFolder = artworkKind switch
        {
            ArtworkKind.Thumbnail => "thumbnails",
            _ => "posters"
        };

        return(Url.Parse($"{scheme}://{host}/iptv/artwork/{artworkFolder}/jellyfin")
               .AppendPathSegment(pathSegment)
               .SetQueryParams(query));
    }
Example #32
0
        /// <summary>
        /// Initialize UrlBuilder fields from url string
        /// </summary>
        /// <param name="baseUrl">Url as string</param>
        private void Initialize(string baseUrl)
        {
            uriBuilder = new UriBuilder(baseUrl);
            segments = new List<string>();
            hasTrailingSlash = false;
            SetPath(uriBuilder.Path);

            var query = uriBuilder.Query.TrimStart('?');
            queryParams = QueryParamCollection.Parse(query.Length > 1 ? query : string.Empty);
        }
Example #33
0
 /// <summary>
 /// Constructs a UrlBuilder object
 /// </summary>
 public UrlBuilder()
 {
     uriBuilder = new UriBuilder();
     segments = new List<string>();
     queryParams = new QueryParamCollection();
 }