fix the bot

Signed-off-by: Xe Iaso <me@xeiaso.net>

7 files changed, 102 insertions, 20 deletions

diff --git a/cmd/marabot/.gitignore b/cmd/marabot/.gitignore
new file mode 100644
index 0000000..81e8b4d
--- /dev/null
+++ b/cmd/marabot/.gitignore
@@ -0,0 +1,3 @@
+*.db
+*.db-shm
+*.db-wal
diff --git a/cmd/marabot/main.go b/cmd/marabot/main.go
index 12c0b1a..2d94bc5 100644
--- a/cmd/marabot/main.go
+++ b/cmd/marabot/main.go
@@ -2,12 +2,16 @@ package main
 
 import (
 	"context"
+	"database/sql"
+	_ "embed"
 	"flag"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
 
+	"github.com/bwmarrin/discordgo"
+	_ "modernc.org/sqlite"
 	"within.website/ln"
 	"within.website/ln/opname"
 	"within.website/x/internal"
@@ -15,9 +19,19 @@ import (
 )
 
 var (
+	dbFile                = flag.String("db-file", "marabot.db", "Path to the database file")
+	discordToken          = flag.String("discord-token", "", "Discord bot token")
 	revoltToken           = flag.String("revolt-token", "", "Revolt bot token")
 	revoltAPIServer       = flag.String("revolt-api-server", "https://api.revolt.chat", "API server for Revolt")
 	revoltWebsocketServer = flag.String("revolt-ws-server", "wss://ws.revolt.chat", "Websocket server for Revolt")
+
+	//go:embed schema.sql
+	dbSchema string
+)
+
+const (
+	furryholeDiscord = "192289762302754817"
+	furryholeRevolt  = "01H2VRKJFPYPEAE438B6JRFSCP"
 )
 
 func main() {
@@ -37,6 +51,58 @@ func main() {
 
 	client.Connect(ctx, mr)
 
+	dg, err := discordgo.New("Bot " + *discordToken)
+	if err != nil {
+		ln.FatalErr(ctx, err, ln.Action("creating discord client"))
+	}
+
+	if err := dg.Open(); err != nil {
+		ln.FatalErr(ctx, err, ln.Action("opening discord client"))
+	}
+	defer dg.Close()
+
+	db, err := sql.Open("sqlite", *dbFile)
+	if err != nil {
+		ln.FatalErr(ctx, err, ln.Action("opening sqlite database"))
+	}
+	defer db.Close()
+
+	if _, err := db.ExecContext(ctx, dbSchema); err != nil {
+		ln.FatalErr(ctx, err, ln.Action("running database schema"))
+	}
+
+	// roles, err := dg.GuildRoles(furryholeDiscord)
+	// if err != nil {
+	// 	ln.FatalErr(ctx, err, ln.Action("getting guild roles"))
+	// }
+
+	// for _, role := range roles {
+	// 	if role.Name == "@everyone" {
+	// 		continue
+	// 	}
+	// 	ln.Log(ctx, ln.Info("role"), ln.F{"name": role.Name, "id": role.ID, "color": fmt.Sprintf("#%06x", role.Color)})
+
+	// 	id, err := client.ServerCreateRole(ctx, furryholeRevolt, role.Name)
+	// 	if err != nil {
+	// 		ln.Error(ctx, err, ln.Action("creating role"))
+	// 		continue
+	// 	}
+
+	// 	if err := client.ServerEditRole(ctx, furryholeRevolt, id, &revolt.EditRole{
+	// 		Color: fmt.Sprintf("#%06x", role.Color),
+	// 		Hoist: role.Hoist,
+	// 		Rank:  250 - role.Position,
+	// 	}); err != nil {
+	// 		ln.Error(ctx, err, ln.Action("editing role"))
+	// 		continue
+	// 	}
+
+	// 	if _, err := db.ExecContext(ctx, "INSERT INTO roles (discord_server, discord_id, revolt_server, revolt_id, name, color, hoist) VALUES (?, ?, ?, ?, ?, ?, ?)", furryholeDiscord, role.ID, furryholeRevolt, id, role.Name, fmt.Sprintf("#%06x", role.Color), role.Hoist); err != nil {
+	// 		ln.Error(ctx, err, ln.Action("inserting role"))
+	// 		continue
+	// 	}
+	// }
+
 	// Wait for close.
 	sc := make(chan os.Signal, 1)
 
@@ -74,7 +140,7 @@ func (m *MaraRevolt) MessageCreate(ctx context.Context, msg *revolt.Message) err
 		}
 		sendMsg.SetContent("🏓 Pong!")
 
-		if _, err := msg.Reply(true, sendMsg); err != nil {
+		if _, err := m.cli.MessageReply(ctx, msg.ChannelId, msg.ID, true, sendMsg); err != nil {
 			return err
 		}
 	}
diff --git a/cmd/marabot/schema.sql b/cmd/marabot/schema.sql
new file mode 100644
index 0000000..7d4046f
--- /dev/null
+++ b/cmd/marabot/schema.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS roles (
+    id SERIAL PRIMARY KEY,
+    discord_server TEXT NOT NULL,
+    discord_id TEXT NOT NULL,
+    revolt_server TEXT NOT NULL,
+    revolt_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    color TEXT NOT NULL,
+    hoist BOOLEAN NOT NULL
+);
\ No newline at end of file
diff --git a/web/revolt/client.go b/web/revolt/client.go
index c68a090..60cc001 100644
--- a/web/revolt/client.go
+++ b/web/revolt/client.go
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"time"
 
 	"github.com/sacOO7/gowebsocket"
 )
@@ -18,6 +19,7 @@ func New(token string) *Client {
 		Token:   token,
 		BaseURL: "https://api.revolt.chat",
 		WSURL:   "wss://ws.revolt.chat",
+		Ticker:  time.NewTicker(3 * time.Second),
 	}
 }
 
