Reddit Chat Dumper

main.go

package main

import (
	"context"
	"fmt"
	"log"

	"maunium.net/go/mautrix"
	"maunium.net/go/mautrix/event"
	"maunium.net/go/mautrix/id"
)

func fetchMessages(client *mautrix.Client, roomID id.RoomID, callback func(messages []*event.Event)) error {
	r, err := client.CreateFilter(mautrix.NewDefaultSyncer().FilterJSON)

	if err != nil {
		return err
	}

	resp, err := client.SyncRequest(0, "", r.FilterID, true, event.PresenceOnline, context.TODO())

	if err != nil {
		return err
	}

	var room *mautrix.SyncJoinedRoom

	for id, r := range resp.Rooms.Join {
		if id == roomID {
			room = r
			break
		}
	}

	var messages []*event.Event

	for _, m := range room.Timeline.Events {
		if m.Type == event.EventMessage {
			messages = append(messages, m)
		}
	}

	callback(messages)

	end := room.Timeline.PrevBatch

	for {
		if end == "" {
			break
		}

		var messages []*event.Event

		msgs, err := client.Messages(roomID, end, "", mautrix.DirectionBackward, &mautrix.FilterPart{}, 100)

		if err != nil {
			log.Fatalf(err.Error())
		}

		for _, m := range msgs.Chunk {
			if m.Type == event.EventMessage {
				messages = append(messages, m)
			}
		}
		
		callback(messages)

		end = msgs.End

		if len(messages) == 0 {
			continue
		}
	}

	return nil
}

type Message struct {
    Source      string    `bson:"source"`
    ChatID      string    `bson:"chat_id"`
    Author      string    `bson:"author"`
    Timestamp   time.Time `bson:"timestamp"`
    SourceID    string    `bson:"source_id"`
    Body        string    `bson:"body"`
    Attachments []string  `bson:"attachments"`
}

func parseMsg(message *event.Event, roomId id.RoomID) *model.Message {
	ts := time.Unix(message.Timestamp, 0)

	msg := &model.Message{
		Source:    "reddit",
		ChatID:    roomId.String(),
		Author:    message.Sender.String(),
		Timestamp: ts,
		SourceID:  message.ID.String(),
	}

	switch message.Content.Raw["msgtype"] {
	case "m.text":
		if message.Content.Raw["body"] == nil {
			fmt.Println("Empty message body:", message.Content.Raw)
			return nil
		} else {
			msg.Body = message.Content.Raw["body"].(string)
		}
	case "m.image":
		msg.Attachments = []string{
			message.Content.Raw["url"].(string),
		}
	case nil:
		if message.Content.Raw["m.relates_to"] != nil && message.Content.Raw["m.relates_to"].(map[string]interface{})["rel_type"] == "com.reddit.potentially_toxic" {
		} else {
			fmt.Println("No message type:", message.Content.Raw)
		}
		return nil
	default:
		fmt.Println("Unknown message type:", message.Content.Raw)
	}

	return msg
}

func main() {
    client, err := mautrix.NewClient("https://matrix.redditspace.com/", id.NewUserID("t2_<userID>", "reddit.com"), "<redditAccessToken>")

    var (
	    allMessages []*Message
	    roomID = id.RoomID("<roomID>")
    )
    
    err = fetchMessages(client, roomId, func(messages []*event.Event) {
        for _, msg := range messages {
            m := parseMsg(msg, roomId)
            if m == nil {
                continue
            }
            messages = append(messages, m)
        }
    }

    if err != nil {
        log.Fatalf(err.Error())
    }

    file, _ := json.MarshalIndent(allMessages, "", " ")
    err = os.WriteFile("events.json", file, 0644)

    if err != nil {
        log.Fatalf(err.Error())
    }
}