public async Task <ResponseEnvelope <string> > SyncDataAsync()
{
try
{
var versionResponse = await this.ClientApi.GetRequestAsync <string>(WebApi.ApiStaticDataVersion);
if (versionResponse.Ack == AckCode.SUCCESS)
{
var jsonString = await this.GetStaticDataAsync(versionResponse.Data);
if (string.IsNullOrEmpty(jsonString) == false)
{
this.staticDataRepository.SyncronizeDatabase(versionResponse.Data, jsonString);
return(await ResponseEnvelope <string> .SuccessAsync(string.Empty));
}
}
return(await ResponseEnvelope <string> .ErrorAsync(string.Empty));
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <string> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <string> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
protected override void CompleteFailedRequest(OperationResult result, string error)
{
base.CompleteFailedRequest(result, error);
var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, result, error);
ResponseEnvelope.ReplyWith(responseMsg);
}
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 (Exception ex) when(ex is PtcOfflineException || ex is AccessTokenExpiredException)
{
_session.EventDispatcher.Send(new ErrorEvent
{
Message = _session.Translation.GetTranslation(TranslationString.PtcOffline)
});
_session.EventDispatcher.Send(new NoticeEvent
{
Message = _session.Translation.GetTranslation(TranslationString.TryingAgainIn, 20)
});
await Task.Delay(20000);
}
}
return(ApiOperation.Retry);
}
public ResponseEnvelope <List <dto.Banner> > Response(ObterResponse response)
{
var envelope = new ResponseEnvelope <List <dto.Banner> >();
envelope.HttpStatusCode = (HttpStatusCode)response.HttpStatusCode;
if (envelope.Success)
{
foreach (var item in response.Banners)
{
envelope.Item.Add(new dto.Banner(item.Id, item.Imagem, item.Thumb, item.URL));
}
}
else
{
envelope.Error = new ErrorEnvelope
{
Messages = new List <string> {
response.Erro
}
};
}
return(envelope);
}
protected override void CompleteSuccessRequest(int firstEventNumber, int lastEventNumber)
{
base.CompleteSuccessRequest(firstEventNumber, lastEventNumber);
var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, OperationResult.Success, null);
ResponseEnvelope.ReplyWith(responseMsg);
}
public static async Task <ResponseEnvelope> PerformThrottledRemoteProcedureCall <TRequest>(this System.Net.Http.HttpClient client, Client apiClient, RequestEnvelope requestEnvelope) where TRequest : IMessage <TRequest>
{
rpcQueue.Enqueue(requestEnvelope);
var count = rpcQueue.Count;
ResponseEnvelope ret;
try
{
mutex.WaitOne();
RequestEnvelope r;
while (rpcQueue.TryDequeue(out r))
{
var diff = Math.Max(0, DateTime.Now.Millisecond - lastRpc);
if (diff < minDiff)
{
var delay = (minDiff - diff) + (int)(new Random().NextDouble() * 0); // Add some randomness
await Task.Delay((int)(delay));
}
lastRpc = DateTime.Now.Millisecond;
ResponseEnvelope response = await PerformRemoteProcedureCall <TRequest>(client, apiClient, r);
responses.GetOrAdd(r, response);
}
responses.TryRemove(requestEnvelope, out ret);
}
finally
{
mutex.Release();
}
return(ret);
}
public static async Task <IMessage[]> PostProtoPayload <TRequest>(this System.Net.Http.HttpClient client,
Client apiClient, RequestEnvelope requestEnvelope,
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");
}
}
ResponseEnvelope response = await PerformThrottledRemoteProcedureCall <TRequest>(client, apiClient, requestEnvelope);
if (response.Returns.Count != requestEnvelope.Requests.Count)
{
throw new InvalidResponseException();
}
for (var i = 0; i < responseTypes.Length; i++)
{
var payload = response.Returns[i];
result[i].MergeFrom(payload);
}
return(result);
}
public ResponseEnvelope <comum_dto.externo.EstornoResponse> Response(grpc.Protos.EstornoResponse estornoResponse)
{
var response = new ResponseEnvelope <comum_dto.externo.EstornoResponse>()
{
HttpStatusCode = (HttpStatusCode)estornoResponse.HttpStatusCode
};
if (response.Success)
{
var id = Guid.Empty;
Guid.TryParse(estornoResponse.TransacaoId, out id);
response.Item = new comum_dto.externo.EstornoResponse
{
Id = id
};
}
else if (!string.IsNullOrEmpty(estornoResponse.Erro))
{
response.Error.Messages.Add(estornoResponse.Erro);
}
return(response);
}
public static async Task <ResponseEnvelope> PerformThrottledRemoteProcedureCall <TRequest>(this System.Net.Http.HttpClient client, string url, RequestEnvelope requestEnvelope) where TRequest : IMessage <TRequest>
{
rpcQueue.Enqueue(requestEnvelope);
var count = rpcQueue.Count;
mutex.WaitOne();
RequestEnvelope r;
while (rpcQueue.TryDequeue(out r))
{
var diff = Math.Max(0, (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalMilliseconds - lastRpc);
if (diff < minDiff)
{
var delay = (int)((minDiff - diff) + (int)(new Random().NextDouble() * 0)); // Add some randomness
RandomHelper.RandomSleep(delay, delay + 100);
}
lastRpc = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalMilliseconds;
ResponseEnvelope response = await PerformRemoteProcedureCall <TRequest>(client, url, r).ConfigureAwait(false);
responses.GetOrAdd(r, response);
}
ResponseEnvelope ret;
responses.TryRemove(requestEnvelope, out ret);
mutex.Release();
return(ret);
}
protected override void CompleteSuccessRequest(int firstEventNumber, int lastEventNumber)
{
base.CompleteSuccessRequest(firstEventNumber, lastEventNumber);
var responseMsg = new ClientMessage.TransactionCommitCompleted(ClientCorrId, _transactionId, firstEventNumber, lastEventNumber);
ResponseEnvelope.ReplyWith(responseMsg);
}
public async Task <ResponseEnvelope <LookupModel> > GetFavoriteMusicByIdAsync(long id)
{
try
{
var dbResponse = this.staticDataRepository.GetAllFavoriteMusic();
if (dbResponse == null)
{
return(await ResponseEnvelope <LookupModel> .ErrorAsync(INVALID_DATA));
}
var selectedResponse = dbResponse.Where(d => d.ID == id).FirstOrDefault();
if (selectedResponse == null)
{
return(await ResponseEnvelope <LookupModel> .ErrorAsync(INVALID_DATA));
}
return(await ResponseEnvelope <LookupModel> .SuccessAsync(new LookupModel()
{
Id = selectedResponse.ID,
Key = selectedResponse.Key,
Name = selectedResponse.Name
}));
}
catch (Exception ex)
{
return(await ResponseEnvelope <LookupModel> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public async Task <ResponseEnvelope <string> > LogoutAsync()
{
try
{
var currentUser = this.userRepository.GetUser();
if (currentUser == null)
{
return(await ResponseEnvelope <string> .BadRequestAsync(INVALID_DATA));
}
var response = await this.ClientApi.PostJsonRequestAsync <string, object>(WebApi.ApiLogout, null);
if (response.Ack == AckCode.SUCCESS)
{
//update user data in local db
userRepository.ClearUser();
this.RefreshProxyData();
}
return(response);
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <string> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <string> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public async Task <ResponseEnvelope <string> > InviteUserToUseAppBySMSAsync(string phoneNumber)
{
try
{
if (string.IsNullOrEmpty(phoneNumber))
{
return(await ResponseEnvelope <string> .BadRequestAsync(INVALID_DATA));
}
SimpleDataWrapper_Dto <string> dto = new SimpleDataWrapper_Dto <string>()
{
Data = phoneNumber
};
var response = await this.ClientApi.PostJsonRequestAsync <string, SimpleDataWrapper_Dto <string> >(WebApi.ApiInvitePeopleToUseTheAppBySMS, dto);
return(response);
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <string> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <string> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public async Task <IResponseEnvelope <UserToken> > AuthenticateAsync(string login, string senha)
{
if (login == null || senha == null)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.MISSING_FIELDS)));
}
var userCredentials = await userTokenRepository.SearchAsync(login);
if (userCredentials == null || userCredentials.Password != securityHelper.SHA256(senha))
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.INVALID_LOGIN)));
}
var userToken = new UserToken
{
CreateDate = DateTime.Now,
ModifyDate = DateTime.Now,
IsValid = true,
UserId = userCredentials.Id,
Token = securityHelper.GenerateUniqueToken(),
Email = userCredentials.Email
};
await userTokenRepository.DeleteByEmailAsync(login);
await userTokenRepository.InsertToken(userToken);
return(ResponseEnvelope.CreateResponseEnvelope(userToken));
}
public async Task <IResponseEnvelope <UserToken> > SearchByTokenAsync(string token)
{
//Recover user by token
var userToken = await userTokenRepository.SearchByTokenAsync(token);
// Verify if the token is valid
if (userToken == null || !userToken.IsValid)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.UNAUTHORIZED_USER)));
}
// Get all tokens from the current user
var userTokens = await userTokenRepository.SearchTokensByLoginAsync(userToken.Email);
// Get the last token from the current user
var lastUserToken = userTokens.OrderByDescending(e => e.CreateDate).FirstOrDefault();
if (lastUserToken == null ||
lastUserToken.Token != token)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.UNAUTHORIZED_USER)));
}
if (DateTime.Now.Subtract(lastUserToken.ModifyDate).TotalMinutes > 3)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.INVALID_TOKEN)));
}
lastUserToken.ModifyDate = DateTime.Now;
await userTokenRepository.UpdateTokenAsync(lastUserToken);
return(ResponseEnvelope.CreateResponseEnvelope(userToken));
}
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)
{
if (response.StatusCode == ResponseEnvelope.Types.StatusCode.BadRequest)
{
for (var i = 0; i < request.Requests.Count; i++)
{
if (request.Requests[i].RequestType != RequestType.GetInventory || !response.Returns[i].IsEmpty)
{
continue;
}
_session.EventDispatcher.Send(new ErrorEvent
{
Message = _session.Translation.GetTranslation(TranslationString.AccountBanned)
});
_session.EventDispatcher.Send(new WarnEvent
{
Message = _session.Translation.GetTranslation(TranslationString.RequireInputText)
});
Console.ReadKey();
Environment.Exit(0);
}
}
_retryCount = 0;
}
public async Task <ResponseEnvelope <FriendRequestModel> > SendFriendRequestAsync(long userId)
{
try
{
if (userId == 0)
{
return(await ResponseEnvelope <FriendRequestModel> .BadRequestAsync(INVALID_DATA));
}
SimpleDataWrapper_Dto <long> dto = new SimpleDataWrapper_Dto <long>()
{
Data = userId
};
var response = await this.ClientApi.PostJsonRequestAsync <FriendRequest_Dto, SimpleDataWrapper_Dto <long> >(WebApi.ApiSendFriendRequest, dto);
return(await ResponseEnvelope <FriendRequestModel> .SuccessAsync(response.Data.ToFriendRequestModel()));
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <FriendRequestModel> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <FriendRequestModel> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public async Task <ResponseEnvelope <FriendModel> > AcceptFriendRequestAsync(long friendRequestId)
{
try
{
if (friendRequestId == 0)
{
return(await ResponseEnvelope <FriendModel> .BadRequestAsync(INVALID_DATA));
}
SimpleDataWrapper_Dto <long> dto = new SimpleDataWrapper_Dto <long>()
{
Data = friendRequestId
};
var response = await this.ClientApi.PostJsonRequestAsync <Friend_Dto, SimpleDataWrapper_Dto <long> >(WebApi.ApiAcceptFriendRequest, dto);
if (response.Ack == AckCode.SUCCESS)
{
return(await ResponseEnvelope <FriendModel> .SuccessAsync(response.Data.ToModel()));
}
return(await ResponseEnvelope <FriendModel> .ErrorAsync(response.Message));
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <FriendModel> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <FriendModel> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public async Task <ResponseEnvelope <FriendDetailsModel> > GetFriendProfileAsync(long id)
{
try
{
if (id == 0)
{
return(await ResponseEnvelope <FriendDetailsModel> .BadRequestAsync(INVALID_DATA));
}
var response = await this.ClientApi.GetRequestAsync <FriendProfile_Dto>(string.Format("{0}{1}", WebApi.ApiFriendProfile, id));
if (response.Ack == AckCode.SUCCESS)
{
return(await ResponseEnvelope <FriendDetailsModel> .SuccessAsync(response.Data.ToModel()));
}
return(await ResponseEnvelope <FriendDetailsModel> .ErrorAsync(response.Message));
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <FriendDetailsModel> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <FriendDetailsModel> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public ResponseEnvelope <comum_dto.PerfilAccessToken> Obter(Guid usuariosId, RedeSocialEnum redesocial)
{
var response = new ResponseEnvelope <comum_dto.PerfilAccessToken>();
var responsePerfil = perfilServico.Obter(new Filtro
{
UsuarioId = usuariosId,
RedeSocial = redesocial
});
responsePerfil.ThrownIfError();
response.HttpStatusCode = responsePerfil.HttpStatusCode;
var perfil = responsePerfil.Item;
if (string.IsNullOrEmpty(perfil.Token))
{
response.HttpStatusCode = HttpStatusCode.NotFound;
}
else
{
var servicoRedeSocial = (new Factory(redesocial, perfil.EmpresaId, empresaClient)).Obter();
response.Item = servicoRedeSocial.Parse(perfil.Token);
}
return(response);
}
protected override void CompleteFailedRequest(OperationResult result, string error, long currentVersion)
{
base.CompleteFailedRequest(result, error, currentVersion);
var responseMsg = new ClientMessage.TransactionCommitCompleted(ClientCorrId, _transactionId, result, error);
ResponseEnvelope.ReplyWith(responseMsg);
}
protected override void CompleteSuccessRequest(long firstEventNumber, long lastEventNumber, long preparePosition, long commitPosition)
{
base.CompleteSuccessRequest(firstEventNumber, lastEventNumber, preparePosition, commitPosition);
var responseMsg = new ClientMessage.TransactionCommitCompleted(ClientCorrId, _transactionId, firstEventNumber, lastEventNumber, preparePosition, commitPosition);
ResponseEnvelope.ReplyWith(responseMsg);
}
public Models.Shared.ResponseEnvelope Get(string url)
{
if (this.Authenticate())
{
var entry = new YotpoLogEntry("GET");
var client = this.GetHttpClient(entry);
if (client != null)
{
entry.url = this.ApplyParameters(url);
var result = client.GetAsync(entry.url).Result;
if (result != null)
{
entry.code = (int)result.StatusCode;
entry.response = result.Content.ReadAsStringAsync().Result;
this.Log_Request(entry);
var envelope = ResponseEnvelope.from(entry.response);
if (envelope.status.code == 200)
{
return(envelope);
}
else
{
throw new EnvelopeException(envelope.status);
}
}
}
}
return(null);
}
public async Task <ResponseEnvelope <string> > RegisterUserUsingSocialAsync(string accessToken, AuthProvider provider)
{
try
{
if (string.IsNullOrEmpty(accessToken))
{
return(await ResponseEnvelope <string> .BadRequestAsync(INVALID_DATA));
}
if (provider == AuthProvider.Forms)
{
return(await ResponseEnvelope <string> .BadRequestAsync(INVALID_DATA));
}
Req_SocialRequest_Dto dto = new Req_SocialRequest_Dto()
{
AccessToken = accessToken, Provider = Enum.GetName(typeof(Enums.AuthProvider), provider).ToLower()
};
var response = await this.ClientApi.PostJsonRequestAsync <string, Req_SocialRequest_Dto>(WebApi.ApiSocialRegistration, dto);
return(response);
}
catch (NoInternetConnectionException)
{
return(await ResponseEnvelope <string> .ErrorAsync(NO_INTERNET_CONNECTION));
}
catch (Exception ex)
{
return(await ResponseEnvelope <string> .ErrorAsync(INTERNAL_ERROR, ex));
}
}
public ResponseEnvelope Response(UsuarioResponse usuarioResponse)
{
var responseEnvelope = new ResponseEnvelope()
{
HttpStatusCode = (HttpStatusCode)usuarioResponse.HttpStatusCode
};
return(responseEnvelope);
}
protected override void CompleteSuccessRequest(long firstEventNumber, long lastEventNumber,
long preparePosition, long commitPosition)
{
base.CompleteSuccessRequest(firstEventNumber, lastEventNumber, preparePosition, commitPosition);
var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, OperationResult.Success, null,
preparePosition, commitPosition);
ResponseEnvelope.ReplyWith(responseMsg);
}
private static string strResponseEnvelope(ResponseEnvelope input)
{
var str = "RequestId: " + input.RequestId + " | statusCode: " + input.StatusCode + "| PlatformReturns Type: ";;
foreach (var element in input.PlatformReturns)
{
str += element.Type + ", ";
}
return(str);
}
public ResponseEnvelope <comum_dto.externo.AutenticacaoResponse> Autenticar(comum_dto.externo.AutenticacaoRequest request)
{
var response = new ResponseEnvelope <comum_dto.externo.AutenticacaoResponse>();
try
{
firebase.Autenticar(request.Email, request.Senha);
var userResponse = consultaService.Obter(
new comum_dto.filtros.UsuarioFiltro
{
EmpresaId = request.EmpresaId,
Email = request.Email
});
response.HttpStatusCode = userResponse.HttpStatusCode;
if (userResponse.Success)
{
var token = GerarToken(userResponse.Item.Id);
response.Item = new comum_dto.externo.AutenticacaoResponse
{
Token = token,
Nome = userResponse.Item.Nome,
Apelido = userResponse.Item.Apelido
};
}
}
catch (FirebaseAuthException fex)
{
var retornoNotFound = new List <AuthErrorReason>
{
AuthErrorReason.UnknownEmailAddress,
AuthErrorReason.UserNotFound,
};
response.HttpStatusCode = System.Net.HttpStatusCode.BadRequest;
response.Error.Messages.Add(fex.Reason.ToString());
if (retornoNotFound.Contains(fex.Reason))
{
response.HttpStatusCode = System.Net.HttpStatusCode.NotFound;
}
}
catch (Exception ex)
{
// ## TODO log
response.HttpStatusCode = System.Net.HttpStatusCode.InternalServerError;
response.Error.Messages.Add(ex.Message);
}
return(response);
}
public static async Task <IMessage[]> PostProtoPayload <TRequest>(this System.Net.Http.HttpClient client,
string url, RequestEnvelope requestEnvelope, Client rpcClient,
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 loopsOnBadRepsonse = 1;
/*
* await RandomHelper.RandomDelay(500, 600);
* ResponseEnvelope response;
* while ((response = await PostProto<TRequest>(client, url, requestEnvelope)).Returns.Count != responseTypes.Length)
* {
* throw new InvalidResponseException($"Expected {responseTypes.Length} responses, but got {response.Returns.Count} responses");
* }
*/
await RandomHelper.RandomDelay(500, 600);
ResponseEnvelope response = await PostProto <TRequest>(client, url, requestEnvelope);
while (response.Returns.Count != responseTypes.Length && loopsOnBadRepsonse <= 5)
{
//Logger.Write($"Bad Payload Repsonse. Retry {loopsOnBadRepsonse} of 5 <- IGNORE THIS F*****G MESSAGE...I KNOW IT", LogLevel.Warning);
await RandomHelper.RandomDelay(500, 600);
response = await PostProto <TRequest>(client, url, requestEnvelope);
loopsOnBadRepsonse += 1;
await rpcClient.Login.DoLogin();
}
//error thrown here.
if (response.Returns.Count != responseTypes.Length)
{
throw new InvalidResponseException($"Expected {responseTypes.Length} responses, but got {response.Returns.Count} responses");
}
for (var i = 0; i < responseTypes.Length; i++)
{
var payload = response.Returns[i];
result[i].MergeFrom(payload);
}
return(result);
}
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;
}
/// <summary>
/// Responsible for handling the received <see cref="ResponseEnvelope" />.
/// </summary>
/// <param name="request"></param>
/// <param name="responseEnvelope">
/// The <see cref="ResponseEnvelope" /> received from
/// <see cref="SendRemoteProcedureCall(Request)" />.
/// </param>
/// <returns>Returns the <see cref="ByteString" /> response of the <see cref="Request" />.</returns>
private ByteString HandleResponseEnvelope(Request request, ResponseEnvelope responseEnvelope)
{
if (responseEnvelope.Returns.Count != 5)
{
throw new Exception($"There were only {responseEnvelope.Returns.Count} responses, we expected 5.");
}
// Take requested response and remove from returns.
var requestResponse = responseEnvelope.Returns[0];
responseEnvelope.Returns.RemoveAt(0);
// Handle the default responses.
HandleDefaultResponses(responseEnvelope.Returns);
// Handle responses which affect the inventory
HandleInventoryResponses(request, requestResponse);
return requestResponse;
}
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 async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
return ApiOperation.Retry;
}
public void HandleApiSuccess(RequestEnvelope request, ResponseEnvelope response)
{
}
public async Task<ApiOperation> HandleApiFailure(RequestEnvelope request, ResponseEnvelope response)
{
await Task.Delay(500);
_retryCount++;
return _retryCount < _maxRetries ? ApiOperation.Retry : ApiOperation.Abort;
}
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;
}
