AerogearAngularScaffold.java

package org.jboss.forge.scaffold.angularjs;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.inject.Inject;

import org.jboss.forge.env.Configuration;
import org.jboss.forge.parser.java.JavaClass;
import org.jboss.forge.project.facets.BaseFacet;
import org.jboss.forge.project.facets.DependencyFacet;
import org.jboss.forge.project.facets.JavaSourceFacet;
import org.jboss.forge.project.facets.MetadataFacet;
import org.jboss.forge.project.facets.WebResourceFacet;
import org.jboss.forge.resources.FileResource;
import org.jboss.forge.resources.Resource;
import org.jboss.forge.resources.java.JavaResource;
import org.jboss.forge.scaffoldx.AccessStrategy;
import org.jboss.forge.scaffoldx.ScaffoldProvider;
import org.jboss.forge.scaffoldx.TemplateStrategy;
import org.jboss.forge.scaffoldx.facets.ScaffoldTemplateFacet;
import org.jboss.forge.scaffoldx.util.ScaffoldUtil;
import org.jboss.forge.shell.ShellPrompt;
import org.jboss.forge.shell.plugins.Alias;
import org.jboss.forge.shell.plugins.Help;
import org.jboss.forge.shell.plugins.RequiresFacet;
import org.jboss.forge.shell.project.ProjectScoped;
import org.jboss.forge.shell.util.ConstraintInspector;
import org.jboss.forge.spec.javaee.CDIFacet;
import org.jboss.forge.spec.javaee.EJBFacet;
import org.jboss.forge.spec.javaee.PersistenceFacet;
import org.jboss.forge.spec.javaee.RestFacet;
import org.metawidget.util.simple.StringUtils;

/**
 *
 */
@Alias("angularjs")
@Help("AngularJS scaffolding")
@RequiresFacet({ WebResourceFacet.class, DependencyFacet.class, PersistenceFacet.class, EJBFacet.class, CDIFacet.class,
        RestFacet.class, ScaffoldTemplateFacet.class })
public class AerogearAngularScaffold extends BaseFacet implements ScaffoldProvider {

    protected ShellPrompt prompt;
    
    @Inject
    protected IntrospectorClient introspectorClient;

    @Inject
    protected ResourceProvider resourceProvider;
    
    @Inject
    @ProjectScoped
    Configuration configuration;

    @Inject
    public AerogearAngularScaffold(final ShellPrompt prompt) {
        this.prompt = prompt;
    }

    @Override
    public boolean install() {
        // TODO Add Maven artifacts to the project here. Required facet installation is already handled by the class-level
        // @RequiresFacet annotation.
        return true;
    }

    @Override
    public boolean isInstalled() {
        // TODO Looks unnecessary for this scaffold. See comments on install(). We could extract install() and installed() out.
        return true;
    }

    
    public List<Resource<?>> setup(String targetDir, boolean overwrite, boolean installTemplates) {
        ArrayList<Resource<?>> result = new ArrayList<Resource<?>>();

        // Copy templates
        if(installTemplates) {
            installTemplates();            
        }
        List<ScaffoldResource> staticResources = resourceProvider.getStaticResources();
        for(ScaffoldResource scaffoldResource: staticResources){
           result.add(processResource(scaffoldResource, overwrite));
        }
        return result;
    }

    private Resource processResource(ScaffoldResource scaffoldResource, boolean overwrite) {
        switch (scaffoldResource.getType()){
            case WEB_STATIC:    return processStaticResource(scaffoldResource, overwrite);

            case WEB_TEMPLATE:  return processWebTemplateResource(scaffoldResource, overwrite);

            case JAVA_TEMPLATE: return processJavaTemplateResource(scaffoldResource, overwrite);

            default:            return null;
        }
    }



    public List<Resource<?>> generateIndex(List<Resource<?>> resources, String targetDir, boolean overwrite) {
        ArrayList<Resource<?>> result = new ArrayList<Resource<?>>();
        List<String> entityNames = new ArrayList<String>();

        WebResourceFacet web = getWebResourceFacet();
        FileResource<?> partialsDirectory = web.getWebResource("views");
        for (Resource<?> resource : partialsDirectory.listResources()) {
            entityNames.add(resource.getName());
        }
        Map<String, Object> root = new HashMap<String, Object>();
        setGeneralContext(root);
        root.put("entityNames", entityNames);

        List<ScaffoldResource> templateResources = resourceProvider.getCommonTemplateResources();
        for(ScaffoldResource scaffoldResource : templateResources) {
            scaffoldResource.setContext(root);
            result.add(processResource(scaffoldResource, overwrite));
        }
        return result;
    }

