backend

package
v0.0.0-...-e030774 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 7, 2018 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

Contains a generic interface for backends.

Index

Constants

View Source 
const (
	InboxLabel   string = "0"
	DraftLabel          = "1"
	SentLabel           = "2"
	TrashLabel          = "3"
	SpamLabel           = "4"
	ArchiveLabel        = "6"
	StarredLabel        = "10"
)

System labels

View Source 
const (
	DraftType        int = 1
	SentType             = 2
	SentToMyselfType     = 3
)

Message types.

View Source 
const (
	Unencrypted                    int = 0
	EndToEndEncryptedInternal          = 1
	EncryptedExternal                  = 2
	EndToEndEncryptedExternal          = 3
	StoredEncryptedExternal            = 4
	StoredEncrypted                    = 5
	EndToEndEncryptedExternalReply     = 6
	EncryptedPgp                       = 7
	EncryptedPgpMime                   = 8
)

Message encryption types.

View Source 
const (
	InboxLocation   int = 0
	DraftLocation       = 1
	SentLocation        = 2
	TrashLocation       = 3
	SpamLocation        = 4
	ArchiveLocation     = 6
)

Messages locations.

View Source 
const (
	RoleFreeUser int = iota
	RolePaidMember
	RolePaidAdmin
)
View Source 
const PgpMessageType = "PGP MESSAGE"

Variables

This section is empty.

Functions

func ArmorMessage 

func ArmorMessage(w io.Writer) (io.WriteCloser, error)

Encode a PGP message armor.

func IsEncrypted 

func IsEncrypted(data string) bool

Check if a string contains an encrypted message.

func MessagesTotalFromCounts 

func MessagesTotalFromCounts(counts []*MessagesCount) (totals *MessagesTotal, unread *MessagesTotal)

Types

type Address 

type Address struct {
	ID          string
	DomainID    string
	Email       string
	Send        int
	Receive     int
	Status      int
	Type        int
	DisplayName string
	Signature   string
	MemberID    string
	MemberName  string

	HasKeys int
	Keys    []*Keypair
}

A user's address.

func (*Address) GetEmail 

func (a *Address) GetEmail() *Email

Get this address' email.

type AddressUpdate 

type AddressUpdate struct {
	Address     *Address
	Status      bool
	Type        bool
	DisplayName bool
	Signature   bool
}

func (*AddressUpdate) Apply 

func (update *AddressUpdate) Apply(address *Address)

type AddressesBackend 

type AddressesBackend interface {
	// Get a user's address.
	GetAddress(user, id string) (*Address, error)
	// List all addresses owned by a user.
	ListAddresses(user string) ([]*Address, error)
	// Create a new address.
	InsertAddress(user string, address *Address) (*Address, error)
	// Update an existing address.
	UpdateAddress(user string, update *AddressUpdate) (*Address, error)
	// Delete an address.
	DeleteAddress(user, id string) error
}

type Attachment 

type Attachment struct {
	ID         string
	MessageID  string `json:",omitempty"`
	Name       string
	Size       int
	MIMEType   string
	KeyPackets string `json:",omitempty"`
	Headers    textproto.MIMEHeader
	DataPacket string `json:",omitempty"` // TODO: remove this from here
}

An attachment.

type AttachmentKey 

type AttachmentKey struct {
	ID   string
	Key  string
	Algo string
}

func (*AttachmentKey) Decrypt 

func (at *AttachmentKey) Decrypt(encrypted []byte) (decrypted []byte, err error)

Decrypt a symmetrically encrypted packet with this key.

type AttachmentsBackend 

type AttachmentsBackend interface {
	// List all message's attachments.
	ListAttachments(user, msg string) ([]*Attachment, error)
	// Get an attachment content.
	ReadAttachment(user, id string) (*Attachment, []byte, error)
	// Insert a new attachment.
	InsertAttachment(user string, attachment *Attachment, contents []byte) (*Attachment, error)
	// Delete an attachment.
	DeleteAttachment(user, id string) error
}

Stores attachments.

type Backend 

type Backend struct {
	ContactsBackend
	LabelsBackend
	ConversationsBackend
	SendBackend
	DomainsBackend
	EventsBackend
	UsersBackend
	AddressesBackend
	KeysBackend
	AttachmentsBackend
}

A backend takes care of storing all mailbox data.

func New 

func New() *Backend

func (*Backend) Set 

func (b *Backend) Set(backends ...interface{})

Set one or some of this backend's components.

type Contact 

type Contact struct {
	ID    string
	Name  string
	Email string
}

