git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**
   2  * PermissionClient.java
   3  *
   4  * {Purpose of This Class}
   5  *
   6  * {Other Notes Relating to This Class (Optional)}
   7  *
   8  * $LastChangedBy: $
   9  * $LastChangedRevision: $
  10  * $LastChangedDate: $
  11  *
  12  * This document is a part of the source code and related artifacts
  13  * for CollectionSpace, an open source collections management system
  14  * for museums and related institutions:
  15  *
  16  * http://www.collectionspace.org
  17  * http://wiki.collectionspace.org
  18  *
  19  * Copyright (C) 2009 {Contributing Institution}
  20  *
  21  * Licensed under the Educational Community License (ECL), Version 2.0.
  22  * You may not use this file except in compliance with this License.
  23  *
  24  * You may obtain a copy of the ECL 2.0 License at
  25  * https://source.collectionspace.org/collection-space/LICENSE.txt
  26  */
  27 package org.collectionspace.services.client;
  28
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.List;
  32
  33 import javax.ws.rs.core.Response;
  34 import org.apache.http.HttpStatus;
  35
  36 import org.collectionspace.services.authorization.perms.ActionType;
  37 import org.collectionspace.services.authorization.perms.Permission;
  38 import org.collectionspace.services.authorization.perms.PermissionAction;
  39 import org.collectionspace.services.authorization.perms.PermissionsList;
  40 import org.collectionspace.services.description.ServiceDescription;
  41
  42 /**
  43  * A PermissionClient.
  44
  45  * @version $Revision:$
  46  */
  47 public class PermissionClient extends AbstractServiceClientImpl<PermissionsList, Permission, Permission, PermissionProxy> {
  48         public static final String SERVICE_NAME = "authorization/permissions";
  49         public static final String SERVICE_PATH_COMPONENT = SERVICE_NAME;
  50         public static final String SERVICE_PATH = "/" + SERVICE_PATH_COMPONENT;
  51         public static final String SERVICE_PATH_PROXY = SERVICE_PATH + "/";
  52
  53         public enum ActionCompare {
  54             ACTION_GROUP_EMPTY, ACTION_LIST_EMPTY, ACTIONS_MISSING, MATCHES, MISMATCHES
  55         }
  56
  57         public PermissionClient() throws Exception {
  58                 super();
  59         }
  60
  61         public PermissionClient(String clientPropertiesFilename) throws Exception {
  62                 super(clientPropertiesFilename);
  63         }
  64
  65         /* (non-Javadoc)
  66      * @see org.collectionspace.services.client.AbstractServiceClientImpl#getServicePathComponent()
  67      */
  68     @Override
  69         public String getServicePathComponent() {
  70         return SERVICE_PATH_COMPONENT;
  71     }
  72
  73         @Override
  74         public String getServiceName() {
  75                 return SERVICE_NAME;
  76         }
  77
  78         @Override
  79         public Class<PermissionProxy> getProxyClass() {
  80                 return PermissionProxy.class;
  81         }
  82
  83         /*
  84          * CRUD+L Methods
  85          */
  86
  87     /**
  88      * @return
  89      * @see org.collectionspace.hello.client.PermissionProxy#readList()
  90      */
  91         @Override
  92     public Response readList() {
  93         return getProxy().readList();
  94
  95     }
  96
  97     public Response readSearchList(String resourceName) {
  98         return getProxy().readSearchList(resourceName);
  99     }
 100
 101     /**
 102      * @param csid
 103      * @return
 104      * @see org.collectionspace.hello.client.PermissionProxy#getAccount(java.lang.String)
 105      */
 106     @Override
 107     public Response read(String csid) {
 108         return getProxy().read(csid);
 109     }
 110
 111     /*
 112      * We expect a single result.  An resourceName/actionGroup tuple should uniquely identify the permission resource
 113      */
 114     public Permission read(String resourceName, String actionGroup) {
 115         Permission result = null;
 116
 117         Response res = getProxy().read(resourceName, actionGroup);
 118         try {
 119                 if (res != null && res.getStatus() == Response.Status.OK.getStatusCode()) {
 120                         PermissionsList permsListElement = res.readEntity(PermissionsList.class);
 121                         if (permsListElement != null && permsListElement.getPermission() != null) {
 122                                 List<Permission> permsList = permsListElement.getPermission();
 123                                 if (permsList.size() == 1) {
 124                                         result = permsList.get(0);
 125                                 }
 126                         }
 127                 }
 128         } finally {
 129                 res.close();
 130         }
 131
 132         return result;
 133     }
 134
 135     /**
 136      * @param permission
 137      * @return
 138      * @see org.collectionspace.hello.client.PermissionProxy#create(org.collectionspace.services.permission.Permission)
 139      */
 140     @Override
 141     public Response create(Permission permission) {
 142         return getProxy().create(permission);
 143     }
 144
 145     /**
 146      * @param csid
 147      * @param permission
 148      * @return
 149      * @see org.collectionspace.hello.client.PermissionProxy#updateAccount(java.lang.Long, org.collectionspace.services.permission.Permission)
 150      */
 151     @Override
 152     public Response update(String csid, Permission permission) {
 153         return getProxy().update(csid, permission);
 154     }
 155
 156         @Override
 157         public ServiceDescription getServiceDescription() {
 158                 ServiceDescription result = null;
 159
 160         Response res = getProxy().getServiceDescription();
 161         if (res.getStatus() == HttpStatus.SC_OK) {
 162                 result = (ServiceDescription) res.readEntity(ServiceDescription.class);
 163         }
 164
 165         return result;
 166         }
 167
 168     public static String getActionGroup(List<PermissionAction> actionList) {
 169                 String result = null;
 170                 HashMap<ActionType, String> actionMap = getEmptyActionMap();
 171
 172                 for (PermissionAction permAction : actionList) {
 173                         switch (permAction.getName()) {
 174                                 case CREATE:
 175                                         actionMap.put(ActionType.CREATE, "C");
 176                                         break;
 177                                 case READ:
 178                                         actionMap.put(ActionType.READ, "R");
 179                                         break;
 180                                 case UPDATE:
 181                                         actionMap.put(ActionType.UPDATE, "U");
 182                                         break;
 183                                 case DELETE:
 184                                         actionMap.put(ActionType.DELETE, "D");
 185                                         break;
 186                                 case SEARCH:
 187                                         actionMap.put(ActionType.SEARCH, "L");
 188                                         break;
 189                                 default:
 190                                         String msg = String.format("Unknown permission action '%s'.", permAction.getName().value());
 191                                         logger.error(null);
 192                                         return result;
 193                         }
 194                 }
 195
 196                 result = String.format("%s%s%s%s%s",
 197                                 actionMap.get(ActionType.CREATE),
 198                                 actionMap.get(ActionType.READ),
 199                                 actionMap.get(ActionType.UPDATE),
 200                                 actionMap.get(ActionType.DELETE),
 201                                 actionMap.get(ActionType.SEARCH));
 202
 203                 return result;
 204         }
 205
 206         private static HashMap<ActionType, String> getEmptyActionMap() {
 207                 HashMap<ActionType, String> emptyActionMap = new HashMap<ActionType, String>();
 208
 209                 emptyActionMap.put(ActionType.CREATE, "");
 210                 emptyActionMap.put(ActionType.READ, "");
 211                 emptyActionMap.put(ActionType.UPDATE, "");
 212                 emptyActionMap.put(ActionType.DELETE, "");
 213                 emptyActionMap.put(ActionType.SEARCH, "");
 214
 215                 return emptyActionMap;
 216         }
 217
 218         public static List<PermissionAction> getActionList(String actionGroup) {
 219                 if (actionGroup == null || actionGroup.trim().isEmpty()) {
 220                         return null;
 221                 }
 222
 223                 List<PermissionAction> result = new ArrayList<PermissionAction>();
 224                 for (char c : actionGroup.toUpperCase().toCharArray()) {
 225                         switch (c) {
 226                                 case 'C':
 227                                         result.add(PermissionActionFactory.create(ActionType.CREATE));
 228                                         break;
 229                                 case 'R':
 230                                         result.add(PermissionActionFactory.create(ActionType.READ));
 231                                         break;
 232                                 case 'U':
 233                                         result.add(PermissionActionFactory.create(ActionType.UPDATE));
 234                                         break;
 235                                 case 'D':
 236                                         result.add(PermissionActionFactory.create(ActionType.DELETE));
 237                                         break;
 238                                 case 'L':
 239                                         result.add(PermissionActionFactory.create(ActionType.SEARCH));
 240                                         break;
 241                         }
 242                 }
 243
 244                 return result;
 245         }
 246
 247         /*
 248          * Validate that the permission's action group and action list are non-null, non-empty, and equivalent.
 249          * Returns:
 250          *              -1 - Permission action group is empty or null
 251          */
 252         public static ActionCompare validatePermActions(Permission permission) {
 253                 String actionGroup = permission.getActionGroup();
 254                 List<PermissionAction> actionList = permission.getAction();
 255
 256                 if ((actionGroup == null || actionGroup.trim().isEmpty() == true) && (actionList == null || actionList.size() < 1)) {
 257                         return ActionCompare.ACTIONS_MISSING;
 258                 }
 259
 260                 if (actionGroup == null || actionGroup.trim().isEmpty() == true) {
 261                         return ActionCompare.ACTION_GROUP_EMPTY;
 262                 }
 263
 264                 if (actionList == null || actionList.size() < 1) {
 265                         return ActionCompare.ACTION_LIST_EMPTY;
 266                 }
 267
 268                 String actionGroupFromActionList = getActionGroup(permission.getAction());
 269                 if (actionGroupFromActionList == null || !actionGroupFromActionList.equalsIgnoreCase(actionGroup)) {
 270                         return ActionCompare.MISMATCHES;
 271                 }
 272
 273                 return ActionCompare.MATCHES;
 274         }
 275 }