initial commit

Author: jordi-reinsma

.env.example

@@ -0,0 +1,8 @@
+SLACK_TOKEN=xxxx-YOUR-SLACK-OAUTH-TOKEN
+
+# Comma separated list of channel ids
+SLACK_CHANNEL_IDS=ABC,XXX,YYY,ZZZ
+
+SLACK_BOT_ID=ABC123XYZ
+
+RUN_INTERVAL_DAYS=14

.gitignore

@@ -0,0 +1,3 @@
+*.db
+*.sqlite
+.env

README.md

@@ -0,0 +1,2 @@
+# bagel-bot
+Donut app for Slack clone

cmd/run/main.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/jordi-reinsma/bagel/core"
+	"github.com/jordi-reinsma/bagel/db"
+	"github.com/jordi-reinsma/bagel/slack"
+)
+
+func main() {
+	fmt.Println("Starting bagel...")
+	rand.Seed(time.Now().UnixNano())
+
+	// change to true to reset the database
+	DB := db.MustConnect(false)
+	defer DB.Close()
+
+	skip, err := core.ShouldSkipExecution(DB)
+	if err != nil {
+		panic(err)
+	}
+	if skip {
+		fmt.Println("Skipping execution")
+		return
+	}
+
+	// change to true to use mock data
+	slack := slack.New(false)
+
+	channelIDs := slack.GetChannelUUIDs()
+
+	for _, channelID := range channelIDs {
+		fmt.Println("Generating matches for channel", channelID)
+
+		userUUIDs, err := slack.GetUserUUIDs(channelID)
+		if err != nil {
+			panic(err)
+		}
+
+		users, err := DB.AddAndGetUsers(userUUIDs)
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Println("Users:", len(users))
+
+		matches, err := core.GenerateMatches(DB, users)
+		if err != nil {
+			panic(err)
+		}
+
+		for _, match := range matches {
+			err = slack.SendMessage(match, channelID)
+
+			if err != nil {
+				fmt.Println(match, err)
+				continue
+			}
+			err = DB.UpdateMatch(match)
+			if err != nil {
+				fmt.Println(match, err)
+				continue
+			}
+		}
+
+		err = slack.SendChannelMessage(channelID)
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Println("Matches:", len(matches))
+	}
+
+	err = DB.SaveExecution()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println("Done!")
+}

core/matcher.go

@@ -0,0 +1,100 @@
+package core
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"sort"
+
+	"github.com/jordi-reinsma/bagel/db"
+	"github.com/jordi-reinsma/bagel/model"
+)
+
+func GenerateMatches(DB db.DB, users []model.User) ([]model.Match, error) {
+	pairs, err := preparePairs(DB, users)
+	if err != nil {
+		return nil, err
+	}
+
+	return greedyMatcher(users, pairs)
+}
+
+func preparePairs(DB db.DB, users []model.User) ([]model.Match, error) {
+	var pairs []model.Match
+	for i := 0; i < len(users)-1; i++ {
+		for j := i + 1; j < len(users); j++ {
+			if users[i].ID == users[j].ID {
+				continue
+			}
+			pairs = append(pairs, model.Match{A: users[i], B: users[j]})
+		}
+	}
+	return DB.AddAndGetPairs(pairs)
+}
+
+// greedyMatcher implements the greedy algorithm for the minimum weight perfect matching problem
+func greedyMatcher(users []model.User, pairs []model.Match) ([]model.Match, error) {
+	// shuffle the pairs to remove bias towards lower ids
+	swapPair := func(i, j int) {
+		pairs[i], pairs[j] = pairs[j], pairs[i]
+	}
+	rand.Shuffle(len(pairs), swapPair)
+
+	// stable sort the pairs by the least matches they have
+	byFrequency := func(i, j int) bool {
+		return pairs[i].Freq < pairs[j].Freq
+	}
+	sort.SliceStable(pairs, byFrequency)
+
+	// number of matches is the ceil of the half of the number of users
+	numMatches := len(users)/2 + len(users)%2
+
+	matches := make([]model.Match, 0, numMatches)
+	matched := make(map[int]bool)
+	for _, user := range users {
+		matched[user.ID] = false
+	}
+
+	// iterate over the pairs and match unmatched users
+	for _, pair := range pairs {
+		// break the loop if we have enough matches
+		if len(matches) == numMatches-len(users)%2 {
+			break
+		}
+		ok1 := matched[pair.A.ID]
+		ok2 := matched[pair.B.ID]
+		if ok1 || ok2 {
+			continue
+		}
+		matches = append(matches, pair)
+		matched[pair.A.ID] = true
+		matched[pair.B.ID] = true
+	}
+
+	// in the case of an odd number of users, we need to add the last unmatched user
+	if len(matches) == numMatches-1 {
+		var unmatched int
+		for id, found := range matched {
+			if !found {
+				unmatched = id
+				break
+			}
+		}
+		if unmatched == 0 {
+			return nil, errors.New("no unmatched user found but one match is missing")
+		}
+		// match the unmatched user to the first available pair
+		for _, pair := range pairs {
+			if pair.A.ID == unmatched || pair.B.ID == unmatched {
+				matches = append(matches, pair)
+				break
+			}
+		}
+	}
+
+	if len(matches) != numMatches {
+		return nil, fmt.Errorf("could not generate %d matches", numMatches)
+	}
+
+	return matches, nil
+}

