Writing a Telegram Bot to control a Raspberry Pi from afar (to observe Guinea Pigs)

# General settings
general:
  # REST Settings
  server: "0.0.0.0"
  port: "6060"
  # Rate filter for heavy motion; only applies to REST calls from motion detection; 0 == unlimited
  max_requests_per_hr: 0

telegram:
  # Bot Name
  bot_name: "@your_bot_name"
  # Bot API Key
  api_key: "ID:Key"
  # Chat ID; get from `https://api.telegram.org/bot<YourBOTToken>/getUpdates`
  chat_id: 000000

# Snapshots module
snapshots:
  enabled: true
  interval_s: 1200 # Every 20 mins
  snapshot_url: "http://camera.local/picture/1/current/?_username=whoami&_signature=KEY"
  # Hours active, in local TZ, as 24:00
  active_time:
    from_time: "08:30"
    to_time: "22:30"

func initConfig() {
  if cfgFile != "" {
    // Use config file from the flag.
    viper.SetConfigFile(cfgFile)
  } else {
    printUsage("--config is required")
  }

  viper.AutomaticEnv() // read in environment variables that match
}

package cmd

import (
  "github.com/spf13/cobra"
  "go.uber.org/zap"

  "github.com/spf13/viper"
)

var cfgFile string
var isDebug bool

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
  Use:   "telegram-camera-bridge",
  Short: "A bridge between a camera / MotionEye and Telegram",
  Long:  `A bridge between a camera / MotionEye and Telegram`,
  // Uncomment the following line if your bare application
  // has an action associated with it:
  // Run: func(cmd *cobra.Command, args []string) { },
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
  cobra.CheckErr(rootCmd.Execute())
}

func init() {
  cobra.OnInitialize(initConfig)
  cobra.OnInitialize(initLogging)
  // Here you will define your flags and configuration settings.
  // Cobra supports persistent flags, which, if defined here,
  // will be global for your application.

  rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "Path to config file yaml")
  rootCmd.PersistentFlags().BoolVar(&isDebug, "debug", false, "Enable debug logging")

  // Cobra also supports local flags, which will only run
  // when this action is called directly.
  rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}

// serveCmd represents the serve command
var serveCmd = &cobra.Command{
  Use:   "serve",
  Short: "Start the service",
  Long:  `Start the integration service between MotionEye OS and Telegram.`,
  Run: func(cmd *cobra.Command, args []string) {
    app := newApp()
    // Rest
    app.Serve()
  },
}

type App struct {
  Router  *mux.Router
  Cfg     *c.Config
  RestUri string
  // Modules
  Snapshots           c.CamModule
  SnapshotTimeoutChan chan int
}

