gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.itempermissions.impl;
  17
  18 import org.apache.commons.collections.CollectionUtils;
  19 import org.openecomp.sdc.common.errors.CoreException;
  20 import org.openecomp.sdc.itempermissions.PermissionsRules;
  21 import org.openecomp.sdc.itempermissions.PermissionsServices;
  22 import org.openecomp.sdc.itempermissions.PermissionsServicesFactory;
  23 import org.openecomp.sdc.itempermissions.errors.PermissionsErrorMessagesBuilder;
  24 import org.openecomp.sdc.itempermissions.impl.types.PermissionActionTypes;
  25 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
  26
  27 import java.util.Collections;
  28 import java.util.HashSet;
  29 import java.util.Set;
  30
  31 import static org.openecomp.sdc.itempermissions.errors.PermissionsErrorMessages.INVALID_ACTION_TYPE;
  32 import static org.openecomp.sdc.itempermissions.errors.PermissionsErrorMessages.INVALID_PERMISSION_TYPE;
  33
  34 /**
  35  * Created by ayalaben on 6/26/2017.
  36  */
  37 public class PermissionsRulesImpl implements PermissionsRules {
  38
  39
  40     @Override
  41     public boolean isAllowed(String permission, String action) {
  42
  43         if (permission == null) {
  44             return false;
  45         }
  46         try {
  47             PermissionTypes.valueOf(permission);
  48         } catch (IllegalArgumentException ex) {
  49             throw new CoreException(new PermissionsErrorMessagesBuilder(INVALID_PERMISSION_TYPE).build());
  50         }
  51
  52         try {
  53             switch (PermissionActionTypes.valueOf(action)) {
  54                 case Create_Item:
  55                     return true;
  56
  57                 case Edit_Item:
  58                     if (permission.equals(PermissionTypes.Contributor.name()) || permission.equals
  59                             (PermissionTypes.Owner.name())) {
  60                         return true;
  61                     }
  62                     break;
  63                 case Commit_Item:
  64                     if (permission.equals(PermissionTypes.Contributor.name()) || permission.equals
  65                             (PermissionTypes.Owner.name())) {
  66                         return true;
  67                     }
  68                     break;
  69                 case Delete_Item:
  70                     if (permission.equals(PermissionTypes.Contributor.name()) || permission.equals
  71                             (PermissionTypes.Owner.name())) {
  72                         return true;
  73                     }
  74                     break;
  75
  76                 case Change_Item_Permissions:
  77                     if (permission.equals(PermissionTypes.Owner.name())) {
  78                         return true;
  79                     }
  80                     break;
  81
  82                 case Submit_Item:
  83                     if (permission.equals(PermissionTypes.Contributor.name()) || permission.equals
  84                             (PermissionTypes.Owner.name())) {
  85                         return true;
  86                     }
  87                     break;
  88
  89                 default:
  90                     return false;
  91             }
  92         } catch (IllegalArgumentException ex) {
  93             throw new CoreException(new PermissionsErrorMessagesBuilder(INVALID_ACTION_TYPE).build());
  94         }
  95
  96         return false;
  97     }
  98
  99     @Override
 100     public void executeAction(String itemId, String userId, String action) {
 101         try {
 102             switch (PermissionActionTypes.valueOf(action)) {
 103                 case Create_Item:
 104                     caseCreateItem(userId, itemId);
 105                     break;
 106
 107                 case Change_Item_Permissions:
 108                     break;
 109
 110                 case Edit_Item:
 111                     break;
 112
 113                 case Submit_Item:
 114                     break;
 115
 116                 default:
 117             }
 118         } catch (IllegalArgumentException ex) {
 119             throw new CoreException(new PermissionsErrorMessagesBuilder(INVALID_ACTION_TYPE).build());
 120         }
 121     }
 122
 123   @Override
 124   public void updatePermission(String itemId, String currentUserId, String permission, Set<String>
 125       addedUsersIds, Set<String> removedUsersIds) {
 126     try {
 127       PermissionTypes.valueOf(permission);
 128     } catch (IllegalArgumentException ex) {
 129       throw new CoreException(new PermissionsErrorMessagesBuilder(INVALID_PERMISSION_TYPE).build());
 130     }
 131
 132     if (isOwnerAdded(permission, addedUsersIds)) {
 133       handleCurrentOwner(itemId, currentUserId);
 134     }
 135   }
 136
 137   private boolean isOwnerAdded(String permission, Set<String> addedUsersIds) {
 138     return permission.equals(PermissionTypes.Owner.name()) &&
 139         CollectionUtils.isNotEmpty(addedUsersIds);
 140   }
 141
 142   private void handleCurrentOwner(String itemId, String currentUserId) {
 143     PermissionsServices permissionsServices =
 144         PermissionsServicesFactory.getInstance().createInterface();
 145     if (!permissionsServices.getUserItemPermission(itemId, currentUserId).isPresent()) {
 146       return; // no current owner - first owner addition
 147     }
 148
 149     Set<String> currentUserSet = Collections.singleton(currentUserId);
 150     permissionsServices
 151         .updateItemPermissions(itemId, PermissionTypes.Contributor.name(), currentUserSet,
 152             new HashSet<>());
 153     permissionsServices.updateItemPermissions(itemId, PermissionTypes.Owner.name(), new HashSet<>(),
 154         currentUserSet);
 155   }
 156
 157     private void caseCreateItem(String userId, String itemId) {
 158         HashSet<String> ownerId = new HashSet<>();
 159         ownerId.add(userId);
 160         PermissionsServicesFactory.getInstance().createInterface()
 161                 .updateItemPermissions(itemId, PermissionTypes.Owner.name(), ownerId,
 162                         new HashSet<>());
 163     }
 164
 165 }