Examples of org.jboss.forge.project.facets.JavaSourceFacet

org.jboss.forge.project.facets.JavaSourceFacet
@author Lincoln Baxter, III

      {
         ShellMessages.error(out, "Must specify a domain @Entity on which to operate.");
         return;
      }


      final JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);
      for (JavaResource jr : javaTargets)
      {
         JavaClass entity = (JavaClass) (jr).getJavaSource();
         if (!entity.hasAnnotation(XmlRootElement.class))
            entity.addAnnotation(XmlRootElement.class);


         String idType = resolveIdType(entity);
         if (!Types.isBasicType(idType))
         {
            ShellMessages.error(out, "Skipping class because @Id type [" + idType + "] is not supported by endpoint generation.");
            continue;
         }
         String idSetterName = resolveIdSetterName(entity);


         CompiledTemplateResource template = compiler.compileResource(getClass().getResourceAsStream(
                 "/org/jboss/forge/rest/Endpoint.jv"));


         Map<Object, Object> map = new HashMap<Object, Object>();
         map.put("entity", entity);
         map.put("idType", idType);
         map.put("setIdStatement", idSetterName);
         map.put("contentType", contentType);
         map.put("entityTable", getEntityTable(entity));


         JavaClass endpoint = JavaParser.parse(JavaClass.class, template.render(map));
         endpoint.addImport(entity.getQualifiedName());
         endpoint.setPackage(java.getBasePackage() + ".rest");
         endpoint.getAnnotation(Path.class).setStringValue("/" + getEntityTable(entity).toLowerCase());


         /*
         * Save the sources
         */
         java.saveJavaSource(entity);


         if (!java.getJavaResource(endpoint).exists()
                 || prompt.promptBoolean("Endpoint [" + endpoint.getQualifiedName() + "] already, exists. Overwrite?"))
         {
            java.saveJavaSource(endpoint);
            ShellMessages.success(out, "Generated REST endpoint for [" + entity.getQualifiedName() + "]");
         } else
            ShellMessages.info(out, "Aborted endpoint generation for [" + entity.getQualifiedName() + "]");
      }
   }

