cacert-boardvoting/cmd/boardvoting/notifications.go

355 lines
9 KiB
Go
Raw Normal View History

2022-05-21 12:09:19 +00:00
/*
Copyright 2022 CAcert Inc.
SPDX-License-Identifier: Apache-2.0
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
2022-05-15 18:10:49 +00:00
package main
import (
"bytes"
"fmt"
"log"
"net"
2022-05-15 18:10:49 +00:00
"path"
"text/template"
"github.com/Masterminds/sprig/v3"
"gopkg.in/mail.v2"
2022-05-21 12:09:19 +00:00
"git.cacert.org/cacert-boardvoting/internal"
"git.cacert.org/cacert-boardvoting/internal/models"
2022-05-15 18:10:49 +00:00
)
type recipientData struct {
field, address, name string
}
type NotificationContent struct {
template string
data interface{}
subject string
2022-05-21 11:51:17 +00:00
headers map[string][]string
2022-05-15 18:10:49 +00:00
recipients []recipientData
}
type NotificationMail interface {
2022-05-21 11:51:17 +00:00
GetNotificationContent(*mailConfig) *NotificationContent
2022-05-15 18:10:49 +00:00
}
type MailNotifier struct {
notifyChannel chan NotificationMail
senderAddress string
dialer *mail.Dialer
quitChannel chan struct{}
infoLog, errorLog *log.Logger
mailConfig *mailConfig
2022-05-15 18:10:49 +00:00
}
func (app *application) NewMailNotifier() {
app.mailNotifier = &MailNotifier{
notifyChannel: make(chan NotificationMail, 1),
senderAddress: app.mailConfig.NotificationSenderAddress,
dialer: mail.NewDialer(app.mailConfig.SMTPHost, app.mailConfig.SMTPPort, "", ""),
2022-05-21 12:09:19 +00:00
quitChannel: make(chan struct{}),
infoLog: app.infoLog,
errorLog: app.errorLog,
mailConfig: app.mailConfig,
2022-05-15 18:10:49 +00:00
}
}
func (mn *MailNotifier) Start() {
mn.infoLog.Print("Launching mail notifier")
2022-05-15 18:10:49 +00:00
for {
select {
case notification := <-mn.notifyChannel:
content := notification.GetNotificationContent(mn.mailConfig)
2022-05-15 18:10:49 +00:00
mailText, err := content.buildMail(mn.mailConfig.BaseURL)
2022-05-15 18:10:49 +00:00
if err != nil {
mn.errorLog.Printf("building mail failed: %v", err)
2022-05-15 18:10:49 +00:00
continue
}
m := mail.NewMessage()
2022-05-21 11:51:17 +00:00
m.SetHeaders(content.headers)
m.SetAddressHeader("From", mn.senderAddress, "CAcert board voting system")
2022-05-15 18:10:49 +00:00
for _, recipient := range content.recipients {
m.SetAddressHeader(recipient.field, recipient.address, recipient.name)
}
m.SetHeader("Subject", content.subject)
m.SetBody("text/plain", mailText.String())
if err = mn.dialer.DialAndSend(m); err != nil {
mn.errorLog.Printf("sending mail failed: %v", err)
2022-05-15 18:10:49 +00:00
}
case <-mn.quitChannel:
mn.infoLog.Print("ending mail notifier")
2022-05-15 18:10:49 +00:00
return
}
}
}
func (mn *MailNotifier) Quit() {
mn.quitChannel <- struct{}{}
}
func (mn *MailNotifier) Notify(w NotificationMail) {
mn.notifyChannel <- w
}
func (mn *MailNotifier) Ping() error {
conn, err := net.DialTimeout(
"tcp",
fmt.Sprintf("%s:%d", mn.mailConfig.SMTPHost, mn.mailConfig.SMTPPort),
mn.mailConfig.SMTPTimeOut,
)
if err != nil {
return fmt.Errorf("could not connect to SMTP server: %w", err)
}
defer func(conn net.Conn) {
_ = conn.Close()
}(conn)
return nil
2022-05-21 12:09:19 +00:00
}
func (n *NotificationContent) buildMail(baseURL string) (fmt.Stringer, error) {
// TODO: implement a template cache for mail templates too
2022-05-21 12:09:19 +00:00
b, err := internal.MailTemplates.ReadFile(path.Join("mailtemplates", n.template))
2022-05-15 18:10:49 +00:00
if err != nil {
return nil, fmt.Errorf("could not read mail template %s: %w", n.template, err)
}
t, err := template.New(n.template).Funcs(sprig.GenericFuncMap()).Parse(string(b))
if err != nil {
return nil, fmt.Errorf("could not parse mail template %s: %w", n.template, err)
}
data := struct {
Data any
BaseURL string
2022-05-21 12:09:19 +00:00
}{Data: n.data, BaseURL: baseURL}
2022-05-15 18:10:49 +00:00
mailText := bytes.NewBuffer(make([]byte, 0))
if err = t.Execute(mailText, data); err != nil {
return nil, fmt.Errorf(
"failed to execute template %s with context %v: %w", n.template, n.data, err)
}
return mailText, nil
}
func defaultRecipient(mc *mailConfig) recipientData {
2022-05-27 15:39:54 +00:00
return recipientData{
field: "To",
address: mc.NoticeMailAddress,
name: "CAcert board mailing list",
}
}
func voteNoticeRecipient(mc *mailConfig) recipientData {
return recipientData{
field: "To",
address: mc.VoteNoticeMailAddress,
name: "CAcert board votes mailing list",
}
}
func motionReplyHeaders(m *models.Motion) map[string][]string {
return map[string][]string{
"References": {fmt.Sprintf("<%s>", m.Tag)},
"In-Reply-To": {fmt.Sprintf("<%s>", m.Tag)},
}
}
type RemindVoterNotification struct {
voter *models.User
decisions []*models.Motion
}
func (r RemindVoterNotification) GetNotificationContent(*mailConfig) *NotificationContent {
return &NotificationContent{
template: "remind_voter_mail.txt",
data: struct {
Decisions []*models.Motion
Name string
}{Decisions: r.decisions, Name: r.voter.Name},
subject: "Outstanding CAcert board votes",
recipients: []recipientData{{
field: "To",
address: r.voter.Reminder,
name: r.voter.Name,
}},
}
}
2022-05-21 11:51:17 +00:00
type ClosedDecisionNotification struct {
2022-05-27 15:39:54 +00:00
Decision *models.Motion
2022-05-21 11:51:17 +00:00
}
func (c *ClosedDecisionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
return &NotificationContent{
2022-05-27 15:39:54 +00:00
template: "closed_motion_mail.txt",
data: struct {
*models.Motion
2022-05-27 18:45:04 +00:00
}{Motion: c.Decision},
2022-05-27 15:39:54 +00:00
subject: fmt.Sprintf("Re: %s - %s - finalised", c.Decision.Tag, c.Decision.Title),
headers: motionReplyHeaders(c.Decision),
recipients: []recipientData{defaultRecipient(mc)},
2022-05-21 11:51:17 +00:00
}
}
type NewDecisionNotification struct {
2022-05-27 15:39:54 +00:00
Decision *models.Motion
Proposer *models.User
}
func (n NewDecisionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
2022-05-27 15:39:54 +00:00
voteURL := fmt.Sprintf("/vote/%s", n.Decision.Tag)
unvotedURL := "/motions/?unvoted=1"
return &NotificationContent{
template: "create_motion_mail.txt",
data: struct {
*models.Motion
Name string
VoteURL string
UnvotedURL string
2022-05-27 18:45:04 +00:00
}{
Motion: n.Decision,
Name: n.Proposer.Name,
VoteURL: voteURL,
UnvotedURL: unvotedURL,
},
2022-05-27 15:39:54 +00:00
subject: fmt.Sprintf("%s - %s", n.Decision.Tag, n.Decision.Title),
headers: n.getHeaders(),
recipients: []recipientData{defaultRecipient(mc)},
}
}
func (n NewDecisionNotification) getHeaders() map[string][]string {
return map[string][]string{
2022-05-27 15:39:54 +00:00
"Message-ID": {fmt.Sprintf("<%s>", n.Decision.Tag)},
2022-05-26 19:04:47 +00:00
}
}
type UpdateDecisionNotification struct {
2022-05-27 15:39:54 +00:00
Decision *models.Motion
User *models.User
2022-05-26 19:04:47 +00:00
}
func (u UpdateDecisionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
2022-05-27 15:39:54 +00:00
voteURL := fmt.Sprintf("/vote/%s", u.Decision.Tag)
2022-05-26 19:04:47 +00:00
unvotedURL := "/motions/?unvoted=1"
return &NotificationContent{
template: "update_motion_mail.txt",
data: struct {
*models.Motion
Name string
VoteURL string
UnvotedURL string
2022-05-27 18:45:04 +00:00
}{
Motion: u.Decision,
Name: u.User.Name,
VoteURL: voteURL,
UnvotedURL: unvotedURL,
},
2022-05-27 15:39:54 +00:00
subject: fmt.Sprintf("%s - %s", u.Decision.Tag, u.Decision.Title),
headers: motionReplyHeaders(u.Decision),
2022-05-26 19:04:47 +00:00
recipients: []recipientData{defaultRecipient(mc)},
}
}
2022-05-27 15:39:54 +00:00
type DirectVoteNotification struct {
Decision *models.Motion
User *models.User
Choice *models.VoteChoice
}
func (d DirectVoteNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
return &NotificationContent{
template: "direct_vote_mail.txt",
data: struct {
*models.Motion
Name string
Choice *models.VoteChoice
2022-05-27 18:45:04 +00:00
}{
Motion: d.Decision,
Name: d.User.Name,
Choice: d.Choice,
},
2022-05-27 15:39:54 +00:00
subject: fmt.Sprintf("Re: %s - %s", d.Decision.Tag, d.Decision.Title),
headers: motionReplyHeaders(d.Decision),
recipients: []recipientData{voteNoticeRecipient(mc)},
}
2022-05-21 11:51:17 +00:00
}
2022-05-27 18:45:04 +00:00
type ProxyVoteNotification struct {
Decision *models.Motion
User *models.User
Voter *models.User
Choice *models.VoteChoice
Justification string
}
func (p ProxyVoteNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
return &NotificationContent{
template: "proxy_vote_mail.txt",
data: struct {
*models.Motion
Name string
Voter string
Choice *models.VoteChoice
Justification string
}{
Motion: p.Decision,
Name: p.User.Name,
Voter: p.Voter.Name,
Choice: p.Choice,
Justification: p.Justification,
},
subject: fmt.Sprintf("Re: %s - %s", p.Decision.Tag, p.Decision.Title),
headers: motionReplyHeaders(p.Decision),
recipients: []recipientData{voteNoticeRecipient(mc)},
}
}
2022-05-29 10:01:58 +00:00
type WithDrawMotionNotification struct {
Motion *models.Motion
Voter *models.User
}
func (w WithDrawMotionNotification) GetNotificationContent(mc *mailConfig) *NotificationContent {
return &NotificationContent{
template: "withdraw_motion_mail.txt",
data: struct {
*models.Motion
Name string
}{Motion: w.Motion, Name: w.Voter.Name},
subject: fmt.Sprintf("Re: %s - %s", w.Motion.Tag, w.Motion.Title),
headers: motionReplyHeaders(w.Motion),
recipients: []recipientData{defaultRecipient(mc)},
}
}