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
|
package maildir
import (
"fmt"
"io"
"github.com/emersion/go-maildir"
"git.sr.ht/~rjarry/aerc/lib/log"
"git.sr.ht/~rjarry/aerc/lib/rfc822"
"git.sr.ht/~rjarry/aerc/models"
"git.sr.ht/~rjarry/aerc/worker/lib"
)
// A Message is an individual email inside of a maildir.Dir.
type Message struct {
dir maildir.Dir
uid uint32
key string
}
// NewReader reads a message into memory and returns an io.Reader for it.
func (m Message) NewReader() (io.ReadCloser, error) {
return m.dir.Open(m.key)
}
// Flags fetches the set of flags currently applied to the message.
func (m Message) Flags() ([]maildir.Flag, error) {
return m.dir.Flags(m.key)
}
// ModelFlags fetches the set of models.flags currently applied to the message.
func (m Message) ModelFlags() (models.Flags, error) {
flags, err := m.dir.Flags(m.key)
if err != nil {
return 0, err
}
return lib.FromMaildirFlags(flags), nil
}
// SetFlags replaces the message's flags with a new set.
func (m Message) SetFlags(flags []maildir.Flag) error {
return m.dir.SetFlags(m.key, flags)
}
// SetOneFlag enables or disables a single message flag on the message.
func (m Message) SetOneFlag(flag maildir.Flag, enable bool) error {
flags, err := m.Flags()
if err != nil {
return fmt.Errorf("could not read previous flags: %w", err)
}
if enable {
flags = append(flags, flag)
return m.SetFlags(flags)
}
var newFlags []maildir.Flag
for _, oldFlag := range flags {
if oldFlag != flag {
newFlags = append(newFlags, oldFlag)
}
}
return m.SetFlags(newFlags)
}
// MarkReplied either adds or removes the maildir.FlagReplied flag from the
// message.
func (m Message) MarkReplied(answered bool) error {
return m.SetOneFlag(maildir.FlagReplied, answered)
}
// Remove deletes the email immediately.
func (m Message) Remove() error {
return m.dir.Remove(m.key)
}
// MessageInfo populates a models.MessageInfo struct for the message.
func (m Message) MessageInfo() (*models.MessageInfo, error) {
info, err := rfc822.MessageInfo(m)
if err != nil {
return nil, err
}
info.Size, err = m.Size()
if err != nil {
// don't care if size retrieval fails
log.Debugf("message size: %v", err)
}
return info, nil
}
func (m Message) Size() (uint32, error) {
name, err := m.dir.Filename(m.key)
if err != nil {
return 0, fmt.Errorf("failed to get filename: %w", err)
}
size, err := lib.FileSize(name)
if err != nil {
return 0, fmt.Errorf("failed to get filesize: %w", err)
}
return size, nil
}
// MessageHeaders populates a models.MessageInfo struct for the message with
// minimal information, used for sorting and threading.
func (m Message) MessageHeaders() (*models.MessageInfo, error) {
info, err := rfc822.MessageHeaders(m)
if err != nil {
return nil, err
}
info.Size, err = m.Size()
if err != nil {
// don't care if size retrieval fails
log.Debugf("message size failed: %v", err)
}
return info, nil
}
// NewBodyPartReader creates a new io.Reader for the requested body part(s) of
// the message.
func (m Message) NewBodyPartReader(requestedParts []int) (io.Reader, error) {
f, err := m.dir.Open(m.key)
if err != nil {
return nil, err
}
defer f.Close()
msg, err := rfc822.ReadMessage(f)
if err != nil {
return nil, fmt.Errorf("could not read message: %w", err)
}
return rfc822.FetchEntityPartReader(msg, requestedParts)
}
func (m Message) UID() uint32 {
return m.uid
}
func (m Message) Labels() ([]string, error) {
return nil, nil
}
|
