System.Net.WebUtility.UrlEncode(string)

protected internal async Task<ConfigEnvironment> RemoteLoadAsync(string[] requestUris, string label)
        {
            // Get client if not already set
            _httpClient ??= GetHttpClient(_settings);

            Exception error = null;
            foreach (var requestUri in requestUris)
            {
                error = null;

                // Get a config server uri and username preplacedwords to use
                var trimUri = requestUri.Trim();
                var serverUri = _settings.GetRawUri(trimUri);
                var username = _settings.GetUserName(trimUri);
                var preplacedword = _settings.GetPreplacedword(trimUri);

                // Make Config Server URI from settings
                var path = GetConfigServerUri(serverUri, label);

                // Get the request message
                var request = GetRequestMessage(path, username, preplacedword);

                // If certificate validation is disabled, inject a callback to handle properly
                var prevProtocols = (SecurityProtocolType)0;
                HttpClientHelper.ConfigureCertificateValidation(_settings.ValidateCertificates, out prevProtocols, out var prevValidator);

                // Invoke config server
                try
                {
                    using var response = await _httpClient.SendAsync(request).ConfigureAwait(false);

                    // Log status
                    var message = $"Config Server returned status: {response.StatusCode} invoking path: {requestUri}";
                    _logger?.LogInformation(WebUtility.UrlEncode(message));

                    if (response.StatusCode != HttpStatusCode.OK)
                    {
                        if (response.StatusCode == HttpStatusCode.NotFound)
                        {
                            return null;
                        }

                        // Throw if status >= 400
                        if (response.StatusCode >= HttpStatusCode.BadRequest)
                        {
                            // HttpClientErrorException
                            throw new HttpRequestException(message);
                        }
                        else
                        {
                            return null;
                        }
                    }

                    return await response.Content.ReadFromJsonAsync<ConfigEnvironment>(SerializerOptions).ConfigureAwait(false);
                }
                catch (Exception e)
                {
                    error = e;
                    _logger?.LogError(e, "Config Server exception, path: {requestUri}", WebUtility.UrlEncode(requestUri));
                    if (IsContinueExceptionType(e))
                    {
                        continue;
                    }

                    throw;
                }
                finally
                {
                    HttpClientHelper.RestoreCertificateValidation(_settings.ValidateCertificates, prevProtocols, prevValidator);
                }
            }

            if (error != null)
            {
                throw error;
            }

            return null;
        }

[Obsolete("Will be removed in next release. See RemoteLoadAsync(string[], string)")]
        protected internal virtual async Task<ConfigEnvironment> RemoteLoadAsync(string requestUri)
        {
            // Get client if not already set
            _httpClient ??= GetHttpClient(_settings);

            // Get the request message
            var request = GetRequestMessage(requestUri);

            // If certificate validation is disabled, inject a callback to handle properly
            HttpClientHelper.ConfigureCertificateValidation(_settings.ValidateCertificates, out var prevProtocols, out var prevValidator);

            // Invoke config server
            try
            {
                using var response = await _httpClient.SendAsync(request).ConfigureAwait(false);
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    if (response.StatusCode == HttpStatusCode.NotFound)
                    {
                        return null;
                    }

                    // Log status
                    var message = $"Config Server returned status: {response.StatusCode} invoking path: {requestUri}";

                    _logger?.LogInformation(WebUtility.UrlEncode(message));

                    // Throw if status >= 400
                    if (response.StatusCode >= HttpStatusCode.BadRequest)
                    {
                        throw new HttpRequestException(message);
                    }
                    else
                    {
                        return null;
                    }
                }

                return await response.Content.ReadFromJsonAsync<ConfigEnvironment>(SerializerOptions).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                // Log and rethrow
                _logger?.LogError("Config Server exception: {0}, path: {1}", e, WebUtility.UrlEncode(requestUri));
                throw;
            }
            finally
            {
                HttpClientHelper.RestoreCertificateValidation(_settings.ValidateCertificates, prevProtocols, prevValidator);
            }
        }

protected internal Uri MakeUri(string scheme, string host, int port, string username, string preplacedword, string path, string query)
        {
            var cleanedPath = path == null || path.StartsWith("/") ? path : $"/{path}";
            cleanedPath = query != null ? cleanedPath + "?" + query : cleanedPath;

            if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(preplacedword))
            {
                var builder = new UriBuilder()
                {
                    Scheme = scheme,
                    Host = host,
                    Port = port,
                    UserName = WebUtility.UrlEncode(username),
                    Preplacedword = WebUtility.UrlEncode(preplacedword),
                    Path = cleanedPath
                };
                return builder.Uri;
            }
            else
            {
                var builder = new UriBuilder()
                {
                    Scheme = scheme,
                    Host = host,
                    Port = port,
                    Path = cleanedPath
                };
                return builder.Uri;
            }
        }

public Uri BuildUri()
        {
            var sb = new StringBuilder("?client_id=");
            sb.Append(System.Net.WebUtility.UrlEncode(ClientId));


            foreach (var set in new (string key, string value)[]
            {
                ("scope", BotScope),
                ("user_scope", UserScope),
                ("redirect_uri", RedirectUri),
                ("state", State)
            })
            {
                if (string.IsNullOrWhiteSpace(set.key)) continue;

                sb.Append("&");
                sb.Append(set.key);
                sb.Append("=");
                sb.Append(System.Net.WebUtility.UrlEncode(set.value));
            }

            return new UriBuilder("https", "slack.com", 443, "/oauth/v2/authorize")
            {
                Query = sb.ToString()
                    
            }.Uri;
        }

private string UrlEncode(string value)
        {
            return WebUtility.UrlEncode(value).Replace("+", "%20");
        }

