Implement interface for my custom IMAP flags

5 files changed, 358 insertions, 0 deletions

diff --git a/worker/imap/flags.go b/worker/imap/flags.go
index aef1019..d71e3bb 100644
--- a/worker/imap/flags.go
+++ b/worker/imap/flags.go
@@ -76,6 +76,263 @@ func (imapw *IMAPWorker) handleAnsweredMessages(msg *types.AnsweredMessages) {
 	})
 }
 
+// NOTE(shivesh): my custom flags
+func (imapw *IMAPWorker) handleImportantMessages(msg *types.ImportantMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"important"}
+	if !msg.Important {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"important"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleImportantMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handleListMessages(msg *types.ListMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"list"}
+	if !msg.List {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"list"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleListMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handleFoodMessages(msg *types.FoodMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"food"}
+	if !msg.Food {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"food"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleFoodMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handlePersonalMessages(msg *types.PersonalMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"personal"}
+	if !msg.Personal {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"personal"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handlePersonalMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handleWorkMessages(msg *types.WorkMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"work"}
+	if !msg.Work {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"work"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleWorkMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handlePhysicsMessages(msg *types.PhysicsMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"physics"}
+	if !msg.Physics {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"physics"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handlePhysicsMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handleTodoMessages(msg *types.TodoMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"todo"}
+	if !msg.Todo {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"todo"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleTodoMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
+func (imapw *IMAPWorker) handleLaterMessages(msg *types.LaterMessages) {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{"later"}
+	if !msg.Later {
+		item = imap.FormatFlagsOp(imap.RemoveFlags, true)
+		flags = []interface{}{"later"}
+	}
+	uids := toSeqSet(msg.Uids)
+	emitErr := func(err error) {
+		imapw.worker.PostMessage(&types.Error{
+			Message: types.RespondTo(msg),
+			Error:   err,
+		}, nil)
+	}
+	if err := imapw.client.UidStore(uids, item, flags, nil); err != nil {
+		emitErr(err)
+		return
+	}
+	imapw.worker.PostAction(&types.FetchMessageHeaders{
+		Uids: msg.Uids,
+	}, func(_msg types.WorkerMessage) {
+		switch m := _msg.(type) {
+		case *types.Error:
+			err := fmt.Errorf("handleLaterMessages: %v", m.Error)
+			imapw.worker.Logger.Printf("could not fetch headers: %s", err)
+			emitErr(err)
+		case *types.Done:
+			imapw.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
+		}
+	})
+}
+
 func (imapw *IMAPWorker) handleFlagMessages(msg *types.FlagMessages) {
 	flags := []interface{}{flagToImap[msg.Flag]}
 	item := imap.FormatFlagsOp(imap.AddFlags, true)
diff --git a/worker/imap/imap.go b/worker/imap/imap.go
index 29dbc10..e625374 100644
--- a/worker/imap/imap.go
+++ b/worker/imap/imap.go
@@ -85,6 +85,15 @@ var imapToFlag = map[string]models.Flag{
 	imap.AnsweredFlag: models.AnsweredFlag,
 	imap.DeletedFlag:  models.DeletedFlag,
 	imap.FlaggedFlag:  models.FlaggedFlag,
+	// NOTE(shivesh): my custom flags
+	"important":       models.ImportantFlag,
+	"list":            models.ListFlag,
+	"food":            models.FoodFlag,
+	"personal":        models.PersonalFlag,
+	"work":            models.WorkFlag,
+	"physics":         models.PhysicsFlag,
+	"todo":            models.TodoFlag,
+	"later":           models.LaterFlag,
 }
 
 var flagToImap = map[models.Flag]string{
@@ -93,6 +102,15 @@ var flagToImap = map[models.Flag]string{
 	models.AnsweredFlag: imap.AnsweredFlag,
 	models.DeletedFlag:  imap.DeletedFlag,
 	models.FlaggedFlag:  imap.FlaggedFlag,
+	// NOTE(shivesh): my custom flags
+	models.ImportantFlag: "important",
+	models.ListFlag:      "list",
+	models.FoodFlag:      "food",
+	models.PersonalFlag:  "personal",
+	models.WorkFlag:      "work",
+	models.PhysicsFlag:   "physics",
+	models.TodoFlag:      "todo",
+	models.LaterFlag:     "later",
 }
 
 func translateImapFlags(imapFlags []string) []models.Flag {
diff --git a/worker/imap/search.go b/worker/imap/search.go
index f866b1c..d27648b 100644
--- a/worker/imap/search.go
+++ b/worker/imap/search.go
@@ -66,6 +66,23 @@ func getParsedFlag(name string) (string, error) {
 		return imap.FlaggedFlag, nil
 	case "answered":
 		return imap.AnsweredFlag, nil
+	// NOTE(shivesh): my custom flags
+	case "important":
+		return name, nil
+	case "list":
+		return name, nil
+	case "food":
+		return name, nil
+	case "personal":
+		return name, nil
+	case "work":
+		return name, nil
+	case "physics":
+		return name, nil
+	case "todo":
+		return name, nil
+	case "later":
+		return name, nil
 	}
 	return imap.FlaggedFlag, errors.New("Flag not suppored")
 }
diff --git a/worker/imap/worker.go b/worker/imap/worker.go
index dab0afb..d5d4421 100644
--- a/worker/imap/worker.go
+++ b/worker/imap/worker.go
@@ -181,6 +181,23 @@ func (w *IMAPWorker) handleMessage(msg types.WorkerMessage) error {
 		w.handleFlagMessages(msg)
 	case *types.AnsweredMessages:
 		w.handleAnsweredMessages(msg)
+	// NOTE(shivesh): my custom flags
+	case *types.ImportantMessages:
+		w.handleImportantMessages(msg)
+	case *types.ListMessages:
+		w.handleListMessages(msg)
+	case *types.FoodMessages:
+		w.handleFoodMessages(msg)
+	case *types.PersonalMessages:
+		w.handlePersonalMessages(msg)
+	case *types.WorkMessages:
+		w.handleWorkMessages(msg)
+	case *types.PhysicsMessages:
+		w.handlePhysicsMessages(msg)
+	case *types.TodoMessages:
+		w.handleTodoMessages(msg)
+	case *types.LaterMessages:
+		w.handleLaterMessages(msg)
 	case *types.CopyMessages:
 		w.handleCopyMessages(msg)
 	case *types.AppendMessage:
diff --git a/worker/types/messages.go b/worker/types/messages.go
index ab0e545..ea61211 100644
--- a/worker/types/messages.go
+++ b/worker/types/messages.go
@@ -133,6 +133,55 @@ type AnsweredMessages struct {
 	Uids     []uint32
 }
 
+// NOTE(shivesh): my custom flags
+type ImportantMessages struct {
+	Message
+	Important bool
+	Uids      []uint32
+}
+
+type ListMessages struct {
+	Message
+	List bool
+	Uids []uint32
+}
+
+type FoodMessages struct {
+	Message
+	Food bool
+	Uids []uint32
+}
+
+type PersonalMessages struct {
+	Message
+	Personal bool
+	Uids     []uint32
+}
+
+type WorkMessages struct {
+	Message
+	Work bool
+	Uids []uint32
+}
+
+type PhysicsMessages struct {
+	Message
+	Physics bool
+	Uids    []uint32
+}
+
+type TodoMessages struct {
+	Message
+	Todo bool
+	Uids []uint32
+}
+
+type LaterMessages struct {
+	Message
+	Later bool
+	Uids  []uint32
+}
+
 type CopyMessages struct {
 	Message
 	Destination string