public static async Task InternalExceptionHandler(HttpContext context)
{
context.Response.StatusCode = StatusCodes.Status200OK;
context.Response.ContentType = "application/json";
var response = Responses.Error();
var exceptionDetails = context.Features.Get <IExceptionHandlerFeature>();
var exception = exceptionDetails?.Error;
if (exception != null)
{
if (exception is MyException ex)
{
response = new RawResponse
{
Code = ex.Code,
Message = ex.Value,
Data = ex.ToString()
};
}
//var stream = httpContext.Response.Body;
//await JsonSerializer.SerializeAsync(stream, response, JsonSerializerOptions());
var text = JsonSerializer.Serialize(response, JsonUtils.DefaultOptions());
await context.Response.WriteAsync(text);
}
}
public async Task <RawResponse> PrivateRequest(SignedRequest req)
{
if (apiKey == null || apiSecret == null)
{
throw new BinanceClientNotConfigured($"API key and API secret must be set before making private/signed requests. Provided: {apiKey}, {apiSecret}");
}
if (!req.IsValid())
{
//TODO: proper exception
throw new Exception("Signed Request not valid");
}
var response = await ReqAsync(req.BuildSignedUrl(apiSecret), req.Method, req.UseApiKey);
Console.WriteLine("URL: " + response.RequestMessage.RequestUri.ToString());
Console.WriteLine(response.StatusCode);
if (!response.IsSuccessStatusCode)
{
throw new BinanceFailedRequest($"Request failed with status code: {response.StatusCode}. Request URL: {response.RequestMessage.RequestUri.ToString()}");
}
_lastResponse = await RawResponse.FromHttpResponse(response);
return(_lastResponse);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private RawResponse openRaw(HttpWebRequest request)
{
RawResponse rawResponse = null;
try
{
try
{
httpWebResponse = (HttpWebResponse)request.GetResponse();
}
catch (WebException ex)
{
httpWebResponse = (HttpWebResponse)ex.Response;
}
int code = (int)httpWebResponse.StatusCode;
String mensajeCode = httpWebResponse.StatusCode.ToString();
streamReader = new StreamReader(httpWebResponse.GetResponseStream(), Encoding.UTF8);
String responseFromServer = streamReader.ReadToEnd();
rawResponse = new RawResponse(mensajeCode, code, responseFromServer);
}
catch (IOException e)
{
throw new Exception(e.Message);
}
finally
{
httpWebResponse.Close();
}
return(rawResponse);
}
public async Task JsonTypingTest()
{
var payload = @"
{
""string1"": 1,
""num1"": 1,
""string2"": ""2"",
""num2"": ""2"",
""string3"": ""3"",
""num3"": 3,
""string4"": ""4"",
""num4"": 4
}
";
var resp = new RawResponse
{
Method = HttpMethod.Get,
Body = payload,
StatusCode = HttpStatusCode.OK,
StatusMessage = "test",
ContentType = "application/json"
} as IRawResponse;
var actual = Transport.ParseResponse <TestModel, Exception>(resp).Value;
Assert.Equal("1", actual.string1);
Assert.Equal(1, actual.num1);
Assert.Equal("2", actual.string2);
Assert.Equal(2, actual.num2);
Assert.Equal("3", actual.string3);
Assert.Equal(3, actual.num3);
}
private void ParseRawResponseKeyValues()
{
_keyValuePairs = new Dictionary <string, string>();
if (RawResponse.StartsWith("error:"))
{
ErrorMessage = RawResponse;
}
string[] lines = RawResponse.Split(_lineSeparator);
if (lines.Length == 0)
{
return;
}
foreach (var line in lines)
{
string[] kvp = line.Split(_keyValueSeparator);
if (kvp.Length < 2)
{
continue;
}
_keyValuePairs.Add(kvp[0].Trim(), kvp[1].Trim());
}
AssignModelValues();
}
/// <summary>
/// Realiza una petición a un servidor web.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Response open(Request request)
{
HttpWebRequest httpWebRequest = null;
if (request.getMethod().ToString() == Request.HttpMethod.POST.ToString())
{
httpWebRequest = WebRequest(request);
soapEnvelopeXml = request.getXMlDocument();
string xml = soapEnvelopeXml.OuterXml;
using (Stream stream = httpWebRequest.GetRequestStream())
{
using (StreamWriter stmw = new StreamWriter(stream))
{
stmw.Write(xml);
}
}
httpWebResponse = default(HttpWebResponse);
}
RawResponse rawResponse = openRaw(httpWebRequest);
return(new Response(rawResponse.getXML(), rawResponse.getContenido(), rawResponse.getCode()));
}
public static ServerFullStateResponse ParseFullState(RawResponse rawResponse)
{
if (rawResponse.RawData.Length <= 5)
{
throw new IncorrectPackageDataException(rawResponse.RawData);
}
var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(rawResponse.RawData));
reader.Advance(1); // Skip Type
var sessionId = ParseSessionId(ref reader);
if (!reader.IsNext(constant1, advancePast: true))
{
throw new IncorrectPackageDataException(rawResponse.RawData);
}
var statusKeyValues = new Dictionary <string, string>();
while (!reader.IsNext(0, advancePast: true))
{
var key = ReadString(ref reader);
var value = ReadString(ref reader);
statusKeyValues.Add(key, value);
}
if (!reader.IsNext(constant2, advancePast: true)) // Padding: 10 bytes constant
{
throw new IncorrectPackageDataException(rawResponse.RawData);
}
var players = new List <string>();
while (!reader.IsNext(0, advancePast: true))
{
players.Add(ReadString(ref reader));
}
ServerFullStateResponse fullState = new
(
serverUUID : rawResponse.ServerUUID,
sessionId : sessionId,
motd : statusKeyValues["hostname"],
gameType : statusKeyValues["gametype"],
gameId : statusKeyValues["game_id"],
version : statusKeyValues["version"],
plugins : statusKeyValues["plugins"],
map : statusKeyValues["map"],
numPlayers : int.Parse(statusKeyValues["numplayers"]),
maxPlayers : int.Parse(statusKeyValues["maxplayers"]),
playerList : players.ToArray(),
hostIp : statusKeyValues["hostip"],
hostPort : int.Parse(statusKeyValues["hostport"]),
rawData : (byte[])rawResponse.RawData.Clone()
);
return(fullState);
}
/// <summary>
/// Default Constructor
/// </summary>
public Fetch(CallbackSuccessHandler callback, CallbackFailureHandler failCallback, String url, RawResponse rawResponse)
{
this.failureCallback = failCallback;
this.successCallback = callback;
this.rawResponse = rawResponse;
www = new WWW(url);
}
/// <summary>
/// A fetch that parses champion data from a file.
/// </summary>
public Fetch(CallbackSuccessHandler callback, CallbackFailureHandler failCallback, RawResponse rawResponse, string fileLocation)
{
this.failureCallback = failCallback;
this.successCallback = callback;
this.rawResponse = rawResponse;
ParseFromFile(fileLocation);
}
public Fetch(CallbackSuccessHandler callback, CallbackFailureHandler failCallback, RawResponse rawResponse)
{
this.failureCallback = failCallback;
this.successCallback = callback;
this.rawResponse = rawResponse;
ParseFromString(MatchInfoStrings.GetInstance().GetChampionList());
}
public GetMarketCalendarResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
if (this.MessageFormat == MessageFormatEnum.JSON)
{
_days = Parse(raw.Content);
}
}
public GetQuotesResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
if (this.MessageFormat == MessageFormatEnum.JSON)
{
_quotes = MapToQuotes(raw.Content);
}
}
public override RawResponse GetStatus()
{
var response = new RawResponse();
var worker = new Worker();
response.Value = worker.Work().ToString();
Console.WriteLine($"{Name}: curent status is {response.Value}");
return(response);
}
/// <summary>
/// 更新缓存
/// </summary>
/// <param name="content">渲染结果</param>
protected virtual void UpdateCache(string content)
{
var response = new RawResponse();
response.Content = content;
response.Headers.Add("ContentType", "text/html");
CachedResponse = response;
}
private static RawResponse GetRawResponse(Stream stream)
{
var buffer = new byte[stream.Length];
int bytesRead = stream.Read(buffer, 0, buffer.Length);
RawResponse rawResponse = SerializeObject <RawResponse> .ByteArray2Object(buffer);
return(rawResponse);
}
public override RawResponse Stop(RawRequest request)
{
var response = new RawResponse();
response.Succeed = true;
var message = $"{Name} Stopped.";
response.ProgressMessage = message;
Console.WriteLine(message);
return(response);
}
public override RawResponse Start(RawRequest request)
{
var response = new RawResponse();
response.Succeed = true;
var worker = new Worker();
var message = $"{Name} Started {worker.Work().ToString()}";
Console.WriteLine(message);
response.ProgressMessage = message;
return(response);
}
private ICachedResponse CreateCachedResponse(ContentResult content)
{
var response = new RawResponse()
{
Content = content.Content,
ContentEncoding = content.ContentEncoding,
};
response.Headers.Add("ContentType", content.ContentType);
return(response);
}
public async Task <RawResponse> PublicRequest(Request req)
{
if (!req.IsValid())
{
throw new Exception("WTF");
}
var response = await ReqAsync(req.BuildUrl(), req.Method, req.UseApiKey);
_lastResponse = await RawResponse.FromHttpResponse(response);
return(_lastResponse);
}
public void ProcessRequest(HttpContext context)
{
if (context.Request.InputStream.Length == 0)
{
throw new ArgumentException("No file input");
}
GetQueryStringParameters(context);
RawResponse rawResponse = GetRawResponse(context.Request.InputStream);
CacheDependency dependencies = GetDependencies(context, _pathUrl, _currentSiteUrl);
context.Cache.Insert(_key, rawResponse, dependencies, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(60), CacheItemPriority.Low, null);
}
public RawResponse StartEngine(RawArg[] args)
{
var engine = GetTestEngine();
var request = new RawRequest();
var response = new RawResponse();
if (args != null && args.Length > 0)
{
request.Args = args;
}
if (engine != null)
{
var result = engine.Start(request);
response.BindTo(result);
}
return(response);
}
public static byte[] ParseHandshake(RawResponse rawResponse)
{
var data = (byte[])rawResponse.RawData.Clone();
if (data.Length < 5)
{
throw new IncorrectPackageDataException(data);
}
var response = BitConverter.GetBytes(int.Parse(Encoding.ASCII.GetString(data, 5, rawResponse.RawData.Length - 6)));
if (BitConverter.IsLittleEndian)
{
response = response.Reverse().ToArray();
}
return(response);
}
private void ParseResponse()
{
if (RawResponse.Length > 0)
{
char[] separator = { '|' };
string[] responseValues = RawResponse.Split(separator, StringSplitOptions.None);
//should be at least 39 elements
if (responseValues.Length > 38)
{
ResponseCode = responseValues[ResponseCodePosition];
switch (ResponseCode)
{
case "1":
Response = PaymentGatewayResponse.Approved;
break;
case "2":
Response = PaymentGatewayResponse.Declined;
break;
case "3":
Response = PaymentGatewayResponse.Error;
break;
}
ReasonCode = responseValues[ResponseReasonCodePosition];
ResponseReason = responseValues[ResponseReasonTextPosition];
ApprovalCode = responseValues[ResponseAuthCodePosition];
AvsResultCode = responseValues[ResponseAvsCodePosition];
if (AVSResultTextLookup.Contains(AvsResultCode))
{
AvsResultText = (string)AVSResultTextLookup[AvsResultCode];
}
TransactionId = responseValues[ResponseTransactionIdPosition];
}
}
}
/// <summary>
/// Creates a license key from a <see cref="RawResponse"/> object that can be obtained when calling
/// <see cref="Key.Activate(string, int, string, string, bool, int, int)"/>.
/// </summary>
public static LicenseKey FromResponse(string RSAPubKey, RawResponse response)
{
if (response == null || response.Result == ResultType.Error)
{
return(null);
}
var licenseBytes = Convert.FromBase64String(response.LicenseKey);
var signatureBytes = Convert.FromBase64String(response.Signature);
bool verificationResult = false;
try
{
#if NET40 || NET46 || NET35 || NET47 || NET471
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(2048);
rsa.FromXmlString(RSAPubKey);
#else
RSA rsa = RSA.Create();
rsa.ImportParameters(SecurityMethods.FromXMLString(RSAPubKey));
#endif
#if NET40 || NET46 || NET35 || NET47 || NET471
verificationResult = rsa.VerifyData(licenseBytes, "SHA256", signatureBytes);
#else
verificationResult = rsa.VerifyData(licenseBytes, signatureBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
#endif
}
catch (Exception ex) { }
if (!verificationResult)
{
return(null);
}
var license = JsonConvert.DeserializeObject <LicenseKeyPI>(System.Text.UTF8Encoding.UTF8.GetString(licenseBytes)).ToLicenseKey();
license.RawResponse = response;
return(license);
}
public static ServerBasicStateResponse ParseBasicState(RawResponse rawResponse)
{
if (rawResponse.RawData.Length <= 5)
{
throw new IncorrectPackageDataException(rawResponse.RawData);
}
SequenceReader <byte> reader = new(new ReadOnlySequence <byte>(rawResponse.RawData));
reader.Advance(1); // Skip Type
var sessionId = ParseSessionId(ref reader);
var motd = ReadString(ref reader);
var gameType = ReadString(ref reader);
var map = ReadString(ref reader);
var numPlayers = int.Parse(ReadString(ref reader));
var maxPlayers = int.Parse(ReadString(ref reader));
if (!reader.TryReadLittleEndian(out short port))
{
throw new IncorrectPackageDataException(rawResponse.RawData);
}
var hostIp = ReadString(ref reader);
ServerBasicStateResponse serverInfo = new(
serverUUID : rawResponse.ServerUUID,
sessionId : sessionId,
motd : motd,
gameType : gameType,
map : map,
numPlayers : numPlayers,
maxPlayers : maxPlayers,
hostPort : port,
hostIp : hostIp,
rawData : (byte[])rawResponse.RawData.Clone()
);
return(serverInfo);
}
public override RawResponse Start(RawRequest request)
{
var response = new RawResponse();
var args = request.ToMap();
var arg1 = args["Arg1"];
var arg2 = args["Arg2"];
if (arg1 == null || arg2 == null)
{
response.Succeed = false;
response.ProgressMessage = "Lack of parameter.";
}
else
{
var worker = new Worker();
var message = $"{Name} Started {worker.Work().ToString()}, Arg1 = {arg1.Value}, Arg2 = {arg2.Value}";
Console.WriteLine(message);
response.Succeed = true;
response.ProgressMessage = message;
}
return(response);
}
private async Task WriteExceptionAsync(HttpContext httpContext, Exception exception)
{
httpContext.Response.StatusCode = StatusCodes.Status200OK;
httpContext.Response.ContentType = "application/json";
var response = Responses.Error();
if (exception != null)
{
if (exception is MyException ex)
{
response = new RawResponse
{
Code = ex.Code,
Message = ex.Value,
Data = ex.ToString()
};
}
var stream = httpContext.Response.Body;
await JsonSerializer.SerializeAsync(stream, response, JsonUtils.DefaultOptions());
}
}
public InfoResponse(byte[] bytes)
{
RawResponse = new RawResponse(bytes);
Parse(bytes);
}
public GetCompanySearchResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public GetTimeAndSalesResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public async Task <RawResponse> PerformCall(Func <Task <HttpResponseMessage> > call, CancellationTokenSource cancellationTokenSource)
{
await _callSemaphore.WaitAsync();
var retry = true;
var rawResponse = RawResponse.FromNotCompleted();
while (retry)
{
_httpClient.DefaultRequestHeaders.Clear();
if (_authManager.IsAuthenticated)
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _authManager.AccessToken);
}
retry = false;
try
{
var start = DateTime.Now;
var response = await call();
var delta = DateTime.Now - start;
if (response.IsSuccessStatusCode)
{
rawResponse = RawResponse.FromSuccess(await response.Content.ReadAsStringAsync());
}
else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
_logger.AddCustomEvent(LogLevel.Error, "RawRestClient_PerformCall", "401 From Server");
retry = ((await RenewRefreshToken()).Successful);
if (!retry)
{
rawResponse = RawResponse.FromNotAuthorized();
}
}
else
{
_logger.AddCustomEvent(LogLevel.Message, "RawRestClient_PerformCall", $"Http Error {(int)response.StatusCode}");
/* Check for 401 (I think, if so then attempt to get a new access token, */
rawResponse = RawResponse.FromHttpFault((int)response.StatusCode, $"{ClientResources.Err_GeneralErrorCallingServer} : HTTP{(int)response.StatusCode} - {response.ReasonPhrase}");
}
}
catch (Exceptions.CouldNotRenewTokenException)
{
_callSemaphore.Release();
throw;
}
catch (TaskCanceledException tce)
{
_logger.AddException("RawRestClient_PerformCall_TaskCancelled", tce);
rawResponse = RawResponse.FromException(tce, tce.CancellationToken.IsCancellationRequested);
}
catch (Exception ex)
{
_logger.AddException("RawRestClient_PerformCall", ex);
rawResponse = RawResponse.FromException(ex);
}
}
_callSemaphore.Release();
return(rawResponse);
}
public GetOptionChainResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public GeneralAccountDataResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public GetSymbolLookupResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
/// <summary>
/// Returns the content of the response without status or empty lines
/// </summary>
/// <returns></returns>
public List <string> GetContent()
{
return(RawResponse.Take(RawResponse.Count() - 1).Where(s => !string.IsNullOrEmpty(s)).ToList());
}
public ChallengeResponse(byte[] bytes)
{
RawResponse = new RawResponse(bytes);
Parse(bytes);
}
public GetHistoricalPricingResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public MasterServerResponse(byte[] bytes)
{
RawResponse = new RawResponse(bytes);
Servers = Parse(bytes);
}
public PlayerResponse(byte[] bytes)
{
RawResponse = new RawResponse(bytes);
Parse(bytes);
}
public GetIntradayStatusResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
}
public GetQuotesResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
if(this.MessageFormat == MessageFormatEnum.JSON)
_quotes = MapToQuotes(raw.Content);
}
public GetMarketCalendarResponse(RawResponse raw, MessageFormatEnum format) : base(raw)
{
this.MessageFormat = format;
if (this.MessageFormat == MessageFormatEnum.JSON)
_days = Parse(raw.Content);
}
