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