net.intelie.live.plugins.messenger.chat.ChatManager Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of plugin-messenger Show documentation
Intelie Live Messenger Plugin
The newest version!
package net.intelie.live.plugins.messenger.chat;

import com.google.common.base.Preconditions;
import net.intelie.live.SettingsNode;
import net.intelie.live.SettingsOptions;
import net.intelie.live.StringIds;
import net.intelie.live.plugins.messenger.data.MessengerRoomTypes;
import net.intelie.live.plugins.messenger.data.RoomData;
import net.intelie.live.plugins.messenger.data.RoomDataResolver;
import net.intelie.live.plugins.messenger.data.UserData;

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static net.intelie.live.plugins.messenger.chat.MessengerConstants.ROOM_NOT_FOUND;

public class ChatManager {
    private final Map rooms = new LinkedHashMap<>();
    private final SettingsNode node;
    private final RoomDataResolver resolver;

    public ChatManager(SettingsNode node, RoomDataResolver resolver) {
        this.node = node.cd("rooms");
        this.resolver = resolver;
        initRooms();
    }

    private void initRooms() {
        for (SettingsNode roomNode : node.children()) {
            RoomState data = roomNode.get(RoomState.class);
            String id = roomNode.name();
            rooms.put(id, data);
        }
    }

    public synchronized RoomData createRoom(String roomName, String roomType, UserData author) {
        String id = StringIds.newId();
        RoomState newState = new RoomState();
        newState.setName(roomName);
        newState.setType(roomType);
        newState.setCreatedAt(System.currentTimeMillis());
        if (author != null) {
            newState.setAuthorId(author.getId());
            newState.addUser(author.getId());
            newState.makeAdmin(author.getId(), true);
        }
        return writeRoomState(id, newState);
    }

    public synchronized RoomData renameRoom(String id, String newName) {
        RoomState newState = getRoom(id);
        newState.setName(newName);
        return writeRoomState(id, newState);
    }

    public synchronized RoomData setRoomType(String roomId, String roomType) {
        RoomState newState = getRoom(roomId);
        newState.setType(roomType);
        return writeRoomState(roomId, newState);
    }

    public synchronized RoomState getRoom(String roomId) {
        RoomState state = rooms.get(roomId);
        Preconditions.checkArgument(state != null && !MessengerRoomTypes.DELETED_ROOM.equals(state.getType()), ROOM_NOT_FOUND + ": %s", roomId);
        return state.deepClone();
    }

    public synchronized RoomData getRoomData(String roomId) {
        return resolver.resolve(roomId, getRoom(roomId));
    }

    public synchronized RoomData addUser(String roomId, Integer user) {
        RoomState state = getRoom(roomId);
        state.addUser(user);
        return this.writeRoomState(roomId, state);
    }

    public synchronized RoomData removeUser(String room, Integer user) {
        RoomState state = getRoom(room);
        state.removeUser(user);
        return this.writeRoomState(room, state);
    }

    public synchronized RoomData makeAdmin(String room, Integer user, boolean opt) {
        RoomState state = getRoom(room);
        state.makeAdmin(user, opt);
        return this.writeRoomState(room, state);
    }

    public synchronized RoomData writeRoomState(String id, RoomState state) {
        SettingsOptions options = new SettingsOptions();
        options = options.enableLog(false);
        node.withOptions(options, () -> {
            node.cd(id).set(state);
            return null;
        });
        rooms.put(id, state);
        return resolver.resolve(id, state);
    }

    public Collection roomsVisibleToUser(Integer userId, boolean isSuperUser) {
        Stream rooms = allRooms().stream().filter(r -> !MessengerRoomTypes.DELETED_ROOM.equals(r.getType()));
        if (!isSuperUser)
            rooms = rooms.filter(roomData -> MessengerRoomTypes.GLOBAL_ROOM.equals(roomData.getType()) || roomData.isUser(userId));
        return rooms.collect(Collectors.toList());
    }

    public synchronized Set allRooms() {
        Set roomIds = rooms.keySet();
        return roomIds.stream()
                .map(x -> resolver.resolve(x, rooms.get(x)))
                .collect(Collectors.toSet());
    }
}