public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
        {
            if (!recipientUserId.HasValue || !jobId.HasValue)
            {
                throw new Exception($"Recipient or JobID is missing");
            }
            var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);

            var job = await _connectRequestService.GetJobDetailsAsync(jobId.Value);

            string encodedJobId = HelpMyStreet.Utils.Utils.Base64Utils.Base64Encode(job.JobSummary.JobID.ToString());

            string dueDateMessage = string.Empty;

            switch (job.JobSummary.DueDateType)
            {
            case DueDateType.Before:
                dueDateMessage = $"The help is needed on or before {job.JobSummary.DueDate.FormatDate(DateTimeFormat.ShortDateFormat)} – {job.JobSummary.DueDays} days from now.";
                break;

            case DueDateType.On:
                dueDateMessage = $"The help is needed on {job.JobSummary.DueDate.FormatDate(DateTimeFormat.ShortDateFormat)} – {job.JobSummary.DueDays} days from now.";
                break;
            }

            return(new EmailBuildData()
            {
                BaseDynamicData = new TaskReminderData(
                    encodedJobId,
                    GetTitleFromDays(job.JobSummary.DueDays, job.JobSummary.DueDateType, job.JobSummary.DueDate),
                    user.UserPersonalDetails.FirstName,
                    job.JobSummary.SupportActivity.FriendlyNameShort(),
                    job.JobSummary.PostCode,
                    job.JobSummary.DueDays == 0 ? true : false,
                    job.JobSummary.DueDays == 1 ? true : false,
                    job.JobSummary.DueDateType == DueDateType.Before,
                    job.JobSummary.DateStatusLastChanged.FormatDate(DateTimeFormat.ShortDateFormat),
                    dueDateMessage,
                    dueDateString: $"({job.JobSummary.DueDate.FormatDate(DateTimeFormat.ShortDateFormat)})"
                    ),
                JobID = jobId,
                GroupID = groupId,
                RecipientUserID = recipientUserId.Value,
                EmailToAddress = user.UserPersonalDetails.EmailAddress,
                EmailToName = $"{user.UserPersonalDetails.FirstName} {user.UserPersonalDetails.LastName}",
                RequestID = job.JobSummary.RequestID,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = job.JobSummary.ReferringGroupID,
                        R = job.JobSummary.RequestID,
                        J = job.JobSummary.JobID
                    }
                }
            });
        }
        private List <RequestJob> GetJobsForStandardRequest(GetRequestDetailsResponse response, List <GroupJob> groupJobs)
        {
            List <RequestJob> requestJobs = new List <RequestJob>();

            string dueDateString = string.Empty;
            bool   showJobUrl    = false;
            string jobUrl        = string.Empty;

            //TODO - This can be written to handle multiple jobs for a standard request. Need to tweak when repeat enquiries functionality added
            if (groupJobs.Count == 1)
            {
                int jobid = response.RequestSummary.JobBasics[0].JobID;
                GetJobDetailsResponse jobResponse = _connectRequestService.GetJobDetailsAsync(jobid).Result;

                if (jobResponse != null)
                {
                    RequestRoles getChangedBy = GetChangedByRole(jobResponse);
                    showJobUrl = getChangedBy == RequestRoles.Volunteer ||
                                 getChangedBy == RequestRoles.GroupAdmin ||
                                 (getChangedBy == RequestRoles.Requestor && jobResponse.JobSummary.RequestorDefinedByGroup);
                    jobUrl = showJobUrl ? GetJobUrl(jobid, response.RequestSummary.RequestID, groupJobs[0].Count) : string.Empty;

                    dueDateString = $" - Due Date: <strong>{jobResponse.JobSummary.DueDate.FormatDate(DateTimeFormat.LongDateFormat)}.</strong>";
                }
                else
                {
                    throw new Exception($"Unable to retrieve job details for jobid { jobid }");
                }
            }

            foreach (GroupJob gj in groupJobs)
            {
                requestJobs.Add(new RequestJob(
                                    activity: gj.SupportActivity.FriendlyNameShort(),
                                    countString: gj.Count == 1 ? string.Empty: $" - {gj.Count} volunteers required. ",
                                    dueDateString: dueDateString,
                                    showJobUrl: showJobUrl,
                                    jobUrl: jobUrl
                                    ));
            }
            return(requestJobs);
        }
        public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
        {
            var job = _connectRequestService.GetJobDetailsAsync(jobId.Value).Result;

            // Recipient
            RequestRoles emailRecipientRequestRole = (RequestRoles)Enum.Parse(typeof(RequestRoles), additionalParameters["RequestRole"]);

            string emailToAddress   = string.Empty;
            string emailToFullName  = string.Empty;
            string emailToFirstName = string.Empty;

            switch (emailRecipientRequestRole)
            {
            case RequestRoles.Volunteer:
                var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);

                emailToFirstName = user.UserPersonalDetails.FirstName;
                emailToAddress   = user.UserPersonalDetails.EmailAddress;
                emailToFullName  = $"{user.UserPersonalDetails.FirstName} {user.UserPersonalDetails.LastName}";
                break;

            case RequestRoles.Requestor:
                emailToFirstName = job.Requestor.FirstName;
                emailToAddress   = job.Requestor.EmailAddress;
                emailToFullName  = $"{job.Requestor.FirstName} {job.Requestor.LastName}";
                break;

            case RequestRoles.Recipient:
                emailToFirstName = job.Recipient.FirstName;
                emailToAddress   = job.Recipient.EmailAddress;
                emailToFullName  = $"{job.Recipient.FirstName} {job.Recipient.LastName}";
                break;
            }

            // Change summary
            additionalParameters.TryGetValue("FieldUpdated", out string fieldUpdated);
            JobStatuses  previousStatus  = _connectRequestService.PreviousJobStatus(job);
            RequestRoles changedByRole   = GetChangedByRole(job);
            string       supportActivity = job.JobSummary.SupportActivity.FriendlyNameShort();

            bool showJobUrl = emailRecipientRequestRole == RequestRoles.Volunteer ||
                              emailRecipientRequestRole == RequestRoles.GroupAdmin ||
                              (emailRecipientRequestRole == RequestRoles.Requestor && job.JobSummary.RequestorDefinedByGroup);
            string jobUrl = showJobUrl ? GetJobUrl(jobId.Value) : string.Empty;

            // First table
            List <TaskDataItem> importantDataList = new List <TaskDataItem>();

            AddIfNotNullOrEmpty(importantDataList, "Status", job.JobSummary.JobStatus.FriendlyName().ToTitleCase());
            AddIfNotNullOrEmpty(importantDataList, "Reference", GetReference(emailRecipientRequestRole, job));

            // Second table
            string requestedBy   = GetRequestedBy(emailRecipientRequestRole, job);
            string helpRecipient = GetHelpRecipient(emailRecipientRequestRole, job);

            List <TaskDataItem> otherDataList = new List <TaskDataItem>();

            AddIfNotNullOrEmpty(otherDataList, "Request type", supportActivity.ToTitleCase());
            AddIfNotNullOrEmpty(otherDataList, "Help needed", GetDueDate(job));
            AddIfNotNullOrEmpty(otherDataList, "Help needed", GetShiftDetails(job));
            AddIfNotNullOrEmpty(otherDataList, "Location", GetLocationDetails(job));
            AddIfNotNullOrEmpty(otherDataList, "Requested by", requestedBy);
            AddIfNotNullOrEmpty(otherDataList, "Help requested from", await GetHelpRequestedFrom(job));
            if (!helpRecipient.Equals(requestedBy))
            {
                AddIfNotNullOrEmpty(otherDataList, "Recipient", helpRecipient);
            }
            AddIfNotNullOrEmpty(otherDataList, "Volunteer", await GetVolunteer(emailRecipientRequestRole, job));

            return(new EmailBuildData()
            {
                BaseDynamicData = new TaskUpdateSimplifiedData
                                  (
                    $"A {supportActivity} request has been updated",
                    $"A {supportActivity} request has been updated",
                    emailToFirstName,
                    changedByRole == RequestRoles.GroupAdmin ? "group administrator" : "volunteer",
                    fieldUpdated.ToLower(),
                    showJobUrl,
                    jobUrl,
                    importantDataList,
                    otherDataList,
                    faceCoveringComplete: job.JobSummary.SupportActivity == SupportActivities.FaceMask && job.JobSummary.JobStatus == JobStatuses.Done,
                    previouStatusCompleteAndNowInProgress: previousStatus == JobStatuses.Done && job.JobSummary.JobStatus == JobStatuses.InProgress,
                    previouStatusInProgressAndNowOpen: previousStatus == JobStatuses.InProgress && job.JobSummary.JobStatus == JobStatuses.Open,
                    statusNowCancelled: job.JobSummary.JobStatus == JobStatuses.Cancelled,
                    GetFeedback(job, emailRecipientRequestRole)
                                  ),
                EmailToAddress = emailToAddress,
                EmailToName = emailToFullName,
                JobID = job.JobSummary.JobID,
                RequestID = job.JobSummary.RequestID,
                GroupID = job.JobSummary.ReferringGroupID,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = job.JobSummary.ReferringGroupID,
                        R = job.JobSummary.RequestID,
                        J = job.JobSummary.JobID
                    }
                }
            });
        }
