The phishing simulation report for {{.CampaignName}} is attached.
" + +// renderReportEmailField renders a report email subject or body template with the +// given data. on a parse or execute error it logs and falls back to the default +// template so delivery is never blocked by a malformed custom template. +func renderReportEmailField(c *Campaign, tmplStr string, fallback string, data any) string { + render := func(s string) (string, error) { + t, err := template.New("reportEmail").Funcs(TemplateFuncs()).Parse(s) + if err != nil { + return "", err + } + var b bytes.Buffer + if err := t.Execute(&b, data); err != nil { + return "", err + } + return b.String(), nil + } + out, err := render(tmplStr) + if err != nil { + c.Logger.Warnw("failed to render report email template, using default", "error", err) + if out, err = render(fallback); err != nil { + return "" + } + } + return out +} + +// sanitizeReportFilename removes characters that are unsafe in filenames +func sanitizeReportFilename(name string) string { + replacer := strings.NewReplacer( + "/", "-", "\\", "-", ":", "-", "*", "-", + "?", "-", "\"", "-", "<", "-", ">", "-", "|", "-", + ) + safe := strings.TrimSpace(replacer.Replace(name)) + if safe == "" { + return "campaign" + } + return safe +} + +// resolveEffectiveReportConfig merges a company config with the global default +// config. the enabled and send-on-finish decisions always come from the company +// config; each delivery field uses the company value when set, otherwise the +// global default. +func resolveEffectiveReportConfig(company, global *model.CompanyReportConfig) *model.CompanyReportConfig { + uuidSet := func(v nullable.Nullable[uuid.UUID]) bool { return v.IsSpecified() && !v.IsNull() } + emailSet := func(v nullable.Nullable[vo.Email]) bool { return v.IsSpecified() && !v.IsNull() } + strSet := func(v nullable.Nullable[string]) bool { + return v.IsSpecified() && !v.IsNull() && strings.TrimSpace(v.MustGet()) != "" + } + + eff := &model.CompanyReportConfig{ + Enabled: company.Enabled, + SendOnFinish: company.SendOnFinish, + RecipientGroupID: company.RecipientGroupID, + SMTPConfigurationID: company.SMTPConfigurationID, + SenderEmail: company.SenderEmail, + EmailSubject: company.EmailSubject, + EmailBody: company.EmailBody, + } + if global == nil { + return eff + } + if !uuidSet(eff.RecipientGroupID) { + eff.RecipientGroupID = global.RecipientGroupID + } + if !uuidSet(eff.SMTPConfigurationID) { + eff.SMTPConfigurationID = global.SMTPConfigurationID + } + if !emailSet(eff.SenderEmail) { + eff.SenderEmail = global.SenderEmail + } + if !strSet(eff.EmailSubject) { + eff.EmailSubject = global.EmailSubject + } + if !strSet(eff.EmailBody) { + eff.EmailBody = global.EmailBody + } + return eff +} + +// SendCampaignReport renders the campaign report PDF and emails it to the +// company's configured recipient group using the configured SMTP. when onDemand +// is false the send is treated as the automatic on close delivery and silently +// skips when the company has not enabled it; when onDemand is true the caller +// receives an error explaining why delivery is not possible. +func (c *Campaign) SendCampaignReport( + ctx context.Context, + session *model.Session, + campaignID *uuid.UUID, + onDemand bool, +) error { + ae := NewAuditEvent("Campaign.SendCampaignReport", session) + ae.Details["campaignId"] = campaignID.String() + isAuthorized, authErr := IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL) + if authErr != nil && !errors.Is(authErr, errs.ErrAuthorizationFailed) { + c.LogAuthError(authErr) + return errs.Wrap(authErr) + } + if !isAuthorized { + c.AuditLogNotAuthorized(ae) + return errs.ErrAuthorizationFailed + } + // global PDF report generation must be enabled + opt, _ := c.OptionService.GetOptionWithoutAuth(ctx, data.OptionKeyReportPDFEnabled) + if opt == nil || opt.Value.String() != "true" { + if onDemand { + return errs.NewCustomError(errors.New("PDF report generation is not enabled")) + } + return nil + } + // load the campaign to resolve its company + campaign, err := c.CampaignRepository.GetByID(ctx, campaignID, &repository.CampaignOption{WithCompany: true}) + if err != nil { + return errs.Wrap(err) + } + var companyIDPtr *uuid.UUID + if cid, cErr := campaign.CompanyID.Get(); cErr == nil { + companyIDPtr = &cid + } + // the enable decision is per company: the company must have its own config + companyConfig, err := c.CompanyReportConfigRepository.GetByCompanyID(ctx, companyIDPtr) + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + if onDemand { + return errs.NewCustomError(errors.New("report delivery is not configured for this company")) + } + return nil + } + return errs.Wrap(err) + } + if !companyConfig.Enabled { + if onDemand { + return errs.NewCustomError(errors.New("report delivery is not enabled for this company")) + } + return nil + } + // for the automatic path the company must have opted into on close delivery + if !onDemand && !companyConfig.SendOnFinish { + return nil + } + // committed to attempting delivery from here: audit the outcome on every path + deliveryOutcome := "failed" + defer func() { + ae.Details["outcome"] = deliveryOutcome + ae.Details["onDemand"] = onDemand + c.AuditLogAuthorized(ae) + }() + // the global config supplies default delivery fields the company has not set + var globalConfig *model.CompanyReportConfig + if g, gErr := c.CompanyReportConfigRepository.GetByCompanyID(ctx, nil); gErr == nil { + globalConfig = g + } else if !errors.Is(gErr, gorm.ErrRecordNotFound) { + return errs.Wrap(gErr) + } + config := resolveEffectiveReportConfig(companyConfig, globalConfig) + + trigger := "on_finish" + if onDemand { + trigger = "on_demand" + } + campaignName := "" + if n, nErr := campaign.Name.Get(); nErr == nil { + campaignName = n.String() + } + // filled in once the effective config is validated and resolved; the log + // closure reads them by reference so it can record partial failures too + groupName := "" + senderEmailStr := "" + // writeReportSendLog records the outcome of this delivery attempt. logging must + // never break delivery, so its own failure is only logged. + writeReportSendLog := func(status string, recipients []string, sendErr error) { + errMsg := "" + if sendErr != nil { + errMsg = sendErr.Error() + } + logRow := &model.ReportSendLog{ + CompanyID: nullableUUIDPtr(companyIDPtr), + CampaignID: nullable.NewNullableWithValue(*campaignID), + CampaignName: campaignName, + GroupName: groupName, + Trigger: trigger, + Status: status, + RecipientCount: len(recipients), + Recipients: strings.Join(recipients, ", "), + SenderEmail: senderEmailStr, + ErrorMessage: errMsg, + } + if _, logErr := c.ReportSendLogRepository.Insert(ctx, logRow); logErr != nil { + c.Logger.Errorw("failed to write report send log", "error", logErr, "campaignID", campaignID.String()) + } + } + + // the effective config must be complete enough to deliver + if err := config.Validate(); err != nil { + writeReportSendLog("failed", nil, err) + if onDemand { + return errs.Wrap(err) + } + c.Logger.Warnw("skipping automatic report delivery, config incomplete", "error", err, "campaignID", campaignID.String()) + return nil + } + configID := companyConfig.ID.MustGet() + groupID := config.RecipientGroupID.MustGet() + smtpConfigID := config.SMTPConfigurationID.MustGet() + senderEmail := config.SenderEmail.MustGet() + senderEmailStr = senderEmail.String() + + // resolve the recipient group name now so the log keeps it even if the group is + // deleted later. an empty name means the group no longer exists. + if group, gErr := c.RecipientGroupRepository.GetByID(ctx, &groupID, &repository.RecipientGroupOption{}); gErr == nil && group != nil { + if n, nErr := group.Name.Get(); nErr == nil { + groupName = n.String() + } + } + + // build the report and render it to PDF + htmlContent, reportData, _, err := c.buildReportHTMLWithData(ctx, session, campaignID) + if err != nil { + writeReportSendLog("failed", nil, fmt.Errorf("failed to build report: %w", err)) + return errs.Wrap(err) + } + pdfBytes, err := remotebrowser.RenderHTMLToPDF(ctx, htmlContent, c.RemoteBrowserExecPath) + if err != nil { + c.Logger.Errorw("failed to render report PDF", "error", err) + writeReportSendLog("failed", nil, fmt.Errorf("failed to render report PDF: %w", err)) + return errs.Wrap(err) + } + // load the smtp configuration to send through + smtpConfig, err := c.SMTPConfigService.GetByID( + ctx, + session, + &smtpConfigID, + &repository.SMTPConfigurationOption{WithHeaders: true}, + ) + if err != nil { + c.Logger.Errorw("failed to load smtp configuration for report", "error", err) + writeReportSendLog("failed", nil, fmt.Errorf("smtp configuration unavailable: %w", err)) + return errs.Wrap(err) + } + // resolve the recipients of the group; the group may have been deleted + recipientResult, err := c.RecipientGroupRepository.GetRecipientsByGroupID( + ctx, + &groupID, + &repository.RecipientOption{}, + ) + if err != nil { + c.Logger.Errorw("failed to get report recipients", "error", err) + writeReportSendLog("failed", nil, errors.New("the configured recipient group is unavailable")) + if onDemand { + return errs.NewCustomError(errors.New("the configured recipient group is unavailable, it may have been deleted")) + } + return nil + } + toEmails := []string{} + for _, r := range recipientResult.Rows { + if email, eErr := r.Email.Get(); eErr == nil { + toEmails = append(toEmails, email.String()) + } + } + if len(toEmails) == 0 { + writeReportSendLog("failed", nil, errors.New("the recipient group has no recipients")) + if onDemand { + return errs.NewCustomError(errors.New("the selected recipient group has no recipients")) + } + c.Logger.Warnw("skipping report delivery, recipient group is empty", "groupID", groupID.String()) + return nil + } + // build the report email with the PDF attached + filename := fmt.Sprintf("report-%s.pdf", sanitizeReportFilename(campaignName)) + m := mail.NewMsg(mail.WithNoDefaultUserAgent()) + if err := m.EnvelopeFrom(senderEmail.String()); err != nil { + return errs.Wrap(err) + } + if err := m.From(senderEmail.String()); err != nil { + return errs.Wrap(err) + } + if err := m.To(toEmails...); err != nil { + return errs.Wrap(err) + } + if headers := smtpConfig.Headers; headers != nil { + for _, header := range headers { + m.SetGenHeader(mail.Header(header.Key.MustGet().String()), header.Value.MustGet().String()) + } + } + // the subject and body are configurable and support the same variables and + // template functions as the report template (e.g. {{.CompanyName}}, + // {{.CampaignName}}, dates and stats), with defaults when empty + subjectTmpl := defaultReportEmailSubject + if config.EmailSubject.IsSpecified() && !config.EmailSubject.IsNull() { + if v := config.EmailSubject.MustGet(); strings.TrimSpace(v) != "" { + subjectTmpl = v + } + } + bodyTmpl := defaultReportEmailBody + if config.EmailBody.IsSpecified() && !config.EmailBody.IsNull() { + if v := config.EmailBody.MustGet(); strings.TrimSpace(v) != "" { + bodyTmpl = v + } + } + subject := renderReportEmailField(c, subjectTmpl, defaultReportEmailSubject, reportData) + body := renderReportEmailField(c, bodyTmpl, defaultReportEmailBody, reportData) + m.Subject(subject) + m.SetBodyString("text/html", body) + if err := m.AttachReader(filename, bytes.NewReader(pdfBytes)); err != nil { + return errs.Wrap(err) + } + if err := c.SMTPConfigService.SendMessages(ctx, smtpConfig, m); err != nil { + c.Logger.Errorw("failed to send report email", "error", err) + writeReportSendLog("failed", toEmails, err) + return errs.Wrap(err) + } + writeReportSendLog("sent", toEmails, nil) + deliveryOutcome = "sent" + ae.Details["recipients"] = len(toEmails) + // record when the report was last delivered; the audit event is emitted by the + // deferred outcome handler + if err := c.CompanyReportConfigRepository.UpdateLastSentAt(ctx, &configID); err != nil { + c.Logger.Errorw("failed to update report last sent at", "error", err, "campaignID", campaignID.String()) + } + + return nil +} + +// nullableUUIDPtr converts a possibly nil uuid pointer into a nullable value +func nullableUUIDPtr(id *uuid.UUID) nullable.Nullable[uuid.UUID] { + if id == nil { + return nullable.NewNullNullable[uuid.UUID]() + } + return nullable.NewNullableWithValue(*id) } func buildReportData( diff --git a/backend/service/companyReportConfig.go b/backend/service/companyReportConfig.go new file mode 100644 index 0000000..3f3f0b8 --- /dev/null +++ b/backend/service/companyReportConfig.go @@ -0,0 +1,177 @@ +package service + +import ( + "context" + + "github.com/go-errors/errors" + "github.com/google/uuid" + "github.com/oapi-codegen/nullable" + "github.com/phishingclub/phishingclub/data" + "github.com/phishingclub/phishingclub/errs" + "github.com/phishingclub/phishingclub/model" + "github.com/phishingclub/phishingclub/repository" + "gorm.io/gorm" +) + +// CompanyReportConfig is the service for report delivery configuration. a nil +// companyID refers to the global default config used as a fallback. +type CompanyReportConfig struct { + Common + CompanyReportConfigRepository *repository.CompanyReportConfig + ReportSendLogRepository *repository.ReportSendLog +} + +// reportConfigScope returns a human label for the config scope for audit logging +func reportConfigScope(companyID *uuid.UUID) string { + if companyID == nil { + return "global" + } + return companyID.String() +} + +// GetByCompanyID returns the report config for the given company +func (s *CompanyReportConfig) GetByCompanyID( + ctx context.Context, + session *model.Session, + companyID *uuid.UUID, +) (*model.CompanyReportConfig, error) { + ae := NewAuditEvent("CompanyReportConfig.GetByCompanyID", session) + ae.Details["scope"] = reportConfigScope(companyID) + // check permissions + isAuthorized, err := IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL) + if err != nil { + s.LogAuthError(err) + return nil, errs.Wrap(err) + } + if !isAuthorized { + s.AuditLogNotAuthorized(ae) + return nil, errs.ErrAuthorizationFailed + } + // get + config, err := s.CompanyReportConfigRepository.GetByCompanyID(ctx, companyID) + if err != nil { + s.Logger.Errorw("failed to get report config by company id", "error", err) + return nil, errs.Wrap(err) + } + // no audit on read + + return config, nil +} + +// Upsert creates or updates the report delivery configuration for the given company +func (s *CompanyReportConfig) Upsert( + ctx context.Context, + session *model.Session, + companyID *uuid.UUID, + incoming *model.CompanyReportConfig, +) (*model.CompanyReportConfig, error) { + ae := NewAuditEvent("CompanyReportConfig.Upsert", session) + ae.Details["scope"] = reportConfigScope(companyID) + // check permissions + isAuthorized, err := IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL) + if err != nil { + s.LogAuthError(err) + return nil, errs.Wrap(err) + } + if !isAuthorized { + s.AuditLogNotAuthorized(ae) + return nil, errs.ErrAuthorizationFailed + } + // delivery fields are not required at save time: a company config may enable + // delivery while inheriting unset fields from the global default, and the + // global config is itself only a set of defaults. completeness is enforced on + // the effective (merged) config when a report is actually sent. + // a nil companyID targets the global default config. enabling and on-finish + // delivery are per company decisions, so they are never stored on the global + // config which only supplies default fields. + if companyID == nil { + incoming.CompanyID = nullable.NewNullNullable[uuid.UUID]() + incoming.Enabled = false + incoming.SendOnFinish = false + } else { + incoming.CompanyID = nullable.NewNullableWithValue(*companyID) + } + // check if a config already exists for this scope + existing, err := s.CompanyReportConfigRepository.GetByCompanyID(ctx, companyID) + if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) { + s.Logger.Errorw("failed to look up existing report config", "error", err) + return nil, errs.Wrap(err) + } + if existing != nil { + existingID, idErr := existing.ID.Get() + if idErr != nil { + s.Logger.Errorw("report config has no id", "error", idErr) + return nil, errs.Wrap(idErr) + } + if err := s.CompanyReportConfigRepository.UpdateByID(ctx, &existingID, incoming); err != nil { + s.Logger.Errorw("failed to update report config", "error", err) + return nil, errs.Wrap(err) + } + ae.Details["id"] = existingID.String() + ae.Details["action"] = "update" + s.AuditLogAuthorized(ae) + return s.CompanyReportConfigRepository.GetByID(ctx, &existingID) + } + // create + id, err := s.CompanyReportConfigRepository.Insert(ctx, incoming) + if err != nil { + s.Logger.Errorw("failed to insert report config", "error", err) + return nil, errs.Wrap(err) + } + ae.Details["id"] = id.String() + ae.Details["action"] = "insert" + s.AuditLogAuthorized(ae) + + return s.CompanyReportConfigRepository.GetByID(ctx, id) +} + +// DeleteByCompanyID removes the report configuration for the given company +func (s *CompanyReportConfig) DeleteByCompanyID( + ctx context.Context, + session *model.Session, + companyID *uuid.UUID, +) error { + ae := NewAuditEvent("CompanyReportConfig.DeleteByCompanyID", session) + ae.Details["scope"] = reportConfigScope(companyID) + // check permissions + isAuthorized, err := IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL) + if err != nil { + s.LogAuthError(err) + return errs.Wrap(err) + } + if !isAuthorized { + s.AuditLogNotAuthorized(ae) + return errs.ErrAuthorizationFailed + } + // delete + if err := s.CompanyReportConfigRepository.DeleteByCompanyID(ctx, companyID); err != nil { + s.Logger.Errorw("failed to delete report config", "error", err) + return errs.Wrap(err) + } + s.AuditLogAuthorized(ae) + + return nil +} + +// ListLogByCompanyID returns the report delivery log for a company using pagination +func (s *CompanyReportConfig) ListLogByCompanyID( + ctx context.Context, + session *model.Session, + companyID *uuid.UUID, + options *repository.ReportSendLogOption, +) (*model.Result[model.ReportSendLog], error) { + ae := NewAuditEvent("CompanyReportConfig.ListLogByCompanyID", session) + ae.Details["scope"] = reportConfigScope(companyID) + // check permissions + isAuthorized, err := IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL) + if err != nil { + s.LogAuthError(err) + return nil, errs.Wrap(err) + } + if !isAuthorized { + s.AuditLogNotAuthorized(ae) + return nil, errs.ErrAuthorizationFailed + } + // no audit on read + return s.ReportSendLogRepository.GetAllByCompanyID(ctx, companyID, options) +} diff --git a/backend/service/smtpConfiguration.go b/backend/service/smtpConfiguration.go index 4d0809c..0f4351d 100644 --- a/backend/service/smtpConfiguration.go +++ b/backend/service/smtpConfiguration.go @@ -625,3 +625,111 @@ func (s *SMTPConfiguration) DeleteByID( return nil } + +// SendMessages dials the SMTP server described by smtpConfig and sends the given +// messages over a single connection, applying the same authentication fallback +// used by campaign and test sending. it performs no authorization check; callers +// must authorize before building messages. +func (s *SMTPConfiguration) SendMessages( + ctx context.Context, + smtpConfig *model.SMTPConfiguration, + messages ...*mail.Msg, +) error { + if len(messages) == 0 { + return nil + } + smtpPort, err := smtpConfig.Port.Get() + if err != nil { + s.Logger.Errorw("failed to get smtp port", "error", err) + return errs.Wrap(err) + } + smtpHost, err := smtpConfig.Host.Get() + if err != nil { + s.Logger.Errorw("failed to get smtp host", "error", err) + return errs.Wrap(err) + } + smtpIgnoreCertErrors, err := smtpConfig.IgnoreCertErrors.Get() + if err != nil { + s.Logger.Errorw("failed to get smtp ignore cert errors", "error", err) + return errs.Wrap(err) + } + emailOptions := []mail.Option{ + mail.WithPort(smtpPort.Int()), + mail.WithTLSConfig( + &tls.Config{ + ServerName: smtpHost.String(), + // #nosec + InsecureSkipVerify: smtpIgnoreCertErrors, + }, + ), + } + username, err := smtpConfig.Username.Get() + if err != nil { + s.Logger.Errorw("failed to get smtp username", "error", err) + return errs.Wrap(err) + } + password, err := smtpConfig.Password.Get() + if err != nil { + s.Logger.Errorw("failed to get smtp password", "error", err) + return errs.Wrap(err) + } + if un := username.String(); len(un) > 0 { + emailOptions = append(emailOptions, mail.WithUsername(un)) + if pw := password.String(); len(pw) > 0 { + emailOptions = append(emailOptions, mail.WithPassword(pw)) + } + } + var mc *mail.Client + if un := username.String(); len(un) > 0 { + // try CRAM-MD5 first when credentials are provided + emailOptionsCRAM5 := append(emailOptions, mail.WithSMTPAuth(mail.SMTPAuthCramMD5)) + mc, _ = mail.NewClient(smtpHost.String(), emailOptionsCRAM5...) + mc.SetLogger(log.NewGoMailLoggerAdapter(s.Logger)) + mc.SetDebugLog(true) + if build.Flags.Production { + mc.SetTLSPolicy(mail.TLSMandatory) + } else { + mc.SetTLSPolicy(mail.TLSOpportunistic) + } + err = mc.DialAndSendWithContext(ctx, messages...) + // on auth error fall back to PLAIN auth + if err != nil && (strings.Contains(err.Error(), "535 ") || + strings.Contains(err.Error(), "534 ") || + strings.Contains(err.Error(), "538 ") || + strings.Contains(err.Error(), "CRAM-MD5") || + strings.Contains(err.Error(), "authentication failed")) { + s.Logger.Debugf("CRAM-MD5 authentication failed, trying PLAIN auth", "error", err) + emailOptionsBasic := append(emailOptions, mail.WithSMTPAuth(mail.SMTPAuthPlain)) + mc, _ = mail.NewClient(smtpHost.String(), emailOptionsBasic...) + mc.SetLogger(log.NewGoMailLoggerAdapter(s.Logger)) + mc.SetDebugLog(true) + if build.Flags.Production { + mc.SetTLSPolicy(mail.TLSMandatory) + } else { + mc.SetTLSPolicy(mail.TLSOpportunistic) + } + err = mc.DialAndSendWithContext(ctx, messages...) + } + } else { + // no credentials provided, try without authentication + mc, _ = mail.NewClient(smtpHost.String(), emailOptions...) + mc.SetLogger(log.NewGoMailLoggerAdapter(s.Logger)) + mc.SetDebugLog(true) + if build.Flags.Production { + mc.SetTLSPolicy(mail.TLSMandatory) + } else { + mc.SetTLSPolicy(mail.TLSOpportunistic) + } + err = mc.DialAndSendWithContext(ctx, messages...) + } + if err != nil { + s.Logger.Errorw("failed to send messages", "error", err) + for _, m := range messages { + if m.HasSendError() { + return m.SendError() + } + } + return errs.Wrap(err) + } + return nil +} diff --git a/frontend/src/lib/api/api.js b/frontend/src/lib/api/api.js index c320402..59a4d81 100644 --- a/frontend/src/lib/api/api.js +++ b/frontend/src/lib/api/api.js @@ -1290,6 +1290,53 @@ export class API { return await postJSON(this.getPath(`/company/scim/${companyID}/restore`), {}); } }, + + reportConfig: { + // path for a scope: a company id, or the global default when companyID is null + scopePath: (companyID) => + companyID ? `/company/report-config/${companyID}` : `/report-config`, + // get the report delivery config for a company, or the global default when companyID is null + getByCompanyID: async (companyID) => { + return await getJSON(this.getPath(this.company.reportConfig.scopePath(companyID))); + }, + // create or update the report delivery config for a company or the global default + upsert: async ( + companyID, + { + enabled, + sendOnFinish, + recipientGroupID, + smtpConfigurationID, + senderEmail, + emailSubject, + emailBody + } + ) => { + return await postJSON(this.getPath(this.company.reportConfig.scopePath(companyID)), { + enabled: enabled, + sendOnFinish: sendOnFinish, + recipientGroupID: recipientGroupID ?? null, + smtpConfigurationID: smtpConfigurationID ?? null, + senderEmail: senderEmail ?? null, + emailSubject: emailSubject ?? '', + emailBody: emailBody ?? '' + }); + }, + // delete the report delivery config for a company or the global default + delete: async (companyID) => { + return await deleteJSON(this.getPath(this.company.reportConfig.scopePath(companyID))); + }, + // get the report delivery log for a company using pagination + getLog: async (companyID, options) => { + return await getJSON( + this.getPath(`/company/report-config/${companyID}/log?${appendQuery(options)}`) + ); + }, + // generate the report for a campaign and email it to the configured group now + sendNow: async (campaignID) => { + return await postJSON(this.getPath(`/report-config/send/${campaignID}`), {}); + } + }, /** * Get the auto-prune orphaned recipients setting for a company. * Returns only the per-company enabled flag. diff --git a/frontend/src/lib/components/company/CompanyReportDeliveryLog.svelte b/frontend/src/lib/components/company/CompanyReportDeliveryLog.svelte new file mode 100644 index 0000000..ab98bdc --- /dev/null +++ b/frontend/src/lib/components/company/CompanyReportDeliveryLog.svelte @@ -0,0 +1,93 @@ + + +Loading...
++ PDF report generation is disabled. Enable it under Settings → Reports before configuring + automatic delivery. +
++ Email the campaign report PDF to a recipient group, on demand or automatically when a + campaign is closed. + {#if isGlobal} + These are the global defaults used for any field a company does not set itself. + {:else} + Leave a field empty to use the global default. Enabling delivery is decided here, per + company. + {/if} +
+ + {#if config && !isGlobal} +Enabled
++ Turn report delivery on for this company. +
++ Send automatically on finish +
++ Deliver the report when a campaign is closed. When off, send on demand only. +
++ Host {selectedSmtp.host} +
+ {#if selectedSmtp.username} ++ Username + {selectedSmtp.username} +
+ {/if} +Email body
++ Subject and body support the same variables as the report template, such as {'{{.CompanyName}}'}, + {' '}{'{{.CampaignName}}'} and {'{{.ReportDate}}'}. + {isGlobal + ? 'The default is shown and can be edited.' + : 'Leave empty to use the global default.'} +
++ Are you sure you want to delete the report delivery configuration for + {isGlobal ? 'the global default' : company?.name}? +
++ PDF report generation is disabled. Enable it under Settings → Reports to configure + report templates and delivery. +
+@@ -303,7 +328,29 @@ >
+ Email the campaign report PDF to a recipient group, on demand or when a campaign is + closed. +
++ Reports sent for this company, including automatic and on demand deliveries. +
+Default HTML template used when generating campaign PDF reports. Companies without their own @@ -187,10 +191,24 @@
+ Default delivery settings used to email campaign reports. Companies without their own + configuration fall back to this. +
+