public SkaterTargetAnalysis Analyse(ApplicationUser skater, List <SkateLogEntry> allSessions)
{
var orderedLog = allSessions.Where(x => x.ApplicationUserId.Equals(skater.Id, System.StringComparison.CurrentCultureIgnoreCase)).OrderBy(x => x.Logged);
var totalMiles = 0M;
var totalSessions = 0;
var checkPoints = checkPointRepository.Get().Where(x => !x.SkateTarget.Equals(SkateTarget.None)).ToList();
var statistics = new SkaterTargetAnalysis
{
Skater = skater,
CheckPointDates = new Dictionary <SkateTarget, DateTime>()
};
foreach (var session in orderedLog)
{
totalSessions++;
totalMiles += session.DistanceInMiles;
foreach (var checkPoint in checkPoints)
{
if (totalMiles >= checkPoint.Distance && !statistics.CheckPointDates.ContainsKey(checkPoint.SkateTarget))
{
statistics.CheckPointDates.Add(checkPoint.SkateTarget, session.Logged);
}
}
}
statistics.TotalMiles = totalMiles;
statistics.TotalSessions = totalSessions;
return(statistics);
}
public async Task Process(SaveActivityCommand request, CancellationToken cancellationToken)
{
try
{
if (request.Skater.Target.Equals(SkateTarget.ThereAndBackAgain))
{
// No need to update the user's target.
return;
}
var userMiles = await context.SkateLogEntries.Where(x => x.ApplicationUserId.Equals(request.Skater.Id)).SumAsync(x => x.DistanceInMiles, cancellationToken);
var targetCheckPoint = checkPointRepository.Get().First(x => x.SkateTarget.Equals(request.Skater.Target));
if (userMiles > targetCheckPoint.Distance)
{
request.Skater.Target = GetNewTarget(request.Skater.Target);
await userManager.UpdateAsync(request.Skater);
}
}
catch (Exception exception)
{
logger.LogError(exception, "Failed to update the user's personal target.");
}
}
private IEnumerable <CheckPointStatisticsModel> GetCheckPointStatistics(List <SkaterTargetAnalysis> skaterAnalyses)
{
var checkPoints = checkPointRepository.Get().Where(x => !x.SkateTarget.Equals(SkateTarget.None)).ToList();
foreach (var checkPoint in checkPoints)
{
var firstSkater = skaterAnalyses.Where(x => x.CheckPointDates.ContainsKey(checkPoint.SkateTarget))
.OrderBy(x => x.GetMileStoneDate(checkPoint.SkateTarget))
.Select(x => x.Skater)
.FirstOrDefault();
var lastSkater = skaterAnalyses.Where(x => x.CheckPointDates.ContainsKey(checkPoint.SkateTarget))
.OrderByDescending(x => x.GetMileStoneDate(checkPoint.SkateTarget))
.Select(x => x.Skater)
.FirstOrDefault();
yield return(new CheckPointStatisticsModel
{
Target = checkPoint.SkateTarget,
CheckPointName = checkPoint.Title,
FirstSkaterName = firstSkater?.GetDisplaySkaterName(),
FirstSkaterProfile = firstSkater != null?GetProfileImage(firstSkater) : null,
LatestSkaterName = lastSkater?.GetDisplaySkaterName(),
LatestSkaterProfile = lastSkater != null?GetProfileImage(lastSkater) : null
});
}
}
public async Task <Unit> Handle(SendRegistrationEmailCommand request, CancellationToken cancellationToken)
{
try
{
var startPoint = checkPointRepository.Get().OrderBy(x => x.Distance).FirstOrDefault();
var emailModel = new RegistrationEmailModel
{
LogoUrl = absoluteUrlHelper.Get("/images/AllInSkateChallengeBannerSmall.png"),
EmailConfirmationUrl = request.EmailConfirmationUrl,
SiteUrl = absoluteUrlHelper.Get("/"),
LogMilesUrl = absoluteUrlHelper.Get("/skater/skate-log"),
SponsorLogoUrl = absoluteUrlHelper.Get("/images/SkateEverywhereLogo.png"),
StartingPostCard = absoluteUrlHelper.Get(startPoint?.Image),
FromSkateEverywhere = request.FromSkateEverywhere
};
var emailBody = await viewToStringRenderer.RenderPartialToStringAsync("~/Views/Email/RegistrationEmail.cshtml", emailModel);
await emailSender.SendEmailAsync(request.Email, "ALL IN Skate Challenge Registration", emailBody);
}
catch (Exception exception)
{
logger.LogError(exception, "Failed to progress updates when saving mileage entries", request);
}
return(Unit.Value);
}
public async Task Process(SaveActivityCommand request, SaveActivityCommandResult response, CancellationToken cancellationToken)
{
if (!response.WasSuccessful || !request.Skater.AcceptProgressNotifications || !request.Skater.EmailConfirmed)
{
return;
}
try
{
var milesThisSkate = request.Distance;
switch (request.DistanceUnit)
{
case DistanceUnit.Kilometres:
milesThisSkate = milesThisSkate * 0.621371M;
break;
case DistanceUnit.Metres:
milesThisSkate = milesThisSkate * 0.000621371M;
break;
}
var totalMiles = context.SkateLogEntries.Where(x => x.ApplicationUserId.Equals(request.Skater.Id)).Sum(x => x.DistanceInMiles);
var previousMiles = totalMiles - milesThisSkate;
var checkPoints = checkPointRepository.Get().Where(x => x.SkateTarget <= request.Skater.Target).ToList();
var targetCheckPoint = checkPoints.Last();
var checkPointsReached = checkPoints.Where(x => x.Distance >= previousMiles && x.Distance <= totalMiles).OrderByDescending(x => x.Distance).ToList();
foreach (var checkPointReached in checkPointsReached)
{
var isFinalCheckpoint = checkPointReached.SkateTarget.Equals(request.Skater.Target);
var emailModel = new SkaterProgressEmailViewModel
{
LogoUrl = absoluteUrlHelper.Get("/images/AllInSkateChallengeBannerSmall.png"),
SponsorLogoUrl = absoluteUrlHelper.Get("/images/SkateEverywhereLogo.png"),
Skater = request.Skater,
CheckPoint = checkPointReached,
TotalMiles = totalMiles,
NextCheckPoint = checkPoints.Where(x => x.Distance > totalMiles).OrderBy(x => x.Distance).FirstOrDefault(),
TargetCheckPoint = targetCheckPoint
};
var emailTemplate = isFinalCheckpoint ? "~/Views/Email/ChallengeCompleteEmail.cshtml" : "~/Views/Email/SkaterProgressEmail.cshtml";
var emailBody = await viewToStringRenderer.RenderPartialToStringAsync(emailTemplate, emailModel);
await emailSender.SendEmailAsync(request.Skater.Email, "ALL IN Skate Challenge - Your Progress", emailBody);
}
}
catch (Exception exception)
{
logger.LogError(exception, "Failed to progress updates when saving mileage entries", request);
}
}
public async Task <Unit> Handle(ResendRegistrationEmailCommand request, CancellationToken cancellationToken)
{
try
{
var user = await userManager.FindByIdAsync(request.UserId);
if (user == null)
{
throw new EntityNotFoundException(typeof(ApplicationUser), Guid.Parse(request.UserId));
}
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = $"/Identity/Account/ConfirmEmail/?userId={request.UserId}&code={code}&returnUrl=%2F";
callbackUrl = absoluteUrlHelper.Get(callbackUrl);
var startPoint = checkPointRepository.Get().OrderBy(x => x.Distance).FirstOrDefault();
var emailModel = new RegistrationEmailModel
{
LogoUrl = absoluteUrlHelper.Get("/images/AllInSkateChallengeBannerSmall.png"),
EmailConfirmationUrl = callbackUrl,
SiteUrl = absoluteUrlHelper.Get("/"),
LogMilesUrl = absoluteUrlHelper.Get("/skater/skate-log"),
SponsorLogoUrl = absoluteUrlHelper.Get("/images/SkateEverywhereLogo.png"),
StartingPostCard = absoluteUrlHelper.Get(startPoint?.Image),
FromSkateEverywhere = false
};
var emailBody = await viewToStringRenderer.RenderPartialToStringAsync("~/Views/Email/RegistrationEmail.cshtml", emailModel);
await emailSender.SendEmailAsync(user.Email, "ALL IN Skate Challenge Registration", emailBody);
}
catch (Exception exception)
{
logger.LogError(exception, "Failed to progress updates when saving mileage entries", request);
}
return(Unit.Value);
}
public override async Task <PageViewModel <SkaterProgressViewModel> > Build()
{
var command = new SkaterLogQuery {
Skater = User
};
var commandResponse = await mediator.Send(command);
var mileageEntries = commandResponse.Entries ?? new List <SkateLogEntry>();
var analysis = skaterTargetAnalyser.Analyse(this.User, mileageEntries);
var totalDistance = mileageEntries.Sum(x => x.DistanceInMiles);
var checkPoints = checkPointRepository.Get();
var checkPointsReached = checkPoints.Where(x => x.Distance <= totalDistance).OrderBy(x => x.Distance);
var targetCheckPoint = checkPoints.First(x => x.SkateTarget.Equals(User.Target));
var nextCheckPoint = checkPoints.Where(x => x.Distance > totalDistance && x.Distance <= targetCheckPoint.Distance).OrderBy(x => x.Distance).FirstOrDefault();
var model = await base.Build();
model.PageTitle = "Your Progress";
model.DisplayPageTitle = "Your Progress";
model.IsNoIndexPage = true;
model.Content.MilesSkated = totalDistance;
model.Content.TargetMiles = targetCheckPoint.Distance;
model.Content.Entries = mileageEntries;
model.Content.CheckPointsReached =
(from cp in checkPointsReached
join acp in analysis.CheckPointDates on cp.SkateTarget equals acp.Key
orderby acp.Value
select new SkaterProgressCheckPoint
{
SkateTarget = cp.SkateTarget,
Distance = cp.Distance,
Title = cp.Title,
Description = cp.Description,
Longitude = cp.Longitude,
Latitude = cp.Latitude,
Url = cp.Url,
Image = cp.Image,
DigitalBadge = cp.DigitalBadge,
FinisherDigitalBadge = cp.FinisherDigitalBadge,
DateAchieved = acp.Value
}).ToList();
if (nextCheckPoint != null)
{
var distanceToNextCheckpoint = nextCheckPoint.Distance - totalDistance;
model.Content.NextCheckPoint = new SkaterProgressCheckPoint
{
Title = "Your Next Checkpoint",
Description = $"You have to skate a further {distanceToNextCheckpoint:F2} miles to reach {nextCheckPoint.Title}.",
Longitude = nextCheckPoint.Longitude,
Latitude = nextCheckPoint.Latitude,
Url = nextCheckPoint.Url
};
}
else
{
var lastCheckPointReached = model.Content.CheckPointsReached.Last();
model.Content.NextCheckPoint = lastCheckPointReached;
model.Content.CheckPointsReached.Remove(lastCheckPointReached);
}
return(model);
}