func newApp() *App {
  app := &App{}

  // Read the config
  cfg := &c.Config{}
  err := viper.ReadInConfig()
  if err != nil {
    zap.S().Fatalf("Cannot read config")
  }
  err = viper.Unmarshal(cfg)
  if err != nil {
    zap.S().Fatalf("Cannot read config")
  }
    / ...

type CamModule interface {
  Capture() (image.Image, error)
  Send(image.Image) error
  SendTo(image.Image, int) error
  HandleCommands(chan int) error
}

type Snapshots struct {
  Cfg    *Config
  Client *http.Client
  TgBot  *tgbotapi.BotAPI
}

func (a *Snapshots) Capture() (image.Image, error) {
  method := "GET"
  req, err := http.NewRequest(method, a.Cfg.Snapshots.SnapshotUrl, nil)
  zap.S().Debugf("Sending request to %s", a.Cfg.Snapshots.SnapshotUrl)

  if err != nil {
    return nil, err
  }
  req.Header.Add("Cookie", "capture_fps_1=14.0; monitor_info_1=; motion_detected_1=false")

  res, err := a.Client.Do(req)
  if err != nil {
    return nil, err
  }
  defer res.Body.Close()

  img, _, err := image.Decode(res.Body)
  if err != nil {
    return nil, err
  }
  return img, nil
}

func (a *Snapshots) sendToChat(file *os.File, replyId int) {
  defer os.Remove(file.Name())

  zap.S().Debugf("Authorized on account %s", a.TgBot.Self.UserName)

  u := tgbotapi.NewUpdate(0)
  u.Timeout = 60
  zap.S().Infof("File; %s", file.Name())
  msg := tgbotapi.NewPhotoUpload(a.Cfg.Telegram.ChatId, file.Name())
  if replyId != 0 {
    msg.ReplyToMessageID = replyId
  }
  _, err := a.TgBot.Send(msg)
  if err != nil {
    zap.S().Error(err)
  }
}

func (a *Snapshots) HandleCommands(ch chan int) error {
  u := tgbotapi.NewUpdate(0)
  u.Timeout = 60

  updates, err := a.TgBot.GetUpdatesChan(u)

  if err != nil {
    return err
  }

  for update := range updates {
    if update.Message == nil { // ignore any non-Message Updates
      continue
    }
        if update.Message.Chat.ID != a.Cfg.Telegram.ChatId {
      zap.S().Warnf("Ignoring message from %s [%v] via %s", update.Message.From.UserName, update.Message.From.ID, update.Message.Chat.ID)
      continue
    }

    zap.S().Debugf("[%s] `%s`", update.Message.From.UserName, update.Message.Text)

    // Take a snapshot
    if update.Message.Text == "/snap" || update.Message.Text == fmt.Sprintf("%s %s", a.Cfg.Telegram.BotName, "/snap") {
      img, err := a.Capture()
      if err != nil {
        zap.S().Error(err)
        msg := tgbotapi.NewMessage(update.Message.Chat.ID, "Can't do that right now")
        msg.ReplyToMessageID = update.Message.MessageID
        a.TgBot.Send(msg)

        return err
      }
      // Send picture ootherwise
      a.SendTo(img, update.Message.MessageID)
// ...

func (a *App) periodicUpdater() {
  // Snapshots
  if a.Cfg.Snapshots.Enabled {
    interval := a.Cfg.Snapshots.IntervalS
    zap.S().Infof("Snapshot updater running every %vs", interval)
    ticker := time.NewTicker(time.Second * time.Duration(interval))

    for {
      select {
      case <-a.SnapshotTimeoutChan:
        zap.S().Infof("Updated Snapshot updater running every %vs", a.Cfg.Snapshots.IntervalS)
        ticker.Stop()
        ticker = time.NewTicker(time.Second * time.Duration(a.Cfg.Snapshots.IntervalS))
      case <-ticker.C:
        zap.S().Debugf("Tick, taking screenshot after %vs", a.Cfg.Snapshots.IntervalS)
        go a.handleSnapshots()
      }

    }
  }
}

func (app *App) buildRouter() {
  app.Router = mux.NewRouter()

    // ..
  app.Router.HandleFunc("/motion", app.PostHandlerMotion).Methods(http.MethodPost)
  http.Handle("/", app.Router)
}

func (a *App) Serve() {
  // Update snapshots and videos
  go a.periodicUpdater()
  // Handle commands
  go a.commandHandler()

  // Server
  uri := fmt.Sprintf("%s:%s", a.Cfg.General.Server, a.Cfg.General.Port)
  zap.S().Infof("Listening on %s", uri)
  a.RestUri = uri
  log.Fatal(http.ListenAndServe(uri, a.Router))
}

func (a *App) PostHandlerMotion(w http.ResponseWriter, r *http.Request) {
  if r.Body == nil {
    zap.S().Error("Null request")
    a.sendErr(w, "", http.StatusBadRequest)
    return
  }
  defer r.Body.Close()

  // IP range filter
  if err := a.filterRequest(w, r); err != nil {
    return
  }
  _, err := ioutil.ReadAll(r.Body)
  if err != nil {
    zap.S().Error(err)
    a.sendErr(w, "", http.StatusBadRequest)
    return
  }
  // Handle Snapshots
  if a.Cfg.Snapshots.Enabled {
    err = a.handleSnapshots()
    if err != nil {
      zap.S().Error(err)
      a.sendErr(w, "", http.StatusInternalServerError)
    }
  }
}

func (app *App) buildRouter() {
  app.Router = mux.NewRouter()
  if app.Cfg.General.RateFilter != 0 {
    // Throttling
    store, err := memstore.New(65536)
    if err != nil {
      log.Fatal(err)
    }

    quota := throttled.RateQuota{
      MaxRate:  throttled.PerHour(app.Cfg.General.RateFilter),
      MaxBurst: 0,
    }
    rateLimiter, err := throttled.NewGCRARateLimiter(store, quota)
    if err != nil {
      zap.S().Fatal(err)
    }

    httpRateLimiter := throttled.HTTPRateLimiter{
      Error:       app.denyHandler,
      RateLimiter: rateLimiter,
      VaryBy:      &throttled.VaryBy{Path: true},
    }
    // Handle
    app.Router.Use(httpRateLimiter.RateLimit)
    app.Router.HandleFunc("/motion", app.PostHandlerMotion).Methods(http.MethodPost)
    http.Handle("/", httpRateLimiter.RateLimit(app.Router))

  } else {
    app.Router.HandleFunc("/motion", app.PostHandlerMotion).Methods(http.MethodPost)
    http.Handle("/", app.Router)
  }
}

// MiddlewareFunc is a function which receives an http.Handler and returns another http.Handler.
// Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed
// to it, and then calls the handler passed as parameter to the MiddlewareFunc.
type MiddlewareFunc func(http.Handler) http.Handler

// middleware interface is anything which implements a MiddlewareFunc named Middleware.
type middleware interface {
  Middleware(handler http.Handler) http.Handler
}

func isWithinActiveHours(now, start, end string) bool {
  startTime, err := time.Parse("15:04", start)
  if err != nil {
    zap.S().Error(err)
    return false
  }
  endTime, err := time.Parse("15:04", end)
  if err != nil {
    zap.S().Error(err)
    return false
  }
  nowTime, err := time.Parse("15:04", now)
  if err != nil {
    zap.S().Error(err)
    return false
  }
  return inTimeSpan(nowTime, startTime, endTime)
}

func inTimeSpan(check, start, end time.Time) bool {
  if start.Before(end) {
    return !check.Before(start) && !check.After(end)
  }
  if start.Equal(end) {
    return check.Equal(start)
  }
  return !start.After(check) || !end.Before(check)
}

func getNowAsHrMinString() string {
  now := time.Now()
  return fmt.Sprintf("%02d:%02d", now.Hour(), now.Minute())
}

if update.Message.Chat.ID != a.Cfg.Telegram.ChatId {
      zap.S().Warnf("Ignoring message from %s [%v] via %s", update.Message.From.UserName, update.Message.From.ID, update.Message.Chat.ID)
      continue
    }

// GetUpdates fetches updates.
// If a WebHook is set, this will not return any data!
//
// Offset, Limit, and Timeout are optional.
// To avoid stale items, set Offset to one higher than the previous item.
// Set Timeout to a large number to reduce requests so you can get updates
// instantly instead of having to wait between requests.
func (bot *BotAPI) GetUpdates(config UpdateConfig) ([]Update, error) {
  v := url.Values{}
  if config.Offset != 0 {
    v.Add("offset", strconv.Itoa(config.Offset))
  }
  if config.Limit > 0 {
    v.Add("limit", strconv.Itoa(config.Limit))
  }
  if config.Timeout > 0 {
    v.Add("timeout", strconv.Itoa(config.Timeout))
  }

  resp, err := bot.MakeRequest("getUpdates", v)
  if err != nil {
    return []Update{}, err
  }

  var updates []Update
  json.Unmarshal(resp.Result, &updates)

  bot.debugLog("getUpdates", v, updates)

  return updates, nil
}