catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.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  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import java.nio.charset.StandardCharsets;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Collections;
  27 import java.util.EnumMap;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Optional;
  32 import java.util.Set;
  33 import java.util.concurrent.Callable;
  34 import java.util.function.Function;
  35 import java.util.stream.Collectors;
  36
  37 import javax.servlet.ServletContext;
  38 import javax.servlet.http.HttpServletRequest;
  39
  40 import org.apache.commons.collections.CollectionUtils;
  41 import org.apache.commons.collections.MapUtils;
  42 import org.apache.commons.lang3.tuple.ImmutablePair;
  43 import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
  44 import org.openecomp.sdc.be.components.distribution.engine.INotificationData;
  45 import org.openecomp.sdc.be.components.distribution.engine.VfModuleArtifactPayload;
  46 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  47 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  48 import org.openecomp.sdc.be.config.ConfigurationManager;
  49 import org.openecomp.sdc.be.dao.api.ActionStatus;
  50 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  51 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  52 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  53 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  54 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  56 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  57 import org.openecomp.sdc.be.model.ArtifactDefinition;
  58 import org.openecomp.sdc.be.model.Component;
  59 import org.openecomp.sdc.be.model.ComponentInstance;
  60 import org.openecomp.sdc.be.model.ComponentParametersView;
  61 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  62 import org.openecomp.sdc.be.model.DistributionTransitionEnum;
  63 import org.openecomp.sdc.be.model.GroupInstance;
  64 import org.openecomp.sdc.be.model.GroupInstanceProperty;
  65 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  66 import org.openecomp.sdc.be.model.Resource;
  67 import org.openecomp.sdc.be.model.Service;
  68 import org.openecomp.sdc.be.model.User;
  69 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  70 import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation;
  71 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  72 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  73 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  74 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
  75 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
  76 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  77 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  78 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
  79 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
  80 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
  81 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  82 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  83 import org.openecomp.sdc.be.user.Role;
  84 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  85 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  86 import org.openecomp.sdc.common.api.Constants;
  87 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  88 import org.openecomp.sdc.common.datastructure.Wrapper;
  89 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
  90 import org.openecomp.sdc.common.util.GeneralUtility;
  91 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  92 import org.openecomp.sdc.common.util.ValidationUtils;
  93 import org.openecomp.sdc.exception.ResponseFormat;
  94 import org.slf4j.Logger;
  95 import org.slf4j.LoggerFactory;
  96 import org.springframework.beans.factory.annotation.Autowired;
  97 import org.springframework.web.context.WebApplicationContext;
  98
  99 import com.google.gson.Gson;
 100 import com.google.gson.GsonBuilder;
 101
 102 import fj.data.Either;
 103
 104 @org.springframework.stereotype.Component("serviceBusinessLogic")
 105 public class ServiceBusinessLogic extends ComponentBusinessLogic {
 106
 107         private static final String STATUS_SUCCESS_200 = "200";
 108
 109         private static final String STATUS_DEPLOYED = "DEPLOYED";
 110
 111         @Autowired
 112         private IElementOperation elementDao;
 113
 114         @Autowired
 115         private IDistributionEngine distributionEngine;
 116
 117         // @Autowired
 118         // private AuditingDao auditingDao;
 119
 120         @Autowired
 121         private AuditCassandraDao auditCassandraDao;
 122
 123         @Autowired
 124         private ServiceComponentInstanceBusinessLogic serviceComponentInstanceBusinessLogic;
 125
 126         @Autowired
 127         private GroupBusinessLogic groupBusinessLogic;
 128
 129         @Autowired
 130         private ICacheMangerOperation cacheManagerOperation;
 131
 132         private static Logger log = LoggerFactory.getLogger(ServiceBusinessLogic.class.getName());
 133         private static final String INITIAL_VERSION = "0.1";
 134
 135         public ServiceBusinessLogic() {
 136                 log.debug("ServiceBusinessLogic started");
 137         }
 138
 139         public Either<Service, ResponseFormat> changeServiceDistributionState(String serviceId, String state, LifecycleChangeInfoWithAction commentObj, User user) {
 140
 141                 Either<User, ResponseFormat> resp = validateUserExists(user.getUserId(), "change Service Distribution State", false);
 142                 if (resp.isRight()) {
 143                         return Either.right(resp.right().value());
 144                 }
 145
 146                 log.debug("check request state");
 147                 Either<DistributionTransitionEnum, ResponseFormat> validateEnum = validateTransitionEnum(state, user);
 148                 if (validateEnum.isRight()) {
 149                         return Either.right(validateEnum.right().value());
 150                 }
 151                 DistributionTransitionEnum distributionTransition = validateEnum.left().value();
 152                 AuditingActionEnum auditAction = (distributionTransition == DistributionTransitionEnum.APPROVE ? AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV : AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REJECT);
 153                 Either<String, ResponseFormat> commentResponse = validateComment(commentObj, user, auditAction);
 154                 if (commentResponse.isRight()) {
 155                         return Either.right(commentResponse.right().value());
 156                 }
 157                 String comment = commentResponse.left().value();
 158
 159                 Either<Service, ResponseFormat> validateService = validateServiceDistributionChange(user, serviceId, auditAction, comment);
 160                 if (validateService.isRight()) {
 161                         return Either.right(validateService.right().value());
 162                 }
 163                 Service service = validateService.left().value();
 164                 DistributionStatusEnum initState = service.getDistributionStatus();
 165
 166                 Either<User, ResponseFormat> validateUser = validateUserDistributionChange(user, service, auditAction, comment);
 167                 if (validateUser.isRight()) {
 168                         return Either.right(validateUser.right().value());
 169                 }
 170                 user = validateUser.left().value();
 171
 172                 // lock resource
 173                 /*
 174                  * StorageOperationStatus lockResult = graphLockOperation.lockComponent(serviceId, NodeTypeEnum.Service); if (!lockResult.equals(StorageOperationStatus.OK)) { BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.
 175                  * BeFailedLockObjectError, "ChangeServiceDistributionState"); log.debug("Failed to lock service {} error - {}", serviceId, lockResult); ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR,
 176                  * service.getVersion(), service.getServiceName());
 177                  *
 178                  * createAudit(user, auditAction, comment, service, responseFormat); return Either.right(componentsUtils.getResponseFormat(ActionStatus. GENERAL_ERROR)); }
 179                  */
 180                 Either<Boolean, ResponseFormat> lockResult = lockComponent(serviceId, service, "ChangeServiceDistributionState");
 181                 if (lockResult.isRight()) {
 182                         ResponseFormat responseFormat = lockResult.right().value();
 183                         createAudit(user, auditAction, comment, service, responseFormat);
 184                         return Either.right(responseFormat);
 185                 }
 186
 187                 try {
 188
 189                         DistributionStatusEnum newState;
 190                         if (distributionTransition == DistributionTransitionEnum.APPROVE) {
 191                                 newState = DistributionStatusEnum.DISTRIBUTION_APPROVED;
 192                         } else {
 193                                 newState = DistributionStatusEnum.DISTRIBUTION_REJECTED;
 194                         }
 195                         Either<Service, StorageOperationStatus> result = toscaOperationFacade.updateDistributionStatus(service, user, newState);
 196                         if (result.isRight()) {
 197                                 titanDao.rollback();
 198                                 BeEcompErrorManager.getInstance().logBeSystemError("ChangeServiceDistributionState");
 199                                 log.debug("service {} is  change destribuation status failed", service.getUniqueId());
 200                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR, service.getVersion(), service.getName());
 201                                 createAudit(user, auditAction, comment, service, responseFormat);
 202                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 203                         }
 204                         titanDao.commit();
 205                         Service updatedService = result.left().value();
 206                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 207                         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
 208                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, updatedService.getDistributionStatus().name());
 209                         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, initState.name());
 210                         createAudit(user, auditAction, comment, updatedService, responseFormat, auditingFields);
 211                         return Either.left(result.left().value());
 212
 213                 } finally {
 214                         graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
 215                 }
 216
 217         }
 218
 219         public Either<List<Map<String, Object>>, ResponseFormat> getComponentAuditRecords(String componentVersion, String componentUUID, String userId) {
 220                 Either<User, ResponseFormat> resp = validateUserExists(userId, "get Component Audit Records", false);
 221                 if (resp.isRight()) {
 222                         return Either.right(resp.right().value());
 223                 }
 224                 Either<List<Map<String, Object>>, ActionStatus> result;
 225                 try {
 226
 227                         // Certified Version
 228                         if (componentVersion.endsWith(".0")) {
 229                                 Either<List<ResourceAdminEvent>, ActionStatus> eitherAuditingForCertified = auditCassandraDao.getByServiceInstanceId(componentUUID);
 230                                 if (eitherAuditingForCertified.isLeft()) {
 231                                         result = Either.left(getAuditingFieldsList(eitherAuditingForCertified.left().value()));
 232                                 } else {
 233                                         result = Either.right(eitherAuditingForCertified.right().value());
 234                                 }
 235                         }
 236                         // Uncertified Version
 237                         else {
 238                                 result = getAuditRecordsForUncertifiedComponent(componentUUID, componentVersion);
 239                         }
 240                 } catch (Exception e) {
 241                         log.debug("get Audit Records failed with exception {}", e);
 242                         result = Either.right(ActionStatus.GENERAL_ERROR);
 243                 }
 244
 245                 if (result.isRight()) {
 246                         return Either.right(componentsUtils.getResponseFormat(result.right().value()));
 247                 } else {
 248                         return Either.left(result.left().value());
 249                 }
 250
 251         }
 252
 253         private Either<List<Map<String, Object>>, ActionStatus> getAuditRecordsForUncertifiedComponent(String componentUUID, String componentVersion) {
 254                 // First Query
 255                 Either<List<ResourceAdminEvent>, ActionStatus> eitherprevVerAudit = auditCassandraDao.getAuditByServiceIdAndPrevVersion(componentUUID, componentVersion);
 256
 257                 if (eitherprevVerAudit.isRight()) {
 258                         return Either.right(eitherprevVerAudit.right().value());
 259                 }
 260
 261                 // Second Query
 262                 Either<List<ResourceAdminEvent>, ActionStatus> eitherCurrVerAudit = auditCassandraDao.getAuditByServiceIdAndCurrVersion(componentUUID, componentVersion);
 263                 if (eitherCurrVerAudit.isRight()) {
 264                         return Either.right(eitherCurrVerAudit.right().value());
 265                 }
 266
 267                 List<Map<String, Object>> prevVerAuditList = getAuditingFieldsList(eitherprevVerAudit.left().value());
 268                 List<Map<String, Object>> currVerAuditList = getAuditingFieldsList(eitherCurrVerAudit.left().value());
 269
 270                 List<Map<String, Object>> duplicateElements = new ArrayList<Map<String, Object>>();
 271                 duplicateElements.addAll(prevVerAuditList);
 272                 duplicateElements.retainAll(currVerAuditList);
 273
 274                 List<Map<String, Object>> joinedNonDuplicatedList = new ArrayList<Map<String, Object>>();
 275                 joinedNonDuplicatedList.addAll(prevVerAuditList);
 276                 joinedNonDuplicatedList.removeAll(duplicateElements);
 277                 joinedNonDuplicatedList.addAll(currVerAuditList);
 278
 279                 return Either.left(joinedNonDuplicatedList);
 280         }
 281
 282         private List<Map<String, Object>> getAuditingFieldsList(List<? extends AuditingGenericEvent> prevVerAuditList) {
 283
 284                 List<Map<String, Object>> prevVerAudit = new ArrayList<Map<String, Object>>();
 285                 for (AuditingGenericEvent auditEvent : prevVerAuditList) {
 286                         auditEvent.fillFields();
 287                         prevVerAudit.add(auditEvent.getFields());
 288                 }
 289                 return prevVerAudit;
 290         }
 291
 292         /**
 293          * createService
 294          *
 295          * @param service
 296          *            - Service
 297          * @param user
 298          *            - modifier data (userId)
 299          * @return Either<Service, responseFormat>
 300          */
 301         public Either<Service, ResponseFormat> createService(Service service, User user) {
 302
 303                 // get user details
 304                 Either<User, ResponseFormat> eitherCreator = validateUser(user, "Create Service", service, AuditingActionEnum.CREATE_RESOURCE, false);
 305                 if (eitherCreator.isRight()) {
 306                         return Either.right(eitherCreator.right().value());
 307                 }
 308                 user = eitherCreator.left().value();
 309
 310                 // validate user role
 311                 Either<Boolean, ResponseFormat> validateRes = validateUserRole(user, service, new ArrayList<Role>(), AuditingActionEnum.CREATE_RESOURCE, null);
 312                 if (validateRes.isRight()) {
 313                         return Either.right(validateRes.right().value());
 314                 }
 315                 service.setCreatorUserId(user.getUserId());
 316
 317                 // warn on overridden fields
 318                 checkFieldsForOverideAttampt(service);
 319                 // enrich object
 320                 log.debug("enrich service with version and state");
 321                 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 322                 service.setVersion(INITIAL_VERSION);
 323                 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
 324                 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 325
 326                 Either<Service, ResponseFormat> createServiceResponse = validateServiceBeforeCreate(service, user, AuditingActionEnum.CREATE_RESOURCE);
 327                 if (createServiceResponse.isRight()) {
 328                         return createServiceResponse;
 329                 }
 330                 return createServiceByDao(service, AuditingActionEnum.CREATE_RESOURCE, user);
 331         }
 332
 333         private void checkFieldsForOverideAttampt(Service service) {
 334                 checkComponentFieldsForOverrideAttempt(service);
 335                 if ((service.getDistributionStatus() != null)) {
 336                         log.info("Distribution Status cannot be defined by user. This field will be overridden by the application");
 337                 }
 338         }
 339
 340         private Either<Service, ResponseFormat> createServiceByDao(Service service, AuditingActionEnum actionEnum, User user) {
 341                 log.debug("send service {} to dao for create", service.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
 342
 343                 Either<Boolean, ResponseFormat> lockResult = lockComponentByName(service.getSystemName(), service, "Create Service");
 344                 if (lockResult.isRight()) {
 345                         ResponseFormat responseFormat = lockResult.right().value();
 346                         componentsUtils.auditComponentAdmin(responseFormat, user, service, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 347                         return Either.right(responseFormat);
 348                 }
 349
 350                 log.debug("System name locked is {}, status = {}", service.getSystemName(), lockResult);
 351
 352                 try {
 353
 354                         createMandatoryArtifactsData(service, user);
 355                         createServiceApiArtifactsData(service, user);
 356                         setToscaArtifactsPlaceHolders(service, user);
 357                         Either<Resource, ResponseFormat> genericServiceEither = fetchAndSetDerivedFromGenericType(service);
 358                         if (genericServiceEither.isRight())
 359                                 return Either.right(genericServiceEither.right().value());
 360
 361                         generateAndAddInputsFromGenericTypeProperties(service, genericServiceEither.left().value());
 362
 363                         Either<Service, StorageOperationStatus> dataModelResponse = toscaOperationFacade.createToscaComponent(service);
 364
 365                         // service created successfully!!!
 366                         if (dataModelResponse.isLeft()) {
 367                                 log.debug("Service created successfully!!!");
 368                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
 369                                 componentsUtils.auditComponentAdmin(responseFormat, user, service, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 370                                 ASDCKpiApi.countCreatedServicesKPI();
 371                                 return Either.left(dataModelResponse.left().value());
 372                         }
 373
 374                         ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()), service, ComponentTypeEnum.SERVICE);
 375                         log.debug("audit before sending response");
 376                         componentsUtils.auditComponentAdmin(responseFormat, user, service, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 377                         return Either.right(responseFormat);
 378
 379                 } finally {
 380                         graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
 381                 }
 382         }
 383
 384         @SuppressWarnings("unchecked")
 385         private void createServiceApiArtifactsData(Service service, User user) {
 386                 // create mandatory artifacts
 387
 388                 // TODO it must be removed after that artifact uniqueId creation will be
 389                 // moved to ArtifactOperation
 390                 // String serviceUniqueId =
 391                 // UniqueIdBuilder.buildServiceUniqueId(service.getComponentMetadataDefinition().getMetadataDataDefinition().getName(),
 392                 // service.getComponentMetadataDefinition().getMetadataDataDefinition().getVersion());
 393                 String serviceUniqueId = service.getUniqueId();
 394                 Map<String, ArtifactDefinition> artifactMap = service.getServiceApiArtifacts();
 395                 if (artifactMap == null)
 396                         artifactMap = new HashMap<String, ArtifactDefinition>();
 397
 398                 Map<String, Object> serviceApiArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getServiceApiArtifacts();
 399                 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
 400
 401                 List<CategoryDefinition> categories = service.getCategories();
 402                 boolean isCreateArtifact = true;
 403                 if (categories != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
 404                         for (String exlude : exludeServiceCategory) {
 405                                 if (exlude.equalsIgnoreCase(categories.get(0).getName())) {
 406                                         isCreateArtifact = false;
 407                                         break;
 408                                 }
 409                         }
 410
 411                 }
 412
 413                 if (serviceApiArtifacts != null && isCreateArtifact) {
 414                         Set<String> keys = serviceApiArtifacts.keySet();
 415                         for (String serviceApiArtifactName : keys) {
 416                                 Map<String, Object> artifactInfoMap = (Map<String, Object>) serviceApiArtifacts.get(serviceApiArtifactName);
 417                                 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, serviceApiArtifactName, artifactInfoMap, user, true);
 418                                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.SERVICE_API);
 419                                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
 420                         }
 421
 422                         service.setServiceApiArtifacts(artifactMap);
 423                 }
 424         }
 425
 426         private Either<Service, ResponseFormat> validateServiceBeforeCreate(Service service, User user, AuditingActionEnum actionEnum) {
 427
 428                 Either<Boolean, ResponseFormat> validationResponse = validateServiceFieldsBeforeCreate(user, service, actionEnum);
 429                 if (validationResponse.isRight()) {
 430                         return Either.right(validationResponse.right().value());
 431                 }
 432                 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 433                 service.setContactId(service.getContactId().toLowerCase());
 434
 435                 // Generate invariant UUID - must be here and not in operation since it
 436                 // should stay constant during clone
 437                 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
 438                 service.setInvariantUUID(invariantUUID);
 439
 440                 return Either.left(service);
 441         }
 442
 443         private Either<Boolean, ResponseFormat> validateServiceFieldsBeforeCreate(User user, Service service, AuditingActionEnum actionEnum) {
 444                 Either<Boolean, ResponseFormat> componentsFieldsValidation = validateComponentFieldsBeforeCreate(user, service, actionEnum);
 445                 if (componentsFieldsValidation.isRight()) {
 446                         return componentsFieldsValidation;
 447                 }
 448
 449                 log.debug("validate service name uniqueness");
 450                 Either<Boolean, ResponseFormat> serviceNameUniquenessValidation = validateComponentNameUnique(user, service, actionEnum);
 451                 if (serviceNameUniquenessValidation.isRight()) {
 452                         return serviceNameUniquenessValidation;
 453                 }
 454
 455                 log.debug("validate category");
 456                 Either<Boolean, ResponseFormat> categoryValidation = validateServiceCategory(user, service, actionEnum);
 457                 if (categoryValidation.isRight()) {
 458                         return categoryValidation;
 459                 }
 460
 461                 // validate project name (ProjectCode) - mandatory in service
 462                 log.debug("validate projectName");
 463                 Either<Boolean, ResponseFormat> projectCodeValidation = validateProjectCode(user, service, actionEnum);
 464                 if (projectCodeValidation.isRight()) {
 465                         return projectCodeValidation;
 466                 }
 467
 468                 log.debug("validate service type");
 469                 Either<Boolean, ResponseFormat> serviceTypeValidation = validateServiceTypeAndCleanup(user, service, actionEnum);
 470                 if (serviceTypeValidation.isRight()) {
 471                         return serviceTypeValidation;
 472                 }
 473
 474                 log.debug("validate service role");
 475                 Either<Boolean, ResponseFormat> serviceRoleValidation = validateServiceRoleAndCleanup(user, service, actionEnum);
 476                 if (serviceRoleValidation.isRight()) {
 477                         return serviceRoleValidation;
 478                 }
 479
 480                 return Either.left(true);
 481
 482         }
 483
 484         private Either<Boolean, ResponseFormat> validateServiceCategory(User user, Service service, AuditingActionEnum actionEnum) {
 485                 log.debug("validate Service category");
 486
 487                 if (service.getCategories() == null || service.getCategories().size() == 0) {
 488                         ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.SERVICE.getValue());
 489                         componentsUtils.auditComponentAdmin(errorResponse, user, service, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 490                         return Either.right(errorResponse);
 491                 }
 492
 493                 Either<Boolean, ResponseFormat> validatCategory = validateServiceCategory(service.getCategories());
 494                 if (validatCategory.isRight()) {
 495                         ResponseFormat responseFormat = validatCategory.right().value();
 496                         componentsUtils.auditComponentAdmin(responseFormat, user, service, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 497                         return Either.right(responseFormat);
 498                 }
 499
 500                 return Either.left(true);
 501         }
 502
 503         public Either<Map<String, Boolean>, ResponseFormat> validateServiceNameExists(String serviceName, String userId) {
 504
 505                 Either<User, ResponseFormat> resp = validateUserExists(userId, "validate Service Name Exists", false);
 506                 if (resp.isRight()) {
 507                         return Either.right(resp.right().value());
 508                 }
 509
 510                 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade.validateComponentNameUniqueness(serviceName, null, ComponentTypeEnum.SERVICE);
 511
 512                 // DE242223
 513                 titanDao.commit();
 514
 515                 if (dataModelResponse.isLeft()) {
 516                         Map<String, Boolean> result = new HashMap<>();
 517                         result.put("isValid", dataModelResponse.left().value());
 518                         log.debug("validation was successfully performed.");
 519                         return Either.left(result);
 520                 }
 521
 522                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()));
 523
 524                 return Either.right(responseFormat);
 525         }
 526
 527         public void setElementDao(IElementOperation elementDao) {
 528                 this.elementDao = elementDao;
 529         }
 530
 531         public void setCassandraAuditingDao(AuditCassandraDao auditingDao) {
 532                 this.auditCassandraDao = auditingDao;
 533         }
 534
 535         /*
 536          * public void setUserAdmin(UserAdminBuisinessLogic userAdmin) { this.userAdmin = userAdmin; }
 537          *
 538          * public void setComponentsUtils(ComponentsUtils componentsUtils) { this.componentsUtils = componentsUtils; }
 539          *
 540          * public void setGraphLockOperation(IGraphLockOperation graphLockOperation) { this.graphLockOperation = graphLockOperation; }
 541          */
 542
 543         public ArtifactsBusinessLogic getArtifactBl() {
 544                 return artifactsBusinessLogic;
 545         }
 546
 547         public void setArtifactBl(ArtifactsBusinessLogic artifactBl) {
 548                 this.artifactsBusinessLogic = artifactBl;
 549         }
 550
 551         public Either<Service, ResponseFormat> updateServiceMetadata(String serviceId, Service serviceUpdate, User user) {
 552                 Either<User, ResponseFormat> eitherCreator = validateUser(user, "updateServiceMetadata", serviceUpdate, null, false);
 553                 if (eitherCreator.isRight()) {
 554                         return Either.right(eitherCreator.right().value());
 555                 }
 556                 user = eitherCreator.left().value();
 557
 558                 // validate user role
 559                 Either<Boolean, ResponseFormat> validateRes = validateUserRole(user, serviceUpdate, new ArrayList<Role>(), null, null);
 560                 if (validateRes.isRight()) {
 561                         return Either.right(validateRes.right().value());
 562                 }
 563
 564                 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
 565                 if (storageStatus.isRight()) {
 566                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), ""));
 567                 }
 568
 569                 Service currentService = storageStatus.left().value();
 570
 571                 if (!ComponentValidationUtils.canWorkOnComponent(currentService, user.getUserId())) {
 572                         log.info("Restricted operation for user: {}, on service: {}", user.getUserId(), currentService.getCreatorUserId());
 573                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
 574                 }
 575
 576                 Either<Service, ResponseFormat> validationRsponse = validateAndUpdateServiceMetadata(user, currentService, serviceUpdate);
 577                 if (validationRsponse.isRight()) {
 578                         log.info("service update metadata: validations field.");
 579                         return validationRsponse;
 580                 }
 581                 Service serviceToUpdate = validationRsponse.left().value();
 582                 // lock resource
 583
 584                 Either<Boolean, ResponseFormat> lockResult = lockComponent(serviceId, currentService, "Update Service Metadata");
 585                 if (lockResult.isRight()) {
 586                         return Either.right(lockResult.right().value());
 587                 }
 588                 try {
 589                         Either<Service, StorageOperationStatus> updateResponse = toscaOperationFacade.updateToscaElement(serviceToUpdate);
 590                         if (updateResponse.isRight()) {
 591                                 titanDao.rollback();
 592                                 BeEcompErrorManager.getInstance().logBeSystemError("Update Service Metadata");
 593                                 log.debug("failed to update sevice {}", serviceToUpdate.getUniqueId());
 594                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
 595                         }
 596                         titanDao.commit();
 597                         return Either.left(updateResponse.left().value());
 598                 } finally {
 599                         graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
 600                 }
 601         }
 602
 603         private Either<Service, ResponseFormat> validateAndUpdateServiceMetadata(User user, Service currentService, Service serviceUpdate) {
 604
 605                 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentService.getVersion());
 606                 Either<Boolean, ResponseFormat> response = validateAndUpdateCategory(user, currentService, serviceUpdate, hasBeenCertified, null);
 607                 if (response.isRight()) {
 608                         ResponseFormat errorResponse = response.right().value();
 609                         return Either.right(errorResponse);
 610                 }
 611
 612                 String creatorUserIdUpdated = serviceUpdate.getCreatorUserId();
 613                 String creatorUserIdCurrent = currentService.getCreatorUserId();
 614                 if (creatorUserIdUpdated != null && !creatorUserIdCurrent.equals(creatorUserIdUpdated)) {
 615                         log.info("update srvice: recived request to update creatorUserId to {} the field is not updatable ignoring.", creatorUserIdUpdated);
 616                 }
 617
 618                 String creatorFullNameUpdated = serviceUpdate.getCreatorFullName();
 619                 String creatorFullNameCurrent = currentService.getCreatorFullName();
 620                 if (creatorFullNameUpdated != null && !creatorFullNameCurrent.equals(creatorFullNameUpdated)) {
 621                         log.info("update srvice: recived request to update creatorFullName to {} the field is not updatable ignoring.", creatorFullNameUpdated);
 622                 }
 623
 624                 String lastUpdaterUserIdUpdated = serviceUpdate.getLastUpdaterUserId();
 625                 String lastUpdaterUserIdCurrent = currentService.getLastUpdaterUserId();
 626                 if (lastUpdaterUserIdUpdated != null && !lastUpdaterUserIdCurrent.equals(lastUpdaterUserIdUpdated)) {
 627                         log.info("update srvice: recived request to update lastUpdaterUserId to {} the field is not updatable ignoring.", lastUpdaterUserIdUpdated);
 628                 }
 629
 630                 String lastUpdaterFullNameUpdated = serviceUpdate.getLastUpdaterFullName();
 631                 String lastUpdaterFullNameCurrent = currentService.getLastUpdaterFullName();
 632                 if (lastUpdaterFullNameUpdated != null && !lastUpdaterFullNameCurrent.equals(lastUpdaterFullNameUpdated)) {
 633                         log.info("update srvice: recived request to update lastUpdaterFullName to {} the field is not updatable ignoring.", lastUpdaterFullNameUpdated);
 634                 }
 635
 636                 response = validateAndUpdateServiceName(user, currentService, serviceUpdate, hasBeenCertified, null);
 637                 if (response.isRight()) {
 638                         ResponseFormat errorResponse = response.right().value();
 639                         return Either.right(errorResponse);
 640                 }
 641
 642                 DistributionStatusEnum distributionStatusUpdated = serviceUpdate.getDistributionStatus();
 643                 DistributionStatusEnum distributionStatusCurrent = currentService.getDistributionStatus();
 644                 if (distributionStatusUpdated != null && !distributionStatusUpdated.name().equals((distributionStatusCurrent != null ? distributionStatusCurrent.name() : null))) {
 645                         log.info("update srvice: recived request to update distributionStatus to {} the field is not updatable ignoring.", distributionStatusUpdated);
 646                 }
 647
 648                 if (serviceUpdate.getProjectCode() != null) {
 649                         response = validateAndUpdateProjectCode(user, currentService, serviceUpdate, null);
 650                         if (response.isRight()) {
 651                                 ResponseFormat errorResponse = response.right().value();
 652                                 return Either.right(errorResponse);
 653                         }
 654                 }
 655
 656                 response = validateAndUpdateIcon(user, currentService, serviceUpdate, hasBeenCertified, null);
 657                 if (response.isRight()) {
 658                         ResponseFormat errorResponse = response.right().value();
 659                         return Either.right(errorResponse);
 660                 }
 661
 662                 Long creationDateUpdated = serviceUpdate.getCreationDate();
 663                 Long creationDateCurrent = currentService.getCreationDate();
 664                 if (creationDateUpdated != null && !creationDateCurrent.equals(creationDateUpdated)) {
 665                         log.info("update srvice: recived request to update creationDate to {} the field is not updatable ignoring.", creationDateUpdated);
 666                 }
 667
 668                 String versionUpdated = serviceUpdate.getVersion();
 669                 String versionCurrent = currentService.getVersion();
 670                 if (versionUpdated != null && !versionCurrent.equals(versionUpdated)) {
 671                         log.info("update srvice: recived request to update version to {} the field is not updatable ignoring.", versionUpdated);
 672                 }
 673
 674                 response = validateAndUpdateDescription(user, currentService, serviceUpdate, hasBeenCertified, null);
 675                 if (response.isRight()) {
 676                         ResponseFormat errorResponse = response.right().value();
 677                         return Either.right(errorResponse);
 678                 }
 679
 680                 response = validateAndUpdateTags(user, currentService, serviceUpdate, hasBeenCertified, null);
 681                 if (response.isRight()) {
 682                         ResponseFormat errorResponse = response.right().value();
 683                         return Either.right(errorResponse);
 684                 }
 685
 686                 response = validateAndUpdateContactId(user, currentService, serviceUpdate, null);
 687                 if (response.isRight()) {
 688                         ResponseFormat errorResponse = response.right().value();
 689                         return Either.right(errorResponse);
 690                 }
 691
 692                 Long lastUpdateDateUpdated = serviceUpdate.getLastUpdateDate();
 693                 Long lastUpdateDateCurrent = currentService.getLastUpdateDate();
 694                 if (lastUpdateDateUpdated != null && !lastUpdateDateCurrent.equals(lastUpdateDateUpdated)) {
 695                         log.info("update srvice: recived request to update lastUpdateDate to {} the field is not updatable ignoring.", lastUpdateDateUpdated);
 696                 }
 697
 698                 LifecycleStateEnum lifecycleStateUpdated = serviceUpdate.getLifecycleState();
 699                 LifecycleStateEnum lifecycleStateCurrent = currentService.getLifecycleState();
 700                 if (lifecycleStateUpdated != null && !lifecycleStateCurrent.name().equals(lifecycleStateUpdated.name())) {
 701                         log.info("update srvice: recived request to update lifecycleState to {} the field is not updatable ignoring.", lifecycleStateUpdated);
 702                 }
 703
 704                 Boolean isHighestVersionUpdated = serviceUpdate.isHighestVersion();
 705                 Boolean isHighestVersionCurrent = currentService.isHighestVersion();
 706                 if (isHighestVersionUpdated != null && !isHighestVersionCurrent.equals(isHighestVersionUpdated)) {
 707                         log.info("update srvice: recived request to update isHighestVersion to {} the field is not updatable ignoring.", isHighestVersionUpdated);
 708                 }
 709
 710                 String uuidUpdated = serviceUpdate.getUUID();
 711                 String uuidCurrent = currentService.getUUID();
 712                 if (!uuidCurrent.equals(uuidUpdated)) {
 713                         log.info("update service: recived request to update uuid to {} the field is not updatable ignoring.", uuidUpdated);
 714                 }
 715
 716                 response = validateAndUpdateServiceType(user, currentService, serviceUpdate, null);
 717                 if (response.isRight()) {
 718                         ResponseFormat errorResponse = response.right().value();
 719                         return Either.right(errorResponse);
 720                 }
 721
 722                 response = validateAndUpdateServiceRole(user, currentService, serviceUpdate, null);
 723                 if (response.isRight()) {
 724                         ResponseFormat errorResponse = response.right().value();
 725                         return Either.right(errorResponse);
 726                 }
 727
 728                 String currentInvariantUuid = currentService.getInvariantUUID();
 729                 String updatedInvariantUuid = serviceUpdate.getInvariantUUID();
 730
 731                 if ((updatedInvariantUuid != null) && (!updatedInvariantUuid.equals(currentInvariantUuid))) {
 732                         log.warn("Product invariant UUID is automatically set and cannot be updated");
 733                         serviceUpdate.setInvariantUUID(currentInvariantUuid);
 734                 }
 735                 validateAndUpdateEcompNaming(currentService, serviceUpdate);
 736
 737                 currentService.setEnvironmentContext(serviceUpdate.getEnvironmentContext());
 738
 739                 return Either.left(currentService);
 740
 741         }
 742
 743         private void validateAndUpdateEcompNaming(Service currentService, Service serviceUpdate) {
 744                 Boolean isEcompoGeneratedCurr = currentService.isEcompGeneratedNaming();
 745                 Boolean isEcompoGeneratedUpdate = serviceUpdate.isEcompGeneratedNaming();
 746                 if (isEcompoGeneratedUpdate != null && isEcompoGeneratedCurr != isEcompoGeneratedUpdate) {
 747                         currentService.setEcompGeneratedNaming(isEcompoGeneratedUpdate);
 748                 }
 749                 String namingPolicyUpd = serviceUpdate.getNamingPolicy();
 750                 if (!currentService.isEcompGeneratedNaming()) {
 751                         if (ValidationUtils.validateStringNotEmpty(namingPolicyUpd)) {
 752                                 log.warn("NamingPolicy must be empty for EcompGeneratedNaming=false");
 753                                 currentService.setNamingPolicy("");
 754                         } else {
 755                                 currentService.setNamingPolicy(namingPolicyUpd);
 756                         }
 757                 }else{
 758                         currentService.setNamingPolicy(namingPolicyUpd);
 759                 }
 760         }
 761
 762         private Either<Boolean, ResponseFormat> validateAndUpdateContactId(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
 763                 String contactIdUpdated = serviceUpdate.getContactId();
 764                 String contactIdCurrent = currentService.getContactId();
 765                 if (!contactIdCurrent.equals(contactIdUpdated)) {
 766                         Either<Boolean, ResponseFormat> validatContactId = validateContactId(user, serviceUpdate, audatingAction);
 767                         if (validatContactId.isRight()) {
 768                                 ResponseFormat errorRespons = validatContactId.right().value();
 769                                 return Either.right(errorRespons);
 770                         }
 771                         currentService.setContactId(contactIdUpdated.toLowerCase());
 772                 }
 773                 return Either.left(true);
 774         }
 775
 776         private Either<Boolean, ResponseFormat> validateAndUpdateTags(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
 777                 List<String> tagsUpdated = serviceUpdate.getTags();
 778                 List<String> tagsCurrent = currentService.getTags();
 779                 if (tagsUpdated == null || tagsUpdated.isEmpty()) {
 780                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_TAGS);
 781                         componentsUtils.auditComponentAdmin(responseFormat, user, serviceUpdate, "", "", audatingAction, ComponentTypeEnum.SERVICE);
 782                         return Either.right(responseFormat);
 783                 }
 784
 785                 if (!(tagsCurrent.containsAll(tagsUpdated) && tagsUpdated.containsAll(tagsCurrent))) {
 786                         Either<Boolean, ResponseFormat> validatResponse = validateTagsListAndRemoveDuplicates(user, serviceUpdate, audatingAction);
 787                         if (validatResponse.isRight()) {
 788                                 ResponseFormat errorRespons = validatResponse.right().value();
 789                                 return Either.right(errorRespons);
 790                         }
 791                         currentService.setTags(tagsUpdated);
 792                 }
 793                 return Either.left(true);
 794         }
 795
 796         private Either<Boolean, ResponseFormat> validateAndUpdateDescription(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
 797                 String descriptionUpdated = serviceUpdate.getDescription();
 798                 String descriptionCurrent = currentService.getDescription();
 799                 if (!descriptionCurrent.equals(descriptionUpdated)) {
 800                         Either<Boolean, ResponseFormat> validateDescriptionResponse = validateDescriptionAndCleanup(user, serviceUpdate, audatingAction);
 801                         if (validateDescriptionResponse.isRight()) {
 802                                 ResponseFormat errorRespons = validateDescriptionResponse.right().value();
 803                                 return Either.right(errorRespons);
 804                         }
 805                         currentService.setDescription(serviceUpdate.getDescription());
 806                 }
 807                 return Either.left(true);
 808         }
 809
 810         private Either<Boolean, ResponseFormat> validateAndUpdateProjectCode(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
 811                 String projectCodeUpdated = serviceUpdate.getProjectCode();
 812                 String projectCodeCurrent = currentService.getProjectCode();
 813                 if (!projectCodeCurrent.equals(projectCodeUpdated)) {
 814
 815                         Either<Boolean, ResponseFormat> validatProjectCodeResponse = validateProjectCode(user, serviceUpdate, audatingAction);
 816                         if (validatProjectCodeResponse.isRight()) {
 817                                 ResponseFormat errorRespons = validatProjectCodeResponse.right().value();
 818                                 return Either.right(errorRespons);
 819                         }
 820                         currentService.setProjectCode(projectCodeUpdated);
 821
 822                 }
 823                 return Either.left(true);
 824         }
 825
 826         private Either<Boolean, ResponseFormat> validateAndUpdateIcon(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
 827                 String iconUpdated = serviceUpdate.getIcon();
 828                 String iconCurrent = currentService.getIcon();
 829                 if (!iconCurrent.equals(iconUpdated)) {
 830                         if (!hasBeenCertified) {
 831                                 Either<Boolean, ResponseFormat> validatIconResponse = validateIcon(user, serviceUpdate, audatingAction);
 832                                 if (validatIconResponse.isRight()) {
 833                                         ResponseFormat errorRespons = validatIconResponse.right().value();
 834                                         return Either.right(errorRespons);
 835                                 }
 836                                 currentService.setIcon(iconUpdated);
 837                         } else {
 838                                 log.info("icon {} cannot be updated once the service has been certified once.", iconUpdated);
 839                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_ICON_CANNOT_BE_CHANGED);
 840                                 return Either.right(errorResponse);
 841                         }
 842                 }
 843                 return Either.left(true);
 844         }
 845
 846         private Either<Boolean, ResponseFormat> validateAndUpdateServiceName(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum auditingAction) {
 847                 String serviceNameUpdated = serviceUpdate.getName();
 848                 String serviceNameCurrent = currentService.getName();
 849                 if (!serviceNameCurrent.equals(serviceNameUpdated)) {
 850                         if (!hasBeenCertified) {
 851                                 Either<Boolean, ResponseFormat> validatServiceNameResponse = validateComponentName(user, serviceUpdate, auditingAction);
 852                                 if (validatServiceNameResponse.isRight()) {
 853                                         ResponseFormat errorRespons = validatServiceNameResponse.right().value();
 854                                         return Either.right(errorRespons);
 855                                 }
 856
 857                                 Either<Boolean, ResponseFormat> serviceNameUniquenessValidation = validateComponentNameUnique(user, serviceUpdate, auditingAction);
 858                                 if (serviceNameUniquenessValidation.isRight()) {
 859                                         return serviceNameUniquenessValidation;
 860                                 }
 861                                 currentService.setName(serviceNameUpdated);
 862                                 currentService.getComponentMetadataDefinition().getMetadataDataDefinition().setNormalizedName(ValidationUtils.normaliseComponentName(serviceNameUpdated));
 863                                 currentService.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName(ValidationUtils.convertToSystemName(serviceNameUpdated));
 864
 865                         } else {
 866                                 log.info("service name {} cannot be updated once the service has been certified once.", serviceNameUpdated);
 867                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NAME_CANNOT_BE_CHANGED);
 868                                 return Either.right(errorResponse);
 869                         }
 870                 }
 871                 return Either.left(true);
 872         }
 873
 874         private Either<Boolean, ResponseFormat> validateAndUpdateServiceType(User user, Service currentService, Service updatedService, AuditingActionEnum auditingAction) {
 875                 String updatedServiceType = updatedService.getServiceType();
 876                 String currentServiceType = currentService.getServiceType();
 877                 if (!currentServiceType.equals(updatedServiceType)) {
 878                         Either<Boolean, ResponseFormat> validateServiceType = validateServiceTypeAndCleanup(user, updatedService , auditingAction);
 879                         if (validateServiceType.isRight()) {
 880                                 ResponseFormat errorResponse = validateServiceType.right().value();
 881                                 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, "", "", auditingAction, ComponentTypeEnum.SERVICE);
 882                                 return Either.right(errorResponse);
 883                         }
 884                         currentService.setServiceType(updatedServiceType);
 885                 }
 886                 return Either.left(true);
 887         }
 888
 889         protected Either<Boolean, ResponseFormat> validateServiceTypeAndCleanup(User user, Component component, AuditingActionEnum actionEnum) {
 890                 String serviceType = ((Service)component).getServiceType();
 891                 if (serviceType != null){
 892                         serviceType = cleanUpText(serviceType);
 893                         Either<Boolean, ResponseFormat> validateServiceType = validateServiceType(serviceType);
 894                         if (validateServiceType.isRight()) {
 895                                 ResponseFormat responseFormat = validateServiceType.right().value();
 896                                 componentsUtils.auditComponentAdmin(responseFormat, user, component, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 897                                 return Either.right(responseFormat);
 898                         }
 899                         return Either.left(true);
 900                 } else {
 901                         return Either.left(false);
 902                 }
 903         }
 904
 905
 906         private Either<Boolean, ResponseFormat> validateServiceType(String serviceType) {
 907                 if (serviceType.equals("")){
 908                         return Either.left(true);
 909                 } else {
 910                         if (!ValidationUtils.validateServiceTypeLength(serviceType)) {
 911                                 log.info("service type exceeds limit.");
 912                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_TYPE_EXCEEDS_LIMIT, "" + ValidationUtils.SERVICE_TYPE_MAX_LENGTH);
 913                                 return Either.right(errorResponse);
 914                         }
 915
 916                         if (!ValidationUtils.validateIsEnglish(serviceType)) {
 917                                 log.info("service type is not valid.");
 918                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_SERVICE_TYPE);
 919                                 return Either.right(errorResponse);
 920                         }
 921                         return Either.left(true);
 922                 }
 923         }
 924
 925         private Either<Boolean, ResponseFormat> validateAndUpdateServiceRole(User user, Service currentService, Service updatedService, AuditingActionEnum auditingAction) {
 926                 String updatedServiceRole = updatedService.getServiceRole();
 927                 String currentServiceRole = currentService.getServiceRole();
 928                 if (!currentServiceRole.equals(updatedServiceRole)) {
 929                         Either<Boolean, ResponseFormat> validateServiceRole = validateServiceRoleAndCleanup(user, updatedService , auditingAction);
 930                         if (validateServiceRole.isRight()) {
 931                                 ResponseFormat errorResponse = validateServiceRole.right().value();
 932                                 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, "", "", auditingAction, ComponentTypeEnum.SERVICE);
 933                                 return Either.right(errorResponse);
 934                         }
 935                         currentService.setServiceRole(updatedServiceRole);
 936                 }
 937                 return Either.left(true);
 938         }
 939
 940         protected Either<Boolean, ResponseFormat> validateServiceRoleAndCleanup(User user, Component component, AuditingActionEnum actionEnum) {
 941                 String serviceRole = ((Service)component).getServiceRole();
 942                 if (serviceRole != null){
 943                         serviceRole = cleanUpText(serviceRole);
 944
 945                         Either<Boolean, ResponseFormat> validateServiceRole = validateServiceRole(serviceRole);
 946                         if (validateServiceRole.isRight()) {
 947                                 ResponseFormat responseFormat = validateServiceRole.right().value();
 948                                 componentsUtils.auditComponentAdmin(responseFormat, user, component, "", "", actionEnum, ComponentTypeEnum.SERVICE);
 949                                 return Either.right(responseFormat);
 950                         }
 951                         return Either.left(true);
 952                 } else {
 953                         return Either.left(false);
 954                 }
 955         }
 956
 957
 958         private Either<Boolean, ResponseFormat> validateServiceRole(String serviceRole) {
 959                 if (serviceRole.equals("")){
 960                         return Either.left(true);
 961                 } else {
 962                         if (!ValidationUtils.validateServiceRoleLength(serviceRole)) {
 963                                 log.info("service role exceeds limit.");
 964                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_ROLE_EXCEEDS_LIMIT, "" + ValidationUtils.SERVICE_ROLE_MAX_LENGTH);
 965                                 return Either.right(errorResponse);
 966                         }
 967
 968                         if (!ValidationUtils.validateIsEnglish(serviceRole)) {
 969                                 log.info("service role is not valid.");
 970                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_SERVICE_ROLE);
 971                                 return Either.right(errorResponse);
 972                         }
 973                         return Either.left(true);
 974                 }
 975         }
 976
 977
 978
 979         private Either<Boolean, ResponseFormat> validateAndUpdateCategory(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
 980                 List<CategoryDefinition> categoryUpdated = serviceUpdate.getCategories();
 981                 List<CategoryDefinition> categoryCurrent = currentService.getCategories();
 982                 Either<Boolean, ResponseFormat> validatCategoryResponse = validateServiceCategory(user, serviceUpdate, audatingAction);
 983                 if (validatCategoryResponse.isRight()) {
 984                         ResponseFormat errorRespons = validatCategoryResponse.right().value();
 985                         return Either.right(errorRespons);
 986                 }
 987                 if (!categoryCurrent.get(0).getName().equals(categoryUpdated.get(0).getName())) {
 988                         if (!hasBeenCertified) {
 989                                 currentService.setCategories(categoryUpdated);
 990                         } else {
 991                                 log.info("category {} cannot be updated once the service has been certified once.", categoryUpdated);
 992                                 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_CATEGORY_CANNOT_BE_CHANGED);
 993                                 return Either.right(errorResponse);
 994                         }
 995                 }
 996                 return Either.left(true);
 997
 998         }
 999
