/// <summary>
/// This method is used to get a commit author's full name via the github rest api.
/// Reference: https://docs.github.com/en/rest
/// For an example response: https://api.github.com/repos/Azure/iotedge/commits/704250b
/// </summary>
/// <param name="commit">Commit for which to get the author's full name.</param>
/// <returns>Full name of author.</returns>
public async Task <string> GetAuthorFullNameFromCommitAsync(string commit)
{
string requestPath = string.Format(UserPathSegmentFormat, commit);
IFlurlRequest workItemQueryRequest = ((Url)requestPath)
.WithHeader("Content-Type", "application/json")
.WithHeader("User-Agent", "Azure/iotedge");
JObject result;
try
{
IFlurlResponse response = await workItemQueryRequest.GetAsync();
result = await response.GetJsonAsync <JObject>();
string fullName = result["commit"]["author"]["name"].ToString();
return(fullName);
}
catch (FlurlHttpException e)
{
string message = $"Failed making call to commit api: {e.Message}";
Console.WriteLine(message);
Console.WriteLine(e.Call.RequestBody);
Console.WriteLine(e.Call.Response.StatusCode);
Console.WriteLine(e.Call.Response.ResponseMessage);
throw new Exception(message);
}
}
public static async Task <ASMessageResponse> ToAngleSharpResponse(
this IFlurlRequest flurlRequest,
Func <IFlurlRequest, Task <HttpResponseMessage> > executionPredicate,
CancellationToken cancellationToken = default
)
{
// conversion from *flurl's* custom URL to *anglesharp's* custom URL
// apparently .NET's URI just sucks that much
var uri = flurlRequest.Url.ToUri();
var url = Url.Convert(uri);
if (executionPredicate == null)
{
Task <IFlurlResponse> flurlResponseMessageTask = flurlRequest.GetAsync(cancellationToken);
var flurlResponseMessage = await flurlResponseMessageTask.ConfigureAwait(false);
var content = await flurlResponseMessage.ResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(new ASMessageResponse(url, flurlResponseMessage.ResponseMessage, content));
}
else
{
Task <HttpResponseMessage> httpResponseMessageTask = executionPredicate(flurlRequest);
var httpResponseMessage = await httpResponseMessageTask.ConfigureAwait(false);
var content = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(new ASMessageResponse(url, httpResponseMessage, content));
}
}
private static async Task <HttpResponseMessage> SendSimpleAsync(IFlurlRequest flurlRequest, WebRequestContext requestContext)
{
HttpResponseMessage result = default;
try
{
requestContext.AttemptCnt++;
if (requestContext.MethodType == WebMethodType.GET)
{
result = await flurlRequest.GetAsync();
}
else if (requestContext.MethodType == WebMethodType.POST)
{
result = await flurlRequest.PostJsonAsync((string)requestContext);
}
}
catch (FlurlHttpException flurlException)
{
if (flurlException.Call.Response != null &&
requestContext.AttemptCnt < WebConfig.ReTryCount)
{
result = await SendSimpleAsync(flurlRequest, requestContext);
}
}
catch (Exception)
{
}
return(result);
}
public IEnumerable <TResponse> Enumerate(IFlurlRequest request)
{
request.AllowHttpStatus(HttpStatusCode.NotFound);
var more = true;
while (more)
{
// Need headers & result so capture task first: https://stackoverflow.com/a/53514668/129269
var task = request.GetAsync();
var response = task.ConfigureAwait(false).GetAwaiter().GetResult();
if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new NotFoundException(request.Url.ToString());
}
var data = task.ReceiveJson <Multiple <TResponse> >().ConfigureAwait(false).GetAwaiter().GetResult();
foreach (var item in data.Value)
{
yield return(item);
}
more = response.Headers.TryGetValues("x-ms-continuationtoken", out var tokens);
request.SetQueryParam("continuationToken", tokens?.First());
}
}
public static async Task <dynamic> GetRequest(string[] PathSegments)
{
IFlurlRequest request = TrackIt_2019.API.BaseUri.AppendPathSegments(PathSegments).WithOAuthBearerToken((string)TrackIt_2019.API.Authentication.Token.access_token);
dynamic result = await request.GetAsync().ReceiveJson();
return(result);
}
public static Task <T> GetJsonAsync <T>(this IFlurlRequest request, ReadToken <T> readToken) where T : class
{
// Will never return null because no null status codes are provided
#pragma warning disable CS8619 // Nullability of reference types in value doesn't match target type.
return(request.SendJsonAsync(request => request.GetAsync(), readToken, false));
#pragma warning restore CS8619 // Nullability of reference types in value doesn't match target type.
}
public async Task <APIServiceResult <T> > GetById <T>(int id, string pathToAppend = "", bool eagerLoaded = false)
{
try
{
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
if (eagerLoaded)
{
request.SetQueryParam("eagerLoaded", "true");
}
HttpResponseMessage response = null;
request.Url.AppendPathSegment(id.ToString());
response = await request.GetAsync();
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
if (response.Content != null)
{
var errorMessage = await response.Content.ReadAsStringAsync();
return(APIServiceResult <T> .BadRequest(errorMessage));
}
}
return(APIServiceResult <T> .WithStatusCode(response.StatusCode));
}
var result = await response.Content.ReadAsAsync <T>();
return(APIServiceResult <T> .OK(result));
}
catch (FlurlHttpTimeoutException ex)
{
return(APIServiceResult <T> .Exception());
}
catch (FlurlHttpException ex)
{
return(APIServiceResult <T> .Exception());
}
catch (Exception ex)
{
return(APIServiceResult <T> .Exception());
}
}
public Task <T> GetAsync <T>(CancellationToken token, string uri)
{
IFlurlRequest request = _flurlClient.Request(uri)
.WithTimeout(_timeOut)
.WithHeaders(_headers);
if (!string.IsNullOrEmpty(AllowHttpStatus))
{
request.AllowHttpStatus(AllowHttpStatus);
}
return(request.GetAsync().ReceiveJson <T>());
}
public async Task <Result <DigitalOceanGetDomainRecordsResponse> > GetDNSRecordsAsync(DigitalOceanDomain domain, string token, CancellationToken cancellation)
{
string path = string.Format(_getDNSRecordsFormat, domain.Name);
IFlurlRequest httpRequest = BuildRequest(token, path);
IFlurlResponse response = await httpRequest.GetAsync(cancellation);
HttpResponseMessage message = response.ResponseMessage;
if (message.IsSuccessStatusCode)
{
string content = await message.Content.ReadAsStringAsync();
DigitalOceanGetDomainRecordsResponse records = JsonConvert.DeserializeObject <DigitalOceanGetDomainRecordsResponse>(content);
return(Result.Ok(records).WithSuccess(string.Format(_getDNSRecordsSuccessMessageTemplate, records.DomainRecords.Count(), domain.Name)));
}
return(Result.Fail(string.Format(_getDNSRecordsFailureMessageTemplate, domain.Name)));
}
public async Task <Result <GoDaddyGetDNSRecordsResponse> > GetDNSRecordsAsync(GoDaddyGetDNSRecordsRequest request, CancellationToken cancellation)
{
string path = string.Format(_getDNSRecordsFormat, request.DomainName, request.DNSRecordType.Value);
IFlurlRequest httpRequest = BuildRequest(request.ApiKey, request.ApiSecret, path);
IFlurlResponse response = await httpRequest.GetAsync(cancellation);
HttpResponseMessage message = response.ResponseMessage;
if (message.StatusCode == HttpStatusCode.OK)
{
string content = await message.Content.ReadAsStringAsync();
IEnumerable <GoDaddyGetDNSRecordResponse> records = JsonConvert.DeserializeObject <List <GoDaddyGetDNSRecordResponse> >(content);
string resultMessage = string.Format(_getDNSRecordsSuccessMessageTemplate, records.Count(), request.DomainName);
return(Result.Ok(new GoDaddyGetDNSRecordsResponse(records)).WithSuccess(resultMessage));
}
return(Result.Fail(string.Format(_getDNSRecordsFailureMessageTemplate, request.DomainName)));
}
public async Task <FnsResult> LoginAsync(string phone, string password)
{
if (string.IsNullOrEmpty(phone))
{
throw new ArgumentNullException(nameof(phone));
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException(nameof(password));
}
IFlurlRequest request = Urls.Login.WithClient(_client);
request = AddAuthorizationHeaders(request, phone, password);
var response = await request.GetAsync();
return(await GetResultAsync(response));
}
/// <summary>
/// Получить перечисление высших школ
/// </summary>
/// <returns>Перечисление с высшими школами</returns>
/// <exception cref="FlurlHttpException">Выбрасывается, если сайт не вернул положительный Http код</exception>
public async Task <IEnumerable <School> > GetSchools()
{
var response = await _client.GetAsync();
var doc = new HtmlDocument();
doc.Load(await response.Content.ReadAsStreamAsync());
var schools = doc.DocumentNode
.SelectNodes("//div[@id='classic']/div[contains(@class, 'institution_button')]/a")
.Select(x => new School
{
Id = int.Parse(x.Attributes["href"].Value.Split('=')[1]),
Url = $"{Constants.EndPoint}/{x.Attributes["href"].Value.Replace("&", "&")}",
Name = x.InnerText.Trim()
})
.Distinct();
return(schools);
}
/// <summary>
/// This method is used to retrieve all the team members for the larger iotedge team.
/// Reference: https://docs.microsoft.com/en-us/rest/api/azure/devops/graph/users/list?view=azure-devops-rest-6.0
/// </summary>
/// <returns>List of users. Each containing full name and email.</returns>
public async Task <IList <VstsUser> > ListUsersAsync()
{
string requestPath = string.Format(UserPathSegmentFormat, DevOpsAccessSetting.UserManagementBaseUrl, DevOpsAccessSetting.IotedgeOrganization);
IFlurlRequest workItemQueryRequest = ((Url)requestPath)
.WithBasicAuth(string.Empty, this.accessSetting.IotedgePAT)
.WithHeader("Content-Type", "application/json")
.SetQueryParam("api-version", "6.0-preview.1");
JObject result;
try
{
IFlurlResponse response = await workItemQueryRequest.GetAsync();
result = await response.GetJsonAsync <JObject>();
}
catch (FlurlHttpException e)
{
string message = $"Failed making call to list user api: {e.Message}";
Console.WriteLine(message);
Console.WriteLine(e.Call.RequestBody);
Console.WriteLine(e.Call.Response.StatusCode);
Console.WriteLine(e.Call.Response.ResponseMessage);
throw new Exception(message);
}
if (!result.ContainsKey("count") || (int)result["count"] <= 0)
{
return(new VstsUser[0]);
}
IList <VstsUser> users = JsonConvert.DeserializeObject <VstsUser[]>(result["value"].ToString());
return(users);
}
public static async Task <PagedResponse <T> > GetPagedJsonAsync <T>(this IFlurlRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var task = request.GetAsync(cancellationToken);
var r = await task.ConfigureAwait(false);
var data = await task.ReceiveJson <List <T> >().ConfigureAwait(false);
var p = new PagedResponse <T>
{
Data = data
};
if (long.TryParse(r.GetHeaderValue(HeaderNames.Before), out var before))
{
p.Before = before;
}
if (long.TryParse(r.GetHeaderValue(HeaderNames.After), out var after))
{
p.After = after;
}
return(p);
}
public static async Task <PagedResponse <T> > GetPagedJsonAsync <T>(this IFlurlRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var task = request.GetAsync(cancellationToken);
var r = await task.ConfigureAwait(false);
var data = await task.ReceiveJson <List <T> >().ConfigureAwait(false);
var p = new PagedResponse <T>
{
Data = data
};
if (r.Headers.TryGetFirst(HeaderNames.Before, out var beforeString))
{
p.Before = beforeString;
}
if (r.Headers.TryGetFirst(HeaderNames.After, out var afterString))
{
p.After = afterString;
}
return(p);
}
public static Task <T?> GetJsonAsync <T>(this IFlurlRequest request, ReadToken <T> readToken, bool defaultIfNotJson, params HttpStatusCode[] defaultStatusCodes) where T : class
{
return(request.SendJsonAsync(request => request.GetAsync(), readToken, defaultIfNotJson, defaultStatusCodes));
}
public async Task <FnsReceiptDetailInfo> GetReceiptAsync(ReceiptMainInfo receiptInfo, string phone, string password)
{
if (!await ReceiptExistsAsync(receiptInfo))
{
return(null);
}
// Формируем запрос.
IFlurlRequest request = Urls.GetReceiveUrl(receiptInfo.FiscalNumber, receiptInfo.FiscalDocument, receiptInfo.FiscalSign).WithClient(_client);
request = AddRequiredHeaders(request);
request = AddAuthorizationHeaders(request, phone, password);
// Запрашиваем данные из ФНС.
HttpResponseMessage response = null;
const int retires = 4;
for (int i = 0; i < retires; i++)
{
try
{
response = await request.GetAsync();
if (response.StatusCode != HttpStatusCode.Accepted)
{
break;
}
await Task.Delay(TimeSpan.FromMilliseconds(500));
}
catch (Exception ex)
{
_logger.Error($"Во время выполнения запроса информации о чеке (попытка №{i}) произошло исключение", ex);
}
}
if (response == null || response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
var result = new ReceiptFnsResult
{
IsSuccess = response.IsSuccessStatusCode,
StatusCode = response.StatusCode,
};
// Десериализуем ответ.
try
{
string json = await response.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(json))
{
result.Document = JsonConvert.DeserializeObject <RootObject>(json).Document;
}
}
catch (Exception ex)
{
_logger.Error($"Во время десериализации информации о чеке произошло исключение", ex);
}
if (result.Document?.ReceiptInfo == null)
{
return(null);
}
return(result.Document?.ReceiptInfo);
}
protected override Task <HttpResponseMessage> CallOnFlurlRequest(IFlurlRequest req) => req.GetAsync();
private async Task <ServiceResult <TResult> > ResolveHttpResponseAsync <TResult>(DoType type, int retryCount, IFlurlRequest webApiObject, object bodyObject = null, int secondsTimeout = 30, string callerMemberName = null)
{
var _retMessage = "";
ReturnMessage _message;
HttpResponseMessage _exec = null;
HttpStatusCode _HttpStatusCode = HttpStatusCode.BadRequest;
var _policyResult = await Policy
.Handle <FlurlHttpTimeoutException>().Or <FlurlHttpException>().Or <Exception>()
.RetryAsync(retryCount, (exception, retryNumber) =>
{
System.Diagnostics.Debug.WriteLine($"==================================================================");
System.Diagnostics.Debug.WriteLine($"Method: {callerMemberName} -> Retry: number#{retryNumber} -> exception:{exception.Message}");
System.Diagnostics.Debug.WriteLine($"==================================================================");
})
.ExecuteAndCaptureAsync(new Func <Task <ServiceResult <TResult> > >(async() =>
{
var _token = this.GetCancelationToken(secondsTimeout).Token;
var _content = "";
#if DEBUG
var _json = JsonConvert.SerializeObject(bodyObject);
#endif
switch (type)
{
case DoType.Get:
_exec = await webApiObject.GetAsync(_token);
break;
case DoType.Post:
_exec = await webApiObject.PostJsonAsync(bodyObject, _token);
break;
case DoType.Put:
_exec = await webApiObject.PutJsonAsync(bodyObject, _token);
break;
case DoType.Delete:
_exec = bodyObject == null ? await webApiObject.DeleteAsync(_token) : await webApiObject.SendJsonAsync(HttpMethod.Delete, bodyObject, _token);
break;
}
switch (_exec.StatusCode)
{
case HttpStatusCode.OK:
switch (type)
{
case DoType.Get:
case DoType.Post:
case DoType.Put:
// lê o retorno do serviço
var _stringContent = await _exec.Content.ReadAsStringAsync();
// checa se está nulo, se estiver manda uma string vazia
_stringContent = string.IsNullOrEmpty(_stringContent) ? "" : _stringContent;
// vê se o conteúdo é um json, se não for, formatamos para que seja
TResult _result = default(TResult);
if (this.IsValidJson(_stringContent))
{
_result = JsonConvert.DeserializeObject <TResult>(_stringContent);
}
else
{
_result = (TResult)Convert.ChangeType(_stringContent, typeof(TResult), CultureInfo.CurrentCulture);
}
// retornamos o resultado deserializando no formato informado
return(new ServiceResult <TResult>(_result, true, _exec.StatusCode));
case DoType.Delete:
object _RetBool = true;
return(new ServiceResult <TResult>((TResult)_RetBool, true, _exec.StatusCode));
}
break;
case HttpStatusCode.Unauthorized:
_retMessage = $"Você não está autorizado a executar essa rotina: {callerMemberName}!\r\nPor favor contacte o suporte.";
break;
case HttpStatusCode.InternalServerError:
case HttpStatusCode.BadRequest:
_content = await _exec.Content.ReadAsStringAsync();
try
{
_message = JsonConvert.DeserializeObject <ReturnMessage>(_content);
_retMessage = _message.Message;
}
catch (Exception)
{
_retMessage = _content;
}
break;
case HttpStatusCode.NoContent:
return(new ServiceResult <TResult>(default(TResult), false, _exec.StatusCode));
case HttpStatusCode.NotFound:
return(new ServiceResult <TResult>(default(TResult), false, _exec.StatusCode));
default:
_content = await _exec.Content.ReadAsStringAsync();
_message = JsonConvert.DeserializeObject <ReturnMessage>(_content);
_retMessage = $"Ocorreu um erro ao executar operação na rotina {callerMemberName}!\r\nPor favor contacte o suporte:\r\n\r\n{_message.Message}";
break;
}
_HttpStatusCode = _exec.StatusCode;
return(new ServiceResult <TResult>(default(TResult), false, _HttpStatusCode, _retMessage));
}));
if (_policyResult.Outcome == OutcomeType.Successful)
{
return(_policyResult.Result);
}
else
{
switch (_policyResult.FinalException)
{
case FlurlHttpTimeoutException fhtex:
_HttpStatusCode = HttpStatusCode.GatewayTimeout;
_retMessage = $"O tempo para execução desta tarefa expirou!Rotina{callerMemberName}\r\nTente novamente em alguns segundos.";
break;
case FlurlHttpException fhex:
string _retString = fhex.Message;
if (fhex.Call.HttpStatus.HasValue)
{
_HttpStatusCode = fhex.Call.HttpStatus.Value;
switch (fhex.Call.HttpStatus.Value)
{
case HttpStatusCode.InternalServerError:
case HttpStatusCode.BadRequest:
_retMessage = fhex.Call.Response.Content.ReadAsStringAsync().Result;
break;
}
}
else
{
//_retMessage = $"Ocorreu um erro ao executar a operação na rotina {callerMemberName}!\r\nPor favor contacte o suporte:\r\n\r\n{_retString}";
_retMessage = $"Não foi possível executar a sua solicitação. Verifique a sua conexão com a Internet e tente novamente.";
}
break;
case Exception ex:
_retMessage = this.GetInnerExceptionMessages(ex);
break;
default:
_retMessage = this.GetInnerExceptionMessages(_policyResult.FinalException);
break;
}
return(new ServiceResult <TResult>(default(TResult), false, _HttpStatusCode, _retMessage));
}
}
private async Task <Response> ProxyRequest(NancyContext context, CancellationToken cancellationToken)
{
string path = Strings.Encode(context.Request.Path);
string method = Strings.Encode(context.Request.Method.ToUpperInvariant());
if (!path.StartsWith("/nfsw/Engine.svc"))
{
Log.Error("PROXY HANDLER: Invalid Request: " + path);
return("SBRW Launcher Version: " + Theming.PrivacyRPCBuild + "\nBuild Date: " + InsiderInfo.BuildNumberOnly());
}
else
{
path = path.Substring("/nfsw/Engine.svc".Length);
UrlFlurl resolvedUrl = new UrlFlurl(ServerProxy.Instance.GetServerUrl()).AppendPathSegment(path, false);
foreach (var queryParamName in context.Request.Query)
{
resolvedUrl = resolvedUrl.SetQueryParam(queryParamName, context.Request.Query[queryParamName],
NullValueHandling.Ignore);
}
IFlurlRequest request = resolvedUrl.AllowAnyHttpStatus();
foreach (var header in context.Request.Headers)
{
/* Don't send Content-Length for GET requests - HeyItsLeo */
if (method == "GET" && header.Key.ToLowerInvariant() == "content-length")
{
continue;
}
request = request.WithHeader
(header.Key, (header.Key == "Host") ? resolvedUrl.ToUri().Host : ((header.Value != null) ? header.Value.First() : string.Empty));
}
string requestBody = (method != "GET") ? context.Request.Body.AsString(UTF8) : string.Empty;
CommunicationLog.RecordEntry(ServerProxy.Instance.GetServerName(), "SERVER", CommunicationLogEntryType.Request,
new CommunicationLogRequest(requestBody, resolvedUrl.ToString(), method));
IFlurlResponse responseMessage;
if (path == "/event/arbitration" && !string.IsNullOrWhiteSpace(requestBody))
{
requestBody = Strings.Encode(
requestBody.Replace("</TopSpeed>", "</TopSpeed><Konami>" + AntiCheat.Get_Cheat_Status() + "</Konami>"));
foreach (var header in context.Request.Headers)
{
if (header.Key.ToLowerInvariant() == "content-length")
{
int KonamiCode = Convert.ToInt32(header.Value.First()) +
("<Konami>" + AntiCheat.Get_Cheat_Status() + "</Konami>").Length;
request = request.WithHeader(header.Key, KonamiCode);
}
}
}
switch (method)
{
case "GET":
responseMessage = await request.GetAsync(cancellationToken);
break;
case "POST":
responseMessage = await request.PostAsync(new CapturedStringContent(requestBody),
cancellationToken);
break;
case "PUT":
responseMessage = await request.PutAsync(new CapturedStringContent(requestBody),
cancellationToken);
break;
case "DELETE":
responseMessage = await request.DeleteAsync(cancellationToken);
break;
default:
Log.Error("PROXY HANDLER: Cannot handle Request Method " + method);
responseMessage = null;
break;
}
string responseBody = Strings.Encode(await responseMessage.GetStringAsync());
int statusCode = responseMessage.StatusCode;
DiscordGamePresence.HandleGameState(path, responseBody, context.Request.Query);
TextResponse Response = new TextResponse(responseBody,
responseMessage.ResponseMessage.Content.Headers.ContentType?.MediaType ?? "application/xml;charset=UTF-8")
{
StatusCode = (HttpStatusCode)statusCode
};
CommunicationLog.RecordEntry(ServerProxy.Instance.GetServerName(), "SERVER", CommunicationLogEntryType.Response,
new CommunicationLogResponse(responseBody, resolvedUrl.ToString(), method));
return(Response);
}
}
public async Task <APIServiceResult <T> > GetAsSingle <T>(string pathToAppend = "", Dictionary <string, string> queryStringCollection = null)
{
try
{
if (queryStringCollection != null)
{
foreach (var queryString in queryStringCollection)
{
request.Url.QueryParams.Add(queryString.Key, queryString.Value);
}
}
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
var response = await request.GetAsync();
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
dlgError.ShowDialog(Resources.AccessDenied);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
var msg = string.Empty;
if (response.Content != null)
{
msg = await response.Content.ReadAsStringAsync();
}
dlgError.ShowDialog(msg);
}
return(APIServiceResult <T> .WithStatusCode(response.StatusCode));
}
object result;
if (typeof(T) == typeof(DateTime))
{
var textPlain = await response.Content.ReadAsStringAsync();
var dateTimeResult =
DateTime.Parse(textPlain, CultureInfo.InvariantCulture);;
result = dateTimeResult;
}
else
{
result = await response.Content.ReadAsAsync <T>();
}
if (response.StatusCode == HttpStatusCode.OK && result == null)
{
return(APIServiceResult <T> .OK());
}
return(new APIServiceResult <T>
{
Data = (T)result,
HasData = result != null
});
}
catch (Exception ex)
{
logger.Error(ex);
dlgError.ShowDialog(Resources.TemporarilyUnvailable);
return(APIServiceResult <T> .Exception());
}
}
private async Task <Response> ProxyRequest(NancyContext context, CancellationToken cancellationToken)
{
string path = context.Request.Path;
string method = context.Request.Method.ToUpperInvariant();
if (!path.StartsWith("/nfsw/Engine.svc"))
{
throw new ProxyException("Invalid request path: " + path);
}
path = path.Substring("/nfsw/Engine.svc".Length);
Url resolvedUrl = new Url(ServerProxy.Instance.GetServerUrl()).AppendPathSegment(path);
foreach (var queryParamName in context.Request.Query)
{
resolvedUrl = resolvedUrl.SetQueryParam(queryParamName, context.Request.Query[queryParamName],
NullValueHandling.Ignore);
}
IFlurlRequest request = resolvedUrl.AllowAnyHttpStatus();
foreach (var header in context.Request.Headers)
{
request = request.WithHeader(header.Key,
header.Key == "Host" ? resolvedUrl.ToUri().Host : header.Value.First());
}
var requestBody = context.Request.Method != "GET" ? context.Request.Body.AsString(Encoding.UTF8) : "";
CommunicationLog.RecordEntry(ServerProxy.Instance.GetServerName(), "SERVER",
CommunicationLogEntryType.Request,
new CommunicationLogRequest(requestBody, resolvedUrl.ToString(), method));
HttpResponseMessage responseMessage;
var POSTContent = String.Empty;
var queryParams = new Dictionary <string, object>();
foreach (var param in context.Request.Query)
{
var value = context.Request.Query[param];
queryParams[param] = value;
}
var GETContent = string.Join(";", queryParams.Select(x => x.Key + "=" + x.Value).ToArray());
// ReSharper disable once LocalizableElement
//Console.WriteLine($"[LOG] [{method}] ProxyHandler: {path}");
switch (method)
{
case "GET":
responseMessage = await request.GetAsync(cancellationToken);
break;
case "POST":
responseMessage = await request.PostAsync(new CapturedStringContent(requestBody, Encoding.UTF8),
cancellationToken);
POSTContent = context.Request.Body.AsString();
break;
case "PUT":
responseMessage = await request.PutAsync(new CapturedStringContent(requestBody, Encoding.UTF8),
cancellationToken);
break;
case "DELETE":
responseMessage = await request.DeleteAsync(cancellationToken);
break;
default:
throw new ProxyException("Cannot handle request method: " + method);
}
var responseBody = await responseMessage.Content.ReadAsStringAsync();
if (path == "/User/GetPermanentSession")
{
responseBody = Self.CleanFromUnknownChars(responseBody);
}
int statusCode = (int)responseMessage.StatusCode;
try
{
DiscordGamePresence.HandleGameState(path, responseBody, POSTContent, GETContent);
}
catch (Exception e)
{
Log.Error($"DISCORD RPC ERROR [handling {context.Request.Path}]");
Log.Error($"\tMESSAGE: {e.Message}");
Log.Error($"\t{e.StackTrace}");
await Self.SubmitError(e);
}
TextResponse textResponse = new TextResponse(responseBody,
responseMessage.Content.Headers.ContentType?.MediaType ?? "application/xml;charset=UTF-8")
{
StatusCode = (HttpStatusCode)statusCode
};
queryParams.Clear();
CommunicationLog.RecordEntry(ServerProxy.Instance.GetServerName(), "SERVER",
CommunicationLogEntryType.Response, new CommunicationLogResponse(
responseBody, resolvedUrl.ToString(), method));
return(textResponse);
}
private async Task <Response> ProxyRequest(NancyContext ctx, CancellationToken ct)
{
Debug.WriteLine("{0} - {1}", ctx.Request.Method, ctx.Request.Path);
foreach (var requestHeader in ctx.Request.Headers)
{
Debug.WriteLine("\t{0}: {1}", requestHeader.Key, string.Join(" ; ", requestHeader.Value));
}
// Build new request
var url = new Flurl.Url(ServerProxy.Instance.GetCurrentServer().ServerAddress)
.AppendPathSegment(ctx.Request.Path.Replace("/nfsw/Engine.svc", ""));
foreach (var key in ctx.Request.Query)
{
url = url.SetQueryParam(key, ctx.Request.Query[key], NullValueHandling.Ignore);
}
IFlurlRequest request = url.WithTimeout(TimeSpan.FromSeconds(30));
foreach (var requestHeader in ctx.Request.Headers)
{
request = request.WithHeader(requestHeader.Key, requestHeader.Value.First());
}
HttpResponseMessage responseMessage;
switch (ctx.Request.Method)
{
case "GET":
responseMessage = await request.GetAsync(ct);
break;
case "POST":
responseMessage =
await request.PostAsync(new CapturedStringContent(ctx.Request.Body.AsString(Encoding.UTF8)), ct);
break;
case "PUT":
responseMessage =
await request.PutAsync(new CapturedStringContent(ctx.Request.Body.AsString(Encoding.UTF8)), ct);
break;
case "DELETE":
responseMessage =
await request.DeleteAsync(ct);
break;
default:
throw new ServerProxyException("Cannot handle request method: " + ctx.Request.Method);
}
return(new TextResponse(await responseMessage.Content.ReadAsStringAsync(),
responseMessage.Content.Headers.ContentType?.MediaType ?? "application/xml;charset=UTF-8")
{
StatusCode = (HttpStatusCode)(int)responseMessage.StatusCode
});
}
