aai-core/src/main/java/org/openecomp/aai/introspection/MoxyStrategy.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.io.UnsupportedEncodingException;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.LinkedHashSet;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Map.Entry;
  34 import java.util.Set;
  35
  36 import javax.xml.bind.JAXBException;
  37 import javax.xml.bind.Marshaller;
  38 import javax.xml.bind.Unmarshaller;
  39 import javax.xml.transform.stream.StreamSource;
  40
  41 import org.eclipse.persistence.descriptors.ClassDescriptor;
  42 import org.eclipse.persistence.dynamic.DynamicEntity;
  43 import org.eclipse.persistence.dynamic.DynamicType;
  44 import org.eclipse.persistence.exceptions.DynamicException;
  45 import org.eclipse.persistence.jaxb.UnmarshallerProperties;
  46 import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
  47 import org.eclipse.persistence.mappings.DatabaseMapping;
  48 import org.eclipse.persistence.oxm.XMLField;
  49 import org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping;
  50 import org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping;
  51 import org.springframework.web.util.UriUtils;
  52
  53 import org.openecomp.aai.restcore.MediaType;
  54 import org.openecomp.aai.schema.enums.ObjectMetadata;
  55 import org.openecomp.aai.schema.enums.PropertyMetadata;
  56 import com.google.common.base.CaseFormat;
  57 import com.google.common.base.Joiner;
  58
  59 public class MoxyStrategy extends Introspector {
  60
  61         private DynamicEntity internalObject = null;
  62         private DynamicType internalType = null;
  63         private DynamicJAXBContext jaxbContext = null;
  64         private ClassDescriptor cd = null;
  65         private Marshaller marshaller = null;
  66         private Unmarshaller unmarshaller = null;
  67         private Version version = null;
  68         private Set<String> properties = null;
  69         private Set<String> keys = null;
  70         private Set<String> requiredProperties = null;
  71
  72         private boolean isInitialized = false;
  73
  74         protected MoxyStrategy(Object obj) {
  75                 super(obj);
  76                 /* must look up the correct jaxbcontext for this object */
  77                 className = MoxyStrategy.class.getSimpleName();
  78                 internalObject = (DynamicEntity)obj;
  79                 ModelInjestor injestor = ModelInjestor.getInstance();
  80                 version = injestor.getVersionFromClassName(internalObject.getClass().getName());
  81                 jaxbContext = injestor.getContextForVersion(version);
  82                 super.loader = LoaderFactory.createLoaderForVersion(getModelType(), version);
  83                 String simpleName = internalObject.getClass().getName();
  84                 internalType = jaxbContext.getDynamicType(simpleName);
  85                 cd = internalType.getDescriptor();
  86                 try {
  87                         marshaller = jaxbContext.createMarshaller();
  88                         unmarshaller = jaxbContext.createUnmarshaller();
  89                 } catch (JAXBException e) {
  90
  91                 }
  92
  93         }
  94
  95         private void init() {
  96                 isInitialized = true;
  97
  98                 Set<String> props = new LinkedHashSet<>();
  99                 for (String s : internalType.getPropertiesNames()) {
 100                         props.add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, s));
 101
 102                 }
 103                 props = Collections.unmodifiableSet(props);
 104                 this.properties = props;
 105
 106                 Set<String> requiredProps = new LinkedHashSet<>();
 107                 requiredProps = new LinkedHashSet<>();
 108                 for (DatabaseMapping dm : cd.getMappings()) {
 109                         if (dm.getField() instanceof XMLField) {
 110                                 XMLField x = (XMLField)dm.getField();
 111                                 if (x != null) {
 112                                         if (x.isRequired()) {
 113                                                 requiredProps.add(this.removeXPathDescriptor(x.getName()));
 114                                         }
 115                                 }
 116                         }
 117                 }
 118                 requiredProps = Collections.unmodifiableSet(requiredProps);
 119                 this.requiredProperties = requiredProps;
 120
 121                 Set<String> keys = new LinkedHashSet<>();
 122
 123                 for (String name : internalType.getDescriptor().getPrimaryKeyFieldNames()) {
 124                         keys.add(this.removeXPathDescriptor(name));
 125                 }
 126                 keys = Collections.unmodifiableSet(keys);
 127                 this.keys = keys;
 128
 129
 130         }
 131
 132         @Override
 133         public boolean hasProperty(String name) {
 134                 String convertedName = convertPropertyName(name);
 135
 136                 return internalType.containsProperty(convertedName);
 137         }
 138
 139         @Override
 140         public Object get(String name) {
 141                 return internalObject.get(name);
 142         }
 143
 144         @Override
 145         public void set(String name, Object obj) throws IllegalArgumentException {
 146
 147                 internalObject.set(name, obj);
 148         }
 149
 150         @Override
 151         public Set<String> getProperties() {
 152
 153                 if(!isInitialized){
 154                         init();
 155                 }
 156
 157                 return this.properties;
 158
 159         }
 160
 161         @Override
 162         public Set<String> getRequiredProperties() {
 163
 164                 if(!isInitialized){
 165                         init();
 166                 }
 167
 168                 return this.requiredProperties;
 169         }
 170
 171         @Override
 172         public Set<String> getKeys() {
 173
 174                 if(!isInitialized){
 175                         init();
 176                 }
 177
 178                 return this.keys;
 179         }
 180
 181         @Override
 182         public Map<PropertyMetadata, String> getPropertyMetadata(String prop) {
 183                 String propName = this.convertPropertyName(prop);
 184                 DatabaseMapping mapping = cd.getMappingForAttributeName(propName);
 185                 Map<PropertyMetadata, String> result = new HashMap<>();
 186                 if (mapping != null) {
 187                         Set<Entry> entrySet = mapping.getProperties().entrySet();
 188                         for (Entry<?,?> entry : entrySet) {
 189                                 result.put(
 190                                                 PropertyMetadata.valueOf(CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, (String)entry.getKey())), (String)entry.getValue());
 191                         }
 192                 }
 193
 194                 return result;
 195         }
 196
 197         @Override
 198         public String getJavaClassName() {
 199                 return internalObject.getClass().getName();
 200         }
 201
 202
 203
 204         @Override
 205         public Class<?> getClass(String name) {
 206                 name = convertPropertyName(name);
 207                 Class<?> resultClass = null;
 208                 try {
 209                         if (internalType.getPropertyType(name) == null) {
 210                                 if (cd.getMappingForAttributeName(name) instanceof XMLCompositeDirectCollectionMapping) {
 211                                         resultClass = cd.getMappingForAttributeName(name).getContainerPolicy().getContainerClass();
 212
 213                                 } else if (cd.getMappingForAttributeName(name) instanceof XMLCompositeCollectionMapping) {
 214                                         resultClass = cd.getMappingForAttributeName(name).getContainerPolicy().getContainerClass();
 215                                 } else {
 216                                         ClassDescriptor referenceDiscriptor = cd.getMappingForAttributeName(name).getReferenceDescriptor();
 217                                         if (referenceDiscriptor != null) {
 218                                                 resultClass = referenceDiscriptor.getJavaClass();
 219                                         } else {
 220                                                 resultClass = Object.class;
 221                                         }
 222                                 }
 223                         } else {
 224                                 resultClass = internalType.getPropertyType(name);
 225                         }
 226                 } catch (DynamicException e) {
 227                         //property doesn't exist
 228                 }
 229                 return resultClass;
 230         }
 231
 232         @Override
 233         public Class<?> getGenericTypeClass(String name) {
 234                 name = convertPropertyName(name);
 235                 Class<?> resultClass = null;
 236                 if (internalType.getPropertyType(name) == null) {
 237                         if (cd.getMappingForAttributeName(name) instanceof XMLCompositeDirectCollectionMapping) {
 238                                 resultClass = cd.getMappingForAttributeName(name).getFields().get(0).getType();
 239
 240                         } else if (cd.getMappingForAttributeName(name) instanceof XMLCompositeCollectionMapping) {
 241                                 resultClass = cd.getMappingForAttributeName(name).getReferenceDescriptor().getJavaClass();
 242                         }
 243                 }
 244
 245                 return resultClass;
 246         }
 247
 248         @Override
 249         public Object getUnderlyingObject() {
 250                 return this.internalObject;
 251         }
 252
 253         @Override
 254         public String getChildName() {
 255
 256                 String className = internalObject.getClass().getSimpleName();
 257                 String lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
 258
 259                 if (this.isContainer()) {
 260                         lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,this.getGenericTypeClass(this.getProperties().iterator().next()).getSimpleName());
 261                 }
 262
 263                 return lowerHyphen;
 264         }
 265
 266         @Override
 267         public String getName() {
 268                 String className = internalObject.getClass().getSimpleName();
 269                 String lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
 270                 /*
 271                 if (this.isContainer()) {
 272                         lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,this.getGenericTypeClass(this.getProperties().get(0)).getSimpleName());
 273                 }*/
 274
 275
 276                 return lowerHyphen;
 277         }
 278
 279         @Override
 280         public String getObjectId() throws UnsupportedEncodingException {
 281                 String result = "";
 282                 String container = this.getMetadata(ObjectMetadata.CONTAINER);
 283                 if (this.isContainer()) {
 284                          result += "/" + this.getName();
 285                 } else {
 286
 287                         if (container != null) {
 288                                 result += "/" + container;
 289                         }
 290                         result += "/" + this.getDbName() + "/" + this.findKey();
 291
 292                 }
 293
 294                 return result;
 295         }
 296
 297         @Override
 298         protected String findKey() throws UnsupportedEncodingException {
 299                 Set<String> keys = null;
 300                 keys = this.getKeys();
 301                 List<String> results = new ArrayList<>();
 302                 for (String key : keys) {
 303                         if (this.getType(key).toLowerCase().contains("long")) {
 304                                 key = ((Long)this.getValue(key)).toString();
 305                         } else {
 306                                 key = (String)this.getValue(key);
 307                         }
 308                         key = UriUtils.encode(key, "UTF-8");
 309
 310                         results.add(key);
 311                 }
 312
 313                 return Joiner.on("/").join(results);
 314         }
 315
 316         @Override
 317         public String preProcessKey (String key) {
 318                 String result = "";
 319                 //String trimmedRestURI = restURI.replaceAll("/[\\w\\-]+?/[\\w\\-]+?$", "");
 320                 String[] split = key.split("/");
 321                 int i = 0;
 322                 for (i = split.length-1; i >= 0; i--) {
 323
 324                         if (jaxbContext.getDynamicType(split[i]) != null) {
 325                                 break;
 326
 327                         }
 328
 329                 }
 330                 result = Joiner.on("/").join(Arrays.copyOfRange(split, 0, i));
 331
 332                 return result;
 333
 334         }
 335
 336         @Override
 337         public String marshal(MarshallerProperties properties) {
 338                 StringWriter result = new StringWriter();
 339         try {
 340                 if (properties.getMediaType().equals(MediaType.APPLICATION_JSON_TYPE)) {
 341                                 marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.MEDIA_TYPE, "application/json");
 342                         marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_INCLUDE_ROOT, properties.getIncludeRoot());
 343                         marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, properties.getWrapperAsArrayName());
 344                         marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_MARSHAL_EMPTY_COLLECTIONS, false);
 345                 }
 346                 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, properties.getFormatted());
 347                 marshaller.marshal(this.internalObject, result);
 348                 } catch (JAXBException e) {
 349                         //e.printStackTrace();
 350                 }
 351
 352         return result.toString();
 353         }
 354
 355         @Override
 356         public Object clone() {
 357                 Object result = null;
 358                  try {
 359                                 unmarshaller = jaxbContext.createUnmarshaller();
 360
 361                         unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, "application/json");
 362                         unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
 363                                 unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, true);
 364
 365                                 result = unmarshaller.unmarshal(new StreamSource(new StringReader(this.marshal(true))), this.internalObject.getClass()).getValue();
 366                          } catch (JAXBException e) {
 367                                         // TODO Auto-generated catch block
 368                                         //e.printStackTrace();
 369                         }
 370                  result = IntrospectorFactory.newInstance(getModelType(), result);
 371                  return result;
 372         }
 373         @Override
 374         public ModelType getModelType() {
 375                 return ModelType.MOXY;
 376         }
 377
 378         private String removeXPathDescriptor(String name) {
 379
 380                 return name.replaceAll("/text\\(\\)", "");
 381         }
 382
 383         @Override
 384         public String getMetadata(ObjectMetadata name) {
 385
 386                 return (String)cd.getProperty(name.toString());
 387         }
 388
 389         @Override
 390         public Version getVersion() {
 391
 392                 return this.version;
 393         }
 394 }