public async Task <IActionResult> EmailJobDetails(string j, CancellationToken cancellationToken)
{
var jobID = Base64Utils.Base64DecodeToInt(j);
User user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
return(Unauthorized());
}
var commsResponse = await _communicationService.RequestCommunication(null, user.ID, jobID, new CommunicationJob()
{
CommunicationJobType = CommunicationJobTypes.TaskDetail
});
if (commsResponse)
{
return(Ok());
}
else
{
return(new StatusCodeResult(500));
}
}
public async Task <ActionResult> StepOne(string referringGroup, string source, string email, CancellationToken cancellationToken)
{
if (User.Identity.IsAuthenticated)
{
return(Redirect("/account"));
}
int referringGroupId = -1;
if (!string.IsNullOrEmpty(referringGroup))
{
try
{
referringGroupId = Base64Utils.Base64DecodeToInt(referringGroup);
}
catch { }
}
RegistrationFormVariant registrationFormVariant = await _groupService.GetRegistrationFormVariant(referringGroupId, source, cancellationToken);
var group = await _groupService.GetGroupById(referringGroupId, CancellationToken.None);
return(View(new RegistrationViewModel
{
ActiveStep = 1,
FirebaseConfiguration = _configuration["Firebase:Configuration"],
RegistrationFormVariant = registrationFormVariant,
ReferringGroupID = referringGroupId,
Source = source,
GroupName = group.GroupName,
Email = email
}));
}
public async Task <IActionResult> RequestId(string encodedRequestId, CancellationToken cancellationToken)
{
int requestId = Base64Utils.Base64DecodeToInt(encodedRequestId);
User user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
var jobLocation = await _requestService.LocateRequest(requestId, user.ID, cancellationToken);
encodedRequestId = Base64Utils.Base64Encode(requestId);
string destination = jobLocation?.JobSet switch
{
JobSet.UserOpenRequests_MatchingCriteria => $"/account/open-requests/r/{encodedRequestId}",
JobSet.UserOpenRequests_NotMatchingCriteria => $"/account/open-requests/r/{encodedRequestId}",
JobSet.UserMyRequests => $"/account/my-requests/r/{encodedRequestId}",
JobSet.GroupRequests => $"/account/g/{jobLocation.GroupKey}/requests/r/{encodedRequestId}",
JobSet.UserOpenShifts => $"/account/open-shifts/r/{encodedRequestId}",
JobSet.UserMyShifts => $"/account/my-shifts/r/{encodedRequestId}",
JobSet.GroupShifts => $"/account/g/{jobLocation.GroupKey}/shifts/r/{encodedRequestId}",
_ => LINK_EXPIRED_URL,
};
return(Redirect(destination));
}
public async Task <IActionResult> PutFeedback(string j, string r, [FromBody] CapturedFeedback model, CancellationToken cancellationToken)
{
int jobId = Base64Utils.Base64DecodeToInt(j);
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
if (!_authService.GetUrlIsSessionAuthorised(HttpContext))
{
return(StatusCode((int)HttpStatusCode.Unauthorized));
}
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
model.JobId = jobId;
model.RoleSubmittingFeedback = requestRole;
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
var result = await _feedbackService.PostRecordFeedback(user, model);
if (result == Result.Success || result == Result.Failure_FeedbackAlreadyRecorded)
{
return(StatusCode((int)HttpStatusCode.OK));
}
else
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult <SetJobStatusResult> > SetJobStatus(string j, string rq, JobStatuses s, string r, string u, CancellationToken cancellationToken)
{
try
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
UpdateJobStatusOutcome?outcome;
bool requestFeedback = false;
if (string.IsNullOrEmpty(j))
{
int requestId = Base64Utils.Base64DecodeToInt(rq);
outcome = await _requestService.UpdateRequestStatusAsync(requestId, s, user.ID, cancellationToken);
}
else
{
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
int? targetUserId = null;
if (s == JobStatuses.Accepted || s == JobStatuses.InProgress)
{
targetUserId = (requestRole == RequestRoles.Volunteer ? user.ID : Base64Utils.Base64DecodeToInt(u));
}
int jobId = Base64Utils.Base64DecodeToInt(j);
outcome = await _requestService.UpdateJobStatusAsync(jobId, s, user.ID, targetUserId, cancellationToken);
var job = await _requestService.GetJobSummaryAsync(jobId, cancellationToken);
if (job.RequestType.Equals(RequestType.Task))
{
requestFeedback = (await GetJobFeedbackStatus(jobId, user.ID, requestRole, cancellationToken)).FeedbackDue;
}
}
switch (outcome)
{
case UpdateJobStatusOutcome.AlreadyInThisStatus:
case UpdateJobStatusOutcome.Success:
return(new SetJobStatusResult
{
NewStatus = s.FriendlyName(),
RequestFeedback = requestFeedback
});
case UpdateJobStatusOutcome.BadRequest:
return(StatusCode(400));
case UpdateJobStatusOutcome.Unauthorized:
return(StatusCode(401));
default:
return(StatusCode(500));
}
}
catch (Exception ex)
{
_logger.LogError("Exception in SetRequestStatus", ex);
return(StatusCode(500));
}
}
public async Task <IActionResult> PrintJobDetails(string j, CancellationToken cancellationToken)
{
var jobID = Base64Utils.Base64DecodeToInt(j);
User user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
return(ViewComponent("JobDetail", new { JobID = jobID, User = user, Jobset = JobSet.UserMyRequests, ToPrint = true }));
}
public async Task <IActionResult> PostTaskFeedbackCapture(string j, string r, FeedbackCaptureEditModel model, CancellationToken cancellationToken)
{
int jobId = Base64Utils.Base64DecodeToInt(j);
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
if (!_authService.GetUrlIsSessionAuthorised(HttpContext))
{
return(Redirect("/Error/401"));
}
if (!ModelState.IsValid)
{
throw new Exception($"Invalid model state in PostTaskFeedbackCapture for job {jobId}");
}
model.JobId = jobId;
model.RoleSubmittingFeedback = requestRole;
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
var job = await _requestService.GetJobSummaryAsync(jobId, cancellationToken);
var result = await _feedbackService.PostRecordFeedback(user, model);
return(ShowMessage(result, job.ReferringGroupID, model));
}
public async Task <IActionResult> PostTaskFeedbackCapture(string j, string r, string f, CancellationToken cancellationToken)
{
if (!_authService.GetUrlIsSessionAuthorised(HttpContext))
{
return(Redirect("/Error/401"));
}
int jobId = Base64Utils.Base64DecodeToInt(j);
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
FeedbackRating feedbackRating = string.IsNullOrEmpty(f) ? 0 : (FeedbackRating)Base64Utils.Base64DecodeToInt(f);
var job = await _requestService.GetJobSummaryAsync(jobId, cancellationToken);
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (job.JobStatus.Incomplete())
{
return(ShowMessage(Result.Failure_IncorrectJobStatus, job.ReferringGroupID));
}
if (await _feedbackService.GetFeedbackExists(jobId, requestRole, user?.ID))
{
return(ShowMessage(Result.Failure_FeedbackAlreadyRecorded, job.ReferringGroupID));
}
return(View(new FeedbackCaptureViewComponentParameters()
{
JobId = jobId, RequestRole = requestRole, FeedbackRating = feedbackRating
}));
}
public IActionResult GetAssignCredentialPopup(string u, string g, string c)
{
int targetUserId = Base64Utils.Base64DecodeToInt(u);
int groupId = Base64Utils.Base64DecodeToInt(g);
int credentialId = Base64Utils.Base64DecodeToInt(c);
return(ViewComponent("AssignCredentialsPopup", new { targetUserId, groupId, credentialId }));
}
public async Task <IActionResult> GetLeaveGroupPopup(string g, CancellationToken cancellationToken)
{
int groupId = Base64Utils.Base64DecodeToInt(g);
var group = await _groupService.GetGroupById(groupId, cancellationToken);
var community = _communityRepository.GetCommunityDetailByKey(group.GroupKey);
return(PartialView("_LeaveGroupPopup", community));
}
public IActionResult GetWhatIsThisCredentialPopup(string g, string c, string i)
{
int groupId = Base64Utils.Base64DecodeToInt(g);
int?credentialId = c != null?Base64Utils.Base64DecodeToInt(c) : (int?)null;
string item = i;
return(ViewComponent("WhatIsThisCredentialPopup", new { groupId, credentialId, item }));
}
private int DecodeGroupIdOrGetDefault(string encodedGroupId)
{
try
{
return(Base64Utils.Base64DecodeToInt(encodedGroupId));
}
catch
{
return(-1);
}
}
private void AddHighlightIdsToViewModel(AccountViewModel viewModel, string encodedJobId, string encodedRequestId)
{
if (!string.IsNullOrEmpty(encodedJobId))
{
viewModel.HighlightJobId = Base64Utils.Base64DecodeToInt(encodedJobId);
}
if (!string.IsNullOrEmpty(encodedRequestId))
{
viewModel.HighlightRequestId = Base64Utils.Base64DecodeToInt(encodedRequestId);
}
}
public IActionResult GetStatusChangePopup(string j, string rq, JobStatuses s)
{
if (string.IsNullOrEmpty(j))
{
int requestId = Base64Utils.Base64DecodeToInt(rq);
return(ViewComponent("JobStatusChangePopup", new { requestId, targetStatus = s }));
}
else
{
int jobId = Base64Utils.Base64DecodeToInt(j);
return(ViewComponent("JobStatusChangePopup", new { jobId, targetStatus = s }));
}
}
public IActionResult PostTaskFeedbackCapturePopup(string j, string r)
{
if (!_authService.GetUrlIsSessionAuthorised(HttpContext))
{
return(StatusCode((int)HttpStatusCode.Unauthorized));
}
int jobId = Base64Utils.Base64DecodeToInt(j);
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
return(ViewComponent("FeedbackCapture", new { parameters = new FeedbackCaptureViewComponentParameters()
{
JobId = jobId, RequestRole = requestRole, RenderAsPopup = true
} }));
}
public async Task <IActionResult> JoinGroup(string g, CancellationToken cancellationToken)
{
try
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
int groupId = Base64Utils.Base64DecodeToInt(g);
var result = await _groupMemberService.PostAssignRole(user.ID, groupId, GroupRoles.Member, user.ID, cancellationToken);
return(result switch
{
GroupPermissionOutcome.Success => StatusCode((int)HttpStatusCode.OK),
GroupPermissionOutcome.Unauthorized => StatusCode((int)HttpStatusCode.Unauthorized),
_ => throw new ArgumentException(message: $"Unexpected GroupPermissionOutcome value: {result}", paramName: nameof(result))
});
}
public async Task <IActionResult> GetJobDetails(string j, string rq, JobSet js, CancellationToken cancellationToken)
{
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
if (string.IsNullOrEmpty(j))
{
int requestId = Base64Utils.Base64DecodeToInt(rq);
return(ViewComponent("RequestDetail", new { requestId, user, jobSet = js }));
}
else
{
int jobId = Base64Utils.Base64DecodeToInt(j);
return(ViewComponent("JobDetail", new { jobId, user, jobSet = js }));
}
}
public async Task <bool> PutVolunteerCredential(string u, string g, string c, [FromBody] AssignCredentialsViewModel assignCredentialsViewModel, CancellationToken cancellationToken)
{
int targetUserId = Base64Utils.Base64DecodeToInt(u);
int groupId = Base64Utils.Base64DecodeToInt(g);
int credentialId = Base64Utils.Base64DecodeToInt(c);
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
DateTime?validUntil = assignCredentialsViewModel.ValidUntil == "Null" ? (DateTime?)null : DateTime.ParseExact(assignCredentialsViewModel.ValidUntil, DatePickerHelpers.DATE_PICKER_DATE_FORMAT, new CultureInfo("en-GB"));
PutGroupMemberCredentialsRequest putGroupMemberCredentialsRequest = new PutGroupMemberCredentialsRequest()
{
AuthorisedByUserID = user.ID,
UserId = targetUserId,
GroupId = groupId,
CredentialId = credentialId,
Reference = assignCredentialsViewModel.Reference,
Notes = assignCredentialsViewModel.Notes,
ValidUntil = validUntil,
};
return(await _groupMemberService.PutGroupMemberCredentials(putGroupMemberCredentialsRequest));
}
public async Task <IActionResult> GetFeedbackComponent(string j, string r, CancellationToken cancellationToken)
{
int jobId = Base64Utils.Base64DecodeToInt(j);
RequestRoles requestRole = (RequestRoles)Base64Utils.Base64DecodeToInt(r);
var user = await _authService.GetCurrentUser(HttpContext, cancellationToken);
if (user == null)
{
throw new UnauthorizedAccessException("No user in session");
}
var feedbackStatus = await GetJobFeedbackStatus(jobId, user.ID, requestRole, cancellationToken);
if (feedbackStatus.FeedbackDue)
{
return(PartialView("_FeedbackDue"));
}
else if (feedbackStatus.FeedbackSubmitted)
{
return(PartialView("_FeedbackSubmitted"));
}
return(StatusCode((int)HttpStatusCode.OK));
}
public void Base64Encode_Base64DecodeToInt()
{
int result = Base64Utils.Base64DecodeToInt(Base64Utils.Base64Encode(123));
Assert.AreEqual(123, result);
}
public void Base64Encode_Base64DecodeToInt_Negative()
{
int result = Base64Utils.Base64DecodeToInt(Base64Utils.Base64Encode(-1));
Assert.AreEqual(-1, result);
}
public void Base64Encode_Base64DecodeToInt_Invalid()
{
string encodedString = Base64Utils.Base64Encode("Not a number");
Assert.Throws <FormatException>(() => { Base64Utils.Base64DecodeToInt(encodedString); });
}
public void Base64Encode_Base64DecodeToInt_Zero()
{
int result = Base64Utils.Base64DecodeToInt(Base64Utils.Base64Encode(0));
Assert.AreEqual(0, result);
}
public IActionResult GetViewLocationPopup(string j)
{
int jobId = Base64Utils.Base64DecodeToInt(j);
return(ViewComponent("ViewLocationPopup", new { jobId }));
}