public StepChallengeMutation(StepContext db, StepsService stepsService)
{
Name = "Mutation";
Field <StepsType>(
"creatStepsEntry",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StepInputType> > {
Name = "steps"
}),
resolve: context =>
{
var steps = context.GetArgument <StepsInputs>("steps");
var stepsDay = new DateTime(steps.DateOfSteps.Year, steps.DateOfSteps.Month, steps.DateOfSteps.Day, 0, 0, 0);
var existingStepCount = db.Steps
.Where(s => s.ParticipantId == steps.ParticipantId)
.FirstOrDefault(s => s.DateOfSteps == stepsDay);
if (existingStepCount != null)
{
return(stepsService.Update(existingStepCount, steps));
}
return(stepsService.Create(steps));
});
}
public void Test_StepsOnlyCountedToLatestMonday_Total()
{
var teams = TestData.GetTeams_StepsOverLeadBoardDate();
var stepsService = new StepsService(GetMockContext());
var total = stepsService.GetTotalSteps(teams, DateOfFirstWeek, StartDate, 3);
const int expectedTotalSteps = ((10 * 3) + (20 * 3) + (30 * 3)) * 3;
Assert.AreEqual(expectedTotalSteps, total, $"Expected TotalStepCount {expectedTotalSteps} but got {total} instead");
}
public void Test_TeamsWithLessParticipants_GetAnExtraAveragedPerson()
{
var teams = TestData.GetTeams_OneLessParticipantInTeamOne();
var stepsService = new StepsService(GetMockContext());
var result = stepsService.GetTeamScores(teams, DateOfFirstWeek, StartDate, 3);
var teamWithLessParticipants = result.FirstOrDefault(t => t.TeamId == 1);
const int teamActualTotal = (3 * 30) * 2;
const int expectedTotal = (teamActualTotal / 2) * 1;
Assert.AreEqual(expectedTotal, teamWithLessParticipants?.TeamStepCount, $"Expected TeamStepCount {expectedTotal} but got {teamWithLessParticipants?.TeamStepCount} instead");
}
public void Test_StepsOnlyCountedToLatestMonday()
{
var teams = TestData.GetTeams_StepsOverLeadBoardDate();
var stepsService = new StepsService(GetMockContext());
var result = stepsService.GetTeamScores(teams, DateOfFirstWeek, StartDate, 3);
var firstPlace = result.First();
const int expectedTeamId = 3;
const int expectedTotal = (3 * 30) * 3;
Assert.AreEqual(expectedTeamId, firstPlace.TeamId, $"Expected TeamId {expectedTeamId} but got {firstPlace.TeamId} instead");
Assert.AreEqual(expectedTotal, firstPlace.TeamStepCount, $"Expected TeamStepCount {expectedTeamId} but got {firstPlace.TeamStepCount} instead");
}
public void Test_StepsOutOfDateRange_DoNotGetCounted()
{
var teams = TestData.GetTeams_StepsOutsideOfRange();
var stepsService = new StepsService(GetMockContext());
var result = stepsService.GetTeamScores(teams, DateOfFirstWeek, StartDate, 3);
var firstPlace = result.First();
const int expectedTeamId = 3;
const int expectedTotal = (3 * 30) * 3;
Assert.AreEqual(expectedTeamId, firstPlace.TeamId, $"Expected TeamId {expectedTeamId} but got {firstPlace.TeamId} instead");
Assert.AreEqual(expectedTotal, firstPlace.TeamStepCount, $"Expected TeamStepCount {expectedTeamId} but got {firstPlace.TeamStepCount} instead");
}
public void Test_StepsAreCorrectEachDay()
{
var participant = TestData.GetParticipant();
const int expectedCountPerDay = 10;
var expectedDays = new List <DateTime>
{
StartDate,
StartDate.AddDays(1),
StartDate.AddDays(2),
};
var stepsService = new StepsService(GetMockStepContext(participant.Steps));
var result = stepsService.GetParticipantSteps(participant);
Assert.That(result.Steps.All(s => s.StepCount == expectedCountPerDay), $"Expected every stepCount to equal {expectedCountPerDay}");
Assert.That(result.Steps.All(s => expectedDays.Any(e => e == s.DateOfSteps)), $"Expected DateOfSteps to equal {expectedDays}");
}
public StepChallengeQuery(StepContext db, StepsService stepsService, TeamService teamService)
{
// TODO these should be set in the db and able to change
var startDate = new DateTime(2019, 09, 16, 0, 0, 0);
var endDate = new DateTime(2019, 12, 05, 0, 0, 0);
Field <ParticipantType>(
"Participant",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "participantId", Description = "The ID of the Participant"
}),
resolve: context =>
{
var id = context.GetArgument <int>("participantId");
var participant = db.Participants
.Include("Team")
.FirstOrDefault(i => i.ParticipantId == id);
return(stepsService.GetParticipantSteps(participant));
});
Field <ListGraphType <UserType> >(
"Users",
resolve: context =>
{
var participants = db.Participants
.Include("IdentityUser")
.Include("Team");
return(participants);
});
Field <ListGraphType <TeamScoreBoardType> >(
"TeamSteps",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "teamId", Description = "The ID of the Team"
}),
resolve: context =>
{
var id = context.GetArgument <int>("teamId");
var teamSteps = teamService.GetTeamScoreBoard(id);
return(teamSteps);
});
Field <TeamType>(
"Team",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "teamId", Description = "The ID of the Team"
}),
resolve: context =>
{
var teamId = context.GetArgument <int>("teamId");
var team = db.Team
.Include("Participants")
.FirstOrDefault(t => t.TeamId == teamId);
return(team);
});
Field <ListGraphType <TeamType> >(
"Teams",
resolve: context =>
{
var teams = db.Team
.Include("Participants")
.Include("Participants.Steps");
return(teams);
});
Field <LeaderBoardType>(
"LeaderBoard",
resolve: context =>
{
var leaderBoard = new LeaderBoard();
var settings = db.ChallengeSettings
.FirstOrDefault();
if (settings == null || !settings.ShowLeaderBoard)
{
leaderBoard.TeamScores = new List <TeamScores>();
return(leaderBoard);
}
var teams = db.Team;
leaderBoard = stepsService.GetLeaderBoard(teams);
var teamSteps = leaderBoard.TeamScores.Select(t => new TeamScores
{
TeamId = t.TeamId,
TeamName = t.TeamName,
TeamStepCount = settings.ShowLeaderBoardStepCounts ? t.TeamStepCount : 0
}).ToList();
leaderBoard.TeamScores = teamSteps;
return(leaderBoard);
});
Field <AdminLeaderBoardType>(
"AdminLeaderBoard",
resolve: context =>
{
var teams = db.Team;
var leaderBoard = stepsService.GetLeaderBoard(teams);
return(leaderBoard);
});
Field <ChallengeSettingsType>(
"ChallengeSettings",
resolve: context =>
{
var settings = db.ChallengeSettings
.FirstOrDefault();
return(settings);
});
}
public StepChallengeMutation(StepContext db, StepsService stepsService, ParticipantService participantService)
{
Name = "Mutation";
Field <StepsType>(
"creatStepsEntry",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StepInputType> > {
Name = "steps"
}),
resolve: context =>
{
var steps = context.GetArgument <StepsInputs>("steps");
var stepsDay = new DateTime(steps.DateOfSteps.Year, steps.DateOfSteps.Month, steps.DateOfSteps.Day, 0, 0, 0);
var existingStepCount = db.Steps
.Where(s => s.ParticipantId == steps.ParticipantId)
.FirstOrDefault(s => s.DateOfSteps == stepsDay);
if (existingStepCount != null)
{
return(stepsService.Update(existingStepCount, steps));
}
return(stepsService.Create(steps));
});
Field <ChallengeSettingsType>(
"updateChallengeSettings",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ChallengeSettingsInputType> > {
Name = "settings"
}),
resolve: context =>
{
var newSettings = context.GetArgument <ChallengeSettingsInput>("settings");
var existingSettings = db.ChallengeSettings
.FirstOrDefault();
if (existingSettings != null)
{
existingSettings.ShowLeaderBoard = newSettings.ShowLeaderBoard;
existingSettings.ShowLeaderBoardStepCounts = newSettings.ShowLeaderBoardStepCounts;
}
db.SaveChanges();
return(existingSettings);
});
Field <TeamType>(
"updateTeam",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TeamInputType> > {
Name = "team"
}),
resolve: context =>
{
var newTeamInfo = context.GetArgument <TeamInput>("team");
var team = db.Team
.FirstOrDefault(t => t.TeamId == newTeamInfo.TeamId);
if (team != null)
{
team.TeamName = newTeamInfo.TeamName;
team.NumberOfParticipants = newTeamInfo.NumberOfParticipants;
}
db.SaveChanges();
return(team);
});
FieldAsync <ParticipantType>(
"deleteParticipant",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ParticipantInputType> > {
Name = "participant"
}),
resolve: async context =>
{
var participant = context.GetArgument <EditUserModel>("participant");
var user = await db.Participants
.Where(u => u.ParticipantId == participant.ParticipantId)
.Include(u => u.IdentityUser)
.SingleOrDefaultAsync();
if (user != null)
{
await participantService.DeleteParticipant(user);
}
return(user);
});
}
public StepsController(StepsService service)
{
_stepsService = service;
}
public StepChallengeQuery(StepContext db, StepsService stepsService)
{
// TODO these should be set in the db and able to change
var startDate = new DateTime(2019, 09, 16, 0, 0, 0);
var endDate = new DateTime(2019, 12, 05, 0, 0, 0);
Field <ParticipantType>(
"Participant",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "participantId", Description = "The ID of the Participant"
}),
resolve: context =>
{
var id = context.GetArgument <int>("participantId");
var participant = db.Participants
.Include("Team")
.FirstOrDefault(i => i.ParticipantId == id);
var steps = db.Steps
.Where(s => s.ParticipantId == id)
.Where(s => s.DateOfSteps >= startDate && s.DateOfSteps < endDate)
.OrderBy(s => s.DateOfSteps)
.ToList();
if (participant != null)
{
participant.Steps = steps;
}
return(participant);
});
Field <ListGraphType <UserType> >(
"Users",
resolve: context =>
{
var participants = db.Participants
.Include("IdentityUser")
.Include("Team");
return(participants);
});
Field <ListGraphType <StepsType> >(
"TeamSteps",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "teamId", Description = "The ID of the Team"
}),
resolve: context =>
{
var id = context.GetArgument <int>("teamId");
var team = db.Team
.Include("Participants")
.FirstOrDefault(i => i.TeamId == id);
var teamSteps = db.Steps
.Where(s => team.Participants.Any(t => t.ParticipantId == s.ParticipantId))
.Where(s => s.DateOfSteps >= startDate && s.DateOfSteps < endDate)
.GroupBy(s => s.DateOfSteps)
.Select(s => new Steps
{
DateOfSteps = s.First().DateOfSteps,
StepCount = s.Sum(st => st.StepCount)
})
.OrderBy(s => s.DateOfSteps)
.ToList();
return(teamSteps);
});
Field <TeamType>(
"Team",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "teamId", Description = "The ID of the Team"
}),
resolve: context =>
{
var teamId = context.GetArgument <int>("teamId");
var team = db.Team
.Include("Participants")
.FirstOrDefault(t => t.TeamId == teamId);
return(team);
});
Field <ListGraphType <TeamType> >(
"Teams",
resolve: context =>
{
var teams = db.Team
.Include("Participants")
.Include("Participants.Steps");
return(teams);
});
Field <LeaderBoardType>(
"LeaderBoard",
resolve: context =>
{
var leaderBoard = new LeaderBoard();
var teamSteps = db.Team
.Select(t => new TeamScores
{
TeamId = t.TeamId,
TeamName = t.TeamName,
TeamStepCount = t.Participants.Sum(u => u.Steps.Sum(s => s.StepCount))
}).ToList();
leaderBoard.TeamScores = teamSteps;
return(leaderBoard);
});
}
public StepChallengeMutation(StepContext db, StepsService stepsService)
{
Name = "Mutation";
Field <StepsType>(
"creatStepsEntry",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StepInputType> > {
Name = "steps"
}),
resolve: context =>
{
var steps = context.GetArgument <StepsInputs>("steps");
var stepsDay = new DateTime(steps.DateOfSteps.Year, steps.DateOfSteps.Month, steps.DateOfSteps.Day, 0, 0, 0);
var existingStepCount = db.Steps
.Where(s => s.ParticipantId == steps.ParticipantId)
.FirstOrDefault(s => s.DateOfSteps == stepsDay);
if (existingStepCount != null)
{
return(stepsService.Update(existingStepCount, steps));
}
return(stepsService.Create(steps));
});
Field <ChallengeSettingsType>(
"updateChallengeSettings",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ChallengeSettingsInputType> > {
Name = "settings"
}),
resolve: context =>
{
var newSettings = context.GetArgument <ChallengeSettingsInput>("settings");
var existingSettings = db.ChallengeSettings
.FirstOrDefault();
if (existingSettings != null)
{
existingSettings.ShowLeaderBoard = newSettings.ShowLeaderBoard;
existingSettings.ShowLeaderBoardStepCounts = newSettings.ShowLeaderBoardStepCounts;
}
db.SaveChanges();
return(existingSettings);
});
Field <TeamType>(
"updateTeam",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TeamInputType> > {
Name = "team"
}),
resolve: context =>
{
var newTeamInfo = context.GetArgument <TeamInput>("team");
var team = db.Team
.FirstOrDefault(t => t.TeamId == newTeamInfo.TeamId);
if (team != null)
{
team.TeamName = newTeamInfo.TeamName;
team.NumberOfParticipants = newTeamInfo.NumberOfParticipants;
}
db.SaveChanges();
return(team);
});
}
