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