001: /*
002: * Copyright 2004 Outerthought bvba and Schaubroeck nv
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.outerj.daisy.repository.clientimpl.user;
017:
018: import java.util.ArrayList;
019: import java.util.List;
020:
021: import org.apache.commons.httpclient.HttpMethod;
022: import org.apache.commons.httpclient.methods.DeleteMethod;
023: import org.apache.commons.httpclient.methods.GetMethod;
024: import org.apache.commons.httpclient.methods.PostMethod;
025: import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
026: import org.outerj.daisy.repository.RepositoryException;
027: import org.outerj.daisy.repository.RepositoryEventType;
028: import org.outerj.daisy.repository.commonimpl.user.*;
029: import org.outerj.daisy.repository.commonimpl.AuthenticatedUser;
030: import org.outerj.daisy.repository.clientimpl.infrastructure.AbstractRemoteStrategy;
031: import org.outerj.daisy.repository.clientimpl.infrastructure.DaisyHttpClient;
032: import org.outerj.daisy.repository.clientimpl.RemoteRepositoryManager.Context;
033: import org.outerj.daisy.repository.user.*;
034: import org.outerj.daisy.util.ListUtil;
035: import org.outerx.daisy.x10.*;
036:
037: /**
038: * User management strategy that connects to the repository server, communicating through
039: * HTTP/XML.
040: */
041: public class RemoteUserManagementStrategy extends
042: AbstractRemoteStrategy implements UserManagementStrategy {
043:
044: public RemoteUserManagementStrategy(Context context) {
045: super (context);
046: }
047:
048: public Users loadUsers(AuthenticatedUser requestingUser)
049: throws RepositoryException {
050: DaisyHttpClient httpClient = getClient(requestingUser);
051: HttpMethod method = new GetMethod("/repository/user");
052:
053: UsersDocument usersDocument = (UsersDocument) httpClient
054: .executeMethod(method, UsersDocument.class, true);
055: return instantiateUsersFromXml(usersDocument.getUsers(),
056: requestingUser);
057: }
058:
059: public long[] getUserIds(AuthenticatedUser requestingUser)
060: throws RepositoryException {
061: DaisyHttpClient httpClient = getClient(requestingUser);
062: HttpMethod method = new GetMethod("/repository/userIds");
063:
064: IdsDocument idsDocument = (IdsDocument) httpClient
065: .executeMethod(method, IdsDocument.class, true);
066: return ListUtil.toArray(idsDocument.getIds().getIdList());
067: }
068:
069: private UserImpl instantiateUserFromXml(UserDocument.User userXml,
070: AuthenticatedUser requestingUser) {
071: String login = userXml.getLogin();
072:
073: UserImpl user = new UserImpl(this , login, requestingUser);
074: UserImpl.IntimateAccess userInt = user.getIntimateAccess(this );
075:
076: RolesDocument.Roles roles = userXml.getRoles();
077: List<RoleDocument.Role> roleArr = roles.getRoleList();
078: for (RoleDocument.Role role : roleArr) {
079: userInt.addToRole(instantiateRoleFromXml(role,
080: requestingUser));
081: }
082:
083: userInt.saved(userXml.getId(), userXml.getFirstName(), userXml
084: .getLastName(), userXml.getEmail(), userXml
085: .getLastModified().getTime(),
086: userXml.getLastModifier(), userXml.getUpdateCount());
087: if (userXml.getRole() != null)
088: user.setDefaultRole(instantiateRoleFromXml(userXml
089: .getRole(), requestingUser));
090: else
091: user.setDefaultRole(null);
092: user.setUpdateableByUser(userXml.getUpdateableByUser());
093: user.setConfirmed(userXml.getConfirmed());
094: if (userXml.isSetConfirmKey())
095: user.setConfirmKey(userXml.getConfirmKey());
096: user.setAuthenticationScheme(userXml.getAuthenticationScheme());
097:
098: return user;
099: }
100:
101: public Roles loadRoles(AuthenticatedUser requestingUser)
102: throws RepositoryException {
103: DaisyHttpClient httpClient = getClient(requestingUser);
104: HttpMethod method = new GetMethod("/repository/role");
105:
106: RolesDocument rolesDocument = (RolesDocument) httpClient
107: .executeMethod(method, RolesDocument.class, true);
108: RolesDocument.Roles roles = rolesDocument.getRoles();
109: List<RoleDocument.Role> rolesXml = roles.getRoleList();
110: List<RoleImpl> rolesList = new ArrayList<RoleImpl>(rolesXml
111: .size());
112: for (RoleDocument.Role roleXml : rolesXml) {
113: RoleImpl role = instantiateRoleFromXml(roleXml,
114: requestingUser);
115: rolesList.add(role);
116: }
117: Role[] roleArr = rolesList.toArray(new Role[rolesList.size()]);
118: return new RolesImpl(roleArr);
119: }
120:
121: private RoleImpl instantiateRoleFromXml(RoleDocument.Role roleXml,
122: AuthenticatedUser requestingUser) {
123: if (roleXml == null)
124: throw new RuntimeException("roleXml was null!");
125:
126: String roleName = roleXml.getName();
127:
128: RoleImpl role = new RoleImpl(this , roleName, requestingUser);
129: RoleImpl.IntimateAccess roleInt = role.getIntimateAccess(this );
130: roleInt.setLastModified(roleXml.getLastModified().getTime());
131: roleInt.setLastModifier(roleXml.getLastModifier());
132: roleInt.saved(roleXml.getId(), roleName, roleXml
133: .getDescription(), roleXml.getUpdateCount());
134:
135: return role;
136: }
137:
138: public void deleteUser(long userId, AuthenticatedUser requestingUser)
139: throws RepositoryException {
140: DaisyHttpClient httpClient = getClient(requestingUser);
141: DeleteMethod method = new DeleteMethod("/repository/user/"
142: + userId);
143:
144: httpClient.executeMethod(method, null, true);
145: // fire synchronous events
146: context.getCommonRepository().fireRepositoryEvent(
147: RepositoryEventType.USER_DELETED, new Long(userId), -1);
148: }
149:
150: public void deleteRole(long roleId, AuthenticatedUser requestingUser)
151: throws RepositoryException {
152: DaisyHttpClient httpClient = getClient(requestingUser);
153: DeleteMethod method = new DeleteMethod("/repository/role/"
154: + roleId);
155:
156: httpClient.executeMethod(method, null, true);
157: // fire synchronous events
158: context.getCommonRepository().fireRepositoryEvent(
159: RepositoryEventType.ROLE_DELETED, new Long(roleId), -1);
160: }
161:
162: public UserImpl getUser(String login,
163: AuthenticatedUser requestingUser)
164: throws RepositoryException {
165: DaisyHttpClient httpClient = getClient(requestingUser);
166: String encodedLogin = encodeNameForUseInPath("login", login);
167: HttpMethod method = new GetMethod("/repository/userByLogin/"
168: + encodedLogin);
169: return getUserXmlFromServer(requestingUser, httpClient, method);
170: }
171:
172: public RoleImpl getRole(String name,
173: AuthenticatedUser requestingUser)
174: throws RepositoryException {
175: DaisyHttpClient httpClient = getClient(requestingUser);
176: String encodedName = encodeNameForUseInPath("role", name);
177: HttpMethod method = new GetMethod("/repository/roleByName/"
178: + encodedName);
179: return getRoleXmlFromServer(requestingUser, httpClient, method);
180: }
181:
182: public void store(UserImpl user) throws RepositoryException {
183: if (user == null)
184: throw new RuntimeException(
185: "UserImpl expected - instead received null!");
186:
187: UserImpl.IntimateAccess collInt = user.getIntimateAccess(this );
188:
189: DaisyHttpClient httpClient = getClient(collInt.getCurrentUser());
190:
191: String url = "/repository";
192: boolean isNew = user.getId() == -1;
193: if (isNew)
194: url += "/user";
195: else
196: url += "/user/" + user.getId();
197:
198: PostMethod method = new PostMethod(url);
199:
200: UserDocument userDocument = user.getXml();
201:
202: method.setRequestEntity(new InputStreamRequestEntity(
203: userDocument.newInputStream()));
204:
205: UserDocument responseUserDocument = (UserDocument) httpClient
206: .executeMethod(method, UserDocument.class, true);
207: UserDocument.User userXml = responseUserDocument.getUser();
208: UserImpl.IntimateAccess userInt = user.getIntimateAccess(this );
209: userInt.saved(userXml.getId(), userXml.getFirstName(), userXml
210: .getLastName(), userXml.getEmail(), userXml
211: .getLastModified().getTime(),
212: userXml.getLastModifier(), userXml.getUpdateCount());
213:
214: // fire synchronous events
215: if (isNew)
216: context.getCommonRepository().fireRepositoryEvent(
217: RepositoryEventType.USER_CREATED,
218: new Long(user.getId()), user.getUpdateCount());
219: else
220: context.getCommonRepository().fireRepositoryEvent(
221: RepositoryEventType.USER_UPDATED,
222: new Long(user.getId()), user.getUpdateCount());
223: }
224:
225: public void store(RoleImpl role) throws RepositoryException {
226: if (role == null)
227: throw new RuntimeException(
228: "RoleImpl expected - instead received null!");
229:
230: RoleImpl.IntimateAccess collInt = role.getIntimateAccess(this );
231:
232: DaisyHttpClient httpClient = getClient(collInt.getCurrentUser());
233:
234: String url = "/repository";
235: boolean isNew = role.getId() == -1;
236: if (isNew)
237: url += "/role";
238: else
239: url += "/role/" + role.getId();
240:
241: PostMethod method = new PostMethod(url);
242:
243: RoleDocument roleDocument = role.getXml();
244: method.setRequestEntity(new InputStreamRequestEntity(
245: roleDocument.newInputStream()));
246:
247: RoleDocument responseRoleDocument = (RoleDocument) httpClient
248: .executeMethod(method, RoleDocument.class, true);
249: RoleDocument.Role roleXml = responseRoleDocument.getRole();
250: RoleImpl.IntimateAccess roleInt = role.getIntimateAccess(this );
251: roleInt.saved(roleXml.getId(), roleXml.getName(), roleXml
252: .getDescription(), roleXml.getUpdateCount());
253: roleInt.setLastModified(roleXml.getLastModified().getTime());
254: roleInt.setLastModifier(roleXml.getLastModifier());
255:
256: // fire synchronous events
257: if (isNew)
258: context.getCommonRepository().fireRepositoryEvent(
259: RepositoryEventType.ROLE_CREATED,
260: new Long(role.getId()), role.getUpdateCount());
261: else
262: context.getCommonRepository().fireRepositoryEvent(
263: RepositoryEventType.ROLE_UPDATED,
264: new Long(role.getId()), role.getUpdateCount());
265: }
266:
267: public UserImpl getUser(long userId,
268: AuthenticatedUser requestingUser)
269: throws RepositoryException {
270: DaisyHttpClient httpClient = getClient(requestingUser);
271: HttpMethod method = new GetMethod("/repository/user/" + userId);
272: return getUserXmlFromServer(requestingUser, httpClient, method);
273: }
274:
275: public RoleImpl getRole(long roleId,
276: AuthenticatedUser requestingUser)
277: throws RepositoryException {
278: DaisyHttpClient httpClient = getClient(requestingUser);
279: HttpMethod method = new GetMethod("/repository/role/" + roleId);
280: return getRoleXmlFromServer(requestingUser, httpClient, method);
281: }
282:
283: private UserImpl getUserXmlFromServer(
284: AuthenticatedUser requestingUser,
285: DaisyHttpClient httpClient, HttpMethod method)
286: throws RepositoryException {
287: UserDocument userDocument = (UserDocument) httpClient
288: .executeMethod(method, UserDocument.class, true);
289: UserDocument.User userXml = userDocument.getUser();
290: UserImpl document = instantiateUserFromXml(userXml,
291: requestingUser);
292: return document;
293: }
294:
295: private RoleImpl getRoleXmlFromServer(
296: AuthenticatedUser requestingUser,
297: DaisyHttpClient httpClient, HttpMethod method)
298: throws RepositoryException {
299: RoleDocument roleDocument = (RoleDocument) httpClient
300: .executeMethod(method, RoleDocument.class, true);
301: RoleDocument.Role roleXml = roleDocument.getRole();
302: RoleImpl document = instantiateRoleFromXml(roleXml,
303: requestingUser);
304: return document;
305: }
306:
307: public UsersImpl getUsersByEmail(String email,
308: AuthenticatedUser requestingUser)
309: throws RepositoryException {
310: DaisyHttpClient httpClient = getClient(requestingUser);
311: String encodedEmail = encodeNameForUseInPath("email", email);
312: HttpMethod method = new GetMethod("/repository/usersByEmail/"
313: + encodedEmail);
314:
315: UsersDocument usersDocument = (UsersDocument) httpClient
316: .executeMethod(method, UsersDocument.class, true);
317: return instantiateUsersFromXml(usersDocument.getUsers(),
318: requestingUser);
319: }
320:
321: private UsersImpl instantiateUsersFromXml(
322: UsersDocument.Users users, AuthenticatedUser requestingUser) {
323: List<UserDocument.User> usersXml = users.getUserList();
324: List<User> usersList = new ArrayList<User>(usersXml.size());
325: for (UserDocument.User userXml : usersXml) {
326: UserImpl user = instantiateUserFromXml(userXml,
327: requestingUser);
328: usersList.add(user);
329: }
330: User[] userArr = usersList.toArray(new User[usersList.size()]);
331: return new UsersImpl(userArr);
332: }
333:
334: public PublicUserInfo getPublicUserInfo(long userId,
335: AuthenticatedUser requestingUser)
336: throws RepositoryException {
337: DaisyHttpClient httpClient = getClient(requestingUser);
338: HttpMethod method = new GetMethod("/repository/publicUserInfo/"
339: + userId);
340:
341: PublicUserInfoDocument pubUserDoc = (PublicUserInfoDocument) httpClient
342: .executeMethod(method, PublicUserInfoDocument.class,
343: true);
344: return instantiatePublicUserInfoFromXml(pubUserDoc
345: .getPublicUserInfo());
346: }
347:
348: public PublicUserInfo getPublicUserInfo(String login,
349: AuthenticatedUser requestingUser)
350: throws RepositoryException {
351: DaisyHttpClient httpClient = getClient(requestingUser);
352: String encodedLogin = encodeNameForUseInPath("login", login);
353: HttpMethod method = new GetMethod(
354: "/repository/publicUserInfoByLogin/" + encodedLogin);
355:
356: PublicUserInfoDocument pubUserDoc = (PublicUserInfoDocument) httpClient
357: .executeMethod(method, PublicUserInfoDocument.class,
358: true);
359: return instantiatePublicUserInfoFromXml(pubUserDoc
360: .getPublicUserInfo());
361: }
362:
363: public PublicUserInfos getPublicUserInfos(
364: AuthenticatedUser requestingUser)
365: throws RepositoryException {
366: DaisyHttpClient httpClient = getClient(requestingUser);
367: HttpMethod method = new GetMethod("/repository/publicUserInfo");
368:
369: PublicUserInfosDocument pubUsersDoc = (PublicUserInfosDocument) httpClient
370: .executeMethod(method, PublicUserInfosDocument.class,
371: true);
372: List<PublicUserInfoDocument.PublicUserInfo> pubUserInfosXml = pubUsersDoc
373: .getPublicUserInfos().getPublicUserInfoList();
374: PublicUserInfo[] pubUserInfos = new PublicUserInfo[pubUserInfosXml
375: .size()];
376: for (int i = 0; i < pubUserInfosXml.size(); i++) {
377: pubUserInfos[i] = instantiatePublicUserInfoFromXml(pubUserInfosXml
378: .get(i));
379: }
380: return new PublicUserInfosImpl(pubUserInfos);
381: }
382:
383: private PublicUserInfo instantiatePublicUserInfoFromXml(
384: PublicUserInfoDocument.PublicUserInfo userXml) {
385: return new PublicUserInfoImpl(userXml.getId(), userXml
386: .getLogin(), userXml.getDisplayName());
387: }
388:
389: public AuthenticationSchemeInfos getAuthenticationSchemes(
390: AuthenticatedUser requestingUser)
391: throws RepositoryException {
392: DaisyHttpClient httpClient = getClient(requestingUser);
393: HttpMethod method = new GetMethod(
394: "/repository/authenticationSchemes");
395:
396: AuthenticationSchemesDocument schemesDocument = (AuthenticationSchemesDocument) httpClient
397: .executeMethod(method,
398: AuthenticationSchemesDocument.class, true);
399:
400: List<AuthenticationSchemeDocument.AuthenticationScheme> schemesXml = schemesDocument
401: .getAuthenticationSchemes()
402: .getAuthenticationSchemeList();
403: AuthenticationSchemeInfo[] schemes = new AuthenticationSchemeInfo[schemesXml
404: .size()];
405: for (int i = 0; i < schemesXml.size(); i++) {
406: schemes[i] = new AuthenticationSchemeInfoImpl(schemesXml
407: .get(i).getName(), schemesXml.get(i)
408: .getDescription());
409: }
410:
411: return new AuthenticationSchemeInfosImpl(schemes);
412: }
413: }
|