public ActionResult UserIndex()
{
var currentUserId = User.Identity.GetUserId();
var user = db.Users.Where(i => i.Id == currentUserId).First();
if (user.CompanyId != null)
{
var udvm = new UserDashboardViewModel();
udvm.AvailableSkills = db.Skills.Where(x => x.CompanyId == user.CompanyId).Select(x => new SelectListItem {
Value = x.SkillId.ToString(), Text = x.Name
});
udvm.AvailableLevels = db.SkillLevels.Select(x => new SelectListItem {
Value = x.SkillLevelId.ToString(), Text = x.SkillMastery
});
udvm.Employees = db.Users.Where(x => x.CompanyId == user.CompanyId).ToList();
// = from t in db.UserSkillLevels where t.UserId == CurrentUserId select t;
var CurrentSkills = db.UserSkillLevels.Where(i => i.UserId == currentUserId).ToList();
udvm.SkillsForFocus = db.Skills.Where(x => x.CompanyId == user.CompanyId).ToList();
udvm.UserCurrentSkills = CurrentSkills.ToList();
udvm.Focus = db.Foci.Where(x => x.UserId == currentUserId);
udvm.Company = db.Companies.Where(x => x.CompanyId == user.CompanyId).First();
if (user.Admin)
{
udvm.IsAdmin = true;
}
//uslvm.CurrentSkills = db.UserSkillLevels.Where(x => x.UserId == User.Identity.GetUserId().Select());
return(View(udvm));
}
return(RedirectToAction("JoinOrCreateCompany"));
}
public UserDashboardViewModel GetActivitiesByDate(DateTime date)
{
var umbracoRepository = new UmbracoRepository();
var userDashboardViewModel = new UserDashboardViewModel();
//if this date then get first date
if (date.ToString("yyyy-MM-dd") == "1987-05-10")
{
var userActivitiesDate = umbracoRepository.GetAvailableDates();
date = userActivitiesDate.ToArray()[0];
}
var userActivities = umbracoRepository.GetUserActivities(date).ToArray();
foreach (var userActivityItem in userActivities)
{
var useractViewObj = new UserActivitiesViewModel(userActivityItem.Datestamp)
{
NodeId = userActivityItem.NodeId,
LogComment = userActivityItem.LogComment,
LogHeader = userActivityItem.LogHeader,
Text = userActivityItem.Text,
Username = userActivityItem.Username,
UserTypeAlias = userActivityItem.UserTypeAlias
};
userDashboardViewModel.UsersActivitiesLog.Add(useractViewObj);
}
return(userDashboardViewModel);
}
public ActionResult Dashboard()
{
var objEntity = new UserDashboardViewModel();
var objStudent2Repository = new Student2Repository();
#region RecentMembersDashboard
objEntity.Student2RecentMembersList = objStudent2Repository.Select(StudentFlags.SelectAllByRecentMembers.GetHashCode(), new Student2ViewModel()
{
CreatedBy = 1 //Admin UserId or login UserId
});
#endregion
#region RecentActiveMembersDashboard
objEntity.Student2RecentActiveMembersList = objStudent2Repository.Select(StudentFlags.SelectAllByRecentActiveMembers.GetHashCode(), new Student2ViewModel()
{
CreatedBy = 1 //Admin UserId or login UserId
});
#endregion
if (objEntity.Student2RecentMembersList.Count == 0)
{
// this.Flash("Warning", string.Format(@"Your search returns {0} result(s)", 0));
//flash message
}
return(View(objEntity));
}
public IHttpActionResult GetUserDashboard()
{
var userId = userClaims.GetUserClaims((ClaimsIdentity)User.Identity);
UserDashboardViewModel response = userDashboard.UserDashboardSummary(userId);
return(Ok(response));
}
//public IActionResult TryLoginOrCreate(UserDAL user, UserDashboardViewModel model)
//{
// var thisUser = TryLookUpUser(user.EmailAddress, user.Password);
// model.EmailAddress = thisUser.EmailAddress;
// return View("UserDashboard");
//}
public IActionResult UserDashboard(UserDashboardViewModel model)
{
// TODO look up to see if old account exists
var newUser = new User();
newUser.EmailAddress = model.EmailAddress;
model.ToDoItems = ConvertDALToBasic();
return(View(model));
}
public IActionResult TryDeleteItem(int itemID, UserDashboardViewModel model)
{
_toDoListContext.Remove(_toDoListContext.ToDoItems.Find(itemID));
_toDoListContext.SaveChanges();
model.ToDoItems = ConvertDALToBasic();
return(View("UserDashboard", model));
}
public IActionResult TryCompleteItem(int itemID, UserDashboardViewModel model)
{
var thisItem = _toDoListContext.ToDoItems.Find(itemID);
thisItem.IsCompleted = !thisItem.IsCompleted;
_toDoListContext.SaveChanges();
model.ToDoItems = ConvertDALToBasic();
return(View("UserDashboard", model));
}
public IActionResult DeleteItem(UserDashboardViewModel model, int toDoID)
{
foreach (var item in model.ToDoItems)
{
if (item.ID == toDoID)
{
model.ToDoItems.Remove(item);
}
}
return(View("UserDashboard"));
}
public ActionResult Dashboard()
{
UserDashboardViewModel viewModel = new UserDashboardViewModel();
viewModel.User = unitOfWork.UserRepository.GetByID(User.Identity.GetUserId());
if (User.IsInRole(RolesConst.ADMIN) || User.IsInRole(RolesConst.MANAGER))
{
viewModel.OrdersToBeApproved = unitOfWork.OrderRepository.dbSet.Where(o => o.OrderStatus == OrderStatus.Initiating).ToList();
}
return(View(viewModel));
}
//public UserDAL TryLookUpUser(string emailAddress, string password)
//{
// var listOfUsers = _toDoListContext.Users;
// foreach (var nUser in listOfUsers)
// {
// if (nUser.EmailAddress == emailAddress && nUser.Password == password)
// {
// return nUser;
// }
// };
// return new UserDAL();
//}
public IActionResult TryCreateItem(ToDo item, UserDashboardViewModel model)
{
var newItem = new ToDoDAL();
newItem.Description = item.Description;
newItem.DueDate = item.DueDate;
_toDoListContext.ToDoItems.Add(newItem);
_toDoListContext.SaveChanges();
model.ToDoItems = ConvertDALToBasic();
return(View("UserDashboard", model));
}
public IActionResult UserDashboard()
{
int userId = int.Parse(_userService.GetUserId(User));
var totalMoney = _dashboardService.GetTotalMoneyByCurrencyForUser(userId);
var model = new UserDashboardViewModel
{
TotalMoneyByCurrency = new UserTotalMoneyByCurrencyChart
{
JsonData = JsonConvert.SerializeObject(totalMoney)
}
};
return(View(model));
}
// This method return an object that returns total jobs applied, approved and rejected
public UserDashboardViewModel UserDashboardSummary(int userId)
{
var userApplications = db.JobApplications.Where(x => x.UserId == userId).ToList();
var totalJobs = userApplications.Count();
var totalApproved = userApplications.Where(x => x.Status == 3).Count();
var totalRejected = userApplications.Where(x => x.Status == 2).Count();
UserDashboardViewModel model = new UserDashboardViewModel
{
TotalJobs = totalJobs,
TotalApproved = totalApproved,
TotalRejected = totalRejected
};
return(model);
}
/* Save or Update User Dashboard */
public async Task <IEnumerable <dynamic> > SaveorUpdate(UserDashboardViewModel udvm)
{
string sql = "dbo.EAppSaveUserDashboard";
using (var conn = util.MasterCon())
{
try
{
return(await(conn.QueryAsync <dynamic>(sql, new { udvm.UserDashboardId, udvm.WidgetId, udvm.UserId, udvm.XAxis, udvm.YAxis, udvm.WRow, udvm.WColumn, udvm.DataViewPrefId, udvm.Param1, udvm.Param2, udvm.Param3, udvm.Param4, udvm.Param5, udvm.Active }, commandType: CommandType.StoredProcedure)));
}
catch (Exception ex)
{
throw new CustomException("Unable to Load Data, Please Contact Support!!!", "Error", true, ex);
}
}
}
public IEnumerable <string> GetAvailableDates()
{
var umbracoRepository = new UmbracoRepository();
var userDashboardViewModel = new UserDashboardViewModel();
var userActivitiesDate = umbracoRepository.GetAvailableDates().ToArray();
IList <string> itemTransform = new List <string>();
foreach (DateTime date in userActivitiesDate)
{
itemTransform.Add(date.ToString("yyyy-MM-dd"));
}
return(itemTransform);
}
public ActionResult UserAddSkill(UserDashboardViewModel model)
{
var currentUserId = User.Identity.GetUserId();
var currentUserSkills = db.UserSkillLevels.Where(x => x.UserId == currentUserId).ToList();
foreach (var skill in currentUserSkills)
{
if (model.SelectedSkill == skill.SkillId)
{
return(RedirectToAction("UserIndex", "Home"));
}
}
db.UserSkillLevels.Add(new UserSkillLevels {
UserId = currentUserId, SkillId = model.SelectedSkill, SkillLevelId = model.SelectedLevel
});
db.SaveChanges();
return(RedirectToAction("UserIndex", "Home"));
}
public async Task <IActionResult> Index()
{
var userId = this.GetUserId <string>();
var language = this.GetCurrentLanguage();
var countOfExpenses = 5;
var lastExpenses = await this.expenseService.NewestByUserIdLocalized <ExpenseViewModel>(userId, language, countOfExpenses);
var fundsSum = await this.componentsService.AmountSumOfActiveComponentsByTypeAndUserId(userId, ComponentTypes.PaymentComponent);
var savingsSum = await this.componentsService.AmountSumOfActiveComponentsByTypeAndUserId(userId, ComponentTypes.SavingsComponent);
var viewModel = new UserDashboardViewModel
{
FundsAmount = fundsSum,
SavingsAmount = savingsSum,
Expenses = lastExpenses
};
return(this.View(viewModel));
}
public ActionResult Dashboard(Guid?id)
{
var ownerId = id != null && id != Guid.Empty && User.IsInRole("Admin") ? id.Value : UserId;
var views = ApplicationManager.BuildViews();
var user = views.Users.GetById(ownerId);
var userIds = new List <Guid> {
user.Id
};
userIds.AddRange(user.FollowingUserIds);
var model = new UserDashboardViewModel()
{
ProfileSummary = user.ProfileSummary,
Profiles = views.Profiles.GetLatestSummaries(userIds.ToArray(), 0, 20)
};
return(View(model));
}
private ApiResponse <UserDashboardViewModel> GetDashboard()
{
var apiResp = new ApiResponse <UserDashboardViewModel>
{
Type = ResponseType.Fail,
};
var resp = _dashboardBusiness.GetUserDashboard(GetUserId().Value);
var data = new UserDashboardViewModel
{
TransactionCount = resp.TransactionCount,
CustomerCount = resp.Customers.Count,
CustomerDebtsTotal = resp.CustomerDebtsTotal,
CustomerReceivablesTotal = resp.CustomerReceivablesTotal,
LastUpdatedAt = resp.LastUpdatedAt
};
apiResp.Data = data;
apiResp.Type = ResponseType.Success;
return(apiResp);
}
public ActionResult Index()
{
ApplicationDbContext db = new ApplicationDbContext();
UserDashboardViewModel model = new UserDashboardViewModel();
ProjectsHelper projectsHelper = new ProjectsHelper();
var allProj = db.Projects.ToList();
var userId = User.Identity.GetUserId();
foreach (var proj in allProj)
{
//if (projectsHelper.IsUserOnProject(userId, proj.Id))
//{
CompletedViewModel thisModel = new CompletedViewModel();
var compTicket = db.Tickets.Where(t => t.ProjectId == proj.Id && t.TicketStatus.Name == "Completed").ToList().Count();
var totTicket = db.Tickets.Where(t => t.ProjectId == proj.Id).ToList().Count();
thisModel.Project = proj;
thisModel.CompletedTickets = compTicket;
thisModel.TotalTickets = totTicket;
thisModel.PercentComplete = totTicket == 0 ? 0 : (int)(((double)compTicket / totTicket) * 100);
model.CompTickets.Add(thisModel);
//}
}
model.Urgent = db.Tickets.Where(t => t.TicketPriority.Name.Contains("Urgent")).Count();
model.High = db.Tickets.Where(t => t.TicketPriority.Name.Contains("High")).Count();
model.Medium = db.Tickets.Where(t => t.TicketPriority.Name.Contains("Medium")).Count();
model.Low = db.Tickets.Where(t => t.TicketPriority.Name.Contains("Low")).Count();
model.New = db.Tickets.Where(t => t.TicketStatus.Name.Contains("New")).Count();
model.OnHold = db.Tickets.Where(t => t.TicketStatus.Name.Contains("On Hold")).Count();
model.InProgress = db.Tickets.Where(t => t.TicketStatus.Name.Contains("In Progress")).Count();
model.Completed = db.Tickets.Where(t => t.TicketStatus.Name.Contains("Completed")).Count();
model.ProductionFix = db.Tickets.Where(t => t.TicketType.Name.Contains("Production Fix")).Count();
model.ProductionTask = db.Tickets.Where(t => t.TicketType.Name.Contains("Production Task")).Count();
model.SoftwareUpdate = db.Tickets.Where(t => t.TicketType.Name.Contains("Software Update")).Count();
if (User.IsInRole("Admin"))
{
model.Urgent = db.Tickets.Where(t => t.TicketPriority.Name.Contains("Urgent")).Count();
model.New = db.Tickets.Where(t => t.TicketStatus.Name.Contains("New")).Count();
model.OnHold = db.Tickets.Where(t => t.TicketStatus.Name.Contains("On Hold")).Count();
model.NewUsers = db.Users.Where(u => u.Roles.Count() == 0).ToList();
model.Projects = db.Projects.ToList();
}
else if (User.IsInRole("ProjectManager"))
{
var projects = db.Projects.Where(p => p.ProjectManagerId == userId).ToList();
var tickets = projects.SelectMany(t => t.Tickets).ToList();
model.Urgent = tickets.Where(t => t.TicketPriority.Name.Contains("Urgent")).Count();
model.New = db.TicketStatuses.Where(t => t.Name.Contains("New")).Count();
model.OnHold = db.TicketStatuses.Where(t => t.Name.Contains("On Hold")).Count();
model.InProgress = db.TicketStatuses.Where(t => t.Name.Contains("In Progress")).Count();
model.Projects = projects;
}
else if (User.IsInRole("Developer"))
{
var user = db.Users.Find(userId);
var projects = user.Projects.ToList();
var tickets = db.Tickets.Where(t => t.AssignedToUserId == userId).ToList();
model.Urgent = tickets.Where(t => t.TicketPriority.Name.Contains("Urgent")).Count();
model.New = tickets.Where(t => t.TicketStatus.Name.Contains("New")).Count();
model.InProgress = tickets.Where(t => t.TicketStatus.Name.Contains("InProgress")).Count();
model.AllTickets = tickets.Count();
model.Projects = projects;
}
else if (User.IsInRole("Submitter"))
{
var user = db.Users.Find(userId);
var projects = user.Projects.ToList();
var tickets = db.Tickets.Where(t => t.OwnerUserId == userId);
model.Completed = tickets.Where(t => t.TicketPriority.Name.Contains("Completed")).Count();
model.AllTickets = tickets.Count();
model.Projects = projects;
}
return(View(model));
}
public async Task <UserDashboardViewModel> GetUserDashboardAsync(int hoarderID)
{
// TODO: Split into separate methods for each section of the dashboard?
var recentlyStartedPlaythroughs = await playthroughDbService.GetUserRecentlyStartedPlaythroughsAsync(hoarderID);
var recentlyFinishedPlaythroughs = await playthroughDbService.GetUserRecentlyFinishedPlaythroughsAsync(hoarderID);
var recentJournalEntries = await journalDbService.GetRecentJournalEntriesAsync(hoarderID);
var recentEvents = CreateRecentEventsList(recentlyStartedPlaythroughs, recentlyFinishedPlaythroughs, recentJournalEntries);
var totalPlayTime = await playDataDbService.CountUserTotalPlaytimeAsync(hoarderID);
var numberOfOwnedGames = await playDataDbService.CountUserOwnedGamesAsync(hoarderID);
var numberOfDroppedGames = await playDataDbService.CountUserDroppedGamesAsync(hoarderID);
var numberOfWishlistItems = await wishlistDbService.CountUserWishlistItemsAsync(hoarderID);
var userDashboardVM = new UserDashboardViewModel
{
TotalPlaytime = PlaytimeHelper.GetLongPlaytimeString(totalPlayTime),
NumberOfOwnedGames = numberOfOwnedGames.ToString(),
NumberOfDroppedGames = numberOfDroppedGames.ToString(),
NumberOfWishlistItems = numberOfWishlistItems.ToString(),
RecentEvents = recentEvents
};
var currentPlaythroughs = await playthroughDbService.GetUserCurrentPlaythroughsAsync(hoarderID);
foreach (var pt in currentPlaythroughs)
{
userDashboardVM.CurrentGames.Add(UserDashboardMapper.ToGameViewModel(pt));
}
int finishedGamesTotal = 0;
int playedGamesTotal = 0;
int unplayedGamesTotal = 0;
int droppedGamesTotal = 0;
var platforms = await platformDbService.GetAllAsync();
foreach (var platform in platforms)
{
int platformID = platform.ID;
var platformStatisticsVM = UserDashboardMapper.ToPlatformStatisticsViewModel(platform);
int finishedGames = await playDataDbService.CountUserFinishedGamesByPlatformAsync(hoarderID, platformID);
int playedGames = await playDataDbService.CountUserPlayedGamesByPlatformAsync(hoarderID, platformID);
int unplayedGames = await playDataDbService.CountUserUnplayedGamesByPlatformAsync(hoarderID, platformID);
int droppedGames = await playDataDbService.CountUserDroppedGamesByPlatformAsync(hoarderID, platformID);
int totalGames = finishedGames + playedGames + unplayedGames + droppedGames;
if (totalGames > 0)
{
int finishedGamesPercentage = CalculatePercentage(totalGames, finishedGames);
int playedGamesPercentage = CalculatePercentage(totalGames, playedGames);
int unplayedGamesPercentage = CalculatePercentage(totalGames, unplayedGames);
int droppedGamesPercentage = CalculatePercentage(totalGames, droppedGames);
platformStatisticsVM.TotalGamesOwned = totalGames.ToString();
platformStatisticsVM.FinishedGames = finishedGames.ToString();
platformStatisticsVM.FinishedGamesPercentage = finishedGamesPercentage;
platformStatisticsVM.PlayedGames = playedGames.ToString();
platformStatisticsVM.PlayedGamesPercentage = playedGamesPercentage;
platformStatisticsVM.UnplayedGames = unplayedGames.ToString();
platformStatisticsVM.UnplayedGamesPercentage = unplayedGamesPercentage;
platformStatisticsVM.DroppedGames = droppedGames.ToString();
platformStatisticsVM.DroppedGamesPercentage = droppedGamesPercentage;
userDashboardVM.PlatformStatistics.Add(platformStatisticsVM);
finishedGamesTotal += finishedGames;
playedGamesTotal += playedGames;
unplayedGamesTotal += unplayedGames;
droppedGamesTotal += droppedGames;
}
}
int totalFinishedGamesPercentage = CalculatePercentage(numberOfOwnedGames, finishedGamesTotal);
int totalPlayedGamesPercentage = CalculatePercentage(numberOfOwnedGames, playedGamesTotal);
int totalUnplayedGamesPercentage = CalculatePercentage(numberOfOwnedGames, unplayedGamesTotal);
int totalDroppedGamesPercentage = CalculatePercentage(numberOfOwnedGames, droppedGamesTotal);
userDashboardVM.TotalGamesFinished = finishedGamesTotal.ToString();
userDashboardVM.TotalGamesFinishedPercentage = totalFinishedGamesPercentage;
userDashboardVM.TotalGamesPlayed = playedGamesTotal.ToString();
userDashboardVM.TotalGamesPlayedPercentage = totalPlayedGamesPercentage;
userDashboardVM.TotalGamesUnplayed = unplayedGamesTotal.ToString();
userDashboardVM.TotalGamesUnplayedPercentage = totalUnplayedGamesPercentage;
userDashboardVM.TotalGamesDropped = droppedGamesTotal.ToString();
userDashboardVM.TotalGamesDroppedPercentage = totalDroppedGamesPercentage;
return(userDashboardVM);
}
public ActionResult UserDashBoard()
{
var userVM = new UserDashboardViewModel(GetCurrentUser(), _db);
return(View(userVM));
}
