stuve-it-backend/messages/main.go

package messages

import (
	"git.stuve.uni-ulm.de/stuve-it/stuve-it-backend/logger"
	"github.com/pocketbase/dbx"
	"github.com/pocketbase/pocketbase"
	"github.com/pocketbase/pocketbase/core"
	"github.com/pocketbase/pocketbase/models"
	"github.com/pocketbase/pocketbase/tools/mailer"
	"github.com/pocketbase/pocketbase/tools/template"
	"net/mail"
)

// sendEmailNotification sends an email notification to the user
func sendEmailNotification(app *pocketbase.PocketBase, registry *template.Registry, user *models.Record, message *models.Record) {
	// check if user and message are set and user is not the sender
	if user == nil || message == nil || user.GetId() == message.GetString("sender") {
		return
	}

	// don't send email notification if user has muted email notifications and message is not an announcement
	if user.GetBool("muteEmailNotifications") && !message.GetBool("isAnnouncement") {
		return
	}

	// get user email
	userEmail := user.GetString("email")

	// check if user has a valid email
	if len(userEmail) == 0 {
		logger.LogErrorF("Error sending email notification to user with username '%s': no valid email", user.GetString("username"))
		return
	}

	// get link to chat and message type (announcement or message)
	var actionUrl string
	var messageType string
	if message.GetBool("isAnnouncement") {
		actionUrl = app.Settings().Meta.AppUrl + "/chat/announcements"
		messageType = "Ankündigung"
	} else {
		actionUrl = app.Settings().Meta.AppUrl + "/chat/" + message.GetString("eventList")
		messageType = "Nachricht"
	}

	// render email template
	html, err := registry.LoadFiles(
		"html/emailNotification.html",
	).Render(map[string]any{
		"ACTION_URL":   actionUrl,
		"APP_URL":      app.Settings().Meta.AppUrl,
		"MESSAGE_TYPE": messageType,
	})
	if err != nil {
		logger.LogErrorF("Error rendering email notification to user with username '%s': %v", user.GetString("username"), err)
		return
	}

	// send email
	email := &mailer.Message{
		From: mail.Address{
			Address: app.Settings().Meta.SenderAddress,
			Name:    app.Settings().Meta.SenderName,
		},
		To:      []mail.Address{{Address: userEmail}},
		Subject: "[StuVe IT] Neue " + messageType,
		HTML:    html,
	}
	if err := app.NewMailClient().Send(email); err != nil {
		logger.LogErrorF("Error sending email notification to user with username '%s': %v", user.GetString("username"), err)
	}
}

func messageNotifier(app *pocketbase.PocketBase, createdMessageRecord *models.Record) {
	registry := template.NewRegistry()

	// expand the createdMessageRecord to get recipient user and send email notification if recipient is set
	if errs := app.Dao().ExpandRecord(createdMessageRecord, []string{"recipients", "eventList"}, nil); len(errs) > 0 {
		// return new error with all errors
		logger.LogErrorF("Error expanding created message record: %v", errs)
		return
	}
	recipients := createdMessageRecord.ExpandedAll("recipients")
	for _, recipient := range recipients {
		sendEmailNotification(app, registry, recipient, createdMessageRecord)
	}

	// get eventList entries to notify and event admins
	eventList := createdMessageRecord.ExpandedOne("eventList")
	if eventList != nil {
		// get all eventListSlotEntries for the eventList
		listEntryRecords, err := app.Dao().FindRecordsByFilter(
			"eventListSlotEntries",
			"eventListsSlot.eventList.id={:listId}",
			"",
			-1,
			0,
			dbx.Params{"listId": eventList.GetId()},
		)

		if err != nil {
			logger.LogErrorF("Error getting eventListSlotEntries for EmailNotifier: %v", err)
		}

		// send messages to all eventListSlotEntries
		for _, record := range listEntryRecords {
			// expand the createdMessageRecord to get the user
			if errs := app.Dao().ExpandRecord(record, []string{"user"}, nil); len(errs) > 0 {
				logger.LogErrorF("Error expanding user for EmailNotifier: %v", errs)
			}
			sendEmailNotification(app, registry, record.ExpandedOne("user"), createdMessageRecord)
		}

		// get event and eventAdmins
		if errs := app.Dao().ExpandRecord(eventList, []string{"event"}, nil); len(errs) > 0 {
			logger.LogErrorF("Error expanding event for EmailNotifier: %v", errs)
		}
		event := eventList.ExpandedOne("event")
		if errs := app.Dao().ExpandRecord(event, []string{"eventAdmins"}, nil); len(errs) > 0 {
			logger.LogErrorF("Error expanding eventAdmins for EmailNotifier: %v", errs)
		}
		eventAdmins := event.ExpandedAll("eventAdmins")

		// send messages to all eventAdmins
		for _, record := range eventAdmins {
			sendEmailNotification(app, registry, record, createdMessageRecord)
		}
	}

	return
}

// InitMessages initializes the messages email notifier
//
// the function sends an email notification to all recipients of a message after the message has been created
func InitMessages(app *pocketbase.PocketBase, e *core.ServeEvent) error {

	logger.LogInfoF("Adding messages email notifier")

	app.OnModelAfterCreate("messages").Add(func(e *core.ModelEvent) error {

		// get created message record
		createdMessageRecord, err := app.Dao().FindRecordById("messages", e.Model.GetId())
		if err != nil {
			return err
		}

		go messageNotifier(app, createdMessageRecord)

		return nil
	})

	return nil
}