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
  35 import org.apache.http.HttpStatus;
  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     /**
 103      * @param csid
 104      * @return
 105      * @see org.collectionspace.hello.client.PermissionProxy#getAccount(java.lang.String)
 106      */
 107     @Override
 108     public Response read(String csid) {
 109         return getProxy().read(csid);
 110     }
 111
 112     /**
 113      * @param permission
 114      * @return
 115      * @see org.collectionspace.hello.client.PermissionProxy#create(org.collectionspace.services.permission.Permission)
 116      */
 117     @Override
 118     public Response create(Permission permission) {
 119         return getProxy().create(permission);
 120     }
 121
 122     /**
 123      * @param csid
 124      * @param permission
 125      * @return
 126      * @see org.collectionspace.hello.client.PermissionProxy#updateAccount(java.lang.Long, org.collectionspace.services.permission.Permission)
 127      */
 128     @Override
 129     public Response update(String csid, Permission permission) {
 130         return getProxy().update(csid, permission);
 131     }
 132
 133         @Override
 134         public ServiceDescription getServiceDescription() {
 135                 ServiceDescription result = null;
 136
 137         Response res = getProxy().getServiceDescription();
 138         if (res.getStatus() == HttpStatus.SC_OK) {
 139                 result = (ServiceDescription) res.readEntity(ServiceDescription.class);
 140         }
 141
 142         return result;
 143         }
 144
 145     public static String getActionGroup(List<PermissionAction> actionList) {
 146                 String result = null;
 147                 HashMap<ActionType, String> actionMap = getEmptyActionMap();
 148
 149                 for (PermissionAction permAction : actionList) {
 150                         switch (permAction.getName()) {
 151                                 case CREATE:
 152                                         actionMap.put(ActionType.CREATE, "C");
 153                                         break;
 154                                 case READ:
 155                                         actionMap.put(ActionType.READ, "R");
 156                                         break;
 157                                 case UPDATE:
 158                                         actionMap.put(ActionType.UPDATE, "U");
 159                                         break;
 160                                 case DELETE:
 161                                         actionMap.put(ActionType.DELETE, "D");
 162                                         break;
 163                                 case SEARCH:
 164                                         actionMap.put(ActionType.SEARCH, "L");
 165                                         break;
 166                                 default:
 167                                         String msg = String.format("Unknown permission action '%s'.", permAction.getName().value());
 168                                         logger.error(null);
 169                                         return result;
 170                         }
 171                 }
 172
 173                 result = String.format("%s%s%s%s%s",
 174                                 actionMap.get(ActionType.CREATE),
 175                                 actionMap.get(ActionType.READ),
 176                                 actionMap.get(ActionType.UPDATE),
 177                                 actionMap.get(ActionType.DELETE),
 178                                 actionMap.get(ActionType.SEARCH));
 179
 180                 return result;
 181         }
 182
 183         private static HashMap<ActionType, String> getEmptyActionMap() {
 184                 HashMap<ActionType, String> emptyActionMap = new HashMap<ActionType, String>();
 185
 186                 emptyActionMap.put(ActionType.CREATE, "");
 187                 emptyActionMap.put(ActionType.READ, "");
 188                 emptyActionMap.put(ActionType.UPDATE, "");
 189                 emptyActionMap.put(ActionType.DELETE, "");
 190                 emptyActionMap.put(ActionType.SEARCH, "");
 191
 192                 return emptyActionMap;
 193         }
 194
 195         public static List<PermissionAction> getActionList(String actionGroup) {
 196                 if (actionGroup == null || actionGroup.trim().isEmpty()) {
 197                         return null;
 198                 }
 199
 200                 List<PermissionAction> result = new ArrayList<PermissionAction>();
 201                 for (char c : actionGroup.toUpperCase().toCharArray()) {
 202                         switch (c) {
 203                                 case 'C':
 204                                         result.add(PermissionActionFactory.create(ActionType.CREATE));
 205                                         break;
 206                                 case 'R':
 207                                         result.add(PermissionActionFactory.create(ActionType.READ));
 208                                         break;
 209                                 case 'U':
 210                                         result.add(PermissionActionFactory.create(ActionType.UPDATE));
 211                                         break;
 212                                 case 'D':
 213                                         result.add(PermissionActionFactory.create(ActionType.DELETE));
 214                                         break;
 215                                 case 'L':
 216                                         result.add(PermissionActionFactory.create(ActionType.SEARCH));
 217                                         break;
 218                         }
 219                 }
 220
 221                 return result;
 222         }
 223
 224         /*
 225          * Validate that the permission's action group and action list are non-null, non-empty, and equivalent.
 226          * Returns:
 227          *              -1 - Permission action group is empty or null
 228          */
 229         public static ActionCompare validatePermActions(Permission permission) {
 230                 String actionGroup = permission.getActionGroup();
 231                 List<PermissionAction> actionList = permission.getAction();
 232
 233                 if ((actionGroup == null || actionGroup.trim().isEmpty() == true) && (actionList == null || actionList.size() < 1)) {
 234                         return ActionCompare.ACTIONS_MISSING;
 235                 }
 236
 237                 if (actionGroup == null || actionGroup.trim().isEmpty() == true) {
 238                         return ActionCompare.ACTION_GROUP_EMPTY;
 239                 }
 240
 241                 if (actionList == null || actionList.size() < 1) {
 242                         return ActionCompare.ACTION_LIST_EMPTY;
 243                 }
 244
 245                 String actionGroupFromActionList = getActionGroup(permission.getAction());
 246                 if (actionGroupFromActionList == null || !actionGroupFromActionList.equalsIgnoreCase(actionGroup)) {
 247                         return ActionCompare.MISMATCHES;
 248                 }
 249
 250                 return ActionCompare.MATCHES;
 251         }
 252 }