package interact import ( "context" "fmt" "time" log "github.com/sirupsen/logrus" ) type CustomInteraction interface { Commands(interact *Interact) } type Initializer interface { Initialize() error } type Messenger interface { TextMessageResponder CommandResponder Start(ctx context.Context) } type Session interface { ID() string SetOriginState(state State) GetOriginState() State SetState(state State) GetState() State IsAuthorized() bool SetAuthorized() SetAuthorizing(b bool) } // Interact implements the interaction between bot and message software. type Interact struct { startTime time.Time // commands is the default public command map commands map[string]*Command // privateCommands is the private command map, need auth privateCommands map[string]*Command states map[State]State statesFunc map[State]interface{} authenticatedSessions map[string]Session customInteractions []CustomInteraction messengers []Messenger } func New() *Interact { return &Interact{ startTime: time.Now(), commands: make(map[string]*Command), privateCommands: make(map[string]*Command), states: make(map[State]State), statesFunc: make(map[State]interface{}), } } func (it *Interact) AddCustomInteraction(custom CustomInteraction) { custom.Commands(it) it.customInteractions = append(it.customInteractions, custom) } func (it *Interact) PrivateCommand(command, desc string, f interface{}) *Command { cmd := NewCommand(command, desc, f) it.privateCommands[command] = cmd return cmd } func (it *Interact) Command(command string, desc string, f interface{}) *Command { cmd := NewCommand(command, desc, f) it.commands[command] = cmd return cmd } func (it *Interact) getNextState(session Session, currentState State) (nextState State, final bool) { var ok bool final = false nextState, ok = it.states[currentState] if ok { // check if it's the final state if _, hasTransition := it.statesFunc[nextState]; !hasTransition { final = true } return nextState, final } // state not found, return to the origin state return session.GetOriginState(), final } func (it *Interact) handleCallback(session Session, payload string) error { return nil } func (it *Interact) handleResponse(session Session, text string, ctxObjects ...interface{}) error { // We only need response when executing a command switch session.GetState() { case StatePublic, StateAuthenticated: return nil } args := parseCommand(text) state := session.GetState() f, ok := it.statesFunc[state] if !ok { return fmt.Errorf("state function of %s is not defined", state) } ctxObjects = append(ctxObjects, session) _, err := parseFuncArgsAndCall(f, args, ctxObjects...) if err != nil { return err } nextState, end := it.getNextState(session, state) if end { session.SetState(session.GetOriginState()) return nil } session.SetState(nextState) return nil } func (it *Interact) getCommand(session Session, command string) (*Command, error) { if session.IsAuthorized() { if cmd, ok := it.privateCommands[command]; ok { return cmd, nil } } else { if _, ok := it.privateCommands[command]; ok { return nil, fmt.Errorf("private command can not be executed in the public mode, type /auth to get authorized") } } // find any public command if cmd, ok := it.commands[command]; ok { return cmd, nil } return nil, fmt.Errorf("command %s not found", command) } func (it *Interact) runCommand(session Session, command string, args []string, ctxObjects ...interface{}) error { cmd, err := it.getCommand(session, command) if err != nil { return err } ctxObjects = append(ctxObjects, session) session.SetState(cmd.initState) if _, err := parseFuncArgsAndCall(cmd.F, args, ctxObjects...); err != nil { return err } // if we can successfully execute the command, then we can go to the next state. state := session.GetState() nextState, end := it.getNextState(session, state) if end { session.SetState(session.GetOriginState()) return nil } session.SetState(nextState) return nil } func (it *Interact) AddMessenger(messenger Messenger) { // pass Responder function messenger.SetTextMessageResponder(func(session Session, message string, reply Reply, ctxObjects ...interface{}) error { return it.handleResponse(session, message, append(ctxObjects, reply)...) }) it.messengers = append(it.messengers, messenger) } // builtin initializes the built-in commands func (it *Interact) builtin() error { it.Command("/uptime", "show bot uptime", func(reply Reply) error { uptime := time.Since(it.startTime) reply.Message(fmt.Sprintf("uptime %s", uptime)) return nil }) return nil } func (it *Interact) init() error { if err := it.builtin(); err != nil { return err } if err := it.registerCommands(it.commands); err != nil { return err } if err := it.registerCommands(it.privateCommands); err != nil { return err } return nil } func (it *Interact) registerCommands(commands map[string]*Command) error { for n, cmd := range commands { for s1, s2 := range cmd.states { if _, exist := it.states[s1]; exist { return fmt.Errorf("state %s already exists", s1) } it.states[s1] = s2 } for s, f := range cmd.statesFunc { it.statesFunc[s] = f } // register commands to the service if len(it.messengers) == 0 { return fmt.Errorf("messenger is not set") } // commandName is used in the closure, we need to copy the variable commandName := n for _, messenger := range it.messengers { messenger.AddCommand(cmd, func(session Session, message string, reply Reply, ctxObjects ...interface{}) error { args := parseCommand(message) return it.runCommand(session, commandName, args, append(ctxObjects, reply)...) }) } } return nil } func (it *Interact) Start(ctx context.Context) error { if len(it.messengers) == 0 { log.Warn("messenger is not set, skip initializing") return nil } if err := it.init(); err != nil { return err } for _, custom := range it.customInteractions { log.Infof("checking %T custom interaction...", custom) if initializer, ok := custom.(Initializer); ok { log.Infof("initializing %T custom interaction...", custom) if err := initializer.Initialize(); err != nil { return err } } } // TODO: use go routine and context for _, m := range it.messengers { go m.Start(ctx) } return nil }