storj/private/post/message.go
Egon Elbre 961e841bd7 all: fix error naming
errs.Class should not contain "error" in the name, since that causes a
lot of stutter in the error logs. As an example a log line could end up
looking like:

    ERROR node stats service error: satellitedbs error: node stats database error: no rows

Whereas something like:

    ERROR nodestats service: satellitedbs: nodestatsdb: no rows

Would contain all the necessary information without the stutter.

Change-Id: I7b7cb7e592ebab4bcfadc1eef11122584d2b20e0
2021-04-29 15:38:21 +03:00

130 lines
3.5 KiB
Go

// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information
package post
import (
"bytes"
"fmt"
"io"
"mime"
"mime/multipart"
"mime/quotedprintable"
"net/textproto"
"time"
"github.com/zeebo/errs"
)
// Message is RFC compliant email message.
type Message struct {
From Address
To []Address
Subject string
ID string
Date time.Time
ReceiptTo []string
PlainText string
Parts []Part
}
// Part represent one part of multipart message.
type Part struct {
Type string
Encoding string
Disposition string
Content string
}
// Error is the default message errs class.
var Error = errs.Class("Email message")
// Bytes builds message and returns result as bytes.
func (msg *Message) Bytes() (data []byte, err error) {
// always returns nil error on read and write, so most of the errors can be ignored
var body bytes.Buffer
// write headers
fmt.Fprintf(&body, "MIME-Version: 1.0\r\n")
fmt.Fprintf(&body, "Subject: %v\r\n", mime.QEncoding.Encode("utf-8", msg.Subject))
fmt.Fprintf(&body, "From: %s\r\n", &msg.From)
for _, to := range msg.To {
fmt.Fprintf(&body, "To: %s\r\n", &to) // nolint:scopelint
}
for _, recipient := range msg.ReceiptTo {
fmt.Fprintf(&body, "Disposition-Notification-To: <%v>\r\n", mime.QEncoding.Encode("utf-8", recipient))
}
// date and id are optional as they can be set by server itself
if !msg.Date.IsZero() {
fmt.Fprintf(&body, "Date: %v\r\n", msg.Date)
}
if msg.ID != "" {
fmt.Fprintf(&body, "Message-ID: <%v>\r\n", mime.QEncoding.Encode("utf-8", msg.ID))
}
switch {
// multipart upload
case len(msg.Parts) > 0:
wr := multipart.NewWriter(&body)
defer func() { err = errs.Combine(err, wr.Close()) }()
fmt.Fprintf(&body, "Content-Type: multipart/alternative;")
fmt.Fprintf(&body, "\tboundary=\"%v\"\r\n", wr.Boundary())
fmt.Fprintf(&body, "\r\n")
var sub io.Writer
if len(msg.PlainText) > 0 {
sub, err := wr.CreatePart(textproto.MIMEHeader{
"Content-Type": []string{"text/plain; charset=UTF-8; format=flowed"},
"Content-Transfer-Encoding": []string{"quoted-printable"},
})
if err != nil {
return nil, Error.Wrap(err)
}
enc := quotedprintable.NewWriter(sub)
defer func() { err = errs.Combine(err, enc.Close()) }()
_, err = enc.Write([]byte(msg.PlainText))
if err != nil {
return nil, Error.Wrap(err)
}
}
for _, part := range msg.Parts {
header := textproto.MIMEHeader{"Content-Type": []string{mime.QEncoding.Encode("utf-8", part.Type)}}
if part.Encoding != "" {
header["Content-Transfer-Encoding"] = []string{mime.QEncoding.Encode("utf-8", part.Encoding)}
}
if part.Disposition != "" {
header["Content-Disposition"] = []string{mime.QEncoding.Encode("utf-8", part.Disposition)}
}
sub, _ = wr.CreatePart(header)
fmt.Fprint(sub, part.Content)
}
// fallback if there are no parts, write PlainText with appropriate Content-Type
default:
fmt.Fprintf(&body, "Content-Type: text/plain; charset=UTF-8; format=flowed\r\n")
fmt.Fprintf(&body, "Content-Transfer-Encoding: quoted-printable\r\n\r\n")
enc := quotedprintable.NewWriter(&body)
defer func() { err = errs.Combine(err, enc.Close()) }()
if _, err := enc.Write([]byte(msg.PlainText)); err != nil {
return nil, Error.Wrap(err)
}
}
return tocrlf(body.Bytes()), nil
}
func tocrlf(data []byte) []byte {
lf := bytes.ReplaceAll(data, []byte("\r\n"), []byte("\n"))
crlf := bytes.ReplaceAll(lf, []byte("\n"), []byte("\r\n"))
return crlf
}