Exemplo n.º 4
0
        public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
        {
            CacheItemPolicy cacheItemPolicy = new CacheItemPolicy();

            cacheItemPolicy.AbsoluteExpiration = DateTime.Now.AddHours(1.0);

            ObjectCache cache = MemoryCache.Default;

            if (recipientUserId == null)
            {
                throw new BadRequestException("recipientUserId is null");
            }

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

            if (user == null)
            {
                throw new BadRequestException($"unable to retrieve user object for {recipientUserId.Value}");
            }

            var job = await _connectRequestService.GetJobDetailsAsync(jobId.Value);

            var volunteerInstructions = "";

            var instructions = await _connectGroupService.GetGroupSupportActivityInstructions(job.JobSummary.ReferringGroupID, job.JobSummary.SupportActivity);

            volunteerInstructions = $"{Markdown.ParseHtmlString(instructions.Intro)}";
            if (instructions.Steps?.Count > 0)
            {
                var steps = string.Join("", instructions.Steps.Select(x => $"<li><u>{Markdown.ParseHtmlString(x.Heading)}</u> {Markdown.ParseHtmlString(x.Detail)}</li>"));
                volunteerInstructions += $"<ol>{steps}</ol>";
            }
            volunteerInstructions += Markdown.ParseHtmlString(instructions.Close);

            var allQuestions       = job.JobSummary.Questions.Where(q => q.ShowOnTaskManagement(false, false) && !string.IsNullOrEmpty(q.Answer));
            var otherQuestionsList = string.Join("", allQuestions.Select(x => $"<p><strong>{x.FriendlyName()}:</strong><br />{x.Answer.ToHtmlSafeStringWithLineBreaks()}</p>"));

            return(new EmailBuildData()
            {
                BaseDynamicData = new TaskDetailData(
                    organisation: job.JobSummary.RecipientOrganisation,
                    activity: job.JobSummary.SupportActivity.FriendlyNameShort(),
                    furtherDetails: otherQuestionsList,
                    volunteerInstructions: volunteerInstructions,
                    hasOrganisation: !String.IsNullOrEmpty(job.JobSummary.RecipientOrganisation)
                    ),
                EmailToAddress = user.UserPersonalDetails.EmailAddress,
                EmailToName = user.UserPersonalDetails.DisplayName,
                JobID = job.JobSummary.JobID,
                RequestID = job.JobSummary.RequestID,
                GroupID = job.JobSummary.ReferringGroupID,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = job.JobSummary.ReferringGroupID,
                        R = job.JobSummary.RequestID,
                        J = job.JobSummary.JobID
                    }
                }
            });
        }
