public Profile GetProfile()
{
lock (locker)
{
var profile = barrel.Get <Profile>("profile");
profile ??= new Profile
{
Fruit = (int)Model.Fruit.Apple,
Status = "😍",
Name = string.Empty,
FriendCode = string.Empty,
IslandName = string.Empty,
GateClosesAtUTC = DateTime.UtcNow,
DodoCode = string.Empty,
GateStatus = (int)Model.GateStatus.Closed,
GatesOpenLength = .5,
TimeZone = string.Empty
};
//if(profile.GateStatus != (int)GateStatus.Closed && profile.GateClosesAtUTC < DateTime.UtcNow)
//{
// profile.GateStatus = (int)GateStatus.Closed;
// profile.DodoCode = string.Empty;
// profile.GatesOpenLength = .5;
//}
return(profile);
}
}
public async Task <Edition> GetEditionAsync(string id, bool forceRefresh = false)
{
var editionFile = $"{id}.json";
var edition = _barrel.Get <Edition>(key: editionFile);
if (await CachedEditionUpToDate(edition) && !forceRefresh)
{
return(edition);
}
if (_connectivity.NetworkAccess != NetworkAccess.Internet)
{
return(edition);
}
try
{
var editionResponse = await _httpClient.GetStringAsync(editionFile);
edition = JsonConvert.DeserializeObject <Edition>(editionResponse);
_barrel.Add(key: editionFile, data: edition, expireIn: TimeSpan.FromDays(999));
return(edition);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(GetEditionsAsync));
return(edition);
}
}
public async Task <Edition> GetEditionAsync(string id, bool forceRefresh = false)
{
var editionFile = $"{id}.json";
var edition = _barrel.Get <Edition>(key: editionFile);
var cacheInvalid = !await CachedEditionUpToDate(edition);
if ((cacheInvalid || forceRefresh) &&
_connectivity.NetworkAccess == NetworkAccess.Internet)
{
try
{
// get from the interwebs
var editionResponse = await _httpClient.GetStringAsync(editionFile);
edition = JsonConvert.DeserializeObject <Edition>(editionResponse);
_barrel.Add(key: editionFile, data: edition, expireIn: TimeSpan.FromDays(999));
//return edition;
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(GetEditionsAsync));
//return edition;
}
}
CheckEditionForSavedArticles(edition);
return(edition);
}
public static Profile GetProfile()
{
lock (locker)
{
var profile = barrel.Get <Profile>("profile");
return(profile ?? new Profile());
}
}
public static Person GetPerson()
{
lock (_locker)
{
var person = _barrel.Get <Person>("person");
return(person ?? new Person());
}
}
public void GetStringTest()
{
//Saves the cache and pass it a timespan for expiration
barrel.Add(key: url, data: json, expireIn: TimeSpan.FromDays(1));
var cached = barrel.Get <string>(url);
Assert.IsNotNull(cached);
}
public async Task <IEnumerable <PlayerDTO> > GetPlayers(string team)
{
var key = $"{this.ToString()}/{nameof(GetPlayers)}/{team}";
if (!_barrel.IsExpired(key: key))
{
return(_barrel.Get <IEnumerable <PlayerDTO> >(key: key));
}
var data = await _playersService.GetPlayers(team);
AddToCache(_barrel, key, data);
return(data);
}
public Profile GetProfile()
{
lock (locker)
{
var profile = barrel.Get <Profile>("profile");
return(profile ?? new Profile
{
Fruit = (int)Model.Fruit.Apple,
Status = "😍",
Name = string.Empty,
FriendCode = string.Empty,
IslandName = string.Empty,
TimeZone = string.Empty
});
}
}
public ObservableCollection <T> GetMonkey <T>(string nameMonkey) where T : Entity
{
if (file.Exists(nameMonkey))
{
var enumerableMonkey = file.Get <ObservableCollection <T> >(nameMonkey);
return(enumerableMonkey);
}
return(null);
}
public static T Get <T>(this IBarrel source, string key, T defaultValue)
{
if (string.IsNullOrWhiteSpace(key) || !source.Exists(key))
{
return(defaultValue);
}
return(source.Get <T>(key));
}
public Task <IList <IPlaylist> > GetPlaylists()
{
var playlists = _barrel.Get <IList <IPlaylist> >("playlists");
if (playlists == null)
{
playlists = new List <IPlaylist>();
}
return(Task.FromResult(playlists));
}
/// <summary>
/// WebAPIから県別のデータを取得する.
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <Prefecture> > GetPrefectures()
{
try
{
//キャッシュが存在して,有効期間内の場合はキャッシュから
if (!_barrel.IsExpired(key: CachePrefecturesKey))
{
await Task.Yield();
return(_barrel.Get <IEnumerable <Prefecture> >(key: CachePrefecturesKey));
}
//インターネットに接続してれば取得
if (Connectivity.NetworkAccess == NetworkAccess.Internet)
{
//WebAPIからデータ取得
var prefecturesData = await _httpClient.GetFromJsonAsync <IEnumerable <Prefecture> >("prefectures");
//キャッシュを更新.キャッシュの有効期限を設定
_barrel.Add(key: CachePrefecturesKey, data: prefecturesData, expireIn: TimeSpan.FromMinutes(10));
return(prefecturesData);
}
//インターネットにも接続してないし,キャッシュも有効期限切れだった場合
//それでも有効期限切れのキャッシュデータを返すか.
if (_barrel.Exists(key: CachePrefecturesKey))
{
//とりあえず返すことにした.
return(_barrel.Get <IEnumerable <Prefecture> >(key: CachePrefecturesKey));
}
return(new List <Prefecture>());
}
catch
{
throw;
}
}
/// <summary>
/// Find element in file store
/// </summary>
/// <typeparam name="T">type element savind in file store</typeparam>
/// <param name="nameMonkey">name with the save element in file store</param>
/// <returns></returns>
public ConfigurationItem <T> GetMonkey <T>(string nameMonkey)
{
if (file.Exists(nameMonkey))
{
return(new ConfigurationItem <T>()
{
IsExpired = file.IsExpired(nameMonkey),
Item = file.Get <T>(nameMonkey)
});
}
return(null);
}
private async Task <string> GetJsonAsync(string resource, Xamarin.Essentials.NetworkAccess networkAccess, int cacheDuration = 24)
{
var cleanCacheKey = resource.CleanCacheKey();
//Try Get data from Cache
var cachedData = _cacheBarrel.Get <string>(cleanCacheKey);
if (cacheDuration > 0 && cachedData != null)
{
//If the cached data is still valid
if (!_cacheBarrel.IsExpired(cleanCacheKey))
{
return(cachedData);
}
}
//Check for internet connection and return cached data if possible
if (networkAccess != NetworkAccess.Internet)
{
if (cachedData != null)
{
return(cachedData);
}
else
{
throw new InternetConnectionException();
}
}
//No Cache Found, or Cached data was not required, or Internet connection is also available
//Extract response from URI
var response = await _httpClient.GetAsync(new Uri(_httpClient.BaseAddress, resource));
response.EnsureSuccessStatusCode();
//Read Response
string json = await response.Content.ReadAsStringAsync();
//Save to Cache if required
if (cacheDuration > 0)
{
try
{
_cacheBarrel.Add(cleanCacheKey, json, TimeSpan.FromHours(cacheDuration));
}
catch { }
}
//Return the result
return(json);
}
public static T GetOrCreate <T>(this IBarrel barrel, string key, T defaultValue, TimeSpan timeSpan = default)
{
if (string.IsNullOrWhiteSpace(key) || !barrel.Exists(key))
{
if (timeSpan == default)
{
timeSpan = TimeSpan.MaxValue;
}
barrel.Add(key, defaultValue, timeSpan);
return(defaultValue);
}
return(barrel.Get <T>(key));
}
public async Task <Edition> GetEditionAsync(string id, bool forceRefresh = false)
{
//_logger.Log(LogLevel.Information, $"Getting Edition {id}");
var editionFile = $"{id}.json";
var edition = _barrel.Get <Edition>(key: editionFile);
var cacheInvalid = !await CachedEditionUpToDate(edition);
if ((cacheInvalid || forceRefresh) &&
_connectivity.NetworkAccess == NetworkAccess.Internet)
{
try
{
//_logger.Log(LogLevel.Information, $" Getting {id} from the web");
// get from the interwebs
var editionResponse = await _httpClient.GetStringAsync(editionFile);
edition = JsonConvert.DeserializeObject <Edition>(editionResponse);
_barrel.Add(key: editionFile, data: edition, expireIn: TimeSpan.FromDays(999));
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(GetEditionsAsync));
_analytics.TrackError(ex, new Dictionary <string, string> {
{ Constants.Analytics.Properties.FileName, editionFile }
});
}
}
if (edition != null) // smelly??!?!
{
CheckEditionForSavedArticles(edition);
}
return(edition);
}
public Task <IEnumerable <IPlaylist> > GetAll()
{
try
{
if (!_barrel.Exists("playlists"))
{
_barrel.Add <IEnumerable <IPlaylist> >("playlists", new List <IPlaylist>(), TimeSpan.MaxValue);
}
var items = _barrel.Get <IEnumerable <IPlaylist> >("playlists");
return(Task.FromResult(items));
}
catch
{ }
return(Task.FromResult <IEnumerable <IPlaylist> >(null));
}
public override User GetUser(string userPid)
{
User user = null;
if (!_barrel.IsExpired(userPid))
{
user = _barrel.Get <User>(userPid);
}
else
{
user = base.GetUser(userPid);
_barrel.Add(userPid, user, TimeSpan.FromDays(_expiryLengthDays));
}
return(user);
}
public CommentEntity GetCached(string videoId)
{
var commentDbId = videoId + "_c";
return(_barrel.Get <CommentEntity>(commentDbId));
}
/// <summary>
/// Send a cached requests
/// </summary>
/// <param name="http">Http client ot use</param>
/// <param name="barrel">Barrel to use for cache</param>
/// <param name="req">request to send</param>
/// <param name="expireIn">expire in</param>
/// <param name="forceUpdate">If we should force the update or not</param>
/// <param name="throttled">If throttled or not</param>
/// <returns>The new or cached response.</returns>
public static async Task <string> SendCachedAsync(this HttpClient http, IBarrel barrel, HttpRequestMessage req, TimeSpan expireIn, bool forceUpdate = false, bool throttled = true)
{
var url = req.RequestUri.ToString();
var contents = barrel.Get <string>(url);
var eTag = barrel.GetETag(url);
if (!forceUpdate && !string.IsNullOrEmpty(contents) && !barrel.IsExpired(url))
{
return(contents);
}
var etag = eTag ?? null;
if (throttled)
{
await getThrottle.WaitAsync();
}
HttpResponseMessage r;
string c = null;
try {
if (!forceUpdate && !string.IsNullOrEmpty(etag) && !string.IsNullOrEmpty(contents))
{
req.Headers.IfNoneMatch.Clear();
req.Headers.IfNoneMatch.Add(new EntityTagHeaderValue(etag));
}
r = await http.SendAsync(req);
if (r.StatusCode == HttpStatusCode.NotModified)
{
if (string.IsNullOrEmpty(contents))
{
throw new IndexOutOfRangeException($"Cached value missing for HTTP request: {url}");
}
return(contents);
}
c = await r.Content.ReadAsStringAsync();
} finally {
if (throttled)
{
getThrottle.Release();
}
}
if (r.StatusCode == HttpStatusCode.OK)
{
// Cache it?
var newEtag = r.Headers.ETag != null ? r.Headers.ETag.Tag : null;
if (!string.IsNullOrEmpty(newEtag) && newEtag != etag)
{
barrel.Add(url, c, expireIn, newEtag);
}
return(c);
}
else
{
throw new HttpCacheRequestException(r.StatusCode, "HTTP Cache Request Failed");
}
}
public Task <T> Get <T>(string key, CancellationToken cancellationToken = default)
{
return(Task.FromResult(_barrel.Get <T>(key)));
}
