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
  17 package org.openecomp.sdc.itempermissions.dao.impl;
  18
  19 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_ID_PROP;
  20 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_NAME_PROP;
  21 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_CHANGED;
  22 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_GRANTED;
  23 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_ITEM;
  24 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
  25
  26 import java.util.Collection;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29 import java.util.Optional;
  30 import java.util.Set;
  31 import org.openecomp.sdc.common.errors.CoreException;
  32 import org.openecomp.sdc.common.errors.ErrorCategory;
  33 import org.openecomp.sdc.common.errors.ErrorCode;
  34 import org.openecomp.sdc.common.errors.Messages;
  35 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  36 import org.openecomp.sdc.itempermissions.PermissionsManager;
  37 import org.openecomp.sdc.itempermissions.PermissionsServices;
  38 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
  39 import org.openecomp.sdc.itempermissions.type.ItemPermissionsEntity;
  40 import org.openecomp.sdc.logging.api.Logger;
  41 import org.openecomp.sdc.logging.api.LoggerFactory;
  42 import org.openecomp.sdc.notification.dtos.Event;
  43 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  44 import org.openecomp.sdc.notification.services.SubscriptionService;
  45 import org.openecomp.sdc.versioning.AsdcItemManager;
  46 import org.openecomp.sdc.versioning.types.Item;
  47
  48 /**
  49  * Created by ayalaben on 6/18/2017.
  50  */
  51 public class PermissionsManagerImpl implements PermissionsManager {
  52
  53   private static final Logger LOGGER = LoggerFactory.getLogger(PermissionsManagerImpl.class);
  54   private static final String CHANGE_PERMISSIONS = "Change_Item_Permissions";
  55
  56   private PermissionsServices permissionsServices;
  57   private AsdcItemManager asdcItemManager;
  58   private NotificationPropagationManager notifier;
  59   private SubscriptionService subscriptionService;
  60
  61   public PermissionsManagerImpl(PermissionsServices permissionsServices,
  62                                 AsdcItemManager asdcItemManager,
  63                                 NotificationPropagationManager notificationPropagationManager,
  64                                 SubscriptionService subscriptionService) {
  65     this.permissionsServices = permissionsServices;
  66     this.asdcItemManager = asdcItemManager;
  67     this.notifier = notificationPropagationManager;
  68     this.subscriptionService = subscriptionService;
  69   }
  70
  71   @Override
  72   public Collection<ItemPermissionsEntity> listItemPermissions(String itemId) {
  73
  74     return permissionsServices.listItemPermissions(itemId);
  75   }
  76
  77   @Override
  78   public Set<String> listUserPermittedItems(String userId, String permission) {
  79     return permissionsServices.listUserPermittedItems(userId,permission);
  80   }
  81
  82   @Override
  83   public void updateItemPermissions(String itemId, String permission, Set<String> addedUsersIds,
  84                                     Set<String> removedUsersIds) {
  85
  86     String currentUser =
  87         SessionContextProviderFactory.getInstance().createInterface().get().getUser().getUserId();
  88
  89     if (!permissionsServices.isAllowed(itemId, currentUser, CHANGE_PERMISSIONS)) {
  90       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
  91           .withMessage(Messages.PERMISSIONS_ERROR.getErrorMessage())
  92           .withId(Messages.PERMISSIONS_ERROR.name())
  93           .withCategory(ErrorCategory.SECURITY).build());
  94     }
  95
  96     if (permission.equals(PermissionTypes.Owner.name()) ){
  97       if (addedUsersIds.size() == 1){
  98         asdcItemManager.updateOwner(itemId,addedUsersIds.iterator().next());
  99     } else {
 100         throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 101             .withMessage(Messages.PERMISSIONS_OWNER_ERROR.getErrorMessage())
 102             .withId(Messages.PERMISSIONS_OWNER_ERROR.name())
 103             .withCategory(ErrorCategory.SECURITY).build());
 104       }
 105     }
 106
 107     permissionsServices
 108         .updateItemPermissions(itemId, permission, addedUsersIds, removedUsersIds);
 109
 110     sendNotifications(itemId, permission, addedUsersIds, removedUsersIds, currentUser);
 111   }
 112
 113   private void sendNotifications(String itemId, String permission, Set<String> addedUsersIds,
 114                                    Set<String> removedUsersIds, String userName) {
 115
 116     Item item = asdcItemManager.get(itemId);
 117     addedUsersIds.forEach(affectedUser -> {
 118       notifyUser(userName, true, item.getName(), itemId, affectedUser, permission);
 119       subscriptionService.subscribe(affectedUser, itemId);
 120     });
 121     removedUsersIds.forEach(affectedUser -> {
 122       notifyUser(userName, false, item.getName(), itemId, affectedUser, permission);
 123       subscriptionService.unsubscribe(affectedUser, itemId);
 124     });
 125
 126   }
 127
 128   private void notifyUser(String userName, boolean granted, String itemName, String itemId,
 129                           String affectedUser, String permission) {
 130     Map<String, Object> details = new HashMap<>();
 131     details.put(PERMISSION_ITEM, permission);
 132     details.put(ITEM_ID_PROP, itemId);
 133     details.put(ITEM_NAME_PROP, itemName);
 134     details.put(PERMISSION_GRANTED, granted);
 135     details.put(PERMISSION_USER, userName);
 136     PermissionEvent permissionEvent = new PermissionEvent(PERMISSION_CHANGED, affectedUser,
 137         details, affectedUser);
 138
 139     try {
 140       notifier.directNotification(permissionEvent, affectedUser);
 141     } catch (Exception e) {
 142       LOGGER.error("Failed to send notification on permission changed for user '" +
 143           affectedUser + "'");
 144     }
 145
 146   }
 147
 148   @Override
 149   public boolean isAllowed(String itemId, String userId, String action) {
 150     return permissionsServices.isAllowed(itemId, userId, action);
 151   }
 152
 153   @Override
 154   public Optional<String> getUserItemPermission(String itemId, String userId) {
 155     return permissionsServices.getUserItemPermission(itemId, userId);
 156   }
 157
 158   @Override
 159   public void deleteItemPermissions(String itemId) {
 160     permissionsServices.deleteItemPermissions(itemId);
 161   }
 162
 163   private class PermissionEvent implements Event {
 164
 165     private String eventType;
 166     private String originatorId;
 167     private Map<String, Object> attributes;
 168     private String entityId;
 169
 170     private PermissionEvent(String eventType, String originatorId,
 171                             Map<String, Object> attributes, String entityId) {
 172       this.eventType = eventType;
 173       this.originatorId = originatorId;
 174       this.attributes = attributes;
 175       this.entityId = entityId;
 176     }
 177
 178     @Override
 179     public String getEventType() {
 180       return eventType;
 181     }
 182
 183     @Override
 184     public String getOriginatorId() {
 185       return originatorId;
 186     }
 187
 188     @Override
 189     public Map<String, Object> getAttributes() {
 190       return attributes;
 191     }
 192
 193     @Override
 194     public String getEntityId() {
 195       return entityId;
 196     }
 197   }
 198 }