protected string AddFacetToUrl(object dataItem)
{
Tuple<FacetValue, Item, string> tuple = dataItem as Tuple<FacetValue, Item, string>;
Url url = new Url(Request.RawUrl);
url.RemoveQueryParam(SearchResultsManager.PageQueryString);
List<Guid> allFacets = SearchResultsManager.ExtractFacetsFromQueryString(QueryStringParameter);
if (allFacets.Contains(tuple.Item2.ID.Guid))
{
allFacets.Remove(tuple.Item2.ID.Guid);
}
else
{
allFacets.Add(tuple.Item2.ID.Guid);
}
string fullQueryString = String.Join("|", allFacets.Distinct());
url.QueryParams[QueryStringParameter] = fullQueryString;
return url;
}
protected string AddFacetToUrl(object dataItem)
{
Tuple <FacetValue, Item, string> tuple = dataItem as Tuple <FacetValue, Item, string>;
Url url = new Url(Request.RawUrl);
url.RemoveQueryParam(SearchResultsManager.PageQueryString);
List <Guid> allFacets = SearchResultsManager.ExtractFacetsFromQueryString(QueryStringParameter);
if (allFacets.Contains(tuple.Item2.ID.Guid))
{
allFacets.Remove(tuple.Item2.ID.Guid);
}
else
{
allFacets.Add(tuple.Item2.ID.Guid);
}
string fullQueryString = String.Join("|", allFacets.Distinct());
url.QueryParams[QueryStringParameter] = fullQueryString;
return(url);
}
public void Flurl()
{
//for (int i = 0; i < 1_000_000; i++)
{
_ = new Flurl.Url(_uri);
}
}
/// <summary>
/// request url that specified by yourself with get method.
/// according the package Flurl.Http.GeneratedExtensions to rewrite it in order to debug, develop.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="cancellationToken"></param>
/// <param name="completionOption"></param>
/// <returns></returns>
public static Task <T> GetJsonAsync <T>(this Flurl.Url url, CancellationToken cancellationToken = default(CancellationToken), HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
{
var request = new FlurlRequest(url);
var result = request.GetJsonAsync <T>(cancellationToken, completionOption);
return(result);
}
public async Task <IDictionary <string, BatchResponse> > GetQuotesAsync(IEnumerable <string> symbols, CancellationToken cancellationToken)
{
if (!symbols.Any())
{
return(new Dictionary <string, BatchResponse>());
}
var url = new Flurl.Url(BaseUrl)
.AppendPathSegment("/stock/market/batch")
.SetQueryParams(new
{
types = "quote",
symbols = string.Join(',', symbols),
token = this.options.Token
});
var httpClient = this.httpClientFactory.CreateClient();
var response = await httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();
var quotes = JsonConvert.DeserializeObject <Dictionary <string, BatchResponse> >(content);
return(quotes);
}
public async Task ExecuteRoutine(string id)
{
Flurl.Url url = new Flurl.Url(_apiUrl);
await url.AppendPathSegments("routines", id)
.WithHeader("Authorization", string.Format("Bearer " + _apiToken))
.PostAsync(new StringContent(""));
}
protected string RemoveFacets()
{
Url url = new Url(Request.RawUrl);
url.RemoveQueryParam(QueryStringParameter);
return(url);
}
public ActionResult Redirect(string url, IDictionary <string, string> parameters)
{
var matches = _placeHolderMatcher.Matches(url);
if (matches.Count > 0)
{
var values = new List <string>();
foreach (Match match in matches)
{
if (!values.Contains(match.Value))
{
values.Add(match.Value);
}
}
var names = new List <string>();
foreach (var value in values)
{
var left = value.Split(':')[0];
if (left.ToCharArray().All(c => c >= '0' && c <= '9'))
{
continue;
}
if (!names.Contains(left))
{
names.Add(left);
}
}
var count = 0;
var args = new List <object>();
foreach (var name in names)
{
if (parameters.ContainsKey(name))
{
args.Add(parameters[name]);
url = url.Replace("{" + name, "{" + count);
count++;
}
else
{
_orchardServices.Notifier.Error(T("Can not find parameter {0} for BatchRedirect url.", name));
return(null);
}
}
url = string.Format(url, args.ToArray());
}
url = url.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? url : VirtualPathUtility.ToAbsolute(url);
var flurl = new Flurl.Url(url);
foreach (var p in parameters)
{
flurl.QueryParams.Add(p.Key, p.Value);
}
return(new RedirectResult(flurl.ToString()));
}
/// <summary>
/// request url that specified by yourself with post method.
/// according the package Flurl.Http.GeneratedExtensions to rewrite it in order to debug, develop.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="cancellationToken"></param>
/// <param name="completionOption"></param>
/// <returns></returns>
public static Task <T> PostJsonAsync <T>(this Flurl.Url url, object data, CancellationToken cancellationToken = default(CancellationToken), HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
{
var request = new FlurlRequest(url);
CapturedJsonContent content = new CapturedJsonContent(request.Settings.JsonSerializer.Serialize(data));
var response = request.SendAsync(HttpMethod.Post, content, cancellationToken, completionOption);
var result = response.ReceiveJson <T>();
return(result);
}
/// <summary>
/// Makes the HTTP request to the IATAHttpService.
/// </summary>
/// <param name="airportIATACode">The airport iata code.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">airportIATACode</exception>
/// <exception cref="HttpRequestException"></exception>
public async Task <IATAHttpServiceResponse> MakeHttpRequest(string airportIATACode)
{
if (string.IsNullOrWhiteSpace(airportIATACode))
{
throw new ArgumentNullException(nameof(airportIATACode));
}
//Todo: Move url, timeout and number of retries in settings object.
string url = Url.Combine("https://places-dev.cteleport.com/airports/", airportIATACode);
int retries = 5;
double timeout = Math.Pow(2, 5);
CachePolicy <HttpResponseMessage> cachePolicy = CreateCachePolicy(MemoryCacheProvider);
RetryPolicy <HttpResponseMessage> waitAndRetryPolicy = CreateWaitAndRetryPolicy(retries);
HttpClientHandler handler = new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.GZip
};
using (HttpClient client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
client.Timeout = TimeSpan.FromSeconds(timeout);
Context context = new Context(url);
HttpResponseMessage response = await cachePolicy.ExecuteAsync(
async() =>
{
return(await waitAndRetryPolicy.ExecuteAsync(
async() =>
{
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
return await client.SendAsync(requestMessage, HttpCompletionOption.ResponseContentRead);
}
));
},
context
);
await response.Content.LoadIntoBufferAsync();
string responseContent = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException($"An unexpected errpr occured while trying to call \"{url}\". Status: {response.StatusCode}. Content: {responseContent}.");
}
return(ExtractResponse(responseContent));
}
}
public static Flurl.Url WithPagination(this Flurl.Url url, PaginationOptions opts)
{
if (opts is null)
{
return(url);
}
return(url.SetQueryParam("limit", opts.Limit)
.SetQueryParam("order", opts.Order)
.SetQueryParam("starting_after", opts.StartingAfter)
.SetQueryParam("ending_before", opts.EndingBefore));
}
public async Task <List <SymbolDescription> > GetSymbolsAsync(CancellationToken cancellationToken)
{
var url = new Flurl.Url(BaseUrl).AppendPathSegment("/ref-data/symbols").SetQueryParam("token", this.options.Token);
var httpClient = this.httpClientFactory.CreateClient();
var response = await httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();
var symbolDescriptions = JsonConvert.DeserializeObject <List <SymbolDescription> >(content);
return(symbolDescriptions);
}
public async Task <string> GetCurrentMode()
{
Flurl.Url url = new Flurl.Url(_apiUrl);
string content = await url.AppendPathSegment("locations")
.WithHeader("Authorization", string.Format("Bearer " + _apiToken))
.GetStringAsync();
Console.WriteLine(content);
var json = JObject.Parse(content);
string currentMode = json["currentMode"]["name"].Value <string>();
return(currentMode);
}
protected async Task <IDocument> GetDocument(
Url url,
CancellationToken cancellationToken)
{
var delta = DateTime.Now - _lastRequestTime;
if (delta < RequestInterval)
{
await Task.Delay(delta, cancellationToken);
}
var document = await Context.OpenAsync(url, cancellation : cancellationToken);
_lastRequestTime = DateTime.Now;
return(document);
}
public void AppendPathSegments_ValidMultiplePath_ReturnCorrectUrl()
{
var uriBuildler = new UriBuilder()
{
Scheme = "https",
Host = "https://www.abc.com"
};
var path1 = "xx";
var path2 = "yy";
// https://www.hanselman.com/blog/UsingFlurlToEasilyBuildURLsAndMakeTestableHttpClientCallsInNET.aspx
var url = new UrlHelper(uriBuildler.Uri);
url.AppendPathSegments(path1, path2);
Assert.Equal("https://www.abc.com/xx/yy", url);
}
public async Task <Company> GetCompanyAsync(string symbol, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(symbol))
{
throw new ArgumentException("Invalid symbol", nameof(symbol));
}
var url = new Flurl.Url(BaseUrl).AppendPathSegments("stock", symbol, "company").SetQueryParam("token", this.options.Token);
var httpClient = this.httpClientFactory.CreateClient();
var response = await httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();
var companyInfo = JsonConvert.DeserializeObject <Company>(content);
return(companyInfo);
}
protected async Task <IDocument> GetDocument(
Url url,
CancellationToken cancellationToken)
{
var delta = DateTime.Now - _lastRequestTime;
if (delta < RequestInterval)
{
await Task.Delay(delta, cancellationToken);
}
var response = await url.GetStreamAsync(cancellationToken);
var document = await Context.OpenAsync(
req => req.Content(response),
cancellationToken);
_lastRequestTime = DateTime.Now;
return(document);
}
public async Task <IEnumerable <Routine> > ListRoutines()
{
Flurl.Url url = new Flurl.Url(_apiUrl);
string content = await url.AppendPathSegment("routines")
.WithHeader("Authorization", string.Format("Bearer " + _apiToken))
.GetStringAsync();
Console.WriteLine(content);
var array = JArray.Parse(content);
List <Routine> items = new List <Routine>();
foreach (var item in array)
{
items.Add(new Routine()
{
Label = item["label"].Value <string>(),
Id = item["id"].Value <string>(),
});
}
return(items);
}
public async Task <IEnumerable <Device> > ListDevices()
{
Flurl.Url url = new Flurl.Url(_apiUrl);
string content = await url.AppendPathSegment("switches")
.WithHeader("Authorization", string.Format("Bearer " + _apiToken))
.GetStringAsync();
Console.WriteLine(content);
var array = JArray.Parse(content);
List <Device> devices = new List <Device>();
foreach (var item in array)
{
devices.Add(new Device()
{
Name = item["name"].Value <string>(),
State = string.Equals(item["value"].Value <string>(), "on", StringComparison.OrdinalIgnoreCase) ? DeviceState.On : DeviceState.Off
});
}
return(devices);
}
/// <summary>
/// request url that specified by yourself with get method.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="cancellationToken"></param>
/// <param name="completionOption"></param>
/// <returns></returns>
public static Task <T> GetJsonAsync <T>(this string url, CancellationToken cancellationToken = default(CancellationToken), HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
{
Flurl.Url urlObj = url;
return(urlObj.GetJsonAsync <T>(cancellationToken, completionOption));
}
private static Response ProxyRequest(NancyContext context)
{
string POSTContent = String.Empty;
string GETContent = String.Empty;
var serverUrl = ServerProxy.Instance.GetServerUrl();
if (string.IsNullOrEmpty(serverUrl))
{
return(new TextResponse(HttpStatusCode.BadGateway, "Not open for business"));
}
var fixedPath = context.Request.Path.Replace("/nfsw/Engine.svc", "");
var fullUrl = new Uri(serverUrl).Append(fixedPath);
Console.WriteLine($@"{context.Request.Method} {fixedPath}");
var queryParams = new Dictionary <string, object>();
var headers = new Dictionary <string, object>();
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
GETContent = string.Join(";", queryParams.Select(x => x.Key + "=" + x.Value).ToArray());
foreach (var header in context.Request.Headers)
{
headers[header.Key] = header.Value.First();
}
var url = new Flurl.Url(fullUrl.ToString())
.SetQueryParams(queryParams)
.WithHeaders(headers);
HttpResponseMessage response;
switch (context.Request.Method)
{
case "GET":
{
response = url.GetAsync().Result;
//response = await url.GetAsync();
break;
}
case "POST":
{
POSTContent = context.Request.Body.AsString();
response = url.PostAsync(
new CapturedStringContent(
POSTContent
)
).Result;
break;
}
case "PUT":
{
response = url.PutAsync(
new CapturedStringContent(
context.Request.Body.AsString()
)
).Result;
break;
}
case "DELETE":
{
response = url.DeleteAsync().Result;
break;
}
default:
{
throw new Exception($"unsupported method: {context.Request.Method}");
}
}
DiscordRPC.handleGameState(fixedPath, response.Content.ReadAsStringAsync().Result, POSTContent, GETContent);
return(new TextResponse(
response.Content.ReadAsStringAsync().Result,
response.Content.Headers.ContentType.ToString()
)
{
StatusCode = (HttpStatusCode)(int)response.StatusCode
});
}
private static Response ProxyRequest(NancyContext context)
{
//MessageBox.Show("ProxyRequest");
string POSTContent = String.Empty;
string GETContent = String.Empty;
Self.sendRequest = true;
var serverUrl = ServerProxy.Instance.GetServerUrl();
if (string.IsNullOrEmpty(serverUrl))
{
return(new TextResponse(HttpStatusCode.BadGateway, "Not open for business"));
}
var queryParams = new Dictionary <string, object>();
var headers = new Dictionary <string, object>();
if (Self.sendRequest == true)
{
var fixedPath = context.Request.Path.Replace("/nfsw/Engine.svc", "");
var fullUrl = new Uri(serverUrl).Append(fixedPath);
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
GETContent = string.Join(";", queryParams.Select(x => x.Key + "=" + x.Value).ToArray());
foreach (var header in context.Request.Headers)
{
headers[header.Key] = (header.Key == "Host") ? fullUrl.Host : header.Value.First();
}
var url = new Flurl.Url(fullUrl.ToString()).SetQueryParams(queryParams).WithHeaders(headers);
HttpResponseMessage response;
switch (context.Request.Method)
{
case "GET":
{
response = url.GetAsync().Result;
break;
}
case "POST":
{
POSTContent = context.Request.Body.AsString();
response = url.PostAsync(
new CapturedStringContent(
POSTContent
)
).Result;
break;
}
case "PUT":
{
response = url.PutAsync(
new CapturedStringContent(
context.Request.Body.AsString()
)
).Result;
break;
}
case "DELETE":
{
response = url.DeleteAsync().Result;
break;
}
default:
{
throw new Exception($"unsupported method: {context.Request.Method}");
}
}
String replyToServer = response.Content.ReadAsStringAsync().Result;
/*if (fixedPath == "/getrebroadcasters"){
* replyToServer = Regex.Replace(replyToServer, @"<Host>(.*?)<\/Host>", "<Host>37.233.101.12</Host>");
* replyToServer = Regex.Replace(replyToServer, @"<Port>(.*?)<\/Port>", "<Port>9999</Port>");
* }*/
if (fixedPath == "/User/GetPermanentSession")
{
replyToServer = Self.CleanFromUnknownChars(replyToServer);
var SBRW_XML = new XmlDocument();
SBRW_XML.LoadXml(replyToServer);
XmlNode UserInfo = SBRW_XML.SelectSingleNode("UserInfo");
XmlNodeList personas = UserInfo.SelectNodes("personas/ProfileData");
if (personas.Count == 0)
{
replyToServer = replyToServer.Replace("false", "true");
}
}
if (fixedPath == "")
{
}
if (checkOnline)
{
DiscordGamePresence.handleGameState(fixedPath, replyToServer, POSTContent, GETContent);
}
return(new TextResponse(replyToServer, response.Content.Headers.ContentType.ToString())
{
StatusCode = (HttpStatusCode)(int)response.StatusCode
});
}
else
{
var fullUrl = new Uri(Self.internetcheckurl);
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
foreach (var header in context.Request.Headers)
{
headers[header.Key] = (header.Key == "Host") ? fullUrl.Host : header.Value.First();
}
var url = new Flurl.Url(fullUrl.ToString()).SetQueryParams().WithHeaders(headers);
HttpResponseMessage response;
switch (context.Request.Method)
{
case "GET": { response = url.GetAsync().Result; break; }
case "POST": { POSTContent = context.Request.Body.AsString(); response = url.PostAsync(new CapturedStringContent(POSTContent)).Result; break; }
default: { throw new Exception($"unsupported method: {context.Request.Method}"); }
}
Self.sendRequest = true;
return(new TextResponse(String.Empty, response.Content.Headers.ContentType.ToString())
{
StatusCode = (HttpStatusCode)(int)response.StatusCode
});
}
}
protected string RemoveFacets()
{
Url url = new Url(Request.RawUrl);
url.RemoveQueryParam(QueryStringParameter);
return url;
}
private static string SanitizeRelativeSrcUrl(string url, int idx) => url != null?Url.Combine($"https://{Domain}/", url.Substring(idx)) : null;
protected Task <JsonDocument> GetJson(
Url url,
CancellationToken cancellationToken)
{
return(GetJson(new FlurlRequest(url), cancellationToken));
}
private static Response ProxyRequest(NancyContext context)
{
string POSTContent = String.Empty;
string GETContent = String.Empty;
Self.sendRequest = true;
Dictionary <string, string> powerups = new Dictionary <string, string>();
powerups.Add("-1681514783", "NITROUS");
powerups.Add("-537557654", "RUN FLATS");
powerups.Add("-1692359144", "INSTANT COOLDOWN");
powerups.Add("-364944936", "SHIELD");
powerups.Add("2236629", "SLINGSHOT");
powerups.Add("957701799", "READY");
powerups.Add("1805681994", "JUGGERNAUT");
powerups.Add("-611661916", "EMERGENCY EVADE");
powerups.Add("-1564932069", "TEAM EMERGENCY EVADE");
powerups.Add("1627606782", "ONE MORE LAP");
powerups.Add("1113720384", "TEAM SLINGSHOT");
powerups.Add("125509666", "TRAFFIC MAGNET");
if (Regex.Match(context.Request.Path, "/powerups/activated/", RegexOptions.IgnoreCase).Success)
{
String activatedHash = context.Request.Path.Split('/').Last();
try {
Console.WriteLine("--- CHECK ACTIVATED POWERUPS ---");
foreach (KeyValuePair <string, bool> entry in executedPowerups)
{
Console.WriteLine(powerups[entry.Key] + ": " + entry.Value);
}
} catch {
Console.WriteLine("No activated powerups were found!");
}
executedPowerups.TryGetValue(activatedHash, out activated);
if (activated)
{
var notification = new NotifyIcon()
{
Visible = true,
Icon = System.Drawing.SystemIcons.Information,
BalloonTipIcon = ToolTipIcon.Info,
BalloonTipTitle = "Powerup Spam Detected",
BalloonTipText = "Hey! You can't use " + powerups[activatedHash] + " right now. Therefore, this powerup has been disabled till next event/freeroam session.",
};
notification.ShowBalloonTip(5000);
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainScreen));
notification.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
notification.Dispose();
Self.sendRequest = false;
}
else
{
executedPowerupsRemainingSecs[activatedHash] = 14;
System.Timers.Timer poweruptimer = new System.Timers.Timer();
poweruptimer.Elapsed += (x, y) => {
if (activatedHash == "957701799")
{
foreach (KeyValuePair <string, bool> allpowerups in executedPowerups)
{
executedPowerups[allpowerups.Key] = false;
executedPowerupsRemainingSecs[allpowerups.Key] = 0;
executedPowerups.Remove(allpowerups.Key);
executedPowerupsRemainingSecs.Remove(allpowerups.Key);
}
executedPowerups[activatedHash] = false;
executedPowerupsRemainingSecs[activatedHash] = 0;
poweruptimer.Close();
}
else
{
if (executedPowerupsRemainingSecs[activatedHash] == 0)
{
executedPowerups[activatedHash] = false;
executedPowerupsRemainingSecs[activatedHash] = 0;
poweruptimer.Close();
}
else
{
executedPowerups[activatedHash] = true;
executedPowerupsRemainingSecs[activatedHash] -= 1;
}
}
};
poweruptimer.Interval = 1000;
poweruptimer.Enabled = true;
}
}
var serverUrl = ServerProxy.Instance.GetServerUrl();
if (string.IsNullOrEmpty(serverUrl))
{
return(new TextResponse(HttpStatusCode.BadGateway, "Not open for business"));
}
var queryParams = new Dictionary <string, object>();
var headers = new Dictionary <string, object>();
if (Self.sendRequest == true)
{
var fixedPath = context.Request.Path.Replace("/nfsw/Engine.svc", "");
var fullUrl = new Uri(serverUrl).Append(fixedPath);
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
GETContent = string.Join(";", queryParams.Select(x => x.Key + "=" + x.Value).ToArray());
foreach (var header in context.Request.Headers)
{
headers[header.Key] = (header.Key == "Host") ? fullUrl.Host : header.Value.First();
}
var url = new Flurl.Url(fullUrl.ToString()).SetQueryParams(queryParams).WithHeaders(headers);
HttpResponseMessage response;
switch (context.Request.Method)
{
case "GET": {
response = url.GetAsync().Result;
break;
}
case "POST": {
POSTContent = context.Request.Body.AsString();
response = url.PostAsync(
new CapturedStringContent(
POSTContent
)
).Result;
break;
}
case "PUT": {
response = url.PutAsync(
new CapturedStringContent(
context.Request.Body.AsString()
)
).Result;
break;
}
case "DELETE": {
response = url.DeleteAsync().Result;
break;
}
default: {
throw new Exception($"unsupported method: {context.Request.Method}");
}
}
String replyToServer = response.Content.ReadAsStringAsync().Result;
/*if (fixedPath == "/getrebroadcasters"){
* replyToServer = Regex.Replace(replyToServer, @"<Host>(.*?)<\/Host>", "<Host>37.233.101.12</Host>");
* replyToServer = Regex.Replace(replyToServer, @"<Port>(.*?)<\/Port>", "<Port>9999</Port>");
* }*/
if (fixedPath == "/User/GetPermanentSession")
{
replyToServer = Self.CleanFromUnknownChars(replyToServer);
var SBRW_XML = new XmlDocument();
SBRW_XML.LoadXml(replyToServer);
XmlNode UserInfo = SBRW_XML.SelectSingleNode("UserInfo");
XmlNodeList personas = UserInfo.SelectNodes("personas/ProfileData");
if (personas.Count == 0)
{
replyToServer = replyToServer.Replace("false", "true");
}
}
if (fixedPath == "")
{
}
Log.Debug($@"{context.Request.Method} {fixedPath} -> {POSTContent} -> {GETContent} -> {replyToServer}");
DiscordGamePresence.handleGameState(fixedPath, replyToServer, POSTContent, GETContent);
return(new TextResponse(replyToServer, response.Content.Headers.ContentType.ToString())
{
StatusCode = (HttpStatusCode)(int)response.StatusCode
});
}
else
{
var fullUrl = new Uri(Self.internetcheckurl);
Log.Debug($@"{context.Request.Method} -> {fullUrl}");
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
foreach (var header in context.Request.Headers)
{
headers[header.Key] = (header.Key == "Host") ? fullUrl.Host : header.Value.First();
}
var url = new Flurl.Url(fullUrl.ToString()).SetQueryParams().WithHeaders(headers);
HttpResponseMessage response;
switch (context.Request.Method)
{
case "GET": { response = url.GetAsync().Result; break; }
case "POST": { POSTContent = context.Request.Body.AsString(); response = url.PostAsync(new CapturedStringContent(POSTContent)).Result; break; }
default: { throw new Exception($"unsupported method: {context.Request.Method}"); }
}
Self.sendRequest = true;
return(new TextResponse(String.Empty, response.Content.Headers.ContentType.ToString())
{
StatusCode = (HttpStatusCode)(int)response.StatusCode
});
}
}
public static AbstractForm CreateOpenInBrowserForm(string formId, string formBody, Flurl.Url url, INavigationService navService)
{
return(CreateSingleButtonForm(formId, formBody, "Open in browser",
async(sender, e) => await navService.OpenInBrowser(url)));
}
