aai-core/src/main/java/org/openecomp/aai/introspection/PojoStrategy.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.StringReader;
  24 import java.io.StringWriter;
  25 import java.lang.reflect.Field;
  26 import java.lang.reflect.InvocationTargetException;
  27 import java.lang.reflect.Method;
  28 import java.lang.reflect.ParameterizedType;
  29 import java.lang.reflect.Type;
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.Collections;
  33 import java.util.HashMap;
  34 import java.util.LinkedHashSet;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Set;
  38
  39 import javax.xml.bind.JAXBContext;
  40 import javax.xml.bind.JAXBException;
  41 import javax.xml.bind.Marshaller;
  42 import javax.xml.bind.Unmarshaller;
  43 import javax.xml.bind.annotation.XmlElement;
  44 import javax.xml.transform.stream.StreamSource;
  45
  46 import org.eclipse.persistence.jaxb.UnmarshallerProperties;
  47
  48 import org.openecomp.aai.annotations.Metadata;
  49 import org.openecomp.aai.logging.ErrorLogHelper;
  50 import org.openecomp.aai.restcore.MediaType;
  51 import org.openecomp.aai.schema.enums.ObjectMetadata;
  52 import org.openecomp.aai.schema.enums.PropertyMetadata;
  53 import com.google.common.base.CaseFormat;
  54 import com.google.common.base.Joiner;
  55 import com.google.common.collect.Multimap;
  56
  57 public class PojoStrategy extends Introspector {
  58
  59         private Object internalObject = null;
  60         private PojoInjestor injestor = null;
  61         private Multimap<String, String> keyProps = null;
  62         private Metadata classLevelMetadata = null;
  63         private Version version;
  64         private JAXBContext jaxbContext;
  65         private Marshaller marshaller;
  66         private Unmarshaller unmarshaller;
  67         private Set<String> properties = null;
  68         private Set<String> keys = null;
  69         private Set<String> requiredProperties = null;
  70
  71         private boolean isInitialized = false;
  72
  73         protected PojoStrategy(Object obj) {
  74                 super(obj);
  75                 className = PojoStrategy.class.getSimpleName();
  76                 this.internalObject = obj;
  77                 injestor = new PojoInjestor();
  78                 classLevelMetadata = obj.getClass().getAnnotation(Metadata.class);
  79
  80                 version = injestor.getVersion(obj.getClass().getName());
  81                 jaxbContext = injestor.getContextForVersion(version);
  82                 super.loader = LoaderFactory.createLoaderForVersion(getModelType(), version);
  83                 try {
  84                         marshaller = jaxbContext.createMarshaller();
  85                         unmarshaller = jaxbContext.createUnmarshaller();
  86                 } catch (JAXBException e) {
  87
  88                 }
  89
  90         }
  91
  92         private void init() {
  93
  94                 isInitialized = true;
  95
  96                 Set<String> properties = new LinkedHashSet<>();
  97                 Set<String> keys = new LinkedHashSet<>();
  98                 Set<String> required = new LinkedHashSet<>();
  99
 100                 Field[] fields = this.internalObject.getClass().getDeclaredFields();
 101
 102                 for (Field field : fields) {
 103                         if (!field.getName().equals("any")) {
 104                                 properties.add(covertFieldToOutputFormat(field.getName()));
 105                                 Metadata annotation = field.getAnnotation(Metadata.class);
 106                                 XmlElement xmlAnnotation = field.getAnnotation(XmlElement.class);
 107                                 if (annotation != null) {
 108                                         if (annotation.isKey()) {
 109                                                 keys.add(covertFieldToOutputFormat(field.getName()));
 110                                         }
 111                                 }
 112                                 if (xmlAnnotation != null) {
 113                                         if (xmlAnnotation.required()) {
 114                                                 required.add(covertFieldToOutputFormat(field.getName()));
 115                                         }
 116                                 }
 117                         }
 118                 }
 119                 properties = Collections.unmodifiableSet(properties);
 120                 this.properties = properties;
 121
 122                 keys = Collections.unmodifiableSet(keys);
 123                 this.keys = keys;
 124
 125                 required = Collections.unmodifiableSet(required);
 126                 this.requiredProperties = required;
 127
 128         }
 129         private String covertFieldToOutputFormat(String propName) {
 130                 return CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, propName);
 131         }
 132
 133         @Override
 134         public boolean hasProperty(String name) {
 135                 //TODO
 136                 return true;
 137         }
 138
 139         @Override
 140         /**
 141          * Gets the value of the property via reflection
 142          */
 143         public Object get(String name) {
 144                 String getMethodName = "get" + CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, name);
 145                 try {
 146                         return this.internalObject.getClass().getDeclaredMethod(getMethodName).invoke(this.internalObject);
 147                 } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
 148                         return null;
 149                 }
 150         }
 151
 152         @Override
 153         public void set(String name, Object value) {
 154                 String setMethodName = "set" + CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, name);
 155                 try {
 156                         this.internalObject.getClass().getDeclaredMethod(setMethodName, value.getClass()).invoke(this.internalObject, value);
 157                 } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
 158                         ErrorLogHelper.logError("AAI_4017", "Error setting name/value pair on POJO: " + e.getMessage());
 159                 }
 160         }
 161
 162         @Override
 163         public Set<String> getProperties() {
 164
 165                 if(!isInitialized){
 166                         this.init();
 167                 }
 168                 return this.properties;
 169         }
 170
 171
 172         @Override
 173         public Set<String> getRequiredProperties() {
 174
 175                 if(!isInitialized) {
 176                         this.init();
 177                 }
 178                 return this.requiredProperties;
 179         }
 180
 181         @Override
 182         public Set<String> getKeys() {
 183
 184                 if(!isInitialized){
 185                         this.init();
 186                 }
 187                 return this.keys;
 188         }
 189
 190         public Class<?> getClass(String name) {
 191
 192                 Field field = null;
 193                 try {
 194                         field = this.internalObject.getClass().getDeclaredField(CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, name));
 195                 } catch (NoSuchFieldException | SecurityException e) {
 196
 197                         return null;
 198                 }
 199
 200                 return field.getType();
 201         }
 202
 203         public Class<?> getGenericTypeClass(String name) {
 204
 205                 try {
 206                         String getMethodName = "get" + CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, name);
 207                         Method method = internalObject.getClass().getDeclaredMethod(getMethodName);
 208                         Type t = method.getGenericReturnType();
 209                         if(t instanceof ParameterizedType) {
 210                                 ParameterizedType pt = (ParameterizedType)t;
 211                                 return ((Class<?>)pt.getActualTypeArguments()[0]);
 212                         } else {
 213                                 return null;
 214                         }
 215
 216                 } catch (Exception e) {
 217                         return null;
 218                 }
 219         }
 220
 221         @Override
 222         public String getJavaClassName() {
 223                 return internalObject.getClass().getName();
 224         }
 225
 226         @Override
 227         public Object getUnderlyingObject() {
 228                 return this.internalObject;
 229         }
 230
 231         @Override
 232         public String getName() {
 233                 String className = internalObject.getClass().getSimpleName();
 234
 235                 return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
 236         }
 237
 238         @Override
 239         protected String findKey() {
 240                 Set<String> keys = null;
 241                 keys = this.getKeys();
 242                 List<String> results = new ArrayList<>();
 243                 for (String key : keys) {
 244                         if (this.getType(key).toLowerCase().contains("long")) {
 245                                 key = ((Long)this.getValue(key)).toString();
 246                         } else {
 247                                 key = (String)this.getValue(key);
 248                         }
 249                         results.add(key);
 250                 }
 251
 252                 return Joiner.on("/").join(results);
 253         }
 254
 255         @Override
 256         public String marshal(MarshallerProperties properties) {
 257                 StringWriter result = new StringWriter();
 258         try {
 259                 if (properties.getMediaType().equals(MediaType.APPLICATION_JSON_TYPE)) {
 260                                 marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.MEDIA_TYPE, "application/json");
 261                         marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_INCLUDE_ROOT, properties.getIncludeRoot());
 262                         marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, properties.getWrapperAsArrayName());
 263                 }
 264                 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, properties.getFormatted());
 265                 marshaller.marshal(this.internalObject, result);
 266                 } catch (JAXBException e) {
 267                         //e.printStackTrace();
 268                 }
 269
 270         return result.toString();
 271         }
 272
 273         @Override
 274         public Object clone() {
 275                 Object result = null;
 276                  try {
 277                                 unmarshaller = jaxbContext.createUnmarshaller();
 278
 279                         unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, "application/json");
 280                         unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
 281                                 unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, true);
 282
 283                                 result = unmarshaller.unmarshal(new StreamSource(new StringReader(this.marshal(true))), this.internalObject.getClass()).getValue();
 284                          } catch (JAXBException e) {
 285                                         // TODO Auto-generated catch block
 286                                         //e.printStackTrace();
 287                         }
 288                  result = IntrospectorFactory.newInstance(getModelType(), result);
 289                  return result;
 290         }
 291
 292         @Override
 293         public String preProcessKey (String key) {
 294                 String result = "";
 295                 //String trimmedRestURI = restURI.replaceAll("/[\\w\\-]+?/[\\w\\-]+?$", "");
 296                 String[] split = key.split("/");
 297                 int i = 0;
 298                 for (i = split.length-1; i >= 0; i--) {
 299
 300                         if (keyProps.containsKey(split[i])) {
 301                                 break;
 302
 303                         }
 304
 305                 }
 306                 result = Joiner.on("/").join(Arrays.copyOfRange(split, 0, i));
 307
 308                 return result;
 309
 310         }
 311
 312         @Override
 313         public ModelType getModelType() {
 314                 return ModelType.POJO;
 315         }
 316
 317         @Override
 318         public String getChildName() {
 319                 String className = internalObject.getClass().getSimpleName();
 320                 String lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
 321
 322                 if (this.isContainer()) {
 323                         lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,this.getGenericTypeClass(this.getProperties().iterator().next()).getSimpleName());
 324                 }
 325
 326                 return lowerHyphen;
 327         }
 328
 329         @Override
 330         public Map<PropertyMetadata, String> getPropertyMetadata(String prop) {
 331                 Field f;
 332                 Map<PropertyMetadata, String> result = new HashMap<>();
 333                 try {
 334                         f = internalObject.getClass().getField(prop);
 335                         Metadata m = f.getAnnotation(Metadata.class);
 336                         if (m != null) {
 337                                 Field[] fields = m.getClass().getFields();
 338                                 String fieldName;
 339                                 for (Field field : fields) {
 340                                         fieldName = field.getName();
 341                                         if (fieldName.equals("isAbstract")) {
 342                                                 fieldName = "abstract";
 343                                         } else if (fieldName.equals("extendsFrom")) {
 344                                                 fieldName = "extends";
 345                                         }
 346                                         fieldName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, fieldName);
 347                                         result.put(PropertyMetadata.valueOf(fieldName), (String)field.get(m));
 348                                 }
 349                         }
 350                 } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
 351                         // TODO Auto-generated catch block
 352                 }
 353
 354                 return result;
 355         }
 356
 357         @Override
 358         public String getObjectId() {
 359                 // TODO Auto-generated method stub
 360                 return null;
 361         }
 362
 363         @Override
 364         public String getMetadata(ObjectMetadata metadataName) {
 365                 String value = null;
 366                 String methodName;
 367                 if (ObjectMetadata.ABSTRACT.equals(metadataName)) {
 368                         methodName = "isAbstract";
 369                 } else if (ObjectMetadata.EXTENDS.equals(metadataName)) {
 370                         methodName = "extendsFrom";
 371                 } else {
 372                         methodName = metadataName.toString();
 373                 }
 374
 375                 try {
 376                         value = (String)this.classLevelMetadata.getClass().getMethod(methodName).invoke(classLevelMetadata);
 377                 } catch (IllegalArgumentException | IllegalAccessException | SecurityException | InvocationTargetException | NoSuchMethodException e) {
 378                         //TODO
 379                 }
 380
 381                 return value;
 382         }
 383
 384         @Override
 385         public Version getVersion() {
 386                 // TODO Auto-generated method stub
 387                 return null;
 388         }
 389 }