private async Task <IEnumerable <SessionGroup> > Load()
{
Username = await CardboardKnight.Username();
var plays = await CardboardKnight.RetrievePlays();
if (!plays.Any())
{
plays = await CardboardKnight.FetchPlays();
}
var user = await CardboardKnight.Username();
foreach (var p in plays)
{
p.User = user;
}
var results = plays
.GroupBy(p => p.Date, p => p, (key, g) => new SessionGroup(g.ToList())
{
Date = key
})
.OrderByDescending(i => i.Date);
Sessions = new ObservableCollection <SessionGroup>(results);
return(Sessions);
}
public async Task <List <Game> > Load()
{
var results = await CardboardKnight.FetchHotness().ConfigureAwait(false);
Hotness = new MvxObservableCollection <Game>(results);
await Load(false).ConfigureAwait(false);
return(Hotness.ToList());
}
private async Task Load(Play p)
{
if (p.Game == null)
{
p.Game = await CardboardKnight.RetrieveGame(p.GameId);
Play = p;
}
}
private async Task OnLogoutConfirm(WarningPopupMessage message)
{
_messenger.Unsubscribe <WarningPopupMessage>(_token);
if (message.Confirmed)
{
await CardboardKnight.Logout();
await _navigationService.Navigate <LoginViewModel>();
}
}
private async Task OnRatingMessage(RatingResultMessage message)
{
_messenger.Unsubscribe <RatingResultMessage>(_token);
if (message.Success)
{
await CardboardKnight.RateGameForUser(Game, message.Value, message.Review);
Game.UserRating = message.Value;
await UpdateGame(Game);
}
}
public async Task AddGame()
{
if (Game == null)
{
return;
}
bool success = Game.InCollection ? await CardboardKnight.RemoveGameFromUser(Game) : await CardboardKnight.AddGameToUser(Game);
if (success)
{
await CardboardKnight.StoreGame((Game)Game);
}
}
private async Task AttemptLogin()
{
await Task.Delay(1000);
Success = await CardboardKnight.Login(Username, Password);
if (Success)
{
await _navigationService.Navigate <RootViewModel>(); //This feels *very* wrong. Find documentation on modal dialogs for MvvmCross.
}
else
{
throw new InvalidOperationException();
}
}
private async Task Appearing()
{
string username;
username = await CardboardKnight.Username();
if (string.IsNullOrEmpty(username)) // if no user name, launch the login experience
{
await _navigationService.Navigate <LoginViewModel>();
}
else
{
await _navigationService.Navigate <MenuViewModel>();
await _navigationService.Navigate <HomeViewModel>();
}
}
private async Task Load(bool forced)
{
try
{
IList <Game> games = new List <Game>();
if (forced)
{
IsBusy = true;
var results = await CardboardKnight.GetTop100().ConfigureAwait(false);
foreach (var g in results)
{
games.Add(await CardboardKnight.StoreGame(g).ConfigureAwait(false));
}
}
else
{
var r = await CardboardKnight.RetrieveGames();
var g = r.FirstOrDefault();
//This is a *really* ugly query
games = r.Where(g => g.Ranks.Any(rank => rank.Category == Category.All && rank.Position >= 1 && rank.Position <= 100))
.OrderBy(g => g.Ranks.FirstOrDefault(rank => rank.Category == Category.All).Position)
.ToList();
if (games.Count < 100)
{
await Load(true);
return;
}
}
Top100 = new MvxObservableCollection <Game>(games);
}
catch (Exception ex)
{
//TODO: some sort of logging
}
finally
{
IsBusy = false;
}
}
public async Task Load(int id)
{
Fetched = true;
var existing = await CardboardKnight.RetrieveGame(id);
if (existing != null && !string.IsNullOrEmpty(existing.Description)) //assumption is if the description is added, the game has been completely downloaded via the games page.
{
Game = existing;
}
else
{
var g = await CardboardKnight.FetchGame(id);
Game = await CardboardKnight.StoreGame((Game)g);
}
await SetupVideos();
}
private async Task SetupVideos()
{
Videos = new VideosViewModel(Game);
var results = await CardboardKnight.GetVideos(Game.Id);
//var results = await CardboardKnight.VideosDb.GetVideoByGame(Game.Id).ConfigureAwait(false);
var videos = new ObservableCollection <Video>(results);
foreach (var v in results)
{
if (v.UserId == "247565")//watch it played
{
Game.HasRodney = true;
RodneyVideo = v.Link;
}
}
Videos.Videos = videos;
}
private async Task <List <Game> > Load(bool forced)
{
List <Game> games = new List <Game>();
try
{
if (forced)
{
var results = await CardboardKnight.GetTop100(category : Category);
foreach (var g in results)
{
games.Add(await CardboardKnight.StoreGame((Game)g));
}
}
else
{
// This now has issues with multiple-top - 100 lists, and wouldn't allow for paging.
// For now, just fetch the list every time, no caching.
//var r = await CardboardKnight.RetrieveGames();
//games = r
// .Where(g => g.Rank >= 1 && g.Rank <= 100)
// .OrderBy(g => g.Rank)
// .ToList();
//if (games.Count < 100)
//{
return(await Load(true));
//}
}
Games = new ObservableCollection <Game>(games);
}
catch (Exception ex)
{
//Debug.WriteLine(ex);
}
return(games);
}
public async Task ForceUpdate()
{
var g = await CardboardKnight.FetchGame(Game.Id);
Game = await CardboardKnight.StoreGame(g);
}
private async Task UpdateGame(Game g)
{
Game = await CardboardKnight.StoreGame((Game)g);
}
private async Task <List <Game> > Search(string t)
{
Games = new ObservableCollection <Game>(await CardboardKnight.Search(t));
return(Games.ToList());
}
