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

   1 /**
   2  *  This document is a part of the source code and related artifacts
   3  *  for CollectionSpace, an open source collections management system
   4  *  for museums and related institutions:
   5
   6  *  http://www.collectionspace.org
   7  *  http://wiki.collectionspace.org
   8
   9  *  Copyright 2009 University of California at Berkeley
  10
  11  *  Licensed under the Educational Community License (ECL), Version 2.0.
  12  *  You may not use this file except in compliance with this License.
  13
  14  *  You may obtain a copy of the ECL 2.0 License at
  15
  16  *  https://source.collectionspace.org/collection-space/LICENSE.txt
  17
  18  *  Unless required by applicable law or agreed to in writing, software
  19  *  distributed under the License is distributed on an "AS IS" BASIS,
  20  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21  *  See the License for the specific language governing permissions and
  22  *  limitations under the License.
  23  */
  24 package org.collectionspace.services.authorization.storage;
  25
  26 import java.util.HashMap;
  27 import java.util.List;
  28
  29 import org.collectionspace.services.common.document.DocumentNotFoundException;
  30 import org.collectionspace.services.common.context.ServiceContext;
  31 import org.collectionspace.services.common.context.ServiceContextProperties;
  32 import org.collectionspace.services.common.storage.jpa.JpaRelationshipStorageClient;
  33 import org.collectionspace.services.common.storage.jpa.JpaStorageUtils;
  34
  35 import org.collectionspace.services.authorization.Permission;
  36 import org.collectionspace.services.authorization.PermissionRole;
  37 import org.collectionspace.services.authorization.PermissionRoleRel;
  38 import org.collectionspace.services.authorization.PermissionValue;
  39 import org.collectionspace.services.authorization.Role;
  40 import org.collectionspace.services.authorization.RoleResource;
  41 import org.collectionspace.services.authorization.RoleValue;
  42 import org.collectionspace.services.authorization.SubjectType;
  43
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 // TODO: Auto-generated Javadoc
  48 /**
  49  * The Class PermissionRoleUtil.
  50  *
  51  * @author
  52  */
  53 public class PermissionRoleUtil {
  54
  55     final Logger logger = LoggerFactory.getLogger(PermissionRoleUtil.class);
  56
  57     /**
  58      * Gets the relation subject.
  59      *
  60      * @param ctx the ctx
  61      * @return the relation subject
  62      */
  63     static SubjectType getRelationSubject(ServiceContext ctx) {
  64         Object o = ctx.getProperty(ServiceContextProperties.SUBJECT);
  65         if (o == null) {
  66             throw new IllegalArgumentException(ServiceContextProperties.SUBJECT
  67                     + " property is missing in context "
  68                     + ctx.toString());
  69         }
  70         return (SubjectType) o;
  71     }
  72
  73     /**
  74      * Gets the relation subject.
  75      *
  76      * @param ctx the ctx
  77      * @param pr the pr
  78      * @return the relation subject
  79      */
  80     static SubjectType getRelationSubject(ServiceContext ctx, PermissionRole pr) {
  81         SubjectType subject = pr.getSubject();
  82         if (subject == null) {
  83             //it is not required to give subject as URI determines the subject
  84             subject = getRelationSubject(ctx);
  85         }
  86         return subject;
  87     }
  88
  89     /**
  90      * buildPermissionRoleRel builds persistent relationship entities from given
  91      * permissionrole.
  92      *
  93      * @param pr permissionrole
  94      * @param subject the subject
  95      * @param prrl persistent entities built are inserted into this list
  96      * @param toDelete the to delete
  97      */
  98     static public void buildPermissionRoleRel(PermissionRole pr,
  99                 SubjectType subject,
 100                 List<PermissionRoleRel> prrl,
 101                 boolean handleDelete)
 102                         throws DocumentNotFoundException {
 103         if (subject.equals(SubjectType.ROLE)) {
 104             //FIXME: potential index out of bounds exception...negative test needed
 105             PermissionValue pv = pr.getPermissions().get(0);
 106             for (RoleValue rv : pr.getRoles()) {
 107                 PermissionRoleRel prr = buildPermissonRoleRel(pv, rv, subject, handleDelete);
 108                 prrl.add(prr);
 109             }
 110         } else if (SubjectType.PERMISSION.equals(subject)) {
 111             //FIXME: potential index out of bounds exception...negative test needed
 112             RoleValue rv = pr.getRoles().get(0);
 113             for (PermissionValue pv : pr.getPermissions()) {
 114                 PermissionRoleRel prr = buildPermissonRoleRel(pv, rv, subject, handleDelete);
 115                 prrl.add(prr);
 116             }
 117         }
 118     }
 119
 120     /**
 121      * Builds a permisson role relationship for either 'create' or 'delete'
 122      *
 123      * @param pv the pv (currently using only the ID)
 124      * @param rv the rv (currently using only the ID)
 125      * @param handleDelete the handle delete
 126      * @return the permission role rel
 127      */
 128     static private PermissionRoleRel buildPermissonRoleRel(PermissionValue permissionValue,
 129                 RoleValue roleValue,
 130                 SubjectType subject,
 131                 boolean handleDelete)
 132                         throws DocumentNotFoundException {
 133
 134         PermissionRoleRel result = null;
 135
 136         //
 137         // Ensure we can find both the Permission and Role to relate.
 138         // FIXME: REM - This is a workaround until the Import utility creates Perm/Role relationships
 139         // correctly.  The import utility should create and store the permissions and roles BEFORE creating the relationships
 140         //
 141         PermissionValue pv = permissionValue;
 142         try {
 143                 Permission permission = (Permission)JpaStorageUtils.getEntity(pv.getPermissionId(),
 144                                 Permission.class);
 145                 if (permission != null) {
 146                         // If the permission already exists, then use it to fill our the relation record
 147                         pv = JpaRelationshipStorageClient.createPermissionValue(permission);
 148                 }
 149         } catch (DocumentNotFoundException e) {
 150                 // ignore this exception, pv is set to permissionValue;
 151         }
 152         //
 153         // Ensure we can find both the Permission and Role to relate.
 154         // FIXME: REM - This is a workaround until the Import utility creates Perm/Role relationships
 155         // correctly.  The import utility should create and store the permissions and roles BEFORE creating the relationships
 156         //
 157         RoleValue rv = roleValue;
 158         try {
 159                 Role role = (Role)JpaStorageUtils.getEntity(rv.getRoleId(),
 160                                 Role.class);
 161                 if (role != null) {
 162                         // If the role already exists, then use it to fill out the relation record
 163                         rv = JpaRelationshipStorageClient.createRoleValue(role);
 164                 }
 165         } catch (DocumentNotFoundException e) {
 166                 // ignore this exception, rv is set to roleValue
 167         }
 168
 169         result = new PermissionRoleRel();
 170         result.setPermissionId(pv.getPermissionId());
 171         result.setPermissionResource(pv.getResourceName());
 172         result.setActionGroup(pv.getActionGroup());
 173         result.setRoleId(rv.getRoleId());
 174         result.setRoleName(rv.getRoleName());
 175         //
 176         // For 'delete' we need to set the hjid of the existing relstionship
 177         //
 178         String relationshipId = null;
 179         if (subject.equals(SubjectType.ROLE) == true) {
 180                 relationshipId = roleValue.getRoleRelationshipId();
 181         } else if (subject.equals(SubjectType.PERMISSION) == true) {
 182                 relationshipId = permissionValue.getPermRelationshipId();
 183         }
 184         if (relationshipId != null && handleDelete == true) {
 185                 result.setHjid(Long.parseLong(relationshipId));  // set this so we can convince JPA to del the relation
 186         }
 187
 188         return result;
 189     }
 190
 191     /**
 192      * Checks if is invalid tenant.
 193      *
 194      * @param tenantId the tenant id
 195      * @param msgBldr the msg bldr
 196      * @return true, if is invalid tenant
 197      */
 198     static boolean isInvalidTenant(String tenantId, StringBuilder msgBldr) {
 199         boolean invalid = false;
 200
 201         if (tenantId == null || tenantId.isEmpty()) {
 202             invalid = true;
 203             msgBldr.append("\n tenant : tenantId is missing");
 204         }
 205         String whereClause = "where id = :id";
 206         HashMap<String, Object> params = new HashMap<String, Object>();
 207         params.put("id", tenantId);
 208
 209         Object tenantFound = JpaStorageUtils.getEntity(
 210                 "org.collectionspace.services.account.Tenant", whereClause, params);
 211         if (tenantFound == null) {
 212             invalid = true;
 213             msgBldr.append("\n tenant : tenantId=" + tenantId
 214                     + " not found");
 215         }
 216         return invalid;
 217     }
 218 }