139 lines
4.4 KiB
Go
139 lines
4.4 KiB
Go
package imap
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/emersion/go-imap"
|
|
)
|
|
|
|
type Mailbox struct {
|
|
name string
|
|
session *Session
|
|
}
|
|
|
|
// Name returns this mailbox name.
|
|
func (m *Mailbox) Name() string {
|
|
return m.name
|
|
}
|
|
|
|
// Info returns this mailbox info.
|
|
func (m *Mailbox) Info() (*imap.MailboxInfo, error) {
|
|
return &imap.MailboxInfo{
|
|
Attributes: []string{}, // FIXME: what do we need here?
|
|
Delimiter: "/",
|
|
Name: m.Name(),
|
|
}, nil
|
|
}
|
|
|
|
// Status returns this mailbox status. The fields Name, Flags, PermanentFlags
|
|
// and UnseenSeqNum in the returned MailboxStatus must be always populated.
|
|
// This function does not affect the state of any messages in the mailbox. See
|
|
// RFC 3501 section 6.3.10 for a list of items that can be requested.
|
|
func (m *Mailbox) Status(items []string) (*imap.MailboxStatus, error) {
|
|
return &imap.MailboxStatus{
|
|
Name: m.Name(),
|
|
Flags: []string{}, // FIXME: what do we need here?
|
|
PermanentFlags: []string{}, // FIXME: what do we need here?
|
|
//UnseenSeqNum: 0, // FIXME: what do we need here? What even is a seqnum?
|
|
Messages: 1, // FIXME: hardcoded
|
|
}, nil
|
|
}
|
|
|
|
// SetSubscribed adds or removes the mailbox to the server's set of "active"
|
|
// or "subscribed" mailboxes.
|
|
func (m *Mailbox) SetSubscribed(subscribed bool) error {
|
|
return ErrNotImplemented
|
|
}
|
|
|
|
// Check requests a checkpoint of the currently selected mailbox. A checkpoint
|
|
// refers to any implementation-dependent housekeeping associated with the
|
|
// mailbox (e.g., resolving the server's in-memory state of the mailbox with
|
|
// the state on its disk). A checkpoint MAY take a non-instantaneous amount of
|
|
// real time to complete. If a server implementation has no such housekeeping
|
|
// considerations, CHECK is equivalent to NOOP.
|
|
func (m *Mailbox) Check() error {
|
|
return nil // FIXME: do we need to do anything here?
|
|
}
|
|
|
|
// ListMessages returns a list of messages. seqset must be interpreted as UIDs
|
|
// if uid is set to true and as message sequence numbers otherwise. See RFC
|
|
// 3501 section 6.4.5 for a list of items that can be requested.
|
|
//
|
|
// Messages must be sent to ch. When the function returns, ch must be closed.
|
|
func (m *Mailbox) ListMessages(uid bool, seqset *imap.SeqSet, items []string, ch chan<- *imap.Message) error {
|
|
defer close(ch)
|
|
|
|
// FIXME: TODO
|
|
|
|
messages, err := m.session.store.FindMessages(m.session.Username(), m.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i, _ := range messages {
|
|
envelope := &imap.Envelope{}
|
|
|
|
body := map[*imap.BodySectionName]imap.Literal{}
|
|
|
|
imapMsg := &imap.Message{
|
|
SeqNum: uint32(i + 1),
|
|
Envelope: envelope,
|
|
Uid: uint32(i + 1),
|
|
Body: body,
|
|
}
|
|
|
|
fmt.Printf("Sending message %#v", imapMsg)
|
|
|
|
ch <- imapMsg
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SearchMessages searches messages. The returned list must contain UIDs if
|
|
// uid is set to true, or sequence numbers otherwise.
|
|
func (m *Mailbox) SearchMessages(uid bool, criteria *imap.SearchCriteria) ([]uint32, error) {
|
|
return nil, ErrNotImplemented
|
|
}
|
|
|
|
// CreateMessage appends a new message to this mailbox. The \Recent flag will
|
|
// be added no matter flags is empty or not. If date is nil, the current time
|
|
// will be used.
|
|
//
|
|
// If the Backend implements Updater, it must notify the client immediately
|
|
// via a mailbox update.
|
|
func (m *Mailbox) CreateMessage(flags []string, date time.Time, body imap.Literal) error {
|
|
return ErrNotImplemented
|
|
}
|
|
|
|
// UpdateMessagesFlags alters flags for the specified message(s).
|
|
//
|
|
// If the Backend implements Updater, it must notify the client immediately
|
|
// via a message update.
|
|
func (m *Mailbox) UpdateMessagesFlags(uid bool, seqset *imap.SeqSet, operation imap.FlagsOp, flags []string) error {
|
|
return ErrNotImplemented
|
|
}
|
|
|
|
// CopyMessages copies the specified message(s) to the end of the specified
|
|
// destination mailbox. The flags and internal date of the message(s) SHOULD
|
|
// be preserved, and the Recent flag SHOULD be set, in the copy.
|
|
//
|
|
// If the destination mailbox does not exist, a server SHOULD return an error.
|
|
// It SHOULD NOT automatically create the mailbox.
|
|
//
|
|
// If the Backend implements Updater, it must notify the client immediately
|
|
// via a mailbox update.
|
|
func (m *Mailbox) CopyMessages(uid bool, seqset *imap.SeqSet, dest string) error {
|
|
return ErrNotImplemented
|
|
}
|
|
|
|
// Expunge permanently removes all messages that have the \Deleted flag set
|
|
// from the currently selected mailbox.
|
|
//
|
|
// If the Backend implements Updater, it must notify the client immediately
|
|
// via an expunge update.
|
|
func (m *Mailbox) Expunge() error {
|
|
return ErrNotImplemented
|
|
}
|