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; }