catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentBusinessLogic.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.components.impl;
  23
  24 import fj.data.Either;
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Map.Entry;
  30 import java.util.Optional;
  31 import java.util.function.BiFunction;
  32 import java.util.function.BooleanSupplier;
  33 import java.util.stream.Collectors;
  34 import org.apache.commons.collections.CollectionUtils;
  35 import org.apache.commons.lang3.StringUtils;
  36 import org.apache.commons.lang3.tuple.ImmutablePair;
  37 import org.openecomp.sdc.be.catalog.enums.ChangeTypeEnum;
  38 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  39 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  40 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  41 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  42 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
  43 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
  44 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
  45 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
  46 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
  47 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
  48 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
  49 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  50 import org.openecomp.sdc.be.config.ConfigurationManager;
  51 import org.openecomp.sdc.be.dao.api.ActionStatus;
  52 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  53 import org.openecomp.sdc.be.dao.utils.MapUtil;
  54 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  55 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
  56 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  57 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  58 import org.openecomp.sdc.be.datatypes.enums.FilterKeyEnum;
  59 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  60 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  61 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  62 import org.openecomp.sdc.be.facade.operations.CatalogOperation;
  63 import org.openecomp.sdc.be.impl.ComponentsUtils;
  64 import org.openecomp.sdc.be.model.ArtifactDefinition;
  65 import org.openecomp.sdc.be.model.AttributeDefinition;
  66 import org.openecomp.sdc.be.model.CapReqDef;
  67 import org.openecomp.sdc.be.model.Component;
  68 import org.openecomp.sdc.be.model.ComponentInstance;
  69 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  70 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  71 import org.openecomp.sdc.be.model.ComponentParametersView;
  72 import org.openecomp.sdc.be.model.DataTypeDefinition;
  73 import org.openecomp.sdc.be.model.GroupDefinition;
  74 import org.openecomp.sdc.be.model.IComponentInstanceConnectedElement;
  75 import org.openecomp.sdc.be.model.InputDefinition;
  76 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  77 import org.openecomp.sdc.be.model.Operation;
  78 import org.openecomp.sdc.be.model.PropertyDefinition;
  79 import org.openecomp.sdc.be.model.Resource;
  80 import org.openecomp.sdc.be.model.User;
  81 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  82 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  83 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  84 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  85 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  86 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  87 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  88 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  89 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  90 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  91 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  92 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  93 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  94 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  95 import org.openecomp.sdc.be.user.Role;
  96 import org.openecomp.sdc.be.utils.CommonBeUtils;
  97 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  98 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  99 import org.openecomp.sdc.common.log.wrappers.Logger;
 100 import org.openecomp.sdc.common.util.ValidationUtils;
 101 import org.openecomp.sdc.exception.ResponseFormat;
 102 import org.springframework.beans.factory.annotation.Autowired;
 103
 104 public abstract class ComponentBusinessLogic extends BaseBusinessLogic {
 105
 106     private static final Logger log = Logger.getLogger(ComponentBusinessLogic.class.getName());
 107     protected final GroupBusinessLogic groupBusinessLogic;
 108     protected ArtifactsBusinessLogic artifactsBusinessLogic;
 109     protected GenericTypeBusinessLogic genericTypeBusinessLogic;
 110     protected ComponentDescriptionValidator componentDescriptionValidator;
 111     protected ComponentProjectCodeValidator componentProjectCodeValidator;
 112     protected CatalogOperation catalogOperations;
 113     protected ComponentIconValidator componentIconValidator;
 114     protected ComponentTagsValidator componentTagsValidator;
 115     protected ComponentNameValidator componentNameValidator;
 116     protected ComponentContactIdValidator componentContactIdValidator;
 117
 118     public ComponentBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
 119                                   IGroupTypeOperation groupTypeOperation, GroupBusinessLogic groupBusinessLogic,
 120                                   InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
 121                                   ArtifactsBusinessLogic artifactsBusinessLogic, ArtifactsOperations artifactToscaOperation,
 122                                   ComponentContactIdValidator componentContactIdValidator, ComponentNameValidator componentNameValidator,
 123                                   ComponentTagsValidator componentTagsValidator, ComponentValidator componentValidator,
 124                                   ComponentIconValidator componentIconValidator, ComponentProjectCodeValidator componentProjectCodeValidator,
 125                                   ComponentDescriptionValidator componentDescriptionValidator) {
 126         super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
 127             artifactToscaOperation);
 128         this.artifactsBusinessLogic = artifactsBusinessLogic;
 129         this.groupBusinessLogic = groupBusinessLogic;
 130         this.componentContactIdValidator = componentContactIdValidator;
 131         this.componentNameValidator = componentNameValidator;
 132         this.componentTagsValidator = componentTagsValidator;
 133         this.componentIconValidator = componentIconValidator;
 134         this.componentProjectCodeValidator = componentProjectCodeValidator;
 135         this.componentDescriptionValidator = componentDescriptionValidator;
 136     }
 137
 138     private static Either<ArtifactDefinition, Operation> saveToscaArtifactAndPopulateToscaArtifactsWithResult(Component component,
 139                                                                                                               final ComponentsUtils componentsUtils,
 140                                                                                                               final ArtifactTypeEnum artifactEnum,
 141                                                                                                               final BiFunction<Component, ArtifactDefinition, Either<ArtifactDefinition, Operation>> saveToscaArtifactPayloadFunction) {
 142         ArtifactDefinition artifactDefinition = getToscaArtifactByTypeOrThrowException(component, artifactEnum, componentsUtils);
 143         Either<ArtifactDefinition, Operation> result = saveToscaArtifactPayloadFunction.apply(component, artifactDefinition);
 144         if (result.isLeft()) {
 145             ArtifactDefinition def = result.left().value();
 146             component.getToscaArtifacts().put(def.getArtifactLabel(), def);
 147         }
 148         return result;
 149     }
 150
 151     private static Optional<ArtifactDefinition> getToscaArtifactByType(final Map<String, ArtifactDefinition> toscaArtifacts,
 152                                                                        final ArtifactTypeEnum typeEnum) {
 153         return toscaArtifacts.values().stream().filter(p -> p.getArtifactType().equals(typeEnum.getType())).findAny();
 154     }
 155
 156     private static ArtifactDefinition getToscaArtifactByTypeOrThrowException(final Component component, final ArtifactTypeEnum typeEnum,
 157                                                                              final ComponentsUtils componentsUtils) {
 158         return Optional.ofNullable(component.getToscaArtifacts()).flatMap(toscaArtifacts -> getToscaArtifactByType(toscaArtifacts, typeEnum))
 159             .orElseThrow(() -> {
 160                 log.debug("Impossible to find a ToscaArtifact with type '{}' for {}", typeEnum.getType(), component);
 161                 return new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, typeEnum.name()));
 162             });
 163     }
 164
 165     public void setComponentDescriptionValidator(ComponentDescriptionValidator componentDescriptionValidator) {
 166         this.componentDescriptionValidator = componentDescriptionValidator;
 167     }
 168
 169     public void setComponentProjectCodeValidator(ComponentProjectCodeValidator componentProjectCodeValidator) {
 170         this.componentProjectCodeValidator = componentProjectCodeValidator;
 171     }
 172
 173     public void setComponentIconValidator(ComponentIconValidator componentIconValidator) {
 174         this.componentIconValidator = componentIconValidator;
 175     }
 176
 177     public void setComponentContactIdValidator(ComponentContactIdValidator componentContactIdValidator) {
 178         this.componentContactIdValidator = componentContactIdValidator;
 179     }
 180
 181     public void setComponentTagsValidator(ComponentTagsValidator componentTagsValidator) {
 182         this.componentTagsValidator = componentTagsValidator;
 183     }
 184
 185     public void setComponentNameValidator(ComponentNameValidator componentNameValidator) {
 186         this.componentNameValidator = componentNameValidator;
 187     }
 188
 189     @Autowired
 190     public void setGenericTypeBusinessLogic(GenericTypeBusinessLogic genericTypeBusinessLogic) {
 191         this.genericTypeBusinessLogic = genericTypeBusinessLogic;
 192     }
 193
 194     public abstract Either<List<String>, ResponseFormat> deleteMarkedComponents();
 195
 196     public abstract ComponentInstanceBusinessLogic getComponentInstanceBL();
 197
 198     public abstract Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(String componentId,
 199                                                                                                                        String userId);
 200
 201     /**
 202      * @param componentId
 203      * @param dataParamsToReturn
 204      * @return
 205      */
 206     public abstract Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String componentId,
 207                                                                                                             List<String> dataParamsToReturn);
 208
 209     User validateUser(User user, String ecompErrorContext, Component component, AuditingActionEnum auditAction, boolean inTransaction) {
 210         User validatedUser;
 211         ResponseFormat responseFormat;
 212         try {
 213             validateUserNotEmpty(user, ecompErrorContext);
 214             validatedUser = validateUserExists(user);
 215         } catch (ByActionStatusComponentException e) {
 216             if (e.getActionStatus() == ActionStatus.MISSING_INFORMATION) {
 217                 user.setUserId("UNKNOWN");
 218             }
 219             responseFormat = componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 220             componentsUtils.auditComponentAdmin(responseFormat, user, component, auditAction, component.getComponentType());
 221             throw e;
 222         } catch (ByResponseFormatComponentException e) {
 223             responseFormat = e.getResponseFormat();
 224             componentsUtils.auditComponentAdmin(responseFormat, user, component, auditAction, component.getComponentType());
 225             throw e;
 226         }
 227         return validatedUser;
 228     }
 229
 230     protected void validateUserRole(User user, Component component, List<Role> roles, AuditingActionEnum auditAction, String comment) {
 231         if (roles != null && roles.isEmpty()) {
 232             roles.add(Role.ADMIN);
 233             roles.add(Role.DESIGNER);
 234         }
 235         try {
 236             validateUserRole(user, roles);
 237         } catch (ByActionStatusComponentException e) {
 238             ResponseFormat responseFormat = componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 239             handleComponentException(component, comment, responseFormat, user, auditAction);
 240             throw e;
 241         } catch (ByResponseFormatComponentException e) {
 242             ResponseFormat responseFormat = e.getResponseFormat();
 243             handleComponentException(component, comment, responseFormat, user, auditAction);
 244             throw e;
 245         }
 246     }
 247
 248     private void handleComponentException(Component component, String comment, ResponseFormat responseFormat, User user,
 249                                           AuditingActionEnum auditAction) {
 250         String commentStr = null;
 251         String distrStatus = null;
 252         ComponentTypeEnum componentType = component.getComponentType();
 253         if (componentType == ComponentTypeEnum.SERVICE) {
 254             distrStatus = ((ServiceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition())
 255                 .getDistributionStatus();
 256             commentStr = comment;
 257         }
 258         componentsUtils.auditComponent(responseFormat, user, component, auditAction, new ResourceCommonInfo(componentType.getValue()),
 259             ResourceVersionInfo.newBuilder().distributionStatus(distrStatus).build(),
 260             ResourceVersionInfo.newBuilder().distributionStatus(distrStatus).build(), commentStr, null, null);
 261     }
 262
 263     public Either<Boolean, ResponseFormat> validateConformanceLevel(String componentUuid, ComponentTypeEnum componentTypeEnum, String userId) {
 264         log.trace("validate conformance level");
 265         if (componentTypeEnum != ComponentTypeEnum.SERVICE) {
 266             log.error("conformance level validation for non service component, id {}", componentUuid);
 267             ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
 268             return Either.right(errorResponse);
 269         }
 270         validateUserExists(userId);
 271         Either<ComponentMetadataData, StorageOperationStatus> eitherComponent = toscaOperationFacade
 272             .getLatestComponentMetadataByUuid(componentUuid, JsonParseFlagEnum.ParseMetadata, null);
 273         if (eitherComponent.isRight()) {
 274             log.error("can't validate conformance level, component not found, uuid {}", componentUuid);
 275             BeEcompErrorManager.getInstance().logBeComponentMissingError("validateConformanceLevel", componentTypeEnum.getValue(), componentUuid);
 276             StorageOperationStatus status = eitherComponent.right().value();
 277             ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(status, componentTypeEnum);
 278             ResponseFormat responseFormat = componentsUtils.getResponseFormat(actionStatus);
 279             return Either.right(responseFormat);
 280         }
 281         String componentConformanceLevel = eitherComponent.left().value().getMetadataDataDefinition().getConformanceLevel();
 282         if (StringUtils.isBlank(componentConformanceLevel)) {
 283             log.error("component conformance level property is null or empty, uuid {}", componentUuid);
 284             ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 285             return Either.right(errorResponse);
 286         }
 287         String configConformanceLevel = ConfigurationManager.getConfigurationManager().getConfiguration().getMinToscaConformanceLevel();
 288         Boolean result = true;
 289         if (CommonBeUtils.conformanceLevelCompare(componentConformanceLevel, configConformanceLevel) < 0) {
 290             log.error("invalid asset conformance level, uuid {}, asset conformanceLevel {}, config conformanceLevel {}", componentUuid,
 291                 componentConformanceLevel, configConformanceLevel);
 292             result = false;
 293         }
 294         log.trace("conformance level validation finished");
 295         return Either.left(result);
 296     }
 297
 298     protected void validateIcon(User user, Component component, AuditingActionEnum actionEnum) {
 299         log.debug("validate Icon");
 300         ComponentTypeEnum type = component.getComponentType();
 301         String icon = component.getIcon();
 302         if (!ValidationUtils.validateStringNotEmpty(icon)) {
 303             log.info("icon is missing.");
 304             ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_ICON, type.getValue());
 305             componentsUtils.auditComponentAdmin(errorResponse, user, component, actionEnum, type);
 306             throw new ComponentException(ActionStatus.COMPONENT_MISSING_ICON, type.getValue());
 307         }
 308         try {
 309             validateIcon(icon, type);
 310         } catch (ComponentException e) {
 311             ResponseFormat responseFormat =
 312                 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 313             componentsUtils.auditComponentAdmin(responseFormat, user, component, actionEnum, type);
 314             throw e;
 315         }
 316     }
 317
 318     private void validateIcon(String icon, ComponentTypeEnum type) {
 319         if (icon != null) {
 320             if (!ValidationUtils.validateIconLength(icon)) {
 321                 log.debug("icon exceeds max length");
 322                 throw new ComponentException(ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, type.getValue(), "" + ValidationUtils.ICON_MAX_LENGTH);
 323             }
 324             if (!ValidationUtils.validateIcon(icon)) {
 325                 log.info("icon is invalid.");
 326                 throw new ComponentException(ActionStatus.COMPONENT_INVALID_ICON, type.getValue());
 327             }
 328         }
 329     }
 330
 331     protected void checkComponentFieldsForOverrideAttempt(Component component) {
 332         if (component.getLifecycleState() != null) {
 333             log.info("LifecycleState cannot be defined by user. This field will be overridden by the application");
 334         }
 335         if (component.getVersion() != null) {
 336             log.info("Version cannot be defined by user. This field will be overridden by the application");
 337         }
 338         if (component.getCreatorUserId() != null || component.getCreatorFullName() != null) {
 339             log.info("Creator cannot be defined by user. This field will be overridden by the application");
 340         }
 341         if (component.getLastUpdaterUserId() != null || component.getLastUpdaterFullName() != null) {
 342             log.info("Last Updater cannot be defined by user. This field will be overridden by the application");
 343         }
 344         if (component.getCreationDate() != null) {
 345             log.info("Creation Date cannot be defined by user. This field will be overridden by the application");
 346         }
 347         if (component.isHighestVersion() != null) {
 348             log.info("Is Highest Version cannot be defined by user. This field will be overridden by the application");
 349         }
 350         if (component.getUUID() != null) {
 351             log.info("UUID cannot be defined by user. This field will be overridden by the application");
 352         }
 353         if (component.getLastUpdateDate() != null) {
 354             log.info("Last Update Date cannot be defined by user. This field will be overridden by the application");
 355         }
 356         if (component.getUniqueId() != null) {
 357             log.info("uid cannot be defined by user. This field will be overridden by the application.");
 358             component.setUniqueId(null);
 359         }
 360         if (component.getInvariantUUID() != null) {
 361             log.info("Invariant UUID cannot be defined by user. This field will be overridden by the application.");
 362         }
 363     }
 364
 365     protected void validateComponentFieldsBeforeCreate(User user, Component component, AuditingActionEnum actionEnum) {
 366         // validate component name uniqueness
 367         log.debug("validate component name ");
 368         componentNameValidator.validateAndCorrectField(user, component, actionEnum);
 369         // validate description
 370         log.debug("validate description");
 371         componentDescriptionValidator.validateAndCorrectField(user, component, actionEnum);
 372         // validate tags
 373         log.debug("validate tags");
 374         componentTagsValidator.validateAndCorrectField(user, component, actionEnum);
 375         // validate contact info
 376         log.debug("validate contact info");
 377         componentContactIdValidator.validateAndCorrectField(user, component, actionEnum);
 378         // validate icon
 379         log.debug("validate icon");
 380         validateIcon(user, component, actionEnum);
 381     }
 382
 383     public CapReqDef getRequirementsAndCapabilities(String componentId, ComponentTypeEnum componentTypeEnum, String userId) {
 384         validateUserExists(userId);
 385         ComponentParametersView filter = new ComponentParametersView(true);
 386         filter.setIgnoreCapabilities(false);
 387         filter.setIgnoreRequirements(false);
 388         filter.setIgnoreComponentInstances(false);
 389         try {
 390             Component component = validateComponentExists(componentId, componentTypeEnum, filter);
 391             return new CapReqDef(component.getRequirements(), component.getCapabilities());
 392         } catch (ComponentException e) {
 393             BeEcompErrorManager.getInstance().logBeComponentMissingError("getRequirementsAndCapabilities", componentTypeEnum.getValue(), componentId);
 394             throwComponentException(e.getResponseFormat());
 395         }
 396         return null;
 397     }
 398
 399     public Either<List<Component>, ResponseFormat> getLatestVersionNotAbstractComponents(boolean isAbstractAbstract,
 400                                                                                          ComponentTypeEnum componentTypeEnum,
 401                                                                                          String internalComponentType, List<String> componentUids,
 402                                                                                          String userId) {
 403         try {
 404             validateUserExists(userId);
 405             List<Component> result = new ArrayList<>();
 406             List<String> componentsUidToFetch = new ArrayList<>();
 407             componentsUidToFetch.addAll(componentUids);
 408             if (!componentsUidToFetch.isEmpty()) {
 409                 log.debug("Number of Components to fetch from graph is {}", componentsUidToFetch.size());
 410                 Either<List<Component>, StorageOperationStatus> nonCheckoutCompResponse = toscaOperationFacade
 411                     .getLatestVersionNotAbstractComponents(isAbstractAbstract, componentTypeEnum, internalComponentType, componentsUidToFetch);
 412                 if (nonCheckoutCompResponse.isLeft()) {
 413                     log.debug("Retrived Resource successfully.");
 414                     result.addAll(nonCheckoutCompResponse.left().value());
 415                 } else {
 416                     return Either.right(
 417                         componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(nonCheckoutCompResponse.right().value())));
 418                 }
 419             }
 420             return Either.left(result);
 421         } finally {
 422             janusGraphDao.commit();
 423         }
 424     }
 425
 426     public Either<List<Component>, ResponseFormat> getLatestVersionNotAbstractComponentsMetadata(boolean isAbstractAbstract,
 427                                                                                                  HighestFilterEnum highestFilter,
 428                                                                                                  ComponentTypeEnum componentTypeEnum,
 429                                                                                                  String internalComponentType, String userId,
 430                                                                                                  String modelName) {
 431         Either<List<Component>, StorageOperationStatus> nonCheckoutCompResponse = null;
 432         try {
 433             validateUserExists(userId);
 434            nonCheckoutCompResponse = toscaOperationFacade
 435                 .getLatestVersionNotAbstractMetadataOnly(isAbstractAbstract, componentTypeEnum, internalComponentType, modelName);
 436             if (nonCheckoutCompResponse.isLeft()) {
 437                 log.debug("Retrieved Resource successfully.");
 438                 return Either.left(nonCheckoutCompResponse.left().value());
 439             }
 440             return Either
 441                 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(nonCheckoutCompResponse.right().value())));
 442         } finally {
 443             if(nonCheckoutCompResponse != null && nonCheckoutCompResponse.isLeft() ) {
 444                 janusGraphDao.commit();
 445             }
 446         }
 447     }
 448
 449     public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
 450     }
 451
 452     @SuppressWarnings("unchecked")
 453     public void setToscaArtifactsPlaceHolders(Component component, User user) {
 454         Map<String, ArtifactDefinition> artifactMap = component.getToscaArtifacts();
 455         if (artifactMap == null) {
 456             artifactMap = new HashMap<>();
 457         }
 458         String componentUniqueId = component.getUniqueId();
 459         String componentSystemName = component.getSystemName();
 460         String componentType = component.getComponentType().getValue().toLowerCase();
 461         Map<String, Object> toscaArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getToscaArtifacts();
 462         if (toscaArtifacts != null) {
 463             for (Entry<String, Object> artifactInfoMap : toscaArtifacts.entrySet()) {
 464                 Map<String, Object> artifactInfo = (Map<String, Object>) artifactInfoMap.getValue();
 465                 ArtifactDefinition artifactDefinition = artifactsBusinessLogic
 466                     .createArtifactPlaceHolderInfo(componentUniqueId, artifactInfoMap.getKey(), artifactInfo, user, ArtifactGroupTypeEnum.TOSCA);
 467                 artifactDefinition
 468                     .setArtifactName(ValidationUtils.normalizeFileName(componentType + "-" + componentSystemName + artifactInfo.get("artifactName")));
 469                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
 470             }
 471         }
 472         component.setToscaArtifacts(artifactMap);
 473     }
 474
 475     public Either<ArtifactDefinition, Operation> populateToscaArtifacts(Component component, User user, boolean isInCertificationRequest,
 476                                                                         boolean inTransaction, boolean shouldLock) {
 477         return populateToscaArtifacts(component, user, isInCertificationRequest, inTransaction, shouldLock, true, true);
 478     }
 479
 480     public Either<ArtifactDefinition, Operation> populateToscaArtifacts(Component component, User user, boolean isInCertificationRequest,
 481                                                                         boolean inTransaction, boolean shouldLock, boolean retrieveResource) {
 482         return populateToscaArtifacts(component, user, isInCertificationRequest, inTransaction, shouldLock, true, retrieveResource);
 483     }
 484
 485     private Either<ArtifactDefinition, Operation> populateToscaArtifacts(Component component, User user, boolean isInCertificationRequest,
 486                                                                          boolean inTransaction, boolean shouldLock, boolean fetchTemplatesFromDB,
 487                                                                          boolean retrieveResource) {
 488         if (retrieveResource) {
 489             Either<Component, StorageOperationStatus> toscaElement = toscaOperationFacade.getToscaFullElement(component.getUniqueId());
 490             if (toscaElement.isRight()) {
 491                 throw new ByActionStatusComponentException(
 492                     componentsUtils.convertFromStorageResponse(toscaElement.right().value(), component.getComponentType()));
 493             }
 494             component = toscaElement.left().value();
 495         }
 496         Either<ArtifactDefinition, Operation> generateToscaRes = saveToscaArtifactAndPopulateToscaArtifactsWithResult(component, componentsUtils,
 497             ArtifactTypeEnum.TOSCA_TEMPLATE,
 498             (comp, toscaArtifact) -> saveToscaArtifactPayload(toscaArtifact, comp, user, isInCertificationRequest, shouldLock, inTransaction,
 499                 fetchTemplatesFromDB));
 500         if (!isAbstractResource(component)) {
 501             generateToscaRes = saveToscaArtifactAndPopulateToscaArtifactsWithResult(component, componentsUtils, ArtifactTypeEnum.TOSCA_CSAR,
 502                 (comp, toscaArtifactArg) -> saveToscaArtifactPayload(toscaArtifactArg, comp, user, isInCertificationRequest, shouldLock,
 503                     inTransaction, true));
 504         }
 505         return generateToscaRes;
 506     }
 507
 508     private boolean isAbstractResource(Component component) {
 509         return component.getComponentType() == ComponentTypeEnum.RESOURCE && ((Resource) component).isAbstract();
 510     }
 511
 512     private Either<ArtifactDefinition, Operation> saveToscaArtifactPayload(ArtifactDefinition artifactDefinition,
 513                                                                            org.openecomp.sdc.be.model.Component component, User user,
 514                                                                            boolean isInCertificationRequest, boolean shouldLock,
 515                                                                            boolean inTransaction, boolean fetchTemplatesFromDB) {
 516         return artifactsBusinessLogic
 517             .generateAndSaveToscaArtifact(artifactDefinition, component, user, isInCertificationRequest, shouldLock, inTransaction,
 518                 fetchTemplatesFromDB);
 519     }
 520
 521     public ImmutablePair<String, byte[]> getToscaModelByComponentUuid(ComponentTypeEnum componentType, String uuid,
 522                                                                       ResourceCommonInfo resourceCommonInfo) {
 523         Either<List<Component>, StorageOperationStatus> latestVersionEither = toscaOperationFacade.getComponentListByUuid(uuid, null);
 524         if (latestVersionEither.isRight()) {
 525             throw new ByActionStatusComponentException(
 526                 componentsUtils.convertFromStorageResponse(latestVersionEither.right().value(), componentType));
 527         }
 528         List<Component> components = latestVersionEither.left().value();
 529         Component component = components.stream().filter(Component::isHighestVersion).findFirst().orElse(null);
 530         if (component == null) {
 531             component = components.stream().filter(c -> c.getLifecycleState() == LifecycleStateEnum.CERTIFIED).findFirst().orElse(null);
 532         }
 533         if (component == null) {
 534             throw new ByResponseFormatComponentException(
 535                 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND, componentType)));
 536         }
 537         resourceCommonInfo.setResourceName(component.getName());
 538         // TODO remove after migration - handle artifact not found(no
 539
 540         // placeholder)
 541         if (null == component.getToscaArtifacts() || component.getToscaArtifacts().isEmpty()) {
 542             throw new ByResponseFormatComponentException(
 543                 componentsUtils.getResponseFormat(ActionStatus.ARTIFACT_NOT_FOUND, ArtifactTypeEnum.TOSCA_CSAR.name()));
 544         }
 545         ArtifactDefinition csarArtifact = component.getToscaArtifacts().values().stream()
 546             .filter(p -> p.getArtifactType().equals(ArtifactTypeEnum.TOSCA_CSAR.getType())).findAny().get();
 547         return artifactsBusinessLogic.handleDownloadToscaModelRequest(component, csarArtifact);
 548     }
 549
 550     protected StorageOperationStatus markComponentToDelete(Component component) {
 551         ComponentTypeEnum componentType = component.getComponentType();
 552         String uniqueId = component.getUniqueId();
 553         if (Boolean.TRUE.equals(component.getIsDeleted())) {
 554             log.info("component {} already marked as deleted. id= {}, type={}", component.getName(), uniqueId, componentType);
 555             return StorageOperationStatus.NOT_FOUND;
 556         }
 557         StorageOperationStatus markResourceToDelete = toscaOperationFacade.markComponentToDelete(component);
 558         if (StorageOperationStatus.OK != markResourceToDelete) {
 559             log.debug("failed to mark component {} of type {} for delete. error = {}", uniqueId, componentType, markResourceToDelete);
 560             return markResourceToDelete;
 561         } else {
 562             log.debug("Component {}  of type {} was marked as deleted", uniqueId, componentType);
 563             updateCatalog(component, ChangeTypeEnum.DELETE);
 564             return StorageOperationStatus.OK;
 565         }
 566     }
 567
 568     public Either<Boolean, ResponseFormat> validateAndUpdateDescription(User user, Component currentComponent, Component updatedComponent,
 569                                                                         AuditingActionEnum auditingAction) {
 570         String descriptionUpdated = updatedComponent.getDescription();
 571         String descriptionCurrent = currentComponent.getDescription();
 572         if (descriptionUpdated != null && !descriptionCurrent.equals(descriptionUpdated)) {
 573             componentDescriptionValidator.validateAndCorrectField(user, updatedComponent, auditingAction);
 574             currentComponent.setDescription(updatedComponent.getDescription());
 575         }
 576         return Either.left(true);
 577     }
 578
 579     public Either<Boolean, ResponseFormat> validateAndUpdateProjectCode(User user, Component currentComponent, Component updatedComponent) {
 580         String projectCodeUpdated = updatedComponent.getProjectCode();
 581         String projectCodeCurrent = currentComponent.getProjectCode();
 582         if (projectCodeUpdated != null && !projectCodeCurrent.equals(projectCodeUpdated)) {
 583             try {
 584                 componentProjectCodeValidator.validateAndCorrectField(user, updatedComponent, null);
 585             } catch (ComponentException exp) {
 586                 ResponseFormat errorRespons = exp.getResponseFormat();
 587                 return Either.right(errorRespons);
 588             }
 589             currentComponent.setProjectCode(updatedComponent.getProjectCode());
 590         }
 591         return Either.left(true);
 592     }
 593
 594     public Either<Boolean, ResponseFormat> validateAndUpdateIcon(User user, Component currentComponent, Component updatedComponent,
 595                                                                  boolean hasBeenCertified) {
 596         String iconUpdated = updatedComponent.getIcon();
 597         String iconCurrent = currentComponent.getIcon();
 598         if (iconUpdated != null && !iconCurrent.equals(iconUpdated)) {
 599             if (!hasBeenCertified) {
 600                 componentIconValidator.validateAndCorrectField(user, updatedComponent, null);
 601                 currentComponent.setIcon(updatedComponent.getIcon());
 602             } else {
 603                 log.info("icon {} cannot be updated once the component has been certified once.", iconUpdated);
 604                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_PARAMETER_CANNOT_BE_CHANGED, "Icon",
 605                     currentComponent.getComponentType().name().toLowerCase());
 606                 return Either.right(errorResponse);
 607             }
 608         }
 609         return Either.left(true);
 610     }
 611
 612     protected Either<List<String>, ResponseFormat> deleteMarkedComponents(ComponentTypeEnum componentType) {
 613         log.trace("start deleteMarkedComponents");
 614         Either<List<String>, StorageOperationStatus> deleteMarkedElements = toscaOperationFacade.deleteMarkedElements(componentType);
 615         if (deleteMarkedElements.isRight()) {
 616             janusGraphDao.rollback();
 617             ResponseFormat responseFormat = componentsUtils
 618                 .getResponseFormat(componentsUtils.convertFromStorageResponse(deleteMarkedElements.right().value(), componentType));
 619             return Either.right(responseFormat);
 620         }
 621         log.trace("end deleteMarkedComponents");
 622         janusGraphDao.commit();
 623         return Either.left(deleteMarkedElements.left().value());
 624     }
 625
 626     public Either<List<ArtifactDefinition>, StorageOperationStatus> getComponentArtifactsForDelete(String parentId, NodeTypeEnum parentType) {
 627         List<ArtifactDefinition> artifacts = new ArrayList<>();
 628         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsResponse = artifactToscaOperation.getArtifacts(parentId);
 629         if (artifactsResponse.isRight()) {
 630             if (artifactsResponse.right().value() != StorageOperationStatus.NOT_FOUND) {
 631                 log.debug("failed to retrieve artifacts for {} {}", parentType, parentId);
 632                 return Either.right(artifactsResponse.right().value());
 633             }
 634         } else {
 635             artifacts.addAll(artifactsResponse.left().value().values());
 636         }
 637         return Either.left(artifacts);
 638     }
 639
 640     /**
 641      * @param componentId
 642      * @param user
 643      * @param dataParamsToReturn - ui list of params to return
 644      * @return
 645      */
 646     public Either<UiComponentDataTransfer, ResponseFormat> getComponentDataFilteredByParams(String componentId, User user,
 647                                                                                             List<String> dataParamsToReturn) {
 648         if (user != null) {
 649             validateUserExists(user);
 650         }
 651         UiComponentDataTransfer result = new UiComponentDataTransfer();
 652         if (dataParamsToReturn == null || dataParamsToReturn.isEmpty()) {
 653             Either.left(result);
 654         } else {
 655             Either<UiComponentDataTransfer, ResponseFormat> uiDataTransferEither = getUiComponentDataTransferByComponentId(componentId,
 656                 dataParamsToReturn);
 657             if (uiDataTransferEither.isRight()) {
 658                 return Either.right(uiDataTransferEither.right().value());
 659             }
 660             result = uiDataTransferEither.left().value();
 661         }
 662         return Either.left(result);
 663     }
 664
 665     protected <T extends Component> void generateAndAddInputsFromGenericTypeProperties(T component, Resource genericType) {
 666         List<InputDefinition> genericAndComponentInputs = new ArrayList<>();
 667         List<InputDefinition> genericInputs = genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericType);
 668         genericAndComponentInputs.addAll(genericInputs);
 669         if (null != component.getInputs()) {
 670             List<InputDefinition> nonGenericInputsFromComponent = getAllNonGenericInputsFromComponent(genericInputs, component.getInputs());
 671             genericAndComponentInputs.addAll(nonGenericInputsFromComponent);
 672         }
 673         component.setInputs(genericAndComponentInputs);
 674     }
 675
 676     private List<InputDefinition> getAllNonGenericInputsFromComponent(List<InputDefinition> genericInputs, List<InputDefinition> componentInputs) {
 677         if (genericInputs == null) {
 678             return componentInputs;
 679         }
 680         Map<String, InputDefinition> inputByNameMap = MapUtil.toMap(genericInputs, InputDefinition::getName);
 681         List<InputDefinition> componentNonGenericInputs = new ArrayList<>();
 682         componentInputs.stream().forEach(input -> {
 683             if (!inputByNameMap.containsKey(input.getName())) {
 684                 componentNonGenericInputs.add(input);
 685             }
 686         });
 687         return componentNonGenericInputs;
 688     }
 689
 690     protected <T extends Component> Resource fetchAndSetDerivedFromGenericType(T component) {
 691         Either<Resource, ResponseFormat> genericTypeEither = this.genericTypeBusinessLogic.fetchDerivedFromGenericType(component);
 692         if (genericTypeEither.isRight()) {
 693             log.debug("Failed to fetch latest generic type for component {} of type", component.getName(), component.assetType());
 694             throw new ByActionStatusComponentException(ActionStatus.GENERIC_TYPE_NOT_FOUND, component.assetType());
 695         }
 696         Resource genericTypeResource = genericTypeEither.left().value();
 697         component.setDerivedFromGenericInfo(genericTypeResource);
 698         return genericTypeResource;
 699     }
 700
 701     public Either<Map<String, List<IComponentInstanceConnectedElement>>, ResponseFormat> getFilteredComponentInstanceProperties(String componentId,
 702                                                                                                                                 Map<FilterKeyEnum, List<String>> filters,
 703                                                                                                                                 String userId) {
 704         Either<Map<String, List<IComponentInstanceConnectedElement>>, ResponseFormat> response = null;
 705         Either<Component, StorageOperationStatus> getResourceRes = null;
 706         try {
 707             if (!filters.containsKey(FilterKeyEnum.NAME_FRAGMENT) && StringUtils.isEmpty(filters.get(FilterKeyEnum.NAME_FRAGMENT).get(0))) {
 708                 response = Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
 709             }
 710             if (userId != null && response == null) {
 711                 validateUserExists(userId);
 712             }
 713             if (response == null) {
 714                 getResourceRes = toscaOperationFacade.getToscaElement(componentId);
 715                 if (getResourceRes.isRight()) {
 716                     response = Either
 717                         .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(getResourceRes.right().value())));
 718                 }
 719             }
 720             if (response == null) {
 721                 response = getFilteredComponentInstancesProperties(getResourceRes.left().value(), filters);
 722             }
 723         } catch (Exception e) {
 724             log.debug("The exception {} occured during filtered instance properties fetching. the  containing component is {}. ", e, componentId);
 725             response = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 726         } finally {
 727             if (response != null && response.isLeft()) {
 728                 toscaOperationFacade.commit();
 729             } else {
 730                 toscaOperationFacade.rollback();
 731             }
 732         }
 733         return response;
 734     }
 735
 736     private Either<Map<String, List<IComponentInstanceConnectedElement>>, ResponseFormat> getFilteredComponentInstancesProperties(Component component,
 737                                                                                                                                   Map<FilterKeyEnum, List<String>> filters) {
 738         Map<String, List<IComponentInstanceConnectedElement>> filteredProperties = new HashMap<>();
 739         Either<Map<String, List<IComponentInstanceConnectedElement>>, ResponseFormat> result = Either.left(filteredProperties);
 740         List<ComponentInstance> filteredInstances = getFilteredInstances(component, filters.get(FilterKeyEnum.RESOURCE_TYPE));
 741         String propertyNameFragment = filters.get(FilterKeyEnum.NAME_FRAGMENT).get(0);
 742         boolean searchByFragment = propertyNameFragment.length() > 3;
 743         if (CollectionUtils.isNotEmpty(filteredInstances)) {
 744             for (ComponentInstance instance : filteredInstances) {
 745                 if (component.getComponentInstancesProperties() != null && component.getComponentInstancesProperties()
 746                     .containsKey(instance.getUniqueId())) {
 747                     List<IComponentInstanceConnectedElement> currProperties = getFilteredComponentInstanceProperties(
 748                         component.getComponentInstancesProperties().get(instance.getUniqueId()), propertyNameFragment, searchByFragment);
 749                     setFilteredProperties(filteredProperties, instance, currProperties);
 750                 }
 751                 if (component.getComponentInstancesInputs() != null && component.getComponentInstancesInputs().containsKey(instance.getUniqueId())) {
 752                     List<IComponentInstanceConnectedElement> currInputs = getFilteredComponentInstanceInputs(
 753                         component.getComponentInstancesInputs().get(instance.getUniqueId()), propertyNameFragment, searchByFragment);
 754                     if (CollectionUtils.isNotEmpty(currInputs)) {
 755                         checkFilteredProperties(filteredProperties, instance, currInputs);
 756                     }
 757                 }
 758             }
 759         }
 760         return result;
 761     }
 762
 763     private void setFilteredProperties(Map<String, List<IComponentInstanceConnectedElement>> filteredProperties, ComponentInstance instance,
 764                                        List<IComponentInstanceConnectedElement> currProperties) {
 765         if (CollectionUtils.isNotEmpty(currProperties)) {
 766             filteredProperties.put(instance.getUniqueId(), currProperties);
 767         }
 768     }
 769
 770     private void checkFilteredProperties(Map<String, List<IComponentInstanceConnectedElement>> filteredProperties, ComponentInstance instance,
 771                                          List<IComponentInstanceConnectedElement> currInputs) {
 772         if (filteredProperties.get(instance.getUniqueId()) != null) {
 773             filteredProperties.get(instance.getUniqueId()).addAll(currInputs);
 774         } else {
 775             filteredProperties.put(instance.getUniqueId(), currInputs);
 776         }
 777     }
 778
 779     private List<IComponentInstanceConnectedElement> getFilteredComponentInstanceInputs(List<ComponentInstanceInput> inputs,
 780                                                                                         String propertyNameFragment, boolean searchByFragment) {
 781         return inputs.stream().filter(i -> isMatchingInput(i, propertyNameFragment, searchByFragment)).collect(Collectors.toList());
 782     }
 783
 784     private List<IComponentInstanceConnectedElement> getFilteredComponentInstanceProperties(List<ComponentInstanceProperty> instanceProperties,
 785                                                                                             String propertyNameFragment, boolean searchByFragment) {
 786         return instanceProperties.stream().filter(p -> isMatchingProperty(p, propertyNameFragment, searchByFragment)).collect(Collectors.toList());
 787     }
 788
 789     private boolean isMatchingInput(ComponentInstanceInput input, String propertyNameFragment, boolean searchByFragment) {
 790         boolean isMatching = false;
 791         if (searchByFragment && input.getName().toLowerCase().contains(propertyNameFragment)) {
 792             isMatching = true;
 793         }
 794         if (!searchByFragment && input.getName().equalsIgnoreCase(propertyNameFragment)) {
 795             isMatching = true;
 796         }
 797         return isMatching;
 798     }
 799
 800     private boolean isMatchingProperty(ComponentInstanceProperty property, String propertyNameFragment, boolean searchByFragment) {
 801         boolean isMatching = false;
 802         if (searchByFragment && property.getName().toLowerCase().contains(propertyNameFragment)) {
 803             isMatching = true;
 804         }
 805         if (!searchByFragment && property.getName().equalsIgnoreCase(propertyNameFragment)) {
 806             isMatching = true;
 807         }
 808         if (!isMatching && !ToscaPropertyType.isPrimitiveType(property.getType())) {
 809             isMatching = isMatchingComplexPropertyByRecursively(property, propertyNameFragment, searchByFragment);
 810         }
 811         return isMatching;
 812     }
 813
 814     private boolean isMatchingComplexPropertyByRecursively(PropertyDataDefinition property, String propertyNameFragment, boolean searchByFragment) {
 815         String propertyType;
 816         List<PropertyDefinition> dataTypeProperties;
 817         DataTypeDefinition currentProperty;
 818         if (searchByFragment && property.getName().toLowerCase().contains(propertyNameFragment.toLowerCase())) {
 819             return true;
 820         }
 821         if (!searchByFragment && property.getName().equalsIgnoreCase(propertyNameFragment)) {
 822             return true;
 823         }
 824         propertyType = isEmptyInnerType(property) ? property.getType() : property.getSchema().getProperty().getType();
 825         if (ToscaPropertyType.isScalarType(propertyType)) {
 826             return false;
 827         }
 828         Either<DataTypeDefinition, StorageOperationStatus> getDataTypeByNameRes = propertyOperation.getDataTypeByName(propertyType, null);
 829         if (getDataTypeByNameRes.isRight()) {
 830             return false;
 831         }
 832         currentProperty = getDataTypeByNameRes.left().value();
 833         dataTypeProperties = currentProperty.getProperties();
 834         boolean dataPropertiesNotNull = CollectionUtils.isNotEmpty(dataTypeProperties);
 835         BooleanSupplier dataMatchesComplexProperty = () -> isMatchingComplexProperty(propertyNameFragment, searchByFragment, dataTypeProperties);
 836         BooleanSupplier parentPropertiesNotNull = () -> CollectionUtils.isNotEmpty(currentProperty.getDerivedFrom().getProperties());
 837         BooleanSupplier parentDataMatchesComplexProperty = () -> isMatchingComplexProperty(propertyNameFragment, searchByFragment,
 838             currentProperty.getDerivedFrom().getProperties());
 839         return ((dataPropertiesNotNull && dataMatchesComplexProperty.getAsBoolean()) || (parentPropertiesNotNull.getAsBoolean()
 840             && parentDataMatchesComplexProperty.getAsBoolean()));
 841     }
 842
 843     private boolean isMatchingComplexProperty(String propertyNameFragment, boolean searchByFragment, List<PropertyDefinition> dataTypeProperties) {
 844         for (PropertyDefinition prop : dataTypeProperties) {
 845             if (isMatchingComplexPropertyByRecursively(prop, propertyNameFragment, searchByFragment)) {
 846                 return true;
 847             }
 848         }
 849         return false;
 850     }
 851
 852     private boolean isEmptyInnerType(PropertyDataDefinition property) {
 853         return property == null || property.getSchema() == null || property.getSchema().getProperty() == null
 854             || property.getSchema().getProperty().getType() == null;
 855     }
 856
 857     public Either<Boolean, ResponseFormat> shouldUpgradeToLatestGeneric(Component clonedComponent) {
 858         if (!clonedComponent.deriveFromGeneric()) {
 859             return Either.left(false);
 860         }
 861         Boolean shouldUpgrade = false;
 862         String currentGenericType = clonedComponent.getDerivedFromGenericType();
 863         String currentGenericVersion = clonedComponent.getDerivedFromGenericVersion();
 864         Resource genericTypeResource = fetchAndSetDerivedFromGenericType(clonedComponent);
 865         if (null == currentGenericType || !currentGenericType.equals(genericTypeResource.getToscaResourceName()) || !currentGenericVersion
 866             .equals(genericTypeResource.getVersion())) {
 867             shouldUpgrade = upgradeToLatestGeneric(clonedComponent, genericTypeResource);
 868             if (!shouldUpgrade) {
 869                 reverntUpdateOfGenericVersion(clonedComponent, currentGenericType, currentGenericVersion);
 870             }
 871         }
 872         return Either.left(shouldUpgrade);
 873     }
 874
 875     private void reverntUpdateOfGenericVersion(Component clonedComponent, String currentGenericType, String currentGenericVersion) {
 876         clonedComponent.setDerivedFromGenericType(currentGenericType);
 877         clonedComponent.setDerivedFromGenericVersion(currentGenericVersion);
 878     }
 879
 880     private <T extends ToscaDataDefinition> Either<Map<String, T>, String> validateNoConflictingProperties(List<T> currentList,
 881                                                                                                            List<T> upgradedList) {
 882         Map<String, T> currentMap = ToscaDataDefinition.listToMapByName(currentList);
 883         Map<String, T> upgradedMap = ToscaDataDefinition.listToMapByName(upgradedList);
 884         return ToscaDataDefinition.mergeDataMaps(upgradedMap, currentMap, true);
 885     }
 886
 887     private boolean shouldUpgradeNodeType(Component componentToCheckOut, Resource latestGeneric) {
 888         List<PropertyDefinition> genericTypeProps = latestGeneric.getProperties();
 889         Either<Map<String, PropertyDefinition>, String> validPropertiesMerge = validateNoConflictingProperties(genericTypeProps,
 890             ((Resource) componentToCheckOut).getProperties());
 891         if (validPropertiesMerge.isRight()) {
 892             if (log.isDebugEnabled()) {
 893                 log.debug("property {} cannot be overriden, check out performed without upgrading to latest generic",
 894                         validPropertiesMerge.right().value());
 895             }
 896             return false;
 897         }
 898         List<AttributeDefinition> genericTypeAttributes = latestGeneric.getAttributes();
 899         final Either<Map<String, AttributeDefinition>, String> validAttributesMerge = validateNoConflictingProperties(genericTypeAttributes,
 900             ((Resource) componentToCheckOut).getAttributes());
 901         if (validAttributesMerge.isRight()) {
 902             if (log.isDebugEnabled()) {
 903                 log.debug("attribute {} cannot be overriden, check out performed without upgrading to latest generic",
 904                         validAttributesMerge.right().value());
 905             }
 906             return false;
 907         }
 908         return true;
 909     }
 910
 911     private boolean upgradeToLatestGeneric(Component componentToCheckOut, Resource latestGeneric) {
 912         if (!componentToCheckOut.shouldGenerateInputs()) {
 913             //node type - validate properties and attributes
 914             return shouldUpgradeNodeType(componentToCheckOut, latestGeneric);
 915         }
 916         List<PropertyDefinition> genericTypeProps = latestGeneric.getProperties();
 917         List<InputDefinition> genericTypeInputs = null == genericTypeProps ? null
 918             : genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericTypeProps, latestGeneric.getUniqueId());
 919         List<InputDefinition> currentList = new ArrayList<>();
 920         // nullify existing ownerId from existing list and merge into updated list
 921         if (null != componentToCheckOut.getInputs()) {
 922             for (InputDefinition input : componentToCheckOut.getInputs()) {
 923                 InputDefinition copy = new InputDefinition(input);
 924                 copy.setOwnerId(null);
 925                 currentList.add(copy);
 926             }
 927         }
 928         if (null == genericTypeInputs) {
 929             componentToCheckOut.setInputs(currentList);
 930             return true;
 931         }
 932         Either<Map<String, InputDefinition>, String> eitherMerged = validateNoConflictingProperties(genericTypeInputs, currentList);
 933         if (eitherMerged.isRight()) {
 934             if (log.isDebugEnabled()) {
 935                 log.debug("input {} cannot be overriden, check out performed without upgrading to latest generic", eitherMerged.right().value());
 936             }
 937             return false;
 938         }
 939         componentToCheckOut.setInputs(new ArrayList<>(eitherMerged.left().value().values()));
 940         return true;
 941     }
 942
 943     private List<ComponentInstance> getFilteredInstances(Component component, List<String> resourceTypes) {
 944         List<ComponentInstance> filteredInstances = null;
 945         if (CollectionUtils.isEmpty(resourceTypes)) {
 946             filteredInstances = component.getComponentInstances();
 947         } else if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
 948             filteredInstances = component.getComponentInstances().stream().filter(i -> isMatchingType(i.getOriginType(), resourceTypes))
 949                 .collect(Collectors.toList());
 950         }
 951         if (filteredInstances == null) {
 952             filteredInstances = new ArrayList<>();
 953         }
 954         return filteredInstances;
 955     }
 956
 957     private boolean isMatchingType(OriginTypeEnum originType, List<String> resourceTypes) {
 958         boolean isMatchingType = false;
 959         for (String resourceType : resourceTypes) {
 960             if (originType == OriginTypeEnum.findByValue(resourceType.toUpperCase())) {
 961                 isMatchingType = true;
 962                 break;
 963             }
 964         }
 965         return isMatchingType;
 966     }
 967
 968     public Either<Component, ActionStatus> shouldUpgradeToLatestDerived(Component clonedComponent) {
 969         //general implementation. Must be error for service, VF . In ResourceBuisnessLogic exist override
 970         return Either.right(ActionStatus.GENERAL_ERROR);
 971     }
 972
 973     protected Either<Component, ResponseFormat> updateCatalog(Component component, ChangeTypeEnum changeStatus) {
 974         if (log.isDebugEnabled()) {
 975             log.debug("update Catalog start with Component Type {} And Componet Name {} with change status {}",
 976                     component.getComponentType().name(),component.getName(), changeStatus.name());
 977         }
 978         ActionStatus status = catalogOperations.updateCatalog(changeStatus, component);
 979         if (status != ActionStatus.OK) {
 980             return Either.right(componentsUtils.getResponseFormat(status));
 981         }
 982         return Either.left(component);
 983     }
 984
 985     public CatalogOperation getCatalogOperations() {
 986         return catalogOperations;
 987     }
 988
 989     @Autowired
 990     public void setCatalogOperations(CatalogOperation catalogOperations) {
 991         this.catalogOperations = catalogOperations;
 992     }
 993
 994     public List<GroupDefinition> throwComponentException(ResponseFormat responseFormat) {
 995         throw new ByResponseFormatComponentException(responseFormat);
 996     }
 997 }