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