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