aai-core/src/main/java/org/openecomp/aai/introspection/Introspector.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   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.aai.introspection;
  22
  23 import java.io.UnsupportedEncodingException;
  24 import java.lang.reflect.InvocationTargetException;
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.LinkedHashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import java.util.Set;
  32
  33 import org.apache.commons.lang.ClassUtils;
  34 import org.eclipse.persistence.exceptions.DynamicException;
  35
  36 import org.openecomp.aai.introspection.exceptions.AAIUnknownObjectException;
  37 import org.openecomp.aai.logging.ErrorLogHelper;
  38 import org.openecomp.aai.restcore.MediaType;
  39 import org.openecomp.aai.schema.enums.ObjectMetadata;
  40 import org.openecomp.aai.schema.enums.PropertyMetadata;
  41 import org.openecomp.aai.workarounds.NamingExceptions;
  42 import com.att.eelf.configuration.EELFLogger;
  43 import com.att.eelf.configuration.EELFManager;
  44 import com.google.common.base.CaseFormat;
  45
  46 public abstract class Introspector implements Cloneable {
  47
  48         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(Introspector.class);
  49
  50         protected String className;
  51         protected String uriChain = "";
  52         protected Loader loader;
  53         protected final NamingExceptions namingException = NamingExceptions.getInstance();
  54         private Set<String> uniqueProperties = null;
  55         private Set<String> indexedProperties = null;
  56         private Set<String> allKeys = null;
  57         protected Introspector(Object obj) {
  58         }
  59
  60         public abstract boolean hasProperty(String name);
  61
  62         protected String convertPropertyName (String name) {
  63                 return CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, name);
  64         }
  65
  66         protected abstract Object get(String name);
  67         protected abstract void set(String name, Object value);
  68         /**
  69          *
  70          * @param name the property name you'd like to retrieve the value for
  71          * @return the value of the property
  72          */
  73         public <T> T getValue(String name) {
  74                 String convertedName = convertPropertyName(name);
  75                 Object result = null;
  76
  77                 if (this.hasProperty(name)) {
  78                         result = this.get(convertedName);
  79                 } else {
  80                         /* property not found - slightly ambiguous */
  81                         return null;
  82                 }
  83
  84                 Class<?> clazz = this.getClass(name);
  85                 if (this.isListType(name) && result == null) {
  86                         try {
  87                                 this.set(convertedName, clazz.newInstance());
  88                                 result = this.get(convertedName);
  89                         } catch (DynamicException | InstantiationException | IllegalAccessException e) {
  90
  91                         }
  92                 }
  93
  94                 return (T)result;
  95         }
  96
  97         public Introspector getWrappedValue(String name) {
  98                 String convertedName = convertPropertyName(name);
  99                 Object value = null;
 100
 101                 if (this.hasProperty(name)) {
 102                         value = this.get(convertedName);
 103                 } else {
 104                         /* property not found - slightly ambiguous */
 105                         return null;
 106                 }
 107
 108                 Class<?> clazz = this.getClass(name);
 109                 if (this.isListType(name) && value == null) {
 110                         try {
 111                                 this.set(convertedName, clazz.newInstance());
 112                                 value = this.get(convertedName);
 113                         } catch (DynamicException | InstantiationException | IllegalAccessException e) {
 114
 115                         }
 116                 }
 117                 if (value != null) {
 118                         return IntrospectorFactory.newInstance(this.getModelType(), value);
 119                 } else {
 120                         //no value
 121                         return null;
 122                 }
 123
 124         }
 125
 126         public List<Introspector> getWrappedListValue(String name) {
 127                 String convertedName = convertPropertyName(name);
 128                 Object value = null;
 129                 List<Introspector> resultList = new ArrayList<>();
 130                 if (this.hasProperty(name)) {
 131                         value = this.get(convertedName);
 132                 } else {
 133                         /* property not found - slightly ambiguous */
 134                         return null;
 135                 }
 136                 boolean isListType = this.isListType(name);
 137                 if (!this.isListType(name)) {
 138                         return null;
 139                 }
 140                 Class<?> clazz = this.getClass(name);
 141                 if (isListType && value == null) {
 142                         try {
 143                                 this.set(convertedName, clazz.newInstance());
 144                                 value = this.get(convertedName);
 145                         } catch (DynamicException | InstantiationException | IllegalAccessException e) {
 146
 147                         }
 148                 }
 149
 150                 List<Object> valueList = (List<Object>)value;
 151
 152                 for (Object item : valueList) {
 153                         resultList.add(IntrospectorFactory.newInstance(this.getModelType(), item));
 154                 }
 155
 156                 return resultList;
 157
 158         }
 159
 160         public Object castValueAccordingToSchema(String name, Object obj) {
 161                 Object result = obj;
 162                 Class<?> nameClass = this.getClass(name);
 163                 if (nameClass == null) {
 164                         throw new IllegalArgumentException("property: " + name + " does not exist on " + this.getDbName());
 165                 }
 166                 if (obj != null) {
 167
 168                         try {
 169                                 if (!obj.getClass().getName().equals(nameClass.getName())) {
 170                                         if (nameClass.isPrimitive()) {
 171                                                 nameClass = ClassUtils.primitiveToWrapper(nameClass);
 172                                                 result = nameClass.getConstructor(String.class).newInstance(obj.toString());
 173                                         }
 174                                         if (obj.getClass().getName().equals("java.lang.String")) {
 175                                                 result = nameClass.getConstructor(String.class).newInstance(obj);
 176                                         } else if (!this.isListType(name) && !this.isComplexType(name)){
 177                                                 //box = obj.toString();
 178                                                 result = nameClass.getConstructor(String.class).newInstance(obj.toString());
 179                                         }
 180                                 }
 181                         } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
 182                                         | InvocationTargetException | NoSuchMethodException | SecurityException e) {
 183                                 ErrorLogHelper.logError("AAI_4017", e.getMessage());
 184                         }
 185                 }
 186                 return result;
 187         }
 188
 189         public List<Object> castValueAccordingToSchema(String name, List<?> objs) {
 190                 List<Object> result = new ArrayList<>();
 191
 192                 for (Object item : objs) {
 193                         result.add(this.castValueAccordingToSchema(name, item));
 194                 }
 195
 196                 return result;
 197
 198         }
 199         /**
 200          *
 201          * @param name the property name you'd like to set the value of
 202          * @param obj the value to be set
 203          * @return
 204          */
 205         public void setValue(String name, Object obj) throws IllegalArgumentException {
 206                 Object box = this.castValueAccordingToSchema(name, obj);
 207
 208                 name = convertPropertyName(name);
 209                 this.set(name, box);
 210         }
 211         /**
 212          *
 213          * @return a list of all the properties available on the object
 214          */
 215         public abstract Set<String> getProperties();
 216
 217         public Set<String> getProperties(PropertyPredicate<Introspector, String> p) {
 218                 final Set<String> temp = new LinkedHashSet<>();
 219                 this.getProperties().stream().filter(item -> {
 220                         return p.test(this, item);
 221                 }).forEach(item -> {
 222                         temp.add(item);
 223                 });
 224                 final Set<String> result = Collections.unmodifiableSet(temp);
 225
 226                 return result;
 227
 228         }
 229         /**
 230          *
 231          * @return a list of the required properties on the object
 232          */
 233         public abstract Set<String> getRequiredProperties();
 234         /**
 235          *
 236          * @return a list of the properties that can be used to query the object in the db
 237          */
 238         public abstract Set<String> getKeys();
 239         /**
 240          *
 241          * @return a list of the all key properties for this object
 242          */
 243         public Set<String> getAllKeys() {
 244                 Set<String> result = null;
 245                 if (this.allKeys == null) {
 246                         Set<String> keys = this.getKeys();
 247                         result = new LinkedHashSet<>();
 248                         result.addAll(keys);
 249                         String altKeys = this.getMetadata(ObjectMetadata.ALTERNATE_KEYS_1);
 250                         if (altKeys != null) {
 251                                 String[] altKeysArray = altKeys.split(",");
 252                                 for (String altKey : altKeysArray) {
 253                                         result.add(altKey);
 254                                 }
 255                         }
 256                         result = Collections.unmodifiableSet(result);
 257                         this.allKeys = result;
 258                 }
 259                 result = this.allKeys;
 260                 return result;
 261         }
 262
 263         public Set<String> getIndexedProperties() {
 264                 Set<String> result = null;
 265
 266                 if (this.indexedProperties == null) {
 267                         result = new LinkedHashSet<>();
 268                         Set<String> keys = this.getKeys();
 269                         result.addAll(keys);
 270                         String altKeys = this.getMetadata(ObjectMetadata.INDEXED_PROPS);
 271                         if (altKeys != null) {
 272                                 String[] altKeysArray = altKeys.split(",");
 273                                 for (String altKey : altKeysArray) {
 274                                         result.add(altKey);
 275                                 }
 276                         }
 277                         this.indexedProperties = Collections.unmodifiableSet(result);
 278                 }
 279                 result = this.indexedProperties;
 280                 return result;
 281         }
 282
 283         public Set<String> getUniqueProperties() {
 284                 Set<String> result = null;
 285                 if (this.uniqueProperties == null) {
 286                         String altKeys = this.getMetadata(ObjectMetadata.UNIQUE_PROPS);
 287                         result = new LinkedHashSet<>();
 288                         if (altKeys != null) {
 289                                 String[] altKeysArray = altKeys.split(",");
 290                                 for (String altKey : altKeysArray) {
 291                                         result.add(altKey);
 292                                 }
 293                         }
 294                         this.uniqueProperties = Collections.unmodifiableSet(result);
 295
 296                 }
 297                 result = this.uniqueProperties;
 298                 return result;
 299         }
 300         /**
 301          *
 302          * @param name
 303          * @return the string name of the java class of the named property
 304          */
 305         public String getType(String name) {
 306                 Class<?> resultClass = this.getClass(name);
 307                 String result = "";
 308
 309                 if (resultClass != null) {
 310                         result = resultClass.getName();
 311                         if (result.equals("java.util.ArrayList")) {
 312                                 result = "java.util.List";
 313                         }
 314                 }
 315
 316                 return result;
 317         }
 318         /**
 319          * This will returned the generic parameterized type of the underlying
 320          * object if it exists
 321          * @param name
 322          * @return the generic type of the java class of the underlying object
 323          */
 324         public String getGenericType(String name) {
 325                 Class<?> resultClass = this.getGenericTypeClass(name);
 326                 String result = "";
 327
 328                 if (resultClass != null) {
 329                         result = resultClass.getName();
 330                 }
 331
 332                 return result;
 333         }
 334         /**
 335          *
 336          * @return the string name of the java class of the underlying object
 337          */
 338         public abstract String getJavaClassName();
 339
 340         /**
 341          *
 342          * @param name the property name
 343          * @return the Class object
 344          */
 345         public abstract Class<?> getClass(String name);
 346
 347         public abstract Class<?> getGenericTypeClass(String name);
 348
 349         /**
 350          *
 351          * @param name the property name
 352          * @return a new instance of the underlying type of this property
 353          * @throws AAIUnknownObjectException
 354          */
 355         public Object newInstanceOfProperty(String name) throws AAIUnknownObjectException {
 356                 String type = this.getType(name);
 357                 return loader.objectFromName(type);
 358         }
 359
 360         public Object newInstanceOfNestedProperty(String name) throws AAIUnknownObjectException {
 361                 String type = this.getGenericType(name);
 362                 return loader.objectFromName(type);
 363         }
 364
 365
 366         public Introspector newIntrospectorInstanceOfProperty(String name) throws AAIUnknownObjectException {
 367
 368                 Introspector result = IntrospectorFactory.newInstance(this.getModelType(), this.newInstanceOfProperty(name));
 369
 370                 return result;
 371
 372         }
 373
 374         public Introspector newIntrospectorInstanceOfNestedProperty(String name) throws AAIUnknownObjectException {
 375
 376                 Introspector result = IntrospectorFactory.newInstance(this.getModelType(), this.newInstanceOfNestedProperty(name));
 377
 378                 return result;
 379
 380         }
 381         /**
 382          * Is this type not a Java String or primitive
 383          * @param name
 384          * @return
 385          */
 386         public boolean isComplexType(String name) {
 387                 String result = this.getType(name);
 388
 389                 if (result.contains("aai") || result.equals("java.lang.Object")) {
 390                         return true;
 391                 } else {
 392                         return false;
 393                 }
 394         }
 395
 396         public boolean isComplexGenericType(String name) {
 397                 String result = this.getGenericType(name);
 398
 399                 if (result.contains("aai")) {
 400                         return true;
 401                 } else {
 402                         return false;
 403                 }
 404         }
 405
 406         public boolean isSimpleType(String name) {
 407                 return !(this.isComplexType(name) || this.isListType(name));
 408         }
 409
 410         public boolean isSimpleGenericType(String name) {
 411                 return !this.isComplexGenericType(name);
 412         }
 413
 414         public boolean isListType(String name) {
 415                 String result = this.getType(name);
 416
 417                 if (result.contains("java.util.List")) {
 418                         return true;
 419                 } else {
 420                         return false;
 421                 }
 422         }
 423
 424         public boolean isContainer() {
 425                 Set<String> props = this.getProperties();
 426                 boolean result = false;
 427                 if (props.size() == 1 && this.isListType(props.iterator().next())) {
 428                         result = true;
 429                 }
 430
 431                 return result;
 432         }
 433
 434         public abstract String getChildName();
 435         public String getChildDBName() {
 436                 String result = this.getChildName();
 437
 438                 result = namingException.getDBName(result);
 439                 return result;
 440         }
 441         public abstract String getName();
 442
 443         public String getDbName() {
 444                 String lowerHyphen = this.getName();
 445
 446                 lowerHyphen = namingException.getDBName(lowerHyphen);
 447
 448                 return lowerHyphen;
 449         }
 450
 451         public abstract ModelType getModelType();
 452
 453         public boolean hasChild(Introspector child) {
 454                 boolean result = false;
 455                 //check all inheriting types for this child
 456                 if ("true".equals(this.getMetadata(ObjectMetadata.ABSTRACT))) {
 457                         String[] inheritors = this.getMetadata(ObjectMetadata.INHERITORS).split(",");
 458                         for (String inheritor : inheritors) {
 459                                 try {
 460                                         Introspector temp = this.loader.introspectorFromName(inheritor);
 461                                         result = temp.hasProperty(child.getName());
 462                                         if (result) {
 463                                                 break;
 464                                         }
 465                                 } catch (AAIUnknownObjectException e) {
 466                                         LOGGER.warn("Skipping inheritor " + inheritor + " (Unknown Object)", e);
 467                                 }
 468                         }
 469                 } else {
 470                         result = this.hasProperty(child.getName());
 471                 }
 472                 return result;
 473         }
 474
 475         public void setURIChain(String uri) {
 476                 this.uriChain = uri;
 477         }
 478         public abstract String getObjectId() throws UnsupportedEncodingException;
 479
 480         public String getURI() throws UnsupportedEncodingException {
 481                 //String result = this.uriChain;
 482                 String result = "";
 483                 String namespace = this.getMetadata(ObjectMetadata.NAMESPACE);
 484                 String container = this.getMetadata(ObjectMetadata.CONTAINER);
 485                 if (this.isContainer()) {
 486                          result += "/" + this.getName();
 487                 } else {
 488
 489                         if (container != null) {
 490                                 result += "/" + container;
 491                         }
 492                         result += "/" + this.getDbName() + "/" + this.findKey();
 493
 494                         if (namespace != null && !namespace.equals("")) {
 495                                 result = "/" + namespace + result;
 496                         }
 497                 }
 498
 499
 500                 return result;
 501         }
 502
 503         public String getGenericURI() {
 504                 String result = "";
 505                 if (this.isContainer()) {
 506                          result += "/" + this.getName();
 507                 } else {
 508                         result += "/" + this.getDbName();
 509                         for (String key : this.getKeys()) {
 510                                 result += "/{" + this.getDbName() + "-" + key + "}";
 511                         }
 512                 }
 513
 514                 return result;
 515         }
 516
 517         public String getFullGenericURI() {
 518                 String result = "";
 519                 String namespace = this.getMetadata(ObjectMetadata.NAMESPACE);
 520                 String container = this.getMetadata(ObjectMetadata.CONTAINER);
 521                 if (this.isContainer()) {
 522                          result += "/" + this.getName();
 523                 } else {
 524
 525
 526                         if (container != null) {
 527                                 result += "/" + container;
 528                         }
 529                         result += "/" + this.getDbName();
 530
 531                         for (String key : this.getKeys()) {
 532                                 result += "/{" + this.getDbName() + "-" + key + "}";
 533                         }
 534                         if (namespace != null && !namespace.equals("")) {
 535                                 result = "/" + namespace + result;
 536                         }
 537
 538                 }
 539
 540                 return result;
 541         }
 542
 543         public abstract String preProcessKey(String key);
 544
 545         protected abstract String findKey() throws UnsupportedEncodingException;
 546
 547         public abstract String marshal(MarshallerProperties properties);
 548
 549         public abstract Object clone();
 550
 551         public abstract Object getUnderlyingObject();
 552
 553         public String marshal(boolean formatted) {
 554                 MarshallerProperties properties =
 555                                 new MarshallerProperties.Builder(MediaType.APPLICATION_JSON_TYPE).formatted(formatted).build();
 556
 557                 return marshal(properties);
 558         }
 559         public String makeSingular(String word) {
 560
 561                 String result = word;
 562                 result = result.replaceAll("(?:([ho])es|s)$", "");
 563
 564                 if (result.equals("ClassesOfService")) {
 565                         result = "ClassOfService";
 566                 } else if (result.equals("CvlanTag")) {
 567                         result = "CvlanTagEntry";
 568                 } else if (result.equals("Metadata")) {
 569                         result = "Metadatum";
 570                 }
 571                 return result;
 572         }
 573
 574         protected String makePlural(String word) {
 575                 String result = word;
 576
 577                 if (result.equals("cvlan-tag-entry")) {
 578                         return "cvlan-tags";
 579                 } else if (result.equals("class-of-service")) {
 580                         return "classes-of-service";
 581                 } else if (result.equals("metadatum")) {
 582                         return "metadata";
 583                 }
 584                 result = result.replaceAll("([a-z])$", "$1s");
 585                 result = result.replaceAll("([hox])s$", "$1es");
 586                 /*
 587                 if (result.equals("classes-of-services")) {
 588                         result = "classes-of-service";
 589                 }*/
 590
 591                 return result;
 592         }
 593
 594         public abstract String getMetadata(ObjectMetadata metadataName);
 595         public abstract Map<PropertyMetadata, String> getPropertyMetadata(String propName);
 596         public Optional<String> getPropertyMetadata(String propName, PropertyMetadata metadataName) {
 597                 final String resultValue = this.getPropertyMetadata(propName).getOrDefault(metadataName, "");
 598                 Optional<String> result = Optional.empty();
 599
 600                 if (!resultValue.isEmpty()) {
 601                         result = Optional.of(resultValue);
 602                 }
 603                 return result;
 604
 605         }
 606
 607         public abstract Version getVersion();
 608         public Loader getLoader() {
 609                 return this.loader;
 610         }
 611
 612         public boolean isTopLevel() {
 613
 614                 return this.getMetadata(ObjectMetadata.NAMESPACE) != null;
 615         }
 616 }