Author: tchemit Date: 2013-08-15 12:50:33 +0200 (Thu, 15 Aug 2013) New Revision: 2800 Url: http://nuiton.org/projects/topia/repository/revisions/2800 Log: refs #1468: Make DAOHelper instantiable and not static anymore (adding a new template) Added: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java Modified: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java Added: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java =================================================================== --- trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java (rev 0) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java 2013-08-15 10:50:33 UTC (rev 2800) @@ -0,0 +1,295 @@ +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.TopiaContext; +import org.nuiton.topia.TopiaException; +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; + +/** + * To generate PersistenceHelper + * + * @author tchemit <chemit@codelutin.com> + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.topia.generator.PersistenceContextTransformer" + * @since 3.0 + */ +public class PersistenceContextTransformer extends ObjectModelTransformerToJava { + + @Override + public void transformFromModel(ObjectModel input) { + + String packageName = TopiaGeneratorUtil.getPersistenceContextPackage(this, model); + + String entityAbstractName = TopiaGeneratorUtil.getPersistenceContextAbstractName(model); + + String entityConcreteName = TopiaGeneratorUtil.getPersistenceContextConcreteName(model); + + boolean generateAbstract = !isInClassPath(packageName, entityAbstractName); + + boolean generateConcrete = !isInClassPath(packageName, entityConcreteName); + + + if (generateAbstract) { + + generateAbstract(packageName, + entityAbstractName); + } + + if (generateConcrete) { + + generateImpl(packageName, + entityAbstractName, + entityConcreteName); + } + + } + + protected void generateAbstract(String packageName, + String className) { + +// // try to find a super class by tag-value +// String superClass = TopiaGeneratorUtil.getPersistenceContextSuperClassTagValue( +// model); +// +// if (superClass == null) { +// +// // no super-class, use default one +// superClass = AbstractTopiaPersistenceContext.class.getName(); +// } + + ObjectModelClass output = createAbstractClass(className, packageName); + +// setSuperClass(output, superClass); + + // 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, TopiaContext.class, "context"); + setOperationBody(constructor, "" +/*{ + this.context = context; + }*/ + ); + + ObjectModelOperation op; + + // getModelVersion method + String modelVersion = model.getVersion(); + op = addOperation(output, "getModelVersion", "String", ObjectModelJavaModifier.PUBLIC, ObjectModelJavaModifier.STATIC); + setOperationBody(op, "" +/*{ + return "<%=modelVersion%>"; + }*/ + ); + + // getModelName method + op = addOperation(output, "getModelName", "String", ObjectModelJavaModifier.PUBLIC, ObjectModelJavaModifier.STATIC); + setOperationBody(op, "" +/*{ + return "<%=modelName%>"; + }*/ + ); + + for (ObjectModelClass clazz : entityClasses) { + String clazzName = clazz.getName(); + String daoClazzName = clazzName + "DAO"; + + // specialized getXXXDao method + op = addOperation(output, "get" + daoClazzName, clazz.getPackageName() + '.' + daoClazzName); + addImport(output, clazz); + addException(op, TopiaException.class); + setOperationBody(op, "" +/*{ + <%=daoClazzName%> result = context.getDAO(<%=clazzName%>.class, <%=daoClazzName%>.class); + return result; + }*/ + ); + + } + + // getContractClass method + op = addOperation(output, "getContractClass", "<T extends TopiaEntity> Class<T>", ObjectModelJavaModifier.PUBLIC, ObjectModelJavaModifier.STATIC); + 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, ObjectModelJavaModifier.STATIC); + 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, ObjectModelJavaModifier.STATIC); + 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, ObjectModelJavaModifier.STATIC); + 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, ObjectModelJavaModifier.STATIC); + 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, ObjectModelJavaModifier.STATIC); + setOperationBody(op, "" +/*{ + return <%=entityEnumName%>.values(); + }*/ + ); + + if (generateOperator) { + // getOperator method + op = addOperation(output, "getOperator", "<T extends TopiaEntity> EntityOperator<T>", ObjectModelJavaModifier.PUBLIC, ObjectModelJavaModifier.STATIC); + addParameter(op, "Class<T>", "klass"); + setOperationBody(op, "" +/*{ + <%=entityEnumName%> constant = <%=entityEnumName%>.valueOf(klass); + return EntityOperatorStore.getOperator(constant); + }*/ + ); + } + + } + + protected ObjectModelClass generateImpl(String packageName, + String entityAbstractName, + String entityConcreteName) { + + ObjectModelClass output = createClass(entityConcreteName, packageName); + + setSuperClass(output, entityAbstractName); + + ObjectModelOperation constructor = addConstructor( + output, + ObjectModelJavaModifier.PUBLIC); + addParameter(constructor, TopiaContext.class, "context"); + setOperationBody(constructor, "" + /*{ + super(context); + }*/ + ); + + return output; + } + +} Property changes on: trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/PersistenceContextTransformer.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native 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-08-15 10:47:30 UTC (rev 2799) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaGeneratorUtil.java 2013-08-15 10:50:33 UTC (rev 2800) @@ -25,6 +25,7 @@ package org.nuiton.topia.generator; +import com.google.common.base.Preconditions; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.logging.Log; @@ -33,6 +34,7 @@ import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.ModelPropertiesUtil; import org.nuiton.eugene.java.JavaGeneratorUtil; +import org.nuiton.eugene.java.ObjectModelTransformerToJava; import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelAssociationClass; import org.nuiton.eugene.models.object.ObjectModelAttribute; @@ -124,12 +126,70 @@ */ public static String getDefaultPackage(AbstractGenerator<?> generator) { String packageName = generator.getProperty(PROPERTY_DEFAULT_PACKAGE); - if (packageName == null || "".equals(packageName)) { + if (StringUtils.isBlank(packageName)) { packageName = DEFAULT_PACKAGE; } return packageName; } + public static String getPersistenceContextPackage(ObjectModelTransformerToJava transformer, + ObjectModel model) { + + String result = transformer.getDefaultPackageName(); + + return result; + } + + public static String getDaoPackage(ObjectModelTransformerToJava transformer, + ObjectModel model, + ObjectModelClassifier input) { + + Preconditions.checkState(isEntity(input), "Cant' find dao package name for a none entity " + input); + String result = input.getPackageName(); + return result; + } + + public static String getPersistenceContextAbstractName(ObjectModel model) { + return "AbstractTopia" + model.getName() + "PersistenceContext"; + } + + public static String getPersistenceContextConcreteName(ObjectModel model) { + return "Topia" + model.getName() + "PersistenceContext"; + } + + public static String getPersistenceContextInterfaceName(ObjectModel model) { + return model.getName() + "PersistenceContext"; + } + + public static String getEntityAbstractName(ObjectModelClass input) { + return "AbstractTopia" + input.getName(); + } + + public static String getEntityConcreteName(ObjectModelClass input) { + return input.getName(); + } + + public static String getDaoAbstractName(ObjectModelClass input) { + return "Abstract" + input.getName() + "TopiaDao"; + } + + public static String getDaoGeneratedName(ObjectModelClass input) { + return "Generated" + input.getName() + "TopiaDao"; + } + + public static String getDaoConcreteName(ObjectModelClass input) { +// return input.getName() + "TopiaDao"; + return input.getName() + "DAO"; + } + + public static String getEntityPackage(ObjectModelTransformerToJava transformer, + ObjectModel model, + ObjectModelClassifier input) { + + String result = input.getPackageName(); + return result; + } + /** * Renvoie l'interface DAO associée à la classe passée en paramètre * 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-08-15 10:47:30 UTC (rev 2799) +++ trunk/topia-persistence/src/main/java/org/nuiton/topia/generator/TopiaMetaTransformer.java 2013-08-15 10:50:33 UTC (rev 2800) @@ -61,6 +61,7 @@ // ); setTemplateTypes( + PersistenceContextTransformer.class, EntityTransformer.class, EntityDAOTransformer.class, // DAOTransformer.class,