Skip to content

O
Openfire
Commit 4c2804b6 authored by Roman S's avatar Roman S
Browse files
Options

REST API plugin version 1.0.0

parent 475130eb
Hide whitespace changes
Inline Side-by-side
Showing with 7500 additions and 2146 deletions
src/plugins/restAPI/changelog.html
View file @ 4c2804b6
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html> <html>
<head> <head>
<title>REST API Plugin Changelog</title> <title>REST API Plugin Changelog</title>
<style type="text/css"> <style type="text/css">
BODY { BODY {
font-size : 100%; font-size : 100%;
} }
BODY, TD, TH { BODY, TD, TH {
font-family : tahoma, verdana, arial, helvetica, sans-serif; font-family : tahoma, verdana, arial, helvetica, sans-serif;
font-size : 0.8em; font-size : 0.8em;
} }
H2 { H2 {
font-size : 10pt; font-size : 10pt;
font-weight : bold; font-weight : bold;
padding-left : 1em; padding-left : 1em;
} }
A:hover { A:hover {
text-decoration : none; text-decoration : none;
} }
H1 { H1 {
font-family : tahoma, arial, helvetica, sans-serif; font-family : tahoma, arial, helvetica, sans-serif;
font-size : 1.4em; font-size : 1.4em;
font-weight: bold; font-weight: bold;
border-bottom : 1px #ccc solid; border-bottom : 1px #ccc solid;
padding-bottom : 2px; padding-bottom : 2px;
} }
TT { TT {
font-family : courier new; font-family : courier new;
font-weight : bold; font-weight : bold;
color : #060; color : #060;
} }
PRE { PRE {
font-family : courier new; font-family : courier new;
font-size : 100%; font-size : 100%;
} }
</style> </style>
</head> </head>
<body> <body>
<h1> <h1>
REST API Plugin Changelog REST API Plugin Changelog
</h1> </h1>
<p><b>0.1.0</b> -- November 14th, 2014</p> <p><b>1.0.0</b> -- February 3rd, 2015</p>
<ul> <ul>
<li>Initial release of REST API Plugin with possibility to manage system properties.</li> <li>UserService plugin and MUC Service plugin are merged to the REST API plugin.</li>
</ul> <li>Extended REST API with JSON data format.</li>
</ul>
</body>
</html> <p><b>0.1.0</b> -- November 14th, 2014</p>
<ul>
<li>Initial release of REST API Plugin with possibility to manage system properties.</li>
</ul>
</body>
</html>
src/plugins/restAPI/plugin.xml
View file @ 4c2804b6
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<plugin> <plugin>
<class>org.jivesoftware.openfire.plugin.rest.RESTServicePlugin</class> <class>org.jivesoftware.openfire.plugin.rest.RESTServicePlugin</class>
<name>REST API</name> <name>REST API</name>
<description>Allows administration over a RESTful API.</description> <description>Allows administration over a RESTful API.</description>
<author>Roman Soldatow</author> <author>Roman Soldatow</author>
<version>0.1.0</version> <version>1.0.0</version>
<date>11/14/2014</date> <date>02/03/2015</date>
<minServerVersion>3.9.0</minServerVersion> <minServerVersion>3.9.0</minServerVersion>
<adminconsole> <adminconsole>
<tab id="tab-server"> <tab id="tab-server">
<sidebar id="sidebar-server-settings"> <sidebar id="sidebar-server-settings">
<item id="rest-api" name="REST API" url="rest-api.jsp" <item id="rest-api" name="REST API" url="rest-api.jsp"
description="Click to manage the service that allows to configure the Openfire over a RESTFul API" /> description="Click to manage the service that allows to configure the Openfire over a RESTFul API" />
</sidebar> </sidebar>
</tab> </tab>
</adminconsole> </adminconsole>
</plugin> </plugin>
src/plugins/restAPI/readme.html
View file @ 4c2804b6
This source diff could not be displayed because it is too large. You can view the blob instead.
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/AuthFilter.java
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest; package org.jivesoftware.openfire.plugin.rest;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.WebApplicationException; import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Context; import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response.Status; import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.XMPPServer; import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.admin.AdminManager; import org.jivesoftware.openfire.admin.AdminManager;
import org.jivesoftware.openfire.auth.AuthFactory; import org.jivesoftware.openfire.auth.AuthFactory;
import org.jivesoftware.openfire.auth.ConnectionException; import org.jivesoftware.openfire.auth.ConnectionException;
import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; import org.jivesoftware.openfire.auth.InternalUnauthenticatedException;
import org.jivesoftware.openfire.auth.UnauthorizedException; import org.jivesoftware.openfire.auth.UnauthorizedException;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.sun.jersey.spi.container.ContainerRequest; import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerRequestFilter; import com.sun.jersey.spi.container.ContainerRequestFilter;
/** /**
* The Class AuthFilter. * The Class AuthFilter.
*/ */
public class AuthFilter implements ContainerRequestFilter { public class AuthFilter implements ContainerRequestFilter {
/** The log. */ /** The log. */
private static Logger LOG = LoggerFactory.getLogger(AuthFilter.class); private static Logger LOG = LoggerFactory.getLogger(AuthFilter.class);
/** The http request. */ /** The http request. */
@Context @Context
private HttpServletRequest httpRequest; private HttpServletRequest httpRequest;
/** The plugin. */ /** The plugin. */
private RESTServicePlugin plugin = (RESTServicePlugin) XMPPServer.getInstance().getPluginManager() private RESTServicePlugin plugin = (RESTServicePlugin) XMPPServer.getInstance().getPluginManager()
.getPlugin("restapi"); .getPlugin("restapi");
/* /*
* (non-Javadoc) * (non-Javadoc)
* *
* @see * @see
* com.sun.jersey.spi.container.ContainerRequestFilter#filter(com.sun.jersey * com.sun.jersey.spi.container.ContainerRequestFilter#filter(com.sun.jersey
* .spi.container.ContainerRequest) * .spi.container.ContainerRequest)
*/ */
@Override @Override
public ContainerRequest filter(ContainerRequest containerRequest) throws WebApplicationException { public ContainerRequest filter(ContainerRequest containerRequest) throws WebApplicationException {
if (!plugin.isEnabled()) { if (!plugin.isEnabled()) {
throw new WebApplicationException(Status.FORBIDDEN); throw new WebApplicationException(Status.FORBIDDEN);
} }
if (!plugin.getAllowedIPs().isEmpty()) { // To be backwards compatible to userservice 1.*
// Get client's IP address if ("restapi/v1/userservice".equals(containerRequest.getPath())) {
String ipAddress = httpRequest.getHeader("x-forwarded-for"); return containerRequest;
if (ipAddress == null) { }
ipAddress = httpRequest.getHeader("X_FORWARDED_FOR");
if (ipAddress == null) { if (!plugin.getAllowedIPs().isEmpty()) {
ipAddress = httpRequest.getHeader("X-Forward-For"); // Get client's IP address
if (ipAddress == null) { String ipAddress = httpRequest.getHeader("x-forwarded-for");
ipAddress = httpRequest.getRemoteAddr(); if (ipAddress == null) {
} ipAddress = httpRequest.getHeader("X_FORWARDED_FOR");
} if (ipAddress == null) {
} ipAddress = httpRequest.getHeader("X-Forward-For");
if (!plugin.getAllowedIPs().contains(ipAddress)) { if (ipAddress == null) {
LOG.warn("REST API rejected service to IP address: " + ipAddress); ipAddress = httpRequest.getRemoteAddr();
throw new WebApplicationException(Status.UNAUTHORIZED); }
} }
} }
if (!plugin.getAllowedIPs().contains(ipAddress)) {
// Get the authentification passed in HTTP headers parameters LOG.warn("REST API rejected service to IP address: " + ipAddress);
String auth = containerRequest.getHeaderValue("authorization"); throw new WebApplicationException(Status.UNAUTHORIZED);
}
if (auth == null) { }
throw new WebApplicationException(Status.UNAUTHORIZED);
} // Get the authentification passed in HTTP headers parameters
String auth = containerRequest.getHeaderValue("authorization");
// HTTP Basic Auth or Shared Secret key
if (plugin.isHttpBasicAuth()) { if (auth == null) {
String[] usernameAndPassword = BasicAuth.decode(auth); throw new WebApplicationException(Status.UNAUTHORIZED);
}
// If username or password fail
if (usernameAndPassword == null || usernameAndPassword.length != 2) { // HTTP Basic Auth or Shared Secret key
throw new WebApplicationException(Status.UNAUTHORIZED); if (plugin.isHttpBasicAuth()) {
} String[] usernameAndPassword = BasicAuth.decode(auth);
boolean userAdmin = AdminManager.getInstance().isUserAdmin(usernameAndPassword[0], true); // If username or password fail
if (usernameAndPassword == null || usernameAndPassword.length != 2) {
if (!userAdmin) { throw new WebApplicationException(Status.UNAUTHORIZED);
throw new WebApplicationException(Status.UNAUTHORIZED); }
}
boolean userAdmin = AdminManager.getInstance().isUserAdmin(usernameAndPassword[0], true);
try {
AuthFactory.authenticate(usernameAndPassword[0], usernameAndPassword[1]); if (!userAdmin) {
} catch (UnauthorizedException e) { throw new WebApplicationException(Status.UNAUTHORIZED);
LOG.warn("Wrong HTTP Basic Auth authorization", e); }
throw new WebApplicationException(Status.UNAUTHORIZED);
} catch (ConnectionException e) { try {
throw new WebApplicationException(Status.UNAUTHORIZED); AuthFactory.authenticate(usernameAndPassword[0], usernameAndPassword[1]);
} catch (InternalUnauthenticatedException e) { } catch (UnauthorizedException e) {
throw new WebApplicationException(Status.UNAUTHORIZED); LOG.warn("Wrong HTTP Basic Auth authorization", e);
} throw new WebApplicationException(Status.UNAUTHORIZED);
} else { } catch (ConnectionException e) {
if (!auth.equals(plugin.getSecret())) { throw new WebApplicationException(Status.UNAUTHORIZED);
LOG.warn("Wrong secret key authorization. Provided key: " + auth); } catch (InternalUnauthenticatedException e) {
throw new WebApplicationException(Status.UNAUTHORIZED); throw new WebApplicationException(Status.UNAUTHORIZED);
} }
} } else {
return containerRequest; if (!auth.equals(plugin.getSecret())) {
} LOG.warn("Wrong secret key authorization. Provided key: " + auth);
} throw new WebApplicationException(Status.UNAUTHORIZED);
}
}
return containerRequest;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/controller/MUCRoomController.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.controller;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.plugin.rest.entity.MUCChannelType;
import org.jivesoftware.openfire.plugin.rest.entity.MUCRoomEntities;
import org.jivesoftware.openfire.plugin.rest.entity.MUCRoomEntity;
import org.jivesoftware.openfire.plugin.rest.entity.ParticipantEntities;
import org.jivesoftware.openfire.plugin.rest.entity.ParticipantEntity;
import org.jivesoftware.openfire.plugin.rest.exceptions.ExceptionType;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.muc.ConflictException;
import org.jivesoftware.openfire.muc.ForbiddenException;
import org.jivesoftware.openfire.muc.MUCRole;
import org.jivesoftware.openfire.muc.MUCRoom;
import org.jivesoftware.openfire.muc.NotAllowedException;
import org.jivesoftware.openfire.plugin.rest.utils.MUCRoomUtils;
import org.jivesoftware.openfire.plugin.rest.utils.UserUtils;
import org.xmpp.packet.JID;
/**
* The Class MUCRoomController.
*/
public class MUCRoomController {
/** The Constant INSTANCE. */
public static final MUCRoomController INSTANCE = new MUCRoomController();
/**
* Gets the single instance of MUCRoomController.
*
* @return single instance of MUCRoomController
*/
public static MUCRoomController getInstance() {
return INSTANCE;
}
/**
* Gets the chat rooms.
*
* @param serviceName
* the service name
* @param channelType
* the channel type
* @param roomSearch
* the room search
* @return the chat rooms
*/
public MUCRoomEntities getChatRooms(String serviceName, String channelType, String roomSearch) {
List<MUCRoom> rooms = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRooms();
List<MUCRoomEntity> mucRoomEntities = new ArrayList<MUCRoomEntity>();
for (MUCRoom chatRoom : rooms) {
if (roomSearch != null) {
if (!chatRoom.getName().contains(roomSearch)) {
continue;
}
}
if (channelType.equals(MUCChannelType.ALL)) {
mucRoomEntities.add(convertToMUCRoomEntity(chatRoom));
} else if (channelType.equals(MUCChannelType.PUBLIC) && chatRoom.isPublicRoom()) {
mucRoomEntities.add(convertToMUCRoomEntity(chatRoom));
}
}
return new MUCRoomEntities(mucRoomEntities);
}
/**
* Gets the chat room.
*
* @param roomName
* the room name
* @param serviceName
* the service name
* @return the chat room
* @throws ServiceException
* the service exception
*/
public MUCRoomEntity getChatRoom(String roomName, String serviceName) throws ServiceException {
MUCRoom chatRoom = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName);
if (chatRoom == null) {
throw new ServiceException("Could not find the chat room", roomName, ExceptionType.ROOM_NOT_FOUND, Response.Status.NOT_FOUND);
}
MUCRoomEntity mucRoomEntity = convertToMUCRoomEntity(chatRoom);
return mucRoomEntity;
}
/**
* Delete chat room.
*
* @param roomName
* the room name
* @param serviceName
* the service name
* @throws ServiceException
* the service exception
*/
public void deleteChatRoom(String roomName, String serviceName) throws ServiceException {
MUCRoom chatRoom = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
if (chatRoom != null) {
chatRoom.destroyRoom(null, null);
} else {
throw new ServiceException("Could not remove the channel", roomName, ExceptionType.ROOM_NOT_FOUND, Response.Status.NOT_FOUND);
}
}
/**
* Creates the chat room.
*
* @param serviceName
* the service name
* @param mucRoomEntity
* the MUC room entity
* @throws ServiceException
* the service exception
*/
public void createChatRoom(String serviceName, MUCRoomEntity mucRoomEntity) throws ServiceException {
try {
createRoom(mucRoomEntity, serviceName);
} catch (NotAllowedException e) {
throw new ServiceException("Could not create the channel", mucRoomEntity.getRoomName(),
ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ForbiddenException e) {
throw new ServiceException("Could not create the channel", mucRoomEntity.getRoomName(),
ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not create the channel", mucRoomEntity.getRoomName(),
ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Update chat room.
*
* @param roomName
* the room name
* @param serviceName
* the service name
* @param mucRoomEntity
* the MUC room entity
* @throws ServiceException
* the service exception
*/
public void updateChatRoom(String roomName, String serviceName, MUCRoomEntity mucRoomEntity)
throws ServiceException {
try {
// If the room name is different throw exception
if (!roomName.equals(mucRoomEntity.getRoomName())) {
throw new ServiceException(
"Could not update the channel. The room name is different to the entity room name.", roomName,
ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION, Response.Status.BAD_REQUEST);
}
createRoom(mucRoomEntity, serviceName);
} catch (NotAllowedException e) {
throw new ServiceException("Could not update the channel", roomName, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ForbiddenException e) {
throw new ServiceException("Could not update the channel", roomName, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not update the channel", roomName, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Creates the room.
*
* @param mucRoomEntity
* the MUC room entity
* @param serviceName
* the service name
* @throws NotAllowedException
* the not allowed exception
* @throws ForbiddenException
* the forbidden exception
* @throws ConflictException
* the conflict exception
*/
private void createRoom(MUCRoomEntity mucRoomEntity, String serviceName) throws NotAllowedException,
ForbiddenException, ConflictException {
// Set owner
JID owner = XMPPServer.getInstance().createJID("admin", null);
if (mucRoomEntity.getOwners() != null && mucRoomEntity.getOwners().size() > 0) {
owner = new JID(mucRoomEntity.getOwners().get(0));
} else {
List<String> owners = new ArrayList<String>();
owners.add(owner.toBareJID());
mucRoomEntity.setOwners(owners);
}
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(mucRoomEntity.getRoomName().toLowerCase(), owner);
// Set values
room.setNaturalLanguageName(mucRoomEntity.getNaturalName());
room.setSubject(mucRoomEntity.getSubject());
room.setDescription(mucRoomEntity.getDescription());
room.setPassword(mucRoomEntity.getPassword());
room.setPersistent(mucRoomEntity.isPersistent());
room.setPublicRoom(mucRoomEntity.isPublicRoom());
room.setRegistrationEnabled(mucRoomEntity.isRegistrationEnabled());
room.setCanAnyoneDiscoverJID(mucRoomEntity.isCanAnyoneDiscoverJID());
room.setCanOccupantsChangeSubject(mucRoomEntity.isCanOccupantsChangeSubject());
room.setCanOccupantsInvite(mucRoomEntity.isCanOccupantsInvite());
room.setChangeNickname(mucRoomEntity.isCanChangeNickname());
room.setModificationDate(mucRoomEntity.getModificationDate());
room.setLogEnabled(mucRoomEntity.isLogEnabled());
room.setLoginRestrictedToNickname(mucRoomEntity.isLoginRestrictedToNickname());
room.setMaxUsers(mucRoomEntity.getMaxUsers());
room.setMembersOnly(mucRoomEntity.isMembersOnly());
room.setModerated(mucRoomEntity.isModerated());
// Set broadcast presence roles
if (mucRoomEntity.getBroadcastPresenceRoles() != null) {
room.setRolesToBroadcastPresence(mucRoomEntity.getBroadcastPresenceRoles());
} else {
room.setRolesToBroadcastPresence(new ArrayList<String>());
}
// Set all roles
setRoles(room, mucRoomEntity);
// Set creation date
if (mucRoomEntity.getCreationDate() != null) {
room.setCreationDate(mucRoomEntity.getCreationDate());
} else {
room.setCreationDate(new Date());
}
// Set modification date
if (mucRoomEntity.getModificationDate() != null) {
room.setModificationDate(mucRoomEntity.getModificationDate());
} else {
room.setModificationDate(new Date());
}
// Unlock the room, because the default configuration lock the room.
room.unlock(room.getRole());
// Save the room to the DB if the room should be persistant
if (room.isPersistent()) {
room.saveToDB();
}
}
/**
* Gets the room participants.
*
* @param roomName
* the room name
* @param serviceName
* the service name
* @return the room participants
*/
public ParticipantEntities getRoomParticipants(String roomName, String serviceName) {
ParticipantEntities participantEntities = new ParticipantEntities();
List<ParticipantEntity> participants = new ArrayList<ParticipantEntity>();
Collection<MUCRole> serverParticipants = XMPPServer.getInstance().getMultiUserChatManager()
.getMultiUserChatService(serviceName).getChatRoom(roomName).getParticipants();
for (MUCRole role : serverParticipants) {
ParticipantEntity participantEntity = new ParticipantEntity();
participantEntity.setJid(role.getRoleAddress().toFullJID());
participantEntity.setRole(role.getRole().name());
participantEntity.setAffiliation(role.getAffiliation().name());
participants.add(participantEntity);
}
participantEntities.setParticipants(participants);
return participantEntities;
}
/**
* Convert to MUC room entity.
*
* @param room
* the room
* @return the MUC room entity
*/
public MUCRoomEntity convertToMUCRoomEntity(MUCRoom room) {
MUCRoomEntity mucRoomEntity = new MUCRoomEntity(room.getNaturalLanguageName(), room.getName(),
room.getDescription());
mucRoomEntity.setCanAnyoneDiscoverJID(room.canAnyoneDiscoverJID());
mucRoomEntity.setCanChangeNickname(room.canChangeNickname());
mucRoomEntity.setCanOccupantsChangeSubject(room.canOccupantsChangeSubject());
mucRoomEntity.setCanOccupantsInvite(room.canOccupantsInvite());
mucRoomEntity.setPublicRoom(room.isPublicRoom());
mucRoomEntity.setPassword(room.getPassword());
mucRoomEntity.setPersistent(room.isPersistent());
mucRoomEntity.setRegistrationEnabled(room.isRegistrationEnabled());
mucRoomEntity.setLogEnabled(room.isLogEnabled());
mucRoomEntity.setLoginRestrictedToNickname(room.isLoginRestrictedToNickname());
mucRoomEntity.setMaxUsers(room.getMaxUsers());
mucRoomEntity.setMembersOnly(room.isMembersOnly());
mucRoomEntity.setModerated(room.isModerated());
mucRoomEntity.setOwners(MUCRoomUtils.convertJIDsToStringList(room.getOwners()));
mucRoomEntity.setAdmins(MUCRoomUtils.convertJIDsToStringList(room.getAdmins()));
mucRoomEntity.setMembers(MUCRoomUtils.convertJIDsToStringList(room.getMembers()));
mucRoomEntity.setOutcasts(MUCRoomUtils.convertJIDsToStringList(room.getOutcasts()));
mucRoomEntity.setBroadcastPresenceRoles(room.getRolesToBroadcastPresence());
mucRoomEntity.setCreationDate(room.getCreationDate());
mucRoomEntity.setModificationDate(room.getModificationDate());
return mucRoomEntity;
}
/**
* Reset roles.
*
* @param room
* the room
* @param mucRoomEntity
* the muc room entity
* @throws ForbiddenException
* the forbidden exception
* @throws NotAllowedException
* the not allowed exception
* @throws ConflictException
* the conflict exception
*/
private void setRoles(MUCRoom room, MUCRoomEntity mucRoomEntity) throws ForbiddenException, NotAllowedException,
ConflictException {
List<JID> roles = new ArrayList<JID>();
Collection<JID> owners = new ArrayList<JID>();
Collection<JID> existingOwners = new ArrayList<JID>();
List<JID> mucRoomEntityOwners = MUCRoomUtils.convertStringsToJIDs(mucRoomEntity.getOwners());
owners.addAll(room.getOwners());
// Find same owners
for (JID jid : owners) {
if (mucRoomEntityOwners.contains(jid)) {
existingOwners.add(jid);
}
}
// Don't delete the same owners
owners.removeAll(existingOwners);
room.addOwners(MUCRoomUtils.convertStringsToJIDs(mucRoomEntity.getOwners()), room.getRole());
// Collect all roles to reset
roles.addAll(owners);
roles.addAll(room.getAdmins());
roles.addAll(room.getMembers());
roles.addAll(room.getOutcasts());
for (JID jid : roles) {
room.addNone(jid, room.getRole());
}
room.addOwners(MUCRoomUtils.convertStringsToJIDs(mucRoomEntity.getOwners()), room.getRole());
if (mucRoomEntity.getAdmins() != null) {
room.addAdmins(MUCRoomUtils.convertStringsToJIDs(mucRoomEntity.getAdmins()), room.getRole());
}
if (mucRoomEntity.getMembers() != null) {
for (String memberJid : mucRoomEntity.getMembers()) {
room.addMember(new JID(memberJid), null, room.getRole());
}
}
if (mucRoomEntity.getOutcasts() != null) {
for (String outcastJid : mucRoomEntity.getOutcasts()) {
room.addOutcast(new JID(outcastJid), null, room.getRole());
}
}
}
/**
* Adds the admin.
*
* @param serviceName
* the service name
* @param roomName
* the room name
* @param jid
* the jid
* @throws ServiceException
* the service exception
*/
public void addAdmin(String serviceName, String roomName, String jid) throws ServiceException {
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
try {
room.addAdmin(UserUtils.checkAndGetJID(jid), room.getRole());
} catch (ForbiddenException e) {
throw new ServiceException("Could not add admin", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not add admin", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Adds the owner.
*
* @param serviceName
* the service name
* @param roomName
* the room name
* @param jid
* the jid
* @throws ServiceException
* the service exception
*/
public void addOwner(String serviceName, String roomName, String jid) throws ServiceException {
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
try {
room.addOwner(UserUtils.checkAndGetJID(jid), room.getRole());
} catch (ForbiddenException e) {
throw new ServiceException("Could not add owner", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Adds the member.
*
* @param serviceName
* the service name
* @param roomName
* the room name
* @param jid
* the jid
* @throws ServiceException
* the service exception
*/
public void addMember(String serviceName, String roomName, String jid) throws ServiceException {
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
try {
room.addMember(UserUtils.checkAndGetJID(jid), null, room.getRole());
} catch (ForbiddenException e) {
throw new ServiceException("Could not add member", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not add member", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Adds the outcast.
*
* @param serviceName
* the service name
* @param roomName
* the room name
* @param jid
* the jid
* @throws ServiceException
* the service exception
*/
public void addOutcast(String serviceName, String roomName, String jid) throws ServiceException {
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
try {
room.addOutcast(UserUtils.checkAndGetJID(jid), null, room.getRole());
} catch (NotAllowedException e) {
throw new ServiceException("Could not add outcast", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ForbiddenException e) {
throw new ServiceException("Could not add outcast", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not add outcast", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
/**
* Delete affiliation.
*
* @param serviceName
* the service name
* @param roomName
* the room name
* @param jid
* the jid
* @throws ServiceException
* the service exception
*/
public void deleteAffiliation(String serviceName, String roomName, String jid) throws ServiceException {
MUCRoom room = XMPPServer.getInstance().getMultiUserChatManager().getMultiUserChatService(serviceName)
.getChatRoom(roomName.toLowerCase());
try {
room.addNone(UserUtils.checkAndGetJID(jid), room.getRole());
} catch (ForbiddenException e) {
throw new ServiceException("Could not delete affiliation", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
} catch (ConflictException e) {
throw new ServiceException("Could not delete affiliation", jid, ExceptionType.NOT_ALLOWED, Response.Status.FORBIDDEN, e);
}
}
}
\ No newline at end of file
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/controller/UserServiceController.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.controller;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.SharedGroupException;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.plugin.rest.entity.RosterEntities;
import org.jivesoftware.openfire.plugin.rest.entity.RosterItemEntity;
import org.jivesoftware.openfire.plugin.rest.entity.UserEntities;
import org.jivesoftware.openfire.plugin.rest.entity.UserEntity;
import org.jivesoftware.openfire.plugin.rest.entity.UserGroupsEntity;
import org.jivesoftware.openfire.plugin.rest.entity.UserProperty;
import org.jivesoftware.openfire.plugin.rest.exceptions.ExceptionType;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.group.Group;
import org.jivesoftware.openfire.group.GroupAlreadyExistsException;
import org.jivesoftware.openfire.group.GroupManager;
import org.jivesoftware.openfire.group.GroupNotFoundException;
import org.jivesoftware.openfire.lockout.LockOutManager;
import org.jivesoftware.openfire.plugin.rest.dao.PropertyDAO;
import org.jivesoftware.openfire.roster.Roster;
import org.jivesoftware.openfire.roster.RosterItem;
import org.jivesoftware.openfire.roster.RosterManager;
import org.jivesoftware.openfire.user.User;
import org.jivesoftware.openfire.user.UserAlreadyExistsException;
import org.jivesoftware.openfire.user.UserManager;
import org.jivesoftware.openfire.user.UserNotFoundException;
import org.jivesoftware.openfire.plugin.rest.utils.UserUtils;
import org.xmpp.packet.JID;
/**
* The Class UserServiceController.
*/
public class UserServiceController {
/** The Constant INSTANCE. */
public static final UserServiceController INSTANCE = new UserServiceController();
/** The user manager. */
private UserManager userManager;
/** The roster manager. */
private RosterManager rosterManager;
/** The server. */
private XMPPServer server;
/**
* Gets the single instance of UserServiceController.
*
* @return single instance of UserServiceController
*/
public static UserServiceController getInstance() {
return INSTANCE;
}
/**
* Instantiates a new user service controller.
*/
private UserServiceController() {
server = XMPPServer.getInstance();
userManager = server.getUserManager();
rosterManager = server.getRosterManager();
}
/**
* Creates the user.
*
* @param userEntity
* the user entity
* @throws ServiceException
* the service exception
*/
public void createUser(UserEntity userEntity) throws ServiceException {
if (userEntity != null && !userEntity.getUsername().isEmpty()) {
if (userEntity.getPassword() == null) {
throw new ServiceException("Could not create new user, because password is null",
userEntity.getUsername(), "PasswordIsNull", Response.Status.BAD_REQUEST);
}
try {
userManager.createUser(userEntity.getUsername(), userEntity.getPassword(), userEntity.getName(),
userEntity.getEmail());
} catch (UserAlreadyExistsException e) {
throw new ServiceException("Could not create new user", userEntity.getUsername(),
ExceptionType.USER_ALREADY_EXISTS_EXCEPTION, Response.Status.BAD_REQUEST);
}
addProperties(userEntity);
}
}
/**
* Update user.
*
* @param username
* the username
* @param userEntity
* the user entity
* @throws ServiceException
* the service exception
*/
public void updateUser(String username, UserEntity userEntity) throws ServiceException {
if (userEntity != null && !username.isEmpty()) {
User user = getAndCheckUser(username);
if (userEntity.getPassword() != null) {
user.setPassword(userEntity.getPassword());
}
if (userEntity.getName() != null) {
user.setName(userEntity.getName());
}
if (userEntity.getEmail() != null) {
user.setEmail(userEntity.getEmail());
}
addProperties(userEntity);
}
}
/**
* Delete user.
*
* @param username
* the username
* @throws ServiceException
* the service exception
*/
public void deleteUser(String username) throws ServiceException {
User user = getAndCheckUser(username);
userManager.deleteUser(user);
rosterManager.deleteRoster(server.createJID(username, null));
}
/**
* Gets the user entities.
*
* @param userSearch
* the user search
* @param propertyValue
* @param propertyKey
* @return the user entities
* @throws ServiceException
*/
public UserEntities getUserEntities(String userSearch, String propertyKey, String propertyValue) throws ServiceException {
if(propertyKey != null) {
return getUserEntitiesByProperty(propertyKey, propertyValue);
}
UserEntities userEntities = new UserEntities();
userEntities.setUsers(UserUtils.convertUsersToUserEntities(userManager.getUsers(), userSearch));
return userEntities;
}
/**
* Gets the user entity.
*
* @param username
* the username
* @return the user entity
* @throws ServiceException
* the service exception
*/
public UserEntity getUserEntity(String username) throws ServiceException {
return UserUtils.convertUserToUserEntity(getAndCheckUser(username));
}
/**
* Enable user.
*
* @param username
* the username
* @throws ServiceException
* the service exception
*/
public void enableUser(String username) throws ServiceException {
getAndCheckUser(username);
LockOutManager.getInstance().enableAccount(username);
}
/**
* Disable user.
*
* @param username
* the username
* @throws ServiceException
* the service exception
*/
public void disableUser(String username) throws ServiceException {
getAndCheckUser(username);
LockOutManager.getInstance().disableAccount(username, null, null);
}
/**
* Gets the roster entities.
*
* @param username
* the username
* @return the roster entities
* @throws ServiceException
* the service exception
*/
public RosterEntities getRosterEntities(String username) throws ServiceException {
Roster roster = getUserRoster(username);
List<RosterItemEntity> rosterEntities = new ArrayList<RosterItemEntity>();
for (RosterItem rosterItem : roster.getRosterItems()) {
RosterItemEntity rosterItemEntity = new RosterItemEntity(rosterItem.getJid().toBareJID(),
rosterItem.getNickname(), rosterItem.getSubStatus().getValue());
rosterItemEntity.setGroups(rosterItem.getGroups());
rosterEntities.add(rosterItemEntity);
}
return new RosterEntities(rosterEntities);
}
/**
* Adds the roster item.
*
* @param username
* the username
* @param rosterItemEntity
* the roster item entity
* @throws ServiceException
* the service exception
* @throws UserAlreadyExistsException
* the user already exists exception
* @throws SharedGroupException
* the shared group exception
* @throws UserNotFoundException
* the user not found exception
*/
public void addRosterItem(String username, RosterItemEntity rosterItemEntity) throws ServiceException,
UserAlreadyExistsException, SharedGroupException, UserNotFoundException {
Roster roster = getUserRoster(username);
if (rosterItemEntity.getJid() == null) {
throw new ServiceException("JID is null", "JID", "IllegalArgumentException", Response.Status.BAD_REQUEST);
}
JID jid = new JID(rosterItemEntity.getJid());
try {
roster.getRosterItem(jid);
throw new UserAlreadyExistsException(jid.toBareJID());
} catch (UserNotFoundException e) {
// Roster item does not exist. Try to add it.
}
if (roster != null) {
RosterItem rosterItem = roster.createRosterItem(jid, rosterItemEntity.getNickname(),
rosterItemEntity.getGroups(), false, true);
UserUtils.checkSubType(rosterItemEntity.getSubscriptionType());
rosterItem.setSubStatus(RosterItem.SubType.getTypeFromInt(rosterItemEntity.getSubscriptionType()));
roster.updateRosterItem(rosterItem);
}
}
/**
* Update roster item.
*
* @param username
* the username
* @param rosterJid
* the roster jid
* @param rosterItemEntity
* the roster item entity
* @throws ServiceException
* the service exception
* @throws UserNotFoundException
* the user not found exception
* @throws UserAlreadyExistsException
* the user already exists exception
* @throws SharedGroupException
* the shared group exception
*/
public void updateRosterItem(String username, String rosterJid, RosterItemEntity rosterItemEntity)
throws ServiceException, UserNotFoundException, UserAlreadyExistsException, SharedGroupException {
getAndCheckUser(username);
Roster roster = getUserRoster(username);
JID jid = new JID(rosterJid);
RosterItem rosterItem = roster.getRosterItem(jid);
if (rosterItemEntity.getNickname() != null) {
rosterItem.setNickname(rosterItemEntity.getNickname());
}
if (rosterItemEntity.getGroups() != null) {
rosterItem.setGroups(rosterItemEntity.getGroups());
}
UserUtils.checkSubType(rosterItemEntity.getSubscriptionType());
rosterItem.setSubStatus(RosterItem.SubType.getTypeFromInt(rosterItemEntity.getSubscriptionType()));
roster.updateRosterItem(rosterItem);
}
/**
* Delete roster item.
*
* @param username
* the username
* @param rosterJid
* the roster jid
* @throws SharedGroupException
* the shared group exception
* @throws ServiceException
* the service exception
*/
public void deleteRosterItem(String username, String rosterJid) throws SharedGroupException, ServiceException {
getAndCheckUser(username);
Roster roster = getUserRoster(username);
JID jid = new JID(rosterJid);
if (roster.deleteRosterItem(jid, true) == null) {
throw new ServiceException("Roster Item could not deleted", jid.toBareJID(), "RosterItemNotFound",
Response.Status.NOT_FOUND);
}
}
/**
* Gets the user groups.
*
* @param username
* the username
* @return the user groups
* @throws ServiceException
* the service exception
*/
public List<String> getUserGroups(String username) throws ServiceException {
User user = getAndCheckUser(username);
Collection<Group> groups = GroupManager.getInstance().getGroups(user);
List<String> groupNames = new ArrayList<String>();
for (Group group : groups) {
groupNames.add(group.getName());
}
return groupNames;
}
/**
* Adds the user to group.
*
* @param username the username
* @param userGroupsEntity the user groups entity
* @throws ServiceException the service exception
*/
public void addUserToGroups(String username, UserGroupsEntity userGroupsEntity) throws ServiceException {
if (userGroupsEntity != null) {
Collection<Group> groups = new ArrayList<Group>();
for (String groupName : userGroupsEntity.getGroupNames()) {
Group group = null;
try {
group = GroupManager.getInstance().getGroup(groupName);
} catch (GroupNotFoundException e) {
// Create this group
group = createGroup(groupName);
}
groups.add(group);
}
for (Group group : groups) {
group.getMembers().add(server.createJID(username, null));
}
}
}
/**
* Delete user from groups.
*
* @param username
* the username
* @param userGroupsEntity
* the user groups entity
* @throws ServiceException
* the service exception
*/
public void deleteUserFromGroups(String username, UserGroupsEntity userGroupsEntity) throws ServiceException {
if (userGroupsEntity != null) {
for (String groupName : userGroupsEntity.getGroupNames()) {
Group group = null;
try {
group = GroupManager.getInstance().getGroup(groupName);
} catch (GroupNotFoundException e) {
throw new ServiceException("Could not find group", groupName, ExceptionType.GROUP_NOT_FOUND,
Response.Status.NOT_FOUND, e);
}
group.getMembers().remove(server.createJID(username, null));
}
}
}
/**
* Gets the user entities by property key and or value.
*
* @param propertyKey
* the property key
* @param propertyValue
* the property value (can be null)
* @return the user entities by property
* @throws ServiceException
* the service exception
*/
public UserEntities getUserEntitiesByProperty(String propertyKey, String propertyValue) throws ServiceException {
List<String> usernames = PropertyDAO.getUsernameByProperty(propertyKey, propertyValue);
List<UserEntity> users = new ArrayList<UserEntity>();
UserEntities userEntities = new UserEntities();
for (String username : usernames) {
users.add(getUserEntity(username));
}
userEntities.setUsers(users);
return userEntities;
}
/**
* Adds the properties.
*
* @param userEntity
* the user entity
* @throws ServiceException
* the service exception
*/
private void addProperties(UserEntity userEntity) throws ServiceException {
User user = getAndCheckUser(userEntity.getUsername());
user.getProperties().clear();
if (userEntity.getProperties() != null) {
for (UserProperty property : userEntity.getProperties()) {
user.getProperties().put(property.getKey(), property.getValue());
}
}
}
/**
* Creates the group.
*
* @param groupName the group name
* @return the group
* @throws ServiceException the service exception
*/
private Group createGroup(String groupName) throws ServiceException {
Group group = null;
try {
group = GroupManager.getInstance().createGroup(groupName);
group.getProperties().put("sharedRoster.showInRoster", "onlyGroup");
group.getProperties().put("sharedRoster.displayName", groupName);
group.getProperties().put("sharedRoster.groupList", "");
} catch (GroupAlreadyExistsException e) {
throw new ServiceException("Could not create group", groupName, ExceptionType.GROUP_ALREADY_EXISTS,
Response.Status.BAD_REQUEST, e);
}
return group;
}
/**
* Gets the and check user.
*
* @param username
* the username
* @return the and check user
* @throws ServiceException
* the service exception
*/
private User getAndCheckUser(String username) throws ServiceException {
JID targetJID = server.createJID(username, null);
if (targetJID.getNode() == null) {
throw new ServiceException("Could not get user", username, ExceptionType.USER_NOT_FOUND_EXCEPTION,
Response.Status.NOT_FOUND);
}
try {
return userManager.getUser(targetJID.getNode());
} catch (UserNotFoundException e) {
throw new ServiceException("Could not get user", username, ExceptionType.USER_NOT_FOUND_EXCEPTION,
Response.Status.NOT_FOUND, e);
}
}
/**
* Gets the user roster.
*
* @param username
* the username
* @return the user roster
* @throws ServiceException
* the service exception
*/
private Roster getUserRoster(String username) throws ServiceException {
try {
return rosterManager.getRoster(username);
} catch (UserNotFoundException e) {
throw new ServiceException("Could not get user roster", username, ExceptionType.USER_NOT_FOUND_EXCEPTION,
Response.Status.NOT_FOUND, e);
}
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/controller/UserServiceLegacyController.java 0 → 100644
View file @ 4c2804b6
/**
* $Revision: 1722 $
* $Date: 2005-07-28 15:19:16 -0700 (Thu, 28 Jul 2005) $
*
* Copyright (C) 2005-2008 Jive Software. All rights reserved.
*
* Licensed 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.jivesoftware.openfire.plugin.rest.controller;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.StringTokenizer;
import org.jivesoftware.openfire.SharedGroupException;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.group.Group;
import org.jivesoftware.openfire.group.GroupAlreadyExistsException;
import org.jivesoftware.openfire.group.GroupManager;
import org.jivesoftware.openfire.group.GroupNotFoundException;
import org.jivesoftware.openfire.lockout.LockOutManager;
import org.jivesoftware.openfire.roster.Roster;
import org.jivesoftware.openfire.roster.RosterItem;
import org.jivesoftware.openfire.roster.RosterManager;
import org.jivesoftware.openfire.user.User;
import org.jivesoftware.openfire.user.UserAlreadyExistsException;
import org.jivesoftware.openfire.user.UserManager;
import org.jivesoftware.openfire.user.UserNotFoundException;
import org.xmpp.packet.JID;
/**
* Plugin that allows the administration of users via HTTP requests.
*
* @author Justin Hunt
*/
public class UserServiceLegacyController {
/** The Constant INSTANCE. */
public static final UserServiceLegacyController INSTANCE = new UserServiceLegacyController();
/** The user manager. */
private UserManager userManager;
/** The roster manager. */
private RosterManager rosterManager;
/** The server. */
private XMPPServer server;
/**
* Gets the single instance of UserServiceLegacyController.
*
* @return single instance of UserServiceLegacyController
*/
public static UserServiceLegacyController getInstance() {
return INSTANCE;
}
/**
* Instantiates a new user service legacy controller.
*/
private UserServiceLegacyController() {
server = XMPPServer.getInstance();
userManager = server.getUserManager();
rosterManager = server.getRosterManager();
}
/**
* Creates the user.
*
* @param username the username
* @param password the password
* @param name the name
* @param email the email
* @param groupNames the group names
* @throws UserAlreadyExistsException the user already exists exception
* @throws GroupAlreadyExistsException the group already exists exception
* @throws UserNotFoundException the user not found exception
* @throws GroupNotFoundException the group not found exception
*/
public void createUser(String username, String password, String name, String email, String groupNames)
throws UserAlreadyExistsException, GroupAlreadyExistsException, UserNotFoundException,
GroupNotFoundException {
userManager.createUser(username, password, name, email);
userManager.getUser(username);
if (groupNames != null) {
Collection<Group> groups = new ArrayList<Group>();
StringTokenizer tkn = new StringTokenizer(groupNames, ",");
while (tkn.hasMoreTokens()) {
String groupName = tkn.nextToken();
Group group = null;
try {
group = GroupManager.getInstance().getGroup(groupName);
} catch (GroupNotFoundException e) {
// Create this group ;
group = GroupManager.getInstance().createGroup(groupName);
group.getProperties().put("sharedRoster.showInRoster", "onlyGroup");
group.getProperties().put("sharedRoster.displayName", groupName);
group.getProperties().put("sharedRoster.groupList", "");
}
groups.add(group);
}
for (Group group : groups) {
group.getMembers().add(server.createJID(username, null));
}
}
}
/**
* Delete user.
*
* @param username the username
* @throws UserNotFoundException the user not found exception
* @throws SharedGroupException the shared group exception
*/
public void deleteUser(String username) throws UserNotFoundException, SharedGroupException {
User user = getUser(username);
userManager.deleteUser(user);
rosterManager.deleteRoster(server.createJID(username, null));
}
/**
* Lock Out on a given username.
*
* @param username the username of the local user to disable.
* @throws UserNotFoundException if the requested user does not exist in the local server.
*/
public void disableUser(String username) throws UserNotFoundException {
getUser(username);
LockOutManager.getInstance().disableAccount(username, null, null);
}
/**
* Remove the lockout on a given username.
*
* @param username the username of the local user to enable.
* @throws UserNotFoundException if the requested user does not exist in the local server.
*/
public void enableUser(String username) throws UserNotFoundException {
getUser(username);
LockOutManager.getInstance().enableAccount(username);
}
/**
* Update user.
*
* @param username the username
* @param password the password
* @param name the name
* @param email the email
* @param groupNames the group names
* @throws UserNotFoundException the user not found exception
* @throws GroupAlreadyExistsException the group already exists exception
*/
public void updateUser(String username, String password, String name, String email, String groupNames)
throws UserNotFoundException, GroupAlreadyExistsException {
User user = getUser(username);
if (password != null)
user.setPassword(password);
if (name != null)
user.setName(name);
if (email != null)
user.setEmail(email);
if (groupNames != null) {
Collection<Group> newGroups = new ArrayList<Group>();
StringTokenizer tkn = new StringTokenizer(groupNames, ",");
while (tkn.hasMoreTokens()) {
String groupName = tkn.nextToken();
Group group = null;
try {
group = GroupManager.getInstance().getGroup(groupName);
} catch (GroupNotFoundException e) {
// Create this group ;
group = GroupManager.getInstance().createGroup(groupName);
group.getProperties().put("sharedRoster.showInRoster", "onlyGroup");
group.getProperties().put("sharedRoster.displayName", groupName);
group.getProperties().put("sharedRoster.groupList", "");
}
newGroups.add(group);
}
Collection<Group> existingGroups = GroupManager.getInstance().getGroups(user);
// Get the list of groups to add to the user
Collection<Group> groupsToAdd = new ArrayList<Group>(newGroups);
groupsToAdd.removeAll(existingGroups);
// Get the list of groups to remove from the user
Collection<Group> groupsToDelete = new ArrayList<Group>(existingGroups);
groupsToDelete.removeAll(newGroups);
// Add the user to the new groups
for (Group group : groupsToAdd) {
group.getMembers().add(server.createJID(username, null));
}
// Remove the user from the old groups
for (Group group : groupsToDelete) {
group.getMembers().remove(server.createJID(username, null));
}
}
}
/**
* Add new roster item for specified user.
*
* @param username the username of the local user to add roster item to.
* @param itemJID the JID of the roster item to be added.
* @param itemName the nickname of the roster item.
* @param subscription the type of subscription of the roster item. Possible values
* are: -1(remove), 0(none), 1(to), 2(from), 3(both).
* @param groupNames the name of a group to place contact into.
* @throws UserNotFoundException if the user does not exist in the local server.
* @throws UserAlreadyExistsException if roster item with the same JID already exists.
* @throws SharedGroupException if roster item cannot be added to a shared group.
*/
public void addRosterItem(String username, String itemJID, String itemName, String subscription, String groupNames)
throws UserNotFoundException, UserAlreadyExistsException, SharedGroupException {
getUser(username);
Roster r = rosterManager.getRoster(username);
JID j = new JID(itemJID);
try {
r.getRosterItem(j);
throw new UserAlreadyExistsException(j.toBareJID());
} catch (UserNotFoundException e) {
// Roster item does not exist. Try to add it.
}
if (r != null) {
List<String> groups = new ArrayList<String>();
if (groupNames != null) {
StringTokenizer tkn = new StringTokenizer(groupNames, ",");
while (tkn.hasMoreTokens()) {
groups.add(tkn.nextToken());
}
}
RosterItem ri = r.createRosterItem(j, itemName, groups, false, true);
if (subscription == null) {
subscription = "0";
}
ri.setSubStatus(RosterItem.SubType.getTypeFromInt(Integer.parseInt(subscription)));
r.updateRosterItem(ri);
}
}
/**
* Update roster item for specified user.
*
* @param username the username of the local user to update roster item for.
* @param itemJID the JID of the roster item to be updated.
* @param itemName the nickname of the roster item.
* @param subscription the type of subscription of the roster item. Possible values
* are: -1(remove), 0(none), 1(to), 2(from), 3(both).
* @param groupNames the name of a group.
* @throws UserNotFoundException if the user does not exist in the local server or roster item
* does not exist.
* @throws SharedGroupException if roster item cannot be added to a shared group.
*/
public void updateRosterItem(String username, String itemJID, String itemName, String subscription,
String groupNames) throws UserNotFoundException, SharedGroupException {
getUser(username);
Roster r = rosterManager.getRoster(username);
JID j = new JID(itemJID);
RosterItem ri = r.getRosterItem(j);
List<String> groups = new ArrayList<String>();
if (groupNames != null) {
StringTokenizer tkn = new StringTokenizer(groupNames, ",");
while (tkn.hasMoreTokens()) {
groups.add(tkn.nextToken());
}
}
ri.setGroups(groups);
ri.setNickname(itemName);
if (subscription == null) {
subscription = "0";
}
ri.setSubStatus(RosterItem.SubType.getTypeFromInt(Integer.parseInt(subscription)));
r.updateRosterItem(ri);
}
/**
* Delete roster item for specified user. No error returns if nothing to
* delete.
*
* @param username
* the username of the local user to add roster item to.
* @param itemJID
* the JID of the roster item to be deleted.
* @throws UserNotFoundException
* if the user does not exist in the local server.
* @throws SharedGroupException
* if roster item cannot be deleted from a shared group.
*/
public void deleteRosterItem(String username, String itemJID) throws UserNotFoundException, SharedGroupException {
getUser(username);
Roster r = rosterManager.getRoster(username);
JID j = new JID(itemJID);
// No roster item is found. Uncomment the following line to throw
// UserNotFoundException.
// r.getRosterItem(j);
r.deleteRosterItem(j, true);
}
/**
* Returns the the requested user or <tt>null</tt> if there are any problems
* that don't throw an error.
*
* @param username
* the username of the local user to retrieve.
* @return the requested user.
* @throws UserNotFoundException
* if the requested user does not exist in the local server.
*/
private User getUser(String username) throws UserNotFoundException {
JID targetJID = server.createJID(username, null);
// Check that the sender is not requesting information of a remote
// server entity
if (targetJID.getNode() == null) {
// Sender is requesting presence information of an anonymous user
throw new UserNotFoundException("Username is null");
}
return userManager.getUser(targetJID.getNode());
}
/**
* Returns all group names or an empty collection.
*
* @return the all groups
*/
public Collection<String> getAllGroups() {
Collection<Group> groups = GroupManager.getInstance().getGroups();
Collection<String> groupNames = new ArrayList<String>();
for (Group group : groups) {
groupNames.add(group.getName());
}
return groupNames;
}
/**
* Returns all group names or an empty collection for specific user.
*
* @param username the username
* @return the user groups
* @throws UserNotFoundException the user not found exception
*/
public Collection<String> getUserGroups(String username) throws UserNotFoundException {
User user = getUser(username);
Collection<Group> groups = GroupManager.getInstance().getGroups(user);
Collection<String> groupNames = new ArrayList<String>();
for (Group group : groups) {
groupNames.add(group.getName());
}
return groupNames;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/dao/PropertyDAO.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.ws.rs.core.Response;
import org.jivesoftware.database.DbConnectionManager;
import org.jivesoftware.openfire.plugin.rest.exceptions.ExceptionType;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
/**
* The Class PropertyDAO.
*/
public class PropertyDAO {
/** The Constant LOAD_PROPERTY. */
private final static String LOAD_PROPERTY = "SELECT username FROM ofUserProp WHERE name=? AND propValue=?";
/** The Constant LOAD_PROPERTY_BY_KEY. */
private final static String LOAD_PROPERTY_BY_KEY = "SELECT username FROM ofUserProp WHERE name=?";
/**
* Gets the username by property key and or value.
*
* @param propertyName
* the property name
* @param propertyValue
* the property value (can be null)
* @return the username by property
* @throws ServiceException
* the service exception
*/
public static List<String> getUsernameByProperty(String propertyName, String propertyValue) throws ServiceException {
List<String> usernames = new ArrayList<String>();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
con = DbConnectionManager.getConnection();
// Load property by key and value
if (propertyValue != null) {
pstmt = con.prepareStatement(LOAD_PROPERTY);
pstmt.setString(1, propertyName);
pstmt.setString(2, propertyValue);
} else {
// Load property by key
pstmt = con.prepareStatement(LOAD_PROPERTY_BY_KEY);
pstmt.setString(1, propertyName);
}
rs = pstmt.executeQuery();
while (rs.next()) {
usernames.add(rs.getString(1));
}
} catch (SQLException sqle) {
throw new ServiceException("Could not get username by property", propertyName,
ExceptionType.PROPERTY_NOT_FOUND, Response.Status.NOT_FOUND, sqle);
} finally {
DbConnectionManager.closeConnection(rs, pstmt, con);
}
return usernames;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/MUCChannelType.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
public final class MUCChannelType {
public static final String PUBLIC = "public";
public static final String ALL = "all";
private MUCChannelType() {
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/MUCRoomEntities.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "chatRooms")
public class MUCRoomEntities {
List<MUCRoomEntity> mucRooms;
public MUCRoomEntities() {
}
public MUCRoomEntities(List<MUCRoomEntity> mucRooms) {
this.mucRooms = mucRooms;
}
@XmlElement(name = "chatRoom")
public List<MUCRoomEntity> getMucRooms() {
return mucRooms;
}
public void setMucRooms(List<MUCRoomEntity> mucRooms) {
this.mucRooms = mucRooms;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/MUCRoomEntity.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.Date;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlRootElement(name = "chatRoom")
@XmlType(propOrder = { "roomName", "naturalName", "description", "password", "subject", "creationDate",
"modificationDate", "maxUsers", "persistent", "publicRoom", "registrationEnabled", "canAnyoneDiscoverJID",
"canOccupantsChangeSubject", "canOccupantsInvite", "canChangeNickname", "logEnabled",
"loginRestrictedToNickname", "membersOnly", "moderated", "broadcastPresenceRoles", "owners", "admins",
"members", "outcasts" })
public class MUCRoomEntity {
private String roomName;
private String description;
private String password;
private String subject;
private String naturalName;
private int maxUsers;
private Date creationDate;
private Date modificationDate;
private boolean persistent;
private boolean publicRoom;
private boolean registrationEnabled;
private boolean canAnyoneDiscoverJID;
private boolean canOccupantsChangeSubject;
private boolean canOccupantsInvite;
private boolean canChangeNickname;
private boolean logEnabled;
private boolean loginRestrictedToNickname;
private boolean membersOnly;
private boolean moderated;
private List<String> broadcastPresenceRoles;
private List<String> owners;
private List<String> admins;
private List<String> members;
private List<String> outcasts;
public MUCRoomEntity() {
}
public MUCRoomEntity(String naturalName, String roomName, String description) {
this.naturalName = naturalName;
this.roomName = roomName;
this.description = description;
}
@XmlElement
public String getNaturalName() {
return naturalName;
}
public void setNaturalName(String naturalName) {
this.naturalName = naturalName;
}
@XmlElement
public String getRoomName() {
return roomName;
}
public void setRoomName(String roomName) {
this.roomName = roomName;
}
@XmlElement
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@XmlElement
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@XmlElement
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
@XmlElement
public int getMaxUsers() {
return maxUsers;
}
public void setMaxUsers(int maxUsers) {
this.maxUsers = maxUsers;
}
@XmlElement
public Date getCreationDate() {
return creationDate;
}
public void setCreationDate(Date creationDate) {
this.creationDate = creationDate;
}
@XmlElement
public Date getModificationDate() {
return modificationDate;
}
public void setModificationDate(Date modificationDate) {
this.modificationDate = modificationDate;
}
@XmlElement
public boolean isPersistent() {
return persistent;
}
public void setPersistent(boolean persistent) {
this.persistent = persistent;
}
@XmlElement
public boolean isPublicRoom() {
return publicRoom;
}
public void setPublicRoom(boolean publicRoom) {
this.publicRoom = publicRoom;
}
@XmlElement
public boolean isRegistrationEnabled() {
return registrationEnabled;
}
public void setRegistrationEnabled(boolean registrationEnabled) {
this.registrationEnabled = registrationEnabled;
}
@XmlElement
public boolean isCanAnyoneDiscoverJID() {
return canAnyoneDiscoverJID;
}
public void setCanAnyoneDiscoverJID(boolean canAnyoneDiscoverJID) {
this.canAnyoneDiscoverJID = canAnyoneDiscoverJID;
}
@XmlElement
public boolean isCanOccupantsChangeSubject() {
return canOccupantsChangeSubject;
}
public void setCanOccupantsChangeSubject(boolean canOccupantsChangeSubject) {
this.canOccupantsChangeSubject = canOccupantsChangeSubject;
}
@XmlElement
public boolean isCanOccupantsInvite() {
return canOccupantsInvite;
}
public void setCanOccupantsInvite(boolean canOccupantsInvite) {
this.canOccupantsInvite = canOccupantsInvite;
}
public void setBroadcastPresenceRoles(List<String> broadcastPresenceRoles) {
this.broadcastPresenceRoles = broadcastPresenceRoles;
}
@XmlElement
public boolean isCanChangeNickname() {
return canChangeNickname;
}
public void setCanChangeNickname(boolean canChangeNickname) {
this.canChangeNickname = canChangeNickname;
}
@XmlElement
public boolean isLogEnabled() {
return logEnabled;
}
public void setLogEnabled(boolean logEnabled) {
this.logEnabled = logEnabled;
}
@XmlElement
public boolean isLoginRestrictedToNickname() {
return loginRestrictedToNickname;
}
public void setLoginRestrictedToNickname(boolean loginRestrictedToNickname) {
this.loginRestrictedToNickname = loginRestrictedToNickname;
}
@XmlElement
public boolean isMembersOnly() {
return membersOnly;
}
public void setMembersOnly(boolean membersOnly) {
this.membersOnly = membersOnly;
}
@XmlElement
public boolean isModerated() {
return moderated;
}
public void setModerated(boolean moderated) {
this.moderated = moderated;
}
@XmlElement(name = "broadcastPresenceRole")
@XmlElementWrapper(name = "broadcastPresenceRoles")
public List<String> getBroadcastPresenceRoles() {
return broadcastPresenceRoles;
}
@XmlElementWrapper(name = "owners")
@XmlElement(name = "owner")
public List<String> getOwners() {
return owners;
}
public void setOwners(List<String> owners) {
this.owners = owners;
}
@XmlElementWrapper(name = "members")
@XmlElement(name = "member")
public List<String> getMembers() {
return members;
}
public void setMembers(List<String> members) {
this.members = members;
}
@XmlElementWrapper(name = "outcasts")
@XmlElement(name = "outcast")
public List<String> getOutcasts() {
return outcasts;
}
public void setOutcasts(List<String> outcasts) {
this.outcasts = outcasts;
}
@XmlElementWrapper(name = "admins")
@XmlElement(name = "admin")
public List<String> getAdmins() {
return admins;
}
public void setAdmins(List<String> admins) {
this.admins = admins;
}
}
\ No newline at end of file
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/ParticipantEntities.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "participants")
public class ParticipantEntities {
List<ParticipantEntity> participants;
public ParticipantEntities() {
}
public ParticipantEntities(List<ParticipantEntity> participants) {
this.participants = participants;
}
@XmlElement(name = "participant")
public List<ParticipantEntity> getParticipants() {
return participants;
}
public void setParticipants(List<ParticipantEntity> participants) {
this.participants = participants;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/ParticipantEntity.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "participant")
public class ParticipantEntity {
private String jid;
private String role;
private String affiliation;
public ParticipantEntity() {
}
@XmlElement
public String getJid() {
return jid;
}
public void setJid(String jid) {
this.jid = jid;
}
@XmlElement
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
@XmlElement
public String getAffiliation() {
return affiliation;
}
public void setAffiliation(String affiliation) {
this.affiliation = affiliation;
}
}
\ No newline at end of file
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/RosterEntities.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
/**
* The Class RosterEntities.
*/
@XmlRootElement(name = "roster")
public class RosterEntities {
/** The roster. */
List<RosterItemEntity> roster;
/**
* Instantiates a new roster entities.
*/
public RosterEntities() {
}
/**
* Instantiates a new roster entities.
*
* @param roster
* the roster
*/
public RosterEntities(List<RosterItemEntity> roster) {
this.roster = roster;
}
/**
* Gets the roster.
*
* @return the roster
*/
@XmlElement(name = "rosterItem")
public List<RosterItemEntity> getRoster() {
return roster;
}
/**
* Sets the roster.
*
* @param roster
* the new roster
*/
public void setRoster(List<RosterItemEntity> roster) {
this.roster = roster;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/RosterItemEntity.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* The Class RosterItemEntity.
*/
@XmlRootElement(name = "rosterItem")
@XmlType(propOrder = { "jid", "nickname", "subscriptionType", "groups" })
public class RosterItemEntity {
/** The jid. */
private String jid;
/** The nickname. */
private String nickname;
/** The subscription type. */
private int subscriptionType;
/** The groups. */
private List<String> groups;
/**
* Instantiates a new roster item entity.
*/
public RosterItemEntity() {
}
/**
* Instantiates a new roster item entity.
*
* @param jid
* the jid
* @param nickname
* the nickname
* @param subscriptionType
* the subscription type
*/
public RosterItemEntity(String jid, String nickname, int subscriptionType) {
this.jid = jid;
this.nickname = nickname;
this.subscriptionType = subscriptionType;
}
/**
* Gets the jid.
*
* @return the jid
*/
@XmlElement
public String getJid() {
return jid;
}
/**
* Sets the jid.
*
* @param jid
* the new jid
*/
public void setJid(String jid) {
this.jid = jid;
}
/**
* Gets the nickname.
*
* @return the nickname
*/
@XmlElement
public String getNickname() {
return nickname;
}
/**
* Sets the nickname.
*
* @param nickname
* the new nickname
*/
public void setNickname(String nickname) {
this.nickname = nickname;
}
/**
* Gets the subscription type.
*
* @return the subscription type
*/
@XmlElement
public int getSubscriptionType() {
return subscriptionType;
}
/**
* Sets the subscription type.
*
* @param subscriptionType
* the new subscription type
*/
public void setSubscriptionType(int subscriptionType) {
this.subscriptionType = subscriptionType;
}
/**
* Gets the groups.
*
* @return the groups
*/
@XmlElement(name = "group")
@XmlElementWrapper(name = "groups")
public List<String> getGroups() {
return groups;
}
/**
* Sets the groups.
*
* @param groups
* the new groups
*/
public void setGroups(List<String> groups) {
this.groups = groups;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/UserEntities.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
/**
* The Class UserEntities.
*/
@XmlRootElement(name = "users")
public class UserEntities {
/** The users. */
List<UserEntity> users;
/**
* Instantiates a new user entities.
*/
public UserEntities() {
}
/**
* Instantiates a new user entities.
*
* @param users
* the users
*/
public UserEntities(List<UserEntity> users) {
this.users = users;
}
/**
* Gets the users.
*
* @return the users
*/
@XmlElement(name = "user")
public List<UserEntity> getUsers() {
return users;
}
/**
* Sets the users.
*
* @param users
* the new users
*/
public void setUsers(List<UserEntity> users) {
this.users = users;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/UserEntity.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* The Class UserEntity.
*/
@XmlRootElement(name = "user")
@XmlType(propOrder = { "username", "name", "email", "password", "properties" })
public class UserEntity {
/** The username. */
private String username;
/** The name. */
private String name;
/** The email. */
private String email;
/** The password. */
private String password;
/** The properties. */
private List<UserProperty> properties;
/**
* Instantiates a new user entity.
*/
public UserEntity() {
}
/**
* Instantiates a new user entity.
*
* @param username
* the username
* @param name
* the name
* @param email
* the email
*/
public UserEntity(String username, String name, String email) {
this.username = username;
this.name = name;
this.email = email;
}
/**
* Gets the username.
*
* @return the username
*/
@XmlElement
public String getUsername() {
return username;
}
/**
* Sets the username.
*
* @param username
* the new username
*/
public void setUsername(String username) {
this.username = username;
}
/**
* Gets the name.
*
* @return the name
*/
@XmlElement
public String getName() {
return name;
}
/**
* Sets the name.
*
* @param name
* the new name
*/
public void setName(String name) {
this.name = name;
}
/**
* Gets the email.
*
* @return the email
*/
@XmlElement
public String getEmail() {
return email;
}
/**
* Sets the email.
*
* @param email
* the new email
*/
public void setEmail(String email) {
this.email = email;
}
/**
* Gets the password.
*
* @return the password
*/
public String getPassword() {
return password;
}
/**
* Sets the password.
*
* @param password
* the new password
*/
public void setPassword(String password) {
this.password = password;
}
/**
* Gets the properties.
*
* @return the properties
*/
@XmlElement(name = "property")
@XmlElementWrapper(name = "properties")
public List<UserProperty> getProperties() {
return properties;
}
/**
* Sets the properties.
*
* @param properties
* the new properties
*/
public void setProperties(List<UserProperty> properties) {
this.properties = properties;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/UserGroupsEntity.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
/**
* The Class UserGroupsEntity.
*/
@XmlRootElement(name = "groups")
public class UserGroupsEntity {
/** The group names. */
private List<String> groupNames;
/**
* Instantiates a new user groups entity.
*/
public UserGroupsEntity() {
}
/**
* Instantiates a new user groups entity.
*
* @param groupNames
* the group names
*/
public UserGroupsEntity(List<String> groupNames) {
this.groupNames = groupNames;
}
/**
* Gets the group names.
*
* @return the group names
*/
@XmlElement(name = "groupname")
public List<String> getGroupNames() {
return groupNames;
}
/**
* Sets the group names.
*
* @param groupNames
* the new group names
*/
public void setGroupNames(List<String> groupNames) {
this.groupNames = groupNames;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/entity/UserProperty.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.entity;
import javax.xml.bind.annotation.XmlAttribute;
/**
* The Class UserProperty.
*/
public class UserProperty {
/** The key. */
private String key;
/** The value. */
private String value;
/**
* Instantiates a new user property.
*/
public UserProperty() {
}
/**
* Instantiates a new user property.
*
* @param key
* the key
* @param value
* the value
*/
public UserProperty(String key, String value) {
this.key = key;
this.value = value;
}
/**
* Gets the key.
*
* @return the key
*/
@XmlAttribute
public String getKey() {
return key;
}
/**
* Sets the key.
*
* @param key
* the new key
*/
public void setKey(String key) {
this.key = key;
}
/**
* Gets the value.
*
* @return the value
*/
@XmlAttribute
public String getValue() {
return value;
}
/**
* Sets the value.
*
* @param value
* the new value
*/
public void setValue(String value) {
this.value = value;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/exceptions/ExceptionType.java
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.exceptions; package org.jivesoftware.openfire.plugin.rest.exceptions;
/** /**
* The Class ExceptionType. * The Class ExceptionType.
*/ */
public final class ExceptionType { public final class ExceptionType {
/** The Constant PROPERTY_NOT_FOUND. */ /** The Constant ILLEGAL_ARGUMENT_EXCEPTION. */
public static final String PROPERTY_NOT_FOUND = "PropertyNotFoundException"; public static final String ILLEGAL_ARGUMENT_EXCEPTION = "IllegalArgumentException";
/** The Constant ILLEGAL_ARGUMENT_EXCEPTION. */ /** The Constant SHARED_GROUP_EXCEPTION. */
public static final String ILLEGAL_ARGUMENT_EXCEPTION = "IllegalArgumentException"; public static final String SHARED_GROUP_EXCEPTION = "SharedGroupException";
/** /** The Constant PROPERTY_NOT_FOUND. */
* Instantiates a new exception type. public static final String PROPERTY_NOT_FOUND = "PropertyNotFoundException";
*/
private ExceptionType() { /** The Constant USER_ALREADY_EXISTS_EXCEPTION. */
} public static final String USER_ALREADY_EXISTS_EXCEPTION = "UserAlreadyExistsException";
}
/** The Constant USER_NOT_FOUND_EXCEPTION. */
public static final String USER_NOT_FOUND_EXCEPTION = "UserNotFoundException";
/** The Constant GROUP_ALREADY_EXISTS. */
public static final String GROUP_ALREADY_EXISTS = "GroupAlreadyExistsException";
/** The Constant GROUP_NOT_FOUND. */
public static final String GROUP_NOT_FOUND = "GroupNotFoundException";
/** The Constant ROOM_NOT_FOUND. */
public static final String ROOM_NOT_FOUND = "RoomNotFoundException";
/** The Constant NOT_ALLOWED. */
public static final String NOT_ALLOWED = "NotAllowedException";
/**
* Instantiates a new exception type.
*/
private ExceptionType() {
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/RESTExceptionMapper.java → src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/exceptions/RESTExceptionMapper.java
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest; package org.jivesoftware.openfire.plugin.rest.exceptions;
import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper; import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider; import javax.ws.rs.ext.Provider;
import org.jivesoftware.openfire.plugin.rest.exceptions.ErrorResponse; import org.slf4j.Logger;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException; import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; /**
* The Class RESTExceptionMapper.
/** */
* The Class RESTExceptionMapper. @Provider
*/ public class RESTExceptionMapper implements ExceptionMapper<ServiceException> {
@Provider
public class RESTExceptionMapper implements ExceptionMapper<ServiceException> { /** The log. */
private static Logger LOG = LoggerFactory.getLogger(RESTExceptionMapper.class);
/** The log. */
private static Logger LOG = LoggerFactory.getLogger(RESTExceptionMapper.class); /**
* Instantiates a new REST exception mapper.
/** */
* Instantiates a new REST exception mapper. public RESTExceptionMapper() {
*/ }
public RESTExceptionMapper() {
} /*
* (non-Javadoc)
/* *
* (non-Javadoc) * @see javax.ws.rs.ext.ExceptionMapper#toResponse(java.lang.Throwable)
* */
* @see javax.ws.rs.ext.ExceptionMapper#toResponse(java.lang.Throwable) public Response toResponse(ServiceException exception) {
*/ ErrorResponse errorResponse = new ErrorResponse();
public Response toResponse(ServiceException exception) { errorResponse.setRessource(exception.getRessource());
ErrorResponse errorResponse = new ErrorResponse(); errorResponse.setMessage(exception.getMessage());
errorResponse.setRessource(exception.getRessource()); errorResponse.setException(exception.getException());
errorResponse.setMessage(exception.getMessage()); LOG.error(
errorResponse.setException(exception.getException()); exception.getException() + ": " + exception.getMessage() + " with ressource "
LOG.error( + exception.getRessource(), exception.getException());
exception.getException() + ": " + exception.getMessage() + " with ressource " return Response.status(exception.getStatus()).entity(errorResponse).type(MediaType.APPLICATION_XML).build();
+ exception.getRessource(), exception.getException()); }
return Response.status(exception.getStatus()).entity(errorResponse).type(MediaType.APPLICATION_XML).build();
} }
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/JerseyWrapper.java → src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/JerseyWrapper.java
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest; package org.jivesoftware.openfire.plugin.rest.service;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import javax.servlet.ServletConfig; import javax.servlet.ServletConfig;
import javax.servlet.ServletException; import javax.servlet.ServletException;
import org.jivesoftware.admin.AuthCheckFilter; import org.jivesoftware.admin.AuthCheckFilter;
import org.jivesoftware.openfire.plugin.rest.service.RestAPIService; import org.jivesoftware.openfire.plugin.rest.exceptions.RESTExceptionMapper;
import com.sun.jersey.api.core.PackagesResourceConfig; import com.sun.jersey.api.core.PackagesResourceConfig;
import com.sun.jersey.spi.container.servlet.ServletContainer; import com.sun.jersey.spi.container.servlet.ServletContainer;
/** /**
* The Class JerseyWrapper. * The Class JerseyWrapper.
*/ */
public class JerseyWrapper extends ServletContainer { public class JerseyWrapper extends ServletContainer {
/** The Constant AUTHFILTER. */ /** The Constant AUTHFILTER. */
private static final String AUTHFILTER = "org.jivesoftware.openfire.plugin.rest.AuthFilter"; private static final String AUTHFILTER = "org.jivesoftware.openfire.plugin.rest.AuthFilter";
/** The Constant CONTAINER_REQUEST_FILTERS. */ /** The Constant CONTAINER_REQUEST_FILTERS. */
private static final String CONTAINER_REQUEST_FILTERS = "com.sun.jersey.spi.container.ContainerRequestFilters"; private static final String CONTAINER_REQUEST_FILTERS = "com.sun.jersey.spi.container.ContainerRequestFilters";
/** The Constant RESOURCE_CONFIG_CLASS_KEY. */ /** The Constant RESOURCE_CONFIG_CLASS_KEY. */
private static final String RESOURCE_CONFIG_CLASS_KEY = "com.sun.jersey.config.property.resourceConfigClass"; private static final String RESOURCE_CONFIG_CLASS_KEY = "com.sun.jersey.config.property.resourceConfigClass";
/** The Constant RESOURCE_CONFIG_CLASS. */ /** The Constant RESOURCE_CONFIG_CLASS. */
private static final String RESOURCE_CONFIG_CLASS = "com.sun.jersey.api.core.PackagesResourceConfig"; private static final String RESOURCE_CONFIG_CLASS = "com.sun.jersey.api.core.PackagesResourceConfig";
/** The Constant SCAN_PACKAGE_DEFAULT. */ /** The Constant SCAN_PACKAGE_DEFAULT. */
private static final String SCAN_PACKAGE_DEFAULT = JerseyWrapper.class.getPackage().getName(); private static final String SCAN_PACKAGE_DEFAULT = JerseyWrapper.class.getPackage().getName();
/** The Constant serialVersionUID. */ /** The Constant serialVersionUID. */
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** The Constant SERVLET_URL. */ /** The Constant SERVLET_URL. */
private static final String SERVLET_URL = "restapi/*"; private static final String SERVLET_URL = "restapi/*";
/** The config. */ /** The config. */
private static Map<String, Object> config; private static Map<String, Object> config;
/** The prc. */ /** The prc. */
private static PackagesResourceConfig prc; private static PackagesResourceConfig prc;
static { static {
config = new HashMap<String, Object>(); config = new HashMap<String, Object>();
config.put(RESOURCE_CONFIG_CLASS_KEY, RESOURCE_CONFIG_CLASS); config.put(RESOURCE_CONFIG_CLASS_KEY, RESOURCE_CONFIG_CLASS);
prc = new PackagesResourceConfig(SCAN_PACKAGE_DEFAULT); prc = new PackagesResourceConfig(SCAN_PACKAGE_DEFAULT);
prc.setPropertiesAndFeatures(config); prc.setPropertiesAndFeatures(config);
prc.getProperties().put(CONTAINER_REQUEST_FILTERS, AUTHFILTER); prc.getProperties().put(CONTAINER_REQUEST_FILTERS, AUTHFILTER);
prc.getClasses().add(RestAPIService.class); prc.getClasses().add(RestAPIService.class);
prc.getClasses().add(RESTExceptionMapper.class); prc.getClasses().add(MUCRoomService.class);
} prc.getClasses().add(MUCRoomOwnersService.class);
prc.getClasses().add(MUCRoomAdminsService.class);
/** prc.getClasses().add(MUCRoomMembersService.class);
* Instantiates a new jersey wrapper. prc.getClasses().add(MUCRoomOutcastsService.class);
*/
public JerseyWrapper() { prc.getClasses().add(UserServiceLegacy.class);
super(prc); prc.getClasses().add(UserService.class);
} prc.getClasses().add(UserRosterService.class);
prc.getClasses().add(UserGroupService.class);
/* prc.getClasses().add(UserLockoutService.class);
* (non-Javadoc)
* prc.getClasses().add(RESTExceptionMapper.class);
* @see javax.servlet.GenericServlet#init(javax.servlet.ServletConfig) }
*/
@Override /**
public void init(ServletConfig servletConfig) throws ServletException { * Instantiates a new jersey wrapper.
super.init(servletConfig); */
// Exclude this servlet from requering the user to login public JerseyWrapper() {
AuthCheckFilter.addExclude(SERVLET_URL); super(prc);
} }
/* /*
* (non-Javadoc) * (non-Javadoc)
* *
* @see com.sun.jersey.spi.container.servlet.ServletContainer#destroy() * @see javax.servlet.GenericServlet#init(javax.servlet.ServletConfig)
*/ */
@Override @Override
public void destroy() { public void init(ServletConfig servletConfig) throws ServletException {
super.destroy(); super.init(servletConfig);
// Release the excluded URL // Exclude this servlet from requering the user to login
AuthCheckFilter.removeExclude(SERVLET_URL); AuthCheckFilter.addExclude(SERVLET_URL);
} }
}
/*
* (non-Javadoc)
*
* @see com.sun.jersey.spi.container.servlet.ServletContainer#destroy()
*/
@Override
public void destroy() {
super.destroy();
// Release the excluded URL
AuthCheckFilter.removeExclude(SERVLET_URL);
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/MUCRoomAdminsService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.plugin.rest.controller.MUCRoomController;
@Path("restapi/v1/chatrooms/{roomName}/admins")
public class MUCRoomAdminsService {
@POST
@Path("/{jid}")
public Response addMUCRoomAdmin(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("jid") String jid, @PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().addAdmin(serviceName, roomName, jid);
return Response.status(Status.CREATED).build();
}
@DELETE
@Path("/{jid}")
public Response deleteMUCRoomAdmin(@PathParam("jid") String jid,
@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().deleteAffiliation(serviceName, roomName, jid);
return Response.status(Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/MUCRoomMembersService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.plugin.rest.controller.MUCRoomController;
@Path("restapi/v1/chatrooms/{roomName}/members")
public class MUCRoomMembersService {
@POST
@Path("/{jid}")
public Response addMUCRoomMember(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("jid") String jid, @PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().addMember(serviceName, roomName, jid);
return Response.status(Status.CREATED).build();
}
@DELETE
@Path("/{jid}")
public Response deleteMUCRoomMember(@PathParam("jid") String jid,
@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().deleteAffiliation(serviceName, roomName, jid);
return Response.status(Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/MUCRoomOutcastsService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.plugin.rest.controller.MUCRoomController;
@Path("restapi/v1/chatrooms/{roomName}/outcasts")
public class MUCRoomOutcastsService {
@POST
@Path("/{jid}")
public Response addMUCRoomOutcast(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("jid") String jid, @PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().addOutcast(serviceName, roomName, jid);
return Response.status(Status.CREATED).build();
}
@DELETE
@Path("/{jid}")
public Response deleteMUCRoomOutcast(@PathParam("jid") String jid,
@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().deleteAffiliation(serviceName, roomName, jid);
return Response.status(Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/MUCRoomOwnersService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.plugin.rest.controller.MUCRoomController;
@Path("restapi/v1/chatrooms/{roomName}/owners")
public class MUCRoomOwnersService {
@POST
@Path("/{jid}")
public Response addMUCRoomOwner(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("jid") String jid, @PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().addOwner(serviceName, roomName, jid);
return Response.status(Status.CREATED).build();
}
@DELETE
@Path("/{jid}")
public Response deleteMUCRoomOwner(@PathParam("jid") String jid,
@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@PathParam("roomName") String roomName) throws ServiceException {
MUCRoomController.getInstance().deleteAffiliation(serviceName, roomName, jid);
return Response.status(Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/MUCRoomService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.jivesoftware.openfire.plugin.rest.entity.MUCChannelType;
import org.jivesoftware.openfire.plugin.rest.entity.MUCRoomEntities;
import org.jivesoftware.openfire.plugin.rest.entity.MUCRoomEntity;
import org.jivesoftware.openfire.plugin.rest.entity.ParticipantEntities;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.plugin.rest.controller.MUCRoomController;
@Path("restapi/v1/chatrooms")
public class MUCRoomService {
@GET
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public MUCRoomEntities getMUCRooms(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
@DefaultValue(MUCChannelType.PUBLIC) @QueryParam("type") String channelType,
@QueryParam("search") String roomSearch) {
return MUCRoomController.getInstance().getChatRooms(serviceName, channelType, roomSearch);
}
@GET
@Path("/{roomName}")
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public MUCRoomEntity getMUCRoomJSON2(@PathParam("roomName") String roomName,
@DefaultValue("conference") @QueryParam("servicename") String serviceName) throws ServiceException {
return MUCRoomController.getInstance().getChatRoom(roomName, serviceName);
}
@DELETE
@Path("/{roomName}")
public Response deleteMUCRoom(@PathParam("roomName") String roomName,
@DefaultValue("conference") @QueryParam("servicename") String serviceName) throws ServiceException {
MUCRoomController.getInstance().deleteChatRoom(roomName, serviceName);
return Response.status(Status.OK).build();
}
@POST
public Response createMUCRoom(@DefaultValue("conference") @QueryParam("servicename") String serviceName,
MUCRoomEntity mucRoomEntity) throws ServiceException {
MUCRoomController.getInstance().createChatRoom(serviceName, mucRoomEntity);
return Response.status(Status.CREATED).build();
}
@PUT
@Path("/{roomName}")
public Response udpateMUCRoom(@PathParam("roomName") String roomName,
@DefaultValue("conference") @QueryParam("servicename") String serviceName, MUCRoomEntity mucRoomEntity)
throws ServiceException {
MUCRoomController.getInstance().updateChatRoom(roomName, serviceName, mucRoomEntity);
return Response.status(Status.OK).build();
}
@GET
@Path("/{roomName}/participants")
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public ParticipantEntities getMUCRoomParticipants(@PathParam("roomName") String roomName,
@DefaultValue("conference") @QueryParam("servicename") String serviceName) {
return MUCRoomController.getInstance().getRoomParticipants(roomName, serviceName);
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/RestAPIService.java
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service; package org.jivesoftware.openfire.plugin.rest.service;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import javax.ws.rs.DELETE; import javax.ws.rs.DELETE;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.POST; import javax.ws.rs.POST;
import javax.ws.rs.PUT; import javax.ws.rs.PUT;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.plugin.rest.RESTServicePlugin; import org.jivesoftware.openfire.plugin.rest.RESTServicePlugin;
import org.jivesoftware.openfire.plugin.rest.entity.SystemProperties; import org.jivesoftware.openfire.plugin.rest.entity.SystemProperties;
import org.jivesoftware.openfire.plugin.rest.entity.SystemProperty; import org.jivesoftware.openfire.plugin.rest.entity.SystemProperty;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException; import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
@Path("restapi/system/properties") @Path("restapi/v1/system/properties")
public class RestAPIService { public class RestAPIService {
private RESTServicePlugin plugin; private RESTServicePlugin plugin;
@PostConstruct @PostConstruct
public void init() { public void init() {
plugin = RESTServicePlugin.getInstance(); plugin = RESTServicePlugin.getInstance();
} }
@GET @GET
@Produces(MediaType.APPLICATION_XML) @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public SystemProperties getSystemProperties() { public SystemProperties getSystemProperties() {
return plugin.getSystemProperties(); return plugin.getSystemProperties();
} }
@GET @GET
@Path("/{propertyKey}") @Path("/{propertyKey}")
@Produces(MediaType.APPLICATION_XML) @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public SystemProperty getSystemProperty(@PathParam("propertyKey") String propertyKey) throws ServiceException { public SystemProperty getSystemProperty(@PathParam("propertyKey") String propertyKey) throws ServiceException {
return plugin.getSystemProperty(propertyKey); return plugin.getSystemProperty(propertyKey);
} }
@POST @POST
public Response createSystemProperty(SystemProperty systemProperty) throws ServiceException { public Response createSystemProperty(SystemProperty systemProperty) throws ServiceException {
plugin.createSystemProperty(systemProperty); plugin.createSystemProperty(systemProperty);
return Response.status(Response.Status.CREATED).build(); return Response.status(Response.Status.CREATED).build();
} }
@PUT @PUT
@Path("/{propertyKey}") @Path("/{propertyKey}")
public Response updateUser(@PathParam("propertyKey") String propertyKey, SystemProperty systemProperty) throws ServiceException { public Response updateUser(@PathParam("propertyKey") String propertyKey, SystemProperty systemProperty) throws ServiceException {
plugin.updateSystemProperty(propertyKey, systemProperty); plugin.updateSystemProperty(propertyKey, systemProperty);
return Response.status(Response.Status.OK).build(); return Response.status(Response.Status.OK).build();
} }
@DELETE @DELETE
@Path("/{propertyKey}") @Path("/{propertyKey}")
public Response deleteUser(@PathParam("propertyKey") String propertyKey) throws ServiceException { public Response deleteUser(@PathParam("propertyKey") String propertyKey) throws ServiceException {
plugin.deleteSystemProperty(propertyKey); plugin.deleteSystemProperty(propertyKey);
return Response.status(Response.Status.OK).build(); return Response.status(Response.Status.OK).build();
} }
} }
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/UserGroupService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.annotation.PostConstruct;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.plugin.rest.controller.UserServiceController;
import org.jivesoftware.openfire.plugin.rest.entity.UserGroupsEntity;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
@Path("restapi/v1/users/{username}/groups")
public class UserGroupService {
private UserServiceController plugin;
@PostConstruct
public void init() {
plugin = UserServiceController.getInstance();
}
@GET
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public UserGroupsEntity getUserGroups(@PathParam("username") String username) throws ServiceException {
return new UserGroupsEntity(plugin.getUserGroups(username));
}
@POST
public Response addUserToGroups(@PathParam("username") String username, UserGroupsEntity userGroupsEntity)
throws ServiceException {
plugin.addUserToGroups(username, userGroupsEntity);
return Response.status(Response.Status.CREATED).build();
}
@DELETE
public Response deleteUserFromGroups(@PathParam("username") String username, UserGroupsEntity userGroupsEntity)
throws ServiceException {
plugin.deleteUserFromGroups(username, userGroupsEntity);
return Response.status(Response.Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/UserLockoutService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.annotation.PostConstruct;
import javax.ws.rs.DELETE;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.plugin.rest.controller.UserServiceController;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
@Path("restapi/v1/lockouts")
public class UserLockoutService {
private UserServiceController plugin;
@PostConstruct
public void init() {
plugin = UserServiceController.getInstance();
}
@POST
@Path("/{username}")
public Response disableUser(@PathParam("username") String username) throws ServiceException {
plugin.disableUser(username);
return Response.status(Response.Status.CREATED).build();
}
@DELETE
@Path("/{username}")
public Response enableUser(@PathParam("username") String username) throws ServiceException {
plugin.enableUser(username);
return Response.status(Response.Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/UserRosterService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.annotation.PostConstruct;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.SharedGroupException;
import org.jivesoftware.openfire.plugin.rest.controller.UserServiceController;
import org.jivesoftware.openfire.plugin.rest.entity.RosterEntities;
import org.jivesoftware.openfire.plugin.rest.entity.RosterItemEntity;
import org.jivesoftware.openfire.plugin.rest.exceptions.ExceptionType;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
import org.jivesoftware.openfire.user.UserAlreadyExistsException;
import org.jivesoftware.openfire.user.UserNotFoundException;
@Path("restapi/v1/users/{username}/roster")
public class UserRosterService {
private static final String COULD_NOT_UPDATE_THE_ROSTER = "Could not update the roster";
private static final String COULD_NOT_CREATE_ROSTER_ITEM = "Could not create roster item";
private UserServiceController plugin;
@PostConstruct
public void init() {
plugin = UserServiceController.getInstance();
}
@GET
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public RosterEntities getUserRoster(@PathParam("username") String username) throws ServiceException {
return plugin.getRosterEntities(username);
}
@POST
public Response createRoster(@PathParam("username") String username, RosterItemEntity rosterItemEntity)
throws ServiceException {
try {
plugin.addRosterItem(username, rosterItemEntity);
} catch (UserNotFoundException e) {
throw new ServiceException(COULD_NOT_CREATE_ROSTER_ITEM, "", ExceptionType.USER_NOT_FOUND_EXCEPTION,
Response.Status.NOT_FOUND, e);
} catch (UserAlreadyExistsException e) {
throw new ServiceException(COULD_NOT_CREATE_ROSTER_ITEM, "", ExceptionType.USER_ALREADY_EXISTS_EXCEPTION,
Response.Status.BAD_REQUEST, e);
} catch (SharedGroupException e) {
throw new ServiceException(COULD_NOT_CREATE_ROSTER_ITEM, "", ExceptionType.SHARED_GROUP_EXCEPTION,
Response.Status.BAD_REQUEST, e);
}
return Response.status(Response.Status.CREATED).build();
}
@DELETE
@Path("/{rosterJid}")
public Response deleteRoster(@PathParam("username") String username, @PathParam("rosterJid") String rosterJid)
throws ServiceException {
try {
plugin.deleteRosterItem(username, rosterJid);
} catch (SharedGroupException e) {
throw new ServiceException("Could not delete the roster item", rosterJid,
ExceptionType.SHARED_GROUP_EXCEPTION, Response.Status.BAD_REQUEST, e);
}
return Response.status(Response.Status.OK).build();
}
@PUT
@Path("/{rosterJid}")
public Response updateRoster(@PathParam("username") String username, @PathParam("rosterJid") String rosterJid,
RosterItemEntity rosterItemEntity) throws ServiceException {
try {
plugin.updateRosterItem(username, rosterJid, rosterItemEntity);
} catch (UserNotFoundException e) {
throw new ServiceException(COULD_NOT_UPDATE_THE_ROSTER, rosterJid, ExceptionType.USER_NOT_FOUND_EXCEPTION,
Response.Status.NOT_FOUND, e);
} catch (SharedGroupException e) {
throw new ServiceException(COULD_NOT_UPDATE_THE_ROSTER, rosterJid, ExceptionType.SHARED_GROUP_EXCEPTION,
Response.Status.BAD_REQUEST, e);
} catch (UserAlreadyExistsException e) {
throw new ServiceException(COULD_NOT_UPDATE_THE_ROSTER, rosterJid,
ExceptionType.USER_ALREADY_EXISTS_EXCEPTION, Response.Status.BAD_REQUEST, e);
}
return Response.status(Response.Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/UserService.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import javax.annotation.PostConstruct;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.jivesoftware.openfire.plugin.rest.controller.UserServiceController;
import org.jivesoftware.openfire.plugin.rest.entity.UserEntities;
import org.jivesoftware.openfire.plugin.rest.entity.UserEntity;
import org.jivesoftware.openfire.plugin.rest.exceptions.ServiceException;
@Path("restapi/v1/users")
public class UserService {
private UserServiceController plugin;
@PostConstruct
public void init() {
plugin = UserServiceController.getInstance();
}
@GET
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public UserEntities getUsers(@QueryParam("search") String userSearch,
@QueryParam("propertyKey") String propertyKey, @QueryParam("propertyValue") String propertyValue)
throws ServiceException {
return plugin.getUserEntities(userSearch, propertyKey, propertyValue);
}
@POST
public Response createUser(UserEntity userEntity) throws ServiceException {
plugin.createUser(userEntity);
return Response.status(Response.Status.CREATED).build();
}
@GET
@Path("/{username}")
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public UserEntity getUser(@PathParam("username") String username) throws ServiceException {
return plugin.getUserEntity(username);
}
@PUT
@Path("/{username}")
public Response updateUser(@PathParam("username") String username, UserEntity userEntity) throws ServiceException {
plugin.updateUser(username, userEntity);
return Response.status(Response.Status.OK).build();
}
@DELETE
@Path("/{username}")
public Response deleteUser(@PathParam("username") String username) throws ServiceException {
plugin.deleteUser(username);
return Response.status(Response.Status.OK).build();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/service/UserServiceLegacy.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.service;
import gnu.inet.encoding.Stringprep;
import java.io.IOException;
import java.io.PrintWriter;
import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;
import org.apache.log4j.Logger;
import org.jivesoftware.openfire.SharedGroupException;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.plugin.rest.RESTServicePlugin;
import org.jivesoftware.openfire.plugin.rest.controller.UserServiceLegacyController;
import org.jivesoftware.openfire.user.UserAlreadyExistsException;
import org.jivesoftware.openfire.user.UserNotFoundException;
import org.xmpp.packet.JID;
@Path("restapi/v1")
public class UserServiceLegacy {
private static Logger Log = Logger.getLogger(UserServiceLegacy.class);
@Context
private HttpServletRequest request;
@Context
private HttpServletResponse response;
private RESTServicePlugin plugin;
private UserServiceLegacyController userServiceController;
@PostConstruct
public void init() {
plugin = (RESTServicePlugin) XMPPServer.getInstance().getPluginManager()
.getPlugin("restapi");
userServiceController = UserServiceLegacyController.getInstance();
}
@POST
@Path("/userservice")
public void userSerivcePostRequest() throws IOException {
userSerivceRequest();
}
@GET
@Path("/userservice")
public Response userSerivceRequest() throws IOException {
// Printwriter for writing out responses to browser
PrintWriter out = response.getWriter();
if (!plugin.getAllowedIPs().isEmpty()) {
// Get client's IP address
String ipAddress = request.getHeader("x-forwarded-for");
if (ipAddress == null) {
ipAddress = request.getHeader("X_FORWARDED_FOR");
if (ipAddress == null) {
ipAddress = request.getHeader("X-Forward-For");
if (ipAddress == null) {
ipAddress = request.getRemoteAddr();
}
}
}
if (!plugin.getAllowedIPs().contains(ipAddress)) {
Log.warn("User service rejected service to IP address: " + ipAddress);
replyError("RequestNotAuthorised", response, out);
return Response.status(200).build();
}
}
String username = request.getParameter("username");
String password = request.getParameter("password");
String name = request.getParameter("name");
String email = request.getParameter("email");
String type = request.getParameter("type");
String secret = request.getParameter("secret");
String groupNames = request.getParameter("groups");
String item_jid = request.getParameter("item_jid");
String sub = request.getParameter("subscription");
// No defaults, add, delete, update only
// type = type == null ? "image" : type;
// Check that our plugin is enabled.
if (!plugin.isEnabled()) {
Log.warn("User service plugin is disabled: " + request.getQueryString());
replyError("UserServiceDisabled", response, out);
return Response.status(200).build();
}
// Check this request is authorised
if (secret == null || !secret.equals(plugin.getSecret())) {
Log.warn("An unauthorised user service request was received: " + request.getQueryString());
replyError("RequestNotAuthorised", response, out);
return Response.status(200).build();
}
// Some checking is required on the username
if (username == null && !"grouplist".equals(type)) {
replyError("IllegalArgumentException", response, out);
return Response.status(200).build();
}
if ((type.equals("add_roster") || type.equals("update_roster") || type.equals("delete_roster"))
&& (item_jid == null || !(sub == null || sub.equals("-1") || sub.equals("0") || sub.equals("1")
|| sub.equals("2") || sub.equals("3")))) {
replyError("IllegalArgumentException", response, out);
return Response.status(200).build();
}
// Check the request type and process accordingly
try {
if ("grouplist".equals(type)) {
String message = "";
for (String groupname : userServiceController.getAllGroups()) {
message += "<groupname>" + groupname + "</groupname>";
}
replyMessage(message, response, out);
} else {
username = username.trim().toLowerCase();
username = JID.escapeNode(username);
username = Stringprep.nodeprep(username);
if ("add".equals(type)) {
userServiceController.createUser(username, password, name, email, groupNames);
replyMessage("ok", response, out);
} else if ("delete".equals(type)) {
userServiceController.deleteUser(username);
replyMessage("ok", response, out);
} else if ("enable".equals(type)) {
userServiceController.enableUser(username);
replyMessage("ok", response, out);
} else if ("disable".equals(type)) {
userServiceController.disableUser(username);
replyMessage("ok", response, out);
} else if ("update".equals(type)) {
userServiceController.updateUser(username, password, name, email, groupNames);
replyMessage("ok", response, out);
} else if ("add_roster".equals(type)) {
userServiceController.addRosterItem(username, item_jid, name, sub, groupNames);
replyMessage("ok", response, out);
} else if ("update_roster".equals(type)) {
userServiceController.updateRosterItem(username, item_jid, name, sub, groupNames);
replyMessage("ok", response, out);
} else if ("delete_roster".equals(type)) {
userServiceController.deleteRosterItem(username, item_jid);
replyMessage("ok", response, out);
} else if ("usergrouplist".equals(type)) {
String message = "";
for (String groupname : userServiceController.getUserGroups(username)) {
message += "<groupname>" + groupname + "</groupname>";
}
replyMessage(message, response, out);
} else {
Log.warn("The userService servlet received an invalid request of type: " + type);
// TODO Do something
}
}
} catch (UserAlreadyExistsException e) {
replyError("UserAlreadyExistsException", response, out);
} catch (UserNotFoundException e) {
replyError("UserNotFoundException", response, out);
} catch (IllegalArgumentException e) {
replyError("IllegalArgumentException", response, out);
} catch (SharedGroupException e) {
replyError("SharedGroupException", response, out);
} catch (Exception e) {
Log.error("Error: ", e);
replyError(e.toString(), response, out);
}
return Response.status(200).build();
}
private void replyMessage(String message, HttpServletResponse response, PrintWriter out) {
response.setContentType("text/xml");
out.println("<result>" + message + "</result>");
out.flush();
}
private void replyError(String error, HttpServletResponse response, PrintWriter out) {
response.setContentType("text/xml");
out.println("<error>" + error + "</error>");
out.flush();
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/utils/MUCRoomUtils.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.utils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.xmpp.packet.JID;
/**
* The Class MUCRoomUtils.
*/
public class MUCRoomUtils {
/**
* Instantiates a new MUC room utils.
*/
private MUCRoomUtils() {
throw new AssertionError();
}
/**
* Convert jids to string list.
*
* @param jids
* the jids
* @return the array list< string>
*/
public static List<String> convertJIDsToStringList(Collection<JID> jids) {
List<String> result = new ArrayList<String>();
for (JID jid : jids) {
result.add(jid.toBareJID());
}
return result;
}
/**
* Convert strings to jids.
*
* @param jids
* the jids
* @return the list<jid>
*/
public static List<JID> convertStringsToJIDs(List<String> jids) {
List<JID> result = new ArrayList<JID>();
for (String jidString : jids) {
result.add(new JID(jidString));
}
return result;
}
}
src/plugins/restAPI/src/java/org/jivesoftware/openfire/plugin/rest/utils/UserUtils.java 0 → 100644
View file @ 4c2804b6
package org.jivesoftware.openfire.plugin.rest.utils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.plugin.rest.entity.UserEntity;
import org.jivesoftware.openfire.plugin.rest.entity.UserProperty;
import org.jivesoftware.openfire.user.User;
import org.jivesoftware.openfire.user.UserAlreadyExistsException;
import org.xmpp.packet.JID;
// TODO: Auto-generated Javadoc
/**
* The Class UserUtils.
*/
public class UserUtils {
/**
* Instantiates a new user utils.
*/
private UserUtils() {
throw new AssertionError();
}
/**
* Convert users to user entities.
*
* @param users the users
* @param userSearch the user search
* @return the list
*/
public static List<UserEntity> convertUsersToUserEntities(Collection<User> users, String userSearch) {
List<UserEntity> result = new ArrayList<UserEntity>();
for (User user : users) {
if (userSearch != null) {
if (!user.getUsername().contains(userSearch)) {
continue;
}
}
result.add(convertUserToUserEntity(user));
}
return result;
}
/**
* Convert user to user entity.
*
* @param user
* the user
* @return the user entity
*/
public static UserEntity convertUserToUserEntity(User user) {
UserEntity userEntity = new UserEntity(user.getUsername(), user.getName(), user.getEmail());
List<UserProperty> userProperties = new ArrayList<UserProperty>();
for (Entry<String, String> property : user.getProperties().entrySet()) {
userProperties.add(new UserProperty(property.getKey(), property.getValue()));
}
userEntity.setProperties(userProperties);
return userEntity;
}
/**
* Checks if is valid sub type.
*
* @param subType the sub type
* @return true, if is valid sub type
* @throws UserAlreadyExistsException the user already exists exception
*/
public static void checkSubType(int subType) throws UserAlreadyExistsException {
if (!(subType >= -1 && subType <= 3)) {
throw new UserAlreadyExistsException();
}
}
/**
* Check and get jid.
*
* @param jid the jid
* @return the jid
*/
public static JID checkAndGetJID(String jid) {
if(isValidBareJid(jid)) {
return new JID(jid);
} else {
return XMPPServer.getInstance().createJID(jid, null);
}
}
/**
* Checks if is valid bare jid.
*
* @param jid the jid
* @return true, if is valid bare jid
*/
public static boolean isValidBareJid(String jid) {
final int index = jid.indexOf('@');
if (index == -1) {
return false;
} else if (jid.indexOf('@', index + 1) != -1) {
return false;
}
return true;
}
}
src/plugins/restAPI/src/web/WEB-INF/web-custom.xml
View file @ 4c2804b6
<?xml version='1.0' encoding='ISO-8859-1'?> <?xml version='1.0' encoding='ISO-8859-1'?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app> <web-app>
<!-- Servlets --> <!-- Servlets -->
<servlet> <servlet>
<servlet-name>JerseyWrapper</servlet-name> <servlet-name>JerseyWrapper</servlet-name>
<servlet-class>org.jivesoftware.openfire.plugin.rest.JerseyWrapper</servlet-class> <servlet-class>org.jivesoftware.openfire.plugin.rest.service.JerseyWrapper</servlet-class>
</servlet> </servlet>
<!-- Servlet mappings --> <!-- Servlet mappings -->
<servlet-mapping> <servlet-mapping>
<servlet-name>JerseyWrapper</servlet-name> <servlet-name>JerseyWrapper</servlet-name>
<url-pattern>/system/*</url-pattern> <url-pattern>/v1/*</url-pattern>
</servlet-mapping> </servlet-mapping>
</web-app>
</web-app>
src/plugins/restAPI/src/web/rest-api.jsp
View file @ 4c2804b6
<%@ page import="java.util.*, <%@ page
org.jivesoftware.openfire.XMPPServer, import="java.util.*,
org.jivesoftware.util.*,org.jivesoftware.openfire.plugin.rest.RESTServicePlugin" org.jivesoftware.openfire.XMPPServer,
errorPage="error.jsp" org.jivesoftware.util.*,org.jivesoftware.openfire.plugin.rest.RESTServicePlugin"
%> errorPage="error.jsp"%>
<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %> <%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c"%>
<%@ taglib uri="http://java.sun.com/jstl/fmt_rt" prefix="fmt" %> <%@ taglib uri="http://java.sun.com/jstl/fmt_rt" prefix="fmt"%>
<%-- Define Administration Bean --%> <%-- Define Administration Bean --%>
<jsp:useBean id="admin" class="org.jivesoftware.util.WebManager" /> <jsp:useBean id="admin" class="org.jivesoftware.util.WebManager" />
<c:set var="admin" value="${admin.manager}" /> <c:set var="admin" value="${admin.manager}" />
<% <%
admin.init(request, response, session, application, out ); admin.init(request, response, session, application, out);
%> %>
<% <%
// Get parameters // Get parameters
boolean save = request.getParameter("save") != null; boolean save = request.getParameter("save") != null;
boolean success = request.getParameter("success") != null; boolean success = request.getParameter("success") != null;
String secret = ParamUtils.getParameter(request, "secret"); String secret = ParamUtils.getParameter(request, "secret");
boolean enabled = ParamUtils.getBooleanParameter(request, "enabled"); boolean enabled = ParamUtils.getBooleanParameter(request, "enabled");
boolean httpBasicAuth = ParamUtils.getBooleanParameter(request, "authtype"); boolean httpBasicAuth = ParamUtils.getBooleanParameter(request, "authtype");
String allowedIPs = ParamUtils.getParameter(request, "allowedIPs"); String allowedIPs = ParamUtils.getParameter(request, "allowedIPs");
RESTServicePlugin plugin = (RESTServicePlugin) XMPPServer.getInstance().getPluginManager().getPlugin("restapi"); RESTServicePlugin plugin = (RESTServicePlugin) XMPPServer.getInstance().getPluginManager()
.getPlugin("restapi");
// Handle a save
Map errors = new HashMap(); // Handle a save
if (save) { Map errors = new HashMap();
if (errors.size() == 0) { if (save) {
plugin.setEnabled(enabled); if (errors.size() == 0) {
plugin.setSecret(secret); plugin.setEnabled(enabled);
plugin.setHttpBasicAuth(httpBasicAuth); plugin.setSecret(secret);
plugin.setAllowedIPs(StringUtils.stringToCollection(allowedIPs)); plugin.setHttpBasicAuth(httpBasicAuth);
response.sendRedirect("rest-api.jsp?success=true"); plugin.setAllowedIPs(StringUtils.stringToCollection(allowedIPs));
return; response.sendRedirect("rest-api.jsp?success=true");
} return;
} }
}
secret = plugin.getSecret();
enabled = plugin.isEnabled(); secret = plugin.getSecret();
httpBasicAuth = plugin.isHttpBasicAuth(); enabled = plugin.isEnabled();
allowedIPs = StringUtils.collectionToString(plugin.getAllowedIPs()); httpBasicAuth = plugin.isHttpBasicAuth();
%> allowedIPs = StringUtils.collectionToString(plugin.getAllowedIPs());
%>
<html>
<head> <html>
<title>REST API Properties</title> <head>
<meta name="pageID" content="rest-api"/> <title>REST API Properties</title>
</head> <meta name="pageID" content="rest-api" />
<body> </head>
<body>
<p> <p>Use the form below to enable or disable the REST API and
Use the form below to enable or disable the REST API and configure the authentication. configure the authentication.</p>
</p>
<%
<% if (success) { %> if (success) {
%>
<div class="jive-success">
<table cellpadding="0" cellspacing="0" border="0"> <div class="jive-success">
<tbody> <table cellpadding="0" cellspacing="0" border="0">
<tr><td class="jive-icon"><img src="images/success-16x16.gif" width="16" height="16" border="0"></td> <tbody>
<td class="jive-icon-label"> <tr>
REST API properties edited successfully. <td class="jive-icon"><img src="images/success-16x16.gif"
</td></tr> width="16" height="16" border="0"></td>
</tbody> <td class="jive-icon-label">REST API properties edited
</table> successfully.</td>
</div><br> </tr>
<% } %> </tbody>
</table>
<form action="rest-api.jsp?save" method="post"> </div>
<br>
<fieldset> <%
<legend>REST API</legend> }
<div> %>
<p>
The addition, deletion and editing of Openfire system properties is not normally available outside of the admin console. <form action="rest-api.jsp?save" method="post">
This service lets those administration tasks be performed HTTP requests to provide
simple integration with other applications.</p> <fieldset>
<legend>REST API</legend>
<p>The REST API can be secured with a shared secret key defined below or a with HTTP basic authentication. <div>
Moreover, for extra security you can specify the list of IP addresses that are allowed to <p>
use this service. An empty list means that the service can be accessed from any The REST API can be secured with a shared secret key defined below
location. Addresses are delimited by commas. or a with HTTP basic authentication.<br />Moreover, for extra
</p> security you can specify the list of IP addresses that are allowed
<ul> to use this service.<br />An empty list means that the service can
<input type="radio" name="enabled" value="true" id="rb01" be accessed from any location. Addresses are delimited by commas.
<%= ((enabled) ? "checked" : "") %>> </p>
<label for="rb01"><b>Enabled</b> - REST API requests will be processed.</label> <ul>
<br> <input type="radio" name="enabled" value="true" id="rb01"
<input type="radio" name="enabled" value="false" id="rb02" <%=((enabled) ? "checked" : "")%>>
<%= ((!enabled) ? "checked" : "") %>> <label for="rb01"><b>Enabled</b> - REST API requests will
<label for="rb02"><b>Disabled</b> - REST API requests will be ignored.</label> be processed.</label>
<br><br> <br>
<input type="radio" name="enabled" value="false" id="rb02"
<input type="radio" name="authtype" value="true" id="http_basic_auth" <%= ((httpBasicAuth) ? "checked" : "") %>> <%=((!enabled) ? "checked" : "")%>>
<label for="http_basic_auth">HTTP basic auth - REST API authentication with Openfire admin account.</label> <label for="rb02"><b>Disabled</b> - REST API requests will
<br> be ignored.</label>
<input type="radio" name="authtype" value="false" id="secretKeyAuth" <%= ((!httpBasicAuth) ? "checked" : "") %>> <br>
<label for="secretKeyAuth">Secret key auth - REST API authentication over specified secret key.</label> <br>
<br>
<label style="padding-left: 25px" for="text_secret">Secret key:</label> <input type="radio" name="authtype" value="true"
<input type="text" name="secret" value="<%= secret %>" id="text_secret"> id="http_basic_auth" <%=((httpBasicAuth) ? "checked" : "")%>>
<br><br> <label for="http_basic_auth">HTTP basic auth - REST API
authentication with Openfire admin account.</label>
<label for="text_secret">Allowed IP Addresses:</label> <br>
<textarea name="allowedIPs" cols="40" rows="3" wrap="virtual"><%= ((allowedIPs != null) ? allowedIPs : "") %></textarea> <input type="radio" name="authtype" value="false"
</ul> id="secretKeyAuth" <%=((!httpBasicAuth) ? "checked" : "")%>>
</div> <label for="secretKeyAuth">Secret key auth - REST API
</fieldset> authentication over specified secret key.</label>
<br>
<br><br> <label style="padding-left: 25px" for="text_secret">Secret
key:</label>
<input type="submit" value="Save Settings"> <input type="text" name="secret" value="<%=secret%>"
</form> id="text_secret">
<br>
<br>
</body>
<label for="allowedIPs">Allowed IP Addresses:</label>
<textarea name="allowedIPs" cols="40" rows="3" wrap="virtual"><%=((allowedIPs != null) ? allowedIPs : "")%></textarea>
</ul>
<p>You can find here detailed documentation over the Openfire REST API:
<a
href="/plugin-admin.jsp?plugin=restapi&showReadme=true&decorator=none">REST
API Documentation</a>
</p>
</div>
</fieldset>
<br> <br> <input type="submit" value="Save Settings">
</form>
</body>
</html> </html>
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Technounit-GROUP 2023