~edwargix/tallyard

21b778e16856fa1b24d3a55fb9fc98b1f64e9c67 — David Florness 4 years ago 315d416
Remove unused files
2 files changed, 0 insertions(+), 118 deletions(-)

D matrix/crypto_logger.go
D matrix/state_store.go
D matrix/crypto_logger.go => matrix/crypto_logger.go +0 -28
@@ 1,28 0,0 @@
package matrix

import (
	log "github.com/sirupsen/logrus"
)

// CryptoMachineLogger wraps around the usual logger, implementing the Logger interface needed by OlmMachine.
type CryptoMachineLogger struct{}

// Error formats and logs an error message.
func (CryptoMachineLogger) Error(message string, args ...interface{}) {
	log.Errorf(message, args...)
}

// Warn formats and logs a warning message.
func (CryptoMachineLogger) Warn(message string, args ...interface{}) {
	log.Warnf(message, args...)
}

// Debug formats and logs a debug message.
func (CryptoMachineLogger) Debug(message string, args ...interface{}) {
	log.Debugf(message, args...)
}

// Trace formats and logs a trace message.
func (CryptoMachineLogger) Trace(message string, args ...interface{}) {
	log.Tracef(message, args...)
}

D matrix/state_store.go => matrix/state_store.go +0 -90
@@ 1,90 0,0 @@
package matrix

import (
	"errors"

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

type TallyardStateStore struct {
	Storer *mautrix.InMemoryStore
}

// GetEncryptionEvent returns the encryption event for a room.
func (ss *TallyardStateStore) GetEncryptionEvent(roomID id.RoomID) *event.EncryptionEventContent {
	room := ss.Storer.LoadRoom(roomID)
	if room == nil {
		return nil
	}
	if evts, ok := room.State[event.StateEncryption]; ok {
		if evt, ok := evts[""]; ok {
			return evt.Content.AsEncryption()
		}
	}
	return nil
}

// IsEncrypted returns whether a room has been encrypted.
func (ss *TallyardStateStore) IsEncrypted(roomID id.RoomID) bool {
	room := ss.Storer.LoadRoom(roomID)
	if room == nil {
		return false
	}
	_, ok := room.State[event.StateEncryption]
	return ok
}

// FindSharedRooms returns a list of room IDs that the given user ID is also a member of.
func (ss *TallyardStateStore) FindSharedRooms(userID id.UserID) []id.RoomID {
	sharedRooms := make([]id.RoomID, 0)
	for roomID, room := range ss.Storer.Rooms {
		if room.GetMembershipState(userID) != event.MembershipLeave {
			sharedRooms = append(sharedRooms, roomID)
		}
	}
	return sharedRooms
}

// UpdateStateStore updates the internal state of NebStateStore from a /sync response.
func (ss *TallyardStateStore) UpdateStateStore(resp *mautrix.RespSync) {
	for roomID, evts := range resp.Rooms.Join {
		room := ss.Storer.LoadRoom(roomID)
		if room == nil {
			room = mautrix.NewRoom(roomID)
			ss.Storer.SaveRoom(room)
		}
		for _, i := range evts.State.Events {
			room.UpdateState(i)
		}
		for _, i := range evts.Timeline.Events {
			if i.Type.IsState() {
				room.UpdateState(i)
			}
		}
	}
}

// GetJoinedMembers returns a list of members that are currently in a room.
func (ss *TallyardStateStore) GetJoinedMembers(roomID id.RoomID) ([]id.UserID, error) {
	joinedMembers := make([]id.UserID, 0)
	room := ss.Storer.LoadRoom(roomID)
	if room == nil {
		return nil, errors.New("unknown roomID")
	}
	memberEvents := room.State[event.StateMember]
	if memberEvents == nil {
		return nil, errors.New("no state member events found")
	}
	for stateKey, stateEvent := range memberEvents {
		if stateEvent == nil {
			continue
		}
		stateEvent.Content.ParseRaw(event.StateMember)
		if stateEvent.Content.AsMember().Membership == event.MembershipJoin {
			joinedMembers = append(joinedMembers, id.UserID(stateKey))
		}
	}
	return joinedMembers, nil
}