View Full Code Here

      DependencyFacet deps = project.getFacet(DependencyFacet.class);
      deps.addRepository(KnownRepository.JBOSS_NEXUS);


      if (project.hasFacet(JavaSourceFacet.class))
      {
         JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
         DirectoryResource sourceFolder = facet.getSourceFolder();
         createTopLevelPackage(sourceFolder, javaPackage);
         if (createMain)
         {
            facet.saveJavaSource(JavaParser
                     .create(JavaClass.class)
                     .setPackage(javaPackage)
                     .setName("Main")
                     .addMethod("public static void main(String[] args) {}")
                     .setBody("System.out.println(\"Hi there! I was forged as part of the project you call " + name

View Full Code Here

            }
            else if (res.length == 0)
            {
               if (getCurrentProject().hasFacet(JavaSourceFacet.class))
               {
                  JavaSourceFacet java = getCurrentProject().getFacet(JavaSourceFacet.class);
                  try
                  {
                     JavaResource resource = java.getJavaResource(obj.toString());
                     return resource;
                  }
                  catch (FileNotFoundException e)
                  {
                     throw new RuntimeException(e);

View Full Code Here

      // Track the list of resources generated


      List<Resource<?>> result = new ArrayList<Resource<?>>();
      try
      {
         JavaSourceFacet java = this.project.getFacet(JavaSourceFacet.class);
         WebResourceFacet web = this.project.getFacet(WebResourceFacet.class);


         loadTemplates();
         Map<Object, Object> context = CollectionUtils.newHashMap();
         context.put("entity", entity);
         String ccEntity = StringUtils.decapitalize(entity.getName());
         context.put("ccEntity", ccEntity);
         setPrimaryKeyMetaData(context, entity);


         // Prepare qbeMetawidget
         this.qbeMetawidget.setPath(entity.getQualifiedName());
         StringWriter stringWriter = new StringWriter();
         this.qbeMetawidget.write(stringWriter, this.backingBeanTemplateQbeMetawidgetIndent);


         context.put("qbeMetawidget", stringWriter.toString().trim());
         Set<String> qbeMetawidgetImports = this.qbeMetawidget.getImports();
         qbeMetawidgetImports.remove(entity.getQualifiedName());
         context.put("qbeMetawidgetImports",
                  CollectionUtils.toString(qbeMetawidgetImports, ";\r\nimport ", true, false));


         // Create the Backing Bean for this entity
         JavaClass viewBean = JavaParser.parse(JavaClass.class, this.backingBeanTemplate.render(context));
         viewBean.setPackage(java.getBasePackage() + ".view");
         result.add(ScaffoldUtil.createOrOverwrite(this.prompt, java.getJavaResource(viewBean), viewBean.toString(),
                  overwrite));


         // Set new context for view generation
         context = getTemplateContext(targetDir, template);
         String beanName = StringUtils.decapitalize(viewBean.getName());
         context.put("beanName", beanName);
         context.put("ccEntity", ccEntity);
         context.put("entityName", StringUtils.uncamelCase(entity.getName()));
         setPrimaryKeyMetaData(context, entity);


         // Prepare entityMetawidget
         this.entityMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + "." + ccEntity));
         this.entityMetawidget.setPath(entity.getQualifiedName());
         this.entityMetawidget.setReadOnly(false);
         this.entityMetawidget.setStyle(null);


         // Generate create
         writeEntityMetawidget(context, this.createTemplateEntityMetawidgetIndent, this.createTemplateNamespaces);


         result.add(ScaffoldUtil.createOrOverwrite(this.prompt,
                  web.getWebResource(targetDir + "/" + ccEntity + "/create.xhtml"),
                  this.createTemplate.render(context),
                  overwrite));


         // Generate view
         this.entityMetawidget.setReadOnly(true);
         writeEntityMetawidget(context, this.viewTemplateEntityMetawidgetIndent, this.viewTemplateNamespaces);


         result.add(ScaffoldUtil.createOrOverwrite(this.prompt,
                  web.getWebResource(targetDir + "/" + ccEntity + "/view.xhtml"),
                  this.viewTemplate.render(context), overwrite));


         // Generate search
         this.searchMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + ".example"));
         this.searchMetawidget.setPath(entity.getQualifiedName());
         this.beanMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + ".pageItems"));
         this.beanMetawidget.setPath(viewBean.getQualifiedName() + "/pageItems");
         writeSearchAndBeanMetawidget(context, this.searchTemplateSearchMetawidgetIndent,
                  this.searchTemplateBeanMetawidgetIndent, this.searchTemplateNamespaces);


         result.add(ScaffoldUtil.createOrOverwrite(this.prompt,
                  web.getWebResource(targetDir + "/" + ccEntity + "/search.xhtml"),
                  this.searchTemplate.render(context), overwrite));


         // Generate navigation
         result.add(generateNavigation(targetDir, overwrite));


         // Need ViewUtils and forge.taglib.xml for forgeview:asList
         JavaClass viewUtils = JavaParser.parse(JavaClass.class, this.viewUtilsTemplate.render(context));
         viewUtils.setPackage(viewBean.getPackage());
         result.add(ScaffoldUtil.createOrOverwrite(this.prompt, java.getJavaResource(viewUtils), viewUtils.toString(),
                  true));


         context.put("viewPackage", viewBean.getPackage());
         result.add(ScaffoldUtil.createOrOverwrite(this.prompt,
                  web.getWebResource("WEB-INF/classes/META-INF/forge.taglib.xml"),

View Full Code Here

            @Option(name = "inverseFieldName",
                     required = false,
                     description = "Create a bi-directional relationship, using this value as the name of the inverse field.",
                     type = PromptType.JAVA_VARIABLE_NAME) final String inverseFieldName)
   {
      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      try
      {
         JavaClass entityClass = getJavaClass();
         JavaClass fieldEntityClass;
         if (areTypesSame(fieldType, entityClass.getCanonicalName()))
         {
            fieldEntityClass = entityClass;
         }
         else
         {
            fieldEntityClass = findEntity(fieldType);
         }


         Field<JavaClass> localField = addFieldTo(entityClass, fieldEntityClass, fieldName, OneToOne.class);
         if ((inverseFieldName != null) && !inverseFieldName.isEmpty())
         {
            Field<JavaClass> inverseField = addFieldTo(fieldEntityClass, entityClass, inverseFieldName, OneToOne.class);
            inverseField.getAnnotation(OneToOne.class).setStringValue("mappedBy", localField.getName());
            java.saveJavaSource(fieldEntityClass);
         }
      }
      catch (FileNotFoundException e)
      {
         shell.println("Could not locate the @Entity requested. No update was made.");

View Full Code Here

                     required = false,
                     description = "Create an bi-directional relationship, using this value as the name of the inverse field.",
                     type = PromptType.JAVA_VARIABLE_NAME) final String inverseFieldName)
   {


      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      try
      {
         JavaClass entity = getJavaClass();
         JavaClass otherEntity;
         if (areTypesSame(fieldType, entity.getCanonicalName()))
         {
            otherEntity = entity;
         }
         else
         {
            otherEntity = findEntity(fieldType);
            entity.addImport(otherEntity.getQualifiedName());
         }


         if (entity.hasField(fieldName))
         {
            throw new IllegalStateException("Entity [" + entity.getCanonicalName() + "] already has a field named ["
                     + fieldName + "]");
         }
         if (!Strings.isNullOrEmpty(inverseFieldName) && otherEntity.hasField(inverseFieldName))
         {
            throw new IllegalStateException("Entity [" + otherEntity.getCanonicalName()
                     + "] already has a field named ["
                     + inverseFieldName + "]");
         }


         entity.addImport(Set.class);
         entity.addImport(HashSet.class);
         Field<JavaClass> field = entity.addField("private Set<" + otherEntity.getName() + "> " + fieldName
                  + "= new HashSet<"
                  + otherEntity.getName() + ">();");
         Annotation<JavaClass> annotation = field.addAnnotation(ManyToMany.class);
         Refactory.createGetterAndSetter(entity, field);


         if (!Strings.isNullOrEmpty(inverseFieldName))
         {
            annotation.setStringValue("mappedBy", inverseFieldName);


            otherEntity.addImport(Set.class);
            otherEntity.addImport(HashSet.class);
            if (!otherEntity.getCanonicalName().equals(entity.getCanonicalName()))
            {
               otherEntity.addImport(entity.getQualifiedName());
            }
            Field<JavaClass> otherField = otherEntity.addField("private Set<" + entity.getName() + "> "
                     + inverseFieldName
                     + "= new HashSet<" + entity.getName() + ">();");
            otherField.addAnnotation(ManyToMany.class);
            Refactory.createGetterAndSetter(otherEntity, otherField);


            java.saveJavaSource(otherEntity);
         }
         java.saveJavaSource(entity);
      }
      catch (FileNotFoundException e)
      {
         shell.println("Could not locate the @Entity requested. No update was made.");
      }

View Full Code Here

            @Option(name = "inverseFieldName",
                     required = false,
                     description = "Create an bi-directional relationship, using this value as the name of the inverse field.",
                     type = PromptType.JAVA_VARIABLE_NAME) final String inverseFieldName)
   {
      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      try
      {
         JavaClass one = getJavaClass();
         JavaClass many;
         // Field type may end with .java
         if (areTypesSame(fieldType, one.getCanonicalName()))
         {
            many = one;
         }
         else
         {
            many = findEntity(fieldType);
            one.addImport(many.getQualifiedName());
         }


         if (one.hasField(fieldName))
         {
            throw new IllegalStateException("Entity [" + one.getCanonicalName() + "] already has a field named ["
                     + fieldName + "]");
         }
         if (!Strings.isNullOrEmpty(inverseFieldName) && many.hasField(inverseFieldName))
         {
            throw new IllegalStateException("Entity [" + many.getCanonicalName() + "] already has a field named ["
                     + inverseFieldName + "]");
         }


         one.addImport(Set.class);
         one.addImport(HashSet.class);


         Field<JavaClass> oneField = one.addField("private Set<" + many.getName() + "> " + fieldName + "= new HashSet<"
                  + many.getName() + ">();");
         Annotation<JavaClass> annotation = oneField.addAnnotation(OneToMany.class);
         Refactory.createGetterAndSetter(one, oneField);


         if (!Strings.isNullOrEmpty(inverseFieldName))
         {
            annotation.setStringValue("mappedBy", inverseFieldName);
            annotation.setLiteralValue("cascade", "CascadeType.ALL");
            annotation.getOrigin().addImport(CascadeType.class);
            annotation.setLiteralValue("orphanRemoval", "true");
            if (!many.getCanonicalName().equals(one.getCanonicalName()))
            {
               many.addImport(one);
            }
            Field<JavaClass> manyField = many.addField("private " + one.getName() + " " + inverseFieldName + ";");
            manyField.addAnnotation(ManyToOne.class);
            Refactory.createGetterAndSetter(many, manyField);
            java.saveJavaSource(many);
         }
         java.saveJavaSource(one);
      }
      catch (FileNotFoundException e)
      {
         shell.println("Could not locate the @Entity requested. No update was made.");
      }

View Full Code Here

            @Option(name = "inverseFieldName",
                     required = false,
                     description = "Create an bi-directional relationship, using this value as the name of the inverse field.",
                     type = PromptType.JAVA_VARIABLE_NAME) final String inverseFieldName)
   {
      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      try
      {
         JavaClass many = getJavaClass();
         JavaClass one;
         if (areTypesSame(fieldType, many.getCanonicalName()))
         {
            one = many;
         }
         else
         {
            one = findEntity(fieldType);
            many.addImport(one);
         }
         if (many.hasField(fieldName))
         {
            throw new IllegalStateException("Entity [" + many.getCanonicalName() + "] already has a field named ["
                     + fieldName + "]");
         }
         if (!Strings.isNullOrEmpty(inverseFieldName) && one.hasField(inverseFieldName))
         {
            throw new IllegalStateException("Entity [" + one.getCanonicalName() + "] already has a field named ["
                     + inverseFieldName + "]");
         }


         Field<JavaClass> manyField = many.addField("private " + one.getName() + " " + fieldName + ";");
         manyField.addAnnotation(ManyToOne.class);
         Refactory.createGetterAndSetter(many, manyField);


         if (!Strings.isNullOrEmpty(inverseFieldName))
         {
            one.addImport(Set.class);
            one.addImport(HashSet.class);
            if (!one.getCanonicalName().equals(many.getCanonicalName()))
            {
               one.addImport(many.getQualifiedName());
            }
            Field<JavaClass> oneField = one.addField("private Set<" + many.getName() + "> " + inverseFieldName
                     + "= new HashSet<"
                     + many.getName() + ">();");
            Annotation<JavaClass> oneAnnotation = oneField.addAnnotation(OneToMany.class).setStringValue("mappedBy",
                     fieldName);
            oneAnnotation.setLiteralValue("cascade", "CascadeType.ALL");
            oneAnnotation.getOrigin().addImport(CascadeType.class);


            Refactory.createGetterAndSetter(one, oneField);
            java.saveJavaSource(one);
         }
         java.saveJavaSource(many);
      }
      catch (FileNotFoundException e)
      {
         shell.println("Could not locate the @Entity requested. No update was made.");
      }

View Full Code Here

      {
         throw new IllegalStateException("Entity [" + targetEntity.getCanonicalName() + "] already has a field named ["
                  + fieldName + "]");
      }


      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      Field<JavaClass> field = targetEntity.addField();
      field.setName(fieldName).setPrivate().setType(fieldEntity.getName()).addAnnotation(annotation);
      if (!targetEntity.getCanonicalName().equals(fieldEntity.getCanonicalName()))
      {
         targetEntity.addImport(fieldEntity.getQualifiedName());
      }
      Refactory.createGetterAndSetter(targetEntity, field);
      updateToString(targetEntity);


      java.saveJavaSource(targetEntity);
      shell.println("Added field to " + targetEntity.getQualifiedName() + ": " + field);


      return field;
   }

View Full Code Here

      if (targetEntity.hasField(fieldName))
      {
         throw new IllegalStateException("Entity already has a field named [" + fieldName + "]");
      }


      JavaSourceFacet java = project.getFacet(JavaSourceFacet.class);


      Field<JavaClass> field = targetEntity.addField();
      field.setName(fieldName).setPrivate().setType(Types.toSimpleName(fieldType)).addAnnotation(annotation);
      if (!targetEntity.getCanonicalName().equals(fieldType))
      {
         targetEntity.addImport(fieldType);
      }
      Refactory.createGetterAndSetter(targetEntity, field);


      updateToString(targetEntity);
      java.saveJavaSource(targetEntity);
      shell.println("Added field to " + targetEntity.getQualifiedName() + ": " + field);


      return field;
   }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.jboss.forge.project.facets.JavaSourceFacet

org.jboss.forge.arquillian.ArquillianPlugin

org.jboss.forge.dev.java.JavaPlugin

org.jboss.forge.dev.NewAddonPlugin

org.jboss.forge.dev.PluginsPlugin

org.jboss.forge.scaffold.faces.FacesScaffold

org.jboss.forge.scaffold.faces.metawidget.inspector.propertystyle.ForgePropertyStyle

org.jboss.forge.scaffold.faces.util.AnnotationLookup

org.jboss.forge.scaffoldx.metawidget.inspector.propertystyle.ForgePropertyStyle

org.jboss.forge.shell.plugins.builtin.NewProjectPlugin

org.jboss.forge.shell.ShellImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.