feat: Add CC and BCC support to email sending. (#16)

* feat: Add CC and BCC support to email sending. Also support mulitple To addresses.

* Typo in from field

Author: bmonkman

.goreleaser.yml

@@ -8,6 +8,9 @@ builds:
   - CGO_ENABLED=0
   ldflags:
     - -X github.com/commitdev/zero-notification-service/cmd.appVersion={{.Version}} -X github.com/commitdev/zero-notification-service/cmd.appBuild={{.ShortCommit}}
+  ignore:
+    - goos: darwin
+      goarch: arm64
 archives:
 - replacements:
     darwin: Darwin

api/notification-service.yaml

@@ -22,7 +22,10 @@ paths:
 
   /email/send:
     post:
-      summary: Send an email
+      summary: |
+        Send a single email.
+        Note that if multiple to addresses are provided it will still only send a single email with multiple addresses in the to field.
+        To send multiple emails to individual addresses, see the sendBulk endpoint.
       operationId: sendEmail
       tags:
         - email
@@ -49,7 +52,10 @@ paths:
 
   /email/sendBulk:
     post:
-      summary: Send a batch of emails to many users with the same content. Note that it is possible for only a subset of these to fail.
+      summary: |
+        Send a batch of multiple emails to individual recipients with the same content.
+        Note that if cc or bcc address are provided, each email sent will also be sent to any addresses in these lists.
+        Note that it is possible for only a subset of these to fail
       operationId: sendBulk
       tags:
         - email
@@ -210,12 +216,22 @@ components:
     SendMailRequest:
       type: object
       required:
-      - to
-      - from
+      - toAddresses
+      - fromAddress
       properties:
-        to:
-          $ref: '#/components/schemas/EmailRecipient'
-        from:
+        toAddresses:
+          type: array
+          items:
+            $ref: '#/components/schemas/EmailRecipient'
+        ccAddresses:
+          type: array
+          items:
+            $ref: '#/components/schemas/EmailRecipient'
+        bccAddresses:
+          type: array
+          items:
+            $ref: '#/components/schemas/EmailRecipient'
+        fromAddress:
           $ref: '#/components/schemas/EmailSender'
         message:
           $ref: '#/components/schemas/MailMessage'
@@ -224,13 +240,21 @@ components:
       type: object
       required:
       - toAddresses
-      - from
+      - fromAddress
       properties:
         toAddresses:
           type: array
           items:
             $ref: '#/components/schemas/EmailRecipient'
-        from:
+        ccAddresses:
+          type: array
+          items:
+            $ref: '#/components/schemas/EmailRecipient'
+        bccAddresses:
+          type: array
+          items:
+            $ref: '#/components/schemas/EmailRecipient'
+        fromAddress:
           $ref: '#/components/schemas/EmailSender'
         message:
           $ref: '#/components/schemas/MailMessage'

internal/mail/mail.go

@@ -20,14 +20,14 @@ type Client interface {
 
 // SendBulkMail sends a batch of email messages to all the specified recipients
 // All the calls to send mail happen in parallel, with their responses returned on the provided channel
-func SendBulkMail(toList []server.EmailRecipient, from server.EmailSender, message server.MailMessage, client Client, responseChannel chan BulkSendAttempt) {
+func SendBulkMail(toList []server.EmailRecipient, from server.EmailSender, cc []server.EmailRecipient, bcc []server.EmailRecipient, message server.MailMessage, client Client, responseChannel chan BulkSendAttempt) {
 	wg := sync.WaitGroup{}
 	wg.Add(len(toList))
 
 	// Create goroutines for each send
 	for _, to := range toList {
 		go func(to server.EmailRecipient) {
-			response, err := SendIndividualMail(to, from, message, client)
+			response, err := SendIndividualMail([]server.EmailRecipient{to}, from, cc, bcc, message, client)
 			responseChannel <- BulkSendAttempt{to.Address, response, err}
 			wg.Done()
 		}(to)
@@ -40,11 +40,44 @@ func SendBulkMail(toList []server.EmailRecipient, from server.EmailSender, messa
 }
 
 // SendIndividualMail sends an email message
-func SendIndividualMail(to server.EmailRecipient, from server.EmailSender, message server.MailMessage, client Client) (*rest.Response, error) {
-	sendFrom := sendgridMail.NewEmail(from.Name, from.Address)
-	sendTo := sendgridMail.NewEmail(to.Name, to.Address)
-	sendMessage := sendgridMail.NewSingleEmail(sendFrom, message.Subject, sendTo, message.Body, message.RichBody)
+func SendIndividualMail(to []server.EmailRecipient, from server.EmailSender, cc []server.EmailRecipient, bcc []server.EmailRecipient, message server.MailMessage, client Client) (*rest.Response, error) {
+	sendMessage := sendgridMail.NewV3Mail()
+
+	sendMessage.SetFrom(sendgridMail.NewEmail(from.Name, from.Address))
+
+	if message.Body != "" {
+		sendMessage.AddContent(sendgridMail.NewContent("text/plain", message.Body))
+	}
+	if message.RichBody != "" {
+		sendMessage.AddContent(sendgridMail.NewContent("text/html", message.RichBody))
+	}
+
 	sendMessage.SetTemplateID(message.TemplateId)
 	sendMessage.SetSendAt(int(message.ScheduleSendAtTimestamp))
+
+	personalization := sendgridMail.NewPersonalization()
+
+	personalization.Subject = message.Subject
+
+	personalization.AddTos(convertAddresses(to)...)
+
+	if len(cc) > 0 {
+		personalization.AddCCs(convertAddresses(cc)...)
+	}
+
+	if len(bcc) > 0 {
+		personalization.AddBCCs(convertAddresses(bcc)...)
+	}
+	sendMessage.AddPersonalizations(personalization)
+
 	return client.Send(sendMessage)
 }
+
+// convertAddresses converts a list of EmailRecipient structs to a list of sendgrid's email address type
+func convertAddresses(addresses []server.EmailRecipient) []*sendgridMail.Email {
+	returnAddresses := make([]*sendgridMail.Email, len(addresses))
+	for i, address := range addresses {
+		returnAddresses[i] = sendgridMail.NewEmail(address.Name, address.Address)
+	}
+	return returnAddresses
+}

internal/mail/mail_internal_test.go

@@ -0,0 +1,20 @@
+package mail
+
+import (
+	"testing"
+
+	"github.com/commitdev/zero-notification-service/internal/server"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConvertAddresses(t *testing.T) {
+
+	addresses := []server.EmailRecipient{
+		server.EmailRecipient{Name: "User1", Address: "user1@address.com"},
+	}
+	convertedAddresses := convertAddresses(addresses)
+
+	assert.Len(t, convertedAddresses, 1, "Returned list should be 1 element")
+	assert.Equal(t, convertedAddresses[0].Name, "User1", "Returned name should match")
+	assert.Equal(t, convertedAddresses[0].Address, "user1@address.com", "Returned address should match")
+}

internal/mail/mail_test.go

@@ -35,14 +35,16 @@ func TestSendBulkMail(t *testing.T) {
 			Address: fmt.Sprintf("address%d@domain.com", i),
 		})
 	}
+	cc := make([]server.EmailRecipient, 0)
+	bcc := make([]server.EmailRecipient, 0)
 	from := server.EmailSender{Name: "Test User", Address: "address@domain.com"}
 	message := server.MailMessage{Subject: "Subject", Body: "Body"}
 	client := FakeClient{}
 
 	client.On("Send").Return(nil, nil)
 
 	responseChannel := make(chan mail.BulkSendAttempt)
-	mail.SendBulkMail(toList, from, message, &client, responseChannel)
+	mail.SendBulkMail(toList, from, cc, bcc, message, &client, responseChannel)
 
 	// Range over the channel until empty
 	returnedCount := 0

internal/service/api_email_service.go

@@ -9,6 +9,7 @@ import (
 	"github.com/commitdev/zero-notification-service/internal/mail"
 	"github.com/commitdev/zero-notification-service/internal/server"
 	"github.com/sendgrid/sendgrid-go"
+	"go.uber.org/zap"
 )
 
 // EmailApiService is a service that implents the logic for the EmailApiServicer
@@ -26,15 +27,16 @@ func NewEmailApiService(c *config.Config) server.EmailApiServicer {
 // SendEmail - Send an email
 func (s *EmailApiService) SendEmail(ctx context.Context, sendMailRequest server.SendMailRequest) (server.ImplResponse, error) {
 	client := sendgrid.NewSendClient(s.config.SendgridAPIKey)
-	response, err := mail.SendIndividualMail(sendMailRequest.To, sendMailRequest.From, sendMailRequest.Message, client)
+	response, err := mail.SendIndividualMail(sendMailRequest.ToAddresses, sendMailRequest.FromAddress, sendMailRequest.CcAddresses, sendMailRequest.BccAddresses, sendMailRequest.Message, client)
 
 	if err != nil {
-		fmt.Printf("Error sending mail: %v\n", response)
+		zap.S().Errorf("Error sending mail: %v", response)
+
 		return server.Response(http.StatusInternalServerError, nil), fmt.Errorf("Unable to send email: %v", err)
 	}
 
 	if !(response.StatusCode >= 200 && response.StatusCode <= 299) {
-		fmt.Printf("Failure from Sendgrid when sending mail: %v\n", response)
+		zap.S().Errorf("Failure from Sendgrid when sending mail: %v", response)
 		return server.Response(http.StatusInternalServerError, nil), fmt.Errorf("Unable to send email: %v from mail provider: %v", response.StatusCode, response.Body)
 	}
 
@@ -47,18 +49,18 @@ func (s *EmailApiService) SendBulk(ctx context.Context, sendBulkMailRequest serv
 
 	responseChannel := make(chan mail.BulkSendAttempt)
 
-	mail.SendBulkMail(sendBulkMailRequest.ToAddresses, sendBulkMailRequest.From, sendBulkMailRequest.Message, client, responseChannel)
+	mail.SendBulkMail(sendBulkMailRequest.ToAddresses, sendBulkMailRequest.FromAddress, sendBulkMailRequest.CcAddresses, sendBulkMailRequest.BccAddresses, sendBulkMailRequest.Message, client, responseChannel)
 
 	var successful []server.SendBulkMailResponseSuccessful
 	var failed []server.SendBulkMailResponseFailed
 
 	// Read all the responses from the channel. This will block if responses aren't ready and the channel is not yet closed
 	for r := range responseChannel {
 		if r.Error != nil {
-			fmt.Printf("Error sending bulk mail: %v", r.Error)
+			zap.S().Errorf("Error sending bulk mail: %v", r.Error)
 			failed = append(failed, server.SendBulkMailResponseFailed{EmailAddress: r.EmailAddress, Error: fmt.Sprintf("Unable to send email: %v\n", r.Error)})
 		} else if !(r.Response.StatusCode >= 200 && r.Response.StatusCode <= 299) {
-			fmt.Printf("Failure from Sendgrid when sending bulk mail: %v", r.Response)
+			zap.S().Errorf("Failure from Sendgrid when sending bulk mail: %v", r.Response)
 			failed = append(failed, server.SendBulkMailResponseFailed{EmailAddress: r.EmailAddress, Error: fmt.Sprintf("Unable to send email: %v from mail provider: %v\n", r.Response.StatusCode, r.Response.Body)})
 		} else {
 			successful = append(successful, server.SendBulkMailResponseSuccessful{EmailAddress: r.EmailAddress, TrackingId: r.Response.Headers["X-Message-Id"][0]})

internal/service/api_notification_service.go

@@ -9,6 +9,7 @@ import (
 	"github.com/commitdev/zero-notification-service/internal/notification/slack"
 	"github.com/commitdev/zero-notification-service/internal/server"
 	slack_lib "github.com/slack-go/slack"
+	"go.uber.org/zap"
 )
 
 // NotificationApiService is a service that implents the logic for the NotificationApiServicer
@@ -28,7 +29,7 @@ func (s *NotificationApiService) SendSlackNotification(ctx context.Context, send
 	client := slack_lib.New(s.config.SlackAPIKey)
 	timestamp, err := slack.SendMessage(sendSlackMessageRequest.To, sendSlackMessageRequest.Message, sendSlackMessageRequest.ReplyToTimestamp, client)
 	if err != nil {
-		fmt.Printf("Error sending slack notification: %v\n", err)
+		zap.S().Errorf("Error sending slack notification: %v", err)
 		return server.Response(http.StatusInternalServerError, nil), fmt.Errorf("Unable to send slack notification: %v", err)
 	}