-
Notifications
You must be signed in to change notification settings - Fork 390
/
service.go
151 lines (124 loc) · 4.08 KB
/
service.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information
package mailservice
import (
"bytes"
"context"
htmltemplate "html/template"
"path/filepath"
"sync"
"github.com/spacemonkeygo/monkit/v3"
"go.uber.org/zap"
"storj.io/storj/private/post"
)
// Config defines values needed by mailservice service
type Config struct {
SMTPServerAddress string `help:"smtp server address" default:""`
TemplatePath string `help:"path to email templates source" default:""`
From string `help:"sender email address" default:""`
AuthType string `help:"smtp authentication type" releaseDefault:"login" devDefault:"simulate"`
Login string `help:"plain/login auth user login" default:""`
Password string `help:"plain/login auth user password" default:""`
RefreshToken string `help:"refresh token used to retrieve new access token" default:""`
ClientID string `help:"oauth2 app's client id" default:""`
ClientSecret string `help:"oauth2 app's client secret" default:""`
TokenURI string `help:"uri which is used when retrieving new access token" default:""`
}
var (
mon = monkit.Package()
)
// Sender sends emails
//
// architecture: Service
type Sender interface {
SendEmail(ctx context.Context, msg *post.Message) error
FromAddress() post.Address
}
// Message defines mailservice template-backed message for SendRendered method
type Message interface {
Template() string
Subject() string
}
// Service sends template-backed email messages through SMTP
//
// architecture: Service
type Service struct {
log *zap.Logger
sender Sender
html *htmltemplate.Template
// TODO(yar): prepare plain text version
//text *texttemplate.Template
sending sync.WaitGroup
}
// New creates new service
func New(log *zap.Logger, sender Sender, templatePath string) (*Service, error) {
var err error
service := &Service{log: log, sender: sender}
// TODO(yar): prepare plain text version
//service.text, err = texttemplate.ParseGlob(filepath.Join(templatePath, "*.txt"))
//if err != nil {
// return nil, err
//}
service.html, err = htmltemplate.ParseGlob(filepath.Join(templatePath, "*.html"))
if err != nil {
return nil, err
}
return service, nil
}
// Close closes and waits for any pending actions.
func (service *Service) Close() error {
service.sending.Wait()
return nil
}
// Send is generalized method for sending custom email message
func (service *Service) Send(ctx context.Context, msg *post.Message) (err error) {
defer mon.Task()(&ctx)(&err)
return service.sender.SendEmail(ctx, msg)
}
// SendRenderedAsync renders content from htmltemplate and texttemplate templates then sends it asynchronously
func (service *Service) SendRenderedAsync(ctx context.Context, to []post.Address, msg Message) {
// TODO: think of a better solution
service.sending.Add(1)
go func() {
defer service.sending.Done()
err := service.SendRendered(ctx, to, msg)
var recipients []string
for _, recipient := range to {
recipients = append(recipients, recipient.String())
}
if err != nil {
service.log.Error("fail sending email",
zap.Strings("recipients", recipients),
zap.Error(err))
} else {
service.log.Info("email sent successfully",
zap.Strings("recipients", recipients))
}
}()
}
// SendRendered renders content from htmltemplate and texttemplate templates then sends it
func (service *Service) SendRendered(ctx context.Context, to []post.Address, msg Message) (err error) {
defer mon.Task()(&ctx)(&err)
var htmlBuffer bytes.Buffer
var textBuffer bytes.Buffer
// TODO(yar): prepare plain text version
//if err = service.text.ExecuteTemplate(&textBuffer, msg.Template() + ".txt", msg); err != nil {
// return
//}
if err = service.html.ExecuteTemplate(&htmlBuffer, msg.Template()+".html", msg); err != nil {
return
}
m := &post.Message{
From: service.sender.FromAddress(),
To: to,
Subject: msg.Subject(),
PlainText: textBuffer.String(),
Parts: []post.Part{
{
Type: "text/html; charset=UTF-8",
Content: htmlBuffer.String(),
},
},
}
return service.sender.SendEmail(ctx, m)
}