src/main/java/org/onap/clamp/clds/service/CldsService.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP CLAMP
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights
   6  *                             reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END============================================
  20  * Modifications copyright (c) 2018 Nokia
  21  * ===================================================================
  22  *
  23  */
  24
  25 package org.onap.clamp.clds.service;
  26
  27 import com.att.eelf.configuration.EELFLogger;
  28 import com.att.eelf.configuration.EELFManager;
  29 import com.fasterxml.jackson.databind.JsonNode;
  30 import com.fasterxml.jackson.databind.ObjectMapper;
  31 import com.fasterxml.jackson.databind.node.ObjectNode;
  32
  33 import java.io.IOException;
  34 import java.security.GeneralSecurityException;
  35 import java.util.Date;
  36 import java.util.List;
  37 import java.util.Optional;
  38 import java.util.UUID;
  39
  40 import javax.servlet.http.HttpServletRequest;
  41 import javax.ws.rs.BadRequestException;
  42 import javax.ws.rs.NotAuthorizedException;
  43 import javax.xml.transform.TransformerException;
  44
  45 import org.apache.camel.Produce;
  46 import org.apache.commons.codec.DecoderException;
  47 import org.apache.commons.lang3.StringUtils;
  48 import org.json.simple.parser.ParseException;
  49 import org.onap.clamp.clds.camel.CamelProxy;
  50 import org.onap.clamp.clds.client.DcaeDispatcherServices;
  51 import org.onap.clamp.clds.client.DcaeInventoryServices;
  52 import org.onap.clamp.clds.client.req.sdc.SdcCatalogServices;
  53 import org.onap.clamp.clds.config.ClampProperties;
  54 import org.onap.clamp.clds.dao.CldsDao;
  55 import org.onap.clamp.clds.exception.CldsConfigException;
  56 import org.onap.clamp.clds.exception.policy.PolicyClientException;
  57 import org.onap.clamp.clds.exception.sdc.SdcCommunicationException;
  58 import org.onap.clamp.clds.model.CldsDbServiceCache;
  59 import org.onap.clamp.clds.model.CldsEvent;
  60 import org.onap.clamp.clds.model.CldsInfo;
  61 import org.onap.clamp.clds.model.CldsModel;
  62 import org.onap.clamp.clds.model.CldsModelProp;
  63 import org.onap.clamp.clds.model.CldsMonitoringDetails;
  64 import org.onap.clamp.clds.model.CldsServiceData;
  65 import org.onap.clamp.clds.model.CldsTemplate;
  66 import org.onap.clamp.clds.model.DcaeEvent;
  67 import org.onap.clamp.clds.model.ValueItem;
  68 import org.onap.clamp.clds.model.properties.AbstractModelElement;
  69 import org.onap.clamp.clds.model.properties.ModelProperties;
  70 import org.onap.clamp.clds.model.sdc.SdcResource;
  71 import org.onap.clamp.clds.model.sdc.SdcServiceDetail;
  72 import org.onap.clamp.clds.model.sdc.SdcServiceInfo;
  73 import org.onap.clamp.clds.sdc.controller.installer.CsarInstallerImpl;
  74 import org.onap.clamp.clds.transform.XslTransformer;
  75 import org.onap.clamp.clds.util.JacksonUtils;
  76 import org.onap.clamp.clds.util.LoggingUtils;
  77 import org.onap.clamp.clds.util.ONAPLogConstants;
  78 import org.slf4j.event.Level;
  79 import org.springframework.beans.factory.annotation.Autowired;
  80 import org.springframework.beans.factory.annotation.Value;
  81 import org.springframework.http.HttpStatus;
  82 import org.springframework.http.ResponseEntity;
  83 import org.springframework.stereotype.Component;
  84 import org.springframework.web.client.HttpClientErrorException;
  85
  86 /**
  87  * Service to save and retrieve the CLDS model attributes.
  88  */
  89 @Component
  90 public class CldsService extends SecureServiceBase {
  91
  92     @Produce(uri = "direct:processSubmit")
  93     private CamelProxy camelProxy;
  94     protected static final EELFLogger securityLogger = EELFManager.getInstance().getSecurityLogger();
  95     protected static final EELFLogger logger = EELFManager.getInstance().getLogger(CldsService.class);
  96
  97     public static final String GLOBAL_PROPERTIES_KEY = "files.globalProperties";
  98     private final String cldsPersmissionTypeCl;
  99     private final String cldsPermissionTypeClManage;
 100     private final String cldsPermissionTypeClEvent;
 101     private final String cldsPermissionTypeFilterVf;
 102     private final String cldsPermissionTypeTemplate;
 103     private final String cldsPermissionInstance;
 104     final SecureServicePermission permissionReadCl;
 105     final SecureServicePermission permissionUpdateCl;
 106     final SecureServicePermission permissionReadTemplate;
 107     final SecureServicePermission permissionUpdateTemplate;
 108
 109     private final CldsDao cldsDao;
 110     private final XslTransformer cldsBpmnTransformer;
 111     private final ClampProperties refProp;
 112     private final SdcCatalogServices sdcCatalogServices;
 113     private final DcaeDispatcherServices dcaeDispatcherServices;
 114     private final DcaeInventoryServices dcaeInventoryServices;
 115     private LoggingUtils util = new LoggingUtils(logger);
 116
 117     @Autowired
 118     private HttpServletRequest request;
 119     @Autowired
 120     public CldsService(CldsDao cldsDao, XslTransformer cldsBpmnTransformer, ClampProperties refProp,
 121         SdcCatalogServices sdcCatalogServices, DcaeDispatcherServices dcaeDispatcherServices,
 122         DcaeInventoryServices dcaeInventoryServices,
 123         @Value("${clamp.config.security.permission.type.cl:permission-type-cl}") String cldsPersmissionTypeCl,
 124         @Value("${clamp.config.security.permission.type.cl.manage:permission-type-cl-manage}") String cldsPermissionTypeClManage,
 125         @Value("${clamp.config.security.permission.type.cl.event:permission-type-cl-event}") String cldsPermissionTypeClEvent,
 126         @Value("${clamp.config.security.permission.type.filter.vf:permission-type-filter-vf}") String cldsPermissionTypeFilterVf,
 127         @Value("${clamp.config.security.permission.type.template:permission-type-template}") String cldsPermissionTypeTemplate,
 128         @Value("${clamp.config.security.permission.instance:dev}") String cldsPermissionInstance) {
 129         this.cldsDao = cldsDao;
 130         this.cldsBpmnTransformer = cldsBpmnTransformer;
 131         this.refProp = refProp;
 132         this.sdcCatalogServices = sdcCatalogServices;
 133         this.dcaeDispatcherServices = dcaeDispatcherServices;
 134         this.dcaeInventoryServices = dcaeInventoryServices;
 135         this.cldsPersmissionTypeCl = cldsPersmissionTypeCl;
 136         this.cldsPermissionTypeClManage = cldsPermissionTypeClManage;
 137         this.cldsPermissionTypeClEvent = cldsPermissionTypeClEvent;
 138         this.cldsPermissionTypeFilterVf = cldsPermissionTypeFilterVf;
 139         this.cldsPermissionTypeTemplate = cldsPermissionTypeTemplate;
 140         this.cldsPermissionInstance = cldsPermissionInstance;
 141         permissionReadCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "read");
 142         permissionUpdateCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "update");
 143         permissionReadTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 144             "read");
 145         permissionUpdateTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 146             "update");
 147     }
 148
 149     /*
 150      * @return list of CLDS-Monitoring-Details: CLOSELOOP_NAME | Close loop name
 151      * used in the CLDS application (prefix: ClosedLoop- + unique ClosedLoop ID)
 152      * MODEL_NAME | Model Name in CLDS application SERVICE_TYPE_ID | TypeId returned
 153      * from the DCAE application when the ClosedLoop is submitted
 154      * (DCAEServiceTypeRequest generated in DCAE application). DEPLOYMENT_ID | Id
 155      * generated when the ClosedLoop is deployed in DCAE. TEMPLATE_NAME | Template
 156      * used to generate the ClosedLoop model. ACTION_CD | Current state of the
 157      * ClosedLoop in CLDS application.
 158      */
 159     public List<CldsMonitoringDetails> getCLDSDetails() {
 160         util.entering(request, "CldsService: GET model details");
 161         Date startTime = new Date();
 162         List<CldsMonitoringDetails> cldsMonitoringDetailsList = cldsDao.getCLDSMonitoringDetails();
 163         // audit log
 164         LoggingUtils.setTimeContext(startTime, new Date());
 165         auditLogger.info("GET cldsDetails completed");
 166         util.exiting("200", "Get cldsDetails success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 167         return cldsMonitoringDetailsList;
 168     }
 169
 170     /*
 171      * CLDS IFO service will return 3 things 1. User Name 2. CLDS code version that
 172      * is currently installed from pom.xml file 3. User permissions
 173      */
 174     public CldsInfo getCldsInfo() {
 175         util.entering(request, "CldsService: GET cldsInfo");
 176         Date startTime = new Date();
 177         LoggingUtils.setTimeContext(startTime, new Date());
 178
 179         CldsInfoProvider cldsInfoProvider = new CldsInfoProvider(this);
 180         CldsInfo cldsInfo = cldsInfoProvider.getCldsInfo();
 181
 182         // audit log
 183         LoggingUtils.setTimeContext(startTime, new Date());
 184         securityLogger.info("GET cldsInfo completed");
 185         util.exiting("200", "Get cldsInfo success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 186         return cldsInfo;
 187     }
 188
 189     /**
 190      * REST service that retrieves BPMN for a CLDS model name from the database.
 191      * This is subset of the json getModel. This is only expected to be used for
 192      * testing purposes, not by the UI.
 193      *
 194      * @param modelName
 195      * @return bpmn xml text - content of bpmn given name
 196      */
 197     public String getBpmnXml(String modelName) {
 198         util.entering(request, "CldsService: GET model bpmn");
 199         Date startTime = new Date();
 200         isAuthorized(permissionReadCl);
 201         logger.info("GET bpmnText for modelName={}", modelName);
 202         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 203         // audit log
 204         LoggingUtils.setTimeContext(startTime, new Date());
 205         auditLogger.info("GET model bpmn completed");
 206         util.exiting("200", "Get model bpmn success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 207         return model.getBpmnText();
 208     }
 209
 210     /**
 211      * REST service that retrieves image for a CLDS model name from the database.
 212      * This is subset of the json getModel. This is only expected to be used for
 213      * testing purposes, not by the UI.
 214      *
 215      * @param modelName
 216      * @return image xml text - content of image given name
 217      */
 218     public String getImageXml(String modelName) {
 219         util.entering(request, "CldsService: GET model image");
 220         Date startTime = new Date();
 221         isAuthorized(permissionReadCl);
 222         logger.info("GET imageText for modelName={}", modelName);
 223         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 224         // audit log
 225         LoggingUtils.setTimeContext(startTime, new Date());
 226         auditLogger.info("GET model image completed");
 227         util.exiting("200", "Get model image success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 228         return model.getImageText();
 229     }
 230
 231     /**
 232      * REST service that retrieves a CLDS model by name from the database.
 233      *
 234      * @param modelName
 235      * @return clds model - clds model for the given model name
 236      */
 237     public CldsModel getModel(String modelName) {
 238         util.entering(request, "CldsService: GET model");
 239         Date startTime = new Date();
 240         isAuthorized(permissionReadCl);
 241         logger.debug("GET model for  modelName={}", modelName);
 242         CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, false);
 243         isAuthorizedForVf(cldsModel);
 244         // Checking condition whether our CLDS model can call Inventory Method
 245         if (cldsModel.canInventoryCall()) {
 246             try {
 247                 // Method to call dcae inventory and invoke insert event method
 248                 dcaeInventoryServices.setEventInventory(cldsModel, getUserId());
 249             } catch (Exception e) {
 250                 LoggingUtils.setErrorContext("900", "Set event inventory error");
 251                 logger.error("getModel set event Inventory error:" + e);
 252             }
 253         }
 254         // audit log
 255         LoggingUtils.setTimeContext(startTime, new Date());
 256         auditLogger.info("GET model completed");
 257         util.exiting("200", "Get model success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 258         return cldsModel;
 259     }
 260
 261     /**
 262      * REST service that saves a CLDS model by name in the database.
 263      *
 264      * @param modelName
 265      */
 266     public CldsModel putModel(String modelName, CldsModel cldsModel) {
 267         util.entering(request, "CldsService: PUT model");
 268         Date startTime = new Date();
 269         isAuthorized(permissionUpdateCl);
 270         isAuthorizedForVf(cldsModel);
 271         logger.info("PUT model for  modelName={}", modelName);
 272         logger.info("PUT bpmnText={}", cldsModel.getBpmnText());
 273         logger.info("PUT propText={}", cldsModel.getPropText());
 274         logger.info("PUT imageText={}", cldsModel.getImageText());
 275         cldsModel.setName(modelName);
 276         fillInCldsModel(cldsModel);
 277         updateAndInsertNewEvent(cldsModel.getName(), cldsModel.getControlNamePrefix(), cldsModel.getEvent(),
 278             CldsEvent.ACTION_MODIFY);
 279         cldsModel.save(cldsDao, getUserId());
 280         // audit log
 281         LoggingUtils.setTimeContext(startTime, new Date());
 282         auditLogger.info("PUT model completed");
 283         util.exiting("200", "Put model success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 284         return cldsModel;
 285     }
 286
 287     /**
 288      * REST service that retrieves a list of CLDS model names.
 289      *
 290      * @return model names in JSON
 291      */
 292     public List<ValueItem> getModelNames() {
 293         util.entering(request, "CldsService: GET model names");
 294         Date startTime = new Date();
 295         isAuthorized(permissionReadCl);
 296         logger.info("GET list of model names");
 297         List<ValueItem> names = cldsDao.getBpmnNames();
 298         // audit log
 299         LoggingUtils.setTimeContext(startTime, new Date());
 300         auditLogger.info("GET model names completed");
 301         util.exiting("200", "Get model names success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 302         return names;
 303     }
 304
 305     private void fillInCldsModel(CldsModel model) {
 306         if (model.getTemplateName() != null) {
 307             CldsTemplate template = cldsDao.getTemplate(model.getTemplateName());
 308             if (template != null) {
 309                 model.setTemplateId(template.getId());
 310                 model.setDocText(template.getPropText());
 311                 // This is to provide the Bpmn XML when Template part in UI
 312                 // is
 313                 // disabled
 314                 model.setBpmnText(template.getBpmnText());
 315             }
 316         }
 317     }
 318
 319     /**
 320      * REST service that saves and processes an action for a CLDS model by name.
 321      *
 322      * @param action
 323      * @param modelName
 324      * @param validateFlag
 325      * @param model
 326      * @return
 327      * @throws TransformerException
 328      *         In case of issues when doing the XSLT of the BPMN flow
 329      * @throws ParseException
 330      *         In case of issues when parsing the JSON
 331      * @throws GeneralSecurityException
 332      *         In case of issues when decrypting the password
 333      * @throws DecoderException
 334      *         In case of issues with the Hex String decoding
 335      */
 336     public ResponseEntity<?> putModelAndProcessAction(String action,
 337         String modelName,String test, CldsModel model)
 338             throws TransformerException, ParseException {
 339         util.entering(request, "CldsService: Process model action");
 340         Date startTime = new Date();
 341         CldsModel retrievedModel = null;
 342         Boolean errorCase = false;
 343         try {
 344             String actionCd = action.toUpperCase();
 345             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 346                 cldsPermissionInstance, actionCd);
 347             isAuthorized(permisionManage);
 348             isAuthorizedForVf(model);
 349             String userId = getUserId();
 350             logger.info("PUT actionCd={}", actionCd);
 351             logger.info("PUT modelName={}", modelName);
 352             logger.info("PUT test={}", test);
 353             logger.info("PUT bpmnText={}", model.getBpmnText());
 354             logger.info("PUT propText={}", model.getPropText());
 355             logger.info("PUT userId={}", userId);
 356             logger.info("PUT getTypeId={}", model.getTypeId());
 357             logger.info("PUT deploymentId={}", model.getDeploymentId());
 358             this.fillInCldsModel(model);
 359             // save model to db
 360             model.setName(modelName);
 361             updateAndInsertNewEvent(modelName, model.getControlNamePrefix(), model.getEvent(), CldsEvent.ACTION_MODIFY);
 362             model.save(cldsDao, getUserId());
 363             // get vars and format if necessary
 364             String prop = model.getPropText();
 365             String bpmn = model.getBpmnText();
 366             String docText = model.getDocText();
 367             String controlName = model.getControlName();
 368             String bpmnJson = cldsBpmnTransformer.doXslTransformToString(bpmn);
 369             logger.info("PUT bpmnJson={}", bpmnJson);
 370             // Flag indicates whether it is triggered by Validation Test button
 371             // from
 372             // UI
 373             boolean isTest = Boolean.valueOf(test);
 374             if (!isTest) {
 375                 String actionTestOverride = refProp.getStringValue("action.test.override");
 376                 if (Boolean.valueOf(actionTestOverride)) {
 377                     logger.info("PUT actionTestOverride={}", actionTestOverride);
 378                     logger.info("PUT override test indicator and setting it to true");
 379                     isTest = true;
 380                 }
 381             }
 382             logger.info("PUT isTest={}", isTest);
 383             String insertTestEvent = refProp.getStringValue("action.insert.test.event");
 384             boolean isInsertTestEvent = Boolean.valueOf(insertTestEvent);
 385
 386             logger.info("PUT isInsertTestEvent={}", isInsertTestEvent);
 387             // determine if requested action is permitted
 388             model.validateAction(actionCd);
 389             logger.info("modelProp - " + prop);
 390             logger.info("docText - " + docText);
 391             try {
 392                 String result = camelProxy.submit(actionCd, prop, bpmnJson, modelName, controlName, docText, isTest,
 393                     userId, isInsertTestEvent, model.getEvent().getActionCd());
 394                 logger.info("Starting Camel flow on request, result is: ", result);
 395             } catch (SdcCommunicationException | PolicyClientException | BadRequestException e) {
 396                 errorCase = true;
 397                 logger.error("Exception occured during invoking Camel process", e);
 398             }
 399             if (!actionCd.equalsIgnoreCase(CldsEvent.ACTION_DELETE)) {
 400                 // refresh model info from db (get fresh event info)
 401                 retrievedModel = CldsModel.retrieve(cldsDao, modelName, false);
 402             }
 403             if (retrievedModel != null) {
 404                 if (!isTest && (actionCd.equalsIgnoreCase(CldsEvent.ACTION_SUBMIT)
 405                     || actionCd.equalsIgnoreCase(CldsEvent.ACTION_RESUBMIT)
 406                     || actionCd.equalsIgnoreCase(CldsEvent.ACTION_SUBMITDCAE))) {
 407                     if (retrievedModel.getTemplateName().startsWith(CsarInstallerImpl.TEMPLATE_NAME_PREFIX)) {
 408                         // SDC artifact case
 409                         logger.info("Skipping DCAE inventory call as closed loop has been created from SDC notification");
 410                         DcaeEvent dcaeEvent = new DcaeEvent();
 411                         dcaeEvent.setArtifactName(retrievedModel.getControlName() + ".yml");
 412                         dcaeEvent.setEvent(DcaeEvent.EVENT_DISTRIBUTION);
 413                         CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), userId, dcaeEvent.getCldsActionCd(),
 414                             CldsEvent.ACTION_STATE_RECEIVED, null);
 415                     } else {
 416                         // This should be done only when the call to DCAE
 417                         // has not yet been done. When CL comes from SDC
 418                         // this is not required as the DCAE inventory call is done
 419                         // during the CL deployment.
 420                         dcaeInventoryServices.setEventInventory(retrievedModel, getUserId());
 421                     }
 422                     retrievedModel.save(cldsDao, getUserId());
 423                 }
 424                 // audit log
 425                 LoggingUtils.setTimeContext(startTime, new Date());
 426                 auditLogger.info("Process model action completed");
 427             } else {
 428                 logger.error("CldsModel not found in database with modelName: " + modelName);
 429                 util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "CldsModel not found in database with modelName " + "modelName", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 430                 return new ResponseEntity<String>("CldsModel not found in database with modelName: \" + modelName", HttpStatus.INTERNAL_SERVER_ERROR);
 431             }
 432         } catch (Exception e) {
 433             errorCase = true;
 434             logger.error("Exception occured during putModelAndProcessAction", e);
 435         }
 436         if (errorCase) {
 437             util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "putModelAndProcessAction failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 438             return new ResponseEntity<>(retrievedModel, HttpStatus.INTERNAL_SERVER_ERROR);
 439         }
 440         util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 441         return new ResponseEntity<>(retrievedModel, HttpStatus.OK);
 442     }
 443
 444     /**
 445      * REST service that accepts events for a model.
 446      *
 447      * @param test
 448      * @param dcaeEvent
 449      */
 450     public String postDcaeEvent(String test, DcaeEvent dcaeEvent) {
 451         util.entering(request, "CldsService: Post dcae event");
 452         Date startTime = new Date();
 453         String userid = null;
 454         // TODO: allow auth checking to be turned off by removing the permission
 455         // type property
 456         if (cldsPermissionTypeClEvent != null && cldsPermissionTypeClEvent.length() > 0) {
 457             SecureServicePermission permissionEvent = SecureServicePermission.create(cldsPermissionTypeClEvent,
 458                 cldsPermissionInstance, dcaeEvent.getEvent());
 459             isAuthorized(permissionEvent);
 460             userid = getUserId();
 461         }
 462         // Flag indicates whether it is triggered by Validation Test button from
 463         // UI
 464         boolean isTest = Boolean.valueOf(test);
 465         int instanceCount = 0;
 466         if (dcaeEvent.getInstances() != null) {
 467             instanceCount = dcaeEvent.getInstances().size();
 468         }
 469         String msgInfo = "event=" + dcaeEvent.getEvent() + " serviceUUID=" + dcaeEvent.getServiceUUID()
 470         + " resourceUUID=" + dcaeEvent.getResourceUUID() + " artifactName=" + dcaeEvent.getArtifactName()
 471         + " instance count=" + instanceCount + " isTest=" + isTest;
 472         logger.info("POST dcae event {}", msgInfo);
 473         if (isTest) {
 474             logger.warn("Ignorning test event from DCAE");
 475         } else {
 476             if (DcaeEvent.EVENT_DEPLOYMENT.equalsIgnoreCase(dcaeEvent.getEvent())) {
 477                 CldsModel.insertModelInstance(cldsDao, dcaeEvent, userid);
 478             } else {
 479                 CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), userid, dcaeEvent.getCldsActionCd(),
 480                     CldsEvent.ACTION_STATE_RECEIVED, null);
 481             }
 482         }
 483         // audit log
 484         LoggingUtils.setTimeContext(startTime, new Date());
 485         auditLogger.info("Post dcae event completed");
 486         util.exiting("200", "Post dcae event success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 487         return msgInfo;
 488     }
 489
 490     /**
 491      * REST service that retrieves sdc services
 492      *
 493      * @throws GeneralSecurityException
 494      *         In case of issue when decryting the SDC password
 495      * @throws DecoderException
 496      *         In case of issues with the decoding of the Hex String
 497      */
 498     public String getSdcServices() throws GeneralSecurityException, DecoderException {
 499         util.entering(request, "CldsService: GET sdc services");
 500         Date startTime = new Date();
 501         String retStr;
 502         try {
 503             retStr = createUiServiceFormatJson(sdcCatalogServices.getSdcServicesInformation(null));
 504         } catch (IOException e) {
 505             logger.error("IOException during SDC communication", e);
 506             throw new SdcCommunicationException("IOException during SDC communication", e);
 507         }
 508         logger.info("value of sdcServices : {}", retStr);
 509         // audit log
 510         LoggingUtils.setTimeContext(startTime, new Date());
 511         auditLogger.info("GET sdc services completed");
 512         util.exiting("200", "Get sdc services success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 513         return retStr;
 514     }
 515
 516     /**
 517      * REST service that retrieves total properties required by UI
 518      *
 519      * @throws IOException
 520      *         In case of issues
 521      */
 522     public String getSdcProperties() throws IOException {
 523         return createPropertiesObjectByUUID("{}");
 524     }
 525
 526     /**
 527      * REST service that retrieves total properties by using invariantUUID based on
 528      * refresh and non refresh
 529      *
 530      * @throws GeneralSecurityException
 531      *         In case of issues with the decryting the encrypted password
 532      * @throws DecoderException
 533      *         In case of issues with the decoding of the Hex String
 534      * @throws IOException
 535      *         In case of issue to convert CldsServiceCache to InputStream
 536      */
 537     public String getSdcPropertiesByServiceUUIDForRefresh(
 538         String serviceInvariantUUID, Boolean refresh)
 539             throws GeneralSecurityException, DecoderException, IOException {
 540         util.entering(request, "CldsService: GET sdc properties by uuid");
 541         Date startTime = new Date();
 542         CldsServiceData cldsServiceData = new CldsServiceData();
 543         cldsServiceData.setServiceInvariantUUID(serviceInvariantUUID);
 544         if (!Optional.ofNullable(refresh).orElse(false)) {
 545             cldsServiceData = cldsDao.getCldsServiceCache(serviceInvariantUUID);
 546         }
 547         if (sdcCatalogServices.isCldsSdcCacheDataExpired(cldsServiceData)) {
 548             cldsServiceData = sdcCatalogServices.getCldsServiceDataWithAlarmConditions(serviceInvariantUUID);
 549             cldsDao.setCldsServiceCache(new CldsDbServiceCache(cldsServiceData));
 550         }
 551         // filter out VFs the user is not authorized for
 552         cldsServiceData.filterVfs(this);
 553         // format retrieved data into properties json
 554         String sdcProperties = sdcCatalogServices.createPropertiesObjectByUUID(cldsServiceData);
 555         // audit log
 556         LoggingUtils.setTimeContext(startTime, new Date());
 557         auditLogger.info("GET sdc properties by uuid completed");
 558         util.exiting("200", "Get sdc properties by uuid success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 559         return sdcProperties;
 560     }
 561
 562     /**
 563      * Determine if the user is authorized for a particular VF by its invariant
 564      * UUID.
 565      *
 566      * @param vfInvariantUuid
 567      * @throws NotAuthorizedException
 568      * @return
 569      */
 570     public boolean isAuthorizedForVf(String vfInvariantUuid) {
 571         if (cldsPermissionTypeFilterVf != null && !cldsPermissionTypeFilterVf.isEmpty()) {
 572             SecureServicePermission permission = SecureServicePermission.create(cldsPermissionTypeFilterVf,
 573                 cldsPermissionInstance, vfInvariantUuid);
 574             return isAuthorized(permission);
 575         } else {
 576             // if CLDS_PERMISSION_TYPE_FILTER_VF property is not provided, then
 577             // VF filtering is turned off
 578             logger.warn("VF filtering turned off");
 579             return true;
 580         }
 581     }
 582
 583     /**
 584      * Determine if the user is authorized for a particular VF by its invariant
 585      * UUID. If not authorized, then NotAuthorizedException is thrown.
 586      *
 587      * @param model
 588      * @return
 589      */
 590     private boolean isAuthorizedForVf(CldsModel model) {
 591         String vf = ModelProperties.getVf(model);
 592         if (vf == null || vf.length() == 0) {
 593             logger.info("VF not found in model");
 594             return true;
 595         } else {
 596             return isAuthorizedForVf(vf);
 597         }
 598     }
 599
 600     private String createUiServiceFormatJson(String responseStr) throws IOException {
 601         if (StringUtils.isBlank(responseStr)) {
 602             return "";
 603         }
 604         ObjectMapper objectMapper = JacksonUtils.getObjectMapperInstance();
 605         List<SdcServiceInfo> rawList = objectMapper.readValue(responseStr,
 606             objectMapper.getTypeFactory().constructCollectionType(List.class, SdcServiceInfo.class));
 607         ObjectNode invariantIdServiceNode = objectMapper.createObjectNode();
 608         ObjectNode serviceNode = objectMapper.createObjectNode();
 609         logger.info("value of cldsserviceiNfolist: {}", rawList);
 610         if (rawList != null && !rawList.isEmpty()) {
 611             List<SdcServiceInfo> cldsSdcServiceInfoList = sdcCatalogServices.removeDuplicateServices(rawList);
 612             for (SdcServiceInfo currCldsSdcServiceInfo : cldsSdcServiceInfoList) {
 613                 if (currCldsSdcServiceInfo != null) {
 614                     invariantIdServiceNode.put(currCldsSdcServiceInfo.getInvariantUUID(),
 615                         currCldsSdcServiceInfo.getName());
 616                 }
 617             }
 618             serviceNode.putPOJO("service", invariantIdServiceNode);
 619         }
 620         return serviceNode.toString();
 621     }
 622
 623     private String createPropertiesObjectByUUID(String cldsResponseStr) throws IOException {
 624         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 625         SdcServiceDetail cldsSdcServiceDetail = mapper.readValue(cldsResponseStr, SdcServiceDetail.class);
 626         ObjectNode globalPropsJson = (ObjectNode) refProp.getJsonTemplate(GLOBAL_PROPERTIES_KEY);
 627         if (cldsSdcServiceDetail != null && cldsSdcServiceDetail.getUuid() != null) {
 628             /**
 629              * to create json with vf, alarm and locations
 630              */
 631             ObjectNode serviceObjectNode = createEmptyVfAlarmObject();
 632             ObjectNode vfObjectNode = mapper.createObjectNode();
 633             /**
 634              * to create json with vf and vfresourceId
 635              */
 636             createVfObjectNode(vfObjectNode, cldsSdcServiceDetail.getResources());
 637             serviceObjectNode.putPOJO(cldsSdcServiceDetail.getInvariantUUID(), vfObjectNode);
 638             ObjectNode byServiceBasicObjetNode = mapper.createObjectNode();
 639             byServiceBasicObjetNode.putPOJO("byService", serviceObjectNode);
 640             /**
 641              * to create json with VFC Node
 642              */
 643             ObjectNode emptyvfcobjectNode = createByVFCObjectNode(cldsSdcServiceDetail.getResources());
 644             byServiceBasicObjetNode.putPOJO("byVf", emptyvfcobjectNode);
 645             globalPropsJson.putPOJO("shared", byServiceBasicObjetNode);
 646             logger.info("valuie of objNode: {}", globalPropsJson);
 647         }
 648         return globalPropsJson.toString();
 649     }
 650
 651     private ObjectNode createEmptyVfAlarmObject() {
 652         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 653         ObjectNode emptyObjectNode = mapper.createObjectNode();
 654         emptyObjectNode.put("", "");
 655         ObjectNode vfObjectNode = mapper.createObjectNode();
 656         vfObjectNode.putPOJO("vf", emptyObjectNode);
 657         vfObjectNode.putPOJO("location", emptyObjectNode);
 658         vfObjectNode.putPOJO("alarmCondition", emptyObjectNode);
 659         ObjectNode emptyServiceObjectNode = mapper.createObjectNode();
 660         emptyServiceObjectNode.putPOJO("", vfObjectNode);
 661         return emptyServiceObjectNode;
 662     }
 663
 664     private void createVfObjectNode(ObjectNode vfObjectNode2, List<SdcResource> rawCldsSdcResourceList) {
 665         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 666         ObjectNode vfNode = mapper.createObjectNode();
 667         vfNode.put("", "");
 668         // To remove repeated resource instance name from
 669         // resourceInstanceList
 670         List<SdcResource> cldsSdcResourceList = sdcCatalogServices
 671             .removeDuplicateSdcResourceInstances(rawCldsSdcResourceList);
 672         /**
 673          * Creating vf resource node using cldsSdcResource Object
 674          */
 675         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 676             for (SdcResource cldsSdcResource : cldsSdcResourceList) {
 677                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 678                     vfNode.put(cldsSdcResource.getResourceUUID(), cldsSdcResource.getResourceName());
 679                 }
 680             }
 681         }
 682         vfObjectNode2.putPOJO("vf", vfNode);
 683         /**
 684          * creating location json object using properties file value
 685          */
 686         ObjectNode locationJsonNode;
 687         try {
 688             locationJsonNode = (ObjectNode) mapper.readValue(refProp.getStringValue("ui.location.default"),
 689                 JsonNode.class);
 690         } catch (IOException e) {
 691             logger.error("Unable to load ui.location.default JSON in clds-references.properties properly", e);
 692             throw new CldsConfigException(
 693                 "Unable to load ui.location.default JSON in clds-references.properties properly", e);
 694         }
 695         vfObjectNode2.putPOJO("location", locationJsonNode);
 696         /**
 697          * creating alarm json object using properties file value
 698          */
 699         String alarmStringValue = refProp.getStringValue("ui.alarm.default");
 700         logger.info("value of alarm: {}", alarmStringValue);
 701         ObjectNode alarmStringJsonNode;
 702         try {
 703             alarmStringJsonNode = (ObjectNode) mapper.readValue(alarmStringValue, JsonNode.class);
 704         } catch (IOException e) {
 705             logger.error("Unable to ui.alarm.default JSON in clds-references.properties properly", e);
 706             throw new CldsConfigException("Unable to load ui.alarm.default JSON in clds-references.properties properly",
 707                 e);
 708         }
 709         vfObjectNode2.putPOJO("alarmCondition", alarmStringJsonNode);
 710     }
 711
 712     private ObjectNode createByVFCObjectNode(List<SdcResource> cldsSdcResourceList) {
 713         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 714         ObjectNode emptyObjectNode = mapper.createObjectNode();
 715         ObjectNode emptyvfcobjectNode = mapper.createObjectNode();
 716         ObjectNode vfCObjectNode = mapper.createObjectNode();
 717         vfCObjectNode.putPOJO("vfC", emptyObjectNode);
 718         ObjectNode subVfCObjectNode = mapper.createObjectNode();
 719         subVfCObjectNode.putPOJO("vfc", emptyObjectNode);
 720         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 721             for (SdcResource cldsSdcResource : cldsSdcResourceList) {
 722                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 723                     vfCObjectNode.putPOJO(cldsSdcResource.getResourceUUID(), subVfCObjectNode);
 724                 }
 725             }
 726         }
 727         emptyvfcobjectNode.putPOJO("", vfCObjectNode);
 728         return emptyvfcobjectNode;
 729     }
 730
 731     public ResponseEntity<CldsModel> deployModel(String modelName, CldsModel model) {
 732         util.entering(request, "CldsService: Deploy model");
 733         Date startTime = new Date();
 734         Boolean errorCase = false;
 735         try {
 736             fillInCldsModel(model);
 737             String bpmnJson = cldsBpmnTransformer.doXslTransformToString(model.getBpmnText());
 738             logger.info("PUT bpmnJson={}", bpmnJson);
 739             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 740                 cldsPermissionInstance, CldsEvent.ACTION_DEPLOY);
 741             isAuthorized(permisionManage);
 742             isAuthorizedForVf(model);
 743             ModelProperties modelProp = new ModelProperties(modelName, model.getControlName(), CldsEvent.ACTION_DEPLOY,
 744                 false, bpmnJson, model.getPropText());
 745             checkForDuplicateServiceVf(modelName, model.getPropText());
 746             String deploymentId = "";
 747             // If model is already deployed then pass same deployment id
 748             if (model.getDeploymentId() != null && !model.getDeploymentId().isEmpty()) {
 749                 deploymentId = model.getDeploymentId();
 750             } else {
 751                 deploymentId = "closedLoop_" + UUID.randomUUID() + "_deploymentId";
 752             }
 753             String createNewDeploymentStatusUrl = dcaeDispatcherServices.createNewDeployment(deploymentId,
 754                 model.getTypeId(), modelProp.getGlobal().getDeployParameters());
 755             String operationStatus = dcaeDispatcherServices.getOperationStatusWithRetry(createNewDeploymentStatusUrl);
 756             if ("succeeded".equalsIgnoreCase(operationStatus)) {
 757                 String artifactName = model.getControlName();
 758                 if (artifactName != null) {
 759                     artifactName = artifactName + ".yml";
 760                 }
 761                 DcaeEvent dcaeEvent = new DcaeEvent();
 762                 /* set dcae events */
 763                 dcaeEvent.setArtifactName(artifactName);
 764                 dcaeEvent.setEvent(DcaeEvent.EVENT_DEPLOYMENT);
 765                 CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 766                     CldsEvent.ACTION_STATE_RECEIVED, null);
 767                 model.setDeploymentId(deploymentId);
 768                 model.save(cldsDao, getUserId());
 769             } else {
 770                 logger.info("Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 771                 util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "DeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 772                 throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 773                     "Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 774             }
 775             logger.info("Deploy model (" + modelName + ") succeeded...Deployment Id is - " + deploymentId);
 776             // audit log
 777             LoggingUtils.setTimeContext(startTime, new Date());
 778             auditLogger.info("Deploy model completed");
 779         } catch (Exception e) {
 780             errorCase = true;
 781             logger.error("Exception occured during deployModel", e);
 782         }
 783         if (errorCase) {
 784                 util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "DeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 785             return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
 786         }
 787         util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 788         return new ResponseEntity<>(model, HttpStatus.OK);
 789     }
 790
 791     public ResponseEntity<CldsModel> unDeployModel(String modelName, CldsModel model) {
 792         util.entering(request, "CldsService: Undeploy model");
 793         Date startTime = new Date();
 794         Boolean errorCase = false;
 795         try {
 796             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 797                 cldsPermissionInstance, CldsEvent.ACTION_UNDEPLOY);
 798             isAuthorized(permisionManage);
 799             isAuthorizedForVf(model);
 800             String operationStatusUndeployUrl = dcaeDispatcherServices.deleteExistingDeployment(model.getDeploymentId(),
 801                 model.getTypeId());
 802             String operationStatus = dcaeDispatcherServices.getOperationStatusWithRetry(operationStatusUndeployUrl);
 803             if ("succeeded".equalsIgnoreCase(operationStatus)) {
 804                 String artifactName = model.getControlName();
 805                 if (artifactName != null) {
 806                     artifactName = artifactName + ".yml";
 807                 }
 808                 DcaeEvent dcaeEvent = new DcaeEvent();
 809                 // set dcae events
 810                 dcaeEvent.setArtifactName(artifactName);
 811                 dcaeEvent.setEvent(DcaeEvent.EVENT_UNDEPLOYMENT);
 812                 CldsEvent.insEvent(cldsDao, model.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 813                     CldsEvent.ACTION_STATE_RECEIVED, null);
 814                 model.setDeploymentId(null);
 815                 model.save(cldsDao, getUserId());
 816             } else {
 817                 logger.info("Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 818                 util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "UndeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 819                 throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 820                     "Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 821             }
 822             logger.info("Undeploy model (" + modelName + ") succeeded.");
 823             // audit log
 824             LoggingUtils.setTimeContext(startTime, new Date());
 825             auditLogger.info("Undeploy model completed");
 826         } catch (Exception e) {
 827             errorCase = true;
 828             logger.error("Exception occured during unDeployModel", e);
 829         }
 830         if (errorCase) {
 831             util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "UndeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
 832             return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
 833         }
 834         util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
 835         return new ResponseEntity<>(model, HttpStatus.OK);
 836     }
 837
 838     private void checkForDuplicateServiceVf(String modelName, String modelPropText) throws IOException {
 839         JsonNode globalNode = JacksonUtils.getObjectMapperInstance().readTree(modelPropText).get("global");
 840         String service = AbstractModelElement.getValueByName(globalNode, "service");
 841         List<String> resourceVf = AbstractModelElement.getValuesByName(globalNode, "vf");
 842         if (service != null && resourceVf != null && !resourceVf.isEmpty()) {
 843             List<CldsModelProp> cldsModelPropList = cldsDao.getDeployedModelProperties();
 844             for (CldsModelProp cldsModelProp : cldsModelPropList) {
 845                 JsonNode currentNode = JacksonUtils.getObjectMapperInstance().readTree(cldsModelProp.getPropText())
 846                     .get("global");
 847                 String currentService = AbstractModelElement.getValueByName(currentNode, "service");
 848                 List<String> currentVf = AbstractModelElement.getValuesByName(currentNode, "vf");
 849                 if (currentVf != null && !currentVf.isEmpty()) {
 850                     if (!modelName.equalsIgnoreCase(cldsModelProp.getName()) && service.equalsIgnoreCase(currentService)
 851                         && resourceVf.get(0).equalsIgnoreCase(currentVf.get(0))) {
 852                         throw new BadRequestException("Same Service/VF already exists in " + cldsModelProp.getName()
 853                         + " model, please select different Service/VF.");
 854                     }
 855                 }
 856             }
 857         }
 858     }
 859
 860     private void updateAndInsertNewEvent(String cldsModelName, String cldsControlNamePrfx, CldsEvent event,
 861         String newAction) {
 862         // If model action is in submit/resubmit/distributed and user try
 863         // to save then we are changing action back to create.
 864         if (event != null && (CldsEvent.ACTION_SUBMIT.equalsIgnoreCase(event.getActionCd())
 865             || CldsEvent.ACTION_RESUBMIT.equalsIgnoreCase(event.getActionCd())
 866             || CldsEvent.ACTION_DISTRIBUTE.equalsIgnoreCase(event.getActionCd()))) {
 867             CldsEvent newEvent = new CldsEvent();
 868             newEvent.setUserid(getUserId());
 869             newEvent.setActionCd(newAction);
 870             newEvent.setActionStateCd(CldsEvent.ACTION_STATE_COMPLETED);
 871             cldsDao.insEvent(cldsModelName, cldsControlNamePrfx, null, newEvent);
 872         }
 873     }
 874
 875     // Created for the integration test
 876     public void setLoggingUtil (LoggingUtils utilP) {
 877         util =  utilP;
 878     }
 879 }