    @Override
    public List<Resource<?>> generateFrom(List<Resource<?>> resources, String targetDir, boolean overwrite) {
        ArrayList<Resource<?>> result = new ArrayList<Resource<?>>();
        for(Resource<?> resource: resources)
        {
            JavaClass entity = getJavaClassFrom(resource);
            System.out.println("Generating artifacts from Entity:" + entity.getQualifiedName());
            WebResourceFacet web = getWebResourceFacet();

            Map<String, Object> root = createEntityContext(entity);

            List<ScaffoldResource> templateResources = resourceProvider.getPerEntityTemplateResources();
            for(ScaffoldResource scaffoldResource : templateResources) {
                scaffoldResource.setContext(root);
                scaffoldResource.setDestination(replacePattern(scaffoldResource.getDestination(), "{entity}", (String) root.get("entityName")));
                result.add(processResource(scaffoldResource, overwrite));
            }

        }
        generateIndex(resources, targetDir, overwrite);
        return result;
    }



    private Resource processStaticResource(ScaffoldResource scaffoldResource, boolean overwrite) {
         return ScaffoldUtil.createOrOverwrite(this.prompt, getWebResourceFacet().getWebResource("/styles/bootstrap.css"), getClass()
                .getResourceAsStream("/scaffold/styles/bootstrap.css"), overwrite);

    }

    private Resource processJavaTemplateResource(ScaffoldResource scaffoldResource, boolean overwrite) {


    }

    private Resource processWebTemplateResource(ScaffoldResource scaffoldResource, boolean overwrite) {
        FreemarkerClient freemarkerClient = new FreemarkerClient();
        String output = freemarkerClient.processFTL(scaffoldResource.getContext(), scaffoldResource.getSource());
        String outputPath = scaffoldResource.getDestination();
        return ScaffoldUtil.createOrOverwrite(prompt, getWebResourceFacet().getWebResource(outputPath), output, overwrite);
    }


    private String replacePattern(String destination, String s, String entityName) {
        return destination.replace(s,entityName);
    }

    private Map<String, Object> createEntityContext(JavaClass entity) {
        List<Map<String, String>> inspectionResults = introspectorClient.inspect(entity);
        Map<String, Object> root = new HashMap<String, Object>();
        setGeneralContext(root);
        root.put("entityName", entity.getName());
        root.put("properties", inspectionResults);
        root.put("resourceRootPath", getResourceRootPath());
        return root;
    }

    private String getResourceRootPath() {
        String resourceRootPath = configuration.getString(RestFacet.ROOTPATH);
        if (resourceRootPath == null) {
            throw new RuntimeException(
                    "This project does not have a rootpath for REST resources. You may need to run \"rest setup\" in Forge.");
        }
        if (resourceRootPath.startsWith("/")) {
            resourceRootPath = resourceRootPath.substring(1);
        }
        if (resourceRootPath.endsWith("/")) {
            resourceRootPath = resourceRootPath.substring(0, resourceRootPath.length() - 1);
        }
        return resourceRootPath;
    }

    private WebResourceFacet getWebResourceFacet() {
        return this.project.getFacet(WebResourceFacet.class);
    }

    private void setGeneralContext(Map<String, Object> root){
        MetadataFacet metadata = this.project.getFacet(MetadataFacet.class);
        root.put("projectId", StringUtils.camelCase(metadata.getProjectName()));
        root.put("projectTitle", StringUtils.uncamelCase(metadata.getProjectName()));

    }



    @Override
    public AccessStrategy getAccessStrategy() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public TemplateStrategy getTemplateStrategy() {
        // TODO Auto-generated method stub
        return null;
    }

    private JavaClass getJavaClassFrom(Resource<?> resource) {
        JavaResource javaResource = null;
        if(resource instanceof JavaResource)
        {
            javaResource = (JavaResource) resource;
        }
        else
        {
            return null;
        }
        JavaClass entity;
        try {
            entity = (JavaClass) javaResource.getJavaSource();
        } catch (FileNotFoundException fileEx) {
            throw new RuntimeException(fileEx);
        }
        return entity;
    }

    private void installTemplates() {
        ScaffoldTemplateFacet templates = project.getFacet(ScaffoldTemplateFacet.class);
        //templates.createResource(null, ConstraintInspector.getName(getClass()), null);
    }

}