matrix-pretix/internal/matrix/client.go

package matrix

import (
	"context"
	"database/sql"
	"log"
	"sync"

	"git.luj0ga.de/franconian/matrix-pretix/internal/config"
	"git.luj0ga.de/franconian/matrix-pretix/internal/database"

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

type Client struct {
	client		*mautrix.Client
	config		*config.MatrixConfig
	db		*sql.DB
	deviceID	id.DeviceID
	olmMachine	*crypto.OlmMachine
	store		*sqlStore
	syncer		*mautrix.DefaultSyncer
	userID		id.UserID
}

func NewClient(config *config.MatrixConfig, db *sql.DB) (*Client, error) {
	client, err := mautrix.NewClient(config.HomeserverURL, "", "")
	if err != nil {
		return nil, err
	}

	syncer := mautrix.NewDefaultSyncer()
	client.Syncer = syncer

	store := &sqlStore{db}
	client.Store = store

	err = store.CreateTables()
	if err != nil {
		return nil, err
	}

	userID, err := makeUserID(config.UserIdentifier, config.HomeserverURL)
	if err != nil {
		return nil, err
	}

	deviceID := loadDeviceID(db, userID)

	return &Client{client, config, db, deviceID, nil, store, syncer, userID}, nil
}

func (c *Client) Login() error {
	c.syncer.OnEventType(event.StateMember, c.handleMemberEvent)

	_, err := c.client.Login(&mautrix.ReqLogin{
		Type:				mautrix.AuthTypePassword,
		Identifier:			mautrix.UserIdentifier{
			Type:	mautrix.IdentifierTypeUser,
			User:	c.config.UserIdentifier,
		},
		Password:			c.config.Password,
		DeviceID:			c.deviceID,
		InitialDeviceDisplayName:	c.config.DisplayName,
		StoreCredentials:		true,
	})
	if err != nil {
		return err
	}

	return nil
}

func (c *Client) Encrypt() error {
	sqlCryptoStore := crypto.NewSQLCryptoStore(
		c.db,
		database.DBDriverName,
		c.userID.String(),
		c.deviceID,
		[]byte(c.config.PickleKey),
		logger{},
	)

	err := sqlCryptoStore.CreateTables()
	if err != nil {
		return err
	}

	c.olmMachine = crypto.NewOlmMachine(c.client, &logger{}, sqlCryptoStore, c.store)

	err = c.olmMachine.Load()
	if err != nil {
		return err
	}

	c.syncer.OnSync(c.olmMachine.ProcessSyncResponse)

	c.syncer.OnEventType(event.StateEncryption, c.handleEncryptionEvent)

	return nil
}

func (c *Client) Sync(ctx context.Context, wg *sync.WaitGroup) {
	wg.Add(1)
	defer wg.Done()

	for {
		select {
		case <-ctx.Done():
			return
		default:
			err := c.client.SyncWithContext(ctx)
			if err != nil && err != ctx.Err() {
				log.Print(err)
			}
		}
	}
}

func (c *Client) handleMemberEvent(source mautrix.EventSource, evt *event.Event) {
	if c.olmMachine != nil {
		c.olmMachine.HandleMemberEvent(evt)
	}

	c.store.SetMembership(evt.RoomID, evt.GetStateKey(), evt.Content.AsMember().Membership)

	if evt.GetStateKey() == c.userID.String() && evt.Content.AsMember().Membership == event.MembershipInvite {
		allowed := false
		for _, room := range c.config.AllowedRooms {
			if room == evt.RoomID.String() {
				allowed = true
				break
			}
		}

		if allowed {
			_, err := c.client.JoinRoomByID(evt.RoomID)
			if err != nil {
				log.Print(err)
			}
		} else {
			_, err := c.client.LeaveRoom(evt.RoomID)
			if err != nil {
				log.Print(err)
			}
		}
	}
}

func (c *Client) handleEncryptionEvent(source mautrix.EventSource, evt *event.Event) {
	c.store.SetEncryptionEvent(evt.RoomID, evt.Content.AsEncryption())
}

func loadDeviceID(db *sql.DB, accountID id.UserID) (deviceID id.DeviceID) {
	row := db.QueryRow("SELECT device_id FROM crypto_account WHERE account_id = ?;", accountID)

	err := row.Scan(&deviceID)
	if err != nil {
		return ""
	}

	return deviceID
}