Author: bleny Date: 2013-10-11 15:46:24 +0200 (Fri, 11 Oct 2013) New Revision: 2834 Url: http://nuiton.org/projects/topia/repository/revisions/2834 Log: introduce generation of PersistenceContext and ApplicationContext Added: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/ApplicationContextTransformer.java Modified: trunk/pom.xml trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaApplicationContext.java trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaPersistenceContext.java trunk/topia-persistence/src/main/java/org/nuiton/topia/TopiaPersistenceContext.java trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java Modified: trunk/pom.xml =================================================================== --- trunk/pom.xml 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/pom.xml 2013-10-11 13:46:24 UTC (rev 2834) @@ -204,7 +204,6 @@ <module>topia-persistence</module> <module>topia-service-replication</module> <module>topia-service-migration</module> - <module>topia-service-security</module> </modules> <scm> Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaApplicationContext.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaApplicationContext.java 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaApplicationContext.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -24,12 +24,11 @@ * #L% */ -import java.beans.PropertyChangeListener; -import java.util.List; -import java.util.Map; -import java.util.Properties; - +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; import org.apache.commons.lang3.StringUtils; +import org.hibernate.SessionFactory; import org.nuiton.topia.event.TopiaEntitiesVetoable; import org.nuiton.topia.event.TopiaEntityListener; import org.nuiton.topia.event.TopiaEntityVetoable; @@ -41,7 +40,10 @@ import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.topia.persistence.TopiaIdFactory; -import com.google.common.base.Preconditions; +import java.beans.PropertyChangeListener; +import java.util.List; +import java.util.Map; +import java.util.Properties; /** * The application context is the main class in ToPIA usage. This class is a kind of equivalent of the RootTopiaContext. @@ -55,19 +57,59 @@ protected TopiaIdFactory topiaIdFactory; + protected ImmutableMap<String, String> configuration; + + protected TopiaReplicationSupport topiaReplicationSupport; + + protected TopiaListenableSupport topiaListenableSupport; + + protected TopiaServiceSupport topiaServiceSupport; + public abstract K newPersistenceContext(); -// { -// // TODO AThimel 27/09/13 Instantiate project specific TopiaPersistenceContext -// return null; -// } public abstract Properties getConfig(); + public AbstractTopiaApplicationContext(Properties properties) { + // TODO arnaud 11/10/13 vérifier le comportement + this((Map) ImmutableMap.copyOf(properties)); + } + + protected abstract Class<? extends TopiaEntity>[] getImplementationClasses(); + + protected String getImplementationClassesAsString() { + StringBuilder buffer = new StringBuilder(); + for (Class<? extends TopiaEntity> aClass : getImplementationClasses()) { + buffer.append(',').append(aClass.getName()); + } + return buffer.substring(1); + } + + public AbstractTopiaApplicationContext(Map<String, String> configuration) { + Map<String, String> configurationCopy = Maps.newHashMap(); + configurationCopy.putAll(configuration); + if ( ! configuration.containsKey(TopiaContextFactory.CONFIG_PERSISTENCE_CLASSES)) { + configurationCopy.put(TopiaContextFactory.CONFIG_PERSISTENCE_CLASSES, getImplementationClassesAsString()); + } + this.configuration = ImmutableMap.copyOf(configurationCopy); + } + + protected SessionFactory getSessionFactory() { + throw new UnsupportedOperationException(); + } + + protected TopiaListenableSupport getTopiaListenableSupport() { + // TODO brendan 11/10/13 instancier + return topiaListenableSupport; + } + + protected ImmutableMap<String, String> getConfiguration() { + return configuration; + } + protected TopiaIdFactory getTopiaIdFactory() { if (topiaIdFactory == null) { - String topiaIdFactoryClassName = - getConfig().getProperty(TopiaContextFactory.CONFIG_PERSISTENCE_TOPIA_ID_FACTORY_CLASS_NAME, ""); + getConfiguration().get(TopiaContextFactory.CONFIG_PERSISTENCE_TOPIA_ID_FACTORY_CLASS_NAME); if (StringUtils.isEmpty(topiaIdFactoryClassName)) { topiaIdFactory = new DefaultTopiaIdFactory(); } else { @@ -91,103 +133,123 @@ return topiaIdFactory; } + @Override + public void replicate(TopiaContext destinationContext, Object... entityAndCondition) throws IllegalArgumentException { + topiaReplicationSupport.replicate(destinationContext, entityAndCondition); + } @Override + public <T extends TopiaEntity> void replicateEntity(TopiaContext destinationContext, T entity) throws IllegalArgumentException { + topiaReplicationSupport.replicateEntity(destinationContext, entity); + } + + @Override + public <T extends TopiaEntity> void replicateEntities(TopiaContext destinationContext, List<T> entities) throws IllegalArgumentException { + topiaReplicationSupport.replicateEntities(destinationContext, entities); + } + + @Override public void addTopiaEntityListener(TopiaEntityListener listener) { + topiaListenableSupport.addTopiaEntityListener(listener); } @Override public void addTopiaEntityListener(Class<? extends TopiaEntity> entityClass, TopiaEntityListener listener) { + topiaListenableSupport.addTopiaEntityListener(entityClass, listener); } @Override public void removeTopiaEntityListener(TopiaEntityListener listener) { + topiaListenableSupport.removeTopiaEntityListener(listener); } @Override public void removeTopiaEntityListener(Class<? extends TopiaEntity> entityClass, TopiaEntityListener listener) { + topiaListenableSupport.removeTopiaEntityListener(entityClass, listener); } @Override public void addTopiaEntityVetoable(TopiaEntityVetoable vetoable) { + topiaListenableSupport.addTopiaEntityVetoable(vetoable); } @Override public void addTopiaEntityVetoable(Class<? extends TopiaEntity> entityClass, TopiaEntityVetoable vetoable) { + topiaListenableSupport.addTopiaEntityVetoable(entityClass, vetoable); } @Override public void removeTopiaEntityVetoable(TopiaEntityVetoable vetoable) { + topiaListenableSupport.removeTopiaEntityVetoable(vetoable); } @Override public void removeTopiaEntityVetoable(Class<? extends TopiaEntity> entityClass, TopiaEntityVetoable vetoable) { + topiaListenableSupport.removeTopiaEntityVetoable(entityClass, vetoable); } @Override public void addTopiaEntitiesVetoable(TopiaEntitiesVetoable vetoable) { + topiaListenableSupport.addTopiaEntitiesVetoable(vetoable); } @Override public void removeTopiaEntitiesVetoable(TopiaEntitiesVetoable vetoable) { + topiaListenableSupport.removeTopiaEntitiesVetoable(vetoable); } @Override public void addTopiaTransactionListener(TopiaTransactionListener listener) { + topiaListenableSupport.addTopiaTransactionListener(listener); } @Override public void removeTopiaTransactionListener(TopiaTransactionListener listener) { + topiaListenableSupport.removeTopiaTransactionListener(listener); } @Override public void addTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) { + topiaListenableSupport.addTopiaTransactionVetoable(vetoable); } @Override public void removeTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) { + topiaListenableSupport.removeTopiaTransactionVetoable(vetoable); } @Override public void addPropertyChangeListener(PropertyChangeListener listener) { + topiaListenableSupport.addPropertyChangeListener(listener); } @Override public void removePropertyChangeListener(PropertyChangeListener listener) { + topiaListenableSupport.removePropertyChangeListener(listener); } @Override public void addTopiaSchemaListener(TopiaSchemaListener listener) { + topiaListenableSupport.addTopiaSchemaListener(listener); } @Override public void removeTopiaSchemaListener(TopiaSchemaListener listener) { + topiaListenableSupport.removeTopiaSchemaListener(listener); } @Override - public void replicate(TopiaContext destinationContext, Object... entityAndCondition) throws IllegalArgumentException { - } - - @Override - public <T extends TopiaEntity> void replicateEntity(TopiaContext destinationContext, T entity) throws IllegalArgumentException { - } - - @Override - public <T extends TopiaEntity> void replicateEntities(TopiaContext destinationContext, List<T> entities) throws IllegalArgumentException { - } - - @Override public <E extends TopiaService> boolean serviceEnabled(Class<E> interfaceService) { - return false; + return topiaServiceSupport.serviceEnabled(interfaceService); } @Override public <E extends TopiaService> E getService(Class<E> interfaceService) throws TopiaNotFoundException { - return null; + return topiaServiceSupport.getService(interfaceService); } @Override public Map<String, TopiaService> getServices() { - return null; + return topiaServiceSupport.getServices(); } } Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaPersistenceContext.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaPersistenceContext.java 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/AbstractTopiaPersistenceContext.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -308,4 +308,23 @@ } } + @Override + public void commitTransaction() { + //To change body of implemented methods use File | Settings | File Templates. + } + + @Override + public void rollbackTransaction() { + //To change body of implemented methods use File | Settings | File Templates. + } + + @Override + public void closeContext() { + //To change body of implemented methods use File | Settings | File Templates. + } + + @Override + public boolean isClosed() { + return false; //To change body of implemented methods use File | Settings | File Templates. + } } Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/TopiaPersistenceContext.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/TopiaPersistenceContext.java 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/TopiaPersistenceContext.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -41,7 +41,7 @@ * @author Arnaud Thimel <thimel@codelutin.com> * @since 3.0 */ -public interface TopiaPersistenceContext extends TopiaDAOSupplier { +public interface TopiaPersistenceContext extends TopiaDAOSupplier, TopiaTransaction { /** * Retrieve {@link org.nuiton.topia.persistence.TopiaEntity} using its unique {@code topiaId}. Copied: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/ApplicationContextTransformer.java (from rev 2809, trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java) =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/ApplicationContextTransformer.java (rev 0) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/ApplicationContextTransformer.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -0,0 +1,310 @@ +package org.nuiton.topia.generator; + +/* + * #%L + * ToPIA :: Persistence + * * + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2004 - 2010 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +/*{generator option: parentheses = false}*/ + +/*{generator option: writeString = +}*/ + +import org.nuiton.eugene.java.ObjectModelTransformerToJava; +import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelJavaModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.topia.AbstractTopiaApplicationContext; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.util.EntityOperator; +import org.nuiton.topia.persistence.util.EntityOperatorStore; + +import java.lang.reflect.Array; +import java.util.List; +import java.util.Properties; + +/** + * To generate PersistenceHelper + * + * @author tchemit <chemit@codelutin.com> + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.topia.generator.ApplicationContextTransformer" + * @since 3.0 + */ +public class ApplicationContextTransformer extends ObjectModelTransformerToJava { + + @Override + public void transformFromModel(ObjectModel input) { + + String packageName = TopiaGeneratorUtil.getApplicationContextPackage(this, model); + + String applicationContextAbstractName = TopiaGeneratorUtil.getApplicationContextAbstractName(model); + + String applicationContextConcreteName = TopiaGeneratorUtil.getApplicationContextConcreteName(model); + + boolean generateAbstract = !isInClassPath(packageName, applicationContextAbstractName); + + boolean generateConcrete = !isInClassPath(packageName, applicationContextConcreteName); + + + if (generateAbstract) { + + generateAbstract(packageName, + applicationContextAbstractName); + } + + if (generateConcrete) { + + generateImpl(packageName, + applicationContextAbstractName, + applicationContextConcreteName); + } + + } + + protected void generateAbstract(String packageName, + String className) { + + // try to find a super class by tag-value +// String superClass = TopiaGeneratorUtil.getPersistenceContextSuperClassTagValue(model); + String superClass = null; + + if (superClass == null) { + + // no super-class, use default one + superClass = AbstractTopiaApplicationContext.class.getName(); + } + + ObjectModelClass output = createAbstractClass(className, packageName); + + String persistenceContextConcreteName = TopiaGeneratorUtil.getPersistenceContextConcreteName(model); + setSuperClass(output, superClass + "<" + persistenceContextConcreteName + ">"); + + // detect if there is a contract to set on abstract + String contractName = TopiaGeneratorUtil.getPersistenceContextInterfaceName(model); + +// addInterface(output, TopiaPersistenceContext.class); + + boolean addPersistenceContextContract = isInClassPath(packageName, contractName); + + if (addPersistenceContextContract) { + addInterface(output, packageName + "." + contractName); + } + + String modelName = model.getName(); + String daoHelperClazzName = modelName + "DAOHelper"; + + String entityEnumName = modelName + "EntityEnum"; + + List<ObjectModelClass> entityClasses = + TopiaGeneratorUtil.getEntityClasses(model, true); + + boolean generateOperator = + TopiaGeneratorUtil.shouldGenerateOperatorForDAOHelper(model); + + boolean generateStandaloneEnum = + TopiaGeneratorUtil.shouldGenerateStandaloneEnumForDAOHelper(model); + + if (!generateStandaloneEnum) { + + addImport(output, packageName + "." + daoHelperClazzName + "." + entityEnumName); + + } + +// addImport(output, TopiaDAO.class); + addImport(output, TopiaEntity.class); +// addImport(output, TopiaContext.class); + addImport(output, Array.class); + addImport(output, Array.class); + + if (generateOperator) { + addImport(output, EntityOperator.class); + addImport(output, EntityOperatorStore.class); + } + + // add context field + addAttribute(output, "context", TopiaContext.class, null, + ObjectModelJavaModifier.PROTECTED); + + // add public constructor + ObjectModelOperation constructor = addConstructor( + output, + ObjectModelJavaModifier.PUBLIC); + addParameter(constructor, Properties.class, "properties"); + setOperationBody(constructor, "" +/*{ + super(properties); + }*/ + ); + + constructor = addConstructor( + output, + ObjectModelJavaModifier.PUBLIC); + addParameter(constructor, "java.util.Map<String, String>", "configuration"); + setOperationBody(constructor, "" +/*{ + super(configuration); + }*/ + ); + + ObjectModelOperation op; + + // getModelVersion method + op = addOperation(output, "newPersistenceContext", persistenceContextConcreteName, ObjectModelJavaModifier.PUBLIC); + addAnnotation(output, op, Override.class); + setOperationBody(op, "" +/*{ + return new <%=persistenceContextConcreteName%>(); + }*/ + ); + + // getModelVersion method + String modelVersion = model.getVersion(); + op = addOperation(output, "getModelVersion", "String", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + return "<%=modelVersion%>"; + }*/ + ); + + // getModelName method + op = addOperation(output, "getModelName", "String", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + return "<%=modelName%>"; + }*/ + ); + + // getContractClass method + op = addOperation(output, "getContractClass", "<T extends TopiaEntity> Class<T>", ObjectModelJavaModifier.PUBLIC); + addParameter(op, "Class<T>", "klass"); + setOperationBody(op, "" +/*{ + <%=entityEnumName%> constant = <%=entityEnumName%>.valueOf(klass); + return (Class<T>) constant.getContract(); + }*/ + ); + + // getImplementationClass method + op = addOperation(output, "getImplementationClass", "<T extends TopiaEntity> Class<T>", ObjectModelJavaModifier.PUBLIC); + addParameter(op, "Class<T>", "klass"); + setOperationBody(op, "" +/*{ + <%=entityEnumName%> constant = <%=entityEnumName%>.valueOf(klass); + return (Class<T>) constant.getImplementation(); + }*/ + ); + + // getContractClasses method + op = addOperation(output, "getContractClasses", "Class<? extends TopiaEntity>[]", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + <%=entityEnumName%>[] values = <%=entityEnumName%>.values(); + Class<? extends TopiaEntity>[] result = (Class<? extends TopiaEntity>[]) Array.newInstance(Class.class, values.length); + for (int i = 0; i < values.length; i++) { + result[i] = values[i].getContract(); + } + return result; + }*/ + ); + + // getImplementationClasses method + op = addOperation(output, "getImplementationClasses", "Class<? extends TopiaEntity>[]", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + <%=entityEnumName%>[] values = <%=entityEnumName%>.values(); + Class<? extends TopiaEntity>[] result = (Class<? extends TopiaEntity>[]) Array.newInstance(Class.class, values.length); + for (int i = 0; i < values.length; i++) { + result[i] = values[i].getImplementation(); + } + return result; + }*/ + ); + + // getImplementationClassesAsString method + op = addOperation(output, "getImplementationClassesAsString", "String", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + StringBuilder buffer = new StringBuilder(); + for (Class<? extends TopiaEntity> aClass : getImplementationClasses()) { + buffer.append(',').append(aClass.getName()); + } + return buffer.substring(1); + }*/ + ); + + // getContracts method + op = addOperation(output, "getContracts", entityEnumName + "[]", ObjectModelJavaModifier.PUBLIC); + setOperationBody(op, "" +/*{ + return <%=entityEnumName%>.values(); + }*/ + ); + + if (generateOperator) { + // getOperator method + op = addOperation(output, "getOperator", "<T extends TopiaEntity> EntityOperator<T>", ObjectModelJavaModifier.PUBLIC); + addParameter(op, "Class<T>", "klass"); + setOperationBody(op, "" +/*{ + <%=entityEnumName%> constant = <%=entityEnumName%>.valueOf(klass); + return EntityOperatorStore.getOperator(constant); + }*/ + ); + } + + } + + protected ObjectModelClass generateImpl(String packageName, + String applicationContextAbstractName, + String applicationContextConcreteName) { + + ObjectModelClass output = createClass(applicationContextConcreteName, packageName); + + setSuperClass(output, applicationContextAbstractName); + + // add public constructor + ObjectModelOperation constructor = addConstructor( + output, + ObjectModelJavaModifier.PUBLIC); + addParameter(constructor, Properties.class, "properties"); + setOperationBody(constructor, "" +/*{ + super(properties); + }*/ + ); + + constructor = addConstructor( + output, + ObjectModelJavaModifier.PUBLIC); + addParameter(constructor, "java.util.Map<String, String>", "configuration"); + setOperationBody(constructor, "" +/*{ + super(configuration); + }*/ + ); + + return output; + } + +} Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -134,6 +134,14 @@ return packageName; } + public static String getApplicationContextPackage(ObjectModelTransformerToJava transformer, + ObjectModel model) { + + String result = transformer.getDefaultPackageName(); + + return result; + } + public static String getPersistenceContextPackage(ObjectModelTransformerToJava transformer, ObjectModel model) { @@ -151,12 +159,24 @@ return result; } + public static String getApplicationContextInterfaceName(ObjectModel model) { + return model.getName() + "ApplicationContext"; + } + + public static String getApplicationContextAbstractName(ObjectModel model) { + return "Abstract" + model.getName() + "TopiaApplicationContext"; + } + + public static String getApplicationContextConcreteName(ObjectModel model) { + return model.getName() + "TopiaApplicationContext"; + } + public static String getPersistenceContextAbstractName(ObjectModel model) { - return "AbstractTopia" + model.getName() + "PersistenceContext"; + return "Abstract" + model.getName() + "TopiaPersistenceContext"; } public static String getPersistenceContextConcreteName(ObjectModel model) { - return "Topia" + model.getName() + "PersistenceContext"; + return model.getName() + "TopiaPersistenceContext"; } public static String getPersistenceContextInterfaceName(ObjectModel model) { Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java 2013-10-10 16:14:22 UTC (rev 2833) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java 2013-10-11 13:46:24 UTC (rev 2834) @@ -61,6 +61,7 @@ // ); setTemplateTypes( + ApplicationContextTransformer.class, PersistenceContextTransformer.class, EntityTransformer.class, EntityDAOTransformer.class,