public async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
if (_retryCount == MaxRetries)
return ApiOperation.Abort;
await Task.Delay(500);
_retryCount++;
if (_retryCount % 5 == 0)
{
// Let's try to refresh the session by getting a new token
await (ClientSettings.AuthType == AuthType.Google ? DoGoogleLogin(ClientSettings.GoogleUsername, ClientSettings.GooglePassword) : DoPtcLogin(ClientSettings.PtcUsername, ClientSettings.PtcPassword));
}
return ApiOperation.Retry;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
const string tokenName = "X-Token";
if (request.Headers.Contains(tokenName))
{
var tokenCriptografado = request.Headers.GetValues(tokenName).First();
try
{
var token = Token.Descriptografar(tokenCriptografado);
var usuarioIdValido = new AplicacaoUsuario().UsuarioIdValido(token.UsuarioId);
var ip = request.GetClientIP();
var ipValido = token.Ip.Equals(ip);
if (!usuarioIdValido || !ipValido)
{
var reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Identidade apresentada não é válida!");
return Task.FromResult(reply);
}
}
catch (Exception ex)
{
var reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Token usado não é válido!");
return Task.FromResult(reply);
}
}
else
{
var reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Esta requisição exige um token de autorização!");
return Task.FromResult(reply);
}
//return base.SendAsync(request, cancellationToken);
var request2 = new RequestEnvelope(request);
if (!request2.IsCorsPreflight)
return base.SendAsync(request, cancellationToken);
request.Headers.Add("Access-Control-Allow-Origin", "*");
const string supportedMethods = "POST, PUT, GET, DELETE, X-Token";
request.Headers.Add("Access-Control-Allow-Methods", supportedMethods);
return base.SendAsync(request, cancellationToken);
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
_retryCount = 0;
switch (response.StatusCode)
{
case ResponseEnvelope.Types.StatusCode.OkRpcUrlInResponse:
if (!string.IsNullOrEmpty(response.ApiUrl))
{
_session.ApiUrl = "https://" + response.ApiUrl + "/rpc";
Logger.Debug("New Client.ApiUrl: " + _session.ApiUrl);
}
break;
}
if (response.AuthTicket != null)
{
_session.SetAuthTicket(response.AuthTicket);
Logger.Debug("Received AuthTicket: " + response.AuthTicket);
}
}
public RequestEnvelope GetRequestEnvelope(params Request[] customRequests)
{
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = 1469378659230941192, //3
Requests = { customRequests }, //4
//Unknown6 = , //6
Latitude = _latitude, //7
Longitude = _longitude, //8
Altitude = _altitude, //9
AuthTicket = _authTicket, //11
Unknown12 = 989 //12
};
e.Unknown6.Add(GenerateSignature(customRequests));
return(e);
}
public RequestEnvelope GetRequestEnvelope(params Request[] customRequests)
{
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = _nextRequestId++, //3
Requests = { customRequests }, //4
//Unknown6 = , //6
Latitude = _latitude, //7
Longitude = _longitude, //8
Altitude = _altitude, //9
AuthTicket = _authTicket, //11
MsSinceLastLocationfix = RandomDevice.Next(800, 1900) //12
};
e.Unknown6.Add(GenerateSignature(customRequests));
return(e);
}
/// <summary>
/// Gets a <see cref="RequestEnvelope" /> with the default requests and authentication data.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private RequestEnvelope GetRequestEnvelope(Request request)
{
var requestEnvelope = new RequestEnvelope
{
StatusCode = 2,
RequestId = GetNextRequestId(),
Latitude = _session.Player.Coordinate.Latitude,
Longitude = _session.Player.Coordinate.Longitude,
Altitude = _session.Player.Coordinate.Altitude,
Unknown12 = 123, // TODO: Figure this out.
Requests = { GetDefaultRequests() }
};
requestEnvelope.Requests.Insert(0, request);
if (_session.AccessToken.AuthTicket == null || _session.AccessToken.IsExpired)
{
if (_session.AccessToken.IsExpired)
{
_session.Reauthenticate();
}
requestEnvelope.AuthInfo = new RequestEnvelope.Types.AuthInfo
{
Provider = _session.AccessToken.LoginProvider == LoginProvider.PokemonTrainerClub ? "ptc" : "google",
Token = new RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = _session.AccessToken.Token,
Unknown2 = 59
}
};
}
else
{
requestEnvelope.AuthTicket = _session.AccessToken.AuthTicket;
}
requestEnvelope.Unknown6 = _rpcEncryption.GenerateSignature(requestEnvelope);
return(requestEnvelope);
}
public async Task <ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
if (_retryCount == MaxRetries)
{
return(ApiOperation.Abort);
}
await Task.Delay(500);
_retryCount++;
if (_retryCount % 5 == 0)
{
await DoRelogin();
Debug.WriteLine("[Relogin] Stopping API via ApiHandledException.");
throw new ApiHandledException("Relogin completed.");
}
return(ApiOperation.Retry);
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
_retryCount = 0;
/*Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Accuracy: {request.Accuracy}");
* //Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"--------------[AUTH INFO]-------------");
* //Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Auth Provider: {request.AuthInfo.Provider}");
* //Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Auth Token: {request.AuthInfo.Token}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"------------[AUTHTICKET INFO]------------");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"AuthTicket End: {request.AuthTicket.End}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"AuthTicket Expire (MS): {request.AuthTicket.ExpireTimestampMs}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"AuthTicket Start: {request.AuthTicket.Start}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"-----------------------------------------");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Latitude: {request.Latitude}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Longitude: {request.Longitude}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Milliseconds SinceLastLocationFix: {request.MsSinceLastLocationfix}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"PlatformRequests: {request.PlatformRequests}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"RequestId: {request.RequestId}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Requests: {request.Requests}");
* Logger.ColoredConsoleWrite(ConsoleColor.Cyan, $"Status Code: {request.StatusCode}");*/
}
public RequestEnvelope GetPlatformRequestEnvelope(RequestEnvelope.Types.PlatformRequest platfReq, bool firstRequest = false)
{
var req = new Request();
req.RequestType = RequestType.Echo;
var _requestEnvelope = new RequestEnvelope {
StatusCode = 2, //1
RequestId = _requestBuilderID.Next(), //3
Requests = { req }, //4
Latitude = _latitude, //7
Longitude = _longitude, //8
Accuracy = _altitude, //9
AuthTicket = _authTicket, //11
MsSinceLastLocationfix = (long)TRandomDevice.Triangular(300, 30000, 10000) //12
};
_requestEnvelope.PlatformRequests.Add(platfReq);
if (_authTicket != null && !firstRequest)
{
_requestEnvelope.AuthTicket = _authTicket;
}
else
{
_requestEnvelope.AuthInfo = new RequestEnvelope.Types.AuthInfo {
Provider = _authType == AuthType.Google ? "google" : "ptc",
Token = new RequestEnvelope.Types.AuthInfo.Types.JWT {
Contents = _authToken,
Unknown2 = _token2
}
};
}
//Logger.Debug("GetPlatformRequestEnvelope");
//Logger.Debug("_requestEnvelope"+ _requestEnvelope);
_requestEnvelope.PlatformRequests.Add(GenerateSignature(_requestEnvelope));
return(_requestEnvelope);
}
public async Task <ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
if (_retryCount == 11)
{
return(ApiOperation.Abort);
}
await Task.Delay(500);
_retryCount++;
if (_retryCount % 5 != 0)
{
return(ApiOperation.Retry);
}
try
{
DoLogin();
}
catch (PtcOfflineException)
{
await Task.Delay(20000);
}
catch (AccessTokenExpiredException)
{
await Task.Delay(2000);
}
catch (MinimumClientVersionException ex)
{
// Re-throw this exception since we need to exit the app.
throw ex;
}
catch (Exception ex) when(ex is InvalidResponseException || ex is TaskCanceledException)
{
await Task.Delay(1000);
}
return(ApiOperation.Retry);
}
public async Task <RequestEnvelope> GetRequestEnvelope(Request[] customRequests)
{
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = GetNextRequestId(), //3
Latitude = _latitude, //7
Longitude = _longitude, //8
Accuracy = (int)_horizontalAccuracy, //9
MsSinceLastLocationfix = (long)TRandomDevice.Triangular(300, 30000, 10000) //12
};
e.Requests.AddRange(customRequests);
if (_client.AccessToken.AuthTicket == null || _client.AccessToken.IsExpired)
{
if (_client.AccessToken.IsExpired)
{
await Rpc.Login.Reauthenticate(_client);
}
e.AuthInfo = new RequestEnvelope.Types.AuthInfo
{
Provider = _client.AccessToken.ProviderID,
Token = new RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = _client.AccessToken.Token,
Unknown2 = 59
}
};
}
else
{
e.AuthTicket = _client.AccessToken.AuthTicket;
}
e.PlatformRequests.Add(GenerateSignature(e));
return(e);
}
public RequestEnvelope SetRequestEnvelopeUnknown6(RequestEnvelope requestEnvelope)
{
var rnd32 = new byte[32];
var rnd = new Random();
rnd.NextBytes(rnd32);
var ticketBytes = requestEnvelope.AuthTicket.ToByteArray();
var sig = new Signature()
{
LocationHash1 =
Utils.GenerateLocation1(ticketBytes, requestEnvelope.Latitude, requestEnvelope.Longitude,
requestEnvelope.Altitude),
LocationHash2 =
Utils.GenerateLocation2(requestEnvelope.Latitude, requestEnvelope.Longitude,
requestEnvelope.Altitude),
Unk22 = ByteString.CopyFrom(rnd32),
Timestamp = (ulong)DateTime.UtcNow.ToUnixTime(),
TimestampSinceStart = (ulong)(DateTime.UtcNow.ToUnixTime() - _startTime.ToUnixTime())
};
foreach (var request in requestEnvelope.Requests)
{
sig.RequestHash.Add(
Utils.GenerateRequestHash(ticketBytes, request.ToByteArray())
);
}
requestEnvelope.Unknown6.Add(new Unknown6()
{
RequestType = 6,
Unknown2 = new Unknown6.Types.Unknown2()
{
Unknown1 = ByteString.CopyFrom(Crypt.Encrypt(sig.ToByteArray()))
}
});
return(requestEnvelope);
}
public static async Task <ResponseEnvelope> PostProto <TRequest>(this System.Net.Http.HttpClient client, string url,
RequestEnvelope requestEnvelope) where TRequest : IMessage <TRequest>
{
//Encode payload and put in envelop, then send
var data = requestEnvelope.ToByteString();
var result = await client.PostAsync(url, new ByteArrayContent(data.ToByteArray()));
if (result.StatusCode == System.Net.HttpStatusCode.Forbidden)
{
throw new IPBannedException("IP Address is banned");
}
//Decode message
var responseData = await result.Content.ReadAsByteArrayAsync();
var codedStream = new CodedInputStream(responseData);
var decodedResponse = new ResponseEnvelope();
decodedResponse.MergeFrom(codedStream);
return(decodedResponse);
}
public static RequestEnvelope GetInitialRequestEnvelope(string authToken, AuthType authType, double lat, double lng,
double altitude, params RequestType[] requestTypeIds)
{
RequestEnvelope envelope = new RequestEnvelope();
//Provide the auth type and the oAuth token issued
envelope.WithAltitude(altitude)
.WithLatitude(lat)
.WithLongitude(lng)
.WithRequestID() //RPC ID?
.WithAuthenticationMessage(authType, authToken);
//Now we generate empty requests and put the ID into them.
foreach (RequestType r in requestTypeIds)
{
Request request = new Request();
request.RequestType = r;
envelope.WithMessage(request);
}
return(envelope);
}
public static async Task <TResponsePayload> PostProtoPayload <TRequest, TResponsePayload>(
this System.Net.Http.HttpClient client,
string url, RequestEnvelope requestEnvelope, IApiFailureStrategy strategy)
where TRequest : IMessage <TRequest>
where TResponsePayload : IMessage <TResponsePayload>, new()
{
Debug.WriteLine($"Requesting {typeof(TResponsePayload).Name}");
var urlArray = new[] { url };
var response = await PostProto <TRequest>(client, url, requestEnvelope);
while (response.Returns.Count == 0)
{
var operation = await strategy.HandleApiFailure(urlArray, requestEnvelope, response);
if (operation == ApiOperation.Abort)
{
break;
}
response = await PostProto <TRequest>(client, urlArray[0], requestEnvelope);
}
// TODO: statuscode = 3 probably means ban!
if (response.Returns.Count == 0)
{
throw new InvalidResponseException();
}
strategy.HandleApiSuccess(requestEnvelope, response);
//Decode payload
//todo: multi-payload support
var payload = response.Returns[0];
var parsedPayload = new TResponsePayload();
parsedPayload.MergeFrom(payload);
return(parsedPayload);
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
if (response.StatusCode == 3)
{
for (int i = 0; i < request.Requests.Count; i++)
{
//detect ban based on empty inventory
if (request.Requests[i].RequestType == RequestType.GetInventory && response.Returns[i].IsEmpty)
{
Logger.Write($"(BAN) No inventory response was returned from the server, which generally means you have been banned. Shutting down the application...", LogLevel.None, ConsoleColor.Red);
//wait
for (int y = 0; y < 20; y++)
{
System.Threading.Thread.Sleep(1000);
}
//exit
Environment.Exit(0);
}
}
}
_retryCount = 0;
}
public static async Task <TResponsePayload> PostProtoPayload <TRequest, TResponsePayload>(
this System.Net.Http.HttpClient client,
Client apiClient, RequestEnvelope requestEnvelope)
where TRequest : IMessage <TRequest>
where TResponsePayload : IMessage <TResponsePayload>, new()
{
ResponseEnvelope response = await PerformThrottledRemoteProcedureCall <TRequest>(client, apiClient, requestEnvelope).ConfigureAwait(false);
if (response.Returns.Count != requestEnvelope.Requests.Count)
{
throw new InvalidResponseException($"Error with API request type: {requestEnvelope.Requests[0].RequestType}");
}
//Decode payload
//todo: multi-payload support
var payload = response.Returns[0];
var parsedPayload = new TResponsePayload();
parsedPayload.MergeFrom(payload);
return(parsedPayload);
}
private void PreProcessRequestEnvelope(RequestEnvelope envelope)
{
envelope.WithRequestID();
if (!session.CurrentSessionState.HasFlag(SessionState.HasValidAuthTicket))
{
//If we don't have an auth ticket
//Then we may need the request
if (session.CurrentSessionState.HasFlag(SessionState.Authenticated))
{
envelope.WithAuthenticationMessage(session.Token.TokenType, session.Token.TokenID);
return;
}
}
else
{
envelope.WithAuthTicket(session.AuthenticationTicketContainer.Ticket);
return;
}
throw new InvalidOperationException($"The session was not in a valid state for network requests.");
}
public async Task <IMessage[]> PostProtoPayload <TRequest>(string url, RequestEnvelope requestEnvelope, IApiFailureStrategy strategy,
params Type[] responseTypes)
where TRequest : IMessage <TRequest>
{
var result = new IMessage[responseTypes.Length];
for (var i = 0; i < responseTypes.Length; i++)
{
result[i] = Activator.CreateInstance(responseTypes[i]) as IMessage;
if (result[i] == null)
{
throw new ArgumentException($"ResponseType {i} is not an IMessage");
}
}
var urlArray = new[] { url };
ResponseEnvelope response;
while ((response = await PostProto <TRequest>(urlArray[0], requestEnvelope)).Returns.Count !=
responseTypes.Length)
{
var operation = await strategy.HandleApiFailure(urlArray, requestEnvelope, response);
if (operation == ApiOperation.Abort)
{
throw new InvalidResponseException(
$"Expected {responseTypes.Length} responses, but got {response.Returns.Count} responses");
}
}
strategy.HandleApiSuccess(requestEnvelope, response);
for (var i = 0; i < responseTypes.Length; i++)
{
var payload = response.Returns[i];
result[i].MergeFrom(payload);
}
return(result);
}
public static async Task <ResponseEnvelope> PostProto <TRequest>(this System.Net.Http.HttpClient client, string url,
RequestEnvelope requestEnvelope) where TRequest : IMessage <TRequest>
{
HttpResponseMessage result = null;
for (int i = 0; i < 3; i++)
{
try
{
//Encode payload and put in envelop, then send
if (requestEnvelope == null)
{
return(new ResponseEnvelope());
}
var data = requestEnvelope.ToByteString();
result = await client.PostAsync(url, new ByteArrayContent(data.ToByteArray()));
break;
}
catch
{
// ignored
}
}
if (result != null)
{
//Decode message
var responseData = await result.Content.ReadAsByteArrayAsync();
var codedStream = new CodedInputStream(responseData);
var decodedResponse = new ResponseEnvelope();
decodedResponse.MergeFrom(codedStream);
return(decodedResponse);
}
return(new ResponseEnvelope());
}
public async Task RegenerateRequestEnvelopeWithNewAccessToken(RequestEnvelope requestEnvelope)
{
var accessToken = await _client.Login.GetValidAccessToken(true /* force refresh */).ConfigureAwait(false);
requestEnvelope.AuthTicket = null;
requestEnvelope.AuthInfo = new RequestEnvelope.Types.AuthInfo
{
Provider = accessToken.ProviderID,
Token = new RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = accessToken.Token,
Unknown2 = (accessToken.ProviderID == "ptc") ? TRandomDevice.Choice(new List <int>(new int[] { 2, 8, 21, 21, 21, 28, 37, 56, 59, 59, 59 })) : 59
}
};
requestEnvelope.PlatformRequests.Clear();
if (_client.AppVersion > 4500)
{
// Only add UnknownPtr8Request if not using the legacy API.
// Chat with SLxTnT - this is required for all request and needed before the main envelope.
//if(customRequests.Any(x=>x.RequestType == RequestType.GetMapObjects || x.RequestType == RequestType.GetPlayer))
var plat8Message = new UnknownPtr8Request()
{
Message = _client.UnknownPlat8Field
};
requestEnvelope.PlatformRequests.Add(new RequestEnvelope.Types.PlatformRequest()
{
Type = PlatformRequestType.UnknownPtr8,
RequestMessage = plat8Message.ToByteString()
});
}
var currentLocation = new GeoCoordinate(requestEnvelope.Latitude, requestEnvelope.Longitude, _client.CurrentAltitude);
requestEnvelope.PlatformRequests.Add(await GenerateSignature(requestEnvelope, currentLocation).ConfigureAwait(false));
}
public PayRequest SubscriptionPayment(int rate, string userId, string paypalId)
{
// Payment operation
// PayRequest requestPay = Payment();
RequestEnvelope envelopeRequest = new RequestEnvelope();
envelopeRequest.errorLanguage = "en_US";
List <Receiver> receiverLst = new List <Receiver>();
// Amount to be credited to the receiver's account
Receiver receiverB = new Receiver(Convert.ToDecimal(rate));
// A receiver's email address
receiverB.email = "*****@*****.**";
receiverLst.Add(receiverB);
ReceiverList receiverList = new ReceiverList(receiverLst);
PayRequest requestPay = new PayRequest(envelopeRequest, "PAY", System.Configuration.ConfigurationManager.AppSettings["CANCEL_URL"] + "/DoctorInformation/PayPalSubscription/?pstatus=cancel&userid=" + userId, "USD", receiverList, System.Configuration.ConfigurationManager.AppSettings["RETURN_URL"] + "/DoctorInformation/PayPalSubscription/?pstatus=success&userId=" + userId + "&pay=" + rate);
requestPay.senderEmail = paypalId;
requestPay.receiverList = receiverList;
//SenderIdentifier sender = new SenderIdentifier();
//sender.accountId = userId;
//sender.email = paypalId;
//requestPay.sender = sender;
// IPN URL
//
// * PayPal Instant Payment Notification is a call back system that is initiated when a transaction is completed
// * The transaction related IPN variables will be received on the call back URL specified in the request
// * The IPN variables have to be sent back to the PayPal system for validation, upon validation PayPal will send a response string "VERIFIED" or "INVALID"
// * PayPal would continuously resend IPN if a wrong IPN is sent
requestPay.ipnNotificationUrl = System.Configuration.ConfigurationManager.AppSettings["IPN_URL"] + "/DoctorInformation/PayPalIPIN/";
return(requestPay);
}
public async Task <ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
var operation = ApiOperation.Abort;
if (_lastRequestEnvelope != null && !_lastRequestEnvelope.Equals(request))
{
_retrieAttempts = 0;
}
_logger.Write("Api failure", LogLevel.DEBUG);
_retrieAttempts++;
if (_retrieAttempts <= RetriesCount)
{
_logger.Write($"Retrying again in 1 second. Attempt number:{_retrieAttempts}", LogLevel.DEBUG);
await Task.Delay(1000);
operation = ApiOperation.Retry;
}
_lastRequestEnvelope = request;
return(operation);
}
public async Task <ResponseEnvelope> PostProto <TRequest>(string url, RequestEnvelope requestEnvelope)
where TRequest : IMessage <TRequest>
{
// robertmclaws: Let's be pro-active about token failures, instead of reactive.
if (AccessToken == null || AccessToken.IsExpired)
{
await Login.DoLogin();
}
//Encode payload and put in envelop, then send
var data = requestEnvelope.ToByteString();
var result = await PostAsync(url, new ByteArrayContent(data.ToByteArray()));
//Decode message
var responseData = await result.Content.ReadAsByteArrayAsync();
var codedStream = new CodedInputStream(responseData);
var decodedResponse = new ResponseEnvelope();
decodedResponse.MergeFrom(codedStream);
return(decodedResponse);
}
private void LoadProtoContent()
{
if (_requestProto != null)
{
return;
}
if (RpcType == RpcRequestType.None)
{
return;
}
_requestProto = new RequestEnvelope();
using (var bodyReader = new BinaryReader(Request.Body))
{
Byte[] buf = new byte[GlobalSettings.ServerCfg.MaxRequestContentLength];
int lent = bodyReader.Read(buf, 0, buf.Length);
Array.Resize(ref buf, lent);
CodedInputStream cis = new CodedInputStream(buf);
_requestProto.MergeFrom(cis);
}
}
public async Task Dispatch_Query_ReplyReturned()
{
var serverCallContext = TestServerCallContextFactory.Create();
serverCallContext.UserState["__HttpContext"] = httpContextFactory();
var dispatcher = new DispatcherService();
var query = new TestQuery
{
Value = Guid.NewGuid().ToString()
};
var request = new RequestEnvelope()
{
Type = query.GetType().AssemblyQualifiedName,
Content = Value.Parser.ParseJson(JsonSerializer.Serialize(query))
};
var response = await dispatcher.Dispatch(request, serverCallContext);
response.ShouldNotBeNull().Content.ShouldNotBeNull();
var responseType = System.Type.GetType(response.Type, an => Assembly.Load(an.Name ?? null !), null, true, true).ShouldNotBeNull();
JsonSerializer.Deserialize(JsonFormatter.Default.Format(response.Content), responseType).ShouldBeOfType <TestQueryReply>().Value.ShouldBe(query.Value);
}
public static async Task <TResponsePayload> PostProtoPayload <TRequest, TResponsePayload>(
this System.Net.Http.HttpClient client,
string url, RequestEnvelope requestEnvelope, IApiFailureStrategy strategy)
where TRequest : IMessage <TRequest>
where TResponsePayload : IMessage <TResponsePayload>, new()
{
Debug.WriteLine($"Requesting {typeof(TResponsePayload).Name}");
var response = await PerformThrottledRemoteProcedureCall <TRequest>(client, url, requestEnvelope).ConfigureAwait(false);
while (response.Returns.Count == 0)
{
var operation = await strategy.HandleApiFailure(requestEnvelope, response).ConfigureAwait(false);
if (operation == ApiOperation.Abort)
{
break;
}
response = await PerformThrottledRemoteProcedureCall <TRequest>(client, url, requestEnvelope).ConfigureAwait(false);
}
if (response.Returns.Count == 0)
{
throw new InvalidResponseException();
}
strategy.HandleApiSuccess(requestEnvelope, response);
//Decode payload
//todo: multi-payload support
var payload = response.Returns[0];
var parsedPayload = new TResponsePayload();
parsedPayload.MergeFrom(payload);
return(parsedPayload);
}
public static TResponsePayload PostProtoPayload <TRequest, TResponsePayload>(
this System.Net.Http.HttpClient httpClient,
string url, RequestEnvelope requestEnvelope, IApiFailureStrategy strategy)
where TRequest : IMessage <TRequest>
where TResponsePayload : IMessage <TResponsePayload>, new()
{
var response = PerformThrottledRemoteProcedureCall <TRequest>(httpClient, url, requestEnvelope).Result;
while (response.Returns.Count == 0)
{
Logger.Debug("Handling Failure");
var operation = strategy.HandleApiFailure(requestEnvelope, response);
if (operation == ApiOperation.Abort)
{
break;
}
response = PerformThrottledRemoteProcedureCall <TRequest>(httpClient, url, requestEnvelope).Result;
}
if (response.Returns.Count == 0)
{
throw new InvalidResponseException();
}
strategy.HandleApiSuccess(requestEnvelope, response);
//Decode payload
//TODO: multi-payload support
var payload = response.Returns[0];
var parsedPayload = new TResponsePayload();
parsedPayload.MergeFrom(payload);
return(parsedPayload);
}
public RequestEnvelope GetInitialRequestEnvelope(params Request[] customRequests)
{
int randomUk12 = 0;
int randomUk2 = 0;
lock (RandomDevice)
{
randomUk12 = RandomDevice.Next(100, 1000);
randomUk2 = RandomDevice.Next(10, 100);
}
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = _requestId, //3
Requests = { customRequests }, //4
//Unknown6 = , //6
Latitude = _latitude, //7
Longitude = _longitude, //8
Altitude = _altitude, //9
AuthInfo = new POGOProtos.Networking.Envelopes.RequestEnvelope.Types.AuthInfo
{
Provider = _authType == AuthType.Google ? "google" : "ptc",
Token = new POGOProtos.Networking.Envelopes.RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = _authToken,
Unknown2 = randomUk2
}
}, //10
Unknown12 = randomUk12 //12
};
return(e);
}
public ApiOperation HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
if (_retryCount == 5)
{
Logger.Debug("Too many tries. Aborting");
return(ApiOperation.Abort);
}
switch (response.StatusCode)
{
case ResponseEnvelope.Types.StatusCode.SessionInvalidated:
case ResponseEnvelope.Types.StatusCode.InvalidAuthToken:
_session.Login.DoLogin().Wait();
request.AuthInfo.Token.Contents = _session.AuthToken;
request.AuthTicket = _session.GetAuthTicket();
break;
//throw new AccessTokenExpiredException();
case ResponseEnvelope.Types.StatusCode.InvalidPlatformRequest:
throw new InvalidPlatformException();
case ResponseEnvelope.Types.StatusCode.Redirect:
if (!string.IsNullOrEmpty(response.ApiUrl))
{
_session.ApiUrl = "https://" + response.ApiUrl + "/rpc";
Logger.Debug("New Client.ApiUrl: " + _session.ApiUrl);
}
throw new RedirectException();
case ResponseEnvelope.Types.StatusCode.BadRequest:
return(ApiOperation.Abort);
}
_retryCount++;
Logger.Debug($"{response.StatusCode}: Retrying. Try {_retryCount}.");
return(ApiOperation.Retry);
}
private static RequestEnvelope Header(MessageHeaderParameters messageHeaderParameters)
{
Log.Debug("Begin creating the header of the message.");
var requestEnvelope = new RequestEnvelope
{
ApplicationMessageId = messageHeaderParameters.ApplicationMessageId ??
MessageIdService.ApplicationMessageId(),
ApplicationMessageSeqNo = Parameters.ApplicationMessageSeqNo,
TechnicalMessageType = messageHeaderParameters.TechnicalMessageType,
Mode = messageHeaderParameters.Mode,
Timestamp = UtcDataService.NowAsTimestamp()
};
if (!string.IsNullOrEmpty(messageHeaderParameters.TeamSetContextId))
{
requestEnvelope.TeamSetContextId = messageHeaderParameters.TeamSetContextId;
}
if (messageHeaderParameters.Recipients != null)
{
foreach (var recipient in messageHeaderParameters.Recipients)
{
requestEnvelope.Recipients.Add(recipient);
}
}
if (messageHeaderParameters.ChunkInfo != null)
{
requestEnvelope.ChunkInfo = messageHeaderParameters.ChunkInfo;
}
Log.Debug("Finished creating the header of the message.");
return(requestEnvelope);
}
public async Task Dispatch_Query_ReplyReturned()
{
var serverCallContext = TestServerCallContextFactory.Create();
serverCallContext.UserState["__HttpContext"] = httpContextFactory();
var dispatcher = new DispatcherService();
var query = new TestQuery
{
Value = Guid.NewGuid().ToString()
};
var request = new RequestEnvelope()
{
Type = query.GetType().AssemblyQualifiedName,
Data = UnsafeByteOperations.UnsafeWrap(JsonSerializer.SerializeToUtf8Bytes(query))
};
var response = await dispatcher.Dispatch(request, serverCallContext);
response.ShouldNotBeNull().Data.ShouldNotBeNull().IsEmpty.ShouldBeFalse();
var responseType = System.Type.GetType(response.Type, an => Assembly.Load(an.Name ?? null !), null, true, true).ShouldNotBeNull();
using var ms = new MemoryStream(response.Data.ToByteArray());
JsonSerializer.Deserialize(ms, responseType).ShouldBeOfType <TestQueryReply>().Value.ShouldBe(query.Value);
}
/// <summary>
/// Gets a <see cref="RequestEnvelope" /> with the default requests and authentication data.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private RequestEnvelope GetRequestEnvelope(Request request)
{
var requestEnvelope = new RequestEnvelope
{
StatusCode = 2,
RequestId = GetNextRequestId(),
Latitude = _session.Player.Coordinate.Latitude,
Longitude = _session.Player.Coordinate.Longitude,
Altitude = _session.Player.Coordinate.Altitude,
Unknown12 = 123, // TODO: Figure this out.
Requests = {GetDefaultRequests()}
};
if (_session.AccessToken.AuthTicket == null || _session.AccessToken.IsExpired)
{
if (_session.AccessToken.IsExpired)
{
_session.Reauthenticate();
}
requestEnvelope.AuthInfo = new RequestEnvelope.Types.AuthInfo
{
Provider = _session.AccessToken.LoginProvider == LoginProvider.PokemonTrainerClub ? "ptc" : "google",
Token = new RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = _session.AccessToken.Token,
Unknown2 = 59
}
};
}
else
{
requestEnvelope.AuthTicket = _session.AccessToken.AuthTicket;
}
requestEnvelope.Requests.Insert(0, request);
return requestEnvelope;
}
public RequestEnvelope GetInitialRequestEnvelope(params Request[] customRequests)
{
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = 1469378659230941192, //3
Requests = { customRequests }, //4
//Unknown6 = , //6
Latitude = _latitude, //7
Longitude = _longitude, //8
Altitude = _altitude, //9
AuthInfo = new POGOProtos.Networking.Envelopes.RequestEnvelope.Types.AuthInfo
{
Provider = _authType == AuthType.Google ? "google" : "ptc",
Token = new POGOProtos.Networking.Envelopes.RequestEnvelope.Types.AuthInfo.Types.JWT
{
Contents = _authToken,
Unknown2 = 14
}
}, //10
Unknown12 = 989 //12
};
return e;
}
public RequestEnvelope GetRequestEnvelope(params Request[] customRequests)
{
var e = new RequestEnvelope
{
StatusCode = 2, //1
RequestId = 1469378659230941192, //3
Requests = { customRequests }, //4
//Unknown6 = , //6
Latitude = _latitude, //7
Longitude = _longitude, //8
Altitude = _altitude, //9
AuthTicket = _authTicket, //11
Unknown12 = 989 //12
};
e.Unknown6.Add(GenerateSignature(customRequests));
return e;
}
public async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
if (_retryCount == 11)
return ApiOperation.Abort;
await Task.Delay(500);
_retryCount++;
if (_retryCount % 5 == 0)
{
try
{
DoLogin();
}
catch (PtcOfflineException)
{
await Task.Delay(20000);
}
catch (AccessTokenExpiredException)
{
await Task.Delay(2000);
}
catch (Exception ex) when (ex is InvalidResponseException || ex is TaskCanceledException)
{
await Task.Delay(1000);
}
}
return ApiOperation.Retry;
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
_retryCount = 0;
}
public ZimbraException( ResponseEnvelope sf, RequestEnvelope req )
{
fault = sf;
this.req = req;
}
public ZimbraException( String msg, ResponseEnvelope sf, RequestEnvelope req )
: base(msg)
{
fault = sf;
this.req = req;
}
public async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
return ApiOperation.Retry;
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
}
/// <summary>
/// Prepares the <see cref="RequestEnvelope" /> to be sent with <see cref="_httpClient" />.
/// </summary>
/// <param name="requestEnvelope">The <see cref="RequestEnvelope" /> that will be send.</param>
/// <returns><see cref="StreamContent" /> to be sent with <see cref="_httpClient" />.</returns>
private ByteArrayContent PrepareRequestEnvelope(RequestEnvelope requestEnvelope)
{
var messageBytes = requestEnvelope.ToByteArray();
// TODO: Compression?
return new ByteArrayContent(messageBytes);
}
public async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
await Task.Delay(500);
_retryCount++;
return _retryCount < _maxRetries ? ApiOperation.Retry : ApiOperation.Abort;
}
