388 lines
10 KiB
Go
388 lines
10 KiB
Go
/*
|
|
Copyright 2017-2024 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.
|
|
*/
|
|
|
|
package notifications
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"path"
|
|
"text/template"
|
|
"time"
|
|
|
|
"github.com/Masterminds/sprig/v3"
|
|
"gopkg.in/mail.v2"
|
|
|
|
"git.cacert.org/cacert-boardvoting/internal"
|
|
"git.cacert.org/cacert-boardvoting/internal/models"
|
|
)
|
|
|
|
type MailConfig struct {
|
|
SMTPHost string `yaml:"smtp_host"`
|
|
SMTPPort int `yaml:"smtp_port"`
|
|
SMTPTimeOut time.Duration `yaml:"smtp_timeout,omitempty"`
|
|
Domain string `yaml:"message_id_domain"`
|
|
NotificationSenderAddress string `yaml:"notification_sender_address"`
|
|
NoticeMailAddress string `yaml:"notice_mail_address"`
|
|
VoteNoticeMailAddress string `yaml:"vote_notice_mail_address"`
|
|
BaseURL string `yaml:"base_url"`
|
|
}
|
|
|
|
type recipientData struct {
|
|
field, address, name string
|
|
}
|
|
|
|
type NotificationContent struct {
|
|
template string
|
|
data interface{}
|
|
subject string
|
|
headers map[string][]string
|
|
recipients []recipientData
|
|
}
|
|
|
|
type NotificationMail interface {
|
|
GetNotificationContent(*MailConfig) *NotificationContent
|
|
}
|
|
|
|
type MailNotifier struct {
|
|
notifyChannel chan NotificationMail
|
|
senderAddress string
|
|
dialer *mail.Dialer
|
|
quitChannel chan struct{}
|
|
infoLog, errorLog *log.Logger
|
|
mailConfig *MailConfig
|
|
}
|
|
|
|
type Option func(*MailNotifier)
|
|
|
|
func NewMailNotifier(config *MailConfig, opts ...Option) *MailNotifier {
|
|
n := &MailNotifier{
|
|
notifyChannel: make(chan NotificationMail, 1),
|
|
senderAddress: config.NotificationSenderAddress,
|
|
dialer: mail.NewDialer(config.SMTPHost, config.SMTPPort, "", ""),
|
|
quitChannel: make(chan struct{}),
|
|
infoLog: log.New(os.Stdout, "", 0),
|
|
errorLog: log.New(os.Stderr, "", 0),
|
|
mailConfig: config,
|
|
}
|
|
|
|
for _, o := range opts {
|
|
o(n)
|
|
}
|
|
|
|
return n
|
|
}
|
|
|
|
func NotifierLog(infoLog, errorLog *log.Logger) Option {
|
|
return func(n *MailNotifier) {
|
|
n.infoLog = infoLog
|
|
n.errorLog = errorLog
|
|
}
|
|
}
|
|
|
|
func (mn *MailNotifier) Start() {
|
|
mn.infoLog.Print("Launching mail notifier")
|
|
|
|
for {
|
|
select {
|
|
case notification := <-mn.notifyChannel:
|
|
content := notification.GetNotificationContent(mn.mailConfig)
|
|
|
|
mailText, err := content.buildMail(mn.mailConfig.BaseURL)
|
|
if err != nil {
|
|
mn.errorLog.Printf("building mail failed: %v", err)
|
|
|
|
continue
|
|
}
|
|
|
|
m := mail.NewMessage()
|
|
|
|
m.SetHeaders(content.headers)
|
|
m.SetAddressHeader("From", mn.senderAddress, "CAcert board voting system")
|
|
|
|
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)
|
|
}
|
|
case <-mn.quitChannel:
|
|
mn.infoLog.Print("ending mail notifier")
|
|
|
|
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
|
|
}
|
|
|
|
func (n *NotificationContent) buildMail(baseURL string) (fmt.Stringer, error) {
|
|
// TODO: implement a template cache for mail templates too
|
|
b, err := internal.MailTemplates.ReadFile(path.Join("mailtemplates", n.template))
|
|
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
|
|
}{Data: n.data, BaseURL: baseURL}
|
|
|
|
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 {
|
|
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, mc *MailConfig) map[string][]string {
|
|
return map[string][]string{
|
|
"References": {fmt.Sprintf("<%s@%s>", m.Tag, mc.Domain)},
|
|
"In-Reply-To": {fmt.Sprintf("<%s@%s>", m.Tag, mc.Domain)},
|
|
}
|
|
}
|
|
|
|
type RemindVoterNotification struct {
|
|
Voter *models.User
|
|
Decisions []*models.Motion
|
|
}
|
|
|
|
func (r RemindVoterNotification) GetNotificationContent(*MailConfig) *NotificationContent {
|
|
recipientAddress := make([]recipientData, 0)
|
|
|
|
if r.Voter.Reminder.Valid {
|
|
recipientAddress = append(recipientAddress, recipientData{
|
|
field: "To",
|
|
address: r.Voter.Reminder.String,
|
|
name: r.Voter.Name,
|
|
})
|
|
}
|
|
|
|
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: recipientAddress,
|
|
}
|
|
}
|
|
|
|
type ClosedDecisionNotification struct {
|
|
Decision *models.Motion
|
|
}
|
|
|
|
func (c *ClosedDecisionNotification) GetNotificationContent(mc *MailConfig) *NotificationContent {
|
|
return &NotificationContent{
|
|
template: "closed_motion_mail.txt",
|
|
data: struct {
|
|
*models.Motion
|
|
}{Motion: c.Decision},
|
|
subject: fmt.Sprintf("Re: %s - %s - finalized", c.Decision.Tag, c.Decision.Title),
|
|
headers: motionReplyHeaders(c.Decision, mc),
|
|
recipients: []recipientData{defaultRecipient(mc)},
|
|
}
|
|
}
|
|
|
|
type NewDecisionNotification struct {
|
|
Decision *models.Motion
|
|
Proposer *models.User
|
|
}
|
|
|
|
func (n NewDecisionNotification) GetNotificationContent(mc *MailConfig) *NotificationContent {
|
|
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
|
|
}{
|
|
Motion: n.Decision,
|
|
Name: n.Proposer.Name,
|
|
VoteURL: voteURL,
|
|
UnvotedURL: unvotedURL,
|
|
},
|
|
subject: fmt.Sprintf("%s - %s", n.Decision.Tag, n.Decision.Title),
|
|
headers: n.getHeaders(mc),
|
|
recipients: []recipientData{defaultRecipient(mc)},
|
|
}
|
|
}
|
|
|
|
func (n NewDecisionNotification) getHeaders(mc *MailConfig) map[string][]string {
|
|
return map[string][]string{
|
|
"Message-ID": {fmt.Sprintf("<%s@%s>", n.Decision.Tag, mc.Domain)},
|
|
}
|
|
}
|
|
|
|
type UpdateDecisionNotification struct {
|
|
Decision *models.Motion
|
|
User *models.User
|
|
}
|
|
|
|
func (u UpdateDecisionNotification) GetNotificationContent(mc *MailConfig) *NotificationContent {
|
|
voteURL := fmt.Sprintf("/vote/%s", u.Decision.Tag)
|
|
unvotedURL := "/motions/?unvoted=1"
|
|
|
|
return &NotificationContent{
|
|
template: "update_motion_mail.txt",
|
|
data: struct {
|
|
*models.Motion
|
|
Name string
|
|
VoteURL string
|
|
UnvotedURL string
|
|
}{
|
|
Motion: u.Decision,
|
|
Name: u.User.Name,
|
|
VoteURL: voteURL,
|
|
UnvotedURL: unvotedURL,
|
|
},
|
|
subject: fmt.Sprintf("%s - %s", u.Decision.Tag, u.Decision.Title),
|
|
headers: motionReplyHeaders(u.Decision, mc),
|
|
recipients: []recipientData{defaultRecipient(mc)},
|
|
}
|
|
}
|
|
|
|
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
|
|
}{
|
|
Motion: d.Decision,
|
|
Name: d.User.Name,
|
|
Choice: d.Choice,
|
|
},
|
|
subject: fmt.Sprintf("Re: %s - %s", d.Decision.Tag, d.Decision.Title),
|
|
headers: motionReplyHeaders(d.Decision, mc),
|
|
recipients: []recipientData{voteNoticeRecipient(mc)},
|
|
}
|
|
}
|
|
|
|
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, mc),
|
|
recipients: []recipientData{voteNoticeRecipient(mc)},
|
|
}
|
|
}
|
|
|
|
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, mc),
|
|
recipients: []recipientData{defaultRecipient(mc)},
|
|
}
|
|
}
|