todoist-repeater

main.go (5560B)

---

 // This program creates tasks in Todoist, based on time specificiations in the
 // cron format. It takes one argument (the path to the input file) and requires
 // that your Todoist developer token be set in the TODOIST_TOKEN environment
 // variable.
 //
 // The input file must be a text file where each line is either empty, a comment
 // (starting with #), or a cron specification followed by the name of the task.
 // Note that the cron specification must be provided as five whitespace
 // separated fields; this program doesn't currently support all the features of
 // robfig/cron (e.g. '@monthly').
 //
 // The input file is checked for changes each minute, and the program creates
 // Todoist tasks when their cron run time occurs.
 package main
 
 import (
 	"bufio"
 	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/cenkalti/backoff/v5"
 	"github.com/robfig/cron/v3"
 )
 
 type InputLine struct {
 	RawSchedule, RawTask string
 }
 
 type TaskAddingJob struct {
 	Schedule cron.Schedule
 	Task     cron.Job
 	EntryID  cron.EntryID
 	Delete   bool
 }
 
 type Task struct {
 	Name string
 }
 
 func (t Task) Run() {
 	_, err := backoff.Retry(
 		context.Background(),
 		func() (bool, error) { return true, createTask(t.Name) },
 	)
 	if err != nil {
 		log.Printf("Failed to create task '%s': %s", t.Name, err)
 	}
 }
 
 var jobsFromInput = map[InputLine]TaskAddingJob{}
 var todoistToken string
 var httpClient = http.Client{
 	Timeout: 10 * time.Second,
 }
 
 func main() {
 	if err := setToken(); err != nil {
 		log.Fatalf("setting token: %s", err)
 	}
 
 	p, err := inputFilePath()
 	if err != nil {
 		log.Fatalf("getting input file: %s", err)
 	}
 	log.Printf("Started watching '%s'", p)
 
 	c := cron.New()
 	c.Start()
 
 	for {
 		err = readInput(p)
 		if err != nil {
 			log.Printf("Error reading input: %s", err)
 			goto SLEEP
 		}
 
 		for inputLine, taskAddingJob := range jobsFromInput {
 			if jobsFromInput[inputLine].EntryID == 0 {
 				taskAddingJob.EntryID = c.Schedule(
 					jobsFromInput[inputLine].Schedule,
 					jobsFromInput[inputLine].Task,
 				)
 				jobsFromInput[inputLine] = taskAddingJob
 
 				log.Printf(
 					"Added '%s' with recurrence '%s'",
 					inputLine.RawTask,
 					inputLine.RawSchedule,
 				)
 			} else if taskAddingJob.Delete {
 				c.Remove(taskAddingJob.EntryID)
 				delete(jobsFromInput, inputLine)
 				log.Printf("Removed '%s'", inputLine.RawTask)
 			}
 		}
 
 	SLEEP:
 		time.Sleep(time.Minute)
 	}
 
 }
 
 func setToken() error {
 	token := os.Getenv("TODOIST_TOKEN")
 	if token == "" {
 		return fmt.Errorf("TODOIST_TOKEN env var must be present and non-empty")
 	}
 	todoistToken = token
 
 	return nil
 }
 
 func inputFilePath() (string, error) {
 	args := os.Args
 	if len(args) != 2 {
 		return "", fmt.Errorf("expected one argument (input file path), got %d", len(args)-1)
 	}
 	p := filepath.Clean(args[1])
 
 	// While we're here, check that the input path actually exists and
 	// is stat-able.
 	if _, err := os.Stat(p); err != nil {
 		return "", fmt.Errorf("cannot stat input file: %w", err)
 	}
 
 	return p, nil
 }
 
 var inputFileRe = regexp.MustCompile(`([^\s]+\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+[^\s]+)\s+(.*)`)
 
 func readInput(p string) error {
 	f, err := os.Open(p)
 	if err != nil {
 		return fmt.Errorf("opening '%s': %w", p, err)
 	}
 	defer f.Close()
 
 	previousInput := map[InputLine]struct{}{}
 	for k := range jobsFromInput {
 		previousInput[k] = struct{}{}
 	}
 	currentInput := map[InputLine]struct{}{}
 
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
 		line := strings.TrimSpace(scanner.Text())
 		if line == "" || strings.HasPrefix(line, "#") {
 			continue
 		}
 
 		matches := inputFileRe.FindStringSubmatch(line)
 		if matches == nil || len(matches) != 1+2 {
 			log.Printf("failed to parse input line: '%s'", line)
 			continue
 		}
 
 		inputLine := InputLine{
 			RawSchedule: matches[1],
 			RawTask:     matches[2],
 		}
 
 		currentInput[inputLine] = struct{}{}
 		if _, ok := previousInput[inputLine]; ok {
 			continue
 		}
 
 		schedule, err := cron.ParseStandard(inputLine.RawSchedule)
 		if err != nil {
 			log.Printf(
 				"Failed to add '%s' with recurrence '%s': %s",
 				inputLine.RawTask,
 				inputLine.RawSchedule,
 				err,
 			)
 			continue
 		}
 
 		jobsFromInput[inputLine] = TaskAddingJob{
 			Schedule: schedule,
 			Task:     Task{Name: inputLine.RawTask},
 		}
 	}
 	if err := scanner.Err(); err != nil {
 		return fmt.Errorf("scanning: %w", err)
 	}
 
 	// Mark for pruning any tasks that we previously saw, but are now missing.
 	for k := range previousInput {
 		if _, ok := currentInput[k]; !ok {
 			v := jobsFromInput[k]
 			v.Delete = true
 			jobsFromInput[k] = v
 		}
 	}
 
 	return nil
 }
 
 func createTask(task string) error {
 	jsonBody := []byte(fmt.Sprintf(`{"content": %s}`, strconv.Quote(task)))
 	req, err := http.NewRequest(
 		http.MethodPost,
 		"https://api.todoist.com/api/v1/tasks",
 		bytes.NewBuffer(jsonBody),
 	)
 	if err != nil {
 		return fmt.Errorf("creating request: %w", err)
 	}
 	req.Header.Add("Authorization", "Bearer "+todoistToken)
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("doing request: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		bodyBytes, err := io.ReadAll(resp.Body)
 		if err != nil {
 			return fmt.Errorf("reading body when preparing error message (HTTP status was %d): %w", resp.StatusCode, err)
 		}
 		return fmt.Errorf("expected 200, got status code %d: body was %s", resp.StatusCode, strconv.Quote(string(bodyBytes)))
 	}
 
 	log.Printf("Created task '%s'", task)
 	return nil
 }