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