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