public IActionResult Index(SortingInputModel sorting, int pageId = 1)
{
if (sorting.OrderBy == null)
{
sorting = new SortingInputModel()
{
OrderBy = "Date",
};
}
var orderBySelector = GetOrderBySelector(sorting);
var skip = DefaultItemsPerPage * (pageId - 1);
var rankingsViewModel = new RankingsViewModel()
{
StartRank = skip + 1,
Ranking = this.applicationUsersService
.GetMany <RankingViewModel>(
orderBySelector: orderBySelector,
asc: false,
skip: skip,
take: DefaultItemsPerPage),
Common = new CommonViewModel()
{
Pagination = this.GetPaginationModel(pageId, this.applicationUsersService.Count()),
Sorting = sorting,
},
};
return(this.View(rankingsViewModel));
}
public RankingsViewModel GetRankings(string userId)
{
// get top ten scores
var rankingModel = new RankingsViewModel();
rankingModel.UsersRanks = this.dbContext.GameResults
.OrderByDescending(gr => gr.Score)
.Take(10)
.Select(gr => new ScoreRankingViewModel()
{
Username = gr.User.Username,
Score = gr.Score,
SubmitedAt = gr.SubmitedAt,
Position = this.dbContext.GameResults
.Count(x => x.Score > gr.Score) + 1
})
.ToList();
if (userId != null)
{
// check if the user is logged in and if yes, get his record
var username = this.dbContext.Users
.First(u => u.Id == userId).Username;
// check if the user is in top ten
if (rankingModel.UsersRanks.Any(r => r.Username == username))
{
// if user is in top ten, then just find the record index
var userModel = rankingModel.UsersRanks
.First(r => r.Username == username);
var index = rankingModel.UsersRanks.IndexOf(userModel);
rankingModel.UserRankIndex = index;
}
else
{
// if the user is not in top ten, find his best score and add it to the scores list
var userModel = this.dbContext.GameResults
.Where(gr => gr.UserId == userId)
.OrderByDescending(gr => gr.Score)
.Select(gr => new ScoreRankingViewModel()
{
Score = gr.Score,
Position = this.dbContext.GameResults
.Count(x => x.Score > gr.Score) + 1,
SubmitedAt = gr.SubmitedAt,
Username = username
})
.FirstOrDefault();
// check if the user has any records
if (userModel != null)
{
rankingModel.UsersRanks.Add(userModel);
rankingModel.UserRankIndex = rankingModel.UsersRanks.Count - 1;
}
}
}
return(rankingModel);
}
public RankingsViewPage()
{
InitializeComponent();
Items = new ObservableCollection <RankingsModel>
{
};
viewModel = new RankingsViewModel();
RankingsListGetter();
BindingContext = this.viewModel;
RankingsList.ItemsSource = Items;
}
public object GetToolView()
{
if (this.rankingsViewModel == null)
{
if (KanColleClient.Current.Homeport != null)
{
this.rankingsViewModel = new RankingsViewModel();
}
}
return(new Calculator {
DataContext = this.rankingsViewModel
});
}
public ActionResult Rankings(string sortOrder)
{
List <RankingsViewModel> TournamentsVW = new List <RankingsViewModel>();
var playerList =
db.Players.Where(p => p.StatusID == 1 && p.LeagueID == 1).Distinct();
foreach (var player in playerList)
{
RankingsViewModel tvm = new RankingsViewModel();
tvm.PlayerName = player.PlayerName;
tvm.OffenseRating = player.OffenseRating;
var playerTournamentList = player.TournamentScores.ToList();
if (playerTournamentList.Count > 0)
{
tvm.Average20PointsFor =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(20)
.Average(x => Convert.ToDouble(x.PointsFor));
tvm.Average20PointsAgainst =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(20)
.Average(x => Convert.ToDouble(x.PointsAgainst));
tvm.Average20DefenseAgainst =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(20)
.Where(ts => ts.DefenseAgainst != null)
.Average(x => Convert.ToDouble(x.DefenseAgainst));
var pf = tvm.Average20PointsFor * 580;
var da = 195 - tvm.Average20DefenseAgainst;
var pa = tvm.Average20PointsAgainst * 1.4;
tvm.Grade = pf / da - pa;
tvm.OffenseRanking35 =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(35)
.Average(x => Convert.ToDecimal(x.PointsFor));
tvm.OffenseRanking28 =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(28)
.Average(x => Convert.ToDecimal(x.PointsFor));
tvm.OffenseRanking14 =
player.TournamentScores.OrderByDescending(ts => ts.TournamentID)
.Take(14)
.Average(x => Convert.ToDecimal(x.PointsFor));
int?_offenseRating = 0;
if (player.OffenseRating.HasValue)
{
_offenseRating = player.OffenseRating;
}
//tvm.PowerRating = Convert.ToDecimal(tvm.OffenseRanking28 * 5 + _offenseRating);
//tvm.PowerRating = Convert.ToDouble((tvm.Average20PointsFor * 5) / tvm.Average20DefenseAgainst + tvm.OffenseRating);
tvm.Ladder = Convert.ToDouble((tvm.Average20PointsFor * tvm.Average20DefenseAgainst) / 20 + tvm.OffenseRating);
TournamentsVW.Add(tvm);
}
}
ViewBag.GradeSortParam = String.IsNullOrEmpty(sortOrder) ? "Grade" : "";
ViewBag.LadderSortParam = sortOrder == "Ladder" ? "Ladder_desc" : "Ladder";
switch (sortOrder)
{
case "Ladder_desc":
TournamentsVW = TournamentsVW.OrderByDescending(ts => ts.Ladder).ToList();
break;
case "Grade":
TournamentsVW = TournamentsVW.OrderBy(t => t.Grade).ToList();
break;
case "Ladder":
TournamentsVW = TournamentsVW.OrderBy(t => t.Ladder).ToList();
break;
default:
TournamentsVW = TournamentsVW.OrderByDescending(t => t.Grade).ToList();
break;
}
return(View(TournamentsVW));
}