A contact is an entry in the user's address book.

type ContactUpdate 

type ContactUpdate struct {
	Contact *Contact
	Name    bool
	Email   bool
}

A request to update a contact. Fields set to true will be updated with values in Contact.

func (*ContactUpdate) Apply 

func (update *ContactUpdate) Apply(contact *Contact)

Apply this update on a contact.

type ContactsBackend 

type ContactsBackend interface {
	// List all user's contacts.
	ListContacts(user string) ([]*Contact, error)
	// Insert a new contact.
	InsertContact(user string, contact *Contact) (*Contact, error)
	// Update an existing contact.
	UpdateContact(user string, update *ContactUpdate) (*Contact, error)
	// Delete a contact.
	DeleteContact(user, id string) error
	// Delete all contacts of a specific user.
	DeleteAllContacts(user string) error
}

Stores contacts data.

type Conversation 

type Conversation struct {
	ID             string
	Order          int
	Subject        string
	Senders        []*Email
	Recipients     []*Email
	NumMessages    int
	NumUnread      int
	NumAttachments int
	ExpirationTime int
	TotalSize      int
	Time           int64
	LabelIDs       []string
	Labels         []*ConversationLabel
}

A conversation is a sequence of messages.

type ConversationLabel 

type ConversationLabel struct {
	ID          string
	Count       int
	NumMessages int
	NumUnread   int
}

Contains messages counts by labels.

type ConversationsBackend 

type ConversationsBackend interface {
	MessagesBackend

	// List all messages belonging to a conversation.
	ListConversationMessages(user, id string) (msgs []*Message, err error)

	// Get a specific conversation.
	GetConversation(user, id string) (conv *Conversation, err error)
	// List all user's conversations. A message filter can be provided.
	ListConversations(user string, filter *MessagesFilter) ([]*Conversation, int, error)
	// Count all user's conversations by label.
	CountConversations(user string) ([]*MessagesCount, error)
	// Permanently delete a conversation.
	DeleteConversation(user, id string) error
}

Stores conversations data.

type Domain 

type Domain struct {
	ID         string
	DomainName string

	State       int
	VerifyState int
	MxState     int
	SpfState    int
	DkimState   int
	DmarcState  int

	Addresses []*Address
}

A domain name.

type DomainsBackend 

type DomainsBackend interface {
	// List all domains.
	ListDomains() ([]*Domain, error)
	// Get a domain.
	GetDomain(id string) (*Domain, error)
	// Get the domain which has the specified name.
	GetDomainByName(name string) (*Domain, error)
	// Insert a new domain.
	InsertDomain(domain *Domain) (*Domain, error)
}

Stores domains data.

type Email 

type Email struct {
	Name    string
	Address string
}

An email contains an address and a name.

type Event 

type Event struct {
	ID string `json:"EventID"`

	Refresh int
	Reload  int
	Notices []string

	// See https://github.com/ProtonMail/WebClient/blob/master/src/app/services/event.js#L274
	Messages           []*EventMessageDelta      `json:",omitempty"`
	Conversations      []*EventConversationDelta `json:",omitempty"`
	MessageCounts      []*MessagesCount          `json:",omitempty"`
	ConversationCounts []*MessagesCount          `json:",omitempty"`
	Total              *MessagesTotal            `json:",omitempty"`
	Unread             *MessagesTotal            `json:",omitempty"`
	Labels             []*EventLabelDelta        `json:",omitempty"`
	Contacts           []*EventContactDelta      `json:",omitempty"`
	User               *User                     `json:",omitempty"`

	UsedSpace int `json:",omitempty"`
}

func NewContactDeltaEvent 

func NewContactDeltaEvent(id string, action EventAction, contact *Contact) *Event

func NewConversationDeltaEvent 

func NewConversationDeltaEvent(id string, action EventAction, conv *Conversation) *Event

func NewLabelDeltaEvent 

func NewLabelDeltaEvent(id string, action EventAction, label *Label) *Event

func NewMessageDeltaEvent 

func NewMessageDeltaEvent(id string, action EventAction, msg *Message) *Event

func NewUserEvent 

func NewUserEvent(user *User) *Event

type EventAction 

type EventAction int
const (
	EventDelete EventAction = iota
	EventCreate
	EventUpdate
)

type EventContactDelta 

type EventContactDelta struct {
	EventDelta
	Contact *Contact
}

type EventConversationDelta 

type EventConversationDelta struct {
	EventDelta
	Conversation *Conversation
}

type EventDelta 

