mirror of
https://github.com/emersion/go-imap
synced 2026-07-01 23:54:34 +00:00
Simon Ser
3a66d70513
All commands embed a base struct previously called "cmd". The
"cmd" type exports a Wait method, intended to be used for simple
commands which don't return any additional data. Typical usage:
type MyCommand {
cmd
}
Unfortunately, even if "cmd" is an unexported field, its Wait method
is accessible to other packages. This causes issues for commands
which need to read a bunch of untagged responses before completing.
Fix this by rejiggering the command types. Introduce a baseCommand
type which is embedded in all command types and doesn't export any
method. Add a Command type which exposes a single Wait method for
simple commands.
Closes: https://github.com/emersion/go-imap/issues/641
86 lines
1.9 KiB
Go
86 lines
1.9 KiB
Go
package imapclient
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/emersion/go-imap/v2"
|
|
"github.com/emersion/go-imap/v2/internal/imapwire"
|
|
)
|
|
|
|
// ThreadOptions contains options for the THREAD command.
|
|
type ThreadOptions struct {
|
|
Algorithm imap.ThreadAlgorithm
|
|
SearchCriteria *imap.SearchCriteria
|
|
}
|
|
|
|
func (c *Client) thread(numKind imapwire.NumKind, options *ThreadOptions) *ThreadCommand {
|
|
cmd := &ThreadCommand{}
|
|
enc := c.beginCommand(uidCmdName("THREAD", numKind), cmd)
|
|
enc.SP().Atom(string(options.Algorithm)).SP().Atom("UTF-8").SP()
|
|
writeSearchKey(enc.Encoder, options.SearchCriteria)
|
|
enc.end()
|
|
return cmd
|
|
}
|
|
|
|
// Thread sends a THREAD command.
|
|
//
|
|
// This command requires support for the THREAD extension.
|
|
func (c *Client) Thread(options *ThreadOptions) *ThreadCommand {
|
|
return c.thread(imapwire.NumKindSeq, options)
|
|
}
|
|
|
|
// UIDThread sends a UID THREAD command.
|
|
//
|
|
// See Thread.
|
|
func (c *Client) UIDThread(options *ThreadOptions) *ThreadCommand {
|
|
return c.thread(imapwire.NumKindUID, options)
|
|
}
|
|
|
|
func (c *Client) handleThread() error {
|
|
cmd := findPendingCmdByType[*ThreadCommand](c)
|
|
for c.dec.SP() {
|
|
data, err := readThreadList(c.dec)
|
|
if err != nil {
|
|
return fmt.Errorf("in thread-list: %v", err)
|
|
}
|
|
if cmd != nil {
|
|
cmd.data = append(cmd.data, *data)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ThreadCommand is a THREAD command.
|
|
type ThreadCommand struct {
|
|
commandBase
|
|
data []ThreadData
|
|
}
|
|
|
|
func (cmd *ThreadCommand) Wait() ([]ThreadData, error) {
|
|
err := cmd.wait()
|
|
return cmd.data, err
|
|
}
|
|
|
|
type ThreadData struct {
|
|
Chain []uint32
|
|
SubThreads []ThreadData
|
|
}
|
|
|
|
func readThreadList(dec *imapwire.Decoder) (*ThreadData, error) {
|
|
var data ThreadData
|
|
err := dec.ExpectList(func() error {
|
|
var num uint32
|
|
if len(data.SubThreads) == 0 && dec.Number(&num) {
|
|
data.Chain = append(data.Chain, num)
|
|
} else {
|
|
sub, err := readThreadList(dec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data.SubThreads = append(data.SubThreads, *sub)
|
|
}
|
|
return nil
|
|
})
|
|
return &data, err
|
|
}
|