public async Task <IViewComponentResult> InvokeAsync(int targetUserId, int groupId, int credentialId, CancellationToken cancellationToken)
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
if (!await _groupMemberService.GetUserHasRole(user.ID, groupId, GroupRoles.UserAdmin, true, cancellationToken))
{
throw new UnauthorizedAccessException("User does not have required role.");
}
if (!await _groupMemberService.GetUserHasRole(targetUserId, groupId, GroupRoles.Member, false, cancellationToken))
{
throw new UnauthorizedAccessException("Target user is not member of group.");
}
var viewModel = new AssignCredentialsViewModel()
{
TargetUser = await _userService.GetUserAsync(targetUserId, cancellationToken),
Credential = await _groupService.GetGroupCredential(groupId, credentialId),
ValidUntilOptions = GetValidUntilOptions(),
};
return(View("AssignCredentialsPopup", viewModel));
}
public async Task <IActionResult> Group(string groupKey, CancellationToken cancellationToken)
{
var group = await _groupService.GetGroupByKey(groupKey, cancellationToken);
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (!_userService.GetRegistrationIsComplete(user))
{
return(Redirect(REGISTRATION_URL));
}
if (await _groupMemberService.GetUserHasRole(user.ID, group.GroupId, GroupRoles.TaskAdmin, true, cancellationToken))
{
if (group.TasksEnabled)
{
return(await GroupRequests(groupKey, null, null, cancellationToken));
}
else if (group.ShiftsEnabled)
{
return(await GroupShifts(groupKey, null, null, cancellationToken));
}
}
else if (await _groupMemberService.GetUserHasRole_Any(user.ID, group.GroupId, new List <GroupRoles> {
GroupRoles.UserAdmin, GroupRoles.UserAdmin_ReadOnly
}, true, cancellationToken))
{
return(await GroupVolunteers(groupKey, cancellationToken));
}
return(Redirect(PROFILE_URL));
}
public async Task <IViewComponentResult> InvokeAsync(int jobId, int requestId, JobStatuses targetStatus, CancellationToken cancellationToken)
{
JobSummary job = null;
if (jobId > 0)
{
job = await _requestService.GetJobSummaryAsync(jobId, cancellationToken);
requestId = job.RequestID;
}
var request = await _requestService.GetRequestSummaryAsync(requestId, cancellationToken);
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
bool userIsAdmin = await _groupMemberService.GetUserHasRole(user.ID, request.ReferringGroupID, GroupRoles.TaskAdmin, true, cancellationToken);
JobStatusChangePopupViewModel vm = await BuildVm(request, job, targetStatus, cancellationToken);
if (job == null)
{
return((request.SingleJobStatus(), targetStatus, userIsAdmin) switch
{
(_, JobStatuses.Done, true) => View("Admin_MarkRequestAsDonePopup", vm),
(_, JobStatuses.Cancelled, true) => View("Admin_CancelRequestPopup", vm),
_ => throw new Exception($"Unhandled status/admin combination for request: {request.SingleJobStatus()} -> {targetStatus} / admin:{userIsAdmin}")
});
public async Task <IActionResult> Index(string groupKey, CancellationToken cancellationToken, bool suag = false)
{
if (String.IsNullOrWhiteSpace(groupKey))
{
return(RedirectToAction(nameof(ErrorsController.Error404), "Errors"));
}
var group = await _groupService.GetGroupByKey(groupKey, cancellationToken);
CommunityViewModel communityViewModel = await _communityRepository.GetCommunity(groupKey, cancellationToken);
if (communityViewModel == null)
{
return(RedirectToAction("Error404", "Errors"));
}
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user != null)
{
communityViewModel.IsLoggedIn = true;
communityViewModel.IsGroupMember = await _groupMemberService.GetUserHasRole(user.ID, group.GroupId, GroupRoles.Member, false, cancellationToken);
}
return(View(communityViewModel.View, communityViewModel));
}
public async Task <int> GetCount(User user, MenuPage menuPage, string groupKey, CancellationToken cancellationToken)
{
if (menuPage == MenuPage.GroupRequests || menuPage == MenuPage.GroupShifts)
{
var group = await _groupService.GetGroupByKey(groupKey, cancellationToken);
if (!await _groupMemberService.GetUserHasRole(user.ID, group.GroupId, GroupRoles.TaskAdmin, true, cancellationToken))
{
return(0);
}
if (!group.ShiftsEnabled && menuPage == MenuPage.GroupShifts)
{
return(0);
}
if (!group.TasksEnabled && menuPage == MenuPage.GroupRequests)
{
return(0);
}
}
try
{
int?count = menuPage switch
{
MenuPage.Group
=> await GetCount(user, MenuPage.GroupRequests, groupKey, cancellationToken) + await GetCount(user, MenuPage.GroupShifts, groupKey, cancellationToken),
MenuPage.GroupRequests
=> (await _requestService.GetGroupRequestsAsync(groupKey, false, cancellationToken))?.Count(r => !r.RequestComplete()),
MenuPage.MyRequests
=> (await _requestService.GetJobsForUserAsync(user.ID, false, cancellationToken))?.Where(j => j.JobStatus.Incomplete())?.Count(),
MenuPage.OpenRequests
=> (await GetFilteredOpenJobsForUser(user, cancellationToken))?.Count(),
MenuPage.OpenShifts
=> (await _requestService.GetOpenShiftsForUserAsync(user, null, null, false, cancellationToken))?.Count(),
MenuPage.MyShifts
=> (await _requestService.GetShiftsForUserAsync(user.ID, null, null, false, cancellationToken))?.Count(s => s.JobStatus.Incomplete()),
MenuPage.GroupShifts
=> (await _requestService.GetGroupShiftRequestsAsync(groupKey, null, null, false, cancellationToken))?.Count(r => !r.RequestComplete()),
_ => null
};
return(count ?? 0);
}
catch
{
// Skip badge if request service has been too slow to respond
return(0);
}
}
public async Task <IActionResult> RequestHelp(string referringGroup, string source, CancellationToken cancellationToken)
{
_logger.LogInformation("request-help");
if (referringGroup == "v4v")
{
return(Redirect("/account"));
}
int referringGroupId = DecodeGroupIdOrGetDefault(referringGroup);
source = ValidateSource(source);
var requestHelpJourney = await _groupService.GetRequestHelpFormVariant(referringGroupId, source);
if (requestHelpJourney.AccessRestrictedByRole)
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
var userHasPermission = user != null && await _groupMemberService.GetUserHasRole(user.ID, referringGroupId, GroupRoles.RequestSubmitter, true, cancellationToken);
if (!userHasPermission)
{
return(RedirectToAction("403", "Error"));
}
}
if (requestHelpJourney.RequestHelpFormVariant == RequestHelpFormVariant.ChildGroupSelector)
{
return(await ChildGroupSelector(referringGroupId, cancellationToken));
}
var model = await _requestService.GetRequestHelpSteps(requestHelpJourney, referringGroupId, source);
var requestStage = (RequestHelpRequestStageViewModel)model.Steps.Where(x => x is RequestHelpRequestStageViewModel).First();
SupportActivities?selectedTask = requestStage.Tasks.Where(t => t.IsSelected).FirstOrDefault()?.SupportActivity;
if (selectedTask != null)
{
requestStage.Questions = await UpdateQuestionsViewModel(null, requestHelpJourney.RequestHelpFormVariant, RequestHelpFormStage.Request, selectedTask.Value, referringGroupId);
}
requestStage.RequestGuid = Guid.NewGuid();
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(int groupId, CancellationToken cancellationToken)
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
var group = await _groupService.GetGroupById(groupId, cancellationToken);
var groupMembers = await _groupMemberService.GetAllGroupMembers(groupId, user.ID);
var groupCompletedJobs = (await _requestService.GetGroupRequestsAsync(groupId, true, cancellationToken))
.SelectMany(r => r.JobBasics).Where(j => j.JobStatus.Equals(JobStatuses.Done));
var groupCredentials = await _groupService.GetGroupCredentials(groupId);
var getEachUser = groupMembers.Select(async(userInGroup) =>
{
return(new VolunteerViewModel()
{
DateJoined = userInGroup.UserRoleAudit.Where(ur => ur.Action == GroupAction.AddMember && ur.Role == GroupRoles.Member && ur.Success).LastOrDefault()?.DateRequested ?? DateTime.MinValue,
Roles = userInGroup.GroupRoles,
User = await _userService.GetUserAsync(userInGroup.UserId, cancellationToken),
CompletedRequests = groupCompletedJobs.Count(j => j.VolunteerUserID.Equals(userInGroup.UserId)),
Credentials = groupCredentials.Select(gc => new AnnotatedGroupCredential(gc, userInGroup.ValidCredentials)).ToList()
});
});
var volunteerListViewModel = new VolunteerListViewModel
{
GroupId = group.GroupId,
GroupCredentials = groupCredentials,
Volunteers = (await Task.WhenAll(getEachUser)).Where(v => v.User != null),
UserId = user.ID,
UserHasEditRights = await _groupMemberService.GetUserHasRole(user.ID, groupId, GroupRoles.UserAdmin, true, cancellationToken),
};
return(View("VolunteerList", volunteerListViewModel));
}
public async Task <IViewComponentResult> InvokeAsync(JobFilterRequest jobFilterRequest, Action hideFilterPanelCallback, Action noJobsCallback, CancellationToken cancellationToken)
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
if (jobFilterRequest.JobSet.GroupAdminView())
{
if (!(await _groupMemberService.GetUserHasRole(user.ID, jobFilterRequest.GroupId.Value, GroupRoles.TaskAdmin, true, cancellationToken)))
{
throw new UnauthorizedAccessException("User not authorized to view group tasks");
}
}
string viewName;
object viewModel;
// TODO: Consolidate 3 methods
switch (jobFilterRequest.JobSet.RequestType(), jobFilterRequest.JobSet)
{
