/
move_counseled.go
134 lines (111 loc) · 4.1 KB
/
move_counseled.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
package notifications
import (
"bytes"
"fmt"
html "html/template"
text "text/template"
"github.com/gofrs/uuid"
"go.uber.org/zap"
"github.com/transcom/mymove/pkg/appcontext"
"github.com/transcom/mymove/pkg/assets"
"github.com/transcom/mymove/pkg/models"
)
var (
moveCounseledRawTextTemplate = string(assets.MustAsset("notifications/templates/move_counseled_template.txt"))
moveCounseledTextTemplate = text.Must(text.New("text_template").Parse(moveCounseledRawTextTemplate))
moveCounseledRawHTMLTemplate = string(assets.MustAsset("notifications/templates/move_counseled_template.html"))
moveCounseledHTMLTemplate = html.Must(html.New("text_template").Parse(moveCounseledRawHTMLTemplate))
)
// MoveCounseled has notification content for counseled moves (before TOO approval)
type MoveCounseled struct {
moveID uuid.UUID
htmlTemplate *html.Template
textTemplate *text.Template
}
// NewMoveCounseled returns a new move counseled notification (before TOO approval)
func NewMoveCounseled(moveID uuid.UUID) *MoveCounseled {
return &MoveCounseled{
moveID: moveID,
htmlTemplate: moveCounseledHTMLTemplate,
textTemplate: moveCounseledTextTemplate,
}
}
func (m MoveCounseled) emails(appCtx appcontext.AppContext) ([]emailContent, error) {
var emails []emailContent
move, err := models.FetchMove(appCtx.DB(), appCtx.Session(), m.moveID)
if err != nil {
return emails, err
}
orders, err := models.FetchOrderForUser(appCtx.DB(), appCtx.Session(), move.OrdersID)
if err != nil {
return emails, err
}
serviceMember, err := models.FetchServiceMemberForUser(appCtx.DB(), appCtx.Session(), orders.ServiceMemberID)
if err != nil {
return emails, err
}
originDSTransportInfo, err := models.FetchDLContactInfo(appCtx.DB(), orders.OriginDutyLocationID)
if err != nil {
return emails, err
}
var originDutyLocationName *string
if originDSTransportInfo != nil {
originDutyLocationName = &originDSTransportInfo.Name
}
if serviceMember.PersonalEmail == nil {
return emails, fmt.Errorf("no email found for service member")
}
htmlBody, textBody, err := m.renderTemplates(appCtx, MoveCounseledEmailData{
OriginDutyLocation: originDutyLocationName,
DestinationDutyLocation: orders.NewDutyLocation.Name,
Locator: move.Locator,
MyMoveLink: MyMoveLink,
})
if err != nil {
appCtx.Logger().Error("error rendering template", zap.Error(err))
}
smEmail := emailContent{
recipientEmail: *serviceMember.PersonalEmail,
subject: "Your counselor has approved your move details",
htmlBody: htmlBody,
textBody: textBody,
}
appCtx.Logger().Info("Generated move counseled email",
zap.String("moveLocator", move.Locator))
// TODO: Send email to trusted contacts when that's supported
return append(emails, smEmail), nil
}
func (m MoveCounseled) renderTemplates(appCtx appcontext.AppContext, data MoveCounseledEmailData) (string, string, error) {
htmlBody, err := m.RenderHTML(appCtx, data)
if err != nil {
return "", "", fmt.Errorf("error rendering html template using %#v", data)
}
textBody, err := m.RenderText(appCtx, data)
if err != nil {
return "", "", fmt.Errorf("error rendering text template using %#v", data)
}
return htmlBody, textBody, nil
}
type MoveCounseledEmailData struct {
OriginDutyLocation *string
DestinationDutyLocation string
Locator string
MyMoveLink string
}
// RenderHTML renders the html for the email
func (m MoveCounseled) RenderHTML(appCtx appcontext.AppContext, data MoveCounseledEmailData) (string, error) {
var htmlBuffer bytes.Buffer
if err := m.htmlTemplate.Execute(&htmlBuffer, data); err != nil {
appCtx.Logger().Error("cant render html template ", zap.Error(err))
}
return htmlBuffer.String(), nil
}
// RenderText renders the text for the email
func (m MoveCounseled) RenderText(appCtx appcontext.AppContext, data MoveCounseledEmailData) (string, error) {
var textBuffer bytes.Buffer
if err := m.textTemplate.Execute(&textBuffer, data); err != nil {
appCtx.Logger().Error("cant render text template ", zap.Error(err))
return "", err
}
return textBuffer.String(), nil
}