catalog-model/src/main/java/org/openecomp/sdc/be/model/ComponentParametersView.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.model;
  22
  23 import java.util.List;
  24 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  25 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
  26 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  27
  28 public class ComponentParametersView {
  29
  30     private boolean ignoreUsers = false;
  31     private boolean ignoreGroups = false;
  32     private boolean ignoreComponentInstances = false;
  33     private boolean ignoreComponentInstancesProperties = false;
  34     private boolean ignoreProperties = false;
  35     private boolean ignoreCapabilities = false;
  36     private boolean ignoreRequirements = false;
  37     private boolean ignoreCategories = false;
  38     private boolean ignoreAllVersions = false;
  39     private boolean ignoreAdditionalInformation = false;
  40     private boolean ignoreArtifacts = false;
  41     private boolean ignoreInterfaces = false;
  42     private boolean ignoreInterfaceInstances = false;
  43     private boolean ignoreComponentInstancesInterfaces = false;
  44     private boolean ignoreDerivedFrom = false;
  45     private boolean ignoreAttributesFrom = false;
  46     private boolean ignoreComponentInstancesAttributesFrom = false;
  47     private boolean ignoreInputs = false;
  48     private boolean ignoreComponentInstancesInputs = false;
  49     private boolean ignoreCapabiltyProperties = true;
  50     private boolean ignoreServicePath = true;
  51     private boolean ignorePolicies = false;
  52     private boolean ignoreNodeFilterRequirements = false;
  53     private boolean ignoreNodeFilter = false;
  54     private boolean ignoreDataType = false;
  55
  56     public ComponentParametersView() {
  57     }
  58
  59     public ComponentParametersView(boolean setAllToIgnore) {
  60         this();
  61         if (setAllToIgnore) {
  62             this.disableAll();
  63         }
  64     }
  65
  66     public ComponentParametersView(List<String> filters) {
  67         this(true);
  68
  69         for (String fieldName : filters) {
  70             switch (ComponentFieldsEnum.findByValue(fieldName)) {
  71                 case PROPERTIES:
  72                     this.setIgnoreProperties(false);
  73                     break;
  74                 case INPUTS:
  75                     this.setIgnoreInputs(false);
  76                     break;
  77                 case USERS:
  78                     this.setIgnoreUsers(false);
  79                     break;
  80                 case CATEGORIES:
  81                     this.setIgnoreCategories(false);
  82                     break;
  83                 case METADATA:
  84                     this.setIgnoreUsers(false);
  85                     this.setIgnoreCategories(false);
  86                     this.setIgnoreAllVersions(false);
  87                     this.setIgnoreDerivedFrom(false);
  88                     break;
  89                 case GROUPS:
  90                 case NON_EXCLUDED_GROUPS:
  91                     this.setIgnoreGroups(false);
  92                     break;
  93                 case COMPONENT_INSTANCES:
  94                     this.setIgnoreComponentInstances(false);
  95                     this.setIgnoreCapabilities(false);
  96                     this.setIgnoreRequirements(false);
  97                     this.setIgnoreNodeFilter(false);
  98                     break;
  99                 case COMPONENT_INSTANCES_PROPERTIES:
 100                     this.setIgnoreComponentInstances(false); //we need this in order to get the calculate capabilities requirements
 101                     this.setIgnoreComponentInstancesProperties(false);
 102                     break;
 103                 case CAPABILITIES:
 104                     this.setIgnoreComponentInstances(false);//we need this in order to get the calculate capabilities requirements
 105                     this.setIgnoreCapabilities(false);
 106                     break;
 107                 case REQUIREMENTS:
 108                     this.setIgnoreComponentInstances(false);
 109                     this.setIgnoreRequirements(false);
 110                     break;
 111                 case ALL_VERSIONS:
 112                     this.setIgnoreAllVersions(false);
 113                     break;
 114                 case ADDITIONAL_INFORMATION:
 115                     this.setIgnoreAdditionalInformation(false);
 116                     break;
 117                 case ARTIFACTS:
 118                 case DEPLOYMENT_ARTIFACTS:
 119                 case TOSCA_ARTIFACTS:
 120                 case SERVICE_API_ARTIFACTS:
 121                     this.setIgnoreArtifacts(false);
 122                     break;
 123                 case INTERFACES:
 124                     this.setIgnoreInterfaces(false);
 125                     break;
 126                 case DERIVED_FROM:
 127                     this.setIgnoreDerivedFrom(false);
 128                     break;
 129                 case ATTRIBUTES:
 130                     this.setIgnoreAttributesFrom(false);
 131                     break;
 132                 case COMPONENT_INSTANCES_ATTRIBUTES:
 133                     this.setIgnoreComponentInstances(false);
 134                     this.setIgnoreComponentInstancesAttributesFrom(false);
 135                     break;
 136                 case COMPONENT_INSTANCE_INPUTS:
 137                     this.setIgnoreComponentInstances(false);
 138                     this.setIgnoreComponentInstancesInputs(false);
 139                     break;
 140                 case INSTANCE_CAPABILTY_PROPERTIES:
 141                     this.setIgnoreCapabiltyProperties(false);
 142                     break;
 143                 case FORWARDING_PATHS:
 144                     this.setIgnoreForwardingPath(false);
 145                     break;
 146                 case POLICIES:
 147                 case NON_EXCLUDED_POLICIES:
 148                     this.setIgnorePolicies(false);
 149                     break;
 150                 case NODE_FILTER:
 151                     this.setIgnoreNodeFilterRequirements(false);
 152                     this.setIgnoreNodeFilter(false);
 153                     break;
 154                 case COMPONENT_INSTANCES_INTERFACES:
 155                     this.setIgnoreComponentInstances(false);
 156                     this.setIgnoreComponentInstancesInterfaces(false);
 157                     break;
 158                 case DATA_TYPES:
 159                     this.setIgnoreDataType(false);
 160                     break;
 161                 default:
 162                     break;
 163             }
 164
 165         }
 166     }
 167
 168     ///////////////////////////////////////////////////////////////
 169     // When adding new member, please update the filter method.
 170     ///////////////////////////////////////////////////////////////
 171
 172     public Component filter(Component component, ComponentTypeEnum componentType) {
 173
 174         if (ignoreUsers) {
 175             component.setCreatorUserId(null);
 176             component.setCreatorFullName(null);
 177             component.setLastUpdaterUserId(null);
 178             component.setLastUpdaterFullName(null);
 179         }
 180         if (ignoreGroups) {
 181             component.setGroups(null);
 182         }
 183         if (ignoreComponentInstances) {
 184             component.setComponentInstances(null);
 185             component.setComponentInstancesRelations(null);
 186         }
 187         if (ignoreComponentInstancesProperties) {
 188             component.setComponentInstancesProperties(null);
 189         }
 190         if (ignoreProperties && componentType == ComponentTypeEnum.RESOURCE) {
 191             ((Resource) component).setProperties(null);
 192         }
 193         if (ignoreCapabilities) {
 194             component.setCapabilities(null);
 195         }
 196         if (ignoreRequirements) {
 197             component.setRequirements(null);
 198         }
 199         if (ignoreCategories) {
 200             component.setCategories(null);
 201         }
 202         if (ignoreAllVersions) {
 203             component.setAllVersions(null);
 204         }
 205         if (ignoreAdditionalInformation && componentType == ComponentTypeEnum.RESOURCE) {
 206             ((Resource) component).setAdditionalInformation(null);
 207         }
 208         if (ignoreArtifacts) {
 209             component.setArtifacts(null);
 210             component.setSpecificComponetTypeArtifacts(null);
 211             component.setDeploymentArtifacts(null);
 212             component.setToscaArtifacts(null);
 213         }
 214         if (ignoreNodeFilterRequirements){
 215           component.setNodeFilterComponents(null);
 216         }
 217         if (ignoreInterfaces && ignoreInterfaceInstances &&
 218             componentType == ComponentTypeEnum.RESOURCE) {
 219             component.setInterfaces(null);
 220         }
 221         if (ignoreDerivedFrom && componentType == ComponentTypeEnum.RESOURCE) {
 222             ((Resource) component).setDerivedFrom(null);
 223         }
 224         if (ignoreAttributesFrom && componentType == ComponentTypeEnum.RESOURCE) {
 225             ((Resource) component).setAttributes(null);
 226         }
 227         if (ignoreComponentInstancesAttributesFrom) {
 228             component.setComponentInstancesAttributes(null);
 229         }
 230         if (ignoreInputs) {
 231             component.setInputs(null);
 232         }
 233         if (ignoreComponentInstancesInputs) {
 234             component.setComponentInstancesInputs(null);
 235         }
 236         if (ignoreServicePath && componentType == ComponentTypeEnum.SERVICE) {
 237             ((Service) component).setForwardingPaths(null);
 238         }
 239         if (ignoreNodeFilter){
 240             component.setNodeFilterComponents(null);
 241         }
 242         if (ignoreDataType) {
 243             component.setDataTypes(null);
 244         }
 245         return component;
 246     }
 247
 248     public boolean isIgnoreNodeFilterRequirements() {
 249         return ignoreNodeFilterRequirements;
 250     }
 251
 252     public void setIgnoreNodeFilterRequirements(boolean ignoreNodeFilter) {
 253         this.ignoreNodeFilterRequirements = ignoreNodeFilter;
 254     }
 255
 256     public void disableAll() {
 257         ignoreUsers = true;
 258         ignoreGroups = true;
 259         ignorePolicies = true;
 260         ignoreComponentInstances = true;
 261         ignoreComponentInstancesProperties = true;
 262         ignoreProperties = true;
 263         ignoreCapabilities = true;
 264         ignoreRequirements = true;
 265         ignoreCategories = true;
 266         ignoreAllVersions = true;
 267         ignoreAdditionalInformation = true;
 268         ignoreArtifacts = true;
 269         ignoreInterfaces = true;
 270         ignoreInterfaceInstances = true;
 271         ignoreDerivedFrom = true;
 272         ignoreAttributesFrom = true;
 273         ignoreInputs = true;
 274         ignoreComponentInstancesAttributesFrom = true;
 275         ignoreComponentInstancesInputs = true;
 276         ignoreCapabiltyProperties = true;
 277         ignoreServicePath = true;
 278         ignoreNodeFilterRequirements = true;
 279         ignoreNodeFilter = true;
 280         ignoreDataType = true;
 281     }
 282
 283     public boolean isIgnoreGroups() {
 284         return ignoreGroups;
 285     }
 286
 287     public void setIgnoreGroups(boolean ignoreGroups) {
 288         this.ignoreGroups = ignoreGroups;
 289         if (!ignoreGroups) {
 290             this.ignoreCapabiltyProperties = ignoreGroups;
 291             this.ignoreCapabilities = ignoreGroups;
 292         }
 293     }
 294
 295     public boolean isIgnoreComponentInstances() {
 296         return ignoreComponentInstances;
 297     }
 298
 299     public void setIgnoreComponentInstances(boolean ignoreComponentInstances) {
 300         this.ignoreComponentInstances = ignoreComponentInstances;
 301     }
 302
 303     public boolean isIgnoreProperties() {
 304         return ignoreProperties;
 305     }
 306
 307     public void setIgnoreProperties(boolean ignoreProperties) {
 308         this.ignoreProperties = ignoreProperties;
 309     }
 310
 311     public boolean isIgnoreCapabilities() {
 312         return ignoreCapabilities;
 313     }
 314
 315     public void setIgnoreCapabilities(boolean ignoreCapabilities) {
 316         this.ignoreCapabilities = ignoreCapabilities;
 317     }
 318
 319     public boolean isIgnoreRequirements() {
 320         return ignoreRequirements;
 321     }
 322
 323     public void setIgnoreRequirements(boolean ignoreRequirements) {
 324         this.ignoreRequirements = ignoreRequirements;
 325     }
 326
 327     public boolean isIgnoreCategories() {
 328         return ignoreCategories;
 329     }
 330
 331     public void setIgnoreCategories(boolean ignoreCategories) {
 332         this.ignoreCategories = ignoreCategories;
 333     }
 334
 335     public boolean isIgnoreAllVersions() {
 336         return ignoreAllVersions;
 337     }
 338
 339     public void setIgnoreAllVersions(boolean ignoreAllVersions) {
 340         this.ignoreAllVersions = ignoreAllVersions;
 341     }
 342
 343     public boolean isIgnoreAdditionalInformation() {
 344         return ignoreAdditionalInformation;
 345     }
 346
 347     private void setIgnoreAdditionalInformation(boolean ignoreAdditionalInformation) {
 348         this.ignoreAdditionalInformation = ignoreAdditionalInformation;
 349     }
 350
 351     public boolean isIgnoreArtifacts() {
 352         return ignoreArtifacts;
 353     }
 354
 355     public void setIgnoreArtifacts(boolean ignoreArtifacts) {
 356         this.ignoreArtifacts = ignoreArtifacts;
 357     }
 358
 359     public boolean isIgnoreComponentInstancesProperties() {
 360         return ignoreComponentInstancesProperties;
 361     }
 362
 363     public void setIgnoreComponentInstancesProperties(boolean ignoreComponentInstancesProperties) {
 364         this.ignoreComponentInstancesProperties = ignoreComponentInstancesProperties;
 365     }
 366
 367     public boolean isIgnoreComponentInstancesInputs() {
 368         return ignoreComponentInstancesInputs;
 369     }
 370
 371     public void setIgnoreComponentInstancesInputs(boolean ignoreComponentInstancesInputs) {
 372         this.ignoreComponentInstancesInputs = ignoreComponentInstancesInputs;
 373     }
 374
 375     public boolean isIgnoreInterfaces() {
 376         return ignoreInterfaces;
 377     }
 378
 379     public void setIgnoreInterfaces(boolean ignoreInterfaces) {
 380         this.ignoreInterfaces = ignoreInterfaces;
 381     }
 382
 383     public boolean isIgnoreComponentInstancesInterfaces() {
 384         return ignoreComponentInstancesInterfaces;
 385     }
 386
 387     public void setIgnoreComponentInstancesInterfaces(boolean ignoreComponentInstancesInterfaces) {
 388         this.ignoreComponentInstancesInterfaces = ignoreComponentInstancesInterfaces;
 389     }
 390
 391     public boolean isIgnoreAttributesFrom() {
 392         return ignoreAttributesFrom;
 393     }
 394
 395     public void setIgnoreAttributesFrom(boolean ignoreAttributesFrom) {
 396         this.ignoreAttributesFrom = ignoreAttributesFrom;
 397     }
 398
 399     public boolean isIgnoreComponentInstancesAttributesFrom() {
 400         return ignoreComponentInstancesAttributesFrom;
 401     }
 402
 403     private void setIgnoreComponentInstancesAttributesFrom(boolean ignoreComponentInstancesAttributesFrom) {
 404         this.ignoreComponentInstancesAttributesFrom = ignoreComponentInstancesAttributesFrom;
 405     }
 406
 407     public boolean isIgnoreDerivedFrom() {
 408         return ignoreDerivedFrom;
 409     }
 410
 411     private void setIgnoreDerivedFrom(boolean ignoreDerivedFrom) {
 412         this.ignoreDerivedFrom = ignoreDerivedFrom;
 413     }
 414
 415     public boolean isIgnoreUsers() {
 416         return ignoreUsers;
 417     }
 418
 419     public void setIgnoreUsers(boolean ignoreUsers) {
 420         this.ignoreUsers = ignoreUsers;
 421     }
 422
 423     public boolean isIgnoreInputs() {
 424         return ignoreInputs;
 425     }
 426
 427     public void setIgnoreInputs(boolean ignoreInputs) {
 428         this.ignoreInputs = ignoreInputs;
 429     }
 430
 431     public boolean isIgnoreCapabiltyProperties() {
 432         return ignoreCapabiltyProperties;
 433     }
 434
 435     public void setIgnoreCapabiltyProperties(boolean ignoreCapabiltyProperties) {
 436         this.ignoreCapabiltyProperties = ignoreCapabiltyProperties;
 437     }
 438
 439     public boolean isIgnoreForwardingPath() {
 440         return ignoreServicePath;
 441     }
 442
 443     public void setIgnoreForwardingPath(boolean ignoreServicePath) {
 444         this.ignoreServicePath = ignoreServicePath;
 445     }
 446
 447     public boolean isIgnorePolicies() {
 448         return ignorePolicies;
 449     }
 450
 451     public void setIgnorePolicies(boolean ignorePolicies) {
 452         this.ignorePolicies = ignorePolicies;
 453     }
 454
 455     public boolean isIgnoreNodeFilter() {
 456         return ignoreNodeFilter;
 457     }
 458
 459     public void setIgnoreNodeFilter(boolean ignoreNodeFilter) {
 460         this.ignoreNodeFilter = ignoreNodeFilter;
 461     }
 462
 463     public boolean isIgnoreDataType() {
 464         return ignoreDataType;
 465     }
 466
 467     public void setIgnoreDataType(boolean ignoreDataType) {
 468         this.ignoreDataType = ignoreDataType;
 469     }
 470
 471     public JsonParseFlagEnum detectParseFlag() {
 472         JsonParseFlagEnum parseFlag;
 473         if (isIgnoreComponentInstances()) {
 474             parseFlag = JsonParseFlagEnum.ParseMetadata;
 475         } else {
 476             parseFlag = JsonParseFlagEnum.ParseAll;
 477         }
 478         return parseFlag;
 479     }
 480 }