public static string Icon(this SupportActivities activity)
{
return(activity switch
{
SupportActivities.Shopping => "shopping.svg",
SupportActivities.FaceMask => "face-covering.svg",
SupportActivities.CheckingIn => "check-in.svg",
SupportActivities.CollectingPrescriptions => "prescriptions.svg",
SupportActivities.Errands => "Errands.svg",
SupportActivities.DogWalking => "dog-walking.svg",
SupportActivities.MealPreparation => "meal.svg",
SupportActivities.PhoneCalls_Friendly => "friendlychat.svg",
SupportActivities.PhoneCalls_Anxious => "supportivechat.svg",
SupportActivities.HomeworkSupport => "homework.svg",
SupportActivities.WellbeingPackage => "package.svg",
SupportActivities.CommunityConnector => "friendlychat.svg",
SupportActivities.ColdWeatherArmy => "snowflake.svg",
SupportActivities.MealsToYourDoor => "mealstoyourdoor.svg",
SupportActivities.MealtimeCompanion => "mealtimecompanion.svg",
SupportActivities.VolunteerSupport => "volunteers.svg",
SupportActivities.Transport => "transport.svg",
SupportActivities.VaccineSupport => "vaccination.svg",
SupportActivities.EmergencySupport => "emergency-support.svg",
SupportActivities.BinDayAssistance => "bin-day-assistance.svg",
SupportActivities.Covid19Help => "covid-19-support.svg",
SupportActivities.DigitalSupport => "digital-support.svg",
SupportActivities.PracticalSupport => "practical.svg",
SupportActivities.InPersonBefriending => "befriending.svg",
SupportActivities.BankStaffVaccinator => "vaccination.svg",
_ => "question-mark.svg"
});
public async Task <double?> GetGroupSupportActivityRadius(int groupID, SupportActivities supportActivity, CancellationToken cancellationToken)
{
return(await _memDistCache.GetCachedDataAsync(async (cancellationToken) =>
{
GetGroupSupportActivityRadiusRequest request = new GetGroupSupportActivityRadiusRequest()
{
GroupId = groupID, SupportActivityType = new SupportActivityType()
{
SupportActivity = supportActivity
}
};
string json = JsonConvert.SerializeObject(request);
StringContent data = new StringContent(json, Encoding.UTF8, "application/json");
using (HttpResponseMessage response = await _httpClientWrapper.PostAsync(HttpClientConfigName.GroupService, "/api/GetGroupSupportActivityRadius", data, CancellationToken.None))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var getRadiusResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetGroupSupportActivityRadiusResponse, GroupServiceErrorCode> >(jsonResponse);
if (getRadiusResponse.HasContent && getRadiusResponse.IsSuccessful)
{
return getRadiusResponse.Content.SupportRadiusMiles;
}
else
{
throw new HttpRequestException("Unable to fetch radius details");
}
}
}, $"{CACHE_KEY_PREFIX}-group-{groupID}-sa-{(int)supportActivity}", RefreshBehaviour.DontWaitForFreshData, cancellationToken));
}
public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
{
var requestDetails = await _connectRequestService.GetRequestDetailsAsync(requestId.Value);
string encodedRequestId = HelpMyStreet.Utils.Utils.Base64Utils.Base64Encode(requestDetails.RequestSummary.RequestID.ToString());
SupportActivities supportActivity = GetSupportActivityFromRequest(requestDetails);
var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);
var volunteers = _connectUserService.GetVolunteersByPostcodeAndActivity
(
requestDetails.RequestSummary.PostCode,
new List <SupportActivities>()
{
supportActivity
},
null,
CancellationToken.None
).Result;
if (volunteers != null)
{
var volunteer = volunteers.Volunteers.FirstOrDefault(x => x.UserID == user.ID);
if (user != null && requestDetails != null)
{
var job = requestDetails.RequestSummary.JobSummaries.First();
return(new EmailBuildData()
{
BaseDynamicData = new TaskNotificationData
(
firstname: user.UserPersonalDetails.FirstName,
isRequestor: false,
encodedRequestID: encodedRequestId,
activity: supportActivity.FriendlyNameShort(),
postcode: requestDetails.RequestSummary.PostCode,
distanceFromPostcode: Math.Round(volunteer.DistanceInMiles, 1),
dueDate: job.DueDate.FormatDate(DateTimeFormat.ShortDateFormat),
isHealthCritical: job.IsHealthCritical,
isFaceMask: supportActivity == SupportActivities.FaceMask
),
EmailToAddress = user.UserPersonalDetails.EmailAddress,
EmailToName = $"{user.UserPersonalDetails.FirstName} {user.UserPersonalDetails.LastName}",
RequestID = job.RequestID,
ReferencedJobs = new List <ReferencedJob>()
{
new ReferencedJob()
{
G = job.ReferringGroupID,
R = job.RequestID,
J = job.JobID
}
}
});
}
}
throw new Exception("unable to retrieve user details");
}
public GroupJob(
SupportActivities supportActivity,
int count
)
{
SupportActivity = supportActivity;
Count = count;
}
private double GetSupportDistanceForActivity(SupportActivities supportActivity, double?distanceInMiles, Dictionary <SupportActivities, double?> activitySpecificSupportDistancesInMiles)
{
if (activitySpecificSupportDistancesInMiles != null && activitySpecificSupportDistancesInMiles.ContainsKey(supportActivity))
{
return(activitySpecificSupportDistancesInMiles[supportActivity] ?? int.MaxValue);
}
else
{
return(distanceInMiles ?? int.MaxValue);
}
}
public async Task WhenVolunteerAlreadyAssignedForRequestAndSupportActivity_ReturnsNoLongerAvailable()
{
_hasPermission = true;
int requestID = 1;
SupportActivities activity = SupportActivities.VolunteerSupport;
int volunteerUserID = 1;
_request = new PutUpdateShiftStatusToAcceptedRequest
{
CreatedByUserID = 2,
RequestID = requestID,
SupportActivity = new SingleSupportActivityRequest()
{
SupportActivity = activity
},
VolunteerUserID = volunteerUserID
};
_jobId = 0;
_getUserGroupsResponse = new GetUserGroupsResponse()
{
Groups = new List <int>()
{
-1
}
};
_groups = new List <int>()
{
-1
};
_repository.Setup(x => x.UpdateRequestStatusToAccepted(It.IsAny <int>(), It.IsAny <SupportActivities>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new UnableToUpdateShiftException($"Unable to UpdateShiftStatus for RequestID:{requestID} SupportActivity:{activity} Volunteer:{volunteerUserID}"));
var response = await _classUnderTest.Handle(_request, CancellationToken.None);
_repository.Verify(x => x.VolunteerAlreadyAcceptedShift(It.IsAny <int>(), It.IsAny <SupportActivities>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_jobService.Verify(x => x.HasPermissionToChangeRequestAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_repository.Verify(x => x.UpdateRequestStatusToAccepted(It.IsAny <int>(), It.IsAny <SupportActivities>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_repository.Verify(x => x.GetGroupsForRequestAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
_groupService.Verify(x => x.GetUserGroups(It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.AreEqual(UpdateJobStatusOutcome.NoLongerAvailable, response.Outcome);
}
public static string FriendlyNameForEmail(this SupportActivities activity)
{
return(activity switch
{
SupportActivities.Shopping => "shopping",
SupportActivities.CollectingPrescriptions => "collecting prescriptions",
SupportActivities.Errands => "local errands",
SupportActivities.DogWalking => "dog walking",
SupportActivities.MealPreparation => "a prepared meal",
SupportActivities.PhoneCalls_Friendly => "a friendly chat",
SupportActivities.PhoneCalls_Anxious => "a supportive chat",
SupportActivities.HomeworkSupport => "homework support for parent",
SupportActivities.CheckingIn => "a neighbourly check-in",
SupportActivities.FaceMask => "homemade face coverings",
SupportActivities.WellbeingPackage => "delivering a well-being package",
SupportActivities.Other => "your requested activity",
SupportActivities.CommunityConnector => "a community connector",
SupportActivities.MedicalAppointmentTransport => "medical appointment transport",
SupportActivities.ColdWeatherArmy => "cold weather army assistance",
SupportActivities.Transport => "transport",
_ => throw new ArgumentException(message: $"Unexpected SupportActivity: {activity}", paramName: nameof(activity))
});
public async Task <ActionResult> Questions([FromBody] QuestionRequest request)
{
RequestHelpFormVariant requestHelpFormVariant = Enum.Parse <RequestHelpFormVariant>(request.FormVariant);
RequestHelpFormStage requestHelpFormStage = Enum.Parse <RequestHelpFormStage>(request.FormStage);
SupportActivities supportActivity = Enum.Parse <SupportActivities>(request.SupportActivity);
QuestionsViewModel questionsViewModel = new QuestionsViewModel()
{
Questions = await _requestHelpBuilder.GetQuestionsForTask(requestHelpFormVariant, requestHelpFormStage, supportActivity, request.GroupId)
};
questionsViewModel = questionsViewModel.GetQuestionsByLocation(request.Position);
foreach (var question in questionsViewModel.Questions)
{
var matchedAnswer = request.Answers.Where(x => x.Id == question.ID && !string.IsNullOrEmpty(x.Answer)).FirstOrDefault();
if (matchedAnswer != null)
{
question.Model = matchedAnswer.Answer;
}
}
return(PartialView("_Questions", questionsViewModel));
}
public async Task <List <List <int> > > GetGroupActivityCredentials(int groupId, SupportActivities supportActivitiy)
{
var getGroupActivityCredentialsRequest = new GetGroupActivityCredentialsRequest()
{
GroupId = groupId,
SupportActivityType = new SupportActivityType()
{
SupportActivity = supportActivitiy
},
};
string json = JsonConvert.SerializeObject(getGroupActivityCredentialsRequest);
StringContent data = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = await Client.PostAsync("/api/GetGroupActivityCredentials", data);
string str = await response.Content.ReadAsStringAsync();
var deserializedResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetGroupActivityCredentialsResponse, GroupServiceErrorCode> >(str);
if (deserializedResponse.HasContent && deserializedResponse.IsSuccessful)
{
return(deserializedResponse.Content.CredentialSets);
}
return(null);
}
public async Task <List <List <GroupCredential> > > GetGroupActivityCredentials(int groupId, SupportActivities supportActivity, CancellationToken cancellationToken)
{
var result = await _memDistCache_listListGroupCred.GetCachedDataAsync(async (cancellationToken) =>
{
var credentialSetsWithIds = await _groupRepository.GetGroupActivityCredentials(groupId, supportActivity);
var groupCredentials = await _groupRepository.GetGroupCredentials(groupId);
return(credentialSetsWithIds.Select(cs => cs.Select(credentialId => groupCredentials.First(gc => gc.CredentialID == credentialId)).ToList()).ToList());
}, $"{CACHE_KEY_PREFIX}-group-activity-credentials-group-{groupId}-activity-{supportActivity}", RefreshBehaviour.DontWaitForFreshData, cancellationToken);
if (result == null)
{
throw new Exception($"Exception in GetGroupActivityCredentials for group {groupId} and activity {supportActivity}");
}
return(result);
}
public async Task <Instructions> GetGroupSupportActivityInstructions(int groupId, SupportActivities supportActivity, CancellationToken cancellationToken)
{
var instructions = await _memDistCache_instructions.GetCachedDataAsync(async (cancellationToken) =>
{
return(await _groupRepository.GetGroupSupportActivityInstructions(groupId, supportActivity));
}, $"{CACHE_KEY_PREFIX}-group-support-activity-instructions-group-{groupId}-activity-{supportActivity}", RefreshBehaviour.DontWaitForFreshData, cancellationToken);
if (instructions == null)
{
throw new Exception($"Unable to find instructions for group {groupId} and activity {supportActivity}");
}
return(instructions);
}
private double?GetSupportDistanceForActivity(int groupId, SupportActivities supportActivity, CancellationToken cancellationToken)
{
return(_groupService.GetGroupSupportActivityRadius(groupId, supportActivity, cancellationToken).Result);
}
private async Task <RequestHelpDetailStageViewModel> BindDetailStage(ModelBindingContext bindingContext, RequestHelpFormVariant requestHelpFormVariant, SupportActivities selectedSupportActivity, int groupId)
{
RequestHelpDetailStageViewModel model = JsonConvert.DeserializeObject <RequestHelpDetailStageViewModel>(bindingContext.ValueProvider.GetValue("DetailStep").FirstValue);
var recpientnamePrefix = "currentStep.Recipient.";
model.Recipient = new RecipientDetails
{
Firstname = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.Firstname)).FirstValue,
Lastname = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.Lastname)).FirstValue,
MobileNumber = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.MobileNumber)).FirstValue,
AlternatePhoneNumber = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.AlternatePhoneNumber)).FirstValue,
AddressLine1 = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.AddressLine1)).FirstValue,
AddressLine2 = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.AddressLine2)).FirstValue,
County = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.County)).FirstValue,
Postcode = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.Postcode)).FirstValue,
Email = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.Email)).FirstValue,
Town = bindingContext.ValueProvider.GetValue(recpientnamePrefix + nameof(model.Recipient.Town)).FirstValue,
};
var requestorPrefix = "currentStep.Requestor.";
model.Requestor = new RequestorDetails
{
Firstname = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.Firstname)).FirstValue,
Lastname = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.Lastname)).FirstValue,
MobileNumber = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.MobileNumber)).FirstValue,
AlternatePhoneNumber = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.AlternatePhoneNumber)).FirstValue,
Postcode = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.Postcode)).FirstValue,
Email = bindingContext.ValueProvider.GetValue(requestorPrefix + nameof(model.Recipient.Email)).FirstValue,
};
model.Organisation = bindingContext.ValueProvider.GetValue("currentStep.Organisation").FirstValue;
model.Questions = new QuestionsViewModel()
{
Questions = await _requestHelpBuilder.GetQuestionsForTask(requestHelpFormVariant, RequestHelpFormStage.Detail, selectedSupportActivity, groupId)
};
foreach (RequestHelpQuestion question in model.Questions.Questions)
{
question.Model = bindingContext.ValueProvider.GetValue($"currentStep.Questions.[{question.ID}].Model").FirstValue;
}
return(model);
}
public async Task <bool> GetUserHasCredentials(int groupId, SupportActivities supportActivitiy, int userId, int authorisingUserId, CancellationToken cancellationToken)
{
var annotatedGacs = await GetAnnotatedGroupActivityCredentials(groupId, supportActivitiy, userId, authorisingUserId, cancellationToken);
return(annotatedGacs.AreSatisfied);
}
public async Task <AnnotatedGroupActivityCredentialSets> GetAnnotatedGroupActivityCredentials(int groupId, SupportActivities supportActivitiy, int userId, int authorisingUserId, CancellationToken cancellationToken)
{
var gacs = await _groupService.GetGroupActivityCredentials(groupId, supportActivitiy, cancellationToken);
var groupMember = await GetGroupMember(groupId, userId, authorisingUserId, cancellationToken);
if (gacs == null)
{
throw new Exception("Null response from GetGroupActivityCredentials");
}
if (groupMember == null)
{
throw new Exception("Null response from GetGroupMember");
}
return(new AnnotatedGroupActivityCredentialSets(gacs, groupMember.ValidCredentials));
}
public async Task <Instructions> GetGroupSupportActivityInstructions(int groupId, SupportActivities supportActivity)
{
GetGroupSupportActivityInstructionsRequest request = new GetGroupSupportActivityInstructionsRequest()
{
GroupId = groupId,
SupportActivityType = new SupportActivityType()
{
SupportActivity = supportActivity
}
};
string json = JsonConvert.SerializeObject(request);
StringContent data = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = await Client.PostAsync("/api/GetGroupSupportActivityInstructions", data);
string str = await response.Content.ReadAsStringAsync();
var deserializedResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetGroupSupportActivityInstructionsResponse, GroupServiceErrorCode> >(str);
if (deserializedResponse.HasContent && deserializedResponse.IsSuccessful)
{
return(deserializedResponse.Content.Instructions);
}
throw new Exception("Bad response from GetGroupSupportActivityInstructions");
}
public async Task <UpdateJobStatusOutcome?> PutUpdateShiftStatusToAccepted(int requestId, SupportActivities supportActivity, int createdByUserId, int volunteerUserId)
{
var request = new PutUpdateShiftStatusToAcceptedRequest()
{
RequestID = requestId,
SupportActivity = new SingleSupportActivityRequest()
{
SupportActivity = supportActivity
},
CreatedByUserID = createdByUserId,
VolunteerUserID = volunteerUserId
};
var response = await PutAsync <BaseRequestHelpResponse <PutUpdateShiftStatusToAcceptedResponse> >($"/api/PutUpdateShiftStatusToAccepted", request);
if (response.HasContent && response.IsSuccessful)
{
return(response.Content.Outcome);
}
return(null);
}
private async Task <QuestionsViewModel> UpdateQuestionsViewModel(QuestionsViewModel previousQuestionsViewModel, RequestHelpFormVariant requestHelpFormVariant, RequestHelpFormStage requestHelpFormStage, SupportActivities selectedSupportActivity, int groupId)
{
QuestionsViewModel updatedQuestionsViewModel = new QuestionsViewModel()
{
Questions = await _requestHelpBuilder.GetQuestionsForTask(requestHelpFormVariant, requestHelpFormStage, selectedSupportActivity, groupId)
};
if (previousQuestionsViewModel != null)
{
foreach (RequestHelpQuestion question in updatedQuestionsViewModel.Questions)
{
var matchedQuestion = previousQuestionsViewModel.Questions.Where(pq => pq.ID == question.ID && !string.IsNullOrEmpty(pq.Model)).FirstOrDefault();
if (matchedQuestion != null)
{
question.Model = matchedQuestion.Model;
}
}
}
return(updatedQuestionsViewModel);
}
