Order functions by their first use

[onechat] / telegram.go

diff --git a/telegram.go b/telegram.go
index 59ea9b4d928a1247e8e54cff2f1871c9b565c002..e3e33c913734b6901f02808f7a9d004fd2aa6f9f 100644 (file)
--- a/telegram.go
+++ b/telegram.go
@@ -74,10 +74,10 @@ type TelegramConfig struct {
 // itself, and as message entities only when Telegram refuses a rich message.
 // The rest is plain text. Tool calls do not go to the chat.
 //
 // itself, and as message entities only when Telegram refuses a rich message.
 // The rest is plain text. Tool calls do not go to the chat.
 //

-// The offset file holds the ID of the next update. It moves past an update
-// only after the message of the update is durable in the log, so a restart
-// does not lose a message. A crash between the flush and the offset write
-// makes Telegram send the update again, and the message repeats once.
+// The offset file holds the ID of the next update. It moves past an update only
+// after the message of the update is durable in the log, so a restart does not
+// lose a message. A crash between the flush and the offset write makes Telegram
+// send the update again, and the message repeats once.

 //
 // A failed Bot API call waits and tries again, from telegramRetryDelay up to
 // telegramRetryLimit, or as long as the Bot API asks. It never stops the agent.
 //
 // A failed Bot API call waits and tries again, from telegramRetryDelay up to
 // telegramRetryLimit, or as long as the Bot API asks. It never stops the agent.


@@ -192,35 +192,6 @@ func (c TelegramConfig) validate() error {
        return nil
 }
 
        return nil
 }
 

-// Notify queues event for the chat. It never blocks, so a slow network does not
-// stop the agent. The WhatsApp batches and the runs of the schedules do not go
-// to the chat: the reply of the agent tells the user what needs the user.
-func (b *TelegramBot) Notify(event Event) {
-       switch event.Kind {
-       case "busy", "idle", "reply", "error", "notice", "subagent":
-       case "work":
-               if event.Source == whatsappSource || event.Source == scheduleSource {
-                       return
-               }
-       case "user":
-               if event.Source == telegramSource {
-                       return
-               }
-       default:
-               return
-       }
-
-       b.mutex.Lock()
-
-       b.queue = append(b.queue, event)
-       b.mutex.Unlock()
-
-       select {
-       case b.ready <- struct{}{}:
-       default:
-       }
-}
-

 // Run polls for the messages of the owner and sends the queued events to the
 // chat until ctx ends. It returns an error only when a message or the offset or
 // image cannot be written, because then the bot would lose or repeat messages.
 // Run polls for the messages of the owner and sends the queued events to the
 // chat until ctx ends. It returns an error only when a message or the offset or
 // image cannot be written, because then the bot would lose or repeat messages.


@@ -595,6 +566,14 @@ func (b *TelegramBot) deliverRich(ctx context.Context, markdown string) {
        }
 }
 
        }
 }
 

+// notice queues a short answer of the bot for the chat.
+func (b *TelegramBot) notice(text string) {
+       b.Notify(Event{
+               Kind: "notice",
+               Text: text,
+       })
+}
+

 // sendOutage returns a new outage of the messages to the chat.
 func (b *TelegramBot) sendOutage() *TelegramOutage {
        return &TelegramOutage{
 // sendOutage returns a new outage of the messages to the chat.
 func (b *TelegramBot) sendOutage() *TelegramOutage {
        return &TelegramOutage{


@@ -604,22 +583,33 @@ func (b *TelegramBot) sendOutage() *TelegramOutage {
        }
 }
 
        }
 }
 

-// notice queues a short answer of the bot for the chat.
-func (b *TelegramBot) notice(text string) {
-       b.Notify(Event{
-               Kind: "notice",
-               Text: text,
-       })
-}
-
-// Fail logs the start of an outage with err and delay, unless an outage runs.
-func (o *TelegramOutage) Fail(err error, delay time.Duration) {
-       if !o.start.IsZero() {
+// Notify queues event for the chat. It never blocks, so a slow network does not
+// stop the agent. The WhatsApp batches and the runs of the schedules do not go
+// to the chat: the reply of the agent tells the user what needs the user.
+func (b *TelegramBot) Notify(event Event) {
+       switch event.Kind {
+       case "busy", "idle", "reply", "error", "notice", "subagent":
+       case "work":
+               if event.Source == whatsappSource || event.Source == scheduleSource {
+                       return
+               }
+       case "user":
+               if event.Source == telegramSource {
+                       return
+               }
+       default:

                return
        }
 
                return
        }
 

-       o.start = time.Now()
-       o.logger.Warn(o.loss, "err", err, "retry", delay)
+       b.mutex.Lock()
+
+       b.queue = append(b.queue, event)
+       b.mutex.Unlock()
+
+       select {
+       case b.ready <- struct{}{}:
+       default:
+       }

 }
 
 // End logs the end of the outage that runs, with its length.
 }
 
 // End logs the end of the outage that runs, with its length.


@@ -633,6 +623,16 @@ func (o *TelegramOutage) End() {
        o.start = time.Time{}
 }
 
        o.start = time.Time{}
 }
 

+// Fail logs the start of an outage with err and delay, unless an outage runs.
+func (o *TelegramOutage) Fail(err error, delay time.Duration) {
+       if !o.start.IsZero() {
+               return
+       }
+
+       o.start = time.Now()
+       o.logger.Warn(o.loss, "err", err, "retry", delay)
+}
+

 // telegramLoadOffset reads the update offset at path. A missing file gives 0,
 // which asks for every update that Telegram keeps.
 func telegramLoadOffset(path string) (int64, error) {
 // telegramLoadOffset reads the update offset at path. A missing file gives 0,
 // which asks for every update that Telegram keeps.
 func telegramLoadOffset(path string) (int64, error) {