type EventDelta struct {
	ID     string
	Action EventAction
}

type EventLabelDelta 

type EventLabelDelta struct {
	EventDelta
	Label *Label
}

type EventMessageDelta 

type EventMessageDelta struct {
	EventDelta
	Message *Message
}

type EventsBackend 

type EventsBackend interface {
	// Insert a new event.
	InsertEvent(user string, event *Event) error
	// Get the last event.
	GetLastEvent(user string) (*Event, error)
	// Get the sum of all events after a specific one.
	GetEventsAfter(user, id string) (*Event, error)
	// Delete all user's events. This happens when the user is no longer connected.
	DeleteAllEvents(user string) error
}

Stores events data.

type Keypair 

type Keypair struct {
	ID          string
	PublicKey   string
	PrivateKey  string
	Fingerprint string // TODO: populate this field
}

A keypair contains a private and a public key.

func NewKeypair 

func NewKeypair(pub, priv string) *Keypair

Create a new keypair.

func (*Keypair) Encrypt 

func (kp *Keypair) Encrypt(data string) (encrypted string, err error)

Encrypt a message to the keypair's owner.

type KeysBackend 

type KeysBackend interface {
	// Get a public key for a user.
	// If no key is available, an empty string and no error must be returned.
	GetPublicKey(email string) (string, error)
	// Get a keypair for a user. Contains public & private key.
	GetKeypair(email string) (*Keypair, error)
	// Create a new keypair.
	InsertKeypair(email string, keypair *Keypair) (*Keypair, error)
	// Update a user's private key.
	// PublicKey must be updated only if it isn't empty.
	UpdateKeypair(email string, keypair *Keypair) (*Keypair, error)
}

type Label 

type Label struct {
	ID        string
	Name      string
	Color     string
	Display   int
	Type      LabelType
	Exclusive int
	Order     int
}

A message label.

type LabelTotal 

type LabelTotal struct {
	LabelID string
	Count   int
}

type LabelType 

type LabelType int
const (
	LabelMessage LabelType = 1
	LabelContact
)

type LabelUpdate 

type LabelUpdate struct {
	Label   *Label
	Name    bool
	Color   bool
	Display bool
	Order   bool
}

A request to update a label. Fields set to true will be updated with values in Label.

func (*LabelUpdate) Apply 

func (update *LabelUpdate) Apply(label *Label)

Apply this update on a label.

type LabelsBackend 

type LabelsBackend interface {
	// List all user's labels.
	ListLabels(user string) ([]*Label, error)
	// Insert a new label.
	InsertLabel(user string, label *Label) (*Label, error)
	// Update an existing label.
	UpdateLabel(user string, update *LabelUpdate) (*Label, error)
	// Delete a label.
	DeleteLabel(user, id string) error
}

Stores labels data.

type LabelsOperation 

type LabelsOperation int

The operation to apply to labels. 

const (
	KeepLabels    LabelsOperation = iota // Do nothing
	ReplaceLabels                        // Replace current labels with new ones
	AddLabels                            // Add new labels to current ones
	RemoveLabels                         // Remove specified labels from current ones
)

type LocationTotal 

type LocationTotal struct {
	Location int
	Count    int
}

type Message 

type Message struct {
	ID             string
	Order          int
	ConversationID string
	Subject        string
	IsRead         int
	Type           int
	SenderAddress  string
	SenderName     string
	Sender         *Email
	ToList         []*Email
	CCList         []*Email
	BCCList        []*Email
	Time           int64
	Size           int
	HasAttachment  int
	NumAttachments int
	IsEncrypted    int
	ExpirationTime int
	IsReplied      int
	IsRepliedAll   int
	IsForwarded    int
	AddressID      string
	Body           string `json:",omitempty"`
	Header         string `json:",omitempty"`
	ReplyTo        *Email
	Attachments    []*Attachment
	Starred        int
	Location       int
	LabelIDs       []string
}

A message.

type MessagePackage 

type MessagePackage struct {
	Address    string
	Type       int
	Body       string
	KeyPackets []string
}

type MessageUpdate 

type MessageUpdate struct {
	Message   *Message
	ToList    bool
	CCList    bool
	BCCList   bool
	Subject   bool
	IsRead    bool
	Type      bool
	AddressID bool
	Body      bool
	Time      bool
	Starred   bool
	LabelIDs  LabelsOperation
}

A request to update a message. Fields set to true will be updated with values in Message.

func (*MessageUpdate) Apply 

func (update *MessageUpdate) Apply(msg *Message)

Apply this update on a message.