Exemplo n.º 5
0
        public async Task <EmailBuildData> PrepareTemplateData(Guid batchId, int?recipientUserId, int?jobId, int?groupId, int?requestId, Dictionary <string, string> additionalParameters, string templateName)
        {
            if (!recipientUserId.HasValue)
            {
                throw new Exception($"RecipientID is missing");
            }

            if (recipientUserId.Value > 0)
            {
                var user = await _connectUserService.GetUserByIdAsync(recipientUserId.Value);
            }
            var recipientDetails = await GetRecipientDetails(recipientUserId, additionalParameters);

            string recipientFirstName = string.Empty;
            string senderName         = string.Empty;

            additionalParameters.TryGetValue("SenderRequestorRole", out string senderRequestorRole);
            string senderMessage  = string.Empty;
            string emailToAddress = string.Empty;
            string emailToName    = string.Empty;

            additionalParameters.TryGetValue("ToRequestorRole", out string toRequestorRole);
            additionalParameters.TryGetValue("SenderGroupName", out string senderGroupName);
            additionalParameters.TryGetValue("ToGroupName", out string toGroupName);
            string subject = GetSubject(toGroupName);
            string title   = GetTitle(toGroupName);


            if (recipientDetails != null)
            {
                emailToAddress     = recipientDetails[RECIPIENT_EMAIL_ADDRESS];
                emailToName        = recipientDetails[RECIPIENT_DISPLAY_NAME];
                recipientFirstName = recipientDetails[RECIPIENT_FIRST_NAME];
            }

            if (additionalParameters != null)
            {
                additionalParameters.TryGetValue("SenderMessage", out senderMessage);
                additionalParameters.TryGetValue("SenderName", out senderName);
            }

            GetJobDetailsResponse job = null;

            if (jobId.HasValue)
            {
                job = await _connectRequestService.GetJobDetailsAsync(jobId.Value);
            }

            string senderAndContext = await SenderAndContext(senderName, senderRequestorRole, toRequestorRole, senderGroupName, job);

            return(new EmailBuildData()
            {
                BaseDynamicData = new InterUserMessageData(
                    title,
                    subject,
                    recipientFirstName,
                    senderAndContext,
                    senderName,
                    senderMessage
                    ),
                EmailToAddress = emailToAddress,
                EmailToName = emailToName,
                JobID = job.JobSummary.JobID,
                RequestID = job.JobSummary.RequestID,
                GroupID = job.JobSummary.ReferringGroupID,
                ReferencedJobs = new List <ReferencedJob>()
                {
                    new ReferencedJob()
                    {
                        G = job.JobSummary.ReferringGroupID,
                        R = job.JobSummary.RequestID,
                        J = job.JobSummary.JobID
                    }
                }
            });
        }