read hardcoded templates

Signed-off-by: jkoberg <jkoberg@owncloud.com>

services/userlog/pkg/service/conversion.go

@@ -3,7 +3,7 @@ package service
 import (
 	"bytes"
 	"context"
-	"path/filepath"
+	"errors"
 	"text/template"
 	"time"
 
@@ -27,6 +27,7 @@ type OC10Notification struct {
 	ResourceID     string                 `json:"object_id"`
 	ResourceType   string                 `json:"object_type"`
 	Subject        string                 `json:"subject"`
+	SubjectRaw     string                 `json:"subjectRich"`
 	Message        string                 `json:"message"`
 	MessageRaw     string                 `json:"messageRich"`
 	MessageDetails map[string]interface{} `json:"messageRichParameters"`
@@ -44,8 +45,8 @@ func (ul *UserlogService) SpaceDisabled(ctx context.Context, eventid string, ev
 		return OC10Notification{}, err
 	}
 
-	subj, msg, msgraw, err := ul.composeMessage("space-disabled", map[string]string{
-		"username":  user.GetUsername(),
+	subj, subjraw, msg, msgraw, err := ul.composeMessage(SpaceDisabled, map[string]string{
+		"username":  user.GetDisplayName(),
 		"spacename": space.GetName(),
 	})
 	if err != nil {
@@ -55,49 +56,53 @@ func (ul *UserlogService) SpaceDisabled(ctx context.Context, eventid string, ev
 	return OC10Notification{
 		EventID:        eventid,
 		Service:        ul.cfg.Service.Name,
+		UserName:       user.GetUsername(),
 		Timestamp:      time.Now().Format(time.RFC3339Nano),
-		Subject:        subj,
 		ResourceID:     ev.ID.GetOpaqueId(),
 		ResourceType:   _resourceTypeSpace,
+		Subject:        subj,
+		SubjectRaw:     subjraw,
 		Message:        msg,
 		MessageRaw:     msgraw,
-		MessageDetails: ul.getMessageDetails(user, space, nil),
+		MessageDetails: ul.getDetails(user, space, nil),
 	}, nil
 
 }
 
-func (ul *UserlogService) composeMessage(eventname string, vars map[string]string) (string, string, string, error) {
-	subjtpl, err := ul.parseTemplate(eventname + "-subj")
-	if err != nil {
-		return "", "", "", err
+func (ul *UserlogService) composeMessage(eventname string, vars map[string]string) (string, string, string, string, error) {
+	tpl, ok := _templates[eventname]
+	if !ok {
+		return "", "", "", "", errors.New("unknown template name")
 	}
 
-	subject := ul.executeTemplate(subjtpl, vars)
+	subject := ul.executeTemplate(tpl.Subject, vars)
 
-	msgtpl, err := ul.parseTemplate(eventname + "-msg")
-	if err != nil {
-		return "", "", "", err
-	}
-
-	message := ul.executeTemplate(msgtpl, vars)
-
-	messageraw := ul.executeTemplate(msgtpl, map[string]string{
+	subjectraw := ul.executeTemplate(tpl.Subject, map[string]string{
 		"username":  "{user}",
 		"spacename": "{space}",
 		"resource":  "{resource}",
 	})
 
-	return subject, message, messageraw, nil
+	message := ul.executeTemplate(tpl.Message, vars)
+
+	messageraw := ul.executeTemplate(tpl.Message, map[string]string{
+		"username":  "{user}",
+		"spacename": "{space}",
+		"resource":  "{resource}",
+	})
+
+	return subject, subjectraw, message, messageraw, nil
 
 }
 
-func (ul *UserlogService) getMessageDetails(user *user.User, space *storageprovider.StorageSpace, item *storageprovider.ResourceInfo) map[string]interface{} {
+func (ul *UserlogService) getDetails(user *user.User, space *storageprovider.StorageSpace, item *storageprovider.ResourceInfo) map[string]interface{} {
 	details := make(map[string]interface{})
 
 	if user != nil {
 		details["user"] = map[string]string{
-			"id":   user.GetId().GetOpaqueId(),
-			"name": user.GetUsername(),
+			"id":          user.GetId().GetOpaqueId(),
+			"name":        user.GetUsername(),
+			"displayname": user.GetDisplayName(),
 		}
 	}
 
@@ -118,21 +123,6 @@ func (ul *UserlogService) getMessageDetails(user *user.User, space *storageprovi
 	return details
 }
 
-func (ul *UserlogService) parseTemplate(templateName string) (*template.Template, error) {
-	var (
-		tpl *template.Template
-		err error
-	)
-	switch ul.templatePath {
-	case "":
-		tpl, err = template.ParseFS(templatesFS, filepath.Join("templates/", templateName+".tmpl"))
-	default:
-		tpl, err = template.ParseFiles(filepath.Join(ul.templatePath, templateName+".tmpl"))
-	}
-
-	return tpl, err
-}
-
 func (ul *UserlogService) executeTemplate(tpl *template.Template, vars map[string]string) string {
 	var writer bytes.Buffer
 	if err := tpl.Execute(&writer, vars); err != nil {

services/userlog/pkg/service/http.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"context"
-	"embed"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -15,11 +14,6 @@ import (
 	ehmsg "github.com/owncloud/ocis/v2/protogen/gen/ocis/messages/eventhistory/v0"
 )
 
-var (
-	//go:embed templates
-	templatesFS embed.FS
-)
-
 // ServeHTTP fulfills Handler interface
 func (ul *UserlogService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ul.m.ServeHTTP(w, r)

services/userlog/pkg/service/options.go

@@ -23,7 +23,6 @@ type Options struct {
 	HistoryClient    ehsvc.EventHistoryService
 	GatewayClient    gateway.GatewayAPIClient
 	RegisteredEvents []events.Unmarshaller
-	TemplatePath     string
 }
 
 // Logger configures a logger for the userlog service
@@ -81,10 +80,3 @@ func RegisteredEvents(e []events.Unmarshaller) Option {
 		o.RegisteredEvents = e
 	}
 }
-
-// TemplatePath registers the events the service should listen to
-func TemplatePath(tmpl string) Option {
-	return func(o *Options) {
-		o.TemplatePath = tmpl
-	}
-}

services/userlog/pkg/service/service.go

@@ -25,14 +25,12 @@ import (
 // UserlogService is the service responsible for user activities
 type UserlogService struct {
 	log              log.Logger
-	ch               <-chan events.Event
 	m                *chi.Mux
 	store            store.Store
 	cfg              *config.Config
 	historyClient    ehsvc.EventHistoryService
 	gwClient         gateway.GatewayAPIClient
 	registeredEvents map[string]events.Unmarshaller
-	templatePath     string // for custom notification templates
 }
 
 // NewUserlogService returns an EventHistory service
@@ -53,14 +51,12 @@ func NewUserlogService(opts ...Option) (*UserlogService, error) {
 
 	ul := &UserlogService{
 		log:              o.Logger,
-		ch:               ch,
 		m:                o.Mux,
 		store:            o.Store,
 		cfg:              o.Config,
 		historyClient:    o.HistoryClient,
 		gwClient:         o.GatewayClient,
 		registeredEvents: make(map[string]events.Unmarshaller),
-		templatePath:     o.TemplatePath,
 	}
 
 	for _, e := range o.RegisteredEvents {
@@ -73,14 +69,14 @@ func NewUserlogService(opts ...Option) (*UserlogService, error) {
 		r.Delete("/*", ul.HandleDeleteEvents)
 	})
 
-	go ul.MemorizeEvents()
+	go ul.MemorizeEvents(ch)
 
 	return ul, nil
 }
 
 // MemorizeEvents stores eventIDs a user wants to receive
-func (ul *UserlogService) MemorizeEvents() {
-	for event := range ul.ch {
+func (ul *UserlogService) MemorizeEvents(ch <-chan events.Event) {
+	for event := range ch {
 		// for each event we need to:
 		// I) find users eligible to receive the event
 		var (
@@ -88,7 +84,6 @@ func (ul *UserlogService) MemorizeEvents() {
 			err   error
 		)
 
-		fmt.Println("RECEIVED", event)
 		switch e := event.Event.(type) {
 		default:
 			err = errors.New("unhandled event")

services/userlog/pkg/service/service_test.go

@@ -64,7 +64,7 @@ var _ = Describe("UserlogService", func() {
 			service.GatewayClient(&gwc),
 			service.HistoryClient(&ehc),
 			service.RegisteredEvents([]events.Unmarshaller{
-				events.UploadReady{},
+				events.SpaceDisabled{},
 			}),
 		)
 		Expect(err).ToNot(HaveOccurred())
@@ -73,9 +73,11 @@ var _ = Describe("UserlogService", func() {
 
 	It("it stores, returns and deletes a couple of events", func() {
 		ids := make(map[string]struct{})
-		ids[bus.Publish(events.SpaceCreated{Executant: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
-		ids[bus.Publish(events.UploadReady{SpaceOwner: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
-		ids[bus.Publish(events.ContainerCreated{SpaceOwner: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
+		ids[bus.Publish(events.SpaceDisabled{Executant: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
+		ids[bus.Publish(events.SpaceDisabled{Executant: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
+		ids[bus.Publish(events.SpaceDisabled{Executant: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
+		// ids[bus.Publish(events.SpaceMembershipExpired{SpaceOwner: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
+		// ids[bus.Publish(events.ShareCreated{Executant: &user.UserId{OpaqueId: "userid"}})] = struct{}{}
 
 		time.Sleep(500 * time.Millisecond)
 

services/userlog/pkg/service/templates.go

@@ -0,0 +1,26 @@
+package service
+
+import "text/template"
+
+// the available templates
+var (
+	SpaceDisabled        = "space-disabled"
+	SpaceDisabledSubject = "space disabled"
+	SpaceDisabledMessage = "{{ .username }} disabled space {{ .spacename }}"
+)
+
+// NotificationTemplate is the data structure for the notifications
+type NotificationTemplate struct {
+	Subject *template.Template
+	Message *template.Template
+}
+
+// rendered templates
+var (
+	_templates = map[string]NotificationTemplate{
+		SpaceDisabled: {
+			Subject: template.Must(template.New(SpaceDisabled).Parse(SpaceDisabledSubject)),
+			Message: template.Must(template.New("").Parse(SpaceDisabledMessage)),
+		},
+	}
+)

services/userlog/pkg/service/templates/space-disabled-msg.tmpl

@@ -1 +0,0 @@
-{{ .username }} disabled Space {{ .spacename }}

services/userlog/pkg/service/templates/space-disabled-subj.tmpl

@@ -1 +0,0 @@
-Space Disabled