/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License") + you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openmeetings.remote;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import org.apache.openmeetings.OpenmeetingsVariables;
import org.apache.openmeetings.cluster.beans.ServerDTO;
import org.apache.openmeetings.data.basic.AuthLevelUtil;
import org.apache.openmeetings.data.basic.SessiondataDao;
import org.apache.openmeetings.data.basic.dao.ServerDao;
import org.apache.openmeetings.data.beans.basic.SearchResult;
import org.apache.openmeetings.data.calendar.management.AppointmentLogic;
import org.apache.openmeetings.data.conference.RoomManager;
import org.apache.openmeetings.data.conference.dao.RoomDao;
import org.apache.openmeetings.data.conference.dao.RoomModeratorsDao;
import org.apache.openmeetings.data.user.UserManager;
import org.apache.openmeetings.persistence.beans.basic.Server;
import org.apache.openmeetings.persistence.beans.calendar.Appointment;
import org.apache.openmeetings.persistence.beans.room.Client;
import org.apache.openmeetings.persistence.beans.room.Room;
import org.apache.openmeetings.persistence.beans.room.RoomModerator;
import org.apache.openmeetings.persistence.beans.room.RoomOrganisation;
import org.apache.openmeetings.persistence.beans.room.RoomType;
import org.apache.openmeetings.persistence.beans.user.User;
import org.apache.openmeetings.session.ISessionManager;
import org.apache.openmeetings.utils.math.CalendarPatterns;
import org.apache.openmeetings.utils.math.TimezoneUtil;
import org.red5.logging.Red5LoggerFactory;
import org.red5.server.api.IConnection;
import org.red5.server.api.Red5;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
/**
*
* @author sebawagner
*
*/
public class ConferenceService {
private static final Logger log = Red5LoggerFactory.getLogger(
ConferenceService.class, OpenmeetingsVariables.webAppRootKey);
@Autowired
private AppointmentLogic appointmentLogic;
@Autowired
private SessiondataDao sessiondataDao;
@Autowired
private UserManager userManager;
@Autowired
private RoomManager roomManager;
@Autowired
private RoomDao roomDao;
@Autowired
private RoomModeratorsDao roomModeratorsDao;
@Autowired
private AuthLevelUtil authLevelUtil;
@Autowired
private TimezoneUtil timezoneUtil;
@Autowired
private ISessionManager sessionManager = null;
@Autowired
private ServerDao serverDao;
/**
* ( get a List of all available Rooms of this organization
* (non-appointments)
*
* @param SID
* @param organisation_id
* @return - all available Rooms of this organization
*/
public List<RoomOrganisation> getRoomsByOrganisationAndType(String SID,
long organisation_id, long roomtypes_id) {
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
log.debug("getRoomsByOrganisationAndType");
if (user_level == null) {
return null;
}
List<RoomOrganisation> roomOrgsList = roomManager
.getRoomsOrganisationByOrganisationIdAndRoomType(
user_level, organisation_id, roomtypes_id);
List<RoomOrganisation> filtered = new ArrayList<RoomOrganisation>();
for (Iterator<RoomOrganisation> iter = roomOrgsList.iterator(); iter
.hasNext();) {
RoomOrganisation orgRoom = iter.next();
if (!orgRoom.getRoom().getAppointment()) {
orgRoom.getRoom().setCurrentusers(
this.getRoomClientsListByRoomId(orgRoom.getRoom()
.getRooms_id()));
filtered.add(orgRoom);
}
}
return filtered;
} catch (Exception err) {
log.error("[getRoomsByOrganisationAndType]", err);
}
return null;
}
public List<RoomOrganisation> getRoomsByOrganisationWithoutType(
String SID, long organisation_id) {
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
log.debug("getRoomsByOrganisationAndType");
if (user_level == null) {
return null;
}
List<RoomOrganisation> roomOrgsList = roomManager
.getRoomsOrganisationByOrganisationId(user_level,
organisation_id);
for (RoomOrganisation roomOrg : roomOrgsList) {
roomOrg.getRoom().setCurrentusers(sessionManager.getClientListByRoom(roomOrg.getRoom().getRooms_id()));
}
return roomOrgsList;
} catch (Exception err) {
log.error("[getRoomsByOrganisationAndType]", err);
}
return null;
}
/**
* gets all rooms of an organization TODO:check if the requesting user is
* also member of that organization
*
* @param SID
* @param organisation_id
* @return - all rooms of an organization
*/
public SearchResult<RoomOrganisation> getRoomsByOrganisation(String SID,
long organisation_id, int start, int max, String orderby,
boolean asc) {
log.debug("getRoomsByOrganisation");
Long user_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByIdAndOrg(user_id,
organisation_id);
return roomManager.getRoomsOrganisationByOrganisationId(user_level,
organisation_id, start, max, orderby, asc);
}
/**
* get a List of all public availible rooms (non-appointments)
*
* @param SID
* @param roomtypes_id
* @return - public rooms with given type, null in case of the error
*/
public List<Room> getRoomsPublic(String SID, Long roomtypes_id) {
try {
log.debug("getRoomsPublic");
Long users_id = sessiondataDao.checkSession(SID);
Long User_level = userManager.getUserLevelByID(users_id);
log.error("getRoomsPublic user_level: " + User_level);
List<Room> roomList = roomManager.getPublicRooms(User_level,
roomtypes_id);
// Filter : no appointed meetings
List<Room> filtered = new ArrayList<Room>();
for (Iterator<Room> iter = roomList.iterator(); iter.hasNext();) {
Room rooms = iter.next();
if (!rooms.getAppointment()) {
rooms.setCurrentusers(this.getRoomClientsListByRoomId(rooms
.getRooms_id()));
filtered.add(rooms);
}
}
return filtered;
} catch (Exception err) {
log.error("[getRoomsByOrganisationAndType]", err);
}
return null;
}
public List<Room> getRoomsPublicWithoutType(String SID) {
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
log.debug("getRoomsPublic user_level: " + user_level);
List<Room> roomList = roomDao.getPublicRooms();
for (Room room : roomList) {
room.setCurrentusers(sessionManager.getClientListByRoom(room.getRooms_id()));
}
return roomList;
} catch (Exception err) {
log.error("[getRoomsPublicWithoutType]", err);
}
return null;
}
/**
* retrieving ServerTime
*
* @return - server time
*/
// --------------------------------------------------------------------------------------------
public Date getServerTime() {
log.debug("getServerTime");
return new Date(System.currentTimeMillis());
}
// --------------------------------------------------------------------------------------------
/**
*
* retrieving Appointment for Room
*
* @param room_id
* @return - Appointment in case the room is appointment, null otherwise
*/
public Appointment getAppointMentDataForRoom(Long room_id) {
log.debug("getAppointMentDataForRoom");
Room room = roomDao.get(room_id);
if (room.getAppointment() == false)
return null;
try {
Appointment ment = appointmentLogic.getAppointmentByRoom(room_id);
return ment;
} catch (Exception e) {
log.error("getAppointMentDataForRoom ", e);
return null;
}
}
// --------------------------------------------------------------------------------------------
public Map<String, Object> getAppointMentAndTimeZones(Long room_id) {
try {
log.debug("getAppointMentDataForRoom");
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
log.debug("getCurrentRoomClient -2- " + streamid);
Client currentClient = this.sessionManager
.getClientByStreamId(streamid, null);
Room room = roomDao.get(room_id);
if (room.getAppointment() == false) {
throw new IllegalStateException("Room has no appointment");
}
Appointment appointment = appointmentLogic
.getAppointmentByRoom(room_id);
Map<String, Object> returnMap = new HashMap<String, Object>();
returnMap.put("appointment", appointment);
User us = userManager.getUserById(currentClient.getUser_id());
TimeZone timezone = timezoneUtil.getTimezoneByUser(us);
returnMap.put("appointment", appointment);
returnMap.put(
"start",
CalendarPatterns.getDateWithTimeByMiliSeconds(
appointment.getAppointmentStarttime(), timezone));
returnMap.put(
"end",
CalendarPatterns.getDateWithTimeByMiliSeconds(
appointment.getAppointmentEndtime(), timezone));
returnMap.put("timeZone", timezone.getDisplayName());
return returnMap;
} catch (Exception e) {
log.error("getAppointMentAndTimeZones " , e );
return null;
}
}
/**
*
*/
// --------------------------------------------------------------------------------------------
public List<Room> getAppointedMeetings(String SID, Long room_types_id) {
log.debug("ConferenceService.getAppointedMeetings");
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
List<Appointment> points = appointmentLogic
.getTodaysAppointmentsForUser(users_id);
List<Room> result = new ArrayList<Room>();
if (points != null) {
for (int i = 0; i < points.size(); i++) {
Appointment ment = points.get(i);
Long rooms_id = ment.getRoom().getRooms_id();
Room rooom = roomDao.get(rooms_id);
if (!rooom.getRoomtype().getRoomtypes_id()
.equals(room_types_id))
continue;
rooom.setCurrentusers(getRoomClientsListByRoomId(rooom
.getRooms_id()));
result.add(rooom);
}
}
log.debug("Found " + result.size() + " rooms");
return result;
} else {
return null;
}
}
// --------------------------------------------------------------------------------------------
public List<Room> getAppointedMeetingRoomsWithoutType(String SID) {
log.debug("ConferenceService.getAppointedMeetings");
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
List<Appointment> appointments = appointmentLogic
.getTodaysAppointmentsForUser(users_id);
List<Room> result = new ArrayList<Room>();
if (appointments != null) {
for (int i = 0; i < appointments.size(); i++) {
Appointment ment = appointments.get(i);
Long rooms_id = ment.getRoom().getRooms_id();
Room rooom = roomDao.get(rooms_id);
rooom.setCurrentusers(this
.getRoomClientsListByRoomId(rooom.getRooms_id()));
result.add(rooom);
}
}
log.debug("Found " + result.size() + " rooms");
return result;
}
} catch (Exception err) {
log.error("[getAppointedMeetingRoomsWithoutType]", err);
}
return null;
}
/**
*
* @param SID
* @return - all room types available
*/
public List<RoomType> getRoomTypes(String SID) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
return roomManager.getAllRoomTypes();
}
return null;
}
/**
*
* @param SID
* @param rooms_id
* @return - room with the id given
*/
public Room getRoomById(String SID, long rooms_id) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRoomById(user_level, rooms_id);
}
public Room getRoomWithCurrentUsersById(String SID, long rooms_id) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
Room room = roomManager.getRoomById(user_level, rooms_id);
room.setCurrentusers(sessionManager.getClientListByRoom(room.getRooms_id()));
return room;
}
/**
*
* @param SID
* @param externalUserId
* @param externalUserType
* @param roomtypes_id
* @return - room with the given external id
*/
public Room getRoomByExternalId(String SID, Long externalUserId,
String externalUserType, long roomtypes_id) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRoomByExternalId(user_level, externalUserId,
externalUserType, roomtypes_id);
}
/**
* gets a list of all available rooms
*
* @param SID
* @param start
* @param max
* @param orderby
* @param asc
* @return - list of rooms being searched
*/
public SearchResult<Room> getRooms(String SID, int start, int max,
String orderby, boolean asc, String search) {
log.debug("getRooms");
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRooms(user_level, start, max, orderby, asc,
search);
}
public SearchResult<Room> getRoomsWithCurrentUsers(String SID, int start,
int max, String orderby, boolean asc) {
log.debug("getRooms");
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRoomsWithCurrentUsers(user_level, start, max,
orderby, asc);
}
/**
* get all Organisations of a room
*
* @param SID
* @param rooms_id
* @return - all Organisations of a room
*/
public List<RoomOrganisation> getOrganisationByRoom(String SID,
long rooms_id) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getOrganisationsByRoom(user_level, rooms_id);
}
/**
*
* @param SID
* @param argObject
* @return - id of the room being saved, null in case of the error
*/
public Long saveOrUpdateRoom(String SID, Object argObject) {
try {
Long users_id = sessiondataDao.checkSession(SID);
long User_level = userManager.getUserLevelByID(users_id);
log.debug("argObject: 1 - " + argObject.getClass().getName());
@SuppressWarnings("unchecked")
LinkedHashMap<String, Object> argObjectMap = (LinkedHashMap<String, Object>) argObject;
log.debug("argObject: 2 - "
+ argObjectMap.get("organisations").getClass().getName());
@SuppressWarnings("unchecked")
List<Integer> organisations = (List<Integer>) argObjectMap
.get("organisations");
Long rooms_id = Long.valueOf(
argObjectMap.get("rooms_id").toString()).longValue();
log.debug("rooms_id " + rooms_id);
@SuppressWarnings("unchecked")
List<Map<String, Object>> roomModerators = (List<Map<String, Object>>) argObjectMap
.get("roomModerators");
Integer demoTime = null;
if (argObjectMap.get("demoTime").toString() != null
&& argObjectMap.get("demoTime").toString().length() > 0) {
demoTime = Integer.valueOf(
argObjectMap.get("demoTime").toString()).intValue();
}
long roomId = -1;
if (rooms_id == 0) {
roomId = roomManager.addRoom(
User_level
, argObjectMap.get("name").toString()
, Long.valueOf(argObjectMap.get("roomtypes_id").toString()).longValue()
, argObjectMap.get("comment").toString()
, Long.valueOf(argObjectMap.get("numberOfPartizipants").toString()).longValue()
, Boolean.valueOf(argObjectMap.get("ispublic").toString())
, organisations
, Boolean.valueOf(argObjectMap.get("appointment").toString())
, Boolean.valueOf(argObjectMap.get("isDemoRoom").toString())
, demoTime
, Boolean.valueOf(argObjectMap.get("isModeratedRoom").toString())
, roomModerators
, Boolean.valueOf(argObjectMap.get("allowUserQuestions").toString())
, Boolean.valueOf(argObjectMap.get("isAudioOnly").toString())
, Boolean.valueOf(argObjectMap.get("allowFontStyles").toString())
, Boolean.valueOf(argObjectMap.get("isClosed").toString())
, argObjectMap.get("redirectURL").toString()
, argObjectMap.get("conferencePin").toString()
, Long.valueOf(argObjectMap.get("ownerId").toString()).longValue()
, Boolean.valueOf(argObjectMap.get("waitForRecording").toString())
, Boolean.valueOf(argObjectMap.get("allowRecording").toString())
, Boolean.valueOf(argObjectMap.get("hideTopBar").toString())
, Boolean.valueOf(argObjectMap.get("hideChat").toString())
, Boolean.valueOf(argObjectMap.get("hideActivitiesAndActions").toString())
, Boolean.valueOf(argObjectMap.get("hideFilesExplorer").toString())
, Boolean.valueOf(argObjectMap.get("hideActionsMenu").toString())
, Boolean.valueOf(argObjectMap.get("hideScreenSharing").toString())
, Boolean.valueOf(argObjectMap.get("hideWhiteboard").toString())
, Boolean.valueOf(argObjectMap.get("showMicrophoneStatus").toString())
, Boolean.valueOf(argObjectMap.get("chatModerated").toString())
, Boolean.valueOf(argObjectMap.get("chatOpened").toString())
, Boolean.valueOf(argObjectMap.get("filesOpened").toString())
, Boolean.valueOf(argObjectMap.get("autoVideoSelect").toString())
, Boolean.valueOf(argObjectMap.get("sipEnabled").toString())
);
} else if (rooms_id > 0) {
roomId = roomManager.updateRoom(
User_level
, rooms_id
, Long.valueOf(argObjectMap.get("roomtypes_id").toString()).longValue()
, argObjectMap.get("name").toString()
, Boolean.valueOf(argObjectMap.get("ispublic").toString())
, argObjectMap.get("comment").toString()
, Long.valueOf(argObjectMap.get("numberOfPartizipants").toString()).longValue()
, organisations
, Boolean.valueOf(argObjectMap.get("appointment").toString())
, Boolean.valueOf(argObjectMap.get("isDemoRoom").toString())
, demoTime
, Boolean.valueOf(argObjectMap.get("isModeratedRoom").toString())
, roomModerators
, Boolean.valueOf(argObjectMap.get("allowUserQuestions").toString())
, Boolean.valueOf(argObjectMap.get("isAudioOnly").toString())
, Boolean.valueOf(argObjectMap.get("allowFontStyles").toString())
, Boolean.valueOf(argObjectMap.get("isClosed").toString())
, argObjectMap.get("redirectURL").toString()
, argObjectMap.get("conferencePin").toString()
, Long.valueOf(argObjectMap.get("ownerId").toString()).longValue()
, Boolean.valueOf(argObjectMap.get("waitForRecording").toString())
, Boolean.valueOf(argObjectMap.get("allowRecording").toString())
, Boolean.valueOf(argObjectMap.get("hideTopBar").toString())
, Boolean.valueOf(argObjectMap.get("hideChat").toString())
, Boolean.valueOf(argObjectMap.get("hideActivitiesAndActions").toString())
, Boolean.valueOf(argObjectMap.get("hideFilesExplorer").toString())
, Boolean.valueOf(argObjectMap.get("hideActionsMenu").toString())
, Boolean.valueOf(argObjectMap.get("hideScreenSharing").toString())
, Boolean.valueOf(argObjectMap.get("hideWhiteboard").toString())
, Boolean.valueOf(argObjectMap.get("showMicrophoneStatus").toString())
, Boolean.valueOf(argObjectMap.get("chatModerated").toString())
, Boolean.valueOf(argObjectMap.get("chatOpened").toString())
, Boolean.valueOf(argObjectMap.get("filesOpened").toString())
, Boolean.valueOf(argObjectMap.get("autoVideoSelect").toString())
, Boolean.valueOf(argObjectMap.get("sipEnabled").toString())
);
}
return roomId;
} catch (Exception e) {
log.error("saveOrUpdateRoom", e);
}
return null;
}
public List<RoomModerator> getRoomModeratorsByRoomId(String SID,
Long roomId) {
try {
Long users_id = sessiondataDao.checkSession(SID);
long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
return roomModeratorsDao.getRoomModeratorByRoomId(roomId);
}
} catch (Exception err) {
log.error("[getRoomModeratorsByRoomId]", err);
}
return null;
}
/**
*
* @param SID
* @param rooms_id
* @return - id of the room being deleted
*/
public Long deleteRoom(String SID, long rooms_id) {
Long users_id = sessiondataDao.checkSession(SID);
long user_level = userManager.getUserLevelByID(users_id);
return roomManager.deleteRoomById(user_level, rooms_id);
}
/**
* return all participants of a room
*
* @param room_id
* @return - true if room is full, false otherwise
*/
public boolean isRoomFull(Long room_id) {
try {
Room room = roomDao.get(room_id);
if (room.getNumberOfPartizipants() <= this.sessionManager
.getClientListByRoom(room_id).size()) {
return true;
}
return false;
} catch (Exception err) {
log.error("[isRoomFull]", err);
}
return true;
}
/**
* return all participants of a room
*
* @param room_id
* @return - all participants of a room
*/
public List<Client> getRoomClientsListByRoomId(Long room_id) {
return sessionManager.getClientListByRoom(room_id);
}
/**
* invoked in the admin interface to show the connections currently open
*
* @param SID
* @param start
* @param max
* @param orderby
* @param asc
* @return - list of the connections currently open
*/
public SearchResult<Client> getRoomClientsMap(String SID, int start, int max,
String orderby, boolean asc) {
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkAdminLevel(user_level)) {
return this.sessionManager.getListByStartAndMax(start, max,
orderby, asc);
}
} catch (Exception err) {
log.error("[getRoomClientsMap]", err);
}
return null;
}
/**
* Get some statistics about the current sessions handled by this instance
*
* @param SID
* @return - session statistics as String
*/
public String getSessionStatistics(String SID) {
try {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkAdminLevel(user_level)) {
return this.sessionManager.getSessionStatistics();
}
} catch (Exception err) {
log.error("[getRoomClientsMap]", err);
}
return null;
}
public List<Room> getRoomsWithCurrentUsersByList(String SID, int start,
int max, String orderby, boolean asc) {
log.debug("getRooms");
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRoomsWithCurrentUsersByList(user_level, start,
max, orderby, asc);
}
public List<Room> getRoomsWithCurrentUsersByListAndType(String SID,
int start, int max, String orderby, boolean asc,
String externalRoomType) {
log.debug("getRooms");
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
return roomManager.getRoomsWithCurrentUsersByListAndType(user_level,
start, max, orderby, asc, externalRoomType);
}
public Room getRoomByOwnerAndType(String SID, Long roomtypesId,
String roomName) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
return roomManager.getRoomByOwnerAndTypeId(users_id,
roomtypesId, roomName);
}
return null;
}
/**
* Gives a {@link Server} entity, in case there is a cluster configured
*
* @param SID
* @param roomId
* @return null means the user should stay on the master, otherwise a
* {@link Server} entity is returned
*/
public ServerDTO getServerForSession(String SID, long roomId) {
Long users_id = sessiondataDao.checkSession(SID);
Long user_level = userManager.getUserLevelByID(users_id);
if (authLevelUtil.checkUserLevel(user_level)) {
List<Server> serverList = serverDao.getActiveServers();
long minimum = -1;
Server result = null;
HashMap<Server, List<Long>> activeRoomsMap = new HashMap<Server, List<Long>>();
for (Server server : serverList) {
List<Long> roomIds = sessionManager.getActiveRoomIdsByServer(server);
if (roomIds.contains(roomId)) {
// if the room is already opened on a server, redirect the user to that one,
log.debug("Room is already opened on a server " + server.getAddress());
return new ServerDTO(server);
}
activeRoomsMap.put(server, roomIds);
}
for (Server server : activeRoomsMap.keySet()) {
List<Long> roomIds = activeRoomsMap.get(server);
Long capacity = roomDao.getRoomsCapacityByIds(roomIds);
if (minimum < 0 || capacity < minimum) {
minimum = capacity;
result = server;
}
log.debug("Checking server: " + server + " Number of rooms " + roomIds.size() + " RoomIds: "
+ roomIds + " max(Sum): " + capacity);
}
return result == null ? null : new ServerDTO(result);
}
log.error("Could not get server for cluster session");
// Empty server object
return null;
}
}