refactor(providers): 🧑‍💻 improve messaging and email

components/core/system_component.go

@@ -117,8 +117,7 @@ func (component *systemComponent) GenerateRSAKeyPair() (string, string, error) {
 
 func (component *systemComponent) Email(destination string, format string, args ...interface{}) {
 	component.Async(func() {
-		message := fmt.Sprintf(format, args...)
-		component.emailProvider.Send(destination, message)
+		component.emailProvider.Send(destination, format, args...)
 	})
 }
 

providers/outbound/common/messaging/provider.go

@@ -4,9 +4,14 @@ import (
 	"fmt"
 
 	. "github.com/xeronith/diamante/contracts/logging"
-	. "github.com/xeronith/diamante/contracts/messaging"
 )
 
+type IMessagingHandler func(receiver string, template string, model map[string]interface{}) error
+
+type IMessagingProvider interface {
+	Send(receiver string, template string, model map[string]interface{}) error
+}
+
 type provider struct {
 	name    string
 	logger  ILogger
@@ -21,8 +26,8 @@ func NewProvider(name string, logger ILogger, handler IMessagingHandler) IMessag
 	}
 }
 
-func (provider *provider) Send(receiver, message string) error {
-	if err := provider.handler(receiver, message); err != nil {
+func (provider *provider) Send(receiver, message string, model map[string]interface{}) error {
+	if err := provider.handler(receiver, message, model); err != nil {
 		provider.logger.Error(fmt.Sprintf("%s: %s", provider.name, err.Error()))
 		return err
 	} else {

providers/outbound/email/postmark/handler.go

@@ -0,0 +1,47 @@
+package postmark
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+)
+
+var client = &http.Client{}
+
+func handler(receiver, templateAlias string, model map[string]interface{}) error {
+	emailBody := map[string]interface{}{
+		"From":          "GreatApe <no-reply@greatape.stream>",
+		"To":            receiver,
+		"TemplateAlias": templateAlias,
+		"TemplateModel": model,
+	}
+
+	requestBody, _ := json.Marshal(emailBody)
+	buffer := bytes.NewBuffer(requestBody)
+
+	r, err := http.NewRequest("POST", "https://api.postmarkapp.com/email/withTemplate", buffer)
+	if err != nil {
+		return err
+	}
+
+	token := os.Getenv("POSTMARK_TOKEN")
+
+	r.Header.Add("Content-Type", "application/json")
+	r.Header.Add("Accept", "application/json")
+	r.Header.Add("X-Postmark-Server-Token", token)
+
+	resp, err := client.Do(r)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("error sending email to %s", receiver)
+	}
+
+	return nil
+}

providers/outbound/email/postmark/provider.go

@@ -0,0 +1,30 @@
+package postmark
+
+import (
+	"github.com/reiver/greatape/providers/outbound/common/messaging"
+	"github.com/xeronith/diamante/contracts/email"
+	"github.com/xeronith/diamante/contracts/logging"
+)
+
+const ProviderName = "POSTMARK_EMAIL_PROVIDER"
+
+type provider struct {
+	messaging messaging.IMessagingProvider
+}
+
+func NewProvider(logger logging.ILogger) email.IEmailProvider {
+	return &provider{
+		messaging: messaging.NewProvider(ProviderName, logger, handler),
+	}
+}
+
+func (provider *provider) Send(receiver, template string, args ...interface{}) error {
+	model := map[string]interface{}{}
+	if len(args) > 0 {
+		if data, ok := args[0].(map[string]interface{}); ok {
+			model = data
+		}
+	}
+
+	return provider.messaging.Send(receiver, template, model)
+}

providers/outbound/email/postmark/provider_test.go

@@ -0,0 +1,17 @@
+package postmark_test
+
+import (
+	"testing"
+
+	"github.com/reiver/greatape/providers/outbound/email/postmark"
+	"github.com/xeronith/diamante/logging"
+)
+
+func Test_Send(t *testing.T) {
+	logger := logging.NewLogger(false)
+	provider := postmark.NewProvider(logger)
+
+	if err := provider.Send("somebody@somewhere.com", "template-alias", map[string]interface{}{}); err != nil {
+		t.Fatal(err)
+	}
+}

providers/outbound/email/provider.go

@@ -1,25 +1,12 @@
 package email
 
 import (
-	"github.com/reiver/greatape/providers/outbound/common/messaging"
 	"github.com/xeronith/diamante/contracts/logging"
 
+	"github.com/reiver/greatape/providers/outbound/email/postmark"
 	"github.com/xeronith/diamante/contracts/email"
-	. "github.com/xeronith/diamante/contracts/messaging"
 )
 
-const EmailProvider = "EMAIL_PROVIDER"
-
-type provider struct {
-	messaging IMessagingProvider
-}
-
 func NewProvider(logger logging.ILogger) email.IEmailProvider {
-	return &provider{
-		messaging: messaging.NewProvider(EmailProvider, logger, handler),
-	}
-}
-
-func (provider *provider) Send(receiver, message string) error {
-	return provider.messaging.Send(receiver, message)
+	return postmark.NewProvider(logger)
 }

providers/outbound/email/sendgrid/handler.go

@@ -1,4 +1,4 @@
-package email
+package sendgrid
 
 import (
 	"fmt"
@@ -9,7 +9,7 @@ import (
 	"github.com/sendgrid/sendgrid-go/helpers/mail"
 )
 
-func handler(receiver, content string) error {
+func handler(receiver, content string, _ map[string]interface{}) error {
 	from := mail.NewEmail("Admin", "admin@site")
 	subject := "Subject"
 	to := mail.NewEmail(receiver, receiver)

providers/outbound/email/sendgrid/provider.go

@@ -0,0 +1,30 @@
+package sendgrid
+
+import (
+	"github.com/reiver/greatape/providers/outbound/common/messaging"
+	"github.com/xeronith/diamante/contracts/email"
+	"github.com/xeronith/diamante/contracts/logging"
+)
+
+const ProviderName = "SENDGRID_EMAIL_PROVIDER"
+
+type provider struct {
+	messaging messaging.IMessagingProvider
+}
+
+func NewProvider(logger logging.ILogger) email.IEmailProvider {
+	return &provider{
+		messaging: messaging.NewProvider(ProviderName, logger, handler),
+	}
+}
+
+func (provider *provider) Send(receiver, template string, args ...interface{}) error {
+	model := map[string]interface{}{}
+	if len(args) > 0 {
+		if data, ok := args[0].(map[string]interface{}); ok {
+			model = data
+		}
+	}
+
+	return provider.messaging.Send(receiver, template, model)
+}

providers/outbound/email/sendgrid/provider_test.go

@@ -1,15 +1,15 @@
-package email_test
+package sendgrid_test
 
 import (
 	"testing"
 
-	"github.com/reiver/greatape/providers/outbound/email"
+	"github.com/reiver/greatape/providers/outbound/email/sendgrid"
 	"github.com/xeronith/diamante/logging"
 )
 
 func Test_Send(t *testing.T) {
 	logger := logging.NewLogger(false)
-	provider := email.NewProvider(logger)
+	provider := sendgrid.NewProvider(logger)
 
 	if err := provider.Send("somebody@somewhere.com", "Message content"); err != nil {
 		t.Fatal(err)

providers/outbound/sms/handler.go

@@ -2,6 +2,6 @@ package sms
 
 import "fmt"
 
-func handler(receiver, message string) error {
+func handler(receiver, message string, _ map[string]interface{}) error {
 	return fmt.Errorf("not_implemented %s %s", receiver, message)
 }

providers/outbound/sms/provider.go

@@ -3,15 +3,13 @@ package sms
 import (
 	"github.com/reiver/greatape/providers/outbound/common/messaging"
 	"github.com/xeronith/diamante/contracts/logging"
-
-	. "github.com/xeronith/diamante/contracts/messaging"
 	"github.com/xeronith/diamante/contracts/sms"
 )
 
 const SMSProvider = "SMS_PROVIDER"
 
 type provider struct {
-	messaging IMessagingProvider
+	messaging messaging.IMessagingProvider
 }
 
 func NewProvider(logger logging.ILogger) sms.ISMSProvider {
@@ -21,5 +19,5 @@ func NewProvider(logger logging.ILogger) sms.ISMSProvider {
 }
 
 func (provider *provider) Send(receiver, message string) error {
-	return provider.messaging.Send(receiver, message)
+	return provider.messaging.Send(receiver, message, nil)
 }