Author: tchemit Date: 2013-06-11 10:36:20 +0200 (Tue, 11 Jun 2013) New Revision: 666 Url: http://nuiton.org/projects/sandbox/repository/revisions/666 Log: generates nice dao methods Modified: nuiton-jpa/nuiton-jpa-api/src/main/java/org/nuiton/jpa/api/AbstractJpaDao.java nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaDaoTransformer.java nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaEntityTransformer.java nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaTemplatesGeneratorUtil.java Modified: nuiton-jpa/nuiton-jpa-api/src/main/java/org/nuiton/jpa/api/AbstractJpaDao.java =================================================================== --- nuiton-jpa/nuiton-jpa-api/src/main/java/org/nuiton/jpa/api/AbstractJpaDao.java 2013-06-10 13:56:13 UTC (rev 665) +++ nuiton-jpa/nuiton-jpa-api/src/main/java/org/nuiton/jpa/api/AbstractJpaDao.java 2013-06-11 08:36:20 UTC (rev 666) @@ -89,6 +89,48 @@ return entityManager.contains(entity); } + public E findByProperty(String propertyName, Object value) + { + Map<String, Object> properties = new HashMap<String, Object>(); + properties.put(propertyName, value); + E result = findByProperties(properties); + return result; + } + + public List<E> findAllByProperty(String propertyName, Object value) { + TypedQuery<E> query = createQuery(propertyName, value); + List<E> result = findAll(query); + return result; + } + + public List<E> findAllByProperties(Map<String, Object> properties) + { + TypedQuery<E> query = createQuery(properties); + List<E> results = findAll(query); + return results; + } + + public E findByProperties(Map<String, Object> properties) + { + TypedQuery<E> query = createQuery(properties); + E result = findAnyOrNull(query); + return result; + } + + public E findContains(String propertyName, + Object property) { + TypedQuery<E> query= createQuery("From "+getEntityClass().getSimpleName()+" Where "+propertyName+" in elements(:K)"); + query.setParameter("K", property); + return findAnyOrNull(query); + } + + public List<E> findAllContains(String propertyName, + Object property) { + TypedQuery<E> query = createQuery("From "+getEntityClass().getSimpleName()+" Where "+propertyName+" in elements(:K)"); + query.setParameter("K", property); + return findAll(query); + } + @Override public E newInstance() { E newInstance; Modified: nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaDaoTransformer.java =================================================================== --- nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaDaoTransformer.java 2013-06-10 13:56:13 UTC (rev 665) +++ nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaDaoTransformer.java 2013-06-11 08:36:20 UTC (rev 666) @@ -28,13 +28,19 @@ /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ +import org.apache.commons.collections.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.GeneratorUtil; +import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelJavaModifier; import org.nuiton.eugene.models.object.ObjectModelOperation; import org.nuiton.jpa.api.AbstractJpaDao; +import java.util.Collection; +import java.util.List; + /** * JpaDaoTransformer generates a dao for an entity. * <p/> @@ -84,6 +90,9 @@ String abstractDaoName, String concreteEntityQualifiedName) { + String prefix = getConstantPrefix(input, DEFAULT_CONSTANT_PREFIX); + setConstantPrefix(prefix); + String entityName = input.getName(); ObjectModelClass output = @@ -139,6 +148,23 @@ }*/ ); + Collection<ObjectModelAttribute> attributes = input.getAttributes(); + if (CollectionUtils.isNotEmpty(attributes)) { + addImport(output, List.class); + } + + for (ObjectModelAttribute attr : attributes) { + if (!attr.isNavigable()) { + continue; + } + + if (!GeneratorUtil.isNMultiplicity(attr)) { + generateNoNMultiplicity(entityName, output, attr, false); + } else { + generateNMultiplicity(entityName, output, attr); + } + } + if (isVerbose()) { log.info("will generate " + output.getQualifiedName()); } @@ -161,4 +187,117 @@ } return output; } + + protected void generateNoNMultiplicity(String clazzName, + ObjectModelClass result, + ObjectModelAttribute attr, + boolean isAssoc) { + String attrName = attr.getName(); + String attrType = attr.getType(); + String propertyName = clazzName + "." + getConstantName(attrName); + if (!isAssoc && attr.hasAssociationClass()) { + String assocClassName = attr.getAssociationClass().getName(); + String assocAttrName = JpaTemplatesGeneratorUtil.getAssocAttrName(attr); + // It is about transitivity : use the property to access the + // associationClass + '.' + the property to access the expected + // attribute + // <class>.<attrAssoc> + '.' + <assocClass>.<attr> + propertyName = + clazzName + '.' + getConstantName(assocAttrName) + + " + '.' + " + + assocClassName + '.' + getConstantName(attrName); + } + + ObjectModelOperation op; + op = addOperation(result, + getJavaBeanMethodName("findBy", attrName), + clazzName, + ObjectModelJavaModifier.PUBLIC); + addParameter(op, attrType, "v"); + setOperationBody(op, "" +/*{ + <%=clazzName%> result = findByProperty(<%=propertyName%>, v); + return result; + }*/ + ); + + op = addOperation(result, + getJavaBeanMethodName("findAllBy", attrName), + "List<" + clazzName + ">", + ObjectModelJavaModifier.PUBLIC); + addParameter(op, attrType, "v"); + setOperationBody(op, "" +/*{ + List<<%=clazzName%>> result = findAllByProperty(<%=propertyName%>, v); + return result; + }*/ + ); + + if (!isAssoc && attr.hasAssociationClass()) { + String assocClassName = attr.getAssociationClass().getName(); + String assocClassFQN = attr.getAssociationClass().getQualifiedName(); + String assocAttrName = GeneratorUtil.getAssocAttrName(attr); + String assocPropertyConstantName = getConstantName(assocAttrName); + op = addOperation(result, + getJavaBeanMethodName("findBy", assocClassName), + clazzName, + ObjectModelJavaModifier.PUBLIC); + addParameter(op, assocClassFQN, "value"); + setOperationBody(op, "" +/*{ + <%=clazzName%> result = findByProperty(<%=clazzName + "." + assocPropertyConstantName%>, value); + return result; + }*/ + ); + + op = addOperation(result, + getJavaBeanMethodName("findAllBy", assocClassName), + "List<" + clazzName + ">", + ObjectModelJavaModifier.PUBLIC); + addParameter(op, assocClassFQN, "value"); + setOperationBody(op, "" +/*{ + List<<%=clazzName%>> result = findAllByProperty(<%=clazzName + "." + assocPropertyConstantName%>, value); + return result; + }*/ + ); + } + } + + protected void generateNMultiplicity(String clazzName, + ObjectModelClass result, + ObjectModelAttribute attr) { + String attrName = attr.getName(); + String attrType = attr.getType(); + if (attr.hasAssociationClass()) { + // do nothing for association class, too complex... + return; + } + ObjectModelOperation op; + // Since 2.4 do nothing, findContains and findAllContains are not generated anymore + op = addOperation(result, + getJavaBeanMethodName("findContains", attrName), + clazzName, + ObjectModelJavaModifier.PUBLIC); + addParameter(op, attrType, "v"); + setOperationBody(op, "" +/*{ + <%=clazzName%> result = findContains(<%=clazzName + "." + getConstantName(attrName)%>, v); + return result; + }*/ + ); + + op = addOperation(result, + getJavaBeanMethodName("findAllContains", attrName), + "List<" + clazzName + ">", + ObjectModelJavaModifier.PUBLIC); + addParameter(op, attrType, "v"); + setOperationBody(op, "" +/*{ + List<<%=clazzName%>> result = findAllContains(<%=clazzName + "." + getConstantName(attrName)%>, v); + return result; + }*/ + ); + } + } \ No newline at end of file Modified: nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaEntityTransformer.java =================================================================== --- nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaEntityTransformer.java 2013-06-10 13:56:13 UTC (rev 665) +++ nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaEntityTransformer.java 2013-06-11 08:36:20 UTC (rev 666) @@ -39,6 +39,7 @@ import org.nuiton.eugene.models.object.xml.ObjectModelAttributeImpl; import org.nuiton.jpa.api.AbstractJpaEntity; import org.nuiton.jpa.api.JpaEntities; +import org.nuiton.jpa.api.JpaEntity; import org.nuiton.jpa.api.JpaEntityIdFactoryResolver; import javax.persistence.CascadeType; @@ -79,7 +80,7 @@ private static final Log log = LogFactory.getLog(JpaEntityTransformer.class); - public static final String PROPERTY_ID = "id"; +// public static final String PROPERTY_ID = "id"; @Override public void transformFromClass(ObjectModelClass input) { @@ -206,7 +207,7 @@ // Create an id property ObjectModelAttributeImpl idAttr = new ObjectModelAttributeImpl(); idAttr.setDeclaringElement(input); - idAttr.setName(PROPERTY_ID); + idAttr.setName(JpaEntity.PROPERTY_ID); idAttr.setType(String.class.getName()); properties.add(0, idAttr); @@ -281,7 +282,7 @@ for (ObjectModelAttribute property : properties) { String propertyName = property.getName(); String propertyType = property.getType(); - if (PROPERTY_ID.equals(propertyName)) { + if (JpaEntity.PROPERTY_ID.equals(propertyName)) { addAnnotation(result, property, output, Id.class); if (JpaTemplatesGeneratorUtil.generateEntityGeneratedValueAnnotation(model, input)) { @@ -333,7 +334,7 @@ if (bidirection && !isInverse) { // add the mappedBy parameter - annotationParams.add("mappedBy = \"" + reverseAttribute.getName()+"\""); + annotationParams.add("mappedBy = \"" + reverseAttribute.getName() + "\""); } if (nMultiplicity) { @@ -419,7 +420,7 @@ createGetChildMethod(output, attrName, attrType, - simpleType ); + simpleType); createGetChildByIdMethod(output, attrName, @@ -427,40 +428,40 @@ simpleType); createIsEmptyMethod(output, - attrName ); + attrName); createSizeMethod(output, - attrName ); + attrName); createAddChildMethod(output, attrName, attrType, constantName, - usePCS ); + usePCS); createAddAllChildrenMethod(output, attrName, attrType, constantName, - usePCS ); + usePCS); createRemoveChildMethod(output, attrName, attrType, constantName, - usePCS ); + usePCS); createRemoveAllChildrenMethod(output, attrName, attrType, constantName, - usePCS ); + usePCS); createContainsChildMethod(output, attrName, attrType, constantName, - usePCS ); + usePCS); createContainsChildByIdMethod(output, attrName, @@ -472,7 +473,7 @@ attrName, attrType, constantName, - usePCS ); + usePCS); // Change type for Multiple attribute Class<?> collectionType = JpaTemplatesGeneratorUtil.getCollectionType(attr); @@ -501,7 +502,7 @@ JpaTemplatesGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX ); - if (PROPERTY_ID.equals(attrName)) { + if (JpaEntity.PROPERTY_ID.equals(attrName)) { addAnnotation(output, getMethod, Override.class); } @@ -567,9 +568,9 @@ } protected void createGetChildByIdMethod(ObjectModelClass output, - String attrName, - String attrType, - String simpleType) { + String attrName, + String attrType, + String simpleType) { ObjectModelOperation operation = addOperation( output, getJavaBeanMethodName("get", attrName + "ById"), @@ -767,14 +768,14 @@ } protected void createContainsChildByIdMethod(ObjectModelClass output, - String attrName, - String attrType, - String constantName, - boolean usePCS) { + String attrName, + String attrType, + String constantName, + boolean usePCS) { ObjectModelOperation operation = addOperation( output, - getJavaBeanMethodName("contains", attrName+"ById"), + getJavaBeanMethodName("contains", attrName + "ById"), "boolean", ObjectModelJavaModifier.PUBLIC ); Modified: nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaTemplatesGeneratorUtil.java =================================================================== --- nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaTemplatesGeneratorUtil.java 2013-06-10 13:56:13 UTC (rev 665) +++ nuiton-jpa/nuiton-jpa-templates/src/main/java/org/nuiton/jpa/templates/JpaTemplatesGeneratorUtil.java 2013-06-11 08:36:20 UTC (rev 666) @@ -185,7 +185,7 @@ return result; } - public static boolean containsMutiple(List<ObjectModelAttribute> attributes) { + public static boolean containsMutiple(Collection<ObjectModelAttribute> attributes) { boolean result = false;