type MessagesBackend 

type MessagesBackend interface {
	// Get a message.
	GetMessage(user, id string) (*Message, error)
	// List all user's messages. A message filter can be provided.
	ListMessages(user string, filter *MessagesFilter) ([]*Message, int, error)
	// Count all user's messages by label.
	CountMessages(user string) ([]*MessagesCount, error)
	// Insert a new message.
	InsertMessage(user string, msg *Message) (*Message, error)
	// Update an existing message.
	UpdateMessage(user string, update *MessageUpdate) (*Message, error)
	// Permanently delete a message.
	DeleteMessage(user, id string) error
}

Stores messages data.

type MessagesCount 

type MessagesCount struct {
	LabelID string
	Total   int
	Unread  int
}

Contains message counts for one label.

type MessagesFilter 

type MessagesFilter struct {
	Limit       int
	Page        int
	Label       string
	Keyword     string
	Address     string // Address ID
	Attachments bool
	From        string
	To          string
	Begin       int64 // Timestamp
	End         int64 // Timestamp
	Sort        string
	Desc        bool
}

Contains fields to filter messages.

type MessagesTotal 

type MessagesTotal struct {
	Locations []*LocationTotal
	Labels    []*LabelTotal
	Starred   int
}

Contains a summary of messages counts per location and label.

type OutgoingAttachment 

type OutgoingAttachment struct {
	*Attachment

	Data []byte
}

An attachment that is going to be sent.

type OutgoingMessage 

type OutgoingMessage struct {
	*Message
	*MessagePackage

	InReplyTo   string
	References  string
	Attachments []*OutgoingAttachment
}

A message that is going to be sent. Message.Body MUST be ignored, MessagePackage.Body MUST be used instead. The recipient is specified in MessagePackage.Address.

type SendBackend 

type SendBackend interface {
	// Send a message to an e-mail address.
	SendMessage(user string, msg *OutgoingMessage) error
}

Sends messages to email addresses.

type User 

type User struct {
	ID                string
	Name              string
	NotificationEmail string
	Signature         string
	NumMessagePerPage int
	UsedSpace         int
	Notify            int
	AutoSaveContacts  int
	Language          string
	LogAuth           int
	ComposerMode      int
	MessageButtons    int
	ShowImages        int
	ShowEmbedded      int
	ViewMode          int
	ViewLayout        int
	SwipeLeft         int
	SwipeRight        int
	Theme             string
	Currency          string
	Credit            int
	InvoiceText       string
	AlsoArchive       int
	Hotkeys           int
	PMSignature       int
	TwoFactor         int
	PasswordReset     int
	PasswordMode      int
	News              int
	DisplayName       string
	MaxSpace          int
	MaxUpload         int
	Role              int
	Private           int
	Subscribed        int
	Deliquent         int
	VPN               interface{}
	Addresses         []*Address
	Keys              []*Keypair
}

A user.

func (*User) GetMainAddress 

func (u *User) GetMainAddress() *Address

type UserUpdate 

type UserUpdate struct {
	User             *User
	DisplayName      bool
	Signature        bool
	AutoSaveContacts bool
	ShowImages       bool
	ComposerMode     bool
	ViewLayout       bool
	MessageButtons   bool
	Theme            bool
}

A request to update a user. Fields set to true will be updated with values in User.

func (*UserUpdate) Apply 

func (update *UserUpdate) Apply(user *User)

Apply this update on a user.

type UsersBackend 

type UsersBackend interface {
	// Check if a username is available.
	IsUsernameAvailable(username string) (bool, error)
	// Get a user.
	GetUser(id string) (*User, error)
	// Check if the provided username and password are correct
	Auth(username, password string) (*User, error)
	// Insert a new user. Returns the newly created user.
	InsertUser(user *User, password string) (*User, error)
	// Update an existing user.
	UpdateUser(update *UserUpdate) error
	// Update a user's password.
	UpdateUserPassword(id, current, new string) error
}

Source Files

View all Source files

Directories

Path Synopsis
Stores data in files on disk.
 Stores data in files on disk.
Provides backends to trigger events.
 Provides backends to trigger events.
Stores messages on an IMAP server.
 Stores messages on an IMAP server.
Stores data in memory.
 Stores data in memory.
Sends messages with a SMTP server.
 Sends messages with a SMTP server.
Backend utilities.
 Backend utilities.
textproto
Provides utilities to parse and format messages.
 Provides utilities to parse and format messages.
textproto/chunksplit
Provides a chunk splitter.
 Provides a chunk splitter.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.