2 * Copyright © 2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 package org.openecomp.sdcrests.vendorlicense.rest.services;
20 import org.openecomp.core.dao.UniqueValueDaoFactory;
21 import org.openecomp.core.util.UniqueValueUtil;
22 import org.openecomp.sdc.common.errors.CoreException;
23 import org.openecomp.sdc.common.errors.ErrorCode;
24 import org.openecomp.sdc.common.errors.Messages;
25 import org.openecomp.sdc.datatypes.model.ItemType;
26 import org.openecomp.sdc.healing.factory.HealingManagerFactory;
27 import org.openecomp.sdc.itempermissions.PermissionsManager;
28 import org.openecomp.sdc.itempermissions.PermissionsManagerFactory;
29 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
30 import org.openecomp.sdc.logging.api.Logger;
31 import org.openecomp.sdc.logging.api.LoggerFactory;
32 import org.openecomp.sdc.notification.dtos.Event;
33 import org.openecomp.sdc.notification.factories.NotificationPropagationManagerFactory;
34 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
35 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
36 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
37 import org.openecomp.sdc.vendorlicense.VendorLicenseManagerFactory;
38 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
39 import org.openecomp.sdc.versioning.AsdcItemManager;
40 import org.openecomp.sdc.versioning.AsdcItemManagerFactory;
41 import org.openecomp.sdc.versioning.VersioningManager;
42 import org.openecomp.sdc.versioning.VersioningManagerFactory;
43 import org.openecomp.sdc.versioning.dao.types.Version;
44 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
45 import org.openecomp.sdc.versioning.types.Item;
46 import org.openecomp.sdc.versioning.types.ItemStatus;
47 import org.openecomp.sdc.versioning.types.NotificationEventTypes;
48 import org.openecomp.sdcrests.item.rest.mapping.MapItemToDto;
49 import org.openecomp.sdcrests.item.rest.mapping.MapVersionToDto;
50 import org.openecomp.sdcrests.item.types.ItemCreationDto;
51 import org.openecomp.sdcrests.item.types.ItemDto;
52 import org.openecomp.sdcrests.item.types.VersionDto;
53 import org.openecomp.sdcrests.vendorlicense.rest.VendorLicenseModels;
54 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapVendorLicenseModelEntityToDto;
55 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity;
56 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelActionRequestDto;
57 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelEntityDto;
58 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelRequestDto;
59 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
60 import org.springframework.context.annotation.Scope;
61 import org.springframework.stereotype.Service;
62 import org.springframework.validation.annotation.Validated;
64 import javax.inject.Named;
65 import javax.ws.rs.core.Response;
66 import java.util.HashMap;
68 import java.util.Objects;
69 import java.util.function.Predicate;
71 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
72 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.*;
73 import static org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelActionRequestDto.VendorLicenseModelAction.Submit;
76 @Service("vendorLicenseModels")
77 @Scope(value = "prototype")
79 public class VendorLicenseModelsImpl implements VendorLicenseModels {
81 private static final String SUBMIT_ITEM_ACTION = "Submit_Item";
82 private static final String SUBMIT_HEALED_VERSION_ERROR =
83 "VLM Id %s: Error while submitting version %s created based on Certified version %s for healing purpose.";
84 private static final Logger LOGGER = LoggerFactory.getLogger(VendorLicenseModelsImpl.class);
85 private PermissionsManager permissionsManager = PermissionsManagerFactory.getInstance().createInterface();
86 private NotificationPropagationManager notifier =
87 NotificationPropagationManagerFactory.getInstance().createInterface();
89 private AsdcItemManager asdcItemManager = AsdcItemManagerFactory.getInstance().createInterface();
90 private VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
91 private VendorLicenseManager vendorLicenseManager = VendorLicenseManagerFactory.getInstance().createInterface();
92 private UniqueValueUtil uniqueValueUtil =
93 new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
96 public Response listLicenseModels(String versionStatus, String itemStatus, String user) {
97 Predicate<Item> itemPredicate = createItemPredicate(versionStatus, itemStatus, user);
99 GenericCollectionWrapper<ItemDto> results = new GenericCollectionWrapper<>();
100 MapItemToDto mapper = new MapItemToDto();
101 asdcItemManager.list(itemPredicate).stream()
102 .sorted((o1, o2) -> o2.getModificationTime().compareTo(o1.getModificationTime()))
103 .forEach(item -> results.add(mapper.applyMapping(item, ItemDto.class)));
105 return Response.ok(results).build();
109 public Response createLicenseModel(VendorLicenseModelRequestDto request, String user) {
111 Item item = new Item();
112 item.setType(ItemType.vlm.name());
114 item.setStatus(ItemStatus.ACTIVE);
115 item.setName(request.getVendorName());
116 item.setDescription(request.getDescription());
118 uniqueValueUtil.validateUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, item.getName());
119 item = asdcItemManager.create(item);
120 uniqueValueUtil.createUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, item.getName());
122 Version version = versioningManager.create(item.getId(), new Version(), null);
124 VendorLicenseModelEntity vlm = new MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity()
125 .applyMapping(request, VendorLicenseModelEntity.class);
126 vlm.setId(item.getId());
127 vlm.setVersion(version);
129 vendorLicenseManager.createVendorLicenseModel(vlm);
130 versioningManager.publish(item.getId(), version, "Initial vlm:" + vlm.getVendorName());
132 ItemCreationDto itemCreationDto = new ItemCreationDto();
133 itemCreationDto.setItemId(item.getId());
134 itemCreationDto.setVersion(new MapVersionToDto().applyMapping(version, VersionDto.class));
136 return Response.ok(itemCreationDto).build();
140 public Response updateLicenseModel(VendorLicenseModelRequestDto request, String vlmId, String versionId,
142 VendorLicenseModelEntity vlm = new MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity()
143 .applyMapping(request, VendorLicenseModelEntity.class);
145 vlm.setVersion(new Version(versionId));
147 vendorLicenseManager.updateVendorLicenseModel(vlm);
148 return Response.ok().build();
152 public Response getLicenseModel(String vlmId, String versionId, String user) {
153 Version version = versioningManager.get(vlmId, new Version(versionId));
154 VendorLicenseModelEntity vlm = vendorLicenseManager.getVendorLicenseModel(vlmId, version);
157 HealingManagerFactory.getInstance().createInterface()
158 .healItemVersion(vlmId, version, ItemType.vlm, false)
159 .ifPresent(healedVersion -> {
160 vlm.setVersion(healedVersion);
161 if (version.getStatus() == VersionStatus.Certified) {
162 submitHealedVersion(vlmId, healedVersion, versionId, user);
165 } catch (Exception e) {
166 LOGGER.error(String.format("Error while auto healing VLM with Id %s and version %s", vlmId, versionId), e);
169 VendorLicenseModelEntityDto vlmDto =
170 new MapVendorLicenseModelEntityToDto().applyMapping(vlm, VendorLicenseModelEntityDto.class);
171 return Response.ok(vlmDto).build();
175 public Response deleteLicenseModel(String vlmId, String user) {
176 Item vlm = asdcItemManager.get(vlmId);
178 if (!vlm.getType().equals(ItemType.vlm.name())) {
179 throw new CoreException((new ErrorCode.ErrorCodeBuilder()
180 .withMessage(String.format("Vlm with id %s does not exist.", vlmId))
184 Integer certifiedVersionsCounter = vlm.getVersionStatusCounters().get(VersionStatus.Certified);
185 if (Objects.isNull(certifiedVersionsCounter) || certifiedVersionsCounter == 0) {
186 asdcItemManager.delete(vlm);
187 permissionsManager.deleteItemPermissions(vlmId);
188 uniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, vlm.getName());
189 notifyUsers(vlmId, vlm.getName(), null, null, user, NotificationEventTypes.DELETE);
191 return Response.ok().build();
193 return Response.status(Response.Status.FORBIDDEN)
194 .entity(new Exception(Messages.DELETE_VLM_ERROR.getErrorMessage())).build();
199 public Response actOnLicenseModel(VendorLicenseModelActionRequestDto request, String vlmId, String versionId,
201 Version version = new Version(versionId);
203 if (request.getAction() == Submit) {
204 if (!permissionsManager.isAllowed(vlmId, user, SUBMIT_ITEM_ACTION)) {
205 return Response.status(Response.Status.FORBIDDEN)
206 .entity(new Exception(Messages.PERMISSIONS_ERROR.getErrorMessage())).build();
208 String message = request.getSubmitRequest() == null ? "Submit" : request.getSubmitRequest().getMessage();
209 submit(vlmId, version, message, user);
211 notifyUsers(vlmId, null, version, message, user, NotificationEventTypes.SUBMIT);
214 return Response.ok().build();
217 private void submit(String vlmId, Version version, String message, String user) {
219 vendorLicenseManager.validate(vlmId, version);
220 versioningManager.submit(vlmId, version, message);
223 private void submitHealedVersion(String vlmId, Version healedVersion, String baseVersionId, String user) {
225 submit(vlmId, healedVersion, "Submit after heal", user);
226 } catch (Exception ex) {
227 LOGGER.error(String.format(SUBMIT_HEALED_VERSION_ERROR, vlmId, healedVersion.getId(), baseVersionId), ex);
231 private void notifyUsers(String itemId, String itemName, Version version, String message, String userName,
232 NotificationEventTypes eventType) {
233 Map<String, Object> eventProperties = new HashMap<>();
234 eventProperties.put(ITEM_NAME, itemName == null ? asdcItemManager.get(itemId).getName() : itemName);
235 eventProperties.put(ITEM_ID, itemId);
237 if (version != null) {
238 eventProperties.put(VERSION_NAME,
239 version.getName() == null ? versioningManager.get(itemId, version).getName() : version.getName());
240 eventProperties.put(VERSION_ID, version.getId());
243 eventProperties.put(SUBMIT_DESCRIPTION, message);
244 eventProperties.put(PERMISSION_USER, userName);
246 Event syncEvent = new SyncEvent(eventType.getEventName(), itemId, eventProperties, itemId);
248 notifier.notifySubscribers(syncEvent, userName);
249 } catch (Exception e) {
250 LOGGER.error("Failed to send sync notification to users subscribed o item '" + itemId);
254 private class SyncEvent implements Event {
256 private String eventType;
257 private String originatorId;
258 private Map<String, Object> attributes;
259 private String entityId;
261 SyncEvent(String eventType, String originatorId, Map<String, Object> attributes, String entityId) {
262 this.eventType = eventType;
263 this.originatorId = originatorId;
264 this.attributes = attributes;
265 this.entityId = entityId;
269 public String getEventType() {
274 public String getOriginatorId() {
279 public Map<String, Object> getAttributes() {
284 public String getEntityId() {
289 private boolean userHasPermission(String itemId, String userId) {
290 return permissionsManager.getUserItemPermission(itemId, userId)
291 .map(permission -> permission
292 .matches(PermissionTypes.Contributor.name() + "|" + PermissionTypes.Owner.name()))
296 private Predicate<Item> createItemPredicate(String versionStatus, String itemStatus, String user) {
297 Predicate<Item> itemPredicate = item -> ItemType.vlm.name().equals(item.getType());
299 if (ItemStatus.ARCHIVED.name().equals(itemStatus)) {
300 itemPredicate = itemPredicate.and(item -> ItemStatus.ARCHIVED.equals(item.getStatus()));
302 itemPredicate = itemPredicate.and(item -> ItemStatus.ACTIVE.equals(item.getStatus()));
304 if (VersionStatus.Certified.name().equals(versionStatus)) {
306 itemPredicate.and(item -> item.getVersionStatusCounters().containsKey(VersionStatus.Certified));
308 } else if (VersionStatus.Draft.name().equals(versionStatus)) {
309 itemPredicate = itemPredicate
310 .and(item -> item.getVersionStatusCounters().containsKey(VersionStatus.Draft)
311 && userHasPermission(item.getId(), user));
314 return itemPredicate;