Esempio n. 1
0
        public async Task <IActionResult> GetEmailPreview([FromBody] PreviewRequestDto request)
        {
            var app = new App
            {
                Name = request.AppName
            };

            try
            {
                if (request.TemplateType == PreviewType.Html)
                {
                    var template = new EmailTemplate
                    {
                        BodyHtml = request.Template
                    };

                    var formatted = await emailFormatter.FormatAsync(Notifications, template, app, EmailUser, true);

                    var response = new PreviewDto
                    {
                        Result = formatted.BodyHtml !
                    };

                    return(Ok(response));
                }
                else
                {
                    var template = new EmailTemplate
                    {
                        BodyText = request.Template
                    };

                    var formatted = await emailFormatter.FormatAsync(Notifications, template, app, EmailUser, true);

                    var response = new PreviewDto
                    {
                        Result = formatted.BodyText !
                    };

                    return(Ok(response));
                }
            }
            catch (EmailFormattingException ex)
            {
                var response = new PreviewDto
                {
                    Errors = ex.Errors.ToArray()
                };

                return(StatusCode(400, response));
            }
        }
Esempio n. 2
0
        public async Task SendJobsAsync(List <EmailJob> jobs,
                                        CancellationToken ct)
        {
            using (Telemetry.Activities.StartActivity("Send"))
            {
                var first = jobs[0];

                var commonEmail = first.EmailAddress;
                var commonApp   = first.Notification.AppId;
                var commonUser  = first.Notification.UserId;

                await UpdateAsync(first.Notification, commonEmail, ProcessStatus.Attempt);

                var app = await appStore.GetCachedAsync(first.Notification.AppId, ct);

                if (app == null)
                {
                    log.LogWarning("Cannot send email: App not found.");

                    await UpdateAsync(jobs, commonEmail, ProcessStatus.Handled);

                    return;
                }

                try
                {
                    var user = await userStore.GetCachedAsync(commonApp, commonUser, ct);

                    if (user == null)
                    {
                        await SkipAsync(jobs, commonEmail, Texts.Email_UserDeleted);

                        return;
                    }

                    if (string.IsNullOrWhiteSpace(user.EmailAddress))
                    {
                        await SkipAsync(jobs, commonEmail, Texts.Email_UserNoEmail);

                        return;
                    }

                    var senders = integrationManager.Resolve <IEmailSender>(app, first.Notification).Select(x => x.Target).ToList();

                    if (senders.Count == 0)
                    {
                        await SkipAsync(jobs, commonEmail, Texts.Email_ConfigReset);

                        return;
                    }

                    EmailMessage?message;

                    using (Telemetry.Activities.StartActivity("Format"))
                    {
                        var(skip, template) = await GetTemplateAsync(
                            first.Notification.AppId,
                            first.Notification.UserLanguage,
                            first.EmailTemplate,
                            ct);

                        if (skip != null)
                        {
                            await SkipAsync(jobs, commonEmail, skip !);

                            return;
                        }

                        if (template == null)
                        {
                            return;
                        }

                        var(result, errors) = await emailFormatter.FormatAsync(jobs, template, app, user, false, ct);

                        if (errors.Count > 0 || result == null)
                        {
                            throw new EmailFormattingException(errors);
                        }

                        message = result;
                    }

                    await SendCoreAsync(message, app.Id, senders, ct);

                    await UpdateAsync(jobs, commonEmail, ProcessStatus.Handled);
                }
                catch (DomainException ex)
                {
                    await logStore.LogAsync(app.Id, Name, ex.Message);

                    throw;
                }
            }
        }