public IActionResult New()
{
OperationResultVo serviceResult = translationAppService.GenerateNew(CurrentUserId);
if (serviceResult.Success)
{
OperationResultVo <LocalizationViewModel> castResult = serviceResult as OperationResultVo <LocalizationViewModel>;
LocalizationViewModel model = castResult.Value;
SetLocalization(model, true);
OperationResultVo gamesResult = translationAppService.GetMyUntranslatedGames(CurrentUserId);
if (gamesResult.Success)
{
OperationResultListVo <SelectListItemVo> castResultGames = gamesResult as OperationResultListVo <SelectListItemVo>;
IEnumerable <SelectListItemVo> games = castResultGames.Value;
List <SelectListItem> gamesDropDown = games.ToSelectList();
ViewBag.UserGames = gamesDropDown;
}
else
{
ViewBag.UserGames = new List <SelectListItem>();
}
return(View("CreateEditWrapper", model));
}
else
{
return(View("CreateEditWrapper", new LocalizationViewModel()));
}
}
public PartialViewResult List(Guid?employerId)
{
IEnumerable <JobPositionViewModel> model;
OperationResultVo serviceResult;
if (employerId.HasValue)
{
ViewData["ListDescription"] = "These are the job positions you posted.";
serviceResult = jobPositionAppService.GetAllMine(employerId.Value);
}
else
{
ViewData["ListDescription"] = "Here you can see the currently available job positions.";
serviceResult = jobPositionAppService.GetAllAvailable(CurrentUserId);
}
if (serviceResult != null && serviceResult.Success)
{
OperationResultListVo <JobPositionViewModel> castResult = serviceResult as OperationResultListVo <JobPositionViewModel>;
model = castResult.Value;
}
else
{
model = new List <JobPositionViewModel>();
}
foreach (JobPositionViewModel item in model)
{
SetLocalization(item);
}
return(PartialView("_List", model));
}
public async Task <PartialViewResult> List()
{
List <GamificationLevelViewModel> model;
OperationResultVo serviceResult = gamificationLevelAppService.GetAll(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <GamificationLevelViewModel> castResult = serviceResult as OperationResultListVo <GamificationLevelViewModel>;
model = castResult.Value.OrderBy(x => x.Number).ToList();
}
else
{
model = new List <GamificationLevelViewModel>();
}
foreach (GamificationLevelViewModel item in model)
{
await SetPermissions(item);
}
ViewData["ListDescription"] = SharedLocalizer["All Gamification Levels"].ToString();
return(PartialView("_ListGamificationLevels", model));
}
public async Task <IActionResult> Edit(Guid userId)
{
ProfileViewModel vm = await profileAppService.GetByUserId(userId, ProfileType.Personal, true);
OperationResultVo countriesResult = profileAppService.GetCountries(CurrentUserId);
if (countriesResult.Success)
{
OperationResultListVo <SelectListItemVo> castResultCountries = countriesResult as OperationResultListVo <SelectListItemVo>;
IEnumerable <SelectListItemVo> countries = castResultCountries.Value;
List <SelectListItem> countriesDropDown = countries.ToSelectList();
if (!string.IsNullOrWhiteSpace(vm.Country))
{
countriesDropDown.ForEach(x => x.Selected = x.Value.Equals(vm.Country));
}
ViewBag.Countries = countriesDropDown;
}
else
{
ViewBag.Countries = new List <SelectListItem>();
}
return(View(vm));
}
public async Task <PartialViewResult> ListMine([FromServices] IMediator mediator)
{
List <NotificationItemViewModel> model;
OperationResultVo serviceResult = await mediator.Send(new ListUserNotificationsRequest(CurrentUserId));
if (serviceResult.Success)
{
OperationResultListVo <NotificationItemViewModel> castResult = serviceResult as OperationResultListVo <NotificationItemViewModel>;
model = castResult.Value.ToList();
foreach (NotificationItemViewModel item in model)
{
item.FormatDisplay(SharedLocalizer, Url);
}
}
else
{
model = new List <NotificationItemViewModel>();
}
ViewData["ListDescription"] = SharedLocalizer["Sent to me"].ToString();
return(PartialView("_ListNotifications", model));
}
public PartialViewResult ListMine()
{
IEnumerable <LocalizationViewModel> model;
OperationResultVo serviceResult;
serviceResult = translationAppService.GetByUserId(CurrentUserId, CurrentUserId);
if (serviceResult != null && serviceResult.Success)
{
OperationResultListVo <LocalizationViewModel> castResult = serviceResult as OperationResultListVo <LocalizationViewModel>;
model = castResult.Value;
}
else
{
model = new List <LocalizationViewModel>();
}
foreach (LocalizationViewModel item in model)
{
SetLocalization(item);
}
ViewData["ListDescription"] = SharedLocalizer["These are translation projects available to help."].ToString();
return(PartialView("_ListByUser", model));
}
public async Task <PartialViewResult> ListPlansForEdit(Guid courseId)
{
ViewData["ListDescription"] = SharedLocalizer["Study Plans"].ToString();
List <StudyCourseListItemVo> model = new List <StudyCourseListItemVo>();
try
{
OperationResultVo result = await studyAppService.GetPlans(CurrentUserId, courseId);
if (result.Success)
{
OperationResultListVo <StudyPlanViewModel> castResult = result as OperationResultListVo <StudyPlanViewModel>;
return(PartialView("_ListPlansForEdit", castResult.Value));
}
else
{
return(PartialView("_ListPlansForEdit", model));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(PartialView("_ListPlansForEdit", model));
}
}
public PartialViewResult ListByMe()
{
List <GiveawayListItemVo> model;
OperationResultVo serviceResult = giveawayAppService.GetGiveawaysByMe(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <GiveawayListItemVo> castResult = serviceResult as OperationResultListVo <GiveawayListItemVo>;
model = castResult.Value.ToList();
}
else
{
model = new List <GiveawayListItemVo>();
}
foreach (GiveawayListItemVo item in model)
{
SetLocalization(item);
}
ViewData["ListDescription"] = SharedLocalizer["My Giveaways"].ToString();
return(PartialView("_ListGiveaways", model));
}
public async Task <IViewComponentResult> InvokeAsync(int qtd)
{
OperationResultVo serviceResult = await Mediator.Send(new ListUserNotificationsRequest(CurrentUserId, qtd));
if (!serviceResult.Success)
{
ViewData["UnreadCount"] = 0;
return(View(new List <NotificationItemViewModel>()));
}
else
{
OperationResultListVo <NotificationItemViewModel> castResult = serviceResult as OperationResultListVo <NotificationItemViewModel>;
List <NotificationItemViewModel> model = castResult.Value.ToList();
foreach (NotificationItemViewModel item in model)
{
item.FormatDisplay(SharedLocalizer, Url);
}
ViewData["UnreadCount"] = model.Count(x => !x.IsRead);
return(await Task.Run(() => View(model)));
}
}
public async Task <IActionResult> FixUserInconcistencies()
{
List <string> messages = new List <string>();
OperationResultListVo <string> result = new OperationResultListVo <string>(messages)
{
Message = "Update Handlers Task"
};
try
{
IQueryable <ApplicationUser> allUsers = await GetUsersAsync();
OperationResultListVo <ProfileViewModel> profileResult = ProfileAppService.GetAll(CurrentUserId, true);
if (!profileResult.Success)
{
return(View("TaskResult", profileResult));
}
IQueryable <ApplicationUser> usersWithoutDate = allUsers.Where(x => x.CreateDate == DateTime.MinValue);
foreach (ApplicationUser user in usersWithoutDate)
{
ProfileViewModel profile = profileResult.Value.FirstOrDefault(x => x.UserId.ToString().Equals(user.Id));
if (profile != null)
{
user.CreateDate = profile.CreateDate;
await UserManager.UpdateAsync(user);
}
}
foreach (ProfileViewModel profile in profileResult.Value)
{
ApplicationUser user = allUsers.FirstOrDefault(x => x.Id.Equals(profile.UserId.ToString()));
if (user == null)
{
messages.Add($"ERROR: user for {profile.Handler} ({profile.UserId}) NOT FOUND");
}
else
{
string handler = user.UserName.ToLower();
if (string.IsNullOrWhiteSpace(profile.Handler) || !profile.Handler.Equals(handler))
{
profile.Handler = handler;
OperationResultVo <Guid> saveResult = ProfileAppService.Save(CurrentUserId, profile);
messages.Add($"SUCCESS: {profile.Name} handler updated to \"{handler}\"");
}
}
}
}
catch (Exception ex)
{
result.Success = false;
messages.Add("ERROR: " + ex.Message);
}
result.Value = messages.OrderBy(x => x);
return(View("TaskResult", result));
}
public IActionResult List()
{
OperationResultListVo <ProfileViewModel> serviceResult = profileAppService.GetAll(CurrentUserId);
List <ProfileViewModel> profiles = serviceResult.Value.OrderByDescending(x => x.CreateDate).ToList();
return(View(profiles));
}
public IActionResult List()
{
OperationResultListVo <TeamViewModel> serviceResult = teamAppService.GetNotSingleMemberGroups(CurrentUserId);
List <TeamViewModel> model = serviceResult.Value.ToList();
return(PartialView("_List", model));
}
public PartialViewResult List(Guid sessionId)
{
OperationResultListVo <BrainstormIdeaViewModel> serviceResult = brainstormAppService.GetAllBySessionId(CurrentUserId, sessionId);
IEnumerable <BrainstormIdeaViewModel> items = serviceResult.Value;
return(PartialView("_List", items));
}
public async Task <OperationResultVo> Handle(ListUserNotificationsRequest request, CancellationToken cancellationToken)
{
if (request.Quantity == 0)
{
request.Quantity = 10;
}
OperationResultListVo <NotificationItemViewModel> result = notificationAppService.GetByUserId(request.UserId, request.Quantity);
return(result);
}
public IActionResult SearchPosts(string q)
{
if (string.IsNullOrWhiteSpace(q))
{
return(View("_SearchPostsResult", new UserContentSearchViewModel()));
}
else
{
OperationResultListVo <UserContentSearchViewModel> result = userContentAppService.Search(CurrentUserId, q);
return(View("_SearchPostsResult", result.Value));
}
}
public IActionResult ListByUser(Guid userId)
{
OperationResultListVo <TeamViewModel> serviceResult = (OperationResultListVo <TeamViewModel>)teamAppService.GetByUserId(userId);
List <TeamViewModel> model = serviceResult.Value.ToList();
foreach (TeamViewModel team in model)
{
team.Permissions.CanEdit = team.Permissions.CanDelete = false;
}
return(PartialView("_List", model));
}
private void SetMyTeamsSelectList()
{
OperationResultVo teamResult = teamAppService.GetSelectListByUserId(CurrentUserId);
if (teamResult.Success)
{
OperationResultListVo <SelectListItemVo> result = (OperationResultListVo <SelectListItemVo>)teamResult;
List <SelectListItemVo> items = result.Value.ToList();
items.Add(new SelectListItemVo(SharedLocalizer["Create a new team (you can edit it later)"], Guid.Empty.ToString()));
SelectList selectList = new SelectList(items, "Value", "Text");
ViewData["MyTeams"] = selectList;
}
}
public IActionResult ListMyTeams()
{
OperationResultVo serviceResult = teamAppService.GetSelectListByUserId(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <SelectListItemVo> castResult = serviceResult as OperationResultListVo <SelectListItemVo>;
List <SelectListItemVo> model = castResult.Value.ToList();
return(PartialView("_ListMine", model));
}
else
{
return(null);
}
}
public IActionResult Index()
{
OperationResultVo gamesResult = translationAppService.GetMyUntranslatedGames(CurrentUserId);
if (gamesResult.Success)
{
OperationResultListVo <SelectListItemVo> castResultGames = gamesResult as OperationResultListVo <SelectListItemVo>;
IEnumerable <SelectListItemVo> games = castResultGames.Value;
ViewData["CanRequest"] = games.Any();
}
else
{
ViewData["CanRequest"] = false;
}
return(View());
}
public IActionResult Index(Guid?id)
{
BrainstormSessionViewModel currentSession;
OperationResultListVo <BrainstormSessionViewModel> sessions = brainstormAppService.GetSessions(CurrentUserId);
ViewData["Sessions"] = sessions.Value;
if (id.HasValue && id.Value != Guid.Empty && sessions.Value.Any(x => x.Id == id))
{
currentSession = sessions.Value.FirstOrDefault(x => x.Id == id.Value);
}
else
{
currentSession = sessions.Value.FirstOrDefault(x => x.Type == BrainstormSessionType.Main);
}
return(View(currentSession));
}
public OperationResultListVo <ArquivoViewModel> GetAll()
{
OperationResultListVo <ArquivoViewModel> result;
try
{
IQueryable <Arquivo> allModels = _repository.GetAll();
IEnumerable <ArquivoViewModel> vms = _mapper.Map <IEnumerable <Arquivo>, IEnumerable <ArquivoViewModel> >(allModels);
result = new OperationResultListVo <ArquivoViewModel>(vms);
}
catch (Exception ex)
{
result = new OperationResultListVo <ArquivoViewModel>(ex.Message);
}
return(result);
}
public PartialViewResult MyApplications()
{
List <JobPositionApplicationVo> model;
OperationResultVo serviceResult = jobPositionAppService.GetMyApplications(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <JobPositionApplicationVo> castResult = serviceResult as OperationResultListVo <JobPositionApplicationVo>;
model = castResult.Value.ToList();
}
else
{
model = new List <JobPositionApplicationVo>();
}
return(PartialView("_MyApplications", model));
}
private List <string> GetDetailUrls(Type controller, OperationResultVo result, string patternUrl)
{
List <string> methodList = new List <string>();
if (result.Success)
{
OperationResultListVo <Guid> castResult = result as OperationResultListVo <Guid>;
foreach (Guid userId in castResult.Value)
{
string route = string.Format(patternUrl, userId.ToString());
string sitemapItem = CheckMethod(controller, "details", false, false, false, true, route);
methodList.Add(sitemapItem);
}
}
return(methodList);
}
public IActionResult Index()
{
OperationResultListVo <RankingViewModel> serviceResult = gamificationAppService.GetAll();
List <RankingViewModel> objs = serviceResult.Value.ToList();
foreach (RankingViewModel obj in objs)
{
Application.ViewModels.User.ProfileViewModel profile = profileAppService.GetUserProfileWithCache(obj.UserId);
if (profile != null)
{
obj.Name = profile.Name;
obj.ProfileImageUrl = UrlFormatter.ProfileImage(obj.UserId);
obj.CoverImageUrl = UrlFormatter.ProfileCoverImage(obj.UserId, profile.Id, profile.LastUpdateDate, profile.HasCoverImage);
}
}
return(View(objs));
}
public async Task <PartialViewResult> ListMine()
{
List <StudyCourseListItemVo> model;
OperationResultVo serviceResult = await studyAppService.GetMyCourses(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <StudyCourseListItemVo> castResult = serviceResult as OperationResultListVo <StudyCourseListItemVo>;
model = castResult.Value.ToList();
}
else
{
model = new List <StudyCourseListItemVo>();
}
ViewData["ListDescription"] = SharedLocalizer["My Courses"].ToString();
return(PartialView("_ListCourses", model));
}
public async Task <PartialViewResult> ListMyStudents()
{
List <ProfileViewModel> model;
OperationResultVo serviceResult = await studyAppService.GetMyStudents(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <ProfileViewModel> castResult = serviceResult as OperationResultListVo <ProfileViewModel>;
model = castResult.Value.ToList();
}
else
{
model = new List <ProfileViewModel>();
}
ViewData["ListDescription"] = SharedLocalizer["My Pupils"].ToString();
return(PartialView("_ListUsers", model));
}
public IActionResult GetTranslation(Guid projectId, SupportedLanguage language)
{
try
{
OperationResultVo result = translationAppService.GetTranslations(CurrentUserId, projectId, language);
if (result.Success)
{
OperationResultListVo <LocalizationEntryViewModel> castResult = result as OperationResultListVo <LocalizationEntryViewModel>;
return(Json(castResult));
}
else
{
return(Json(new OperationResultVo(false)));
}
}
catch (Exception ex)
{
return(Json(new OperationResultVo(ex.Message)));
}
}
public IActionResult Connections(Guid userId)
{
OperationResultListVo <UserConnectionViewModel> connections = (OperationResultListVo <UserConnectionViewModel>)profileAppService.GetConnectionsByUserId(userId);
List <UserConnectionViewModel> model;
if (connections.Success)
{
model = connections.Value.ToList();
}
else
{
model = new List <UserConnectionViewModel>();
}
if (Request.IsAjaxRequest())
{
return(PartialView("~/Views/Shared/_Connections.cshtml", model));
}
return(View("~/Views/Shared/_Connections.cshtml", model));
}
public async Task <IViewComponentResult> InvokeAsync(int qtd)
{
if (qtd == 0)
{
qtd = 10;
}
OperationResultListVo <NotificationItemViewModel> result = _notificationAppService.GetByUserId(CurrentUserId, qtd);
System.Collections.Generic.List <NotificationItemViewModel> model = result.Value.ToList();
foreach (NotificationItemViewModel item in model)
{
item.Url = string.Format("{0}?notificationclicked={1}", item.Url, item.Id);
}
model.DefineVisuals();
ViewData["UnreadCount"] = model.Count(x => !x.IsRead);
return(await Task.Run(() => View(model)));
}
public PartialViewResult List(string backUrl)
{
List <StudyCourseListItemVo> model;
OperationResultVo serviceResult = studyAppService.GetCourses(CurrentUserId);
if (serviceResult.Success)
{
OperationResultListVo <StudyCourseListItemVo> castResult = serviceResult as OperationResultListVo <StudyCourseListItemVo>;
model = castResult.Value.ToList();
}
else
{
model = new List <StudyCourseListItemVo>();
}
ViewData["ListDescription"] = SharedLocalizer["Courses"].ToString();
SetBackUrl(backUrl);
return(PartialView("_ListCoursesCards", model));
}
