public async Task <IEnumerable <SlidersData> > ReadAllDataAsync() { if (IsConnected) { var json = await _client.GetStringAsync($"api/SlidersData"); return(await Task.Run(() => _serializer.DeserializeObject <IEnumerable <SlidersData> >(json))); } return(null); }
private CampData LoadCachedCampData() { if (!_fileManager.FileExists(DataFileName)) { return(null); } var campJson = _fileManager.ReadFile(DataFileName); if (string.IsNullOrEmpty(campJson)) { return(null); } try { return(_jsonConverter.DeserializeObject <CampData>(campJson)); } catch { // if something went wrong deserializing, just nuke the cached version _fileManager.DeleteFile(DataFileName); return(null); } }
/// <summary> /// Makes the API call. /// </summary> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="url">The URL.</param> /// <param name="method">The method.</param> /// <param name="data">The data.</param> /// <returns></returns> public async Task <TResult> MakeAsyncApiCall <TResult>(string url, HttpMethod method, object data = null) where TResult : class { url = url.Replace("http://", "https://"); using (var httpClient = new HttpClient()) { using (var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = method }) { // add content if (method != HttpMethod.Get) { var json = _jsonConverter.SerializeObject(data); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); } var response = new HttpResponseMessage(); try { response = await httpClient.SendAsync(request).ConfigureAwait(false); } catch (Exception) { // log error } var stringSerialized = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // deserialize content return(_jsonConverter.DeserializeObject <TResult>(stringSerialized)); } } }
public virtual void RestoreCacheConfiguration(Bundle savedInstanceState, IMvxJsonConverter serializer) { if (savedInstanceState == null) { return; } EnableOnFragmentPoppedCallback = savedInstanceState.GetBoolean(SavedFragmentCacheConfigurationEnabledFragmentPoppedCallbackState, true); // restore what fragments we have registered - and informations about registered fragments. string jsonSerializedMvxCachedFragmentInfosToRestore; if (Build.VERSION.SdkInt >= BuildVersionCodes.HoneycombMr1) { jsonSerializedMvxCachedFragmentInfosToRestore = savedInstanceState.GetString(SavedFragmentCacheConfiguration, string.Empty); } else { jsonSerializedMvxCachedFragmentInfosToRestore = savedInstanceState.GetString(SavedFragmentCacheConfiguration); } // there are no registered fragments at this moment, skip restore if (string.IsNullOrEmpty(jsonSerializedMvxCachedFragmentInfosToRestore)) { return; } var serializedMvxCachedFragmentInfos = serializer.DeserializeObject <Dictionary <string, TSerializableMvxCachedFragmentInfo> >(jsonSerializedMvxCachedFragmentInfosToRestore); _lookup = serializedMvxCachedFragmentInfos.ToDictionary(x => x.Key, keyValuePair => MvxCachedFragmentInfoFactory.ConvertSerializableFragmentInfo(keyValuePair.Value as SerializableMvxCachedFragmentInfo)); }
private void RestoreCurrentFragmentsFromBundle(IMvxJsonConverter serializer, Bundle savedInstanceState) { var json = savedInstanceState.GetString(SavedCurrentFragmentsKey); var currentFragments = serializer.DeserializeObject <Dictionary <int, string> >(json); _currentFragments = currentFragments; }
/// <summary> /// Gets the data from the file system /// </summary> /// <returns>An instance of the saved data, or a new instance if none had been saved</returns> public FeedbackData GetData() { string feedbackDataBuffer; return(_fileStore.TryReadTextFile(DataFileName, out feedbackDataBuffer) ? _jsonConverter.DeserializeObject <FeedbackData>(feedbackDataBuffer) : new FeedbackData()); }
public async Task <CampData> GetData() { using (var client = new HttpClient()) { var json = await client.GetStringAsync(DataUrl); return(_jsonConverter.DeserializeObject <CampData>(json)); } }
public async Task <List <ConferenceDto> > LoadConferencesAsync(string userName) { string url; if (!string.IsNullOrWhiteSpace(userName)) { url = TekConfApi.BaseUrl + "/conferences?userName="******"/conferences"; } var json = await _httpClient.GetStringAsync(url); var conferences = await TaskEx.Run(() => _jsonConverter.DeserializeObject <List <ConferenceDto> >(json)); return(conferences.OrderBy(c => c.Start).ToList()); }
private static void RestoreViewModelsFromBundle(IMvxJsonConverter serializer, Bundle savedInstanceState) { IMvxSavedStateConverter savedStateConverter; IMvxMultipleViewModelCache viewModelCache; IMvxViewModelLoader viewModelLoader; if (!Mvx.TryResolve(out savedStateConverter)) { Mvx.Trace("Could not resolve IMvxSavedStateConverter, won't be able to convert saved state"); return; } if (!Mvx.TryResolve(out viewModelCache)) { Mvx.Trace("Could not resolve IMvxMultipleViewModelCache, won't be able to convert saved state"); return; } if (!Mvx.TryResolve(out viewModelLoader)) { Mvx.Trace("Could not resolve IMvxViewModelLoader, won't be able to load ViewModel for caching"); return; } // Harder ressurection, just in case we were killed to death. var json = savedInstanceState.GetString(SavedFragmentTypesKey); if (string.IsNullOrEmpty(json)) { return; } var savedState = serializer.DeserializeObject <Dictionary <string, Type> >(json); foreach (var item in savedState) { var bundle = savedInstanceState.GetBundle(item.Key); if (bundle.IsEmpty) { continue; } var mvxBundle = savedStateConverter.Read(bundle); var request = MvxViewModelRequest.GetDefaultRequest(item.Value); // repopulate the ViewModel with the SavedState and cache it. var vm = viewModelLoader.LoadViewModel(request, mvxBundle); viewModelCache.Cache(vm, item.Key); } }
public async Task <TResult> MakeApiCall <TResult>(string url, HttpMethod method, object data = null, string token = null) where TResult : class { url = url.Replace("http://", "https://"); using (var httpClient = new HttpClient()) { using (var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = method }) { request.Headers.Clear(); var accessToken = token ?? await _storageHelper.GetAccessToken(); request.Headers.Authorization = new AuthenticationHeaderValue(accessToken); // add content if (method != HttpMethod.Get) { var json = _jsonConverter.SerializeObject(data); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); } HttpResponseMessage response = new HttpResponseMessage(); try { response = await httpClient.SendAsync(request).ConfigureAwait(false); if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized) { throw new ApplicationException("The session was expired. Please, re-login."); } } catch (Exception ex) { _mvxLog.ErrorException("MakeApiCall failed", ex); throw; } var stringSerialized = await response.Content.ReadAsStringAsync(); return(_jsonConverter.DeserializeObject <TResult>(stringSerialized)); } } }
private async Task <string> GetIsOauthUserRegistered(string providerId) { string tekConfName = ""; try { //var token = new CancellationToken(); string providerName = ""; string userName = ""; if (providerId.ToLower().Contains("twitter")) { providerName = "twitter"; userName = providerId.ToLower().Replace("twitter:", ""); } else if (providerId.ToLower().Contains("facebook")) { providerName = "facebook"; userName = providerId.ToLower().Replace("facebook:", ""); } else if (providerId.ToLower().Contains("google")) { providerName = "google"; userName = providerId.ToLower().Replace("google:", ""); } var uri = string.Format(TekConfWeb.BaseUrl + "/account/IsOAuthUserRegistered?providerName={0}&userId={1}", providerName, userName); var json = await _httpClient.GetStringAsync(uri); var tekConfUser = await TaskEx.Run(() => _jsonConverter.DeserializeObject <TekConfUser>(json)); tekConfName = tekConfUser.UserName; } catch (Exception exception) { } return(tekConfName); }
public async Task <TResult> MakeApiCall <TResult>(string url, HttpMethod method, object data = null, bool NeedAuth = false) where TResult : class { //url = url.Replace("http://", "https://"); using (var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = method }) { // add content if (method != HttpMethod.Get) { var json = _jsonConverter.SerializeObject(data); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); } HttpClient.DefaultRequestHeaders .Accept .Add(new MediaTypeWithQualityHeaderValue("application/json")); if (NeedAuth && TokenResponseModel != null) { HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", TokenResponseModel.Token); } HttpResponseMessage response = new HttpResponseMessage(); try { response = await HttpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead).ConfigureAwait(false); } catch (WebException ex) { IsConnected = false; _mvxLog.ErrorException($"MakeApiCall failed ", ex); } catch (Exception e) { IsConnected = e.InnerException == null || !(e.InnerException is WebException); _mvxLog.ErrorException("MakeApiCall failed ", e); } var stringSerialized = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // deserialize content var result = _jsonConverter.DeserializeObject <TResult>(stringSerialized); return(result); } }
public async Task <TResult> MakeApiCall <TResult>(string requestUri, HttpMethod method, object data = null) where TResult : class { using (var httpClient = new HttpClient()) { var request = new HttpRequestMessage { RequestUri = new Uri(requestUri), Method = method, }; // add content if (method != HttpMethod.Get) { var json = _jsonConverter.SerializeObject(data); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); } var response = new HttpResponseMessage(); try { response = await httpClient.SendAsync(request).ConfigureAwait(false); } catch (Exception ex) { _mvxLog.ErrorException("MakeApiCall failed", ex); } response.EnsureSuccessStatusCode(); if (response.Content != null) { var stringSerialized = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // deserialize content return(_jsonConverter.DeserializeObject <TResult>(stringSerialized)); } return(null); } }
private async Task <List <Session> > GetSessionsAsync(bool forceRefresh = false) { if (forceRefresh || (DateTime.UtcNow - Settings.LastSyncTime).TotalMinutes >= SessionRefreshAfterMinutes || !_fileStore.Exists(SessionsFileName)) { await DownloadSessionsAsync(); } var sessionData = _fileStore.OpenRead(SessionsFileName); var sessions = _jsonConverter.DeserializeObject <Session[]>(sessionData); #if DEBUG foreach (var session in sessions) { var num = (session.id % 11) + 1; session.sessionStartDate = GetRandomSessionTime(num); session.sessionTime = session.sessionStartDate.ToString("hh:mm tt dddd"); session.startTime = num.ToString(); } #endif return(new List <Session>(sessions)); }
public async Task ModernHttpClientTask() { // based on star wars example await Task.Delay(10); //var result = await _navigationService.Navigate<TrackAddViewModel, Track>(); //var strTrackName = result.Name; Message = "Modern Http Client : "; var response = await _baseHttpSvc.PostAsync(_strUrl, _request).ConfigureAwait(false); if (null != response) { string strReponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false); Message += response.StatusCode.ToString(); Message += " " + strReponse; // convert to object var userResponse0 = JsonConvert.DeserializeObject <UserResponse>(strReponse); var userResponse1 = _mvxJsonConverter.DeserializeObject(typeof(UserResponse), strReponse); } }
private static void RestoreViewModelsFromBundle(IMvxJsonConverter serializer, Bundle savedInstanceState) { IMvxSavedStateConverter savedStateConverter; IMvxMultipleViewModelCache viewModelCache; IMvxViewModelLoader viewModelLoader; if (!Mvx.TryResolve(out savedStateConverter)) { Mvx.Trace("Could not resolve IMvxSavedStateConverter, won't be able to convert saved state"); return; } if (!Mvx.TryResolve(out viewModelCache)) { Mvx.Trace("Could not resolve IMvxMultipleViewModelCache, won't be able to convert saved state"); return; } if (!Mvx.TryResolve(out viewModelLoader)) { Mvx.Trace("Could not resolve IMvxViewModelLoader, won't be able to load ViewModel for caching"); return; } // Harder ressurection, just in case we were killed to death. var json = savedInstanceState.GetString(SavedFragmentTypesKey); if (string.IsNullOrEmpty(json)) return; var savedState = serializer.DeserializeObject<Dictionary<string, Type>>(json); foreach (var item in savedState) { var bundle = savedInstanceState.GetBundle(item.Key); if (bundle.IsEmpty) continue; var mvxBundle = savedStateConverter.Read(bundle); var request = MvxViewModelRequest.GetDefaultRequest(item.Value); // repopulate the ViewModel with the SavedState and cache it. var vm = viewModelLoader.LoadViewModel(request, mvxBundle); viewModelCache.Cache(vm, item.Key); } }
private T Deserialize <T>(string responseBody) { var toReturn = _jsonConverter.DeserializeObject <T>(responseBody); return(toReturn); }
public static T FromJson <T>(this string json, IMvxJsonConverter jsonConverter) where T : class { return(jsonConverter.DeserializeObject <T>(json)); }
public async Task <ServiceResult <TResult> > MakeApiCall <TResult>(string url, HttpMethod method, object data = null, string accessToken = "") where TResult : class { var serviceResult = new ServiceResult <TResult>(); if (CrossConnectivity.Current.IsConnected) { //url = url.Replace("http://", "https://"); using (var httpClient = new HttpClient(new NativeMessageHandler { UseCookies = false })) { httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); using (var request = new HttpRequestMessage { RequestUri = new Uri(url), Method = method }) { // add content if (method != HttpMethod.Get) { //if (data is ByteArrayContent) //{ // using (var multipartFormDataContent = new MultipartFormDataContent()) // { // multipartFormDataContent.Add(data as ByteArrayContent, "file", "file.data"); // request.Content = multipartFormDataContent; // } //} //else if (data is ByteArrayContent) { request.Content = data as ByteArrayContent; } else { var json = _jsonConverter.SerializeObject(data); var stringContent = new StringContent(json, Encoding.UTF8, "application/json"); request.Content = stringContent; } } HttpResponseMessage response = new HttpResponseMessage(); try { response = await httpClient.SendAsync(request).ConfigureAwait(false); } catch (Exception ex) { serviceResult.Success = false; serviceResult.Error.Description = ex.Message; serviceResult.Error.Code = ErrorStatusCode.Empty; } var stringSerialized = await response.Content.ReadAsStringAsync().ConfigureAwait(false); if (response.IsSuccessStatusCode) { try { var resultObject = _jsonConverter.DeserializeObject <TResult>(stringSerialized); serviceResult.Success = true; serviceResult.Result = resultObject; } catch (Exception ex) { serviceResult.Success = false; serviceResult.Error.Description = ex.Message; serviceResult.Error.Code = Enums.ErrorStatusCode.Empty; } } else { serviceResult.Success = false; serviceResult.Error.Description = stringSerialized; serviceResult.Error.Code = (ErrorStatusCode)response.StatusCode; } } } } else { serviceResult.Success = false; serviceResult.Error.Description = "Check internet connection."; } return(serviceResult); }