public IActionResult Leaderboards()
{
var model = new List <LeaderboardViewModel>();
var Commutes = _context.Commute.Where(c => c.CommuteDate.Year == DateTime.Now.Year).ToList();
var Users = _context.Users.Include(c => c.Business).Where(c => c.Email != "*****@*****.**").ToList();
foreach (var user in Users)
{
var userViewModel = new LeaderboardViewModel
{
UserName = user.FirstName + " " + user.LastName,
UserPhoto = user.UserPhoto,
UserId = user.Id,
TotalCommutes = Commutes.Where(c => c.UserId == user.Id).Count(),
BikeCommutes = Commutes.Where(c => c.UserId == user.Id && c.CommuteTypeId == 1).Count(),
RunCommutes = Commutes.Where(c => c.UserId == user.Id && c.CommuteTypeId == 3).Count(),
CarpoolCommutes = Commutes.Where(c => c.UserId == user.Id && c.CommuteTypeId == 2).Count(),
TotalDistance = Commutes.Where(c => c.UserId == user.Id).Sum(c => c.CommuteDistance),
UserBusiness = user.Business
};
model.Add(userViewModel);
}
return(View(model.ToList()));
}
public ActionResult Leaderboard()
{
var submissionService = new SubmissionDataService();
var submissions = submissionService.GetAll();
var successfulSubmissions = submissions
.Where(submission => submission.IsSuccessful)
.GroupBy(submission => submission.Nickname)
.Select(group => group.ToList())
.ToList();
var leadersList = new List <LeaderboardViewModel>();
foreach (var item in successfulSubmissions)
{
var solvedProblemsIds = item.Select(submission => submission.ProblemId).ToArray();
var solvedProblems = solvedProblemsIds
.Select(problemId => problemList.Find(problem => problem.Id == problemId).Name).ToList();
var newLeader = new LeaderboardViewModel
{
Nickname = item.First().Nickname,
SuccessfulSolutionsCount = item.Count,
SolvedProblems = solvedProblems
};
leadersList.Add(newLeader);
}
leadersList = leadersList.OrderByDescending(x => x.SuccessfulSolutionsCount).Take(5).ToList();
return(View(leadersList));
}
public async Task <IActionResult> Leaderboard()
{
var allUsers = this.applicationUserRepository.GetAllAsync().Result.ToList();
var mappedUsers = new List <LeaderboardViewModel>();
foreach (var user in allUsers)
{
var userReadBooks = await this.applicationUserRepository.GetManyToManyAsync(u => u.Id == user.Id,
bu => bu.BookUsers.Where(s => s.State == BookState.Read),
b => b.Book);
var booksRed = userReadBooks.Count();
var mappedUser = new LeaderboardViewModel
{
Id = user?.Id,
Email = user?.Email,
ProfilePictureUrl = user?.ProfilePictureUrl,
Username = user?.UserName,
BooksRed = booksRed
};
mappedUsers.Add(mappedUser);
}
var leaderboardMappedUsers = mappedUsers.OrderByDescending(x => x.BooksRed).ToList();
return(View(leaderboardMappedUsers));
}
public IActionResult Index()
{
var profiles = _context.PlayerProfiles.ToList();
var playertitles = _context.PlayerTitles.ToList();
var titles = _context.Titles.ToList();
var playerItems = _context.PlayerItems.ToList();
var items = _context.Items.ToList();
List <PlayerProfile> playerProfiles = _context.PlayerProfiles
.Include(p => p.AvailableTitles)
.Include(p => p.AvailableItems)
.ToList();
List <LeaderboardViewModel> leaderboard = new List <LeaderboardViewModel>();
foreach (PlayerProfile player in playerProfiles)
{
LeaderboardViewModel leaderboardView = new LeaderboardViewModel()
{
Pseudo = player.Pseudo,
Title = player.AvailableTitles.Where(t => t.IsSelected).FirstOrDefault().Title.Text,
TotalMICoins = player.MICoins
};
foreach (PlayerItem item in player.AvailableItems)
{
leaderboardView.TotalMICoins += item.Item.Price;
}
leaderboard.Add(leaderboardView);
}
return(View(leaderboard));
}
public async Task <IActionResult> Index(
int page = 1,
int pageSize = 10,
string mode = "",
string region = ""
)
{
// Create the view model with initial values we already know.
var vm = new LeaderboardViewModel
{
Page = page,
PageSize = pageSize,
SelectedMode = mode,
SelectedRegion = region,
GameModes = new List <string>()
{
"Solo",
"Duo",
"Trio"
},
GameRegions = new List <string>()
{
"Milky Way",
"Andromeda",
"Pinwheel",
"NGC 1300",
"Messier 82",
}
};
return(await NewMethod1(page, pageSize, mode, region, vm));
}
public ActionResult Leaderboard(LeaderboardViewModel viewModel)
{
ViewBag.Message = "Leaderboard";
RefreshLeaderBoardViewModel(viewModel);
return(View(viewModel));
}
public async Task <IActionResult> Index(
int page = 1,
int pageSize = 10,
string mode = "",
string region = ""
)
{
// Create the view model with initial values we already know.
var vm = new LeaderboardViewModel();
vm.GameModes = new List <string>()
{
"Solo",
"Duo",
"Trio"
};
vm.GameRegions = new List <string>()
{
"Milky Way",
"Andromeda",
"Pinwheel",
"NGC 1300",
"Messier 82",
};
vm.PageSize = pageSize;
try
{
// Call the leaderboard service with the provided parameters.
LeaderboardResponse leaderboardResponse = await this._leaderboardServiceClient.GetLeaderboard(page, pageSize, mode, region);
vm.Page = leaderboardResponse.Page;
vm.PageSize = leaderboardResponse.PageSize;
vm.Scores = leaderboardResponse.Scores;
vm.SelectedMode = leaderboardResponse.SelectedMode;
vm.SelectedRegion = leaderboardResponse.SelectedRegion;
vm.TotalResults = leaderboardResponse.TotalResults;
// Set previous and next hyperlinks.
if (page > 1)
{
vm.PrevLink = $"/?page={page - 1}&pageSize={pageSize}&mode={mode}®ion={region}#leaderboard";
}
if (vm.TotalResults > page * pageSize)
{
vm.NextLink = $"/?page={page + 1}&pageSize={pageSize}&mode={mode}®ion={region}#leaderboard";
}
}
catch (Exception e)
{
vm.ErrorMessage = $"Unable to retrieve leaderboard: {e}";
Trace.TraceError(vm.ErrorMessage);
}
return(View(vm));
}
public ActionResult DistanceLeaderboard(Group group)
{
var leaders = _groupService.GetLeaderBoard(group.Id, "Distance");
var vm = new LeaderboardViewModel {
Leaders = leaders
};
return(PartialView("_LeaderboardPartial", vm));
}
public void Setup()
{
serviceClient = new Mock <ITreasureHuntService>();
viewModel = new LeaderboardViewModel(serviceClient.Object);
myFakeHunt = new hunt();
myFakeHunt.HuntName = "My Fake Hunt";
CurrentTreasureHunt = myFakeHunt;
}
public ActionResult TopScore()
{
var scoreVM = new LeaderboardViewModel(
_db.UserProfiles.Include(up => up.ReviewCompletions).Where(
u =>
u.Promotions.Any(p => p.status == "Current") ||
u.ReviewCompletions.Any(rc => rc.Status == "Current" && rc.ComplesionDate != null))
);
return(View(scoreVM));
}
// GET: /Leaderboard
public ActionResult Leaderboard()
{
List <GameSessions> Multiplayer = GameDB.GameSession.OrderByDescending(entry => entry.Score).Take(10).Where(entry => entry.Type == true && entry.IsCompleted == true).ToList();
List <GameSessions> Singleplayer = GameDB.GameSession.OrderByDescending(entry => entry.Score).Take(10).Where(entry => entry.Type == false && entry.IsCompleted == true).ToList();
LeaderboardViewModel model = new LeaderboardViewModel();
model.SinglePlayer = Singleplayer;
model.Multiplayer = Multiplayer;
return(View(model));
}
public ActionResult Leaderboard()
{
ViewBag.Message = "Leaderboard";
var viewModel = new LeaderboardViewModel();
RefreshLeaderBoardViewModel(viewModel);
return(View(viewModel));
}
public void CreateVM()
{
var _navigationService = Mvx.Resolve <IMvxNavigationService>();
var _assetService = Mvx.Resolve <IPlatformAssetService>();
var _alertService = Mvx.Resolve <IAlertService>();
var _messanger = Mvx.Resolve <IMvxMessenger>();
var _localNotificationService = Mvx.Resolve <ILocalNotificationService>();
_transactionsVM = new TransactionsViewModel(_navigationService, _alertService, _assetService, _localNotificationService);
_leaderboardVM = new LeaderboardViewModel(_navigationService, _alertService, _assetService, _localNotificationService, _messanger);
_pointsVM = new PointsViewModel(_navigationService, _alertService, _assetService, _localNotificationService);
}
public ActionResult Index()
{
var model = new LeaderboardViewModel {
Users = RavenSession.Query <User, User_TotalPoints>()
.ProjectFromIndexFieldsInto <UserWithTotalPoints>()
.OrderByDescending(x => x.TotalPoints)
.Take(10)
.ToList()
};
return(PartialView(model));
}
public ActionResult Leaderboard(int limit = int.MaxValue, bool allowDuplicateSpeakers = true)
{
var leaderboardSessions = dataProvider.GetLeaderBoard(limit, allowDuplicateSpeakers);
var highestVoteCount = leaderboardSessions.Max(s => s.NumberOfVotes);
var model = new LeaderboardViewModel
{
HighestVoteCount = highestVoteCount,
Sessions = leaderboardSessions
};
return(View(model));
}
public async Task <IActionResult> Index(int pageIndex = 0)
{
const int pageSize = 10;
var viewModel = new LeaderboardViewModel
{
LeaderboardItems = await PaginatedList <LeaderboardItem> .CreateAsync(_leaderboardRepository.GetAllOrdered(), pageIndex, pageSize),
PageIndex = pageIndex,
PageSize = pageSize
};
return(View("Index", viewModel));
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
var loadData = e.NavigationMode != NavigationMode.Back;
_viewModel = ServiceLocator.Current.GetInstance <LeaderboardViewModel>(loadData);
DataContext = _viewModel;
if (loadData)
{
await _viewModel.LoadState();
}
}
public LeaderboardViewModel GetLeaderboard(int?playerId)
{
var player = _dbContext.Player.SingleOrDefault(p => p.Id == playerId.Value);
if (player == null)
{
return(new LeaderboardViewModel());
}
var syndicateId = player.SyndicateId;
var attendance = GetCampaignAttendance(null, syndicateId.Value);
var allPlayers = _dbContext.Player.Where(p => p.SyndicateId == syndicateId).ToDictionary(p => p.Id, p => p);
var allCampaignsPositions = attendance.TotalAttendance.AsEnumerable()
.OrderByDescending(k => k.Value)
.ThenBy(k => allPlayers[k.Key].Name)
.Select(k => k.Key)
.ToList();
var allCampaignsPositionsDict =
allCampaignsPositions.Where(p => p == playerId.Value || allCampaignsPositions.IndexOf(p) < 10)
.ToDictionary(p => allCampaignsPositions.IndexOf(p) + 1, p => p);
var allT5HardPositions = attendance.T5HardAttendance.AsEnumerable()
.OrderByDescending(k => k.Value)
.ThenByDescending(k => attendance.TotalAttendance[k.Key])
.ThenBy(k => allPlayers[k.Key].Name)
.Select(k => k.Key)
.ToList();
var allT5HardPositionsDict =
allT5HardPositions.Where(p => p == playerId.Value || allT5HardPositions.IndexOf(p) < 10)
.ToDictionary(p => allT5HardPositions.IndexOf(p) + 1, p => p);
var last10T5HardPositions = attendance.Last10T5HardAttendance.AsEnumerable()
.OrderByDescending(k => k.Value)
.ThenByDescending(k => attendance.T5HardAttendance[k.Key])
.ThenByDescending(k => attendance.TotalAttendance[k.Key])
.ThenBy(k => allPlayers[k.Key].Name)
.Select(k => k.Key)
.ToList();
var last10T5HardPositionsDict =
last10T5HardPositions.Where(p => p == playerId.Value || last10T5HardPositions.IndexOf(p) < 10)
.ToDictionary(p => last10T5HardPositions.IndexOf(p) + 1, p => p);
var leaderboard = new LeaderboardViewModel {
AllPlayers = allPlayers,
Attendance = attendance,
TotalLeaderboardPositions = allCampaignsPositionsDict,
T5HardLeaderboardPositions = allT5HardPositionsDict,
Last10T5HardLeaderboardPositions = last10T5HardPositionsDict,
PlayerToCompare = player,
};
return(leaderboard);
}
public ActionResult ViewLeaderboard()
{
var model = new CompleteLeaderboardViewModel();
model.AllLeaderboardEntries = new List<LeaderboardViewModel>();
var leaderBoard = new Leaderboard();
var leaderboardentries = new List<Leaderboard>();
using (var employeerepo = new EmployeeRepository())
{
leaderboardentries = leaderBoard.CreateBlankLeaderboard(employeerepo.ViewEmployees());
}
using (var matchrepo = new MatchRepository())
{
var matches = new List<Match>(matchrepo.GetAllMatches());
foreach (var match in matches)
{
leaderBoard.UpdateLeaderboard(leaderboardentries, leaderBoard.GetLeaderboardEntry(match.WinnerId, match.Player1Id));
leaderBoard.UpdateLeaderboard(leaderboardentries, leaderBoard.GetLeaderboardEntry(match.WinnerId, match.Player2Id));
}
}
leaderboardentries = leaderboardentries.OrderByDescending(x => x.GamesWon).ThenByDescending(x => x.GamesDrawn).ThenBy(x => x.GamesLost).ToList();
foreach (var leaderboardentry in leaderboardentries)
{
var oneleaderboardentry = new LeaderboardViewModel();
oneleaderboardentry.Player = new Employee();
oneleaderboardentry.LeaderboardPlayer = new Leaderboard();
using (var employeerepo = new EmployeeRepository())
{
oneleaderboardentry.Player = employeerepo.GetEmployeeById(leaderboardentry.PlayerId);
}
oneleaderboardentry.LeaderboardPlayer.PlayerId = leaderboardentry.PlayerId;
oneleaderboardentry.LeaderboardPlayer.GamesPlayed = leaderboardentry.GamesPlayed;
oneleaderboardentry.LeaderboardPlayer.GamesWon = leaderboardentry.GamesWon;
oneleaderboardentry.LeaderboardPlayer.GamesDrawn = leaderboardentry.GamesDrawn;
oneleaderboardentry.LeaderboardPlayer.GamesLost = leaderboardentry.GamesLost;
model.AllLeaderboardEntries.Add(oneleaderboardentry);
}
return View(model);
}
public LeaderboardPage(LeaderboardViewModel viewModel, GameType gameType)
{
BindingContext = viewModel;
InitializeComponent();
if (gameType == GameType.NormalGame)
{
Title = AppResources.Leaderboard;
}
else
{
Title = AppResources.ArcadeLeaderboard;
}
viewModel.CurrentGameType = gameType;
}
private void RefreshLeaderBoardViewModel(LeaderboardViewModel viewModel)
{
var player = db.Players.Include("Pools").Single(item => item.UserName == User.Identity.Name);
viewModel.Pools = GetPlayerPools(player);
if (viewModel.SelectedPoolId == null)
{
if (Request.Cookies["SelectedPoolId"] != null)
{
viewModel.SelectedPoolId = Request.Cookies["SelectedPoolId"].Value;
}
else
{
viewModel.SelectedPoolId = player.Pools.FirstOrDefault()?.Id;
}
//viewModel.SelectedPoolId = viewModel.Pools.First().Value;
}
//remember last pool
HttpCookie cookie = new HttpCookie("SelectedPoolId", viewModel.SelectedPoolId);
Response.Cookies.Add(cookie);
var tmpList = new List <Models.LeaderboardPlayerViewModel>();
//get pool id from player pool id
var selectedPoolId = db.PlayerPools.Single(item => item.Id == viewModel.SelectedPoolId).PoolId;
//get players in this pool
var poolPlayers = db.Players.Where(item => item.Pools.Any(p => p.PoolId == selectedPoolId)).ToList();
//load the playerpool for each player
foreach (var poolPlayer in poolPlayers)
{
var playerPool = db.PlayerPools.Single(item => item.PoolId == selectedPoolId && item.PlayerId == poolPlayer.Id);
var vm = new LeaderboardPlayerViewModel()
{
UserName = poolPlayer.UserName,
PoolScore = playerPool.PoolScore,
LostPoints = playerPool.LostPoints,
PossiblePoints = playerPool.PossiblePoints,
WinPercent = playerPool.WinPercent,
IsValid = playerPool.IsValid
};
tmpList.Add(vm);
}
viewModel.Players = new List <LeaderboardPlayerViewModel>();
viewModel.Players.AddRange(tmpList.OrderByDescending(item => item.PoolScore));
}
public ActionResult Leaderboard(bool MinutesOption)
{
LeaderboardViewModel leaderboard = new LeaderboardViewModel();
if (MinutesOption)
{
leaderboard.ChildList = childDAL.GetLeadersByCarrots();
}
else
{
leaderboard.ChildList = childDAL.GetLeadersBySteps();
}
leaderboard.MinutesOption = MinutesOption;
Session["leaderboard"] = leaderboard;
return(RedirectToAction("LeaderBoard", leaderboard));
}
public ActionResult Index(string id)
{
var items = RavenSession
.Query <Board>()
.Where(x => x.Id == id && x.IsPublic)
.TransformWith <LeaderboardViewModelTransformer, LeaderboardViewModel.Item>()
.OrderByDescending(x => x.Points)
.Take(10)
.ToList();
var model = new LeaderboardViewModel {
Items = items
};
return(PartialView(model));
}
public ActionResult Leaderboard()
{
LeaderboardViewModel leaderboard = new LeaderboardViewModel();
if (Session["leaderboard"] != null)
{
leaderboard = Session["leaderboard"] as LeaderboardViewModel;
}
else
{
leaderboard.ChildList = childDAL.GetLeadersBySteps();
}
return(View("LeaderBoard", leaderboard));
}
public void RenderCorrectPartialViewWithCorrectViewModel()
{
// Arrange
var leaderboardService = new Mock <ILeaderboardService>();
var leaderboardController = new LeaderboardController(leaderboardService.Object);
var damageDonePerSecondViewModels = new List <OutputPerSecondViewModel>();
var expectedViewModel = new LeaderboardViewModel(0, damageDonePerSecondViewModels);
leaderboardService.Setup(s => s.GetTopDamageOnPage(It.IsAny <int>())).Returns(expectedViewModel);
// Act & Assert
leaderboardController
.WithCallTo(c => c.Damage(0))
.ShouldRenderPartialView("_DamageAjaxFormPartial")
.WithModel <LeaderboardViewModel>(actualViewModel =>
{
Assert.That(actualViewModel, Is.SameAs(expectedViewModel));
});
}
public void DisplayCorrectViewWithCorrectViewModel()
{
// Arrange
var leaderboardService = new Mock <ILeaderboardService>();
var leaderboardController = new LeaderboardController(leaderboardService.Object);
var healingDonePerSecondViewModels = new List <OutputPerSecondViewModel>();
var expectedViewModel = new LeaderboardViewModel(0, healingDonePerSecondViewModels);
leaderboardService.Setup(s => s.GetTopHealingOnPage(It.IsAny <int>())).Returns(expectedViewModel);
// Act & Assert
leaderboardController
.WithCallTo(c => c.Healing())
.ShouldRenderDefaultView()
.WithModel <LeaderboardViewModel>(actualViewModel =>
{
Assert.That(actualViewModel, Is.SameAs(expectedViewModel));
});
}
public IActionResult GetLeaderboard(LeaderboardFilter filter)
{
if (filter != null)
{
var leaderboard = _leaderboardService.GetLeaderboard(filter);
if (leaderboard != null)
{
int pages = (int)Math.Ceiling(Convert.ToDouble(leaderboard.TotalEntries) / Convert.ToDouble(filter.Count));
var result = new LeaderboardViewModel()
{
Leaderboard = leaderboard,
Page = filter.Page,
NextPage = filter.Page >= pages ? pages : filter.Page + 1,
PreviousPage = filter.Page > 1 ? filter.Page - 1 : 1
};
return(Ok(result));
}
}
return(NotFound());
}
public ActionResult Leaderboard()
{
LeaderboardViewModel model = new LeaderboardViewModel();
model.Vines = DataAccess.DataAccess.GetAllVines().Select(x => new LeaderboardVine()
{
ThumbnailUrl = x.ThumbnailUrl,
Description = x.Description,
Rating = x.Rating,
Permalink = x.Permalink
}).ToList();
// Assign the ranks to the vines
int rank = 1;
foreach (LeaderboardVine leaderboardVine in model.Vines)
{
leaderboardVine.Rank = rank;
rank++;
}
return(View(model));
}
public async Task <IActionResult> Index(
int page = 1,
int pageSize = 10,
string mode = "",
string region = ""
)
{
// Create the view model with initial values we already know.
var vm = new LeaderboardViewModel
{
Page = page,
PageSize = pageSize,
SelectedMode = mode,
SelectedRegion = region,
GameModes = new List <string>()
{
"Solo",
"Duo",
"Trio"
},
GameRegions = new List <string>()
{
"Milky Way",
"Andromeda",
"Pinwheel",
"NGC 1300",
"Messier 82",
}
};
try
{
// Form the query predicate.
// This expression selects all scores that match the provided game
// mode and region (map).
// Select the score if the game mode or region is empty.
Expression <Func <Score, bool> > queryPredicate = score =>
(string.IsNullOrEmpty(mode) || score.GameMode == mode) &&
(string.IsNullOrEmpty(region) || score.GameRegion == region);
// Fetch the total number of results in the background.
var countItemsTask = _scoreRepository.CountItemsAsync(queryPredicate);
// Fetch the scores that match the current filter.
IEnumerable <Score> scores = await _scoreRepository.GetItemsAsync(
queryPredicate, // the predicate defined above
score => score.HighScore, // sort descending by high score
page - 1, // subtract 1 to make the query 0-based
pageSize
);
// Wait for the total count.
vm.TotalResults = await countItemsTask;
// Set previous and next hyperlinks.
if (page > 1)
{
vm.PrevLink = $"/?page={page - 1}&pageSize={pageSize}&mode={mode}®ion={region}#leaderboard";
}
if (vm.TotalResults > page * pageSize)
{
vm.NextLink = $"/?page={page + 1}&pageSize={pageSize}&mode={mode}®ion={region}#leaderboard";
}
// Fetch the user profile for each score.
// This creates a list that's parallel with the scores collection.
var profiles = new List <Task <Profile> >();
foreach (var score in scores)
{
profiles.Add(_profileRespository.GetItemAsync(score.ProfileId));
}
Task <Profile> .WaitAll(profiles.ToArray());
// Combine each score with its profile.
vm.Scores = scores.Zip(profiles, (score, profile) => new ScoreProfile {
Score = score, Profile = profile.Result
});
return(View(vm));
}
catch (Exception)
{
return(View(vm));
}
}
void UpdateUI()
{
try
{
this.sessionStatusView.ViewModel = new Controls.ViewModels.SessionStateViewModel()
{
VehicleDescription = "Fast Car",
DriverName = "Rob Roberts",
SessionName = "Practice",
SetupName = "br-549",
SessionState = "Green",
SessionNumber = 1,
TrackName = "Orange County Speedway",
TrackLength = .375F,
WeatherSummary = "Sunny, 88*, 29.67 Hg rising",
IsFixedSetup = false,
CurrentLapNumber = 88,
SessionLapLimit = 126,
SessionTimeRemaining = new TimeSpan(1, 13, 44),
IsLapLimitedSession = true,
IsTimedSession = false
};
var d1 = new Controls.ViewModels.DriverViewModel()
{
Name = "Rob Roberts",
LicenseLevel = "A",
SR = 2.37F,
iRating = 2000,
Vehicle = "SK Modified",
Team = "R2 Motorsports",
Club = "Carolinas"
};
this.driverView1.ViewModel = d1;
var d2 = new Controls.ViewModels.DriverViewModel()
{
Name = "John Smith",
LicenseLevel = "B",
SR = 1.22F,
iRating = 1354,
Vehicle = "SK Modified",
Team = "Broke Racing",
Club = "Sweden"
};
var d3 = new Controls.ViewModels.DriverViewModel()
{
Name = "Cole Trickle",
LicenseLevel = "A",
SR = 3.99F,
iRating = 5625,
Vehicle = "SK Modified",
Team = "Hendrick Motorsports",
Club = "Carolinas"
};
var lap1 = new Controls.ViewModels.LapTimeViewModel()
{
LapNumber = 7,
LapTime = 18.993F,
LapMPH = 98.234F
};
this.lapTimeView1.ViewModel = lap1;
var lap2 = new Controls.ViewModels.LapTimeViewModel()
{
LapNumber = 8,
LapTime = 18.813F,
LapMPH = 99.764F,
LastLap = lap1,
Interval = 0.3F
};
this.lapTimeView2.ViewModel = lap2;
this.lapTimeView2.DisplayLapTimeDelta = false;
var lap3 = new Controls.ViewModels.LapTimeViewModel()
{
LapNumber = 9,
LapTime = 19.223F,
LapMPH = 96.299F,
LastLap = lap2,
Interval = 1.8F
};
this.lapTimeView3.ViewModel = lap3;
this.lapTimeView3.DisplayLapMPHDelta = false;
this.lapTimeView3.DisplayLapTimeDelta = false;
this.lapTimeView3.DisplayLapMPH = false;
var l1= new LeaderboardViewModel()
{
Driver = d1,
Lap = lap1,
Position = 1,
ClassPosition = 1
};
this.leaderboardView1.ViewModel = l1;
var l2 = new LeaderboardViewModel()
{
Driver = d2,
Lap = lap2,
Position = 2,
ClassPosition = 2
};
this.leaderboardView2.ViewModel = l2;
var l3 = new LeaderboardViewModel()
{
Driver = d3,
Lap = lap3,
Position = 3,
ClassPosition = 3
};
this.leaderboardView3.ViewModel = l3;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public LeaderboardViewModel GetWeeklyLeaderboard(int week)
{
var vm = new LeaderboardViewModel();
// get the summed scores for this season
var scores = (from p in _ctx.Picks
where p.Game.Season.IsCurrent && p.IsWinner.HasValue && p.IsWinner.Value && p.Game.Week == week
orderby p.Game.Week
group p by p.UserId into up
select new LeaderViewModel() { Week = week, UserId = up.Key, Points = up.Sum(p => p.PointTotal) }).ToList();
//
var psScores = (from p in _ctx.PlayoffSuperbowlPicks
where p.Season.IsCurrent && p.IsWinner && p.Week == week
orderby p.Week
group p by p.UserId into up
select new LeaderViewModel() { UserId = up.Key, Week = week, Points = up.Sum(p => p.PointTotal) }).ToList();
foreach (var leaderViewModel in scores)
{
LeaderViewModel model = leaderViewModel;
var iPsScores = psScores.SingleOrDefault(p => p.UserId == model.UserId && p.Week == model.Week);
if (iPsScores != null)
leaderViewModel.Points += iPsScores.Points;
}
vm.Leaders = scores.OrderByDescending(p => p.Points).ToList();
return vm;
}
public LeaderboardView()
{
InitializeComponent();
DataContext = new LeaderboardViewModel();
}
public async Task <IActionResult> Index(
int page = 1,
int pageSize = 10,
string mode = "",
string region = ""
)
{
// Create the view model with initial values we already know.
var vm = new LeaderboardViewModel
{
Page = page,
PageSize = pageSize,
SelectedMode = mode,
SelectedRegion = region,
GameModes = new List <string>()
{
"Solo",
"Duo",
"Trio"
},
GameRegions = new List <string>()
{
"Milky Way",
"Andromeda",
"Pinwheel",
"NGC 1300",
"Messier 82",
}
};
try
{
// Fetch the total number of results in the background.
var countItemsTask = _dbRespository.CountScoresAsync(mode, region);
// Fetch the scores that match the current filter.
IEnumerable <Score> scores = await _dbRespository.GetScoresAsync(mode, region, page, pageSize);
// Wait for the total count.
vm.TotalResults = await countItemsTask;
// Fetch the user profile for each score.
// This creates a list that's parallel with the scores collection.
var profiles = new List <Task <Profile> >();
foreach (var score in scores)
{
profiles.Add(_dbRespository.GetProfileAsync(score.ProfileId));
}
Task <Profile> .WaitAll(profiles.ToArray());
// Combine each score with its profile.
vm.Scores = scores.Zip(profiles, (score, profile) => new ScoreProfile {
Score = score, Profile = profile.Result
});
return(View(vm));
}
catch (Exception ex)
{
return(View(vm));
}
}
