Example #1
0
func (db *roomDb) SetRoomState(roomId types.RoomId, userId types.UserId, content types.TypedContent, stateKey string) (*matrixTypes.State, matrixTypes.Error) {
	db.roomsLock.RLock()
	defer db.roomsLock.RUnlock()
	room := db.rooms[roomId]
	if room == nil {
		return nil, matrixTypes.NotFoundError("room '" + roomId.String() + "' doesn't exist")
	}
	var eventId = types.DeriveEventId(utils.RandomString(16), types.Id(userId))
	stateId := stateId{content.GetEventType(), stateKey}

	state := new(matrixTypes.State)
	state.EventId = eventId
	state.RoomId = roomId
	state.UserId = userId
	state.EventType = content.GetEventType()
	state.StateKey = stateKey
	state.Timestamp = types.Timestamp{time.Now()}
	state.Content = content
	state.OldState = (*matrixTypes.OldState)(room.states[stateId])

	room.stateLock.Lock()
	defer room.stateLock.Unlock()
	room.states[stateId] = state

	return state, nil
}
Example #2
0
func (e authEndpoint) loginWithPassword(hostname string, body *authRequest) interface{} {
	if body.Username == "" {
		return types.BadJsonError("Missing or invalid user")
	}
	if body.Password == "" {
		return types.BadJsonError("Missing or invalid password")
	}
	user := ct.NewUserId(body.Username, hostname)
	exists, err := e.userService.UserExists(user, user)
	if err != nil {
		return err
	}
	if !exists {
		return types.NotFoundError("user '" + user.String() + "' doesn't exist")
	}
	verified, err := e.userService.VerifyPassword(user, body.Password)
	if err != nil {
		return err
	}
	if !verified {
		return types.ForbiddenError("invalid credentials")
	}
	accessToken, err := e.tokenService.NewAccessToken(user)
	if err != nil {
		return err
	}
	return authResponse{
		UserId:      user,
		AccessToken: accessToken.String(),
	}
}
Example #3
0
func (s roomService) LookupAlias(alias ct.Alias) (ct.RoomId, types.Error) {
	room, err := s.aliases.Room(alias)
	if err != nil {
		return ct.RoomId{}, err
	}
	if room == nil {
		return ct.RoomId{}, types.NotFoundError("room alias '" + alias.String() + "' doesn't exist")
	}
	return *room, nil
}
Example #4
0
func (s roomService) RoomExists(id ct.RoomId, caller ct.UserId) types.Error {
	exists, err := s.rooms.RoomExists(id)
	if err != nil {
		return err
	}
	if !exists {
		return types.NotFoundError("room '" + id.String() + "' doesn't exist")
	}
	return nil
}
Example #5
0
func (s *aliasStore) RemoveAlias(alias ct.Alias, room ct.RoomId) types.Error {
	deleted, err := s.idMap.Delete(ct.Id(alias), ct.Id(room))
	if err != nil {
		return types.InternalError(err)
	}
	if !deleted {
		return types.NotFoundError("room alias '" + alias.String() + "' doesn't exist")
	}
	return nil
}
Example #6
0
func (s eventService) Event(user ct.UserId, eventId ct.EventId) (ct.Event, types.Error) {
	event, err := s.eventProvider.Event(user, eventId)
	if err != nil {
		return nil, err
	}
	if event == nil {
		return nil, types.NotFoundError("event not found: " + event.GetEventKey().String())
	}
	return event, nil
}
Example #7
0
func (db *roomDb) RoomState(roomId types.RoomId, eventType, stateKey string) (*matrixTypes.State, matrixTypes.Error) {
	db.roomsLock.RLock()
	defer db.roomsLock.RUnlock()
	room := db.rooms[roomId]
	if room == nil {
		return nil, matrixTypes.NotFoundError("room '" + roomId.String() + "' doesn't exist")
	}
	room.stateLock.RLock()
	defer room.stateLock.RUnlock()
	state := room.states[stateId{eventType, stateKey}]
	return state, nil
}
Example #8
0
func (db *roomDb) EntireRoomState(roomId types.RoomId) ([]*matrixTypes.State, matrixTypes.Error) {
	db.roomsLock.RLock()
	defer db.roomsLock.RUnlock()
	room := db.rooms[roomId]
	if room == nil {
		return nil, matrixTypes.NotFoundError("room '" + roomId.String() + "' doesn't exist")
	}
	room.stateLock.RLock()
	defer room.stateLock.RUnlock()
	states := make([]*matrixTypes.State, 0, len(room.states))
	for _, state := range room.states {
		states = append(states, state)
	}
	return states, nil
}
Example #9
0
func (p urlParams) user(paramPosition int, users interfaces.UserService) (ct.UserId, types.Error) {
	user, err := ct.ParseUserId(p.params[paramPosition].Value)
	if err != nil {
		return ct.UserId{}, types.BadParamError(err.Error())
	}
	if users != nil {
		exists, err := users.UserExists(user, user)
		if err != nil {
			return ct.UserId{}, err
		}
		if !exists {
			return ct.UserId{}, types.NotFoundError("user '" + user.String() + "' doesn't exist")
		}
	}
	return user, nil
}