private async Task <Tuple <T, KinveyException, int> > HandlePushPUT(PendingWriteAction pwa) { T entity = default(T); var offset = 0; KinveyException kinveyException = null; try { int result = 0; var localEntity = Cache.FindByID(pwa.entityId); NetworkRequest <T> request = Client.NetworkFactory.buildUpdateRequest <T>(pwa.collection, localEntity, pwa.entityId); entity = await request.ExecuteAsync().ConfigureAwait(false); Cache.UpdateCacheSave(entity, pwa.entityId); result = SyncQueue.Remove(pwa); if (result == 0) { offset++; } } catch (KinveyException ke) { kinveyException = ke; offset++; } return(new Tuple <T, KinveyException, int>(entity, kinveyException, offset)); }
private async Task <Tuple <T, KinveyException, int> > HandlePushDELETE(PendingWriteAction pwa) { var offset = 0; KinveyException kinveyException = null; try { int result = 0; NetworkRequest <KinveyDeleteResponse> request = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(pwa.collection, pwa.entityId); KinveyDeleteResponse kdr = await request.ExecuteAsync().ConfigureAwait(false); if (kdr.count == 1) { result = SyncQueue.Remove(pwa); if (result == 0) { offset++; } } } catch (KinveyException ke) { kinveyException = ke; offset++; } return(new Tuple <T, KinveyException, int>(default(T), kinveyException, offset)); }
/// <summary> /// Executes the request asynchronously. /// </summary> /// <returns> The async task with the request result.</returns> public override async Task <uint> ExecuteAsync() { uint countResult = default(uint); switch (Policy) { case ReadPolicy.FORCE_LOCAL: // sync countResult = PerformLocalCount(); break; case ReadPolicy.FORCE_NETWORK: // network countResult = await PerformNetworkCount().ConfigureAwait(false); break; case ReadPolicy.BOTH: // cache // first, perform local query PerformLocalCount(cacheDelegate); // once local query finishes, perform network query countResult = await PerformNetworkCount().ConfigureAwait(false); break; case ReadPolicy.NETWORK_OTHERWISE_LOCAL: // auto KinveyException networkKinveyException = null; try { // first, perform a network request countResult = await PerformNetworkCount().ConfigureAwait(false); } catch (KinveyException exception) { if (exception.ErrorCategory != EnumErrorCategory.ERROR_DATASTORE_NETWORK || exception.ErrorCode != EnumErrorCode.ERROR_GENERAL) { throw; } networkKinveyException = exception; } // if the network request fails, fetch data from local cache if (networkKinveyException != null) { countResult = PerformLocalCount(); } break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid read policy"); } return(countResult); }
/// <summary> /// Executes the request asynchronously. /// </summary> /// <returns>The async.</returns> public override async Task <List <GroupAggregationResults> > ExecuteAsync() { List <GroupAggregationResults> aggregateResult = new List <GroupAggregationResults>(); switch (Policy) { case ReadPolicy.FORCE_LOCAL: // sync aggregateResult = PerformLocalAggregateFind(); break; case ReadPolicy.FORCE_NETWORK: // network aggregateResult = await PerformNetworkAggregateFind(); break; case ReadPolicy.BOTH: // cache // first, perform local aggregation PerformLocalAggregateFind(cacheDelegate); // once local finishes, perform network aggregation aggregateResult = await PerformNetworkAggregateFind(); break; case ReadPolicy.NETWORK_OTHERWISE_LOCAL: // auto KinveyException networkKinveyException = null; try { // first, perform a network request aggregateResult = await PerformNetworkAggregateFind(); } catch (KinveyException exception) { if (exception.ErrorCategory != EnumErrorCategory.ERROR_DATASTORE_NETWORK || exception.ErrorCode != EnumErrorCode.ERROR_GENERAL) { throw; } networkKinveyException = exception; } // if the network request fails, fetch data from local cache if (networkKinveyException != null) { aggregateResult = PerformLocalAggregateFind(); } break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid read policy"); } return(aggregateResult); }
/// <summary> /// Executes the request without any parsing. /// </summary> /// <returns>The unparsed.</returns> public HttpResponseMessage ExecuteUnparsed() { var client = InitializeRestClient(); var request = BuildRestRequest(); RequestAuth.Authenticate(request); Logger.Log(request); var req = client.SendAsync(request); var response = req.Result; Logger.Log(response); var contentType = response.Headers .Where(x => x.Key.ToLower().Equals("content-type")) .Select(x => x.Value) .SingleOrDefault(); if (contentType != null && contentType.Any() && !contentType.First().Contains("application/json")) { var kinveyException = new KinveyException( EnumErrorCategory.ERROR_REQUIREMENT, EnumErrorCode.ERROR_REQUIREMENT_CONTENT_TYPE_HEADER, contentType.FirstOrDefault() ) { RequestID = HelperMethods.getRequestID(response) }; throw kinveyException; } lastResponseCode = response.StatusCode; lastResponseMessage = response.StatusCode.ToString(); lastResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >(); foreach (var header in response.Headers) { lastResponseHeaders.Add(header); } try { response.EnsureSuccessStatusCode(); } catch (Exception ex) { throw new KinveyException( EnumErrorCategory.ERROR_BACKEND, EnumErrorCode.ERROR_JSON_RESPONSE, ex.Message, ex ); } return(response); }
/// <summary> /// Executes this request async and parses the result. /// </summary> /// <returns>The async request.</returns> public async Task <KinveyAuthResponse> ExecuteAsync() { string json = null; HttpResponseMessage response = null; try { response = await ExecuteUnparsedAsync().ConfigureAwait(false); json = await response.Content.ReadAsStringAsync().ConfigureAwait(false); return(JsonConvert.DeserializeObject <KinveyAuthResponse>(json)); } catch (JsonException ex) { KinveyException kinveyException = new KinveyException( EnumErrorCategory.ERROR_DATASTORE_NETWORK, EnumErrorCode.ERROR_JSON_PARSE, HelperMethods.GetCustomParsingJsonErrorMessage(json, response?.RequestMessage.RequestUri.ToString(), typeof(KinveyAuthResponse).FullName), null, ex ) { RequestID = HelperMethods.getRequestID(response) }; throw kinveyException; } catch (KinveyException) { throw; } catch (Exception ex) { throw new KinveyException( EnumErrorCategory.ERROR_USER, EnumErrorCode.ERROR_USER_LOGIN_ATTEMPT, "Error deserializing response content.", ex ); } }
private async Task <Tuple <T, KinveyException, int> > HandlePushPOST(PendingWriteAction pwa) { T entity = default(T); var offset = 0; KinveyException kinveyException = null; try { int result = 0; string tempID = pwa.entityId; var localEntity = Cache.FindByID(pwa.entityId); JObject obj = JObject.FromObject(localEntity); obj["_id"] = null; localEntity = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(obj.ToString()); NetworkRequest <T> request = Client.NetworkFactory.buildCreateRequest <T>(pwa.collection, localEntity); entity = await request.ExecuteAsync().ConfigureAwait(false); Cache.UpdateCacheSave(entity, tempID); result = SyncQueue.Remove(pwa); if (result == 0) { offset++; } } catch (KinveyException ke) { kinveyException = ke; offset++; } return(new Tuple <T, KinveyException, int>(entity, kinveyException, offset)); }
public override async Task <List <T> > ExecuteAsync() { List <T> listResult = default(List <T>); switch (Policy) { case ReadPolicy.FORCE_LOCAL: // sync listResult = PerformLocalFind(); break; case ReadPolicy.FORCE_NETWORK: // network var result = await RetrieveNetworkResults(this.BuildMongoQuery()); listResult = result; break; case ReadPolicy.BOTH: // cache // first, perform local query PerformLocalFind(cacheDelegate); // once local query finishes, perform network query var resolved = await PerformNetworkFind(); if (resolved.IsDeltaFetched) { listResult = PerformLocalFind(); } else { listResult = resolved.ResultSet; } break; case ReadPolicy.NETWORK_OTHERWISE_LOCAL: // auto KinveyException networkKinveyException = null; try { // first, perform a network request var networkResult = await PerformNetworkFind(); if (networkResult.IsDeltaFetched) { listResult = PerformLocalFind(); } else { listResult = networkResult.ResultSet; } } catch (KinveyException exception) { if (exception.ErrorCategory != EnumErrorCategory.ERROR_DATASTORE_NETWORK || exception.ErrorCode != EnumErrorCode.ERROR_GENERAL) { throw; } networkKinveyException = exception; } // if the network request fails, fetch data from local cache if (networkKinveyException != null) { listResult = PerformLocalFind(); } break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid read policy"); } return(listResult); }
public override async Task <T> ExecuteAsync() { T savedEntity = default(T); NetworkRequest <T> request = null; string entityID = null;; JToken idToken = JObject.FromObject(entity) ["_id"]; if (idToken != null && !String.IsNullOrEmpty(idToken.ToString())) { entityID = idToken.ToString(); request = Client.NetworkFactory.buildUpdateRequest(Collection, entity, entityID); } else { request = Client.NetworkFactory.buildCreateRequest(Collection, entity); } switch (Policy) { case WritePolicy.FORCE_LOCAL: // sync PendingWriteAction pendingAction = PendingWriteAction.buildFromRequest(request); string saveModeLocal = request.RequestMethod; string tempIdLocal = null; if (String.Equals("POST", saveModeLocal)) { tempIdLocal = PrepareCacheSave(ref entity); savedEntity = Cache.Save(entity); pendingAction.entityId = tempIdLocal; } else { savedEntity = Cache.Update(entity); } SyncQueue.Enqueue(pendingAction); break; case WritePolicy.FORCE_NETWORK: // network savedEntity = await request.ExecuteAsync(); break; case WritePolicy.NETWORK_THEN_LOCAL: // cache string saveModeNetworkThenLocal = request.RequestMethod; string tempIdNetworkThenLocal = null; if (String.Equals("POST", saveModeNetworkThenLocal)) { tempIdNetworkThenLocal = PrepareCacheSave(ref entity); Cache.Save(entity); } else { Cache.Update(entity); } // network save savedEntity = await request.ExecuteAsync(); if (tempIdNetworkThenLocal != null) { Cache.UpdateCacheSave(savedEntity, tempIdNetworkThenLocal); } break; case WritePolicy.LOCAL_THEN_NETWORK: string saveModeLocalThenNetwork = request.RequestMethod; // cache if (String.Equals("POST", saveModeLocalThenNetwork)) { entityID = PrepareCacheSave(ref entity); savedEntity = Cache.Save(entity); } else { savedEntity = Cache.Update(entity); } KinveyException kinveyException = null; Exception exception = null; try { // network save savedEntity = await request.ExecuteAsync(); } catch (KinveyException kinveyEx) { kinveyException = kinveyEx; } catch (Exception ex) { exception = ex; } if (kinveyException != null || exception != null) { // if the network request fails, save data to sync queue var localPendingAction = PendingWriteAction.buildFromRequest(request); localPendingAction.entityId = entityID; SyncQueue.Enqueue(localPendingAction); if (kinveyException != null) { throw kinveyException; } } else { Cache.UpdateCacheSave(savedEntity, entityID); } break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid write policy"); } return(savedEntity); }
KinveyException HandleStatusMessage(PubnubApi.PNStatus status) { KinveyException ke = default(KinveyException); if (status.Error) { // Status indicates an error with PubNub var errorData = status.ErrorData; if (status.StatusCode == 403) { ke = new KinveyException(EnumErrorCategory.ERROR_REALTIME, EnumErrorCode.ERROR_REALTIME_CRITICAL_NOT_AUTHORIZED_ON_CHANNEL, errorData.Information, errorData.Throwable); } else { ke = new KinveyException(EnumErrorCategory.ERROR_REALTIME, EnumErrorCode.ERROR_REALTIME_ERROR, errorData.Information, errorData.Throwable); } } else { // TODO Figure out which status operations need to be logged. switch (status.Operation) { // Publish/Subscribe case PubnubApi.PNOperationType.PNPublishOperation: break; case PubnubApi.PNOperationType.PNSubscribeOperation: break; case PubnubApi.PNOperationType.PNUnsubscribeOperation: break; // Channel Group and Channels case PubnubApi.PNOperationType.ChannelGroupAllGet: break; case PubnubApi.PNOperationType.ChannelGroupAuditAccess: break; case PubnubApi.PNOperationType.ChannelGroupGet: break; case PubnubApi.PNOperationType.ChannelGroupGrantAccess: break; case PubnubApi.PNOperationType.ChannelGroupRevokeAccess: break; case PubnubApi.PNOperationType.PNAddChannelsToGroupOperation: break; case PubnubApi.PNOperationType.PNChannelGroupsOperation: break; case PubnubApi.PNOperationType.PNChannelsForGroupOperation: break; case PubnubApi.PNOperationType.PNRemoveChannelsFromGroupOperation: break; case PubnubApi.PNOperationType.PNRemoveGroupOperation: break; // Access Manager case PubnubApi.PNOperationType.PNAccessManagerAudit: break; case PubnubApi.PNOperationType.PNAccessManagerGrant: break; // Presence case PubnubApi.PNOperationType.Presence: break; case PubnubApi.PNOperationType.PresenceUnsubscribe: break; // Push case PubnubApi.PNOperationType.PushGet: break; case PubnubApi.PNOperationType.PushRegister: break; case PubnubApi.PNOperationType.PushRemove: break; case PubnubApi.PNOperationType.PushUnregister: break; // Miscellaneous case PubnubApi.PNOperationType.Leave: break; case PubnubApi.PNOperationType.None: break; case PubnubApi.PNOperationType.RevokeAccess: break; case PubnubApi.PNOperationType.PNFireOperation: break; case PubnubApi.PNOperationType.PNGetStateOperation: break; case PubnubApi.PNOperationType.PNHeartbeatOperation: break; case PubnubApi.PNOperationType.PNHereNowOperation: break; case PubnubApi.PNOperationType.PNHistoryOperation: break; case PubnubApi.PNOperationType.PNSetStateOperation: break; case PubnubApi.PNOperationType.PNTimeOperation: break; case PubnubApi.PNOperationType.PNWhereNowOperation: break; default: break; } } return(ke); }
internal void AddKinveyException(KinveyException e) { kinveyExceptions.Add(e); }
/// <summary> /// Executes a multi insert request. /// </summary> /// <returns>An async task with the request result.</returns> public override async Task <KinveyMultiInsertResponse <T> > ExecuteAsync() { var kinveyDataStoreResponse = new KinveyMultiInsertResponse <T> { Entities = new List <T>(), Errors = new List <Error>() }; switch (Policy) { case WritePolicy.FORCE_LOCAL: //local cache for (var index = 0; index < entities.Count; index++) { try { var cacheSaveResult = CacheSave(entities[index]); SyncQueue.Enqueue(cacheSaveResult.Item1); kinveyDataStoreResponse.Entities.Add(cacheSaveResult.Item2); } catch (Exception ex) { kinveyDataStoreResponse.Entities.Add(default(T)); var error = new Error { Index = index, Code = 0, Errmsg = ex.Message }; kinveyDataStoreResponse.Errors.Add(error); } } ThrowExceptionIfOnlyErrors(kinveyDataStoreResponse, EnumErrorCategory.ERROR_DATASTORE_CACHE, EnumErrorCode.ERROR_DATASTORE_CACHE_MULTIPLE_SAVE); break; case WritePolicy.FORCE_NETWORK: // network kinveyDataStoreResponse = await HandleNetworkRequestAsync(entities).ConfigureAwait(false); ThrowExceptionIfOnlyErrors(kinveyDataStoreResponse, EnumErrorCategory.ERROR_BACKEND, EnumErrorCode.ERROR_JSON_RESPONSE); break; case WritePolicy.LOCAL_THEN_NETWORK: //local cache KinveyMultiInsertResponse <T> kinveyDataStoreNetworkResponse = null; var pendingWriteActions = new List <PendingWriteAction>(); for (var index = 0; index < entities.Count; index++) { try { var cacheSaveResult = CacheSave(entities[index]); pendingWriteActions.Add(cacheSaveResult.Item1); kinveyDataStoreResponse.Entities.Add(cacheSaveResult.Item2); } catch (Exception ex) { kinveyDataStoreResponse.Entities.Add(default(T)); var error = new Error { Index = index, Code = 0, Errmsg = ex.Message }; kinveyDataStoreResponse.Errors.Add(error); } } ThrowExceptionIfOnlyErrors(kinveyDataStoreResponse, EnumErrorCategory.ERROR_DATASTORE_CACHE, EnumErrorCode.ERROR_DATASTORE_CACHE_MULTIPLE_SAVE); KinveyException kinveyException = null; Exception exception = null; try { // network kinveyDataStoreNetworkResponse = await HandleNetworkRequestAsync(entities).ConfigureAwait(false); } catch (KinveyException kinveyEx) { kinveyException = kinveyEx; } catch (Exception ex) { exception = ex; } if (kinveyException != null || exception != null) { foreach (var pendingAction in pendingWriteActions) { SyncQueue.Enqueue(pendingAction); } if (kinveyException != null) { throw kinveyException; } } else { for (var index = 0; index < kinveyDataStoreResponse.Entities.Count; index++) { if (kinveyDataStoreNetworkResponse.Entities[index] != null) { if (kinveyDataStoreResponse.Entities[index] != null) { var obj = JObject.FromObject(kinveyDataStoreResponse.Entities[index]); var id = obj["_id"].ToString(); Cache.UpdateCacheSave(kinveyDataStoreNetworkResponse.Entities[index], id); } else { CacheSave(kinveyDataStoreNetworkResponse.Entities[index]); } } else { if (kinveyDataStoreResponse.Entities[index] != null) { var obj = JObject.FromObject(kinveyDataStoreResponse.Entities[index]); var id = obj["_id"].ToString(); var existingPendingWriteAction = pendingWriteActions.Find(e => e.entityId.Equals(id)); if (existingPendingWriteAction != null) { SyncQueue.Enqueue(existingPendingWriteAction); } } } } kinveyDataStoreResponse = kinveyDataStoreNetworkResponse; } ThrowExceptionIfOnlyErrors(kinveyDataStoreResponse, EnumErrorCategory.ERROR_BACKEND, EnumErrorCode.ERROR_JSON_RESPONSE); break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid write policy"); } return(kinveyDataStoreResponse); }
public override async Task <KinveyDeleteResponse> ExecuteAsync() { var kdr = default(KinveyDeleteResponse); switch (Policy) { case WritePolicy.FORCE_LOCAL: // sync if (_query == null) { // cache kdr = Cache.DeleteByID(entityID); var request = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID); var pendingAction = PendingWriteAction.buildFromRequest(request); SyncQueue.Enqueue(pendingAction); } else { // cache kdr = Cache.DeleteByQuery(_query); foreach (var id in kdr.IDs) { var request = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, id); var pendingAction = PendingWriteAction.buildFromRequest(request); SyncQueue.Enqueue(pendingAction); } } break; case WritePolicy.FORCE_NETWORK: // network if (_query == null) { kdr = await Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID).ExecuteAsync(); } else { var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query); kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync(); } break; case WritePolicy.NETWORK_THEN_LOCAL: if (_query == null) { // cache kdr = Cache.DeleteByID(entityID); // network kdr = await Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID).ExecuteAsync(); } else { // cache kdr = Cache.DeleteByQuery(_query); // network var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query); kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync(); } break; case WritePolicy.LOCAL_THEN_NETWORK: if (_query == null) { // cache kdr = Cache.DeleteByID(entityID); var deleteRequest = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID); KinveyException kinveyException = null; Exception exception = null; try { // network kdr = await deleteRequest.ExecuteAsync(); } catch (KinveyException kinveyEx) { kinveyException = kinveyEx; } catch (Exception ex) { exception = ex; } if (kinveyException != null || exception != null) { var pendingAction = PendingWriteAction.buildFromRequest(deleteRequest); SyncQueue.Enqueue(pendingAction); if (kinveyException != null) { throw kinveyException; } } } else { // cache kdr = Cache.DeleteByQuery(_query); // network KinveyException kinveyException = null; Exception exception = null; try { var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query); kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync(); } catch (KinveyException kinveyEx) { kinveyException = kinveyEx; } catch (Exception ex) { exception = ex; } if (kinveyException != null || exception != null) { foreach (var id in kdr.IDs) { var request = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, id); var pendingAction = PendingWriteAction.buildFromRequest(request); SyncQueue.Enqueue(pendingAction); } if (kinveyException != null) { throw kinveyException; } } } break; default: throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid write policy"); } return(kdr); }
public virtual async Task <T> ExecuteAsync() { var response = await ExecuteUnparsedAsync(); if (OverrideRedirect) { string newLoc = string.Empty; foreach (var header in response.Headers) { if (header.Key.ToLower().Equals("location")) { newLoc = header.Value.FirstOrDefault(); break; } } //string newlocation = response.Headers.FirstOrDefault(stringToCheck => stringToCheck.ToString().Equals("Location")).ToString(); return(await onRedirectAsync(newLoc)); } // special case to handle void or empty responses if (response.Content == null) { return(default(T)); } string path = response.RequestMessage.RequestUri.AbsolutePath; if (path != null && path.Contains(Constants.STR_PATH_CUSTOM_ENDPOINT) && (((int)response.StatusCode) < 200 || ((int)response.StatusCode) > 302)) { // Seems like only Custom Endpoint/BL would result in having a successful response // without having a successful status code. The BL executed successfully, but did // produce a successsful outcome. try { response.EnsureSuccessStatusCode(); } catch (Exception ex) { var ke = new KinveyException( EnumErrorCategory.ERROR_CUSTOM_ENDPOINT, EnumErrorCode.ERROR_CUSTOM_ENDPOINT_ERROR, response, ex ); throw ke; } } if (path != null && path.Contains(Constants.STR_PATH_REALTIME_STREAM) && (((int)response.StatusCode) < 200 || ((int)response.StatusCode) > 302)) { // Appears as though there is a stream error. A stream error could result in having a successful response // without having a successful status code, such as a 401. The request was successful, but the response // indicates that there is an issue with what was being requested try { response.EnsureSuccessStatusCode(); } catch (Exception ex) { var ke = new KinveyException( EnumErrorCategory.ERROR_REALTIME, EnumErrorCode.ERROR_REALTIME_ERROR, response, ex ); throw ke; } } if (((int)response.StatusCode) < 200 || ((int)response.StatusCode) > 302) { try { response.EnsureSuccessStatusCode(); } catch (Exception ex) { var kinveyException = new KinveyException( EnumErrorCategory.ERROR_BACKEND, EnumErrorCode.ERROR_JSON_RESPONSE, response, ex ) { RequestID = HelperMethods.getRequestID(response) }; throw kinveyException; } } try { var json = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <T>(json); RequestStartTime = HelperMethods.GetRequestStartTime(response); return(result); } catch (JsonException ex) { KinveyException kinveyException = new KinveyException( EnumErrorCategory.ERROR_DATASTORE_NETWORK, EnumErrorCode.ERROR_JSON_PARSE, ex.Message, ex ) { RequestID = HelperMethods.getRequestID(response) }; throw kinveyException; } catch (ArgumentException ex) { Logger.Log(ex.Message); return(default(T)); } catch (NullReferenceException ex) { Logger.Log(ex.Message); return(default(T)); } }
public async Task <HttpResponseMessage> ExecuteUnparsedAsync() { var httClient = InitializeRestClient(); var request = BuildRestRequest(); RequestAuth.Authenticate(request); Logger.Log(request); var response = await httClient.SendAsync(request); Logger.Log(response); var contentType = response.Headers .Where(x => x.Key.ToLower().Equals("content-type")) .Select(x => x.Value) .FirstOrDefault()? .FirstOrDefault(); if (contentType != null && !contentType.Contains("application/json")) { var kinveyException = new KinveyException( EnumErrorCategory.ERROR_REQUIREMENT, EnumErrorCode.ERROR_REQUIREMENT_CONTENT_TYPE_HEADER, contentType ) { RequestID = HelperMethods.getRequestID(response) }; throw kinveyException; } lastResponseCode = response.StatusCode; lastResponseMessage = response.StatusCode.ToString(); lastResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >(); foreach (var header in response.Headers) { lastResponseHeaders.Add(header); } if ((int)response.StatusCode == 401) { ServerError error = null; try { var json = await response.Content.ReadAsStringAsync(); error = JsonConvert.DeserializeObject <ServerError>(json); } catch (Exception) { } if (error != null && !error.Error.Equals(Constants.STR_ERROR_BACKEND_INSUFFICIENT_CREDENTIALS)) { // Attempt to get the refresh token Credential cred = Client.Store.Load(Client.ActiveUser.Id, Client.SSOGroupKey); string refreshToken = null; string redirectUri = null; string micClientId = null; if (cred != null) { refreshToken = cred.RefreshToken; redirectUri = cred.RedirectUri; micClientId = cred.MICClientID; if (!string.IsNullOrEmpty(refreshToken) && !refreshToken.ToLower().Equals("null")) { if (!hasRetried) { // Attempting retry - set flag to prevent additional attempts hasRetried = true; //use the refresh token for a new access token JObject result = await Client.ActiveUser.UseRefreshToken(refreshToken, redirectUri, micClientId).ExecuteAsync(); // log out the current user without removing the user record from the credential store Client.ActiveUser.LogoutSoft(); //login with the access token Provider provider = new Provider(); provider.kinveyAuth = new MICCredential(result["access_token"].ToString()); User u = await User.LoginAsync(new ThirdPartyIdentity(provider), Client); //store the new refresh token Credential currentCred = Client.Store.Load(Client.ActiveUser.Id, Client.SSOGroupKey); currentCred.AccessToken = result["access_token"].ToString(); currentCred.RefreshToken = result.GetValidValue("refresh_token"); currentCred.RedirectUri = redirectUri; Client.Store.Store(Client.ActiveUser.Id, Client.SSOGroupKey, currentCred); // Retry the original request RequestAuth = new KinveyAuthenticator(currentCred.AuthToken); var retryResponse = await ExecuteUnparsedAsync(); return(retryResponse); } else { Client.ActiveUser.Logout(); } } else { //logout the current user Client.ActiveUser.Logout(); } } else { Client.ActiveUser.Logout(); } } } try { response.EnsureSuccessStatusCode(); } catch (Exception ex) { throw new KinveyException( EnumErrorCategory.ERROR_BACKEND, EnumErrorCode.ERROR_JSON_RESPONSE, response, ex ); } return(response); }