Exemplo n.º 1
0
        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 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);

            if (requestDetails == null)
            {
                throw new Exception($"Unable to return request details for requestId {requestId.Value}");
            }

            var group = await _connectGroupService.GetGroup(requestDetails.RequestSummary.ReferringGroupID);

            return(new EmailBuildData()
            {
                BaseDynamicData = new RequestorTaskConfirmationData
                                  (
                    firstname: requestDetails.Requestor.FirstName,
                    pendingApproval: additionalParameters["PendingApproval"] == true.ToString(),
                    groupName: group.Group.GroupName,
                    requestJobList: GetJobs(requestDetails)
                                  ),
                EmailToAddress = requestDetails.Requestor.EmailAddress,
                EmailToName = $"{requestDetails.Requestor.FirstName} {requestDetails.Requestor.LastName}",
                RecipientUserID = REQUESTOR_DUMMY_USERID,
                RequestID = requestId,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = requestDetails.RequestSummary.ReferringGroupID,
                        R = requestId.Value
                    }
                }
            });
        }
Exemplo n.º 3
0
        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);

            if (requestDetails == null)
            {
                throw new Exception($"Unable to return request details for requestId {requestId.Value}");
            }

            var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);

            var group = await _connectGroupService.GetGroup(requestDetails.RequestSummary.ReferringGroupID);

            string encodedRequestId = Base64Utils.Base64Encode(requestDetails.RequestSummary.RequestID.ToString());

            if (requestDetails != null && user?.UserPersonalDetails != null && group?.Group != null)
            {
                var token = await _linkRepository.CreateLink($"/link/r/{encodedRequestId}", _linkConfig.Value.ExpiryDays);

                return(new EmailBuildData()
                {
                    BaseDynamicData = new NewTaskPendingApprovalData
                                      (
                        user.UserPersonalDetails.FirstName,
                        group.Group.GroupName,
                        token
                                      ),
                    EmailToAddress = user.UserPersonalDetails.EmailAddress,
                    EmailToName = $"{user.UserPersonalDetails.FirstName} {user.UserPersonalDetails.LastName}",
                    RequestID = requestDetails.RequestSummary.RequestID,
                    GroupID = requestDetails.RequestSummary.ReferringGroupID,
                    ReferencedJobs = new List <ReferencedJob>()
                    {
                        new ReferencedJob()
                        {
                            G = requestDetails.RequestSummary.ReferringGroupID,
                            R = requestDetails.RequestSummary.RequestID,
                        }
                    }
                });
            }
            throw new Exception("Unable to retrieve necessary details to build email");
        }
        public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
        {
            var request = await _connectRequestService.GetRequestDetailsAsync(requestId.Value);

            var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);

            var job      = request.RequestSummary.JobBasics.Where(x => x.JobID == jobId.Value).FirstOrDefault();
            var location = await _connectAddressService.GetLocationDetails(request.RequestSummary.Shift.Location, CancellationToken.None);

            string encodedJobId = Base64Utils.Base64Encode(jobId.Value.ToString());
            var    joburlToken  = await _linkRepository.CreateLink($"/link/j/{encodedJobId}", _linkConfig.Value.ExpiryDays);

            return(new EmailBuildData()
            {
                BaseDynamicData = new ShiftReminderMessageData(
                    title: "Volunteer shift reminder",
                    subject: "Volunteer shift reminder",
                    firstname: user.UserPersonalDetails.FirstName,
                    activity: job.SupportActivity.FriendlyNameShort(),
                    location: location.Name,
                    shiftStartDateString: FormatDate(request.RequestSummary.Shift.StartDate),
                    shiftEndDateString: FormatDate(request.RequestSummary.Shift.EndDate),
                    locationAddress: string.Empty,
                    joburlToken: joburlToken
                    ),
                EmailToAddress = user.UserPersonalDetails.EmailAddress,
                EmailToName = $"{user.UserPersonalDetails.FirstName} {user.UserPersonalDetails.LastName}",
                RequestID = requestId,
                JobID = jobId,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = request.RequestSummary.ReferringGroupID,
                        R = requestId,
                        J = jobId
                    }
                }
            });
        }