Merge pull request #11 from rusq/back

Picklist: Back button

Author: rusq

errors.go

@@ -0,0 +1,31 @@
+package tbcomctl
+
+import "errors"
+
+// ErrType is the type of error returned by the callback functions.
+type ErrType int
+
+const (
+	TErrNoChange ErrType = iota // there has been no change to the selection
+	TErrRetry                   // error of this type will ask user to retry the selection or input
+	TInputError                 // tell user that there was an input error (user-error)
+)
+
+// Error is the type of error returned by the input-processing callback functions
+type Error struct {
+	Alert bool
+	Msg   string
+	Type  ErrType
+}
+
+func (e *Error) Error() string { return e.Msg }
+
+var (
+	// ErrRetry should be returned by CallbackFunc if the retry should be performed.
+	ErrRetry = &Error{Type: TErrRetry, Msg: "retry", Alert: true}
+	// ErrNoChange should be returned if the user picked the same value as before, and no update needed.
+	ErrNoChange = &Error{Type: TErrNoChange, Msg: "no change"}
+)
+
+// BackPressed is a special type of error indicating that callback handler should call the previous handler.
+var BackPressed = errors.New("back")

examples/picklist/main.go

@@ -39,15 +39,29 @@ func main() {
 	p2 := tbcomctl.NewPicklistText(
 		"2",
 		"second picklist",
-		[]string{"5", "6", "7", "8"},
+		[]string{"5", "6", "7", "8", "back"},
+		func(ctx context.Context, c tb.Context) error {
+			fmt.Println(tbcomctl.Sdump(c.Callback()))
+			if c.Data() == "back" {
+				return tbcomctl.BackPressed
+			}
+			return nil
+		},
+		tbcomctl.PickOptBtnPattern([]uint{1, 2, 1, 1}),
+	)
+	p3 := tbcomctl.NewPicklistText(
+		"3",
+		"picklist with back button option",
+		[]string{"9", "A", "B", "C"},
 		func(ctx context.Context, c tb.Context) error {
 			fmt.Println(tbcomctl.Sdump(c.Callback()))
 			return nil
 		},
 		tbcomctl.PickOptBtnPattern([]uint{1, 2, 1}),
+		tbcomctl.PickOptBtnBackWithText("option back"),
 	)
 	m := tbcomctl.NewMessageText("msg", "all ok")
-	form := tbcomctl.NewForm(p1, p2, m).
+	form := tbcomctl.NewForm(p1, p2, p3, m).
 		SetOverwrite(true).
 		SetRemoveButtons(true)
 	b.Handle("/picklist", form.Handler)

picklist.go

@@ -2,10 +2,12 @@ package tbcomctl
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"runtime/trace"
 	"strings"
 
+	"github.com/rusq/dlog"
 	tb "gopkg.in/tucnak/telebot.v3"
 )
 
@@ -21,9 +23,11 @@ type Picklist struct {
 	removeButtons bool
 	noUpdate      bool
 	msgChoose     bool
+	backBtn       bool
 
-	vFn  ValuesFunc
-	cbFn BtnCallbackFunc
+	vFn       ValuesFunc
+	cbFn      BtnCallbackFunc
+	backTxtFn TextFunc
 
 	btnPattern []uint
 }
@@ -102,6 +106,19 @@ func PickOptBtnPattern(pattern []uint) PicklistOption {
 	}
 }
 
