org.nuiton.topia.templates.PersistenceContextTransformer Maven / Gradle / Ivy

Go to download
package org.nuiton.topia.templates;

/*
 * #%L
 * Toolkit :: Templates
 * %%
 * Copyright (C) 2017 - 2024 Ultreia.io
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program.  If not, see
 * .
 * #L%
 */




import org.codehaus.plexus.component.annotations.Component;
import org.nuiton.eugene.EugeneCoreTagValues;
import org.nuiton.eugene.Template;
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.ObjectModelInterface;
import org.nuiton.eugene.models.object.ObjectModelJavaModifier;
import org.nuiton.eugene.models.object.ObjectModelOperation;
import org.nuiton.topia.persistence.TopiaDaoSupplier;
import org.nuiton.topia.persistence.internal.AbstractTopiaPersistenceContext;
import org.nuiton.topia.persistence.internal.AbstractTopiaPersistenceContextConstructorParameter;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * To generate PersistenceHelper
 *
 * @author Tony Chemit - [email protected]
 * @since 3.0
 */
@Component(role = Template.class, hint = "org.nuiton.topia.templates.PersistenceContextTransformer")
public class PersistenceContextTransformer extends ObjectModelTransformerToJava {

    private String[] relativeNameExcludes;
    private boolean useRelativeName;
    private List entityClasses;
    protected TopiaTemplateHelper templateHelper;

    protected final TopiaCoreTagValues topiaCoreTagValues;

    public PersistenceContextTransformer() {
        this.topiaCoreTagValues = new TopiaCoreTagValues();
    }

    @Override
    public void transformFromModel(ObjectModel input) {

        templateHelper = new TopiaTemplateHelper(model);
        EugeneCoreTagValues coreTagValues = new EugeneCoreTagValues();
        useRelativeName = coreTagValues.isUseRelativeName(model);
        Set relativeNameExcludesSet = coreTagValues.getRelativeNameExcludes(model);
        relativeNameExcludes = relativeNameExcludesSet == null ? new String[0] : relativeNameExcludesSet.toArray(new String[0]);

        entityClasses = templateHelper.getEntityClasses(model, true).stream().filter(t -> !t.isAbstract() || t.isStatic()).collect(Collectors.toList());

        String packageName = templateHelper.getPersistenceContextPackage(this, model);

        String daoSupplierName = templateHelper.getDaoSupplierName(model);

        String persistenceContextAbstractName = templateHelper.getPersistenceContextAbstractName(model);

        String persistenceContextConcreteName = templateHelper.getPersistenceContextConcreteName(model);

        boolean generateDaoSupplier =
                !getResourcesHelper().isJavaFileInClassPath(packageName + "." + daoSupplierName);

        boolean generateAbstract =
                !getResourcesHelper().isJavaFileInClassPath(packageName + "." + persistenceContextAbstractName);

        boolean generateConcrete =
                !getResourcesHelper().isJavaFileInClassPath(packageName + "." + persistenceContextConcreteName);

        if (generateDaoSupplier) {

            generateDaoSupplier(packageName,
                                daoSupplierName);
        }

        if (generateAbstract) {

            generateAbstract(packageName,
                             persistenceContextAbstractName,
                             daoSupplierName);
        }

        if (generateConcrete) {

            generateImpl(packageName,
                         persistenceContextAbstractName,
                         persistenceContextConcreteName);
        }

    }

    protected void generateDaoSupplier(String packageName, String className) {

        ObjectModelInterface output = createInterface(className, packageName);

        // detect if there is a contract to set on abstract
        String contractName = templateHelper.getDaoSupplierInterfaceName(model);

        boolean addPersistenceContextContract = getResourcesHelper().isJavaFileInClassPath(packageName + "." + contractName);

        if (addPersistenceContextContract) {
            addInterface(output, packageName + "." + contractName);
        }

        addInterface(output, TopiaDaoSupplier.class);

        for (ObjectModelClass clazz : entityClasses) {
            String aPackageName = model.getPackage(clazz).getName();
            String daoContractName = templateHelper.getContractDaoName(clazz);
            String daoClazzName = templateHelper.getConcreteDaoName(clazz);

            String methodName = getMethodName(useRelativeName, relativeNameExcludes, "get", aPackageName, daoContractName);

            if (useRelativeName) {
                daoClazzName = aPackageName + "." + daoClazzName;
            } else {
                addImport(output, clazz);
                addImport(output, aPackageName + '.' + daoClazzName);
            }

            // specialized getXXXDao method
            addOperation(
                    output,
                    methodName,
                    daoClazzName);
        }
    }

    protected void generateAbstract(String packageName,
                                    String className,
                                    String daoSupplierName) {

        ObjectModelClass output = createAbstractClass(className, packageName);

        // try to find a super class by tag-value
        String superClass = topiaCoreTagValues.getPersistenceContextSuperClassTagValue(model);

        if (superClass == null) {

            // no super-class, use default one
            superClass = AbstractTopiaPersistenceContext.class.getName();
        } else {

            //TODO check that super class instance of TopiaPersistenceContext
        }

        setSuperClass(output, superClass);

        // detect if there is a contract to set on abstract
        String contractName = templateHelper.getPersistenceContextInterfaceName(model);

        boolean addPersistenceContextContract = getResourcesHelper().isJavaFileInClassPath(packageName + "." + contractName);

        if (addPersistenceContextContract) {
            addInterface(output, packageName + "." + contractName);
        }

        addInterface(output, packageName + "." + daoSupplierName);
        addContructor(output, false);

        for (ObjectModelClass clazz : entityClasses) {
            String aPackageName = getPackage(clazz).getName();
            String clazzName = clazz.getName();

            String daoContractName = templateHelper.getContractDaoName(clazz);
            String daoClazzName = templateHelper.getConcreteDaoName(clazz);

            String methodName = getMethodName(useRelativeName, relativeNameExcludes, "get", aPackageName, daoContractName);

            if (useRelativeName) {
                clazzName = aPackageName + "." + clazzName;
                daoClazzName = aPackageName + "." + daoClazzName;
            } else {
                addImport(output, clazz);
                addImport(output, aPackageName + "." + daoClazzName);
            }

            // specialized getXXXDao method
            ObjectModelOperation op = addOperation(output, methodName, daoClazzName);
            addAnnotation(output, op, Override.class);

            setOperationBody(op, ""+"\n"
+"        return getDao("+clazzName+".class, "+daoClazzName+".class);\n"
+"    "
            );
        }
    }

    protected ObjectModelClass generateImpl(String packageName,
                                            String entityAbstractName,
                                            String entityConcreteName) {

        ObjectModelClass output = createClass(entityConcreteName, packageName);

        setSuperClass(output, entityAbstractName);
        addContructor(output, true);
        return output;
    }

    protected void addContructor(ObjectModelClass output, boolean isPublic) {

        ObjectModelJavaModifier visibility = isPublic ?
                ObjectModelJavaModifier.PUBLIC :
                ObjectModelJavaModifier.PROTECTED;

        ObjectModelOperation constructor = addConstructor(output, visibility);
        addParameter(constructor, AbstractTopiaPersistenceContextConstructorParameter.class, "parameter");
        setOperationBody(constructor, ""
+"\n"
+"        super(parameter);\n"
+"    "
        );
    }

}