7e0d187dcf
Remove the root complianceportal package and the resolver facade that existed only to break an IAM import cycle. Admin policies, domain URL helpers, and actions live under management; visitor OAuth metadata, brand URLs, and public read paths live under visitor. Drop the duplicate trust API magic-link mutations now that Connect handles portal auth, and stop IAM from owning compliance page email branding. Signed-off-by: Bryan Frimin <bryan@probo.com>
894 lines
22 KiB
Go
894 lines
22 KiB
Go
// Copyright (c) 2026 Probo Inc <hello@probo.com>.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
package mailman
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"go.gearno.de/kit/log"
|
|
"go.gearno.de/kit/pg"
|
|
"go.probo.inc/probo/packages/emails"
|
|
"go.probo.inc/probo/pkg/baseurl"
|
|
"go.probo.inc/probo/pkg/complianceportal/management"
|
|
"go.probo.inc/probo/pkg/coredata"
|
|
"go.probo.inc/probo/pkg/crypto/cipher"
|
|
"go.probo.inc/probo/pkg/filemanager"
|
|
"go.probo.inc/probo/pkg/gid"
|
|
"go.probo.inc/probo/pkg/mail"
|
|
"go.probo.inc/probo/pkg/page"
|
|
"go.probo.inc/probo/pkg/validator"
|
|
)
|
|
|
|
const (
|
|
updateTitleMaxLength = 200
|
|
updateBodyMaxLength = 50000
|
|
subscriberFullNameMaxLength = 200
|
|
)
|
|
|
|
const (
|
|
pathUnsubscribe = "/mail-actions/unsubscribe"
|
|
pathConfirm = "/mail-actions/confirm"
|
|
)
|
|
|
|
type Service struct {
|
|
pg *pg.Client
|
|
fm *filemanager.Service
|
|
tokenSecret string
|
|
apiBaseURL *baseurl.BaseURL
|
|
compliancePortal *management.Service
|
|
bucket string
|
|
encryptionKey cipher.EncryptionKey
|
|
logger *log.Logger
|
|
}
|
|
|
|
func NewService(
|
|
pgClient *pg.Client,
|
|
fm *filemanager.Service,
|
|
tokenSecret string,
|
|
apiBaseURL *baseurl.BaseURL,
|
|
compliancePortal *management.Service,
|
|
bucket string,
|
|
encryptionKey cipher.EncryptionKey,
|
|
logger *log.Logger,
|
|
) *Service {
|
|
return &Service{
|
|
pg: pgClient,
|
|
fm: fm,
|
|
tokenSecret: tokenSecret,
|
|
apiBaseURL: apiBaseURL,
|
|
compliancePortal: compliancePortal,
|
|
bucket: bucket,
|
|
encryptionKey: encryptionKey,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
type (
|
|
CreateMailingListUpdateRequest struct {
|
|
MailingListID gid.GID
|
|
Title string
|
|
Body string
|
|
}
|
|
|
|
UpdateMailingListUpdateRequest struct {
|
|
ID gid.GID
|
|
Title *string
|
|
Body *string
|
|
}
|
|
|
|
CreateSubscriberRequest struct {
|
|
MailingListID gid.GID
|
|
Email mail.Addr
|
|
FullName string
|
|
Confirmed bool
|
|
}
|
|
)
|
|
|
|
func (r *CreateMailingListUpdateRequest) Validate() error {
|
|
v := validator.New()
|
|
|
|
v.Check(r.MailingListID, "mailing_list_id", validator.Required(), validator.GID(coredata.MailingListEntityType))
|
|
v.Check(r.Title, "title", validator.Required(), validator.SafeTextNoNewLine(updateTitleMaxLength))
|
|
v.Check(r.Body, "body", validator.Required(), validator.SafeText(updateBodyMaxLength))
|
|
|
|
return v.Error()
|
|
}
|
|
|
|
func (r *UpdateMailingListUpdateRequest) Validate() error {
|
|
v := validator.New()
|
|
|
|
v.Check(r.ID, "id", validator.Required(), validator.GID(coredata.MailingListUpdateEntityType))
|
|
v.Check(r.Title, "title", validator.SafeTextNoNewLine(updateTitleMaxLength))
|
|
v.Check(r.Body, "body", validator.SafeText(updateBodyMaxLength))
|
|
|
|
return v.Error()
|
|
}
|
|
|
|
func (r *CreateSubscriberRequest) Validate() error {
|
|
v := validator.New()
|
|
|
|
v.Check(r.MailingListID, "mailing_list_id", validator.Required(), validator.GID(coredata.MailingListEntityType))
|
|
v.Check(r.Email, "email", validator.Required(), validator.NotEmpty())
|
|
v.Check(r.FullName, "full_name", validator.Required(), validator.SafeTextNoNewLine(subscriberFullNameMaxLength))
|
|
|
|
return v.Error()
|
|
}
|
|
|
|
func (s *Service) UpdateMailingList(
|
|
ctx context.Context,
|
|
id gid.GID,
|
|
replyTo *mail.Addr,
|
|
) (*coredata.MailingList, error) {
|
|
var ml coredata.MailingList
|
|
|
|
scope := coredata.NewScopeFromObjectID(id)
|
|
|
|
err := s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
if err := ml.LoadByID(ctx, tx, scope, id); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrMailingListNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list: %w", err)
|
|
}
|
|
|
|
ml.ReplyTo = replyTo
|
|
ml.UpdatedAt = time.Now()
|
|
|
|
if err := ml.Update(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot update mailing list: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ml, nil
|
|
}
|
|
|
|
func (s *Service) GetSubscriber(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
email mail.Addr,
|
|
) (*coredata.MailingListSubscriber, error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
subscriber := coredata.MailingListSubscriber{}
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
if err := subscriber.LoadByMailingListIDAndEmail(ctx, conn, scope, mailingListID, email); err != nil {
|
|
return fmt.Errorf("cannot load mailing list subscriber: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, nil
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
return &subscriber, nil
|
|
}
|
|
|
|
func (s *Service) CreateSubscriber(
|
|
ctx context.Context,
|
|
req *CreateSubscriberRequest,
|
|
) (*coredata.MailingListSubscriber, error) {
|
|
if err := req.Validate(); err != nil {
|
|
return nil, fmt.Errorf("invalid request: %w", err)
|
|
}
|
|
|
|
mailingListID := req.MailingListID
|
|
email := req.Email
|
|
fullName := req.FullName
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
status := coredata.MailingListSubscriberStatusPending
|
|
|
|
var emailRecord *coredata.Email
|
|
|
|
if req.Confirmed {
|
|
status = coredata.MailingListSubscriberStatusConfirmed
|
|
} else {
|
|
var err error
|
|
|
|
emailRecord, err = s.buildConfirmationMail(ctx, mailingListID, email, fullName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot build confirmation mail: %w", err)
|
|
}
|
|
}
|
|
|
|
now := time.Now()
|
|
subscriber := &coredata.MailingListSubscriber{
|
|
ID: gid.New(scope.GetTenantID(), coredata.MailingListSubscriberEntityType),
|
|
MailingListID: mailingListID,
|
|
FullName: fullName,
|
|
Email: email,
|
|
Status: status,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
|
|
if err := s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
var ml coredata.MailingList
|
|
if err := ml.LoadByID(ctx, tx, scope, mailingListID); err != nil {
|
|
return fmt.Errorf("cannot load mailing list: %w", err)
|
|
}
|
|
|
|
subscriber.OrganizationID = ml.OrganizationID
|
|
|
|
if err := subscriber.Insert(ctx, tx, scope); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return ErrSubscriberAlreadyExist
|
|
}
|
|
|
|
return fmt.Errorf("cannot insert mailing list subscriber: %w", err)
|
|
}
|
|
|
|
if emailRecord != nil {
|
|
if err := emailRecord.Insert(ctx, tx); err != nil {
|
|
return fmt.Errorf("cannot insert subscription confirmation email: %w", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return subscriber, nil
|
|
}
|
|
|
|
func (s *Service) UnsubscribeByEmail(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
email mail.Addr,
|
|
) error {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
return s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
var subscriber coredata.MailingListSubscriber
|
|
if err := subscriber.LoadByMailingListIDAndEmail(ctx, tx, scope, mailingListID, email); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrSubscriberNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list subscriber: %w", err)
|
|
}
|
|
|
|
wasConfirmed := subscriber.Status == coredata.MailingListSubscriberStatusConfirmed
|
|
|
|
if err := subscriber.Delete(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot delete mailing list subscriber: %w", err)
|
|
}
|
|
|
|
if wasConfirmed {
|
|
emailRecord, err := s.buildUnsubscriptionMail(ctx, mailingListID, subscriber.Email, subscriber.FullName)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot build unsubscription email: %w", err)
|
|
}
|
|
|
|
if err := emailRecord.Insert(ctx, tx); err != nil {
|
|
return fmt.Errorf("cannot insert unsubscription email: %w", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (s *Service) ConfirmSubscriberByEmail(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
email mail.Addr,
|
|
) error {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
return s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
var subscriber coredata.MailingListSubscriber
|
|
if err := subscriber.LoadByMailingListIDAndEmail(ctx, tx, scope, mailingListID, email); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrSubscriberNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list subscriber: %w", err)
|
|
}
|
|
|
|
subscriber.Status = coredata.MailingListSubscriberStatusConfirmed
|
|
subscriber.UpdatedAt = time.Now()
|
|
|
|
if err := subscriber.Update(ctx, tx, scope); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrSubscriberNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot update mailing list subscriber: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (s *Service) DeleteSubscriber(
|
|
ctx context.Context,
|
|
id gid.GID,
|
|
) error {
|
|
scope := coredata.NewScopeFromObjectID(id)
|
|
|
|
return s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
var subscriber coredata.MailingListSubscriber
|
|
if err := subscriber.LoadByID(ctx, tx, scope, id); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrSubscriberNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list subscriber: %w", err)
|
|
}
|
|
|
|
wasConfirmed := subscriber.Status == coredata.MailingListSubscriberStatusConfirmed
|
|
|
|
if err := subscriber.Delete(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot delete mailing list subscriber: %w", err)
|
|
}
|
|
|
|
if wasConfirmed {
|
|
emailRecord, err := s.buildUnsubscriptionMail(ctx, subscriber.MailingListID, subscriber.Email, subscriber.FullName)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot build unsubscription email: %w", err)
|
|
}
|
|
|
|
if err := emailRecord.Insert(ctx, tx); err != nil {
|
|
return fmt.Errorf("cannot insert unsubscription email: %w", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (s *Service) CountSubscribers(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
) (int, error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
var count int
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) (err error) {
|
|
subscribers := coredata.MailingListSubscribers{}
|
|
|
|
count, err = subscribers.CountByMailingListID(ctx, conn, scope, mailingListID)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot count mailing list subscribers: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return count, nil
|
|
}
|
|
|
|
func (s *Service) ListSubscribers(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
cursor *page.Cursor[coredata.MailingListSubscriberOrderField],
|
|
) (*page.Page[*coredata.MailingListSubscriber, coredata.MailingListSubscriberOrderField], error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
var subscribers coredata.MailingListSubscribers
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
if err := subscribers.LoadByMailingListID(ctx, conn, scope, mailingListID, cursor); err != nil {
|
|
return fmt.Errorf("cannot load mailing list subscribers: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return page.NewPage(subscribers, cursor), nil
|
|
}
|
|
|
|
func (s *Service) CreateMailingListUpdate(
|
|
ctx context.Context,
|
|
req *CreateMailingListUpdateRequest,
|
|
) (*coredata.MailingListUpdate, error) {
|
|
if err := req.Validate(); err != nil {
|
|
return nil, fmt.Errorf("invalid request: %w", err)
|
|
}
|
|
|
|
mailingListID := req.MailingListID
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
now := time.Now()
|
|
|
|
mlu := &coredata.MailingListUpdate{
|
|
ID: gid.New(scope.GetTenantID(), coredata.MailingListUpdateEntityType),
|
|
MailingListID: mailingListID,
|
|
Title: req.Title,
|
|
Body: req.Body,
|
|
Status: coredata.MailingListUpdateStatusDraft,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
|
|
err := s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
var ml coredata.MailingList
|
|
if err := ml.LoadByID(ctx, tx, scope, mailingListID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrMailingListNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list: %w", err)
|
|
}
|
|
|
|
mlu.OrganizationID = ml.OrganizationID
|
|
|
|
if err := mlu.Insert(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot insert mailing list update: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return mlu, nil
|
|
}
|
|
|
|
func (s *Service) GetMailingListUpdate(
|
|
ctx context.Context,
|
|
id gid.GID,
|
|
) (*coredata.MailingListUpdate, error) {
|
|
scope := coredata.NewScopeFromObjectID(id)
|
|
|
|
var mlu coredata.MailingListUpdate
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
if err := mlu.LoadByID(ctx, conn, scope, id); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrMailingListUpdateNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list update: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &mlu, nil
|
|
}
|
|
|
|
func (s *Service) UpdateMailingListUpdate(
|
|
ctx context.Context,
|
|
req *UpdateMailingListUpdateRequest,
|
|
) (*coredata.MailingListUpdate, error) {
|
|
if err := req.Validate(); err != nil {
|
|
return nil, fmt.Errorf("invalid request: %w", err)
|
|
}
|
|
|
|
scope := coredata.NewScopeFromObjectID(req.ID)
|
|
|
|
var mlu coredata.MailingListUpdate
|
|
|
|
err := s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
if err := mlu.LoadByID(ctx, tx, scope, req.ID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrMailingListUpdateNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list update: %w", err)
|
|
}
|
|
|
|
if mlu.Status != coredata.MailingListUpdateStatusDraft {
|
|
return ErrMailingListUpdateAlreadySent
|
|
}
|
|
|
|
if req.Title != nil {
|
|
mlu.Title = *req.Title
|
|
}
|
|
|
|
if req.Body != nil {
|
|
mlu.Body = *req.Body
|
|
}
|
|
|
|
mlu.UpdatedAt = time.Now()
|
|
|
|
if err := mlu.Update(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot update mailing list update: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &mlu, nil
|
|
}
|
|
|
|
func (s *Service) SendMailingListUpdate(
|
|
ctx context.Context,
|
|
id gid.GID,
|
|
) (*coredata.MailingListUpdate, error) {
|
|
scope := coredata.NewScopeFromObjectID(id)
|
|
|
|
var mlu coredata.MailingListUpdate
|
|
|
|
err := s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
if err := mlu.LoadByID(ctx, tx, scope, id); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return ErrMailingListUpdateNotFound
|
|
}
|
|
|
|
return fmt.Errorf("cannot load mailing list update: %w", err)
|
|
}
|
|
|
|
if mlu.Status != coredata.MailingListUpdateStatusDraft {
|
|
return ErrMailingListUpdateAlreadySent
|
|
}
|
|
|
|
mlu.Status = coredata.MailingListUpdateStatusEnqueued
|
|
mlu.UpdatedAt = time.Now()
|
|
|
|
if err := mlu.Update(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot queue mailing list update for sending: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &mlu, nil
|
|
}
|
|
|
|
func (s *Service) DeleteMailingListUpdate(
|
|
ctx context.Context,
|
|
id gid.GID,
|
|
) error {
|
|
scope := coredata.NewScopeFromObjectID(id)
|
|
|
|
return s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
mlu := coredata.MailingListUpdate{ID: id}
|
|
if err := mlu.Delete(ctx, tx, scope); err != nil {
|
|
return fmt.Errorf("cannot delete mailing list update: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (s *Service) ListMailingListUpdates(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
cursor *page.Cursor[coredata.MailingListUpdateOrderField],
|
|
) (*page.Page[*coredata.MailingListUpdate, coredata.MailingListUpdateOrderField], error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
var items coredata.MailingListUpdateItems
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
if err := items.LoadByMailingListID(ctx, conn, scope, mailingListID, cursor); err != nil {
|
|
return fmt.Errorf("cannot load mailing list updates: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return page.NewPage(items, cursor), nil
|
|
}
|
|
|
|
func (s *Service) ListSentMailingListUpdates(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
cursor *page.Cursor[coredata.MailingListUpdateOrderField],
|
|
) (*page.Page[*coredata.MailingListUpdate, coredata.MailingListUpdateOrderField], error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
var items coredata.MailingListUpdateItems
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
if err := items.LoadSentByMailingListID(ctx, conn, scope, mailingListID, cursor); err != nil {
|
|
return fmt.Errorf("cannot load sent mailing list updates: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return page.NewPage(items, cursor), nil
|
|
}
|
|
|
|
func (s *Service) CountMailingListUpdates(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
) (int, error) {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
var count int
|
|
|
|
err := s.pg.WithConn(
|
|
ctx,
|
|
func(ctx context.Context, conn pg.Querier) error {
|
|
var (
|
|
items coredata.MailingListUpdateItems
|
|
err error
|
|
)
|
|
|
|
count, err = items.CountByMailingListID(ctx, conn, scope, mailingListID)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot count mailing list updates: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return count, nil
|
|
}
|
|
|
|
func (s *Service) CreateUpdateEmails(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
mailingListUpdateID gid.GID,
|
|
updateTitle string,
|
|
updateBody string,
|
|
) error {
|
|
scope := coredata.NewScopeFromObjectID(mailingListID)
|
|
|
|
presenterCfg, orgName, compliancePageURL, replyTo, err := s.UpdateEmailConfig(ctx, mailingListID)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get update email config: %w", err)
|
|
}
|
|
|
|
return s.pg.WithTx(
|
|
ctx,
|
|
func(ctx context.Context, tx pg.Tx) error {
|
|
subscribers, err := page.LoadAll(
|
|
ctx,
|
|
page.OrderBy[coredata.MailingListSubscriberOrderField]{
|
|
Field: coredata.MailingListSubscriberOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionAsc,
|
|
},
|
|
func(ctx context.Context, cursor *page.Cursor[coredata.MailingListSubscriberOrderField]) ([]*coredata.MailingListSubscriber, error) {
|
|
var batch coredata.MailingListSubscribers
|
|
if err := batch.LoadConfirmedByMailingListID(ctx, tx, scope, mailingListID, cursor); err != nil {
|
|
return nil, fmt.Errorf("cannot load confirmed subscribers: %w", err)
|
|
}
|
|
|
|
return batch, nil
|
|
},
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(subscribers) == 0 {
|
|
return nil
|
|
}
|
|
|
|
emailRecords := make(coredata.Emails, 0, len(subscribers))
|
|
for _, sub := range subscribers {
|
|
unsubscribeURL, err := s.buildUnsubscribeURL(mailingListID, sub.Email)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot generate unsubscribe URL: %w", err)
|
|
}
|
|
|
|
subject, textBody, htmlBody, err := emails.NewPresenterFromConfig(presenterCfg, sub.FullName).
|
|
RenderMailingListNews(ctx, orgName, updateTitle, updateBody, compliancePageURL, unsubscribeURL)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot render mailing list update email: %w", err)
|
|
}
|
|
|
|
emailRecords = append(
|
|
emailRecords,
|
|
coredata.NewEmail(
|
|
sub.FullName,
|
|
sub.Email,
|
|
subject,
|
|
textBody,
|
|
htmlBody,
|
|
&coredata.EmailOptions{
|
|
SenderName: new(orgName),
|
|
ReplyTo: replyTo,
|
|
UnsubscribeURL: &unsubscribeURL,
|
|
MailingListUpdateID: &mailingListUpdateID,
|
|
},
|
|
),
|
|
)
|
|
}
|
|
|
|
if err := emailRecords.BulkInsert(ctx, tx); err != nil {
|
|
return fmt.Errorf("cannot bulk insert update emails: %w", err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (s *Service) buildConfirmationMail(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
email mail.Addr,
|
|
fullName string,
|
|
) (*coredata.Email, error) {
|
|
unsubscribeURL, err := s.buildUnsubscribeURL(mailingListID, email)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot generate unsubscribe URL: %w", err)
|
|
}
|
|
|
|
confirmURL, err := s.buildConfirmURL(mailingListID, email)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot generate confirm URL: %w", err)
|
|
}
|
|
|
|
presenterCfg, orgName, replyTo, err := s.SubscriptionConfirmationEmailConfig(ctx, mailingListID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot get subscription confirmation email config: %w", err)
|
|
}
|
|
|
|
subject, textBody, htmlBody, err := emails.NewPresenterFromConfig(presenterCfg, fullName).
|
|
RenderMailingListSubscription(ctx, orgName, confirmURL, unsubscribeURL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot render subscription confirmation email: %w", err)
|
|
}
|
|
|
|
return coredata.NewEmail(
|
|
fullName,
|
|
email,
|
|
subject,
|
|
textBody,
|
|
htmlBody,
|
|
&coredata.EmailOptions{
|
|
SenderName: new(orgName),
|
|
ReplyTo: replyTo,
|
|
UnsubscribeURL: &unsubscribeURL,
|
|
},
|
|
), nil
|
|
}
|
|
|
|
func (s *Service) buildUnsubscriptionMail(
|
|
ctx context.Context,
|
|
mailingListID gid.GID,
|
|
email mail.Addr,
|
|
fullName string,
|
|
) (*coredata.Email, error) {
|
|
presenterCfg, orgName, replyTo, err := s.UnsubscribeEmailConfig(ctx, mailingListID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot get unsubscription email config: %w", err)
|
|
}
|
|
|
|
subject, textBody, htmlBody, err := emails.NewPresenterFromConfig(presenterCfg, fullName).
|
|
RenderMailingListUnsubscription(ctx, orgName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot render unsubscription email: %w", err)
|
|
}
|
|
|
|
return coredata.NewEmail(
|
|
fullName,
|
|
email,
|
|
subject,
|
|
textBody,
|
|
htmlBody,
|
|
&coredata.EmailOptions{
|
|
SenderName: new(orgName),
|
|
ReplyTo: replyTo,
|
|
},
|
|
), nil
|
|
}
|
|
|
|
func (s *Service) buildUnsubscribeURL(mailingListID gid.GID, email mail.Addr) (string, error) {
|
|
if s.tokenSecret == "" {
|
|
return "", nil
|
|
}
|
|
|
|
token, err := newUnsubscribeToken(s.tokenSecret, mailingListID, email)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return s.apiBaseURL.WithPath(pathUnsubscribe).WithQuery("token", token).String()
|
|
}
|
|
|
|
func (s *Service) buildConfirmURL(mailingListID gid.GID, email mail.Addr) (string, error) {
|
|
if s.tokenSecret == "" {
|
|
return "", nil
|
|
}
|
|
|
|
token, err := newConfirmToken(s.tokenSecret, mailingListID, email)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return s.apiBaseURL.WithPath(pathConfirm).WithQuery("token", token).String()
|
|
}
|