+func PickOptBtnBack(textFn TextFunc) PicklistOption {
+	return func(p *Picklist) {
+		p.backBtn = true
+		p.backTxtFn = textFn
+	}
+}
+
+func PickOptBtnBackWithText(s string) PicklistOption {
+	return PickOptBtnBack(func(ctx context.Context, u *tb.User) (string, error) {
+		return s, nil
+	})
+}
+
 // NewPicklist creates a new picklist.
 func NewPicklist(name string, textFn TextFunc, valuesFn ValuesFunc, callbackFn BtnCallbackFunc, opts ...PicklistOption) *Picklist {
 	if textFn == nil || valuesFn == nil || callbackFn == nil {
@@ -116,6 +133,9 @@ func NewPicklist(name string, textFn TextFunc, valuesFn ValuesFunc, callbackFn B
 	for _, opt := range opts {
 		opt(p)
 	}
+	if p.backBtn {
+		p.btnPattern = append(p.btnPattern, 1)
+	}
 	return p
 }
 
@@ -169,12 +189,30 @@ func (p *Picklist) Callback(c tb.Context) error {
 	p.logCallback(cb)
 
 	var resp tb.CallbackResponse
+
+	if p.backBtn {
+		// back button is enabled, check if the callback data contains back button text.
+		txt, err := p.backTxtFn(ctx, c.Sender())
+		if err != nil {
+			trace.Logf(ctx, "back button", "err=%s", err)
+		}
+		if c.Data() == txt {
+			trace.Log(ctx, "callback", "back is pressed (option)")
+			return p.handleBackButton(ctx, c)
+		}
+	}
+
 	err := p.cbFn(WithController(ctx, p), c)
 	if err != nil {
+		if errors.Is(err, BackPressed) {
+			// user callback function might return "back button is pressed" as well
+			trace.Log(ctx, "callback", "back is pressed (user)")
+			return p.handleBackButton(ctx, c)
+		}
 		if e, ok := err.(*Error); !ok {
 			p.editMsg(ctx, c)
 			if err := c.Respond(&tb.CallbackResponse{Text: err.Error(), ShowAlert: true}); err != nil {
-				trace.Logf(ctx, "respond", err.Error())
+				trace.Log(ctx, "respond", err.Error())
 			}
 			p.unregister(c.Sender(), cb.Message.ID)
 			return e
@@ -255,6 +293,13 @@ func (p *Picklist) format(u *tb.User, text string) string {
 }
 
 func (p *Picklist) inlineMarkup(c tb.Context, values []string) *tb.ReplyMarkup {
+	if p.backBtn {
+		txt, err := p.backTxtFn(context.Background(), c.Sender())
+		if err != nil {
+			dlog.Debugf("backTextFn returned an error: %s", err)
+		}
+		values = append(values, txt)
+	}
 	if len(p.btnPattern) == 0 {
 		return ButtonMarkup(c, values, p.maxButtons, p.Callback)
 	}
@@ -292,8 +337,18 @@ func convertToMsg(cb *tb.Callback) *tb.Message {
 
 func (p *Picklist) nextHandler(c tb.Context) error {
 	if p.next != nil {
-		// this call is part of the pipeline
 		return p.next.Handler(c)
 	}
 	return nil
 }
+
+func (p *Picklist) handleBackButton(ctx context.Context, c tb.Context) error {
+	if err := c.Respond(&tb.CallbackResponse{}); err != nil {
+		trace.Log(ctx, "respond", err.Error())
+	}
+	c.Set(BackPressed.Error(), true)
+	if p.prev != nil {
+		return p.prev.Handler(c)
+	}
+	return nil
+}

tbcomctl.go

@@ -133,29 +133,6 @@ type ErrFunc func(ctx context.Context, m *tb.Message, err error)
 // ErrRetry if the retry should be performed.
 type BtnCallbackFunc func(ctx context.Context, c tb.Context) error
 
-type ErrType int
-
-const (
-	TErrNoChange ErrType = iota
-	TErrRetry
-	TInputError
-)
-
-type Error struct {
-	Alert bool
-	Msg   string
-	Type  ErrType
-}
-
-func (e *Error) Error() string { return e.Msg }
-
-var (
-	// ErrRetry should be returned by CallbackFunc if the retry should be performed.
-	ErrRetry = &Error{Type: TErrRetry, Msg: "retry", Alert: true}
-	// ErrNoChange should be returned if the user picked the same value as before, and no update needed.
-	ErrNoChange = &Error{Type: TErrNoChange, Msg: "no change"}
-)
-
 var hasher = sha1.New
 
 func hash(s string) string {
@@ -387,12 +364,8 @@ func (c *commonCtl) setOverwrite(b bool) {
 func (c *commonCtl) sendOrEdit(ct tb.Context, txt string, sendOpts ...interface{}) (*tb.Message, error) {
 	var outbound *tb.Message
 	var err error
-	if c.overwrite && c.prev != nil {
-		msgID, ok := c.prev.OutgoingID(ct.Sender().Recipient())
-		if !ok {
-			return nil, fmt.Errorf("%s can't find previous message ID for %s", caller(2), Userinfo(ct.Sender()))
-
-		}
+	msgID, ok := c.getPreviousMsgID(ct)
+	if c.overwrite && ok {
 		prevMsg := tb.Message{ID: msgID, Chat: ct.Chat()}
 		outbound, err = ct.Bot().Edit(&prevMsg,
 			txt,
@@ -403,3 +376,21 @@ func (c *commonCtl) sendOrEdit(ct tb.Context, txt string, sendOpts ...interface{
 	}
 	return outbound, err
 }
+
+func (c *commonCtl) getPreviousMsgID(ct tb.Context) (int, bool) {
+	backPressed, ok := ct.Get(BackPressed.Error()).(bool)
+	if ok && backPressed {
+		ct.Set(BackPressed.Error(), false) // reset the context value
+		if c.next == nil {
+			// internal error
+			return 0, false
+		}
+		return c.next.OutgoingID(ct.Sender().Recipient())
+	}
+	// back not pressed
+	if c.prev == nil {
+		return 0, false
+	}
+	return c.prev.OutgoingID(ct.Sender().Recipient())
+
+}