public async Task <IActionResult> Rankings(int choice)
{
var viewModel = new RankingViewModel();
if (choice == 0)
{
ViewData["By"] = "(Score)";
viewModel = await _authorService.GetAuthorsByScore();
viewModel.Choice = choice;
}
else if (choice == 1)
{
ViewData["By"] = "(Number Of Articles)";
viewModel = await _authorService.GetAuthorsByNumberOfArticles();
viewModel.Choice = choice;
}
else if (choice == 2)
{
ViewData["By"] = "(Number Of Commented Articles)";
viewModel = await _authorService.GetAuthorsByCommentedArticles();
viewModel.Choice = choice;
}
return(View(viewModel));
}
public async Task <IActionResult> Create(int id, RankingViewModel vm)
{
//removing userid from state to make modelstate valid
ModelState.Remove("Rank.UserId");
if (ModelState.IsValid)
{
//setting user and user id to current user
var user = await GetCurrentUserAsync();
vm.rank.UserId = user.Id;
// a new ranking level instance in view model
vm.rankingLevel = new RankingLevel();
_context.Add(vm.rank);
await _context.SaveChangesAsync();
//if the user selected one or more levels for learning materials add one or more ranking levels to database join table
if (vm.SelectedLevelId != null)
{
foreach (var rl in vm.SelectedLevelId)
{
var newRankingLevel = new RankingLevel();
newRankingLevel.RankingId = vm.rank.Id;
newRankingLevel.LevelId = rl;
_context.Add(newRankingLevel);
}
}
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "LearningMaterials"));
}
return(View(vm));
}
// GET: Rankings/Edit/5
//basically the same code as create
public async Task <IActionResult> Edit(int id)
{
if (id == 0)
{
return(NotFound());
}
RankingViewModel vm = new RankingViewModel();
vm.Levels = _context.Level.Select(i => new SelectListItem
{
Value = i.Id.ToString(),
Text = i.Name
}).ToList();
vm.rank = new Ranking();
vm.rank.LearningMaterialId = id;
vm.SelectedLevelId = _context.RankingLevel.Include(rl => rl.Level).Where(rl => rl.RankingId == vm.rank.Id).Select(rl => rl.LevelId).ToList();
vm.rank = await _context.Ranking.FindAsync(id);
if (vm.rank == null)
{
return(NotFound());
}
return(View(vm));
}
// GET: Ranking/SerieAPRO
public ActionResult SerieAPRO()
{
RankingViewModel modelReturnJSON = null;
RankingViewModel hallOfFameMode = new RankingViewModel();
setViewBagVariablesGlobal();
setViewBagVariablesForChampionship();
try
{
hallOfFameMode.actionUser = "******";
hallOfFameMode.typeMode = "PRO";
hallOfFameMode.typeChampionship = "PRO1";
modelReturnJSON = executeAPIRanking(modelReturnJSON, hallOfFameMode, "Ranking Série A PRO CLUB");
return(View(modelReturnJSON));
}
catch (Exception ex)
{
TempData["returnMessage"] = "Erro interno - Exibindo Ranking Série A PRO CLUB: (" + ex.InnerException.Message + ")";
ModelState.AddModelError("", "application error.");
hallOfFameMode.listOfRanking = new List <listRanking>();
return(View(hallOfFameMode));
}
finally
{
modelReturnJSON = null;
hallOfFameMode = null;
}
}
private RankingViewModel executeAPIRanking(RankingViewModel modelReturnJSON, RankingViewModel hallOfFameMode, string descryptionMode)
{
HttpResponseMessage response = null;
response = GlobalVariables.WebApiClient.PostAsJsonAsync("Ranking", hallOfFameMode).Result;
modelReturnJSON = response.Content.ReadAsAsync <RankingViewModel>().Result;
switch (response.StatusCode)
{
case HttpStatusCode.Created:
if (modelReturnJSON.returnMessage == "RankingSuccessfully")
{
TempData["loggedUserID"] = Session["user.id"].ToString();
return(modelReturnJSON);
}
else
{
//ModelState.AddModelError("", "Senha Atual inválida! Favor tentar novamente.");
TempData["returnMessage"] = "Ocorreu algum erro na exibição do " + descryptionMode + ". (" + modelReturnJSON.returnMessage + ")";
modelReturnJSON.listOfRanking = new List <listRanking>();
return(modelReturnJSON);
}
default:
TempData["returnMessage"] = "Ocorreu algum erro na exibição do " + descryptionMode + ". (" + response.StatusCode + ")";
ModelState.AddModelError("", "application error.");
modelReturnJSON.listOfRanking = new List <listRanking>();
return(modelReturnJSON);
}
}
// GET: Ranking/GeneralPRO
public ActionResult GeneralPRO()
{
RankingViewModel modelReturnJSON = null;
RankingViewModel hallOfFameMode = new RankingViewModel();
setViewBagVariablesGlobal();
try
{
hallOfFameMode.actionUser = "******";
hallOfFameMode.typeMode = "PRO";
hallOfFameMode.totalRecordsRanking = Convert.ToInt16(ConfigurationManager.AppSettings["ranking.total.shown"].ToString());
modelReturnJSON = executeAPIRanking(modelReturnJSON, hallOfFameMode, "Ranking Geral PRO CLUB");
return(View(modelReturnJSON));
}
catch (Exception ex)
{
TempData["returnMessage"] = "Erro interno - Exibindo Ranking Geral PRO CLUB: (" + ex.InnerException.Message + ")";
ModelState.AddModelError("", "application error.");
hallOfFameMode.listOfRanking = new List <listRanking>();
return(View(hallOfFameMode));
}
finally
{
modelReturnJSON = null;
hallOfFameMode = null;
}
}
// GET: Ranking/CurrentFUT
public ActionResult CurrentFUT()
{
RankingViewModel modelReturnJSON = null;
RankingViewModel hallOfFameMode = new RankingViewModel();
setViewBagVariablesGlobal();
try
{
hallOfFameMode.actionUser = "******";
hallOfFameMode.typeMode = "FUT";
modelReturnJSON = executeAPIRanking(modelReturnJSON, hallOfFameMode, "Ranking Atual FUT");
return(View(modelReturnJSON));
}
catch (Exception ex)
{
TempData["returnMessage"] = "Erro interno - Exibindo Ranking Atual FUT: (" + ex.InnerException.Message + ")";
ModelState.AddModelError("", "application error.");
hallOfFameMode.listOfRanking = new List <listRanking>();
return(View(hallOfFameMode));
}
finally
{
modelReturnJSON = null;
hallOfFameMode = null;
}
}
public async Task <ActionResult> Ranking()
{
RankingViewModel rankingModel = new RankingViewModel();
DriverController drivercontroller = new DriverController();
List <User> userList = new List <User>();
string cmd = $"SELECT Username,Points FROM user";
MySqlDataReader reader = dc.ReadSQL(cmd);
while (reader.Read())
{
userList.Add(new User {
Username = reader["Username"].ToString(), Points = int.Parse(reader["Points"].ToString())
});
}
dc.CloseConnection();
rankingModel.UserList = userList;
rankingModel.DriverList = await drivercontroller.DriverRanking();
rankingModel.UserList = rankingModel.UserList.OrderByDescending(P => P.Points).ToList();
return(View(rankingModel));
}
public RankingControl()
{
InitializeComponent();
// Initialize the viewModel
viewModel = DataContext as RankingViewModel;
}
public OperationResultListVo <RankingViewModel> GetAll()
{
try
{
IEnumerable <RankingVo> allModels = gamificationDomainService.Get(20);
List <RankingViewModel> vms = new List <RankingViewModel>();
foreach (RankingVo item in allModels)
{
RankingViewModel vm = new RankingViewModel
{
UserId = item.Gamification.UserId,
CurrentLevelNumber = item.Gamification.CurrentLevelNumber,
XpCurrentLevel = item.Gamification.XpCurrentLevel,
XpToNextLevel = item.Gamification.XpToNextLevel,
XpTotal = item.Gamification.XpTotal,
XpCurrentLevelMax = item.Level.XpToAchieve,
CurrentLevelName = item.Level.Name
};
vms.Add(vm);
}
return(new OperationResultListVo <RankingViewModel>(vms));
}
catch (Exception ex)
{
return(new OperationResultListVo <RankingViewModel>(ex.Message));
}
}
public async Task <IActionResult> SkillRanking(int pageNumber)
{
RankingViewModel viewModel = new RankingViewModel();
double number = (await _unitOfWork.Ratings.GetAllAsync()).Count;
number = number / ((double)RatingConstants.NumberOfItemsOnPage);
viewModel.NumberOfPages = (int)Math.Ceiling(number);
viewModel.PageNumber = pageNumber;
var ratings = await _unitOfWork.Ratings.GetUsersRankingByPageAsync(pageNumber, RatingConstants.NumberOfItemsOnPage, RatingConstants.SkillRating);
viewModel.Users = new List <User>();
viewModel.Points = new List <double>();
viewModel.WhiteSpaces = new List <string>();
foreach (var rate in ratings)
{
var user = await _unitOfWork.Users.GetByIdAsync(rate.UserId);
var nrSpaces = 50 - user.UserName.Length - rate.SkillScore.ToString().Length;
string whiteSpaces = "";
for (int i = 0; i < nrSpaces; i++)
{
whiteSpaces += " ";
}
viewModel.Users.Add(user);
viewModel.Points.Add(rate.SkillScore);
viewModel.WhiteSpaces.Add(whiteSpaces);
}
return(View(viewModel));
}
public IActionResult DeleteHighScoreEntries(RankingViewModel viewModel)
{
var content = JsonConvert.SerializeObject(viewModel.Rankings.Select(a => a.GameId));
_webserviceProvider.PostDataFromWebService <bool>(Controllers.Edit.ToString(), "DeleteHighScore", content);
return(RedirectToAction("EditHighScoreList"));
}
public IActionResult Ranking(DateTime?dataRiferimento = null)
{
var ranking = _rankingService.GetSelezione(dataRiferimento);
var model = RankingViewModel.FromEtfs(ranking);
model.Title = "Ranking";
model.Action = nameof(this.Ranking);
return(View("Ranking", model));
}
public IActionResult AllRanking(DateTime?dataRiferimento = null)
{
var ranking = _rankingService.GetAll(dataRiferimento);
var model = RankingViewModel.FromEtfs(ranking);
model.Title = "Ranking (All ETFs)";
model.Action = nameof(AllRanking);
return(View("Ranking", model));
}
public IActionResult EditHighscoreList()
{
var ranking = _webserviceProvider.GetDataFromWebService <IEnumerable <RankingModel> >(Controllers.Edit.ToString(), "Ranking");
var viewModel = new RankingViewModel
{
LoggedIn = CheckLoggedIn(),
Rankings = ranking.ToList()
};
return(View(viewModel));
}
public ActionResult Ranking()
{
RankingViewModel vmodel = new RankingViewModel();
List <Team> teamList = teamservice.GetTeams();
teamList = teamList.OrderByDescending(P => P.Points).ThenByDescending(G => G.GoalDifferential).ToList();
vmodel.TeamList = teamList;
return(View(vmodel));
}
public MainViewModel()
{
SwitchCommand = new SimpleCommand <string>(Switch);
InitPanel = new InitViewModel();
MembersPanel = new MembersPanelViewModels();
TasksPanel = new TasksPanelViewModels();
ManagmentPanel = new ManagementPanelViewModel();
rankingViewModel = new RankingViewModel();
finishedTaskView = new FinishedTaskViewModel();
CurrentPanel = InitPanel;
Notify("CurrentPanel");
}
public async Task <IHttpActionResult> Put(RankingViewModel model)
{
if (model.RankingTeams.Select(i => i.TeamId).Where(m => !String.IsNullOrEmpty(m)).Distinct().Count() != model.RankingTeams
.Where(m => !String.IsNullOrEmpty(m.TeamId))
.Select(i => i.TeamId)
.Count())
{
ModelState.AddModelError("invalidTeams", "You cannot set the same team more than once in a ranking");
return(BadRequest(ModelState));
}
await _rankingsBuilder.UpdateAsync(model);
return(Ok());
}
public ActionResult UpdateRanking(RankingViewModel ranking)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <RankingViewModel, RankingDTO>()).CreateMapper();
RankingDTO result = mapper.Map <RankingViewModel, RankingDTO>(ranking);
try
{
_rankingService.UpdateRanking(result);
return(Ok());
}
catch
{
return(StatusCode(HttpStatusCode.NoContent));
}
}
public async Task <IActionResult> Edit(int id, RankingViewModel vm)
{
//makes sure that the rank exists
if (id != vm.rank.Id)
{
return(NotFound());
}
ModelState.Remove("UserId");
if (ModelState.IsValid)
{
try
{
var user = await GetCurrentUserAsync();
vm.rank.UserId = user.Id;
_context.Update(vm.rank);
await _context.SaveChangesAsync();
if (vm.SelectedLevelId != null)
{
foreach (var rl in vm.SelectedLevelId)
{
var newRankingLevel = new RankingLevel();
newRankingLevel.RankingId = vm.rank.Id;
newRankingLevel.LevelId = rl;
_context.Update(newRankingLevel);
}
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RankingExists(vm.rank.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index", "LearningMaterials"));
}
return(View(vm));
}
public RankingViewModel GetRankingVendasByMes(int?ano)
{
try
{
var vendas = new DataAccess.VendaDataAccess().GetList();
var filter = vendas.AsEnumerable().Where(x => (ano == null || x.dtVenda.Year == ano)).ToList();
var ranking = from venda in filter
group venda by venda.dtVenda.Month into vendasGroup
select new
{
mes = vendasGroup.Key,
qtdeVendas = vendasGroup.Count(),
vendas = vendasGroup
};
ranking = ranking.OrderByDescending(x => x.qtdeVendas).ThenBy(x => x.mes);
var rankingView = new RankingViewModel();
decimal vrTotalVendas = 0;
foreach (var item in ranking)
{
var vendaGroup = item.vendas;
foreach (var itemVenda in vendaGroup)
{
var produto = new ProdutoBusiness().Get(itemVenda.idProduto);
if (produto != null)
{
var vrProduto = produto.vrProduto.Split('$')[1];
vrTotalVendas = vrTotalVendas + decimal.Parse(vrProduto);
}
}
var itemRank = new RankingModel(null, item.qtdeVendas, vrTotalVendas, DateTimeFormatInfo.CurrentInfo.GetAbbreviatedMonthName(item.mes), null);
rankingView.Ranking.Add(itemRank);
vrTotalVendas = 0;
}
return(rankingView);
}
catch (Exception e)
{
return(new RankingViewModel(e.Message));
}
}
public IActionResult Ranking()
{
var userList = new List <UserViewModel>();
var users = _context.Users.OrderByDescending(u => u.Score).Take(50);
foreach (var user in users)
{
userList.Add(new UserViewModel {
Username = user.UserName, Score = user.Score
});
}
var rankVM = new RankingViewModel {
Users = userList
};
return(View(rankVM));
}
public async Task <IActionResult> BehaviourRanking(int pageNumber)
{
RankingViewModel viewModel = new RankingViewModel();
var ratings = await _unitOfWork.Ratings.GetUsersRankingByPageAsync(pageNumber, RatingConstants.NumberOfItemsOnPage, RatingConstants.BehaviourRating);
viewModel.Users = new List <User>();
viewModel.Points = new List <double>();
foreach (var rate in ratings)
{
viewModel.Users.Add(await _unitOfWork.Users.GetByIdAsync(rate.UserId));
viewModel.Points.Add(rate.BehaviourScore);
}
return(View(viewModel));
}
// GET: Rankings/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
//creating new instance of a view model to present Count of upvotes in each category and current user's Rating
RankingViewModel vm = new RankingViewModel();
var user = await GetCurrentUserAsync();
vm.rank = await _context.Ranking
.Include(r => r.User).Where(r => r.UserId == user.Id)
.Include(r => r.learningMaterial).Include(r => r.learningMaterial.instrument).Include(r => r.learningMaterial.rankings)
.FirstOrDefaultAsync(r => r.LearningMaterialId == id);
//where the learning materials id of the ranking equals the give id parameter
vm.user = user;
//getting the correct information for the view model to have when it is presented to the user if the rank exists
if (vm.rank != null)
{
vm.rankingLevel = await _context.RankingLevel.FirstOrDefaultAsync(r => r.RankingId == vm.rank.Id);
//first i get the entries in the join table that have Correct LevelId and the ranking from join table has correct LM id and turn it into a list
var beginner = await _context.RankingLevel.Where(rl => rl.LevelId == 1 && rl.ranking.LearningMaterialId == vm.rank.LearningMaterialId).ToListAsync();
//then i get the count of the list i created and put it in the view model
vm.BeginnerCount = beginner.Count();
//i rinse and repeat this process for each category
var intermediate = await _context.RankingLevel.Where(rl => rl.LevelId == 2 && rl.ranking.LearningMaterialId == vm.rank.LearningMaterialId).ToListAsync();
vm.IntermediateCount = intermediate.Count();
var advanced = await _context.RankingLevel.Where(rl => rl.LevelId == 3 && rl.ranking.LearningMaterialId == vm.rank.LearningMaterialId).ToListAsync();
vm.AdvancedCount = advanced.Count();
var Pro = await _context.RankingLevel.Where(rl => rl.LevelId == 4 && rl.ranking.LearningMaterialId == vm.rank.LearningMaterialId).ToListAsync();
vm.ProCount = Pro.Count();
}
return(View(vm));
}
// GET: Rankings/Create
public IActionResult Create(int id)
{
//new instance of view model
RankingViewModel vm = new RankingViewModel();
// select list for each level
vm.Levels = _context.Level.Select(i => new SelectListItem
{
Value = i.Id.ToString(),
Text = i.Name
}).ToList();
//a new instance of rank
vm.rank = new Ranking();
//setting the LM id to Param
vm.rank.LearningMaterialId = id;
//selected multiselect list
vm.SelectedLevelId = _context.RankingLevel.Include(rl => rl.Level).Where(rl => rl.RankingId == vm.rank.Id).Select(rl => rl.LevelId).ToList();
return(View(vm));
}
public async Task UpdateAsync(RankingViewModel model)
{
var dbRankings = await _repo.RankingTeams.Where(m => m.RankingId == model.Id).ToListAsync();
var overallRanking = await _repo.Rankings.Where(m => m.Id == model.Id).FirstOrDefaultAsync();
foreach (var ranking in dbRankings)
{
var thisRanking = model.RankingTeams.FirstOrDefault(m => m.Id == ranking.Id);
if (thisRanking == null)
{
continue;
}
ranking.TeamId = thisRanking.TeamId;
}
overallRanking.DateModifiedUtc = DateTime.UtcNow;
await _repo.SaveAsync();
}
public async Task SetupAsync()
{
try
{
if (!_eventsSetup)
{
SetupRaceEvents();
}
_currentSkier = await _activeRaceService.GetCurrentSkier(RaceState.Race.Id);
await LoadStartList();
await CurrentSkierViewModel.InitializeAsync();
await RankingViewModel.InitializeAsync();
}
catch (Exception)
{
MessageBoxUtil.Error("Fehler beim Laden der Daten");
}
}
// GET: Ranking
public ActionResult _RankingPartial(string controllerName)
{
RankingModelViewModel model = new RankingModelViewModel();
if (Enum.TryParse(controllerName, out RankingPages ranking))
{
CRMEntities db = new CRMEntities();
model.Translations.GetTranslations(db, this.RouteData);
var pages = db.Pages.Where(p => p.NumePagina.Contains(controllerName + "Details")).ToList();
foreach (var page in pages)
{
RankingViewModel rankingViewModel = new RankingViewModel();
rankingViewModel.Id = int.Parse(new String(page.NumePagina.Where(char.IsDigit).ToArray()));
rankingViewModel.Nume = GetName(db, ranking, rankingViewModel.Id);
rankingViewModel.NumarAccesari = page.NumarAccesari;
rankingViewModel.ControllerName = controllerName;
model.RankingViewModels.Add(rankingViewModel);
}
model.RankingViewModels = model.RankingViewModels.OrderByDescending(r => r.NumarAccesari).ToList();
}
return(PartialView(model));
}
public ActionResult Ranking()
{
List <score> scoreListStandard = new List <score>();
List <score> scoreListReverse = new List <score>();
List <score> scoreListExtreme = new List <score>();
using (DBModels dbModel = new DBModels())
{
scoreListStandard = dbModel.scores.Where(x => x.mode == 1).OrderBy(x => x.time).ToList <score>(); //OrderBy(x => x.time).ToList<score>();
scoreListReverse = dbModel.scores.Where(x => x.mode == 2).OrderBy(x => x.time).ToList <score>();
scoreListExtreme = dbModel.scores.Where(x => x.mode == 3).OrderBy(x => x.time).ToList <score>();
}
var viewModel = new RankingViewModel
{
RankingsStandard = scoreListStandard,
RankingsReverse = scoreListReverse,
RankingsExtreme = scoreListExtreme
};
return(View(viewModel));
}
public RankingViewModel GetRankingProdutosByPeriodo(DateTime dtInicial, DateTime dtFinal)
{
try
{
var vendas = new DataAccess.VendaDataAccess().GetList();
var filter = vendas.AsEnumerable().Where(x => x.dtVenda >= dtInicial && x.dtVenda <= dtFinal).ToList();
var ranking = from venda in filter
group venda by venda.idProduto into vendasGroup
select new
{
idProduto = vendasGroup.Key,
qtdeVendas = vendasGroup.Count(),
};
ranking = ranking.OrderByDescending(x => x.qtdeVendas);
var rankingView = new RankingViewModel();
foreach (var item in ranking)
{
var produto = new ProdutoBusiness().Get(item.idProduto);
if (produto != null)
{
var vrProduto = produto.vrProduto.Split('$')[1];
var itemRank = new RankingModel(produto.nmProduto, item.qtdeVendas, decimal.Parse(vrProduto) * item.qtdeVendas, null, null);
rankingView.Ranking.Add(itemRank);
}
}
return(rankingView);
}
catch (Exception e)
{
return(new RankingViewModel(e.Message));
}
}
