static async Task <Tuple <TResponse, RequestInfo> > DoDelete <TResponse>(
string relativeUrl,
object jsonParams,
OnError errorAction,
bool showWaiting = true)
{
var request = new RequestInfo(relativeUrl)
{
ErrorAction = errorAction,
HttpMethod = "DELETE",
JsonData = jsonParams
};
try
{
if (showWaiting)
{
await Waiting.Show();
}
var result = default(TResponse);
if (await request.Send())
{
result = await request.ExtractResponse <TResponse>();
}
return(Tuple.Create(result, request));
}
finally
{
if (showWaiting)
{
await Waiting.Hide();
}
}
}
static async Task RefreshUponUpdatedResponse <TResponse>(string url, Func <TResponse, Task> refresher)
{
await Task.Delay(50);
string localCachedVersion;
try
{
localCachedVersion = (await GetCacheFile <TResponse>(url).ReadAllTextAsync()).CreateSHA1Hash();
if (localCachedVersion.LacksValue())
{
throw new Exception("Local cached file's hash is empty!");
}
}
catch (Exception ex)
{
Device.Log.Error("Strangely, there is no cache any more when running RefreshUponUpdatedResponse(...).");
Device.Log.Error(ex);
return; // High concurrency perhaps.
}
var request = new RequestInfo(url)
{
ErrorAction = OnError.Throw,
HttpMethod = "GET",
LocalCachedVersion = localCachedVersion
};
try
{
if (!await request.Send())
{
return;
}
if (localCachedVersion.HasValue() && request.ResponseCode == System.Net.HttpStatusCode.NotModified)
{
return;
}
var newResponseCache = request.ResponseText.OrEmpty().CreateSHA1Hash();
if (newResponseCache == localCachedVersion)
{
// Same response. No update needed.
return;
}
var result = await request.ExtractResponse <TResponse>();
if (request.Error == null)
{
await GetCacheFile <TResponse>(url).WriteAllTextAsync(request.ResponseText);
await refresher(result);
}
}
catch (Exception ex) { Device.Log.Error(ex); }
}
async Task <Tuple <TResponse, RequestInfo> > DoDelete <TResponse>(object jsonParams)
{
var request = new RequestInfo(this)
{
HttpMethod = "DELETE",
JsonData = jsonParams
};
var result = default(TResponse);
if (await request.Send())
{
result = request.ExtractResponse <TResponse>();
}
return(Tuple.Create(result, request));
}
async Task <TResponse> ExecuteGet <TResponse>()
{
var result = default(TResponse);
if (CachePolicy == CachePolicy.CacheOrFreshOrFail)
{
result = await GetCachedResponse <TResponse>();
if (HasValue(result))
{
Log.For(this).Debug("ExecuteGet: Returning from Cache: " + result);
return(result);
}
}
var request = new RequestInfo(this)
{
HttpMethod = "GET"
};
if (await request.Send())
{
result = request.ExtractResponse <TResponse>();
if (request.Error == null)
{
await GetCacheFile <TResponse>().WriteAllTextAsync(request.ResponseText);
}
}
if (request.Error != null)
{
if (CachePolicy == CachePolicy.FreshOrFail)
{
throw request.Error;
}
result = await GetCachedResponse <TResponse>();
if (result == null) // No cache available
{
throw request.Error;
}
}
return(result);
}
public async Task <TResponse> Get <TResponse>(object queryParams = null)
{
Url = GetFullUrl(queryParams);
var result = default(TResponse);
if (CachePolicy == CachePolicy.CacheOrFreshOrFail)
{
result = await GetCachedResponse <TResponse>();
if (HasValue(result))
{
return(result);
}
}
var request = new RequestInfo(this)
{
HttpMethod = "GET"
};
if (await request.Send())
{
result = request.ExtractResponse <TResponse>();
if (request.Error == null)
{
await GetCacheFile <TResponse>().WriteAllTextAsync(request.ResponseText);
}
}
if (request.Error != null)
{
if (CachePolicy != CachePolicy.FreshOrFail)
{
result = await GetCachedResponse <TResponse>();
if (result == null) // No cache available
{
throw request.Error;
}
}
}
return(result);
}
async Task <Tuple <TResponse, RequestInfo> > DoPost <TResponse>(string requestData, object jsonParams)
{
var request = new RequestInfo(this)
{
HttpMethod = "POST",
RequestData = requestData,
JsonData = jsonParams
};
var result = default(TResponse);
if (await request.Send())
{
result = request.ExtractResponse <TResponse>();
}
return(Tuple.Create(result, request));
}
async Task <Tuple <TResponse, RequestInfo> > DoDelete <TResponse, TEntity, TIdentifier>(
TEntity entity, object jsonParams) where TEntity : IQueueable <TIdentifier>
{
var request = new RequestInfo(this)
{
HttpMethod = "DELETE",
JsonData = jsonParams
};
var result = default(TResponse);
if (await request.Send <TEntity, TIdentifier>(entity))
{
result = request.ExtractResponse <TResponse>();
}
return(Tuple.Create(result, request));
}
static async Task <Tuple <TResponse, RequestInfo> > DoPut <TResponse, TEntity, TIdentifier>(
TEntity entity,
string relativeUrl,
string requestData,
object jsonParams,
OnError errorAction,
bool showWaiting) where TEntity : IQueueable <TIdentifier>
{
var request = new RequestInfo(relativeUrl)
{
ErrorAction = errorAction,
HttpMethod = "PUT",
RequestData = requestData,
JsonData = jsonParams
};
try
{
if (showWaiting)
{
await Waiting.Show();
}
var result = default(TResponse);
if (await request.Send <TEntity, TIdentifier>(entity))
{
result = await request.ExtractResponse <TResponse>();
}
return(Tuple.Create(result, request));
}
finally
{
if (showWaiting)
{
await Waiting.Hide();
}
}
}
public static async Task <TResponse> Get <TResponse>(string relativeUrl, object queryParams = null, OnError errorAction = OnError.Toast, ApiResponseCache cacheChoice = ApiResponseCache.Accept, Func <TResponse, Task> refresher = null)
{
if (refresher != null && cacheChoice != ApiResponseCache.PreferThenUpdate)
{
throw new ArgumentException("refresher can only be provided when using ApiResponseCache.PreferThenUpdate.");
}
if (refresher == null && cacheChoice == ApiResponseCache.PreferThenUpdate)
{
throw new ArgumentException("When using ApiResponseCache.PreferThenUpdate, refresher must be specified.");
}
relativeUrl = GetFullUrl(relativeUrl, queryParams);
var result = default(TResponse);
if (cacheChoice == ApiResponseCache.Prefer || cacheChoice == ApiResponseCache.PreferThenUpdate || cacheChoice == ApiResponseCache.CacheOrNull)
{
result = GetCachedResponse <TResponse>(relativeUrl);
if (HasValue(result))
{
if (cacheChoice == ApiResponseCache.PreferThenUpdate)
{
Thread.Pool.RunOnNewThread(() => RefreshUponUpdatedResponse(relativeUrl, refresher));
}
return(result);
}
if (cacheChoice == ApiResponseCache.CacheOrNull)
{
return(result);
}
}
var request = new RequestInfo(relativeUrl)
{
ErrorAction = errorAction, HttpMethod = "GET"
};
if (await request.Send())
{
result = await request.ExtractResponse <TResponse>();
if (request.Error == null)
{
await GetCacheFile <TResponse>(relativeUrl).WriteAllTextAsync(request.ResponseText);
}
}
if (request.Error != null && cacheChoice != ApiResponseCache.Refuse)
{
result = GetCachedResponse <TResponse>(relativeUrl);
if (cacheChoice == ApiResponseCache.AcceptButWarn)
{
await Alert.Toast(StaleDataWarning);
}
}
return(result);
}