public override async Task Handle(HttpContext context)
        {   
            ClientWebSocket wsServer = null;
            System.Net.WebSockets.WebSocket wsClient = null;
            
            try
            {
                // First we need the URL for this connection, since it's been requested to be
                // upgraded to a websocket.

                var connFeature = context.Features.Get<IHttpRequestFeature>();

                string fullUrl = string.Empty;

                if (connFeature != null && connFeature.RawTarget != null && !string.IsNullOrEmpty(connFeature.RawTarget) && !(string.IsNullOrWhiteSpace(connFeature.RawTarget)))
                {
                    fullUrl = $"{context.Request.Scheme}://{context.Request.Host}{connFeature.RawTarget}";
                }
                else
                {
                    fullUrl = $"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}{context.Request.QueryString}";
                }

                // Need to replate the scheme with appropriate websocket scheme.
                if (fullUrl.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
                {
                    fullUrl = "ws://" + fullUrl.Substring(7);
                }
                else if (fullUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
                {
                    fullUrl = "wss://" + fullUrl.Substring(8);
                }

                // Next we need to try and parse the URL as a URI, because the websocket client
                // requires this for connecting upstream.

                if (!Uri.TryCreate(fullUrl, UriKind.RelativeOrAbsolute, out Uri wsUri))
                {
                    LoggerProxy.Default.Error("Failed to parse websocket URI.");
                    return;
                }

                // Create the websocket that's going to connect to the remote server.
                wsServer = new ClientWebSocket();
                wsServer.Options.Cookies = new System.Net.CookieContainer();
                //wsServer.Options.SetBuffer((int)ushort.MaxValue * 16, (int)ushort.MaxValue * 16);
                
                foreach (var proto in context.WebSockets.WebSocketRequestedProtocols)
                {
                    wsServer.Options.AddSubProtocol(proto);
                }

                foreach (var hdr in context.Request.Headers)
                {
                    if (!ForbiddenWsHeaders.IsForbidden(hdr.Key))
                    {
                        try
                        {
                            wsServer.Options.SetRequestHeader(hdr.Key, hdr.Value.ToString());
                        }
                        catch (Exception hdrException)
                        {
                            LoggerProxy.Default.Error(hdrException);
                        }
                    }
                }

                foreach (var cookie in context.Request.Cookies)
                {
                    try
                    {
                        wsServer.Options.Cookies.Add(new Uri(fullUrl, UriKind.Absolute), new System.Net.Cookie(cookie.Key, System.Net.WebUtility.UrlEncode(cookie.Value)));
                    }
                    catch (Exception e)
                    {
                        LoggerProxy.Default.Error("Error while attempting to add websocket cookie.");
                        LoggerProxy.Default.Error(e);
                    }
                }

                if (context.Connection.ClientCertificate != null)
                {
                    wsServer.Options.ClientCertificates = new System.Security.Cryptography.X509Certificates.X509CertificateCollection(new[] { context.Connection.ClientCertificate.ToV2Certificate() });
                }

                // Connect the server websocket to the upstream, remote webserver.
                await wsServer.ConnectAsync(wsUri, context.RequestAborted);

                foreach (string key in wsServer.ResponseHeaders)
                {
                    if (!ForbiddenWsHeaders.IsForbidden(key))
                    {
                        try
                        {   
                            var value = wsServer.ResponseHeaders[key];
                            context.Response.Headers[key] = wsServer.ResponseHeaders[key];                            
                        }
                        catch (Exception hdrException)
                        {
                            LoggerProxy.Default.Error(hdrException);
                        }
                    }
                }
                
                // Create, via acceptor, the client websocket. This is the local machine's websocket.
                wsClient = await context.WebSockets.AcceptWebSocketAsync(wsServer.SubProtocol ?? null);
                
                // Match the HTTP version of the client on the upstream request. We don't want to
                // transparently preplaced around headers that are wrong for the client's HTTP version.
                Version upstreamReqVersionMatch = null;

                Match match = s_httpVerRegex.Match(context.Request.Protocol);
                if (match != null && match.Success)
                {
                    upstreamReqVersionMatch = Version.Parse(match.Value);
                }

                var msgNfo = new HttpMessageInfo
                {
                    Url = wsUri,
                    Method = new HttpMethod(context.Request.Method),
                    IsEncrypted = context.Request.IsHttps,
                    Headers = context.Request.Headers.ToNameValueCollection(),
                    HttpVersion = upstreamReqVersionMatch ?? new Version(1, 0),
                    MessageProtocol = MessageProtocol.WebSocket,
                    MessageType = MessageType.Request,
                    RemoteAddress = context.Connection.RemoteIpAddress,
                    RemotePort = (ushort)context.Connection.RemotePort,
                    LocalAddress = context.Connection.LocalIpAddress,
                    LocalPort = (ushort)context.Connection.LocalPort
                };

                _configuration.NewHttpMessageHandler?.Invoke(msgNfo);

                switch (msgNfo.ProxyNextAction)
                {
                    case ProxyNextAction.DropConnection:
                        {
                            await wsClient.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
                            return;
                        }
                }

                var serverMessageInfo = new HttpMessageInfo
                {
                    Url = wsUri,
                    MessageId = msgNfo.MessageId,
                    Method = new HttpMethod(context.Request.Method),
                    IsEncrypted = context.Request.IsHttps,
                    Headers = context.Request.Headers.ToNameValueCollection(),
                    HttpVersion = upstreamReqVersionMatch ?? new Version(1, 0),
                    MessageProtocol = MessageProtocol.WebSocket,
                    MessageType = MessageType.Response,
                    RemoteAddress = context.Connection.RemoteIpAddress,
                    RemotePort = (ushort)context.Connection.RemotePort,
                    LocalAddress = context.Connection.LocalIpAddress,
                    LocalPort = (ushort)context.Connection.LocalPort
                };

                var clientMessageInfo = new HttpMessageInfo
                {
                    Url = wsUri,
                    MessageId = msgNfo.MessageId,
                    IsEncrypted = context.Request.IsHttps,
                    Headers = context.Request.Headers.ToNameValueCollection(),
                    HttpVersion = upstreamReqVersionMatch ?? new Version(1, 0),
                    MessageProtocol = MessageProtocol.WebSocket,
                    MessageType = MessageType.Request,
                    RemoteAddress = context.Connection.RemoteIpAddress,
                    RemotePort = (ushort)context.Connection.RemotePort,
                    LocalAddress = context.Connection.LocalIpAddress,
                    LocalPort = (ushort)context.Connection.LocalPort
                };

                bool inspect = true;

                switch (msgNfo.ProxyNextAction)
                {
                    case ProxyNextAction.AllowAndIgnoreContent:
                    case ProxyNextAction.AllowAndIgnoreContentAndResponse:
                        {
                            inspect = false;
                        }
                        break;
                }

                // Spawn an async task that will poll the remote server for data in a loop, and then
                // write any data it gets to the client websocket.
                var serverTask = Task.Run(async () =>
                {
                    System.Net.WebSockets.WebSocketReceiveResult serverResult = null;
                    var serverBuffer = new byte[1024 * 4];
                    try
                    {
                        bool looping = true;

                        serverResult = await wsServer.ReceiveAsync(new ArraySegment<byte>(serverBuffer), context.RequestAborted);

                        while (looping && !serverResult.CloseStatus.HasValue && !context.RequestAborted.IsCancellationRequested)
                        {

                            if (inspect)
                            {
                                serverMessageInfo.Body = new Memory<byte>(serverBuffer, 0, serverResult.Count);

                                switch (serverResult.MessageType)
                                {
                                    case System.Net.WebSockets.WebSocketMessageType.Binary:
                                        {
                                            serverMessageInfo.BodyContentType = s_octetStreamContentType;
                                        }
                                        break;

                                    case System.Net.WebSockets.WebSocketMessageType.Text:
                                        {
                                            serverMessageInfo.BodyContentType = s_plainTextContentType;
                                        }
                                        break;
                                }

                                _configuration.HttpMessageWholeBodyInspectionHandler?.Invoke(serverMessageInfo);
                            }

                            switch (serverMessageInfo.ProxyNextAction)
                            {
                                case ProxyNextAction.DropConnection:
                                    {
                                        looping = false;
                                    }
                                    break;

                                default:
                                    {
                                        await wsClient.SendAsync(new ArraySegment<byte>(serverBuffer, 0, serverResult.Count), serverResult.MessageType, serverResult.EndOfMessage, context.RequestAborted);

                                        if (!wsClient.CloseStatus.HasValue)
                                        {
                                            serverResult = await wsServer.ReceiveAsync(new ArraySegment<byte>(serverBuffer), context.RequestAborted);
                                            continue;
                                        }
                                    }
                                    break;
                            }

                            looping = false;
                        }

                        await wsClient.CloseAsync(serverResult.CloseStatus.Value, serverResult.CloseStatusDescription, context.RequestAborted);
                    }
                    catch (Exception err)
                    {
                        LoggerProxy.Default.Error(err);
                        try
                        {
                            var closeStatus = serverResult?.CloseStatus ?? System.Net.WebSockets.WebSocketCloseStatus.NormalClosure;
                            var closeMessage = serverResult?.CloseStatusDescription ?? string.Empty;

                            await wsClient.CloseAsync(closeStatus, closeMessage, context.RequestAborted);
                        }
                        catch { }
                    }
                });

                // Spawn an async task that will poll the local client websocket, in a loop, and then
                // write any data it gets to the remote server websocket.
                var clientTask = Task.Run(async () =>
                {
                    System.Net.WebSockets.WebSocketReceiveResult clientResult = null;
                    var clientBuffer = new byte[1024 * 4];
                    try
                    {
                        bool looping = true;

                        clientResult = await wsClient.ReceiveAsync(new ArraySegment<byte>(clientBuffer), context.RequestAborted);

                        while (looping && !clientResult.CloseStatus.HasValue && !context.RequestAborted.IsCancellationRequested)
                        {
                            if (inspect)
                            {
                                clientMessageInfo.Body = new Memory<byte>(clientBuffer, 0, clientResult.Count);

                                switch (clientResult.MessageType)
                                {
                                    case System.Net.WebSockets.WebSocketMessageType.Binary:
                                        {
                                            clientMessageInfo.BodyContentType = s_octetStreamContentType;
                                        }
                                        break;

                                    case System.Net.WebSockets.WebSocketMessageType.Text:
                                        {
                                            clientMessageInfo.BodyContentType = s_plainTextContentType;
                                        }
                                        break;
                                }

                                _configuration.HttpMessageWholeBodyInspectionHandler?.Invoke(clientMessageInfo);
                            }

                            switch (clientMessageInfo.ProxyNextAction)
                            {
                                case ProxyNextAction.DropConnection:
                                    {
                                        looping = false;
                                    }
                                    break;

                                default:
                                    {
                                        await wsServer.SendAsync(new ArraySegment<byte>(clientBuffer, 0, clientResult.Count), clientResult.MessageType, clientResult.EndOfMessage, context.RequestAborted);

                                        if (!wsServer.CloseStatus.HasValue)
                                        {
                                            clientResult = await wsClient.ReceiveAsync(new ArraySegment<byte>(clientBuffer), context.RequestAborted);
                                            continue;
                                        }
                                    }
                                    break;
                            }

                            looping = false;
                        }

                        await wsServer.CloseAsync(clientResult.CloseStatus.Value, clientResult.CloseStatusDescription, context.RequestAborted);
                    }
                    catch(Exception err)
                    {
                        LoggerProxy.Default.Error(err);
                        try
                        {
                            var closeStatus = clientResult?.CloseStatus ?? System.Net.WebSockets.WebSocketCloseStatus.NormalClosure;
                            var closeMessage = clientResult?.CloseStatusDescription ?? string.Empty;

                            await wsServer.CloseAsync(closeStatus, closeMessage, context.RequestAborted);
                        }
                        catch { }
                    }
                });

                // Above, we have created a bridge between the local and remote websocket. Wait for
                // both replacedociated tasks to complete.
                await Task.WhenAll(serverTask, clientTask);
            }
            catch (Exception wshe)
            {
                LoggerProxy.Default.Error(wshe);
            }
            finally
            {
                if (wsClient != null)
                {
                    wsClient.Dispose();
                    wsClient = null;
                }

                if (wsServer != null)
                {
                    wsServer.Dispose();
                    wsServer = null;
                }
            }
        }

public static async Task<HttpResponseMessage> PostAsync(this HttpClient client, ApiUrl url, JObject json, int timeout)
        {
            var hasOrigin = client.DefaultRequestHeaders.TryGetValues("Origin", out IEnumerable<string> origin);

            if (url.Referer != null)
            {
                client.DefaultRequestHeaders.Referrer = new Uri(url.Referer);
            }
            if (client.DefaultRequestHeaders.Contains("Origin"))
            {
                client.DefaultRequestHeaders.Remove("Origin");
                client.DefaultRequestHeaders.Add("Origin", url.Origin);
            }
            else
            {
                client.DefaultRequestHeaders.Add("Origin", url.Origin);
            }

            HttpContent hc = new StringContent($"r={WebUtility.UrlEncode(json.ToString(Formatting.None))}", Encoding.UTF8);
            hc.Headers.ContentType = MediaTypeHeaderValue.Parse("application/ x-www-form-urlencoded; charset=UTF-8");
            var response = client.PostAsync(url.Url, hc);
            response.Wait();

            // 复原client
            if (hasOrigin)
            {
                client.DefaultRequestHeaders.Remove("Origin");
                client.DefaultRequestHeaders.Add("Origin", origin);
            }
            else
            {
                client.DefaultRequestHeaders.Remove("Origin");
            }

            return await response;
        }

private static string AppendQuery(StringBuilder builder, Dictionary<string, string> param)
        {
            foreach (KeyValuePair<string, string> kvp in param)
            {
                builder.Append($"{WebUtility.UrlEncode(kvp.Key)}={WebUtility.UrlEncode(kvp.Value)}&");
            }
            return builder.ToString().TrimEnd('&');
        }

private string BuildCanonicalQueryString(AbstractModel request)
        {
            string httpRequestMethod = this.Profile.HttpProfile.ReqMethod;
            if (!HttpProfile.REQ_GET.Equals(httpRequestMethod))
            {
                return "";
            }
            Dictionary<string, string> param = new Dictionary<string, string>();
            request.ToMap(param, "");
            StringBuilder urlBuilder = new StringBuilder();
            foreach (KeyValuePair<string, string> kvp in param)
            {
                urlBuilder.Append($"{WebUtility.UrlEncode(kvp.Key)}={WebUtility.UrlEncode(kvp.Value)}&");
            }
            return urlBuilder.ToString().TrimEnd('&');
        }

[Fact]
        public async Task GetPageContent_ResultsTakeTwoPages_ShouldReturnAllAndSpecifyDateAlsoSpecifyNextUrl()
        {
            // Arrange
            var date = DateTime.MinValue;
            var expectedEncodedDate = WebUtility.UrlEncode(date.ToString(CqlDateFormat));
            var pageContent = new List<ContentDto>
            {
                new ContentDto
                {
                    Id = "id1",
                    replacedle = "replacedle1",
                    Body = new ContentBodyDto
                    {
                        View = new ViewRepresentationDto
                        {
                            Value = "body goes here 1"
                        }
                    }
                },
                new ContentDto
                {
                    Id = "id2",
                    replacedle = "replacedle2",
                    Body = new ContentBodyDto
                    {
                        View = new ViewRepresentationDto
                        {
                            Value = "body goes here 2"
                        }
                    }
                }
            };

            var firstPage = new ContentResponse
            {
                Links = new LinksDto { Next = "next url request"},
                Results = pageContent
            };

            _httpClientMock.Setup(m => m.GetAsync(It.IsAny<string>()))
                .ReturnsAsync(new HttpResponseMessage
                {
                    StatusCode = HttpStatusCode.OK,
                    Content = new StringContent(JsonConvert.SerializeObject(firstPage))
                });

            // Act
            var result = await _client.GetLatestPagesAsync(new []{"IH"}, date);
            
            // replacedert
            replacedert.Equal(result.Results.Count, pageContent.Count);
            _httpClientMock.Verify(m => m.GetAsync(It.Is<string>(q => q.Contains(expectedEncodedDate))),
                Times.Once);
        }

private string GetPath(string key)
        {
            if (string.IsNullOrWhiteSpace((cacheFolder)))
            {
                throw new Exception("Initialize has to be called before using TinyCache with file storage");
            }

            var encoded = WebUtility.UrlEncode(key);

            var name = string.Format("TinyCache_{0}.cache", encoded);

            return Path.Combine(cacheFolder, name);
        }

private string GetUrl(string value) {
            var ret = System.Net.WebUtility.UrlEncode(value);
            return ret.Replace("+","%20");
        }

private static string AddParameterInternal(string url, string parameterName, string stringValue)
        {
            var @operator = !url.Contains("?") ? "?" : "&";
            var formattedValue = WebUtility.UrlEncode(stringValue);
            var parameter = $"{@operator}{parameterName}={formattedValue}";
            return url + parameter;
        }

public WikiPage Update(string slug, WikiPageUpdate wikiPage) => _api
            .Put().With(wikiPage)
            .To<WikiPage>(_projectPath + "/wikis/" + WebUtility.UrlEncode(slug));

private string OpenPrivateSession()
        {
            var httpRequestor = new HttpRequestor(_credentials.HostUrl, string.Empty, MethodType.Post, RequestOptions);
            var url =
                $"/session?login={WebUtility.UrlEncode(_credentials.UserName)}&preplacedword={WebUtility.UrlEncode(_credentials.Preplacedword)}";
            try
            {
                var session = httpRequestor.To<Session>(url);
                return session.PrivateToken;
            }
            catch (GitLabException ex)
            {
                const string hiddenPreplacedword = "*****";

                var securedException = new GitLabException(ex.Message.Replace(_credentials.Preplacedword, hiddenPreplacedword))
                {
                    OriginalCall = new Uri(ex.OriginalCall.OriginalString.Replace(_credentials.Preplacedword, hiddenPreplacedword)),
                    StatusCode = ex.StatusCode,
                    ErrorObject = ex.ErrorObject,
                    MethodType = ex.MethodType,
                };

                throw securedException;
            }
        }

public JobStatus GetJobStatus(string branchName)
        {
            var encodedBranch = WebUtility.UrlEncode(branchName);

            var latestCommit = _api.Get().To<Commit>(_repoPath + $"/commits/{encodedBranch}?per_page=1");
            if (latestCommit == null)
            {
                return JobStatus.Unknown;
            }

            if (string.IsNullOrEmpty(latestCommit.Status))
            {
                return JobStatus.NoBuild;
            }

            if (!Enum.TryParse(latestCommit.Status, ignoreCase: true, result: out JobStatus result))
            {
                throw new NotSupportedException($"Status {latestCommit.Status} is unrecognised");
            }

            return result;
        }

public IEnumerable<Membership> OfProject(string projectId, bool includeInheritedMembers)
        {
            return GetAll(Project.Url + "/" + WebUtility.UrlEncode(projectId), includeInheritedMembers);
        }

public IEnumerable<Membership> OfGroup(string groupId, bool includeInheritedMembers)
        {
            return GetAll(GroupsClient.Url + "/" + WebUtility.UrlEncode(groupId), includeInheritedMembers);
        }

public Membership GetMemberOfGroup(string groupId, string userId)
        {
            return _api.Get().To<Membership>(GroupsClient.Url + "/" + WebUtility.UrlEncode(groupId) + "/members/" + WebUtility.UrlEncode(userId));
        }

public Membership GetMemberOfProject(string projectId, string userId)
        {
            return _api.Get().To<Membership>(Project.Url + "/" + WebUtility.UrlEncode(projectId) + "/members/" + WebUtility.UrlEncode(userId));
        }

public Membership AddMemberToProject(string projectId, ProjectMemberCreate user)
        {
            return _api.Post().With(user).To<Membership>(Project.Url + "/" + WebUtility.UrlEncode(projectId) + "/members");
        }

public Membership UpdateMemberOfProject(string projectId, ProjectMemberUpdate user)
        {
            return _api.Put().With(user).To<Membership>(Project.Url + "/" + WebUtility.UrlEncode(projectId) + "/members/" + WebUtility.UrlEncode(user.UserId));
        }

public Membership UpdateMemberOfProject(string projectId, ProjectMemberUpdate user)
        {
            return _api.Put().With(user).To<Membership>(Project.Url + "/" + WebUtility.UrlEncode(projectId) + "/members/" + WebUtility.UrlEncode(user.UserId));
        }

public void Delete(string name)
        {
            _api.Delete().Stream($"{_tagsPath}/{WebUtility.UrlEncode(name)}", _ => { });
        }

public void Delete(string slug) => _api
            .Delete()
            .Execute(_projectPath + "/wikis/" + WebUtility.UrlEncode(slug));

private static void InjectHeaders(Activity currentActivity, HttpRequestMessage request)
        {
            if (currentActivity.IdFormat == ActivityIdFormat.W3C)
            {
                if (!request.Headers.Contains(DiagnosticsHandlerLoggingStrings.TraceParentHeaderName))
                {
                    request.Headers.TryAddWithoutValidation(DiagnosticsHandlerLoggingStrings.TraceParentHeaderName, currentActivity.Id);
                    if (currentActivity.TraceStateString != null)
                    {
                        request.Headers.TryAddWithoutValidation(DiagnosticsHandlerLoggingStrings.TraceStateHeaderName, currentActivity.TraceStateString);
                    }
                }
            }
            else
            {
                if (!request.Headers.Contains(DiagnosticsHandlerLoggingStrings.RequestIdHeaderName))
                {
                    request.Headers.TryAddWithoutValidation(DiagnosticsHandlerLoggingStrings.RequestIdHeaderName, currentActivity.Id);
                }
            }

            // we expect baggage to be empty or contain a few items
            using (IEnumerator<KeyValuePair<string, string>> e = currentActivity.Baggage.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    var baggage = new List<string>();
                    do
                    {
                        KeyValuePair<string, string> item = e.Current;
                        baggage.Add(new NameValueHeaderValue(WebUtility.UrlEncode(item.Key), WebUtility.UrlEncode(item.Value)).ToString());
                    }
                    while (e.MoveNext());
                    request.Headers.TryAddWithoutValidation(DiagnosticsHandlerLoggingStrings.CorrelationContextHeaderName, baggage);
                }
            }
        }

[Command("Announce")]
        [Description("Allows you to construct a custom embed from Unix-style command arguments.")]
        [ShowUnixArgumentsInHelp(VolteUnixCommand.Announce)]
        public async Task<ActionResult> AnnounceAsync(
            [Remainder,
             Description(
                 "Unix-style command line arguments. Example: `-description=\"Some cool thing!\"` will set the embed's description.")]
            Dictionary<string, string> options)
        {
            static string GetRoleMention(TypeParserResult<SocketRole> res) =>
                res.IsSuccessful ? res.Value.Mention : null;

            static Color GetColor(TypeParserResult<Color> res) =>
                res.IsSuccessful ? res.Value : new Color(Config.SuccessColor);

            static bool TryGetUser(TypeParserResult<RestGuildUser> res, out RestGuildUser user)
            {
                user = res.IsSuccessful ? res.Value : null;
                return user != null;
            }

            var embed = new EmbedBuilder();

            if (options.TryGetValue("footer", out var result) || options.TryGetValue("foot", out result))
                embed.WithFooter(result);

            if (options.TryGetValue("thumbnail", out result))
            {
                if (!Uri.IsWellFormedUriString(result, UriKind.Absolute))
                    return BadRequest("Thumbnail URL must be a valid image URL.");

                embed.WithThumbnailUrl(result);
            }

            if (options.TryGetValue("image", out result))
            {
                if (!Uri.IsWellFormedUriString(result, UriKind.Absolute))
                    return BadRequest("Image URL must be a valid image URL.");

                embed.WithImageUrl(result);
            }

            if (options.TryGetValue("description", out result) || options.TryGetValue("desc", out result))
            {
                //must be a URL
                if (Uri.IsWellFormedUriString(WebUtility.UrlEncode(result), UriKind.RelativeOrAbsolute)
                    //must be a website/paste service that has support for raw paste viewing via a URL; feel free to PR more or to message me on discord to add some
                    && result.ContainsAnyIgnoreCase(AllowedPasteSites) 
                    //must be a url that leads to plaintext (aka raw on most websites) so it's not a bunch of HTML as the result.
                    && result.ContainsIgnoreCase("raw"))
                {
                    try
                    {
                        var m = await Http.GetAsync(WebUtility.UrlEncode(result));
                        result = await m.Content.ReadreplacedtringAsync();
                    }
                    catch { /* ignored */ }
                }
                
                embed.WithDescription(result);
            }

            if (options.TryGetValue("replacedle", out result))
                embed.Withreplacedle(result);

            if (options.TryGetValue("color", out result) || options.TryGetValue("colour", out result))
                embed.WithColor(GetColor(await CommandService.GetTypeParser<Color>()
                    .ParseAsync(null, result, Context)));

            if (options.TryGetValue("author", out result))
            {
                if (result.EqualsAnyIgnoreCase("self", "me"))
                    embed.WithAuthor(Context.User);
                else if (result.EqualsAnyIgnoreCase("bot", "you", "volte"))
                    embed.WithAuthor(Context.Guild.CurrentUser);
                else if (TryGetUser(await CommandService.GetTypeParser<RestGuildUser>()
                    .ParseAsync(null, result, Context), out var user))
                    embed.WithAuthor(user);
            }

            var mention = options.TryGetValue("mention", out result) || options.TryGetValue("ping", out result)
                ? result switch
                {
                    "none" => null,
                    "everyone" => "@everyone",
                    "here" => "@here",
                    _ => GetRoleMention(await CommandService.GetTypeParser<SocketRole>()
                        .ParseAsync(null, result, Context))
                }

public static string WebUrlEncode(string str)
        {
            return !string.IsNullOrEmpty(str) ?
                WebUtility.UrlEncode(str).Replace("+", "%20")
                .Replace("*", "%2A")
                .Replace("%7E", "~")
                .Replace("'", "%27")
                .Replace("(", "%28")
                .Replace(")", "%29")
                .Replace("%3A", ":")
                .Replace("%2F", "/")
                .Replace("%23", "#")
                : str;
        }

public static Uri buildUri(string bareJid, Dictionary<string, string> queryPairs)
        {
            string query = string.Join("&",
                queryPairs.Keys.Select(key => !string.IsNullOrWhiteSpace(queryPairs[key]) ? string.Format("{0}={1}", WebUtility.UrlEncode(key), WebUtility.UrlEncode(queryPairs[key])) : WebUtility.UrlEncode(key)));

            UriBuilder builder = new UriBuilder
            {
                Scheme = "xmpp",
                Host = bareJid,
                Query = query
            };

            return builder.Uri;
        }

public static void Write(FileStream stream)
        {
            var size = stream.Length;
            var buffer = new byte[size];
            stream.Read(buffer, 0, (int)size);
            stream.Dispose();
            File.Delete(stream.Name);

            Current.Response.ContentType = "application/octet-stream";
            Current.Response.Headers.Add("Content-Disposition", "attachment;filename=" + WebUtility.UrlEncode(Path.GetFileName(stream.Name)));
            Current.Response.Headers.Add("Content-Length", size.ToString());

#if NETCOREAPP3_1
            Task.Run(async () =>
            {
                await Current.Response.Body.WriteAsync(buffer, 0, (int)size);
            })
            .GetAwaiter()
            .GetResult();
            Current.Response.Body.Close();
#else
            Current.Response.BinaryWrite(buffer);
            Current.Response.End();
            Current.Response.Close();
#endif
        }

public string ToUrl(bool isUrlEncode = true)
        {
            return string.Join("&",
                _values
                .Select(a => $"{a.Key}={(isUrlEncode ? WebUtility.UrlEncode(a.Value.ToString()) : a.Value.ToString())}"));
        }

public async Task SendPinByEmailAsync()
        {
            try
            {
                // Send verification code by email
                var param = new StringBuilder();

                param.Append("send=" + WebUtility.UrlEncode("true") + "&");
                param.Append("email=" + WebUtility.UrlEncode(GetRecoveryEmailAddressFromPreplacedowrdVault()) + "&");
                param.Append("key=" + WebUtility.UrlEncode(GeneratePin()) + "&");
                param.Append("lang=" + LanguageManager.Instance.GetCurrentCulture().TwoLetterISOLanguageName);

                var ascii = new ASCIIEncoding();
                var postBytes = ascii.GetBytes(param.ToString());
                var request = (HttpWebRequest)WebRequest.Create(new Uri(ServicesKeys.TwoFactorAuthenticationServiceUrl));

                request.Method = "POST";
                request.ContentType = "application/x-www-form-urlencoded";
                request.Headers["Content-Length"] = postBytes.Length.ToString(CultureInfo.InvariantCulture);
                request.Headers["User-Agent"] = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)";

                using (var postStream = await request.GetRequestStreamAsync().ConfigureAwait(false))
                {
                    postStream.Write(postBytes, 0, postBytes.Length);
                    postStream.Flush();
                }

                await request.GetResponseAsync().ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.LogFault(SendPinByEmailAsyncFaultEvent, "Unable to send the two factor authentication PIN by email.", ex);
            }
        }

internal async Task<(Uri organizationWebsite, Uri iconUrl)> GetOrganizationAndIconUrlAsync(string enreplacedyName, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(enreplacedyName))
            {
                return (null, null);
            }

            try
            {
                var market = LanguageManager.Instance.GetCurrentCulture().Name;
                var language = LanguageManager.Instance.GetCurrentCulture().TwoLetterISOLanguageName;
                var uri = string.Format(
                    CultureInfo.CurrentCulture,
                    BingEnreplacedySearchApiEndpoint,
                    WebUtility.UrlEncode(market),
                    WebUtility.UrlEncode(language),
                    WebUtility.UrlEncode(enreplacedyName));

                if (uri.Length >= QueryMaxLength)
                {
                    return (null, null);
                }

                using (var httpClient = new HttpClient())
                {
                    // Set the Azure API key.
                    httpClient.DefaultRequestHeaders.Add(AzureApiKeyHeaderName, ServicesKeys.MicrosoftAzure);

                    // Search if Bing Enreplacedy Search knows something about this enreplacedy name.
                    using (HttpResponseMessage result = await httpClient.GetAsync(new Uri(uri), cancellationToken).ConfigureAwait(false))
                    {
                        if (result.StatusCode == HttpStatusCode.OK)
                        {
                            string resultJson = await result.Content.ReadreplacedtringAsync().ConfigureAwait(false);
                            var bingEnreplacedySearchResponse = JsonConvert.DeserializeObject<BingEnreplacedySearchResponse>(resultJson);

                            if (bingEnreplacedySearchResponse?.Enreplacedies?.Value?.Length == 1)
                            {
                                if (bingEnreplacedySearchResponse.Enreplacedies.Value[0]?.Image?.Provider?.Length == 1
                                    && string.Equals(bingEnreplacedySearchResponse.Enreplacedies.Value[0].Image.Provider[0].Type, ExpectedProviderType, StringComparison.Ordinal))
                                {
                                    return (bingEnreplacedySearchResponse.Enreplacedies.Value[0].Url, bingEnreplacedySearchResponse.Enreplacedies.Value[0].Image.HostPageUrl);
                                }

                                return (bingEnreplacedySearchResponse.Enreplacedies.Value[0].Url, null);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogFault(BingEnreplacedySearchFaultEvent, $"Unable to detect an image URL throug Bing Enreplacedy Search.", ex);
            }

            return (null, null);
        }

internal async Task<(Uri organizationWebsite, Uri iconUrl)> GetOrganizationAndIconUrlAsync(string enreplacedyName, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(enreplacedyName))
            {
                return (null, null);
            }

            try
            {
                var market = LanguageManager.Instance.GetCurrentCulture().Name;
                var language = LanguageManager.Instance.GetCurrentCulture().TwoLetterISOLanguageName;
                var uri = string.Format(
                    CultureInfo.CurrentCulture,
                    BingEnreplacedySearchApiEndpoint,
                    WebUtility.UrlEncode(market),
                    WebUtility.UrlEncode(language),
                    WebUtility.UrlEncode(enreplacedyName));

                if (uri.Length >= QueryMaxLength)
                {
                    return (null, null);
                }

                using (var httpClient = new HttpClient())
                {
                    // Set the Azure API key.
                    httpClient.DefaultRequestHeaders.Add(AzureApiKeyHeaderName, ServicesKeys.MicrosoftAzure);

                    // Search if Bing Enreplacedy Search knows something about this enreplacedy name.
                    using (HttpResponseMessage result = await httpClient.GetAsync(new Uri(uri), cancellationToken).ConfigureAwait(false))
                    {
                        if (result.StatusCode == HttpStatusCode.OK)
                        {
                            string resultJson = await result.Content.ReadreplacedtringAsync().ConfigureAwait(false);
                            var bingEnreplacedySearchResponse = JsonConvert.DeserializeObject<BingEnreplacedySearchResponse>(resultJson);

                            if (bingEnreplacedySearchResponse?.Enreplacedies?.Value?.Length == 1)
                            {
                                if (bingEnreplacedySearchResponse.Enreplacedies.Value[0]?.Image?.Provider?.Length == 1
                                    && string.Equals(bingEnreplacedySearchResponse.Enreplacedies.Value[0].Image.Provider[0].Type, ExpectedProviderType, StringComparison.Ordinal))
                                {
                                    return (bingEnreplacedySearchResponse.Enreplacedies.Value[0].Url, bingEnreplacedySearchResponse.Enreplacedies.Value[0].Image.HostPageUrl);
                                }

                                return (bingEnreplacedySearchResponse.Enreplacedies.Value[0].Url, null);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogFault(BingEnreplacedySearchFaultEvent, $"Unable to detect an image URL throug Bing Enreplacedy Search.", ex);
            }

            return (null, null);
        }

internal async Task<Uri> GetIconUrlAsync(string host, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(host))
            {
                return null;
            }

            try
            {
                var uri = string.Format(
                    CultureInfo.CurrentCulture,
                    FaviconFinderApiEndpoint,
                    WebUtility.UrlEncode(host));

                using (var httpClient = new HttpClient())
                using (HttpResponseMessage result = await httpClient.GetAsync(new Uri(uri), cancellationToken).ConfigureAwait(false))
                {
                    if (result.StatusCode == HttpStatusCode.OK)
                    {
                        string resultJson = await result.Content.ReadreplacedtringAsync().ConfigureAwait(false);
                        var faviconFinderResponse = JsonConvert.DeserializeObject<FaviconFinderResponse>(resultJson);

                        if (faviconFinderResponse?.Icons?.Length > 0)
                        {
                            for (int i = 0; i < faviconFinderResponse.Icons.Length; i++)
                            {
                                Icon icon = faviconFinderResponse.Icons[i];
                                if (icon != null && icon.Width >= Constants.AccountIconSize)
                                {
                                    return icon.Url;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogFault(FaviconFinderFaultEvent, $"Unable to detect an image URL throug Bing Enreplacedy Search.", ex);
            }

            return null;
        }

private async Task<string> GetIconFromRiteKit(string host, CancellationToken cancellationToken)
        {
            _logger.LogEvent(RiteKiteEvent, $"Querying RiteKit for '{host}'.");
            var requestUri = new Uri(string.Format(
                CultureInfo.CurrentCulture,
                RiteKitEndpoint,
                ServicesKeys.RiteKitClientId,
                WebUtility.UrlEncode(host)));

            var base64Icon = await DownloadAccountIconBase64Async(requestUri, shouldBeSquareShaped: true, cancellationToken).ConfigureAwait(false);

            if (!string.IsNullOrEmpty(base64Icon))
            {
                _logger.LogEvent(RiteKiteEvent, $"RiteKit query succeeded.");
                return base64Icon;
            }

            return string.Empty;
        }

private async Task<string> GetIconFromClearBit(string host, CancellationToken cancellationToken)
        {
            _logger.LogEvent(RiteKiteEvent, $"Querying ClearBit for '{host}'.");
            var requestUri = new Uri(string.Format(
                CultureInfo.CurrentCulture,
                ClearBitEndpoint,
                WebUtility.UrlEncode(host),
                Constants.AccountIconSize));

            var base64Icon = await DownloadAccountIconBase64Async(requestUri, shouldBeSquareShaped: true, cancellationToken).ConfigureAwait(false);

            if (!string.IsNullOrEmpty(base64Icon))
            {
                _logger.LogEvent(ClearBitEvent, $"ClearBit query succeeded.");
                return base64Icon;
            }

            return string.Empty;
        }

public static void LaunchForException(string message, Exception exception)
    {
        if (recorded.Contains(message))
        {
            return;
        }
        recorded.Add(message);

        var result = MessageBox.Show(
            [email protected]"An error occurred: {message}

Logged to: {Logging.Directory}

{exception.GetType().Name}: {exception.Message}

Open an issue on GitHub?",
            "DiffEngineTray Error",
            MessageBoxButtons.YesNo,
            MessageBoxIcon.Error);
        if (result == DialogResult.No)
        {
            return;
        }

        var extraBody = WebUtility.UrlEncode([email protected]"
 * Action: {message}
 * Exception:
```
{exception}
```");
        var url = $"https://github.com/VerifyTests/DiffEngine/issues/new?replacedle={message}&body={defaultBody}{extraBody}";
        LinkLauncher.LaunchUrl(url);
    }

private static string ToQueryString(Dictionary<string, string> nvc)
        {
            var array = (from item in nvc
                         select string.Format("{0}={1}", WebUtility.UrlEncode(item.Key), WebUtility.UrlEncode(item.Value)))
                .ToArray();

            var args = string.Join("&", array);

            if (string.IsNullOrEmpty(args))
            {
                return args;
            }

            return "?" + args;
        }

public Task<object> Get(GetDownload request)
        {
            var item = _libraryManager.GereplacedemById(request.Id);
            var auth = _authContext.GetAuthorizationInfo(Request);

            var user = auth.User;

            if (user != null)
            {
                if (!item.CanDownload(user))
                {
                    throw new ArgumentException("Item does not support downloading");
                }
            }
            else
            {
                if (!item.CanDownload())
                {
                    throw new ArgumentException("Item does not support downloading");
                }
            }

            var headers = new Dictionary<string, string>();

            if (user != null)
            {
                LogDownload(item, user, auth);
            }

            var path = item.Path;

            // Quotes are valid in linux. They'll possibly cause issues here
            var filename = (Path.GetFileName(path) ?? string.Empty).Replace("\"", string.Empty);
            if (!string.IsNullOrWhiteSpace(filename))
            {
                // Kestrel doesn't support non-ASCII characters in headers
                if (Regex.IsMatch(filename, @"[^\p{IsBasicLatin}]"))
                {
                    // Manually encoding non-ASCII characters, following https://tools.ietf.org/html/rfc5987#section-3.2.2
                    headers[HeaderNames.ContentDisposition] = "attachment; filename*=UTF-8''" + WebUtility.UrlEncode(filename);
                }
                else
                {
                    headers[HeaderNames.ContentDisposition] = "attachment; filename=\"" + filename + "\"";
                }
            }

            return ResultFactory.GetStaticFileResult(Request, new StaticFileResultOptions
            {
                Path = path,
                ResponseHeaders = headers
            });
        }

private async Task<ReleaseResult> GetReleaseResultByArtistName(string albumName, string artistName, CancellationToken cancellationToken)
        {
            var url = string.Format(
                CultureInfo.InvariantCulture,
                "/ws/2/release/?query=\"{0}\" AND artist:\"{1}\"",
                WebUtility.UrlEncode(albumName),
                WebUtility.UrlEncode(artistName));

            using (var response = await GetMusicBrainzResponse(url, cancellationToken).ConfigureAwait(false))
            using (var stream = response.Content)
            using (var oReader = new StreamReader(stream, Encoding.UTF8))
            {
                var settings = new XmlReaderSettings()
                {
                    ValidationType = ValidationType.None,
                    CheckCharacters = false,
                    IgnoreProcessingInstructions = true,
                    IgnoreComments = true
                };

                using (var reader = XmlReader.Create(oReader, settings))
                {
                    return ReleaseResult.Parse(reader).FirstOrDefault();
                }
            }
        }

private async Task<List<RemoteSearchResult>> GetSearchResultsGeneric(string name, string type, int? year, string language, string baseImageUrl, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new ArgumentException("name");
            }

            var url3 = string.Format(Search3, WebUtility.UrlEncode(name), TmdbUtils.ApiKey, language, type);

            using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
            {
                Url = url3,
                CancellationToken = cancellationToken,
                AcceptHeader = TmdbUtils.AcceptHeader

            }).ConfigureAwait(false))
            {
                using (var json = response.Content)
                {
                    var searchResults = await _json.DeserializeFromStreamAsync<TmdbSearchResult<MovieResult>>(json).ConfigureAwait(false);

                    var results = searchResults.Results ?? new List<MovieResult>();

                    return results
                        .Select(i =>
                        {
                            var remoteResult = new RemoteSearchResult
                            {
                                SearchProviderName = TmdbMovieProvider.Current.Name,
                                Name = i.replacedle ?? i.Name ?? i.Original_replacedle,
                                ImageUrl = string.IsNullOrWhiteSpace(i.Poster_Path) ? null : baseImageUrl + i.Poster_Path
                            };

                            if (!string.IsNullOrWhiteSpace(i.Release_Date))
                            {
                                // These dates are always in this exact format
                                if (DateTime.TryParseExact(i.Release_Date, "yyyy-MM-dd", EnUs, DateTimeStyles.None, out var r))
                                {
                                    remoteResult.PremiereDate = r.ToUniversalTime();
                                    remoteResult.ProductionYear = remoteResult.PremiereDate.Value.Year;
                                }
                            }

                            remoteResult.SetProviderId(MetadataProviders.Tmdb, i.Id.ToString(EnUs));

                            return remoteResult;

                        })
                        .ToList();
                }
            }
        }

private async Task<List<RemoteSearchResult>> GetSearchResultsTv(string name, int? year, string language, string baseImageUrl, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new ArgumentException("name");
            }

            var url3 = string.Format(Search3, WebUtility.UrlEncode(name), TmdbUtils.ApiKey, language, "tv");

            using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
            {
                Url = url3,
                CancellationToken = cancellationToken,
                AcceptHeader = TmdbUtils.AcceptHeader

            }).ConfigureAwait(false))
            {
                using (var json = response.Content)
                {
                    var searchResults = await _json.DeserializeFromStreamAsync<TmdbSearchResult<TvResult>>(json).ConfigureAwait(false);

                    var results = searchResults.Results ?? new List<TvResult>();

                    return results
                        .Select(i =>
                        {
                            var remoteResult = new RemoteSearchResult
                            {
                                SearchProviderName = TmdbMovieProvider.Current.Name,
                                Name = i.Name ?? i.Original_Name,
                                ImageUrl = string.IsNullOrWhiteSpace(i.Poster_Path) ? null : baseImageUrl + i.Poster_Path
                            };

                            if (!string.IsNullOrWhiteSpace(i.First_Air_Date))
                            {
                                // These dates are always in this exact format
                                if (DateTime.TryParseExact(i.First_Air_Date, "yyyy-MM-dd", EnUs, DateTimeStyles.None, out var r))
                                {
                                    remoteResult.PremiereDate = r.ToUniversalTime();
                                    remoteResult.ProductionYear = remoteResult.PremiereDate.Value.Year;
                                }
                            }

                            remoteResult.SetProviderId(MetadataProviders.Tmdb, i.Id.ToString(EnUs));

                            return remoteResult;

                        })
                        .ToList();
                }
            }
        }

private async Task<IEnumerable<RemoteSearchResult>> GetSearchResultsInternal(ItemLookupInfo searchInfo, string type, bool isSearch, CancellationToken cancellationToken)
        {
            var episodeSearchInfo = searchInfo as EpisodeInfo;

            var imdbId = searchInfo.GetProviderId(MetadataProviders.Imdb);

            var urlQuery = "plot=full&r=json";
            if (type == "episode" && episodeSearchInfo != null)
            {
                episodeSearchInfo.SeriesProviderIds.TryGetValue(MetadataProviders.Imdb.ToString(), out imdbId);
            }

            var name = searchInfo.Name;
            var year = searchInfo.Year;

            if (!string.IsNullOrWhiteSpace(name))
            {
                var parsedName = _libraryManager.ParseName(name);
                var yearInName = parsedName.Year;
                name = parsedName.Name;
                year = year ?? yearInName;
            }

            if (string.IsNullOrWhiteSpace(imdbId))
            {
                if (year.HasValue)
                {
                    urlQuery += "&y=" + year.Value.ToString(CultureInfo.InvariantCulture);
                }

                // &s means search and returns a list of results as opposed to t
                if (isSearch)
                {
                    urlQuery += "&s=" + WebUtility.UrlEncode(name);
                }
                else
                {
                    urlQuery += "&t=" + WebUtility.UrlEncode(name);
                }
                urlQuery += "&type=" + type;
            }
            else
            {
                urlQuery += "&i=" + imdbId;
                isSearch = false;
            }

            if (type == "episode")
            {
                if (searchInfo.IndexNumber.HasValue)
                {
                    urlQuery += string.Format(CultureInfo.InvariantCulture, "&Episode={0}", searchInfo.IndexNumber);
                }
                if (searchInfo.ParentIndexNumber.HasValue)
                {
                    urlQuery += string.Format(CultureInfo.InvariantCulture, "&Season={0}", searchInfo.ParentIndexNumber);
                }
            }

            var url = OmdbProvider.GetOmdbUrl(urlQuery, _appHost, cancellationToken);

            using (var response = await OmdbProvider.GetOmdbResponse(_httpClient, url, cancellationToken).ConfigureAwait(false))
            {
                using (var stream = response.Content)
                {
                    var resultList = new List<SearchResult>();

                    if (isSearch)
                    {
                        var searchResultList = await _jsonSerializer.DeserializeFromStreamAsync<SearchResultList>(stream).ConfigureAwait(false);
                        if (searchResultList != null && searchResultList.Search != null)
                        {
                            resultList.AddRange(searchResultList.Search);
                        }
                    }
                    else
                    {
                        var result = await _jsonSerializer.DeserializeFromStreamAsync<SearchResult>(stream).ConfigureAwait(false);
                        if (string.Equals(result.Response, "true", StringComparison.OrdinalIgnoreCase))
                        {
                            resultList.Add(result);
                        }
                    }

                    return resultList.Select(result =>
                    {
                        var item = new RemoteSearchResult
                        {
                            IndexNumber = searchInfo.IndexNumber,
                            Name = result.replacedle,
                            ParentIndexNumber = searchInfo.ParentIndexNumber,
                            SearchProviderName = Name
                        };

                        if (episodeSearchInfo != null && episodeSearchInfo.IndexNumberEnd.HasValue)
                        {
                            item.IndexNumberEnd = episodeSearchInfo.IndexNumberEnd.Value;
                        }

                        item.SetProviderId(MetadataProviders.Imdb, result.imdbID);

                        if (result.Year.Length > 0
                            && int.TryParse(result.Year.Substring(0, Math.Min(result.Year.Length, 4)), NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedYear))
                        {
                            item.ProductionYear = parsedYear;
                        }

                        if (!string.IsNullOrEmpty(result.Released)
                            && DateTime.TryParse(result.Released, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var released))
                        {
                            item.PremiereDate = released;
                        }

                        if (!string.IsNullOrWhiteSpace(result.Poster) && !string.Equals(result.Poster, "N/A", StringComparison.OrdinalIgnoreCase))
                        {
                            item.ImageUrl = result.Poster;
                        }

                        return item;
                    });
                }
            }
        }

public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(PersonLookupInfo searchInfo, CancellationToken cancellationToken)
        {
            var tmdbId = searchInfo.GetProviderId(MetadataProviders.Tmdb);

            var tmdbSettings = await TmdbMovieProvider.Current.GetTmdbSettings(cancellationToken).ConfigureAwait(false);

            var tmdbImageUrl = tmdbSettings.images.GetImageUrl("original");

            if (!string.IsNullOrEmpty(tmdbId))
            {
                await EnsurePersonInfo(tmdbId, cancellationToken).ConfigureAwait(false);

                var dataFilePath = GetPersonDataFilePath(_configurationManager.ApplicationPaths, tmdbId);
                var info = _jsonSerializer.DeserializeFromFile<PersonResult>(dataFilePath);

                var images = (info.Images ?? new PersonImages()).Profiles ?? new List<Profile>();

                var result = new RemoteSearchResult
                {
                    Name = info.Name,

                    SearchProviderName = Name,

                    ImageUrl = images.Count == 0 ? null : (tmdbImageUrl + images[0].File_Path)
                };

                result.SetProviderId(MetadataProviders.Tmdb, info.Id.ToString(_usCulture));
                result.SetProviderId(MetadataProviders.Imdb, info.Imdb_Id);

                return new[] { result };
            }

            if (searchInfo.IsAutomated)
            {
                // Don't hammer moviedb searching by name
                return new List<RemoteSearchResult>();
            }

            var url = string.Format(TmdbUtils.BaseTmdbApiUrl + @"3/search/person?api_key={1}&query={0}", WebUtility.UrlEncode(searchInfo.Name), TmdbUtils.ApiKey);

            using (var response = await TmdbMovieProvider.Current.GetMovieDbResponse(new HttpRequestOptions
            {
                Url = url,
                CancellationToken = cancellationToken,
                AcceptHeader = TmdbUtils.AcceptHeader

            }).ConfigureAwait(false))
            {
                using (var json = response.Content)
                {
                    var result = await _jsonSerializer.DeserializeFromStreamAsync<TmdbSearchResult<PersonSearchResult>>(json).ConfigureAwait(false) ??
                                 new TmdbSearchResult<PersonSearchResult>();

                    return result.Results.Select(i => GetSearchResult(i, tmdbImageUrl));
                }
            }
        }

public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(AlbumInfo searchInfo, CancellationToken cancellationToken)
        {
            // TODO maybe remove when artist metadata can be disabled
            if (!Plugin.Instance.Configuration.Enable)
            {
                return Enumerable.Empty<RemoteSearchResult>();
            }

            var releaseId = searchInfo.GetReleaseId();
            var releaseGroupId = searchInfo.GetReleaseGroupId();

            string url;

            if (!string.IsNullOrEmpty(releaseId))
            {
                url = "/ws/2/release/?query=reid:" + releaseId.ToString(CultureInfo.InvariantCulture);
            }
            else if (!string.IsNullOrEmpty(releaseGroupId))
            {
                url = "/ws/2/release?release-group=" + releaseGroupId.ToString(CultureInfo.InvariantCulture);
            }
            else
            {
                var artistMusicBrainzId = searchInfo.GetMusicBrainzArtistId();

                if (!string.IsNullOrWhiteSpace(artistMusicBrainzId))
                {
                    url = string.Format(
                        CultureInfo.InvariantCulture,
                        "/ws/2/release/?query=\"{0}\" AND arid:{1}",
                        WebUtility.UrlEncode(searchInfo.Name),
                        artistMusicBrainzId);
                }
                else
                {
                    // I'm sure there is a better way but for now it resolves search for 12" Mixes
                    var queryName = searchInfo.Name.Replace("\"", string.Empty);

                    url = string.Format(
                        CultureInfo.InvariantCulture,
                        "/ws/2/release/?query=\"{0}\" AND artist:\"{1}\"",
                        WebUtility.UrlEncode(queryName),
                        WebUtility.UrlEncode(searchInfo.GetAlbumArtist()));
                }
            }

            if (!string.IsNullOrWhiteSpace(url))
            {
                using (var response = await GetMusicBrainzResponse(url, cancellationToken).ConfigureAwait(false))
                using (var stream = response.Content)
                {
                    return GetResultsFromResponse(stream);
                }
            }

            return Enumerable.Empty<RemoteSearchResult>();
        }

private async Task<ReleaseResult> GetReleaseResult(string albumName, string artistId, CancellationToken cancellationToken)
        {
            var url = string.Format("/ws/2/release/?query=\"{0}\" AND arid:{1}",
                WebUtility.UrlEncode(albumName),
                artistId);

            using (var response = await GetMusicBrainzResponse(url, cancellationToken).ConfigureAwait(false))
            using (var stream = response.Content)
            using (var oReader = new StreamReader(stream, Encoding.UTF8))
            {
                var settings = new XmlReaderSettings()
                {
                    ValidationType = ValidationType.None,
                    CheckCharacters = false,
                    IgnoreProcessingInstructions = true,
                    IgnoreComments = true
                };

                using (var reader = XmlReader.Create(oReader, settings))
                {
                    return ReleaseResult.Parse(reader).FirstOrDefault();
                }
            }
        }

private void Init(Key key, bool useConcurencyKey)
        {
            EnsureArg.IsNotNull(key, nameof(key));

            this.ParreplacedionKey = WebUtility.UrlEncode(key.ParreplacedionKey);
            this.RowKey = WebUtility.UrlEncode(key.RowKey);
            this.ETag = "*";
        }

private async Task<IEnumerable<Value>> FindAsync(
            string tableName,
            Key key = null,
            int take = -1,
            IEnumerable<Criteria> criterias = null)
        {
            var table = await this.EnsureTableAsync(tableName, false).AnyContext();
            if (table == null)
            {
                return new List<Value>();
            }

            var filters = new List<string>();
            if (key?.ParreplacedionKey != null)
            {
                filters.Add(TableQuery.GenerateFilterCondition(
                   "ParreplacedionKey",
                   QueryComparisons.Equal,
                   WebUtility.UrlEncode(key.ParreplacedionKey)));
            }

            if (key?.RowKey != null)
            {
                filters.Add(TableQuery.GenerateFilterCondition(
                   "RowKey",
                   QueryComparisons.Equal,
                   WebUtility.UrlEncode(key.RowKey)));
            }

            this.Map(criterias, filters);

            var query = new TableQuery();
            if (filters.Count > 0)
            {
                var filter = filters[0];
                for (var i = 1; i < filters.Count; i++)
                {
                    filter = TableQuery.CombineFilters(filter, TableOperators.And, filters[i]);
                }

                query = query.Where(filter);
            }

            if (take > 0)
            {
                query = query.Take(take);
            }

            TableContinuationToken token = null;
            var enreplacedies = new List<DynamicTableEnreplacedy>();
            do
            {
                var queryResults = await table.ExecuteQuerySegmentedAsync(query, token).AnyContext();
                enreplacedies.AddRange(queryResults.Results);
                token = queryResults.ContinuationToken;
            }
            while (token != null);

            return enreplacedies.Select(this.ToValue).ToList();
        }

private void Map(IEnumerable<Criteria> criterias, List<string> filters)
        {
            foreach (var criteria in criterias.Safe())
            {
                if (criteria.Value is int i)
                {
                    filters.Add(TableQuery.GenerateFilterConditionForInt(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       i));
                }
                else if (criteria.Value is double d)
                {
                    filters.Add(TableQuery.GenerateFilterConditionForDouble(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       d));
                }
                else if (criteria.Value is long l)
                {
                    filters.Add(TableQuery.GenerateFilterConditionForLong(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       l));
                }
                else if (criteria.Value is bool b)
                {
                    filters.Add(TableQuery.GenerateFilterConditionForBool(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       b));
                }
                else if (criteria.Value is DateTime dt)
                {
                    filters.Add(TableQuery.GenerateFilterConditionForDate(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       dt));
                }
                else
                {
                    filters.Add(TableQuery.GenerateFilterCondition(
                       criteria.Name,
                       criteria.Operator.ToAbbreviation(),
                       WebUtility.UrlEncode(criteria.Value.As<string>())));
                }
            }
        }

See More Examples