@@ -30,6 +32,7 @@ func NewWithEndpoint(token, baseURL, wsURL string) *Client {
 		Token:   token,
 		BaseURL: baseURL,
 		WSURL:   wsURL,
+		Ticker:  time.NewTicker(3 * time.Second),
 	}
 }
 
@@ -42,6 +45,7 @@ type Client struct {
 	Cache   *Cache
 	BaseURL string
 	WSURL   string
+	Ticker  *time.Ticker
 }
 
 // Self bot struct.
diff --git a/web/revolt/http.go b/web/revolt/http.go
index 6be6853..b7293d2 100644
--- a/web/revolt/http.go
+++ b/web/revolt/http.go
@@ -3,15 +3,18 @@ package revolt
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"io"
 	"net/http"
+
+	"within.website/x/web"
 )
 
 // Send http request
 func (c Client) Request(ctx context.Context, method, path string, data []byte) ([]byte, error) {
 	reqBody := bytes.NewBuffer(data)
 
+	<-c.Ticker.C
+
 	// Prepare request
 	req, err := http.NewRequestWithContext(ctx, method, c.BaseURL+path, reqBody)
 	if err != nil {
@@ -42,7 +45,7 @@ func (c Client) Request(ctx context.Context, method, path string, data []byte) (
 	}
 
 	if !(resp.StatusCode >= 200 && resp.StatusCode < 300) {
-		return []byte{}, fmt.Errorf("%s: %s", resp.Status, body)
+		return []byte{}, web.NewError(200, resp)
 	}
 
 	return body, nil
diff --git a/web/revolt/server.go b/web/revolt/server.go
index 06652d2..6e5fe9b 100644
--- a/web/revolt/server.go
+++ b/web/revolt/server.go
@@ -295,8 +295,8 @@ func (c *Client) ServerSetRolePermissions(ctx context.Context, serverID, roleID
 }
 
 // Create a new role for server.
-// Returns string (role id), uint (server perms), uint (channel perms) and error.
-func (c *Client) ServerCreateRole(ctx context.Context, serverID, name string) (string, uint, uint, error) {
+// Returns string (role id) and error.
+func (c *Client) ServerCreateRole(ctx context.Context, serverID, name string) (string, error) {
 	role := &struct {
 		ID          string `json:"id"`
 		Permissions []uint `json:"permissions"`
@@ -306,20 +306,20 @@ func (c *Client) ServerCreateRole(ctx context.Context, serverID, name string) (s
 		"name": name,
 	})
 	if err != nil {
-		return role.ID, 0, 0, err
+		return role.ID, err
 	}
 
 	data, err = c.Request(ctx, "POST", "/servers/"+serverID+"/roles", data)
 	if err != nil {
-		return role.ID, 0, 0, err
+		return role.ID, err
 	}
 
 	err = json.Unmarshal(data, role)
 	if err != nil {
-		return role.ID, 0, 0, err
+		return role.ID, err
 	}
 
-	return role.ID, role.Permissions[0], role.Permissions[1], nil
+	return role.ID, nil
 }
 
 // Edit a server role.
diff --git a/web/revolt/websocket.go b/web/revolt/websocket.go
index 1994b0a..87a35b4 100644
--- a/web/revolt/websocket.go
+++ b/web/revolt/websocket.go
@@ -52,13 +52,14 @@ func (c *Client) doWebsocket(ctx context.Context, token, wsURL string, handler H
 		return err
 	}
 
-	heartbeat, faster, slower := cardio.Heartbeat(opname.With(ctx, "websocket-pingloop"), time.Minute, 30*time.Second)
+	t := time.NewTicker(30 * time.Second)
+	defer t.Stop()
 	go func(ctx context.Context) {
 		for {
 			select {
 			case <-ctx.Done():
 				return
-			case <-heartbeat:
+			case <-t.C:
 				data, err := json.Marshal(struct {
 					Type string `json:"type"`
 					Data int    `json:"data"`
@@ -68,16 +69,12 @@ func (c *Client) doWebsocket(ctx context.Context, token, wsURL string, handler H
 				})
 				if err != nil {
 					ln.Error(ctx, err, ln.Info("error marshaling ping"))
-					slower()
 					continue
 				}
 				if err := conn.Write(ctx, websocket.MessageText, data); err != nil {
 					ln.Error(ctx, err, ln.Info("error writing ping"))
-					slower()
 					continue
 				}
-			default:
-				faster()
 			}
 		}
 	}(ctx)
@@ -92,7 +89,7 @@ func (c *Client) doWebsocket(ctx context.Context, token, wsURL string, handler H
 			select {
 			case <-ctx.Done():
 				return
-			case <-heartbeat:
+			case <-t.C:
 				if time.Since(lastMsgSeen) > 5*time.Minute {
 					conn.Close(websocket.StatusNormalClosure, "ping timeout")
 					return
@@ -111,13 +108,13 @@ func (c *Client) doWebsocket(ctx context.Context, token, wsURL string, handler H
 		}
 		lastMsgSeen = time.Now()
 
-		if err := c.handleOneMessage(ctx, data, handler, slower); err != nil {
+		if err := c.handleOneMessage(ctx, data, handler); err != nil {
 			return err
 		}
 	}
 }
 
-func (c *Client) handleOneMessage(ctx context.Context, data []byte, handler Handler, slower func()) error {
+func (c *Client) handleOneMessage(ctx context.Context, data []byte, handler Handler) error {
 	var msg typeResolver
 	if err := json.Unmarshal(data, &msg); err != nil {
 		return err
@@ -125,7 +122,6 @@ func (c *Client) handleOneMessage(ctx context.Context, data []byte, handler Hand
 	ctx = opname.With(ctx, msg.Type)
 	switch msg.Type {
 	case "Pong":
-		slower()
 	case "Authenticated":
 		if err := handler.Authenticated(ctx); err != nil {
 			ln.Error(ctx, err, ln.Info("error in handler.Authenticated"))
@@ -149,7 +145,7 @@ func (c *Client) handleOneMessage(ctx context.Context, data []byte, handler Hand
 			return err
 		}
 		for _, msg := range bulk.Messages {
-			if err := c.handleOneMessage(ctx, msg, handler, slower); err != nil {
+			if err := c.handleOneMessage(ctx, msg, handler); err != nil {
 				return err
 			}
 		}