private void UpdateDay(TodaysWalkingModel today)
{
HourlyBreakdown.Clear();
foreach (var dp in today.todaysWalking)
{
HourlyBreakdown.Add(string.Format(
"Fra {0} til {1}: {2}.\n",
dp.Start.ToShortTimeString(),
dp.Stop.ToShortTimeString(),
dp.WasBrisk ? AppText.brisk_walk : AppText.regular_walk));
}
RaisePropertyChanged(() => HourlyBreakdown);
}
public async Task <bool> CheckIfGoalCompleted(TodaysWalkingModel todaysWalking)
{
if (checkTask == null || checkTask.IsCompleted)
{
try
{
var goal = goals.Find(g => (Goal)g.Id == Settings.CurrentGoal);
var goalResult = new GoalStorageModel
{
Day = DateTime.Today,
Id = goal.Id,
HasBeenReached = false,
MinutesToReach = goal.MinutesToReach
};
// check if goal is complete
if (todaysWalking.minutesBriskWalkToday >= goal.MinutesToReach)
{
var previousToday = await storageService.GetTodaysGoal();
// check if already achieved goal today or if goal has changed to a greater goal
if (previousToday == null || previousToday.MinutesToReach < goal.MinutesToReach)
{
goalResult.HasBeenReached = true;
await storageService.StoreDailyGoalResult(goalResult);
// Return true (new goal achieved today)
Analytics.TrackEvent(GoalAccomplished,
new GoalAccomplishedArgs(Enum.GetName(typeof(Goal),
(Goal)goal.Id)));
return(true);
}
}
} catch (Exception e)
{
Crashes.TrackError(e);
}
}
return(false);
}
public async Task CheckTieredAchievementsProgress(TodaysWalkingModel todaysWalking)
{
if (isUpdating || todaysWalking == null)
{
return;
}
isUpdating = true;
if (updateTask == null || updateTask.IsCompleted)
{
updateTask = Task.Run(async() =>
{
var walkingHistory = await storageService.GetWalkingDays();
var goalHistory = await storageService.GetAllGoalResults();
foreach (var a in tieredAchievements)
{
Tier tier = a.CurrentTier;
if (tier == Tier.Complete)
{
continue;
}
var storedProgress = GetProgressCurrentTier(a);
var relevantWalking = walkingHistory.Where(d => d.Day > storedProgress.TimeProgressAchieved);
var relevantGoals = goalHistory.Where(g => g.Day > storedProgress.TimeProgressAchieved);
switch ((TieredAchievement)a.Id)
{
case TieredAchievement.ReachedGoal:
{
var goals = relevantGoals.Where(g => g.HasBeenReached);
if (goals.Any())
{
AchievementProgress p = new AchievementProgress
{
Progress = goals.Select(g => g.Day).ToList(),
};
await AddAchievementProgress(a, p);
}
}
break;
case TieredAchievement.ThirtyMinutes:
{
var walking = relevantWalking.Where(d => d.MinutesBriskWalking + d.MinutesRegularWalking >= 30);
var subProgress = (int)(todaysWalking.minutesBriskWalkToday +
todaysWalking.minutesRegularWalkToday +
todaysWalking.minutesUnknownWalkToday);
AchievementProgress p = new AchievementProgress
{
Progress = walking.Select(w => w.Day).ToList(),
SubProgress = subProgress,
};
await AddAchievementProgress(a, p);
}
break;
case TieredAchievement.ReachedGoalFiveDaysInARow:
{
var progress = GetNumberOfConsectiveGoalDayGroups(relevantGoals, 5);
await AddAchievementProgress(a, progress);
}
break;
}
await storageService.UpdateTieredAchievement(a);
}
});
await updateTask;
}
isUpdating = false;
}
protected void OnTodaysWalkingUpdated(TodaysWalkingModel todaysWalking)
{
TodaysWalkingUpdated?.Invoke(todaysWalking);
}
public async Task UpdateAllDataServices()
{
Debug.WriteLine($"Updating all data services in mode: {currentUpdateMode}");
try
{
IWalkingDataService walkingDataService = CrossServiceContainer.WalkingDataService;
if (!walkingDataService.GetIsConnectedToOSService())
{
walkingDataService.ConnectToOSService();
return;
}
TodaysWalkingModel todaysWalking = null;
if (walkingDataService != null)
{
await walkingDataService.RequestUpdate();
todaysWalking = walkingDataService.GetTodaysHistory();
}
IGoalService goalService = GoalService.Current;
if (goalService != null && todaysWalking != null)
{
if (await goalService.CheckIfGoalCompleted(todaysWalking))
{
if (!App.IsForeground && Settings.WillSendNotifications)
{
var id = (Config.NotificationIdGoal + (int)Settings.CurrentGoal);
CrossLocalNotifications.Current.Show(AppText.notification_title, AppText.notification_goal_reached, id);
Analytics.TrackEvent(TrackingEvents.BackgroundEvents.NotificationSent);
}
}
}
IAchievementService achievementService = AchievementService.Current;
if (achievementService != null && todaysWalking != null)
{
//await achievementService.CheckAllAchievementsCriteria(todaysWalking);
await achievementService.CheckTieredAchievementsProgress(todaysWalking);
}
var lastWalkingDateEventDate = Settings.LastWalkingDataEventDate;
if (lastWalkingDateEventDate.AddDays(1) < DateTime.Today)
{
IStorageService storageService = StorageService.Current;
if (storageService != null)
{
var days = await storageService.GetWalkingDaysSinceInclusive(lastWalkingDateEventDate.AddDays(1));
var today = DateTime.Today;
var daysToTrack = days.Where(d => Settings.LastWalkingDataEventDate < d.Day && d.Day < today);
foreach (var d in daysToTrack)
{
Analytics.TrackEvent(TrackingEvents.BriskWalking, new TrackingEvents.WalkingDataArgs(d.Day.DayOfWeek, d.MinutesBriskWalking));
Analytics.TrackEvent(TrackingEvents.RegularWalking, new TrackingEvents.WalkingDataArgs(d.Day.DayOfWeek, d.MinutesRegularWalking));
Analytics.TrackEvent(TrackingEvents.WalkingRaw, new TrackingEvents.WalkingRawDataArgs(d.Day.Date, d.MinutesBriskWalking, d.MinutesRegularWalking, d.MinutesUnknownWalking, Settings.UserHeight));
}
//Last date stored is always today - 1
Settings.LastWalkingDataEventDate = today.AddDays(-1);
// log history
var all = await storageService.GetWalkingDaysSinceInclusive(DateTime.MinValue);
Analytics.TrackEvent(TrackingEvents.DailyHistory, new TrackingEvents.WalkingDataArgs(all));
}
}
UpdateCompleted?.Invoke();
}
catch (Exception e)
{
#if DEBUG
Device.BeginInvokeOnMainThread(() => throw e);
#else
Crashes.TrackError(e);
#endif
}
}