core/skipper.go

@@ -0,0 +1,26 @@
+package core
+
+import (
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/jordi-reinsma/bagel/db"
+)
+
+var runIntervalDays = os.Getenv("RUN_INTERVAL_DAYS")
+
+func ShouldSkipExecution(DB db.DB) (bool, error) {
+	date, err := DB.GetLastExecutionDate()
+	if err != nil {
+		return true, err
+	}
+	elapsedDays := int(time.Since(date).Hours() / 24)
+
+	interval, err := strconv.Atoi(runIntervalDays)
+	if err != nil {
+		return true, err
+	}
+
+	return elapsedDays < interval, nil
+}

db/db.go

@@ -0,0 +1,110 @@
+package db
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/jordi-reinsma/bagel/model"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+const (
+	connString   = "file:%s?_foreign_keys=on"
+	sqliteDBPath = "./db/sql/bagel.sqlite"
+	dbSchemaPath = "./db/sql/schema.sql"
+)
+
+type DB struct {
+	*sql.DB
+}
+
+func MustConnect(reset bool) DB {
+	if reset {
+		fmt.Println("Resetting database")
+		os.Remove(sqliteDBPath)
+	}
+
+	conn, err := sql.Open("sqlite3", fmt.Sprintf(connString, sqliteDBPath))
+	if err != nil {
+		panic(err)
+	}
+
+	db := DB{conn}
+
+	err = db.createTables()
+	if err != nil {
+		panic(err)
+	}
+
+	return db
+}
+
+func (db DB) createTables() error {
+	schema, err := os.ReadFile(dbSchemaPath)
+	if err != nil {
+		return err
+	}
+
+	_, err = db.Exec((string(schema)))
+	return err
+}
+
+func (db DB) AddAndGetUsers(users []model.User) ([]model.User, error) {
+	query := "INSERT INTO users (uuid) VALUES (?) ON CONFLICT (uuid) DO UPDATE SET uuid=EXCLUDED.uuid RETURNING id"
+	stmt, err := db.Prepare(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer stmt.Close()
+
+	for i := range users {
+		err = stmt.QueryRow(users[i].UUID).Scan(&users[i].ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return users, nil
+}
+
+func (db DB) AddAndGetPairs(pairs []model.Match) ([]model.Match, error) {
+	query := "INSERT INTO matches (a, b) VALUES (?, ?) ON CONFLICT (a, b) DO UPDATE SET a=EXCLUDED.a RETURNING id, freq"
+	stmt, err := db.Prepare(query)
+	if err != nil {
+		return nil, err
+	}
+
+	defer stmt.Close()
+
+	for i := range pairs {
+		err = stmt.QueryRow(pairs[i].A.ID, pairs[i].B.ID).Scan(&pairs[i].ID, &pairs[i].Freq)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return pairs, nil
+}
+
+func (db DB) UpdateMatch(match model.Match) error {
+	query := "UPDATE matches SET freq = freq + 1 WHERE id = ?"
+	_, err := db.Exec(query, match.ID)
+	return err
+}
+
+func (db DB) GetLastExecutionDate() (time.Time, error) {
+	var date time.Time
+	query := "SELECT date FROM executions ORDER BY id DESC LIMIT 1"
+	err := db.QueryRow(query).Scan(&date)
+	if err == sql.ErrNoRows {
+		return time.Time{}, nil
+	}
+	return date, err
+}
+
+func (db DB) SaveExecution() error {
+	query := "INSERT INTO executions DEFAULT VALUES"
+	_, err := db.Exec(query)
+	return err
+}

db/sql/schema.sql

@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS executions (
+  id INTEGER PRIMARY KEY,
+  date DATE NOT NULL DEFAULT CURRENT_DATE
+);
+
+CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY,
+    uuid VARCHAR (255) NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS matches (
+    id INTEGER PRIMARY KEY,
+    a INTEGER NOT NULL CHECK (a < b) REFERENCES users (id),
+    b INTEGER NOT NULL CHECK (a < b) REFERENCES users (id),
+    freq INTEGER NOT NULL DEFAULT 0
+);
+CREATE UNIQUE INDEX IF NOT EXISTS matches_a_b_uidx ON matches (a, b);

go.mod

@@ -0,0 +1,5 @@
+module github.com/jordi-reinsma/bagel
+
+go 1.17
+
+require github.com/mattn/go-sqlite3 v1.14.8

go.sum

@@ -0,0 +1,2 @@
+github.com/mattn/go-sqlite3 v1.14.8 h1:gDp86IdQsN/xWjIEmr9MF6o9mpksUgh0fu+9ByFxzIU=
+github.com/mattn/go-sqlite3 v1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=

model/model.go

@@ -0,0 +1,12 @@
+package model
+
+type User struct {
+	ID   int
+	UUID string
+}
+
+type Match struct {
+	ID   int
+	A, B User
+	Freq int
+}