1000         public Either<Boolean, ResponseFormat> validateServiceCategory(List<CategoryDefinition> list) {
1001                 if (list != null) {
1002                         if (list.size() > 1) {
1003                                 log.debug("Must be only one category for service");
1004                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_TOO_MUCH_CATEGORIES, ComponentTypeEnum.SERVICE.getValue());
1005                                 return Either.right(responseFormat);
1006                         }
1007                         CategoryDefinition category = list.get(0);
1008                         if (category.getSubcategories() != null) {
1009                                 log.debug("Subcategories cannot be defined for service");
1010                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.SERVICE_CANNOT_CONTAIN_SUBCATEGORY);
1011                                 return Either.right(responseFormat);
1012                         }
1013                         if (!ValidationUtils.validateStringNotEmpty(category.getName())) {
1014                                 log.debug("Resource category is empty");
1015                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.SERVICE.getValue());
1016                                 return Either.right(responseFormat);
1017                         }
1018
1019                         log.debug("validating service category {} against valid categories list", list);
1020                         Either<List<CategoryDefinition>, ActionStatus> categorys = elementDao.getAllServiceCategories();
1021                         if (categorys.isRight()) {
1022                                 log.debug("failed to retrive service categories from Titan");
1023                                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(categorys.right().value());
1024                                 return Either.right(responseFormat);
1025                         }
1026                         List<CategoryDefinition> categoryList = categorys.left().value();
1027                         for (CategoryDefinition value : categoryList) {
1028                                 if (value.getName().equals(category.getName())) {
1029                                         return Either.left(true);
1030                                 }
1031                         }
1032                         log.debug("Category {} is not part of service category group. Service category valid values are {}", list, categoryList);
1033                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.SERVICE.getValue()));
1034                 }
1035                 return Either.left(false);
1036         }
1037
1038         public ResponseFormat deleteService(String serviceId, User user) {
1039                 ResponseFormat responseFormat;
1040                 String ecompErrorContext = "delete service";
1041
1042                 Either<User, ResponseFormat> eitherCreator = validateUserExists(user, ecompErrorContext, false);
1043                 if (eitherCreator.isRight()) {
1044                         return eitherCreator.right().value();
1045                 }
1046                 user = eitherCreator.left().value();
1047
1048                 Either<Service, StorageOperationStatus> serviceStatus = toscaOperationFacade.getToscaElement(serviceId);
1049                 if (serviceStatus.isRight()) {
1050                         log.debug("failed to get service {}", serviceId);
1051                         return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceStatus.right().value()), "");
1052                 }
1053
1054                 Service service = serviceStatus.left().value();
1055
1056                 StorageOperationStatus result = StorageOperationStatus.OK;
1057                 Either<Boolean, ResponseFormat> lockResult = lockComponent(service, "Mark service to delete");
1058                 if (lockResult.isRight()) {
1059                         result = StorageOperationStatus.GENERAL_ERROR;
1060                         return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1061                 }
1062
1063                 try {
1064
1065                         result = markComponentToDelete(service);
1066                         if (result.equals(StorageOperationStatus.OK)) {
1067                                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1068                         } else {
1069                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1070                                 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1071                         }
1072                         return responseFormat;
1073
1074                 } finally {
1075                         if (result == null || !result.equals(StorageOperationStatus.OK)) {
1076                                 log.warn("operation failed. do rollback");
1077                                 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1078                                 titanDao.rollback();
1079                         } else {
1080                                 log.debug("operation success. do commit");
1081                                 titanDao.commit();
1082                         }
1083                         graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1084                 }
1085         }
1086
1087         public ResponseFormat deleteServiceByNameAndVersion(String serviceName, String version, User user) {
1088                 ResponseFormat responseFormat;
1089                 String ecompErrorContext = "delete service";
1090                 Either<User, ResponseFormat> validateEmptyResult = validateUserNotEmpty(user, ecompErrorContext);
1091                 if (validateEmptyResult.isRight()) {
1092                         return validateEmptyResult.right().value();
1093                 }
1094
1095                 Either<User, ResponseFormat> eitherCreator = validateUserExists(user, ecompErrorContext, false);
1096                 if (eitherCreator.isRight()) {
1097                         return eitherCreator.right().value();
1098                 }
1099                 user = eitherCreator.left().value();
1100
1101                 Either<Service, ResponseFormat> getResult = getServiceByNameAndVersion(serviceName, version, user.getUserId());
1102                 if (getResult.isRight()) {
1103                         return getResult.right().value();
1104                 }
1105                 Service service = getResult.left().value();
1106
1107                 StorageOperationStatus result = StorageOperationStatus.OK;
1108                 Either<Boolean, ResponseFormat> lockResult = lockComponent(service, "Mark service to delete");
1109                 if (lockResult.isRight()) {
1110                         result = StorageOperationStatus.GENERAL_ERROR;
1111                         return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1112                 }
1113
1114                 try {
1115                         result = markComponentToDelete(service);
1116                         if (result.equals(StorageOperationStatus.OK)) {
1117                                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1118                         } else {
1119                                 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1120                                 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1121                         }
1122                         return responseFormat;
1123
1124                 } finally {
1125                         if (result == null || !result.equals(StorageOperationStatus.OK)) {
1126                                 log.warn("operation failed. do rollback");
1127                                 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1128                                 titanDao.rollback();
1129                         } else {
1130                                 log.debug("operation success. do commit");
1131                                 titanDao.commit();
1132                         }
1133                         graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
1134                 }
1135         }
1136
1137         public Either<Service, ResponseFormat> getService(String serviceId, User user) {
1138                 String ecompErrorContext = "Get service";
1139                 Either<User, ResponseFormat> validateEmptyResult = validateUserNotEmpty(user, ecompErrorContext);
1140                 if (validateEmptyResult.isRight()) {
1141                         return Either.right(validateEmptyResult.right().value());
1142                 }
1143
1144                 Either<User, ResponseFormat> eitherCreator = validateUserExists(user, ecompErrorContext, false);
1145                 if (eitherCreator.isRight()) {
1146                         return Either.right(eitherCreator.right().value());
1147                 }
1148
1149                 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1150                 if (storageStatus.isRight()) {
1151                         log.debug("failed to get service by id {}", serviceId);
1152                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), serviceId));
1153                 }
1154
1155                 if(!(storageStatus.left().value() instanceof Service)){
1156                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), serviceId));
1157                 }
1158                 Service service = storageStatus.left().value();
1159                 return Either.left(service);
1160
1161
1162
1163
1164         }
1165
1166         public Either<Service, ResponseFormat> getServiceByNameAndVersion(String serviceName, String serviceVersion, String userId) {
1167                 Either<User, ResponseFormat> resp = validateUserExists(userId, "get Service By Name And Version", false);
1168                 if (resp.isRight()) {
1169                         return Either.right(resp.right().value());
1170                 }
1171                 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getComponentByNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, serviceVersion);
1172                 if (storageStatus.isRight()) {
1173                         log.debug("failed to get service by name {} and version {}", serviceName, serviceVersion);
1174                         return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), serviceName));
1175                 }
1176                 Service service = storageStatus.left().value();
1177                 return Either.left(service);
1178         }
1179
1180         @SuppressWarnings("unchecked")
1181         private void createMandatoryArtifactsData(Service service, User user) {
1182                 // create mandatory artifacts
1183
1184                 // TODO it must be removed after that artifact uniqueId creation will be
1185                 // moved to ArtifactOperation
1186                 // String serviceUniqueId =
1187                 // UniqueIdBuilder.buildServiceUniqueId(service.getComponentMetadataDefinition().getMetadataDataDefinition().getName(),
1188                 // service.getComponentMetadataDefinition().getMetadataDataDefinition().getVersion());
1189                 String serviceUniqueId = service.getUniqueId();
1190                 Map<String, ArtifactDefinition> artifactMap = service.getArtifacts();
1191                 if (artifactMap == null)
1192                         artifactMap = new HashMap<String, ArtifactDefinition>();
1193
1194                 Map<String, Object> informationalServiceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getInformationalServiceArtifacts();
1195                 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
1196
1197                 String category = service.getCategories().get(0).getName();
1198                 boolean isCreateArtifact = true;
1199                 if (category != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
1200                         for (String exlude : exludeServiceCategory) {
1201                                 if (exlude.equalsIgnoreCase(category)) {
1202                                         isCreateArtifact = false;
1203                                         break;
1204                                 }
1205                         }
1206
1207                 }
1208
1209                 if (informationalServiceArtifacts != null && isCreateArtifact) {
1210                         Set<String> keys = informationalServiceArtifacts.keySet();
1211                         for (String informationalServiceArtifactName : keys) {
1212                                 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalServiceArtifacts.get(informationalServiceArtifactName);
1213                                 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, informationalServiceArtifactName, artifactInfoMap, user, false);
1214                                 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
1215
1216                         }
1217
1218                         service.setArtifacts(artifactMap);
1219                 }
1220         }
1221
1222         private ArtifactDefinition createArtifactDefinition(String serviceId, String logicalName, Map<String, Object> artifactInfoMap, User user, Boolean isServiceApi) {
1223
1224                 ArtifactDefinition artifactInfo = artifactsBusinessLogic.createArtifactPlaceHolderInfo(serviceId, logicalName, artifactInfoMap, user, ArtifactGroupTypeEnum.INFORMATIONAL);
1225
1226                 if (isServiceApi) {
1227                         artifactInfo.setMandatory(false);
1228                         artifactInfo.setServiceApi(true);
1229                 }
1230                 return artifactInfo;
1231         }
1232
1233         private Either<DistributionTransitionEnum, ResponseFormat> validateTransitionEnum(String distributionTransition, User user) {
1234                 DistributionTransitionEnum transitionEnum = null;
1235
1236                 transitionEnum = DistributionTransitionEnum.getFromDisplayName(distributionTransition);
1237                 if (transitionEnum == null) {
1238                         BeEcompErrorManager.getInstance().logBeSystemError("Change Service Distribution");
1239                         log.info("state operation is not valid. operations allowed are: {}", DistributionTransitionEnum.valuesAsString());
1240                         ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1241                         return Either.right(error);
1242                 }
1243
1244                 return Either.left(transitionEnum);
1245         }
1246
1247         private Either<String, ResponseFormat> validateComment(LifecycleChangeInfoWithAction comment, User user, AuditingActionEnum auditAction) {
1248                 String data = comment.getUserRemarks();
1249
1250                 if (data == null || data.trim().isEmpty()) {
1251                         BeEcompErrorManager.getInstance().logBeInvalidJsonInput("Change Service Distribution");
1252                         log.debug("user comment cannot be empty or null.");
1253                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1254                 }
1255                 data = ValidationUtils.removeNoneUtf8Chars(data);
1256                 data = ValidationUtils.removeHtmlTags(data);
1257                 data = ValidationUtils.normaliseWhitespace(data);
1258                 data = ValidationUtils.stripOctets(data);
1259
1260                 if (!ValidationUtils.validateLength(data, ValidationUtils.COMMENT_MAX_LENGTH)) {
1261                         BeEcompErrorManager.getInstance().logBeInvalidJsonInput("Change Service Distribution");
1262                         log.debug("user comment exceeds limit.");
1263                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, "comment", String.valueOf(ValidationUtils.COMMENT_MAX_LENGTH)));
1264                 }
1265                 if (!ValidationUtils.validateIsEnglish(data)) {
1266                         return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1267                 }
1268                 return Either.left(data);
1269         }
1270
1271         private Either<Service, ResponseFormat> validateServiceDistributionChange(User user, String serviceId, AuditingActionEnum auditAction, String comment) {
1272                 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1273                 if (storageStatus.isRight()) {
1274                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceId);
1275                         createAudit(user, auditAction, comment, responseFormat);
1276                         return Either.right(responseFormat);
1277                 }
1278                 Service service = storageStatus.left().value();
1279
1280                 if (service.getLifecycleState() != LifecycleStateEnum.CERTIFIED) {
1281                         log.info("service {} is  not available for distribution. Should be in certified state", service.getUniqueId());
1282                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, service.getVersion(), service.getName());
1283                         createAudit(user, auditAction, comment, service, responseFormat);
1284                         return Either.right(responseFormat);
1285                 }
1286                 return Either.left(service);
1287         }
1288
1289         private Either<User, ResponseFormat> validateUserDistributionChange(User user, Service service, AuditingActionEnum auditAction, String comment) {
1290                 log.debug("get user from DB");
1291
1292                 // get user details
1293                 Either<User, ResponseFormat> eitherCreator = validateUser(user, "Activate Distribution", service, auditAction, false);
1294                 if (eitherCreator.isRight()) {
1295                         return Either.right(eitherCreator.right().value());
1296                 }
1297                 user = eitherCreator.left().value();
1298
1299                 // validate user role
1300                 List<Role> roles = new ArrayList<>();
1301                 roles.add(Role.ADMIN);
1302                 roles.add(Role.GOVERNOR);
1303                 roles.add(Role.OPS);
1304                 Either<Boolean, ResponseFormat> validateRes = validateUserRole(user, service, roles, auditAction, comment);
1305                 if (validateRes.isRight()) {
1306                         return Either.right(validateRes.right().value());
1307                 }
1308                 return Either.left(user);
1309         }
1310
1311         private void createAudit(User user, AuditingActionEnum auditAction, String comment, ResponseFormat responseFormat) {
1312                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1313
1314                 createAudit(user, auditAction, comment, null, responseFormat, auditingFields);
1315         }
1316
1317         private void createAudit(User user, AuditingActionEnum auditAction, String comment, Service component, ResponseFormat responseFormat) {
1318                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1319                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, component.getDistributionStatus().name());
1320                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, component.getDistributionStatus().name());
1321                 createAudit(user, auditAction, comment, component, component.getLifecycleState().name(), component.getVersion(), responseFormat, auditingFields);
1322         }
1323
1324         private void createAudit(User user, AuditingActionEnum auditAction, String comment, Service component, ResponseFormat responseFormat, EnumMap<AuditingFieldsKeysEnum, Object> auditingFields) {
1325                 log.debug("audit before sending response");
1326                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, comment);
1327                 componentsUtils.auditComponent(responseFormat, user, component, null, null, auditAction, ComponentTypeEnum.SERVICE, auditingFields);
1328         }
1329
1330         private void createAudit(User user, AuditingActionEnum auditAction, String comment, Service component, String prevState, String prevVersion, ResponseFormat responseFormat, EnumMap<AuditingFieldsKeysEnum, Object> auditingFields) {
1331                 log.debug("audit before sending response");
1332                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, comment);
1333                 componentsUtils.auditComponent(responseFormat, user, component, prevState, prevVersion, auditAction, ComponentTypeEnum.SERVICE, auditingFields);
1334         }
1335
1336         public Either<Service, ResponseFormat> activateDistribution(String serviceId, String envName, User modifier, HttpServletRequest request) {
1337
1338                 Either<User, ResponseFormat> eitherCreator = validateUserExists(modifier.getUserId(), "activate Distribution", false);
1339                 if (eitherCreator.isRight()) {
1340                         return Either.right(eitherCreator.right().value());
1341                 }
1342
1343                 User user = eitherCreator.left().value();
1344
1345                 Either<Service, ResponseFormat> result = null;
1346                 ResponseFormat response = null;
1347                 Service updatedService = null;
1348                 String did = ThreadLocalsHolder.getUuid();
1349                 EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class);
1350                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, did);
1351                 // DE194021
1352                 String configuredEnvName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
1353                 if (configuredEnvName != null && false == envName.equals(configuredEnvName)) {
1354                         log.trace("Update environment name to be {} instead of {}", configuredEnvName, envName);
1355                         envName = configuredEnvName;
1356                 }
1357                 // DE194021
1358
1359                 ServletContext servletContext = request.getSession().getServletContext();
1360                 boolean isDistributionEngineUp = getHealthCheckBL(servletContext).isDistributionEngineUp(); // DE
1361                 if (!isDistributionEngineUp) {
1362                         BeEcompErrorManager.getInstance().logBeSystemError("Distribution Engine is DOWN");
1363                         log.debug("Distribution Engine is DOWN");
1364                         response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1365                         return Either.right(response);
1366                 }
1367
1368                 Either<Service, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(serviceId);
1369                 if (serviceRes.isRight()) {
1370                         log.debug("failed retrieving service");
1371                         response = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceRes.right().value(), ComponentTypeEnum.SERVICE), serviceId);
1372                         componentsUtils.auditComponent(response, user, null, null, null, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST, ComponentTypeEnum.SERVICE, auditingFields);
1373                         return Either.right(response);
1374                 }
1375                 Service service = serviceRes.left().value();
1376                 String dcurrStatus = service.getDistributionStatus().name();
1377                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, dcurrStatus);
1378
1379                 Either<INotificationData, StorageOperationStatus> readyForDistribution = distributionEngine.isReadyForDistribution(service, did, envName);
1380                 if (readyForDistribution.isLeft()) {
1381                         INotificationData notificationData = readyForDistribution.left().value();
1382                         StorageOperationStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envName, user.getUserId(), user.getFullName());
1383                         if (notifyServiceResponse == StorageOperationStatus.OK) {
1384                                 Either<Service, ResponseFormat> updateStateRes = updateDistributionStatusForActivation(service, user, DistributionStatusEnum.DISTRIBUTED);
1385                                 if (updateStateRes.isLeft() && updateStateRes.left().value() != null) {
1386                                         updatedService = updateStateRes.left().value();
1387                                         dcurrStatus = updatedService.getDistributionStatus().name();
1388                                 } else {
1389                                         // The response is not relevant
1390                                         updatedService = service;
1391                                 }
1392                                 ASDCKpiApi.countActivatedDistribution();
1393                                 response = componentsUtils.getResponseFormat(ActionStatus.OK);
1394                                 result = Either.left(updatedService);
1395                         } else {
1396                                 BeEcompErrorManager.getInstance().logBeSystemError("Activate Distribution - send notification");
1397                                 log.debug("distributionEngine.notifyService response is: {}", notifyServiceResponse);
1398                                 response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1399                                 result = Either.right(response);
1400                         }
1401                 } else {
1402                         StorageOperationStatus distEngineValidationResponse = readyForDistribution.right().value();
1403                         response = componentsUtils.getResponseFormatByDE(componentsUtils.convertFromStorageResponse(distEngineValidationResponse), service.getName(), envName);
1404                         result = Either.right(response);
1405                 }
1406                 auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, dcurrStatus);
1407                 componentsUtils.auditComponent(response, user, service, null, null, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST, ComponentTypeEnum.SERVICE, auditingFields);
1408                 return result;
1409         }
1410
1411         // convert to private after deletion of temp url
1412         public Either<Service, ResponseFormat> updateDistributionStatusForActivation(Service service, User user, DistributionStatusEnum state) {
1413
1414                 Either<User, ResponseFormat> resp = validateUserExists(user.getUserId(), "update Distribution Status For Activation", false);
1415                 if (resp.isRight()) {
1416                         return Either.right(resp.right().value());
1417                 }
1418
1419                 String serviceId = service.getUniqueId();
1420                 Either<Boolean, ResponseFormat> lockResult = lockComponent(serviceId, service, "updateDistributionStatusForActivation");
1421                 if (lockResult.isRight()) {
1422                         return Either.right(lockResult.right().value());
1423                 }
1424                 try {
1425                         Either<Service, StorageOperationStatus> result = toscaOperationFacade.updateDistributionStatus(service, user, state);
1426                         if (result.isRight()) {
1427                                 titanDao.rollback();
1428                                 BeEcompErrorManager.getInstance().logBeSystemError("updateDistributionStatusForActivation");
1429                                 log.debug("service {}  change distribution status failed", serviceId);
1430                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1431                         }
1432                         titanDao.commit();
1433                         return Either.left(result.left().value());
1434                 } finally {
1435                         graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1436                 }
1437         }
1438
1439         public Either<Service, ResponseFormat> markDistributionAsDeployed(String serviceId, String did, User user) {
1440
1441                 Either<User, ResponseFormat> resp = validateUserExists(user.getUserId(), "mark Distribution As Deployed", false);
1442                 if (resp.isRight()) {
1443                         return Either.right(resp.right().value());
1444                 }
1445
1446                 log.debug("mark distribution deployed");
1447
1448                 AuditingActionEnum auditAction = AuditingActionEnum.DISTRIBUTION_DEPLOY;
1449                 Either<Service, StorageOperationStatus> getServiceResponse = toscaOperationFacade.getToscaElement(serviceId);
1450                 if (getServiceResponse.isRight()) {
1451                         BeEcompErrorManager.getInstance().logBeComponentMissingError("markDistributionAsDeployed", ComponentTypeEnum.SERVICE.getValue(), serviceId);
1452                         log.debug("service {} not found", serviceId);
1453                         ResponseFormat responseFormat = auditDeployError(did, user, auditAction, null, componentsUtils.convertFromStorageResponse(getServiceResponse.right().value(), ComponentTypeEnum.SERVICE), "");
1454
1455                         return Either.right(responseFormat);
1456                 }
1457
1458                 Service service = getServiceResponse.left().value();
1459
1460                 Either<User, ResponseFormat> validateRoleForDeploy = validateRoleForDeploy(did, user, auditAction, service);
1461                 if (validateRoleForDeploy.isRight()) {
1462                         return Either.right(validateRoleForDeploy.right().value());
1463                 }
1464                 user = validateRoleForDeploy.left().value();
1465
1466                 return checkDistributionAndDeploy(did, user, auditAction, service);
1467
1468         }
1469
1470         public Either<Service, ResponseFormat> generateVfModuleArtifacts(Service service, User modifier, boolean shouldLock) {
1471                 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = ri ->
1472                 // Only one VF Module Artifact per instance - add it to a list of one
1473                 buildArtifactGenList(service, modifier, shouldLock, ri);
1474
1475                 return generateDeploymentArtifacts(service, modifier, artifactTaskGeneratorCreator);
1476
1477         }
1478
1479         private List<ArtifactGenerator<ArtifactDefinition>> buildArtifactGenList(Service service, User modifier, boolean shouldLock, ComponentInstance ri) {
1480                 List<ArtifactGenerator<ArtifactDefinition>> asList = new ArrayList<ArtifactGenerator<ArtifactDefinition>>();
1481
1482                 if (ri.getOriginType() == OriginTypeEnum.VF) {
1483                         asList = Arrays.asList(new VfModuleArtifacGenerator(modifier, ri, service, shouldLock));
1484                 }
1485                 return asList;
1486         }
1487
1488         private List<GroupInstance> collectGroupsInstanceForCompInstance(ComponentInstance currVF, Wrapper<ResponseFormat> responseWrapper) {
1489
1490                 return currVF.getGroupInstances();
1491         }
1492
1493         private ArtifactDefinition getVfModuleInstArtifactForCompInstance(ComponentInstance currVF, Service service, User modifier, List<GroupInstance> groupsForCurrVF, Wrapper<String> payloadWrapper, Wrapper<ResponseFormat> responseWrapper) {
1494                 ArtifactDefinition vfModuleAertifact = null;
1495                 if (MapUtils.isNotEmpty(currVF.getDeploymentArtifacts())) {
1496                         Optional<ArtifactDefinition> optionalVfModuleArtifact = currVF.getDeploymentArtifacts().values().stream().filter(p -> p.getArtifactType().equals(ArtifactTypeEnum.VF_MODULES_METADATA.name())).findAny();
1497                         if (optionalVfModuleArtifact.isPresent()) {
1498                                 vfModuleAertifact = optionalVfModuleArtifact.get();
1499                         }
1500                 }
1501                 if (vfModuleAertifact == null) {
1502                         Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact = createVfModuleArtifact(modifier, currVF, service, payloadWrapper.getInnerElement());
1503                         if (createVfModuleArtifact.isLeft()) {
1504                                 vfModuleAertifact = createVfModuleArtifact.left().value();
1505                         } else {
1506                                 responseWrapper.setInnerElement(createVfModuleArtifact.right().value());
1507                         }
1508                 }
1509                 return vfModuleAertifact;
1510         }
1511
1512         private void fillVfModuleInstHeatEnvPayload(List<GroupInstance> groupsForCurrVF, Wrapper<String> payloadWrapper) {
1513                 // Converts GroupDefinition to VfModuleArtifactPayload which is the
1514                 // format used in the payload
1515
1516                 // List<VfModuleArtifactPayload> vfModulePayloadForCurrVF = groupsForCurrVF.stream().map(group -> new VfModuleArtifactPayload(group)).collect(Collectors.toList());
1517                 List<VfModuleArtifactPayload> vfModulePayloadForCurrVF = new ArrayList<VfModuleArtifactPayload>();
1518                 if (groupsForCurrVF != null) {
1519                         for (GroupInstance groupInstance : groupsForCurrVF) {
1520                                 VfModuleArtifactPayload modulePayload = new VfModuleArtifactPayload(groupInstance);
1521                                 vfModulePayloadForCurrVF.add(modulePayload);
1522                         }
1523                         Collections.sort(vfModulePayloadForCurrVF, (art1, art2) -> VfModuleArtifactPayload.compareByGroupName(art1, art2));
1524                         // Update Payload With Heat Env
1525 //                      vfModulePayloadForCurrVF.stream().forEach(e -> addHeatEnvArtifactsToVFModulePayload(e, currVFInstance));
1526
1527                         final Gson gson = new GsonBuilder().setPrettyPrinting().create();
1528
1529                         String vfModulePayloadString = gson.toJson(vfModulePayloadForCurrVF);
1530                         payloadWrapper.setInnerElement(vfModulePayloadString);
1531                 }
1532
1533         }
1534
1535         private Either<ArtifactDefinition, ResponseFormat> generateVfModuleInstanceArtifact(User modifier, ComponentInstance currVFInstance, Service service, boolean shouldLock) {
1536                 ArtifactDefinition vfModuleAertifact = null;
1537                 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1538                 Wrapper<String> payloadWrapper = new Wrapper<>();
1539                 List<GroupInstance> groupsForCurrVF = collectGroupsInstanceForCompInstance(currVFInstance, responseWrapper);
1540                 if (responseWrapper.isEmpty()) {
1541                         fillVfModuleInstHeatEnvPayload(groupsForCurrVF, payloadWrapper);
1542                 }
1543                 if (responseWrapper.isEmpty() && payloadWrapper.getInnerElement() != null) {
1544                         vfModuleAertifact = getVfModuleInstArtifactForCompInstance(currVFInstance, service, modifier, groupsForCurrVF, payloadWrapper, responseWrapper);
1545                 }
1546                 if (responseWrapper.isEmpty() && vfModuleAertifact != null) {
1547                         vfModuleAertifact = fillVfModulePayload(modifier, currVFInstance, vfModuleAertifact, shouldLock, payloadWrapper, responseWrapper, service);
1548                 }
1549
1550                 Either<ArtifactDefinition, ResponseFormat> result;
1551                 if (responseWrapper.isEmpty()) {
1552                         result = Either.left(vfModuleAertifact);
1553                 } else {
1554                         result = Either.right(responseWrapper.getInnerElement());
1555                 }
1556
1557                 return result;
1558         }
1559
1560         private ArtifactDefinition fillVfModulePayload(User modifier, ComponentInstance currVF, ArtifactDefinition vfModuleArtifact, boolean shouldLock, Wrapper<String> payloadWrapper, Wrapper<ResponseFormat> responseWrapper, Service service) {
1561                 ArtifactDefinition result = null;
1562 //              final Either<Resource, StorageOperationStatus> eitherResource = toscaOperationFacade.getToscaElement(currVF.getComponentUid());
1563 //              if (eitherResource.isRight()) {
1564 //                      responseWrapper.setInnerElement(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(eitherResource.right().value())));
1565 //              } else if (!payloadWrapper.isEmpty()) {
1566 //                      Resource resource = eitherResource.left().value();
1567                         Either<ArtifactDefinition, ResponseFormat> eitherPayload = artifactsBusinessLogic.generateArtifactPayload(vfModuleArtifact, ComponentTypeEnum.RESOURCE_INSTANCE, service, currVF.getName(), modifier, shouldLock, () -> System.currentTimeMillis(),
1568                                         () -> Either.left(artifactsBusinessLogic.createEsArtifactData(vfModuleArtifact, payloadWrapper.getInnerElement().getBytes(StandardCharsets.UTF_8))), currVF.getUniqueId());
1569                         if (eitherPayload.isLeft()) {
1570                                 result = eitherPayload.left().value();
1571                         } else {
1572                                 responseWrapper.setInnerElement(eitherPayload.right().value());
1573                         }
1574 //              }
1575                 if (result == null) {
1576                         result = vfModuleArtifact;
1577                 }
1578
1579                 return result;
1580         }
1581
1582         private Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact(User modifier, ComponentInstance currVF, Service service, String vfModulePayloadString) {
1583
1584                 ArtifactDefinition vfModuleArtifactDefinition = new ArtifactDefinition();
1585                 String newCheckSum = null;
1586
1587                 vfModuleArtifactDefinition.setDescription("Auto-generated VF Modules information artifact");
1588                 vfModuleArtifactDefinition.setArtifactDisplayName("Vf Modules Metadata");
1589                 vfModuleArtifactDefinition.setArtifactType(ArtifactTypeEnum.VF_MODULES_METADATA.getType());
1590                 vfModuleArtifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1591                 vfModuleArtifactDefinition.setArtifactLabel("vfModulesMetadata");
1592                 vfModuleArtifactDefinition.setTimeout(0);
1593                 vfModuleArtifactDefinition.setArtifactName(currVF.getNormalizedName() + "_modules.json");
1594                 vfModuleArtifactDefinition.setPayloadData(vfModulePayloadString);
1595                 if (vfModulePayloadString != null) {
1596                         newCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(vfModulePayloadString.getBytes());
1597                 }
1598                 vfModuleArtifactDefinition.setArtifactChecksum(newCheckSum);
1599
1600                 Either<ArtifactDefinition, StorageOperationStatus> addArifactToComponent = artifactToscaOperation.addArifactToComponent(vfModuleArtifactDefinition, service.getUniqueId(), NodeTypeEnum.ResourceInstance, true, currVF.getUniqueId());
1601
1602                 Either<ArtifactDefinition, ResponseFormat> result;
1603                 if (addArifactToComponent.isLeft()) {
1604                         result = Either.left(addArifactToComponent.left().value());
1605                 } else {
1606                         result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(addArifactToComponent.right().value())));
1607                 }
1608
1609                 return result;
1610         }
1611
1612         public Either<Service, ResponseFormat> generateHeatEnvArtifacts(Service service, User modifier, boolean shouldLock) {
1613
1614                 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = resourceInstance ->
1615                 // Get All Deployment Artifacts
1616                 service.getComponentInstances().stream().filter(ri -> ri != null && ri == resourceInstance).filter(ri -> ri.getDeploymentArtifacts() != null).flatMap(ri -> ri.getDeploymentArtifacts().values().stream()).
1617                 // Filter in Only Heat Env
1618                                 filter(depArtifact -> ArtifactTypeEnum.HEAT_ENV.getType().equals(depArtifact.getArtifactType())).
1619                                 // Create ArtifactGenerator from those Artifacts
1620                                 map(depArtifact -> new HeatEnvArtifactGenerator(depArtifact, service, resourceInstance.getName(), modifier, shouldLock, resourceInstance.getUniqueId())).collect(Collectors.toList());
1621
1622                 return generateDeploymentArtifacts(service, modifier, artifactTaskGeneratorCreator);
1623
1624         }
1625
1626         private <CallVal> Either<Service, ResponseFormat> generateDeploymentArtifacts(Service service, User modifier, Function<ComponentInstance, List<ArtifactGenerator<CallVal>>> artifactTaskGeneratorCreator) {
1627
1628                 // Get Flat List of (Callable) ArtifactGenerator for all the RI in the
1629                 // service
1630                 if (service.getComponentInstances() != null) {
1631                         List<ArtifactGenerator<CallVal>> artifactGenList = service.getComponentInstances().stream().flatMap(ri -> artifactTaskGeneratorCreator.apply(ri).stream()).collect(Collectors.toList());
1632                         if (artifactGenList != null && !artifactGenList.isEmpty()) {
1633                                 for (ArtifactGenerator<CallVal> entry : artifactGenList) {
1634                                         Either<CallVal, ResponseFormat> callRes;
1635                                         try {
1636                                                 callRes = entry.call();
1637                                                 if (callRes.isRight()) {
1638                                                         log.debug("Failed to generate artifact error : {}", callRes.right().value());
1639                                                         return Either.right(callRes.right().value());
1640                                                 }
1641                                         } catch (Exception e) {
1642                                                 log.debug("Failed to generate artifact exception : {}", e);
1643                                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1644                                         }
1645                                 }
1646                         }
1647                 }
1648                 return Either.left(service);
1649         }
1650
1651         abstract class ArtifactGenerator<CallVal> implements Callable<Either<CallVal, ResponseFormat>> {
1652
1653         }
1654
1655         class HeatEnvArtifactGenerator extends ArtifactGenerator<ArtifactDefinition> {
1656                 ArtifactDefinition artifactDefinition;
1657                 Service service;
1658                 String resourceInstanceName;
1659                 User modifier;
1660                 String instanceId;
1661                 boolean shouldLock;
1662
1663                 HeatEnvArtifactGenerator(ArtifactDefinition artifactDefinition, Service service, String resourceInstanceName, User modifier, boolean shouldLock, String instanceId) {
1664                         this.artifactDefinition = artifactDefinition;
1665                         this.service = service;
1666                         this.resourceInstanceName = resourceInstanceName;
1667                         this.modifier = modifier;
1668                         this.shouldLock = shouldLock;
1669                         this.instanceId = instanceId;
1670                 }
1671
1672                 @Override
1673                 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
1674                         return artifactsBusinessLogic.forceGenerateHeatEnvArtifact(artifactDefinition, ComponentTypeEnum.RESOURCE_INSTANCE, service, resourceInstanceName, modifier, shouldLock, instanceId);
1675                 }
1676
1677                 public ArtifactDefinition getArtifactDefinition() {
1678                         return artifactDefinition;
1679                 }
1680
1681         }
1682
1683         class VfModuleArtifacGenerator extends ArtifactGenerator<ArtifactDefinition> {
1684                 private User user;
1685                 private ComponentInstance componentInstance;
1686                 private Service service;
1687                 boolean shouldLock;
1688
1689                 @Override
1690                 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
1691                         return generateVfModuleInstanceArtifact(user, componentInstance, service, shouldLock);// generateVfModuleArtifact(user, componentInstance, service, shouldLock);
1692                 }
1693
1694                 private VfModuleArtifacGenerator(User user, ComponentInstance componentInstance, Service service, boolean shouldLock) {
1695                         super();
1696                         this.user = user;
1697                         this.componentInstance = componentInstance;
1698                         this.service = service;
1699                         this.shouldLock = shouldLock;
1700                 }
1701
1702         }
1703
1704         private synchronized Either<Service, ResponseFormat> checkDistributionAndDeploy(String did, User user, AuditingActionEnum auditAction, Service service) {
1705                 boolean isDeployed = isDistributionDeployed(did, service);
1706                 if (isDeployed) {
1707                         return Either.left(service);
1708                 }
1709                 Either<Boolean, ResponseFormat> distributionSuccess = checkDistributionSuccess(did, user, auditAction, service);
1710                 if (distributionSuccess.isRight()) {
1711                         return Either.right(distributionSuccess.right().value());
1712                 }
1713
1714                 log.debug("mark distribution {} as deployed - success", did);
1715                 componentsUtils.auditServiceDistributionDeployed(auditAction, service.getName(), service.getVersion(), service.getUUID(), did, STATUS_DEPLOYED, "OK", user);
1716                 return Either.left(service);
1717         }
1718
1719         private boolean isDistributionDeployed(String did, Service service) {
1720                 Either<List<DistributionDeployEvent>, ActionStatus> alreadyDeployed = auditCassandraDao.getDistributionDeployByStatus(did, AuditingActionEnum.DISTRIBUTION_DEPLOY.getName(), STATUS_DEPLOYED);
1721
1722                 boolean isDeployed = false;
1723                 if (alreadyDeployed.isLeft() && !alreadyDeployed.left().value().isEmpty()) {
1724                         // already deployed
1725                         log.debug("distribution {} is already deployed", did);
1726                         isDeployed = true;
1727                 }
1728                 return isDeployed;
1729         }
1730
1731         protected Either<Boolean, ResponseFormat> checkDistributionSuccess(String did, User user, AuditingActionEnum auditAction, Service service) {
1732
1733                 log.trace("checkDistributionSuccess");
1734                 // get all "DRequest" records for this distribution
1735                 // Either<List<ESTimeBasedEvent>, ActionStatus> distRequestsResponse =
1736                 // auditingDao.getListOfDistributionByAction(did,
1737                 // AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName(), "",
1738                 // ResourceAdminEvent.class);
1739                 Either<List<ResourceAdminEvent>, ActionStatus> distRequestsResponse = auditCassandraDao.getDistributionRequest(did, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
1740                 if (distRequestsResponse.isRight()) {
1741                         ResponseFormat error = auditDeployError(did, user, auditAction, service, distRequestsResponse.right().value());
1742                         return Either.right(error);
1743                 }
1744
1745                 List<ResourceAdminEvent> distributionRequests = distRequestsResponse.left().value();
1746                 if (distributionRequests.isEmpty()) {
1747                         BeEcompErrorManager.getInstance().logBeDistributionMissingError("markDistributionAsDeployed", did);
1748                         log.info("distribution {} is not found", did);
1749                         ResponseFormat error = auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_NOT_FOUND);
1750                         return Either.right(error);
1751                 }
1752                 boolean isRequestSucceeded = false;
1753                 for (ResourceAdminEvent event : distributionRequests) {
1754                         String eventStatus = event.getStatus();
1755                         if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
1756                                 isRequestSucceeded = true;
1757                                 break;
1758                         }
1759                 }
1760
1761                 // get all "DNotify" records for this distribution
1762                 // Either<List<ESTimeBasedEvent>, ActionStatus>
1763                 // distNotificationsResponse =
1764                 // auditingDao.getListOfDistributionByAction(did,
1765                 // AuditingActionEnum.DISTRIBUTION_NOTIFY.getName(), "",
1766                 // DistributionNotificationEvent.class);
1767                 Either<List<DistributionNotificationEvent>, ActionStatus> distNotificationsResponse = auditCassandraDao.getDistributionNotify(did, AuditingActionEnum.DISTRIBUTION_NOTIFY.getName());
1768                 if (distNotificationsResponse.isRight()) {
1769                         ResponseFormat error = auditDeployError(did, user, auditAction, service, distNotificationsResponse.right().value());
1770                         return Either.right(error);
1771                 }
1772
1773                 List<DistributionNotificationEvent> distributionNotifications = distNotificationsResponse.left().value();
1774                 boolean isNotificationsSucceeded = false;
1775                 for (DistributionNotificationEvent event : distributionNotifications) {
1776                         String eventStatus = event.getStatus();
1777                         if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
1778                                 isNotificationsSucceeded = true;
1779                                 break;
1780                         }
1781                 }
1782
1783                 // if request failed OR there are notifications that failed
1784                 if (!(isRequestSucceeded && isNotificationsSucceeded)) {
1785
1786                         log.info("distribution {} has failed", did);
1787                         ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
1788                         auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
1789                         return Either.right(error);
1790                 }
1791                 return Either.left(true);
1792         }
1793
1794         private ResponseFormat auditDeployError(String did, User user, AuditingActionEnum auditAction, Service service, ActionStatus status, String... params) {
1795
1796                 ResponseFormat error = componentsUtils.getResponseFormat(status, params);
1797                 String message = "";
1798                 if (error.getMessageId() != null) {
1799                         message = error.getMessageId() + ": ";
1800                 }
1801                 message += error.getFormattedMessage();
1802
1803                 if (service != null) {
1804                         componentsUtils.auditServiceDistributionDeployed(auditAction, service.getName(), service.getVersion(), service.getUUID(), did, error.getStatus().toString(), message, user);
1805                 } else {
1806                         componentsUtils.auditServiceDistributionDeployed(auditAction, "", "", "", did, error.getStatus().toString(), message, user);
1807                 }
1808                 return error;
1809         }
1810
1811         private Either<User, ResponseFormat> validateRoleForDeploy(String did, User user, AuditingActionEnum auditAction, Service service) {
1812                 Either<User, ActionStatus> eitherCreator = userAdmin.getUser(user.getUserId(), false);
1813                 if (eitherCreator.isRight() || eitherCreator.left().value() == null) {
1814                         BeEcompErrorManager.getInstance().logBeUserMissingError("Deploy Service", user.getUserId());
1815                         log.debug("validateRoleForDeploy method - user is not listed. userId= {}", user.getUserId());
1816                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.USER_NOT_FOUND, user.getUserId());
1817                         auditDeployError(did, user, auditAction, service, ActionStatus.USER_NOT_FOUND);
1818                         return Either.right(responseFormat);
1819                 }
1820                 user = eitherCreator.left().value();
1821                 log.debug("validate user role");
1822                 List<Role> roles = new ArrayList<>();
1823                 roles.add(Role.ADMIN);
1824                 roles.add(Role.OPS);
1825                 Either<Boolean, ResponseFormat> validateRes = validateUserRole(user, service, roles, auditAction, null);
1826                 if (validateRes.isRight()) {
1827                         log.info("role {} is not allowed to perform this action", user.getRole());
1828                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
1829                         auditDeployError(did, user, auditAction, service, ActionStatus.RESTRICTED_OPERATION);
1830                         return Either.right(responseFormat);
1831                 }
1832                 return Either.left(user);
1833
1834         }
1835
1836         @Override
1837         public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
1838
1839         }
1840
1841         @Override
1842         public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
1843                 return deleteMarkedComponents(ComponentTypeEnum.SERVICE);
1844         }
1845
1846         private HealthCheckBusinessLogic getHealthCheckBL(ServletContext context) {
1847                 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
1848                 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
1849                 HealthCheckBusinessLogic healthCheckBl = webApplicationContext.getBean(HealthCheckBusinessLogic.class);
1850                 return healthCheckBl;
1851         }
1852
1853         @Override
1854         public ComponentInstanceBusinessLogic getComponentInstanceBL() {
1855                 return serviceComponentInstanceBusinessLogic;
1856         }
1857
1858         @Override
1859         public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(String componentId, ComponentTypeEnum componentTypeEnum, String userId, String searchText) {
1860
1861                 Either<User, ResponseFormat> resp = validateUserExists(userId, "Get Component Instances", false);
1862                 if (resp.isRight()) {
1863                         return Either.right(resp.right().value());
1864                 }
1865                 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1866                 if (getComponentRes.isRight()) {
1867                         ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(getComponentRes.right().value()));
1868                         return Either.right(responseFormat);
1869                 }
1870
1871                 List<ComponentInstance> componentInstances = getComponentRes.left().value().getComponentInstances();
1872                 // componentInstances = componentInstances.stream().filter(instance -> instance.getOriginType().equals(OriginTypeEnum.VF)).collect(Collectors.toList());
1873
1874                 return Either.left(componentInstances);
1875         }
1876
1877         public ICacheMangerOperation getCacheManagerOperation() {
1878                 return cacheManagerOperation;
1879         }
1880
1881         public void setCacheManagerOperation(ICacheMangerOperation cacheManagerOperation) {
1882                 this.cacheManagerOperation = cacheManagerOperation;
1883         }
1884
1885         /**
1886          * updates group instance with new property values in case of successful update of group instance related component instance will be updated with new modification time and related service will be updated with new last update date
1887          *
1888          * @param modifier
1889          * @param serviceId
1890          * @param componentInstanceId
1891          * @param groupInstanceId
1892          * @param newProperties
1893          * @return
1894          */
1895         public Either<List<GroupInstanceProperty>, ResponseFormat> updateGroupInstancePropertyValues(User modifier, String serviceId, String componentInstanceId, String groupInstanceId, List<GroupInstanceProperty> newProperties) {
1896
1897                 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
1898                 Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponentRes;
1899                 Component component = null;
1900                 Either<Boolean, ResponseFormat> lockResult = null;
1901                 log.debug("Going to update group instance {} of service {} with new property values. ", groupInstanceId, serviceId);
1902                 try {
1903                         validateUserAndComponentRes = validateUserAndComponent(serviceId, modifier);
1904                         if (validateUserAndComponentRes.isRight()) {
1905                                 log.debug("Cannot update group instance {} of service {} with new property values. Validation failed.  ", groupInstanceId, serviceId);
1906                                 actionResult = Either.right(validateUserAndComponentRes.right().value());
1907                         }
1908                         if (actionResult == null) {
1909                                 component = validateUserAndComponentRes.left().value().getKey();
1910                                 lockResult = lockComponentByName(component.getSystemName(), component, "Update Group Instance on Service");
1911                                 if (lockResult.isRight()) {
1912                                         log.debug("Failed to lock service {}. Response is {}. ", component.getName(), lockResult.right().value().getFormattedMessage());
1913                                         actionResult = Either.right(lockResult.right().value());
1914                                 } else {
1915                                         log.debug("The service with system name {} locked. ", component.getSystemName());
1916                                 }
1917                         }
1918                         if (actionResult == null) {
1919                                 actionResult = validateAndUpdateGroupInstancePropertyValuesAndContainingParents(component, componentInstanceId, groupInstanceId, newProperties);
1920                                 if (actionResult.isRight()) {
1921                                         log.debug("Failed to validate and update group instance {} property values and containing parents. The message is {}. ", groupInstanceId, actionResult.right().value().getFormattedMessage());
1922                                 }
1923                         }
1924                 } catch (Exception e) {
1925                         log.error("Exception occured during update Group Instance property values: {}", e.getMessage(), e);
1926                         actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1927                 } finally {
1928                         if (lockResult != null && lockResult.isLeft() && lockResult.left().value()) {
1929                                 graphLockOperation.unlockComponentByName(component.getSystemName(), component.getUniqueId(), NodeTypeEnum.Service);
1930                         }
1931                 }
1932                 return actionResult;
1933         }
1934
1935         private Either<List<GroupInstanceProperty>, ResponseFormat> validateAndUpdateGroupInstancePropertyValuesAndContainingParents(Component component, String componentInstanceId, String groupInstanceId, List<GroupInstanceProperty> newProperties) {
1936
1937                 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
1938                 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceRes;
1939                 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeRes;
1940                 ComponentInstance relatedComponentInstance = null;
1941                 GroupInstance oldGroupInstance = null;
1942                 Either<GroupInstance, ResponseFormat> updateGroupInstanceResult = null;
1943                 GroupInstance updatedGroupInstance = null;
1944                 boolean inTransaction = true;
1945                 boolean shouldCloseTransaction = true;
1946                 findGroupInstanceRes = findGroupInstanceOnRelatedComponentInstance(component, componentInstanceId, groupInstanceId);
1947                 if (findGroupInstanceRes.isRight()) {
1948                         log.debug("Group instance {} not found. ", groupInstanceId);
1949                         actionResult = Either.right(findGroupInstanceRes.right().value());
1950                 }
1951                 if (actionResult == null) {
1952                         oldGroupInstance = findGroupInstanceRes.left().value().getValue();
1953                         relatedComponentInstance = findGroupInstanceRes.left().value().getKey();
1954                         updateGroupInstanceResult = groupBusinessLogic.validateAndUpdateGroupInstancePropertyValues(component.getUniqueId(), componentInstanceId, oldGroupInstance, newProperties, inTransaction);
1955                         if (updateGroupInstanceResult.isRight()) {
1956                                 log.debug("Failed to update group instance {} property values. ", oldGroupInstance.getName());
1957                                 actionResult = Either.right(updateGroupInstanceResult.right().value());
1958                         }
1959                 }
1960                 if (actionResult == null) {
1961                         updatedGroupInstance = updateGroupInstanceResult.left().value();
1962                         if (!oldGroupInstance.getModificationTime().equals(updatedGroupInstance.getModificationTime())) {
1963                                 updateParentsModificationTimeRes = updateParentsModificationTimeAndCustomizationUuid(component, relatedComponentInstance, updatedGroupInstance, inTransaction, shouldCloseTransaction);
1964                                 if (updateParentsModificationTimeRes.isRight()) {
1965                                         log.debug("Failed to update modification time. ", oldGroupInstance.getName());
1966                                         actionResult = Either.right(updateParentsModificationTimeRes.right().value());
1967                                 }
1968                         }
1969                 }
1970                 if (actionResult == null) {
1971                         actionResult = Either.left(updatedGroupInstance.convertToGroupInstancesProperties());
1972                 }
1973                 return actionResult;
1974         }
1975
1976         private Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeAndCustomizationUuid(Component component, ComponentInstance relatedComponentInstance, GroupInstance updatedGroupInstance,
1977                         boolean inTranscation, boolean shouldCloseTransaction) {
1978
1979                 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> actionResult;
1980                 Either<ComponentMetadataData, StorageOperationStatus> serviceMetadataUpdateResult;
1981                 Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceRes = serviceComponentInstanceBusinessLogic.updateComponentInstanceModificationTimeAndCustomizationUuid(relatedComponentInstance, NodeTypeEnum.ResourceInstance,
1982                                 updatedGroupInstance.getModificationTime(), inTranscation);
1983                 if (updateComponentInstanceRes.isRight()) {
1984                         log.debug("Failed to update component instance {} after update of group instance {}. ", relatedComponentInstance.getName(), updatedGroupInstance.getName());
1985                         actionResult = Either.right(updateComponentInstanceRes.right().value());
1986                 } else {
1987                         serviceMetadataUpdateResult = toscaOperationFacade.updateComponentLastUpdateDateOnGraph(component, updatedGroupInstance.getModificationTime());
1988                         if (serviceMetadataUpdateResult.isRight()) {
1989                                 log.debug("Failed to update service {} after update of component instance {} with new property values of group instance {}. ", component.getName(), relatedComponentInstance.getName(), updatedGroupInstance.getName());
1990                                 actionResult = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceMetadataUpdateResult.right().value())));
1991                         } else {
1992                                 actionResult = Either.left(new ImmutablePair<>(serviceMetadataUpdateResult.left().value(), updateComponentInstanceRes.left().value()));
1993                         }
1994                 }
1995                 return actionResult;
1996         }
1997
1998         private Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponent(String serviceId, User modifier) {
1999
2000                 Either<ImmutablePair<Component, User>, ResponseFormat> result = null;
2001                 Either<Component, ResponseFormat> validateComponentExistsRes = null;
2002                 User currUser = null;
2003                 Component component = null;
2004                 Either<User, ResponseFormat> validationUserResult = validateUserIgnoreAudit(modifier, "updateGroupInstancePropertyValues");
2005                 if (validationUserResult.isRight()) {
2006                         log.debug("Failed to validate user with userId for update service {}. ", modifier.getUserId(), serviceId);
2007                         result = Either.right(validationUserResult.right().value());
2008                 }
2009                 if (result == null) {
2010                         currUser = validationUserResult.left().value();
2011                         validateComponentExistsRes = validateComponentExists(serviceId, ComponentTypeEnum.SERVICE, null);
2012                         if (validateComponentExistsRes.isRight()) {
2013                                 log.debug("Failed to validate service existing {}. ", serviceId);
2014                                 result = Either.right(validateComponentExistsRes.right().value());
2015                         }
2016                 }
2017                 if (result == null) {
2018                         component = validateComponentExistsRes.left().value();
2019                         if (!ComponentValidationUtils.canWorkOnComponent(component, currUser.getUserId())) {
2020                                 log.info("Restricted operation for user: {}, on service: {}", currUser.getUserId(), component.getCreatorUserId());
2021                                 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2022                         }
2023                 }
2024                 if (result == null) {
2025                         result = Either.left(new ImmutablePair<>(component, currUser));
2026                 }
2027                 return result;
2028         }
2029
2030         private Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceOnRelatedComponentInstance(Component component, String componentInstanceId, String groupInstanceId) {
2031
2032                 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> actionResult = null;
2033                 GroupInstance groupInstance = null;
2034                 ComponentInstance foundComponentInstance = findRelatedComponentInstance(component, componentInstanceId);
2035                 if (foundComponentInstance == null) {
2036                         log.debug("Component instance {} not found on service {}. ", componentInstanceId, component.getName());
2037                         actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstanceId, "resource instance", "service", component.getName()));
2038                 } else if (!CollectionUtils.isEmpty(foundComponentInstance.getGroupInstances())) {
2039                         groupInstance = foundComponentInstance.getGroupInstances().stream().filter(gi -> gi.getUniqueId().equals(groupInstanceId)).findFirst().orElse(null);
2040                         if (groupInstance == null) {
2041                                 log.debug("Group instance {} not found on component instance {}. ", groupInstanceId, foundComponentInstance.getName());
2042                                 actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_INSTANCE_NOT_FOUND_ON_COMPONENT_INSTANCE, groupInstanceId, foundComponentInstance.getName()));
2043                         }
2044                 }
2045                 if (actionResult == null) {
2046                         actionResult = Either.left(new ImmutablePair<>(foundComponentInstance, groupInstance));
2047                 }
2048                 return actionResult;
2049         }
2050
2051         private ComponentInstance findRelatedComponentInstance(Component component, String componentInstanceId) {
2052                 ComponentInstance componentInstance = null;
2053                 if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
2054                         componentInstance = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(componentInstanceId)).findFirst().orElse(null);
2055                 }
2056                 return componentInstance;
2057         }
2058
2059         private Either<User, ResponseFormat> validateUserIgnoreAudit(User modifier, String ecompErrorContext) {
2060                 Either<User, ResponseFormat> result = validateUser(modifier, ecompErrorContext, null, null, false);
2061                 if (result.isLeft()) {
2062                         List<Role> roles = new ArrayList<>();
2063                         roles.add(Role.ADMIN);
2064                         roles.add(Role.DESIGNER);
2065                         Either<Boolean, ResponseFormat> validationRoleRes = validateUserRole(result.left().value(), roles);
2066                         if (validationRoleRes.isRight()) {
2067                                 result = Either.right(validationRoleRes.right().value());
2068                         }
2069                 }
2070                 return result;
2071         }
2072
2073         public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String serviceId, List<String> dataParamsToReturn) {
2074
2075                 ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
2076                 Either<Service, StorageOperationStatus> serviceResultEither = toscaOperationFacade.getToscaElement(serviceId, paramsToRetuen);
2077
2078                 if (serviceResultEither.isRight()) {
2079                         if(serviceResultEither.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
2080                                 log.debug("Failed to found service with id {} ", serviceId);
2081                                 Either.right(componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceId));
2082                         }
2083
2084                         log.debug("failed to get service by id {} with filters {}", serviceId, dataParamsToReturn.toString());
2085                         return Either.right(componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(serviceResultEither.right().value()), ""));
2086                 }
2087
2088                 Service service = serviceResultEither.left().value();
2089                 UiComponentDataTransfer dataTransfer = UiComponentDataConverter.getUiDataTransferFromServiceByParams(service, dataParamsToReturn);
2090                 return Either.left(dataTransfer);
2091         }
2092 }