| /******************************************************************************* | |
| * Copyright (c) 2011, 2013 Oracle and/or its affiliates. All rights reserved. | |
| * This program and the accompanying materials are made available under the | |
| * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
| * which accompanies this distribution. | |
| * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
| * and the Eclipse Distribution License is available at | |
| * http://www.eclipse.org/org/documents/edl-v10.php. | |
| * | |
| * Contributors: | |
| * dclarke/tware - initial | |
| ******************************************************************************/ | |
| package org.eclipse.persistence.jpa.rs; | |
| import java.beans.BeanInfo; | |
| import java.beans.Introspector; | |
| import java.beans.PropertyDescriptor; | |
| import java.io.IOException; | |
| import java.io.InputStream; | |
| import java.io.OutputStream; | |
| import java.lang.reflect.Constructor; | |
| import java.lang.reflect.Field; | |
| import java.lang.reflect.Method; | |
| import java.net.URI; | |
| import java.security.AccessController; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import javax.persistence.EntityManager; | |
| import javax.persistence.EntityManagerFactory; | |
| import javax.persistence.Query; | |
| import javax.persistence.spi.PersistenceUnitInfo; | |
| import javax.ws.rs.core.MediaType; | |
| import javax.xml.bind.JAXBElement; | |
| import javax.xml.bind.JAXBException; | |
| import javax.xml.bind.Marshaller; | |
| import javax.xml.bind.Unmarshaller; | |
| import javax.xml.bind.ValidationEvent; | |
| import javax.xml.bind.ValidationEventHandler; | |
| import javax.xml.bind.annotation.adapters.XmlAdapter; | |
| import javax.xml.stream.XMLOutputFactory; | |
| import javax.xml.stream.XMLStreamWriter; | |
| import javax.xml.transform.stream.StreamSource; | |
| import org.eclipse.persistence.config.PersistenceUnitProperties; | |
| import org.eclipse.persistence.descriptors.ClassDescriptor; | |
| import org.eclipse.persistence.descriptors.FetchGroupManager; | |
| import org.eclipse.persistence.dynamic.DynamicEntity; | |
| import org.eclipse.persistence.dynamic.DynamicType; | |
| import org.eclipse.persistence.eis.mappings.EISCompositeCollectionMapping; | |
| import org.eclipse.persistence.internal.helper.ConversionManager; | |
| import org.eclipse.persistence.internal.jpa.EJBQueryImpl; | |
| import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl; | |
| import org.eclipse.persistence.internal.jpa.weaving.RestAdapterClassWriter; | |
| import org.eclipse.persistence.internal.security.PrivilegedAccessHelper; | |
| import org.eclipse.persistence.internal.security.PrivilegedGetDeclaredFields; | |
| import org.eclipse.persistence.internal.security.PrivilegedMethodInvoker; | |
| import org.eclipse.persistence.internal.sessions.AbstractSession; | |
| import org.eclipse.persistence.internal.weaving.PersistenceWeavedRest; | |
| import org.eclipse.persistence.internal.weaving.RelationshipInfo; | |
| import org.eclipse.persistence.jaxb.JAXBContext; | |
| import org.eclipse.persistence.jaxb.JAXBContextProperties; | |
| import org.eclipse.persistence.jaxb.MarshallerProperties; | |
| import org.eclipse.persistence.jaxb.UnmarshallerProperties; | |
| import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContextFactory; | |
| import org.eclipse.persistence.jpa.JpaHelper; | |
| import org.eclipse.persistence.jpa.PersistenceProvider; | |
| import org.eclipse.persistence.jpa.dynamic.JPADynamicHelper; | |
| import org.eclipse.persistence.jpa.rs.config.ConfigDefaults; | |
| import org.eclipse.persistence.jpa.rs.exceptions.JPARSConfigurationException; | |
| import org.eclipse.persistence.jpa.rs.exceptions.JPARSException; | |
| import org.eclipse.persistence.jpa.rs.logging.LoggingLocalization; | |
| import org.eclipse.persistence.jpa.rs.util.IdHelper; | |
| import org.eclipse.persistence.jpa.rs.util.JPARSLogger; | |
| import org.eclipse.persistence.jpa.rs.util.JTATransactionWrapper; | |
| import org.eclipse.persistence.jpa.rs.util.PreLoginMappingAdapter; | |
| import org.eclipse.persistence.jpa.rs.util.ResourceLocalTransactionWrapper; | |
| import org.eclipse.persistence.jpa.rs.util.TransactionWrapper; | |
| import org.eclipse.persistence.jpa.rs.util.list.MultiResultQueryList; | |
| import org.eclipse.persistence.jpa.rs.util.list.MultiResultQueryListItem; | |
| import org.eclipse.persistence.jpa.rs.util.list.SingleResultQueryList; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.DynamicXMLMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.JavaLangMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.JavaMathMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.JavaUtilMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.LinkMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.MultiResultQueryListItemMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.MultiResultQueryListMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.SimpleHomogeneousListMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.metadatasources.SingleResultQueryListMetadataSource; | |
| import org.eclipse.persistence.jpa.rs.util.xmladapters.LinkAdapter; | |
| import org.eclipse.persistence.jpa.rs.util.xmladapters.RelationshipLinkAdapter; | |
| import org.eclipse.persistence.mappings.DatabaseMapping; | |
| import org.eclipse.persistence.mappings.ForeignReferenceMapping; | |
| import org.eclipse.persistence.mappings.ObjectReferenceMapping; | |
| import org.eclipse.persistence.oxm.mappings.XMLInverseReferenceMapping; | |
| import org.eclipse.persistence.queries.DatabaseQuery; | |
| import org.eclipse.persistence.queries.FetchGroup; | |
| import org.eclipse.persistence.queries.FetchGroupTracker; | |
| import org.eclipse.persistence.sessions.DatabaseSession; | |
| import org.eclipse.persistence.sessions.Session; | |
| /** | |
| * A wrapper around the JPA and JAXB artifacts used to persist an application. | |
| * | |
| * A PersistenceContext provides the capability of using the same persistence unit in JPA to | |
| * to interact with a Database or other JPA-capable data source and in JAXB to interact with either | |
| * XML or JSON. | |
| * | |
| * A PersistenceContext can wrap either an existing persistence unit (EntityManagerFactory), or it can be used to bootstrap a | |
| * fully dynamic persistence unit. | |
| * | |
| * @author douglas.clarke, tom.ware | |
| */ | |
| public class PersistenceContext { | |
| public static final String JPARS_CONTEXT = "eclipselink.jpars.context"; | |
| @SuppressWarnings("rawtypes") | |
| protected List<XmlAdapter> adapters = null; | |
| /** | |
| * The name of the persistence context is used to look it up. By default it will be the | |
| * persistence unit name of the JPA persistence unit. | |
| */ | |
| protected String name = null; | |
| /** The EntityManagerFactory used to interact using JPA **/ | |
| protected EntityManagerFactory emf; | |
| /** The JAXBConext used to produce JSON or XML **/ | |
| protected JAXBContext context = null; | |
| /** The URI of the Persistence context. This is used to build Links in JSON and XML **/ | |
| protected URI baseURI = null; | |
| protected TransactionWrapper transaction = null; | |
| private Boolean weavingEnabled = null; | |
| private String version = null; | |
| protected PersistenceContext() { | |
| } | |
| /** | |
| * Instantiates a new persistence context. | |
| * | |
| * @param emfName the emf name | |
| * @param emf the emf | |
| * @param defaultURI the default uri | |
| */ | |
| public PersistenceContext(String emfName, EntityManagerFactoryImpl emf, URI defaultURI) { | |
| super(); | |
| this.emf = emf; | |
| this.name = emfName; | |
| if (getJpaSession().hasExternalTransactionController()){ | |
| transaction = new JTATransactionWrapper(); | |
| } else { | |
| transaction = new ResourceLocalTransactionWrapper(); | |
| } | |
| try{ | |
| this.context = createDynamicJAXBContext(emf.getDatabaseSession()); | |
| } catch (JAXBException jaxbe){ | |
| JPARSLogger.exception("exception_creating_jaxb_context", new Object[]{emfName, jaxbe.toString()}, jaxbe); | |
| emf.close(); | |
| } catch (IOException e){ | |
| JPARSLogger.exception("exception_creating_jaxb_context", new Object[]{emfName, e.toString()}, e); | |
| emf.close(); | |
| } | |
| setBaseURI(defaultURI); | |
| } | |
| public boolean isWeavingEnabled() { | |
| if (this.weavingEnabled == null) { | |
| this.weavingEnabled = getWeavingProperty(); | |
| } | |
| return this.weavingEnabled; | |
| } | |
| public String getVersion() { | |
| return version; | |
| } | |
| public void setVersion(String version) { | |
| this.version = version; | |
| } | |
| /** | |
| * This method is used to help construct a JAXBContext from an existing EntityManagerFactory. | |
| * | |
| * For each package in the EntityManagerFactory, a MetadataSource that is capable of building a JAXBContext | |
| * that creates the same mappings in JAXB is created. These MetadataSources are used to constuct the JAXContext | |
| * that is used for JSON and XML translation | |
| * @param metadataSources | |
| * @param persistenceUnitName | |
| * @param session | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| protected void addDynamicXMLMetadataSources(List<Object> metadataSources, AbstractSession session) { | |
| Set<String> packages = new HashSet<String>(); | |
| Iterator<Class> i = session.getDescriptors().keySet().iterator(); | |
| while (i.hasNext()){ | |
| Class<?> descriptorClass = i.next(); | |
| String packageName = ""; | |
| if (descriptorClass.getName().lastIndexOf('.') > 0){ | |
| packageName = descriptorClass.getName().substring(0, descriptorClass.getName().lastIndexOf('.')); | |
| } | |
| if (!packages.contains(packageName)){ | |
| packages.add(packageName); | |
| } | |
| } | |
| for(String packageName: packages){ | |
| metadataSources.add(new DynamicXMLMetadataSource(session, packageName)); | |
| } | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Persist an entity in JPA and commit | |
| * @param tenantId | |
| * @param entity | |
| */ | |
| public void create(Map<String, String> tenantId, Object entity) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| transaction.beginTransaction(em); | |
| em.persist(entity); | |
| transaction.commitTransaction(em); | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Create a JAXBContext based on the EntityManagerFactory for this PersistenceContext | |
| * @param session | |
| * @return | |
| */ | |
| protected JAXBContext createDynamicJAXBContext(AbstractSession session) throws JAXBException, IOException { | |
| JAXBContext jaxbContext = (JAXBContext) session.getProperty(JAXBContext.class.getName()); | |
| if (jaxbContext != null) { | |
| return jaxbContext; | |
| } | |
| Map<String, Object> properties = createJAXBProperties(session); | |
| ClassLoader cl = session.getDatasourcePlatform().getConversionManager().getLoader(); | |
| jaxbContext = DynamicJAXBContextFactory.createContextFromOXM(cl, properties); | |
| session.setProperty(JAXBContext.class.getName(), jaxbContext); | |
| return jaxbContext; | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Create an EntityManagerFactory using the given PersistenceUnitInfo and properties | |
| * @param info | |
| * @param properties | |
| * @return | |
| */ | |
| protected EntityManagerFactoryImpl createEntityManagerFactory(PersistenceUnitInfo info, Map<String, ?> properties){ | |
| PersistenceProvider provider = new PersistenceProvider(); | |
| EntityManagerFactory emf = provider.createContainerEntityManagerFactory(info, properties); | |
| return (EntityManagerFactoryImpl)emf; | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Create an EntityManager from the EntityManagerFactory wrapped by this persistence context | |
| * @param tenantId | |
| * @return | |
| */ | |
| protected EntityManager createEntityManager(String tenantId) { | |
| return getEmf().createEntityManager(); | |
| } | |
| /** | |
| * Build the set of properties used to create the JAXBContext based on the EntityManagerFactory that | |
| * this PersistenceContext wraps | |
| * @param persistenceUnitName | |
| * @param session | |
| * @return | |
| * @throws IOException | |
| */ | |
| @SuppressWarnings({ "unchecked", "rawtypes" }) | |
| protected Map<String, Object> createJAXBProperties(AbstractSession session) throws IOException { | |
| Map<String, Object> properties = new HashMap<String, Object>(1); | |
| List<Object> metadataLocations = new ArrayList<Object>(); | |
| addDynamicXMLMetadataSources(metadataLocations, session); | |
| String oxmLocation = (String) emf.getProperties().get("eclipselink.jpa-rs.oxm"); | |
| if (oxmLocation != null){ | |
| metadataLocations.add(oxmLocation); | |
| } | |
| Object passedOXMLocations = emf.getProperties().get(JAXBContextProperties.OXM_METADATA_SOURCE); | |
| if (passedOXMLocations != null){ | |
| if (passedOXMLocations instanceof Collection){ | |
| metadataLocations.addAll((Collection)passedOXMLocations); | |
| } else { | |
| metadataLocations.add(passedOXMLocations); | |
| } | |
| } | |
| metadataLocations.add(new LinkMetadataSource()); | |
| metadataLocations.add(new MultiResultQueryListMetadataSource()); | |
| metadataLocations.add(new MultiResultQueryListItemMetadataSource()); | |
| metadataLocations.add(new SingleResultQueryListMetadataSource()); | |
| metadataLocations.add(new SimpleHomogeneousListMetadataSource()); | |
| metadataLocations.add(new JavaLangMetadataSource()); | |
| metadataLocations.add(new JavaMathMetadataSource()); | |
| metadataLocations.add(new JavaUtilMetadataSource()); | |
| properties.put(JAXBContextProperties.OXM_METADATA_SOURCE, metadataLocations); | |
| properties.put("eclipselink.session-event-listener", new PreLoginMappingAdapter((AbstractSession)session)); | |
| return properties; | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Delete the given entity in JPA and commit the changes | |
| */ | |
| public void delete(Map<String, String> tenantId, String type, Object id) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| transaction.beginTransaction(em); | |
| Object entity = em.find(getClass(type), id); | |
| if (entity != null){ | |
| em.remove(entity); | |
| } | |
| transaction.commitTransaction(em); | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Does exist. | |
| * | |
| * @param tenantId the tenant id | |
| * @param entity the entity | |
| * @return true, if successful | |
| */ | |
| public boolean doesExist(Map<String, String> tenantId, Object entity){ | |
| DatabaseSession session = JpaHelper.getDatabaseSession(getEmf()); | |
| return session.doesObjectExist(entity); | |
| } | |
| /** | |
| * Finalize. | |
| */ | |
| @Override | |
| public void finalize(){ | |
| this.emf.close(); | |
| this.emf = null; | |
| this.context = null; | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Find an entity with the given name and id in JPA | |
| * @param entityName | |
| * @param id | |
| * @return | |
| */ | |
| public Object find(String entityName, Object id) { | |
| return find(null, entityName, id); | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Find an entity with the given name and id in JPA | |
| * @param tenantId | |
| * @param entityName | |
| * @param id | |
| * @return | |
| */ | |
| public Object find(Map<String, String> tenantId, String entityName, Object id) { | |
| return find(tenantId, entityName, id, null); | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Find an entity with the given name and id in JPA | |
| * @param tenantId | |
| * @param entityName | |
| * @param id | |
| * @param properties - query hints used on the find | |
| * @return | |
| */ | |
| public Object find(Map<String, String> tenantId, String entityName, Object id, Map<String, Object> properties) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| return em.find(getClass(entityName), id, properties); | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Find attribute. | |
| * | |
| * @param tenantId the tenant id | |
| * @param entityName the entity name | |
| * @param id the id | |
| * @param properties the properties | |
| * @param attribute the attribute | |
| * @return the object | |
| */ | |
| public Object findAttribute(Map<String, String> tenantId, String entityName, Object id, Map<String, Object> properties, String attribute) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| Object object = em.find(getClass(entityName), id, properties); | |
| ClassDescriptor descriptor =getJpaSession().getClassDescriptor(getClass(entityName)); | |
| DatabaseMapping mapping = descriptor.getMappingForAttributeName(attribute); | |
| if (mapping == null){ | |
| return null; | |
| } | |
| return mapping.getRealAttributeValueFromAttribute(mapping.getAttributeValueFromObject(object), object, (AbstractSession) getJpaSession()); | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Update or add attribute. | |
| * | |
| * @param tenantId the tenant id | |
| * @param entityName the entity name | |
| * @param id the id | |
| * @param properties the properties | |
| * @param attribute the attribute | |
| * @param attributeValue the attribute value | |
| * @param partner the partner | |
| * @return the object | |
| */ | |
| public Object updateOrAddAttribute(Map<String, String> tenantId, String entityName, Object id, Map<String, Object> properties, String attribute, Object attributeValue, String partner) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| ClassDescriptor descriptor = getJpaSession().getClassDescriptor(getClass(entityName)); | |
| DatabaseMapping mapping = descriptor.getMappingForAttributeName(attribute); | |
| Object object = null; | |
| if (mapping == null){ | |
| return null; | |
| } else if (mapping.isObjectReferenceMapping() || mapping.isCollectionMapping()){ | |
| DatabaseMapping partnerMapping = null; | |
| if (partner != null){ | |
| ClassDescriptor referenceDescriptor = ((ForeignReferenceMapping)mapping).getReferenceDescriptor(); | |
| partnerMapping = referenceDescriptor.getMappingForAttributeName(partner); | |
| if (partnerMapping == null){ | |
| return null; | |
| } | |
| } | |
| transaction.beginTransaction(em); | |
| try{ | |
| object = em.find(getClass(entityName), id, properties); | |
| if (object == null){ | |
| return null; | |
| } | |
| attributeValue = em.merge(attributeValue); | |
| setMappingValueInObject(object, attributeValue, mapping, partnerMapping); | |
| transaction.commitTransaction(em); | |
| } catch (Exception e){ | |
| JPARSLogger.fine("exception_while_updating_attribute", new Object[]{entityName, getName(), e.toString()}); | |
| transaction.rollbackTransaction(em); | |
| return null; | |
| } | |
| } else { | |
| return null; | |
| } | |
| return object; | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Removes the attribute. | |
| * | |
| * @param tenantId the tenant id | |
| * @param entityName the entity name | |
| * @param id the id | |
| * @param properties the properties | |
| * @param attribute the attribute | |
| * @param attributeValue the attribute value | |
| * @param partner the partner | |
| * @return the object | |
| * | |
| */ | |
| @SuppressWarnings({ "unchecked", "rawtypes" }) | |
| public Object removeAttribute(Map<String, String> tenantId, String entityName, Object id, String attribute, String listItemId, Object entity, String partner) | |
| { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| String fieldName = null; | |
| try { | |
| Class<?> clazz = getClass(entityName); | |
| ClassDescriptor descriptor = getJpaSession().getClassDescriptor(clazz); | |
| DatabaseMapping mapping = descriptor.getMappingForAttributeName(attribute); | |
| if (mapping == null) { | |
| return null; | |
| } else if (mapping.isObjectReferenceMapping() || mapping.isCollectionMapping()) { | |
| DatabaseMapping partnerMapping = null; | |
| Object originalAttributeValue = null; | |
| ClassDescriptor referenceDescriptor = ((ForeignReferenceMapping) mapping).getReferenceDescriptor(); | |
| if (partner != null) { | |
| partnerMapping = referenceDescriptor.getMappingForAttributeName(partner); | |
| if (partnerMapping == null) { | |
| return null; | |
| } | |
| } | |
| Field[] fields = null; | |
| if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { | |
| fields = AccessController.doPrivileged(new PrivilegedGetDeclaredFields(clazz)); | |
| } else { | |
| fields = PrivilegedAccessHelper.getDeclaredFields(clazz); | |
| } | |
| for (int i = 0; i < fields.length; i++) { | |
| Field field = fields[i]; | |
| fieldName = field.getName(); | |
| if (fieldName.equals(attribute)) { | |
| try { | |
| // call clear on this collection | |
| Object attributeValue = getAttribute(entity, attribute); | |
| originalAttributeValue = attributeValue; | |
| if (attributeValue instanceof Collection) { | |
| if (listItemId == null) { | |
| // no collection member specified in request (listItemId=null) remove entire collection | |
| ((Collection) attributeValue).clear(); | |
| } else { | |
| Object realListItemId = IdHelper.buildId(this, referenceDescriptor.getAlias(), listItemId); | |
| Object member = this.find(referenceDescriptor.getAlias(), realListItemId); | |
| ((Collection) attributeValue).remove(member); | |
| } | |
| } else if (attributeValue instanceof Object) { | |
| attributeValue = null; | |
| } else { | |
| attributeValue = 0; | |
| } | |
| break; | |
| } catch (Exception e) { | |
| e.printStackTrace(); | |
| return null; | |
| } | |
| } | |
| } | |
| transaction.beginTransaction(em); | |
| entity = em.merge(entity); | |
| removeMappingValueFromObject(entity, originalAttributeValue, mapping, partnerMapping); | |
| transaction.commitTransaction(em); | |
| return entity; | |
| } | |
| return null; | |
| } catch (Exception e) { | |
| JPARSLogger.fine("exception_while_removing_attribute", new Object[] { fieldName, entityName, getName(), e.toString() }); | |
| transaction.rollbackTransaction(em); | |
| return null; | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| @SuppressWarnings("unchecked") | |
| private Object getAttribute(Object entity, String propertyName) { | |
| try { | |
| BeanInfo info = Introspector.getBeanInfo(entity.getClass(), Object.class); | |
| PropertyDescriptor[] props = info.getPropertyDescriptors(); | |
| for (PropertyDescriptor pd : props) { | |
| String name = pd.getName(); | |
| if (propertyName.equals(name)) { | |
| Method getter = pd.getReadMethod(); | |
| Object value = null; | |
| if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { | |
| value = AccessController.doPrivileged(new PrivilegedMethodInvoker(getter, entity)); | |
| } else { | |
| value = PrivilegedAccessHelper.invokeMethod(getter, entity); | |
| } | |
| return value; | |
| } | |
| } | |
| } catch (Exception ex) { | |
| return null; | |
| } | |
| return null; | |
| } | |
| @SuppressWarnings("rawtypes") | |
| protected void removeMappingValueFromObject(Object object, Object attributeValue, DatabaseMapping mapping, DatabaseMapping partner){ | |
| if (mapping.isObjectReferenceMapping()){ | |
| Object currentValue = mapping.getRealAttributeValueFromObject(object, (AbstractSession) getJpaSession()); | |
| if (currentValue.equals(attributeValue)){ | |
| ((ObjectReferenceMapping)mapping).getIndirectionPolicy().setRealAttributeValueInObject(object, null, true); | |
| if (partner != null){ | |
| removeMappingValueFromObject(attributeValue, object, partner, null); | |
| } | |
| } | |
| } else if (mapping.isCollectionMapping()){ | |
| boolean removed = ((Collection) mapping.getRealAttributeValueFromObject(object, (AbstractSession) getJpaSession())).remove(attributeValue); | |
| if (removed && partner != null){ | |
| removeMappingValueFromObject(attributeValue, object, partner, null); | |
| } | |
| } | |
| } | |
| /** | |
| * Gets the base uri. | |
| * | |
| * @return the base uri | |
| */ | |
| public URI getBaseURI() { | |
| return baseURI; | |
| } | |
| /** | |
| * Look-up the given entity name in the EntityManagerFactory and return the class | |
| * is describes | |
| * @param entityName | |
| * @return | |
| */ | |
| public Class<?> getClass(String entityName) { | |
| ClassDescriptor descriptor = getDescriptor(entityName); | |
| if (descriptor == null){ | |
| return null; | |
| } | |
| return descriptor.getJavaClass(); | |
| } | |
| /** | |
| * Gets the jpa session. | |
| * | |
| * @return the jpa session | |
| */ | |
| public DatabaseSession getJpaSession() { | |
| // Fix for bug 390786 - JPA-RS: ClassCastException retrieving metadata for Composite Persistence Unit | |
| DatabaseSession dbSession = JpaHelper.getDatabaseSession(emf); | |
| return dbSession; | |
| } | |
| /** | |
| * Lookup the descriptor for the given entity name. | |
| * This method will look first in the EntityManagerFactory wrapped by this persistence context | |
| * and return that descriptor. If one does not exist, it search the JAXBContext and return | |
| * a descriptor from there. | |
| * @param entityName | |
| * @return | |
| */ | |
| public ClassDescriptor getDescriptor(String entityName){ | |
| DatabaseSession session = getJpaSession(); | |
| ClassDescriptor descriptor = session.getDescriptorForAlias(entityName); | |
| if (descriptor == null){ | |
| for (Object ajaxBSession:((JAXBContext)getJAXBContext()).getXMLContext().getSessions() ){ | |
| descriptor = ((Session)ajaxBSession).getClassDescriptorForAlias(entityName); | |
| if (descriptor != null){ | |
| break; | |
| } | |
| } | |
| } | |
| return descriptor; | |
| } | |
| /** | |
| * Gets the descriptor for class. | |
| * | |
| * @param clazz the clazz | |
| * @return the descriptor for class | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public ClassDescriptor getDescriptorForClass(Class clazz){ | |
| DatabaseSession session = getJpaSession(); | |
| ClassDescriptor descriptor = session.getDescriptor(clazz); | |
| if (descriptor == null){ | |
| return getJAXBDescriptorForClass(clazz); | |
| } | |
| return descriptor; | |
| } | |
| /** | |
| * Gets the jAXB descriptor for class. | |
| * | |
| * @param clazz the clazz | |
| * @return the jAXB descriptor for class | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public ClassDescriptor getJAXBDescriptorForClass(Class clazz) { | |
| ClassDescriptor descriptor = null; | |
| for (Object ajaxBSession : ((JAXBContext) getJAXBContext()) | |
| .getXMLContext().getSessions()) { | |
| descriptor = ((Session) ajaxBSession).getClassDescriptor(clazz); | |
| if (descriptor != null) { | |
| break; | |
| } | |
| } | |
| return descriptor; | |
| } | |
| /** | |
| * Gets the emf. | |
| * | |
| * @return the emf | |
| */ | |
| public EntityManagerFactory getEmf() { | |
| return emf; | |
| } | |
| /** | |
| * Gets the jAXB context. | |
| * | |
| * @return the jAXB context | |
| */ | |
| public JAXBContext getJAXBContext() { | |
| return context; | |
| } | |
| /** | |
| * Gets the name. | |
| * | |
| * @return the name | |
| */ | |
| public String getName() { | |
| return name; | |
| } | |
| /** | |
| * A part of the facade over the JPA API | |
| * Call jpa merge on the given object and commit | |
| * If the passed object is a list, we will iterate through the | |
| * list and merge each member | |
| * @param tenantId | |
| * @param entity | |
| * @return | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public Object merge(Map<String, String> tenantId, Object entity) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| Object mergedEntity = null; | |
| try { | |
| transaction.beginTransaction(em); | |
| if (entity instanceof List){ | |
| List<Object> mergeList = new ArrayList<Object>(); | |
| for (Object o: (List)entity){ | |
| mergeList.add(em.merge(o)); | |
| } | |
| mergedEntity = mergeList; | |
| } else { | |
| mergedEntity = em.merge(entity); | |
| } | |
| transaction.commitTransaction(em); | |
| return mergedEntity; | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * A convenience method to create a new dynamic entity of the given type | |
| * @param type | |
| * @return | |
| */ | |
| public DynamicEntity newEntity(String type) { | |
| return newEntity(null, type); | |
| } | |
| /** | |
| * A convenience method to create a new dynamic entity of the given type | |
| * @param tenantId | |
| * @param type | |
| * @return | |
| */ | |
| public DynamicEntity newEntity(Map<String, String> tenantId, String type) { | |
| JPADynamicHelper helper = new JPADynamicHelper(getEmf()); | |
| DynamicEntity entity = null; | |
| try{ | |
| entity = helper.newDynamicEntity(type); | |
| } catch (IllegalArgumentException e){ | |
| ClassDescriptor descriptor = getDescriptor(type); | |
| if (descriptor != null){ | |
| DynamicType jaxbType = (DynamicType) descriptor.getProperty(DynamicType.DESCRIPTOR_PROPERTY); | |
| if (jaxbType != null){ | |
| return jaxbType.newDynamicEntity(); | |
| } | |
| } | |
| JPARSLogger.fine("exception_thrown_while_creating_dynamic_entity", new Object[]{type, e.toString()}); | |
| throw e; | |
| } | |
| return entity; | |
| } | |
| /** | |
| * Query execute update. | |
| * | |
| * @param tenantId the tenant id | |
| * @param name the name | |
| * @param parameters the parameters | |
| * @param hints the hints | |
| * @return the int | |
| */ | |
| public int queryExecuteUpdate(Map<String, String> tenantId, String name, Map<?, ?> parameters, Map<String, ?> hints) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| Query query = constructQuery(em, name, parameters, hints); | |
| transaction.beginTransaction(em); | |
| int result = query.executeUpdate(); | |
| transaction.commitTransaction(em); | |
| return result; | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * Query multiple results. | |
| * | |
| * @param tenantId the tenant id | |
| * @param name the name | |
| * @param parameters the parameters | |
| * @param hints the hints | |
| * @return the list | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| public List queryMultipleResults(Map<String, String> tenantId, String name, Map<?, ?> parameters, Map<String, ?> hints) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| try { | |
| Query query = constructQuery(em, name, parameters, hints); | |
| return query.getResultList(); | |
| } finally { | |
| em.close(); | |
| } | |
| } | |
| @SuppressWarnings("rawtypes") | |
| protected Query constructQuery(EntityManager em, String name, Map<?, ?> parameters, Map<String, ?> hints) { | |
| Query query = em.createNamedQuery(name); | |
| DatabaseQuery dbQuery = ((EJBQueryImpl<?>) query).getDatabaseQuery(); | |
| if (parameters != null) { | |
| Iterator i = parameters.keySet().iterator(); | |
| while (i.hasNext()) { | |
| String key = (String) i.next(); | |
| Class parameterClass = null; | |
| int index = dbQuery.getArguments().indexOf(key); | |
| if (index >= 0) { | |
| parameterClass = dbQuery.getArgumentTypes().get(index); | |
| } | |
| Object parameter = parameters.get(key); | |
| if (parameterClass != null) { | |
| parameter = ConversionManager.getDefaultManager().convertObject(parameter, parameterClass); | |
| } | |
| query.setParameter(key, parameter); | |
| } | |
| } | |
| if (hints != null) { | |
| for (String key : hints.keySet()) { | |
| query.setHint(key, hints.get(key)); | |
| } | |
| } | |
| return query; | |
| } | |
| @SuppressWarnings("rawtypes") | |
| public Query buildQuery(Map<String, String> tenantId, String name, Map<?, ?> parameters, Map<String, ?> hints) { | |
| EntityManager em = getEmf().createEntityManager(tenantId); | |
| Query query = em.createNamedQuery(name); | |
| DatabaseQuery dbQuery = ((EJBQueryImpl<?>) query).getDatabaseQuery(); | |
| if (parameters != null) { | |
| Iterator i = parameters.keySet().iterator(); | |
| while (i.hasNext()) { | |
| String key = (String) i.next(); | |
| Class parameterClass = null; | |
| int index = dbQuery.getArguments().indexOf(key); | |
| if (index >= 0) { | |
| parameterClass = dbQuery.getArgumentTypes().get(index); | |
| } | |
| Object parameter = parameters.get(key); | |
| if (parameterClass != null) { | |
| parameter = ConversionManager.getDefaultManager().convertObject(parameter, parameterClass); | |
| } | |
| query.setParameter(key, parameter); | |
| } | |
| } | |
| if (hints != null) { | |
| for (String key : hints.keySet()) { | |
| query.setHint(key, hints.get(key)); | |
| } | |
| } | |
| return query; | |
| } | |
| /** | |
| * Sets the base uri. | |
| * | |
| * @param baseURI the new base uri | |
| */ | |
| public void setBaseURI(URI baseURI) { | |
| this.baseURI = baseURI; | |
| } | |
| @SuppressWarnings({ "rawtypes", "unchecked" }) | |
| protected void setMappingValueInObject(Object object, Object attributeValue, DatabaseMapping mapping, DatabaseMapping partner){ | |
| if (mapping.isObjectReferenceMapping()){ | |
| ((ObjectReferenceMapping)mapping).getIndirectionPolicy().setRealAttributeValueInObject(object, attributeValue, true); | |
| if (partner != null){ | |
| setMappingValueInObject(attributeValue, object, partner, null); | |
| } | |
| } else if (mapping.isCollectionMapping()){ | |
| ((Collection)mapping.getAttributeValueFromObject(object)).add(attributeValue); | |
| if (partner != null){ | |
| setMappingValueInObject(attributeValue, object, partner, null); | |
| } | |
| } | |
| } | |
| /** | |
| * Stop the current application instance | |
| */ | |
| public void stop() { | |
| if (emf != null && emf.isOpen()) { | |
| emf.close(); | |
| } | |
| this.emf = null; | |
| this.context = null; | |
| } | |
| /** | |
| * To string. | |
| * | |
| * @return the string | |
| */ | |
| public String toString() { | |
| return "Application(" + getName() + ")::" + System.identityHashCode(this); | |
| } | |
| /** | |
| * Marshall an entity to either JSON or XML | |
| * Calling this method, will treat relationships as unfetched in the XML/JSON and marshall them as links | |
| * rather than attempting to marshall the data in those relationships | |
| * @param object | |
| * @param mediaType | |
| * @param output | |
| * @throws JAXBException | |
| */ | |
| public Object unmarshalEntity(String type, MediaType acceptedMedia, InputStream in) throws JAXBException { | |
| return unmarshalEntity(getClass(type), acceptedMedia, in); | |
| } | |
| /** | |
| * Marshall an entity to either JSON or XML | |
| * @param object | |
| * @param mediaType | |
| * @param output | |
| * @param sendRelationships if this is set to true, relationships will be sent as links instead of sending | |
| * the actual objects in the relationships | |
| * @throws JAXBException | |
| */ | |
| @SuppressWarnings({ "unchecked", "rawtypes" }) | |
| public Object unmarshalEntity(Class type, MediaType acceptedMedia, InputStream in) throws JAXBException { | |
| Unmarshaller unmarshaller = getJAXBContext().createUnmarshaller(); | |
| unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, Boolean.FALSE); | |
| unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, acceptedMedia.toString()); | |
| unmarshaller.setAdapter(new LinkAdapter(getBaseURI().toString(), this)); | |
| unmarshaller.setEventHandler(new ValidationEventHandler() { | |
| @Override | |
| /* | |
| * ReferenceAdaptor unmarshal throws exception if the object referred by a link | |
| * doesn't exist, and this handler is required to interrupt the unmarshal | |
| * operation under this condition. | |
| * (non-Javadoc) @see javax.xml.bind.ValidationEventHandler#handleEvent(javax.xml.bind.ValidationEvent) | |
| * | |
| */ | |
| public boolean handleEvent(ValidationEvent event) { | |
| if (event.getSeverity() != ValidationEvent.WARNING) { | |
| // ValidationEventLocator eventLocator = event.getLocator(); | |
| // Throwable throwable = event.getLinkedException(); | |
| // nothing is really useful to check for us in eventLocator | |
| // and linked exception, just return false; | |
| return false; | |
| } | |
| return true; | |
| } | |
| }); | |
| for (XmlAdapter adapter:getAdapters()) { | |
| unmarshaller.setAdapter(adapter); | |
| } | |
| if (acceptedMedia == MediaType.APPLICATION_JSON_TYPE) { | |
| // Part of the fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=394059 | |
| // This issue happens when request has objects derived from an abstract class. | |
| // JSON_INCLUDE_ROOT is set to false for JPA-RS. This means JSON requests won't have root tag. | |
| // The unmarshal method needs to be called with type, so that moxy can unmarshal the message based on type. | |
| // For xml, root tag is always set, unmarshaller must use root of the message for unmarshalling and type should | |
| // not be passed to unmarshal for xml type requests. | |
| JAXBElement<?> element = unmarshaller.unmarshal(new StreamSource(in), type); | |
| if (element.getValue() instanceof List<?>) { | |
| for (Object object : (List<?>) element.getValue()) { | |
| wrap(object); | |
| } | |
| return element.getValue(); | |
| } else { | |
| wrap(element.getValue()); | |
| } | |
| return element.getValue(); | |
| } | |
| Object domainObject = unmarshaller.unmarshal(new StreamSource(in)); | |
| if (domainObject instanceof List<?>) { | |
| for (Object object : (List<?>) domainObject) { | |
| wrap(object); | |
| } | |
| return domainObject; | |
| } else { | |
| wrap(domainObject); | |
| } | |
| return domainObject; | |
| } | |
| /** | |
| * Make adjustments to an unmarshalled entity based on what is found in the weaved fields | |
| * | |
| * @param entity | |
| * @return | |
| */ | |
| protected Object wrap(Object entity) { | |
| if ((entity != null) && (PersistenceWeavedRest.class.isAssignableFrom(entity.getClass()))) { | |
| if (!doesExist(null, entity)) { | |
| return entity; | |
| } | |
| ClassDescriptor descriptor = getJAXBDescriptorForClass(entity.getClass()); | |
| if (entity instanceof FetchGroupTracker) { | |
| FetchGroup fetchGroup = new FetchGroup(); | |
| for (DatabaseMapping mapping : descriptor.getMappings()) { | |
| if (!(mapping instanceof XMLInverseReferenceMapping)) { | |
| fetchGroup.addAttribute(mapping.getAttributeName()); | |
| } | |
| } | |
| (new FetchGroupManager()).setObjectFetchGroup(entity, fetchGroup, null); | |
| ((FetchGroupTracker) entity)._persistence_setSession(JpaHelper.getDatabaseSession(getEmf())); | |
| } else if (descriptor.hasRelationships()) { | |
| for (DatabaseMapping mapping : descriptor.getMappings()) { | |
| if (mapping instanceof XMLInverseReferenceMapping) { | |
| // we require Fetch groups to handle relationships | |
| throw new JPARSConfigurationException(LoggingLocalization.buildMessage("weaving_required_for_relationships", new Object[] {})); | |
| } | |
| } | |
| } | |
| } | |
| return entity; | |
| } | |
| /** | |
| * Marshall an entity to either JSON or XML | |
| * Calling this method, will treat relationships as unfetched in the XML/JSON and marshall them as links | |
| * rather than attempting to marshall the data in those relationships | |
| * @param object | |
| * @param mediaType | |
| * @param output | |
| * @throws JAXBException | |
| */ | |
| public void marshallEntity(Object object, MediaType mediaType, OutputStream output) throws JAXBException { | |
| marshallEntity(object, mediaType, output, true); | |
| } | |
| /** | |
| * Marshall an entity to either JSON or XML | |
| * @param object | |
| * @param mediaType | |
| * @param output | |
| * @param sendRelationships if this is set to true, relationships will be sent as links instead of sending | |
| * the actual objects in the relationships | |
| * @throws JAXBException | |
| */ | |
| @SuppressWarnings({ "rawtypes", "unchecked" }) | |
| public void marshallEntity(Object object, MediaType mediaType, OutputStream output, boolean sendRelationships) throws JAXBException { | |
| if (sendRelationships) { | |
| preMarshallEntity(object); | |
| } | |
| Marshaller marshaller = getJAXBContext().createMarshaller(); | |
| marshaller.setProperty(MarshallerProperties.MEDIA_TYPE, mediaType.toString()); | |
| marshaller.setProperty(MarshallerProperties.JSON_INCLUDE_ROOT, false); | |
| marshaller.setProperty(MarshallerProperties.JSON_REDUCE_ANY_ARRAYS, true); | |
| marshaller.setAdapter(new LinkAdapter(getBaseURI().toString(), this)); | |
| marshaller.setAdapter(new RelationshipLinkAdapter(getBaseURI().toString(), this)); | |
| for (XmlAdapter adapter:getAdapters()) { | |
| marshaller.setAdapter(adapter); | |
| } | |
| if (mediaType == MediaType.APPLICATION_XML_TYPE && object instanceof List) { | |
| marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true); | |
| XMLOutputFactory outputFactory = XMLOutputFactory.newFactory(); | |
| XMLStreamWriter writer = null; | |
| try { | |
| writer = outputFactory.createXMLStreamWriter(output); | |
| writer.writeStartDocument(); | |
| writer.writeStartElement(ConfigDefaults.JPARS_LIST_GROUPING_NAME); | |
| for (Object o : (List<Object>) object) { | |
| marshaller.marshal(o, writer); | |
| } | |
| writer.writeEndDocument(); | |
| writer.flush(); | |
| postMarshallEntity(object); | |
| } catch (Exception e) { | |
| e.printStackTrace(); | |
| throw new JPARSException(e.toString()); | |
| } | |
| } else { | |
| marshaller.marshal(object, output); | |
| postMarshallEntity(object); | |
| } | |
| } | |
| /** | |
| * Process an entity and add any additional data that needs to be added prior to marshalling | |
| * This method will both single entities and lists of entities | |
| * @param object | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| protected void preMarshallEntity(Object object){ | |
| if (object instanceof List){ | |
| Iterator i = ((List)object).iterator(); | |
| while (i.hasNext()){ | |
| preMarshallIndividualEntity(i.next()); | |
| } | |
| } else { | |
| preMarshallIndividualEntity(object); | |
| } | |
| } | |
| /** | |
| * Add any data required prior to marshalling an entity to XML or JSON | |
| * In general, this will only affect fields that have been weaved into the object | |
| * @param entity | |
| */ | |
| @SuppressWarnings("rawtypes") | |
| protected void preMarshallIndividualEntity(Object entity) { | |
| if (entity instanceof MultiResultQueryListItem) { | |
| MultiResultQueryListItem item = (MultiResultQueryListItem) entity; | |
| List<JAXBElement> fields = item.getFields(); | |
| for (int i = 0; i < fields.size(); i++) { | |
| // one or more fields in the MultiResultQueryListItem might be a domain object, | |
| // so, we need to set the relationshipInfo for those domain objects. | |
| setRelationshipInfo(fields.get(i).getValue()); | |
| } | |
| } else if (entity instanceof SingleResultQueryList) { | |
| SingleResultQueryList item = (SingleResultQueryList) entity; | |
| List<JAXBElement> fields = item.getFields(); | |
| for (int i = 0; i < fields.size(); i++) { | |
| // one or more fields in the SingleResultQueryList might be a domain object, | |
| // so, we need to set the relationshipInfo for those domain objects. | |
| setRelationshipInfo(fields.get(i).getValue()); | |
| } | |
| } else if (entity instanceof MultiResultQueryList) { | |
| MultiResultQueryList list = (MultiResultQueryList) entity; | |
| List<MultiResultQueryListItem> items = list.getItems(); | |
| for (int i = 0; i < items.size(); i++) { | |
| MultiResultQueryListItem item = items.get(i); | |
| List<JAXBElement> fields = item.getFields(); | |
| for (int index = 0; index < fields.size(); index++) { | |
| // one or more fields in the MultiResultQueryList might be a domain object, | |
| // so, we need to set the relationshipInfo for those domain objects. | |
| setRelationshipInfo(fields.get(index).getValue()); | |
| } | |
| } | |
| } else { | |
| setRelationshipInfo(entity); | |
| } | |
| } | |
| private void setRelationshipInfo(Object entity) { | |
| if ((entity != null) && (entity instanceof PersistenceWeavedRest)) { | |
| ClassDescriptor descriptor = getJpaSession().getClassDescriptor(entity.getClass()); | |
| if (descriptor != null) { | |
| ((PersistenceWeavedRest) entity)._persistence_setRelationships(new ArrayList<RelationshipInfo>()); | |
| for (DatabaseMapping mapping : descriptor.getMappings()) { | |
| if (mapping.isForeignReferenceMapping()) { | |
| ForeignReferenceMapping frMapping = (ForeignReferenceMapping) mapping; | |
| RelationshipInfo info = new RelationshipInfo(); | |
| info.setAttributeName(frMapping.getAttributeName()); | |
| info.setOwningEntity(entity); | |
| info.setOwningEntityAlias(descriptor.getAlias()); | |
| info.setPersistencePrimaryKey(descriptor.getObjectBuilder().extractPrimaryKeyFromObject(entity, (AbstractSession) getJpaSession())); | |
| ((PersistenceWeavedRest) entity)._persistence_getRelationships().add(info); | |
| } else if (mapping.isEISMapping()) { | |
| if (mapping instanceof EISCompositeCollectionMapping) { | |
| EISCompositeCollectionMapping eisMapping = (EISCompositeCollectionMapping)mapping; | |
| RelationshipInfo info = new RelationshipInfo(); | |
| info.setAttributeName(eisMapping.getAttributeName()); | |
| info.setOwningEntity(entity); | |
| info.setOwningEntityAlias(descriptor.getAlias()); | |
| info.setPersistencePrimaryKey(descriptor.getObjectBuilder().extractPrimaryKeyFromObject(entity, (AbstractSession) getJpaSession())); | |
| ((PersistenceWeavedRest) entity)._persistence_getRelationships().add(info); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| @SuppressWarnings("rawtypes") | |
| protected void postMarshallEntity(Object object){ | |
| if (object instanceof List){ | |
| Iterator i = ((List)object).iterator(); | |
| while (i.hasNext()){ | |
| Object entity = i.next(); | |
| if (entity instanceof PersistenceWeavedRest){ | |
| ((PersistenceWeavedRest)entity)._persistence_setRelationships(new ArrayList<RelationshipInfo>()); | |
| } | |
| } | |
| } else { | |
| if (object instanceof PersistenceWeavedRest){ | |
| ((PersistenceWeavedRest)object)._persistence_setRelationships(new ArrayList<RelationshipInfo>()); | |
| } | |
| } | |
| } | |
| @SuppressWarnings({ "rawtypes", "unchecked" }) | |
| protected List<XmlAdapter> getAdapters() throws JPARSException { | |
| if (adapters != null) { | |
| return adapters; | |
| } | |
| adapters = new ArrayList<XmlAdapter>(); | |
| try { | |
| for (ClassDescriptor desc : this.getJpaSession().getDescriptors().values()) { | |
| // avoid embeddables | |
| if (!desc.isAggregateCollectionDescriptor() && !desc.isAggregateDescriptor()) { | |
| Class clz = desc.getJavaClass(); | |
| String referenceAdapterName = RestAdapterClassWriter.constructClassNameForReferenceAdapter(clz.getName()); | |
| ClassLoader cl = getJpaSession().getDatasourcePlatform().getConversionManager().getLoader(); | |
| Class referenceAdaptorClass = Class.forName(referenceAdapterName, true, cl); | |
| Class[] argTypes = { String.class, PersistenceContext.class}; | |
| Constructor referenceAdaptorConstructor = referenceAdaptorClass.getDeclaredConstructor(argTypes); | |
| Object[] args = new Object[] { getBaseURI().toString(), this }; | |
| adapters.add((XmlAdapter) referenceAdaptorConstructor.newInstance(args)); | |
| } | |
| } | |
| } catch(Exception ex) { | |
| ex.printStackTrace(); | |
| throw new JPARSException(ex.getMessage()); | |
| } | |
| return adapters; | |
| } | |
| private boolean getWeavingProperty() { | |
| // Initialize the properties with their defaults first | |
| boolean restWeavingEnabled = true; | |
| boolean fetchGroupWeavingEnabled = true; | |
| boolean weavingEnabled = true; | |
| Map<String, Object> properties = this.emf.getProperties(); | |
| for (Map.Entry<String, Object> entry : properties.entrySet()) { | |
| String key = entry.getKey(); | |
| Object value = entry.getValue(); | |
| if (key.equals(PersistenceUnitProperties.WEAVING)) { | |
| if (!("true".equalsIgnoreCase((String) value)) && !("static".equalsIgnoreCase((String) value))) { | |
| weavingEnabled = false; | |
| } | |
| } | |
| if (key.equals(PersistenceUnitProperties.WEAVING_REST)) { | |
| if (!("true".equalsIgnoreCase((String) value))) { | |
| restWeavingEnabled = false; | |
| } | |
| } | |
| if (key.equals(PersistenceUnitProperties.WEAVING_FETCHGROUPS)) { | |
| if (!("true".equalsIgnoreCase((String) value))) { | |
| fetchGroupWeavingEnabled = false; | |
| } | |
| } | |
| } | |
| return (weavingEnabled && restWeavingEnabled && fetchGroupWeavingEnabled); | |
| } | |
| } |