@Override public void initializeUI(UIBuilder builder) throws Exception { dependencyResolver = SimpleContainer.getServices(getClass().getClassLoader(), DependencyResolver.class).get(); InputComponentFactory factory = builder.getInputComponentFactory(); dbType = factory.createSelectOne("dbType", DatabaseType.class).setLabel("Database Type") .setDescription("The database driver to be added to this project").setRequired(true) .setNote(() -> { return (dbType.hasValue()) ? dbType.getValue().getDriverCoordinate().toString() : null; }) .setValueChoices(DatabaseType.getTypesWithDriverSet()); version = factory.createInput("version", String.class).setLabel("Driver Version") .setDescription("The JDBC driver version to be used") .setCompleter(new UICompleter<String>() { @Override public Iterable<String> getCompletionProposals(UIContext context, InputComponent<?, String> input, String value) { return Completers.fromValues(getVersionsFor(dbType.getValue())).getCompletionProposals(context, input, value); } }); scope = factory.createSelectOne("scope", String.class).setLabel("Dependency Scope") .setDescription("The scope this database driver dependency should use when added to this project") .setRequired(true) .setDefaultValue("runtime") .setValueChoices(Arrays.asList("compile", "provided", "runtime", "test")); builder.add(dbType).add(version).add(scope); }
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); provider = factory.createSelectOne("provider", ScaffoldProvider.class).setLabel("Scaffold Type") .setRequired(true); webRoot = factory.createInput("webRoot", String.class).setLabel("Web Root Path").setDefaultValue("/") .setDescription( "The web root path where the scaffolding will be placed/accessible from the client browser (default '/')."); Imported<ScaffoldProvider> scaffoldProviders = SimpleContainer.getServices(getClass().getClassLoader(), ScaffoldProvider.class); if (!scaffoldProviders.isUnsatisfied() && !scaffoldProviders.isAmbiguous()) { provider.setDefaultValue(scaffoldProviders.get()); } provider.setValueChoices(scaffoldProviders); provider.setItemLabelConverter((source) -> source.getName()); builder.add(provider).add(webRoot); }
@Override public void initializeUI(final UIBuilder uiBuilder) throws Exception { InputComponentFactory factory = uiBuilder.getInputComponentFactory(); testFramework = factory.createSelectOne("testFramework", TestingFacet.class).setLabel("Test Framework"); version = factory.createSelectOne("version", String.class).setLabel("Test Framework Version"); uiBuilder.add(testFramework) .add(version); testFramework.setEnabled(true); testFramework.setItemLabelConverter(source -> buildFrameworkName(uiBuilder, source)); testFramework.setRequired(true); version.setRequired(true); version.setEnabled(() -> testFramework.hasValue()); version.setValueChoices(this::getAvailableVersions); version.setDefaultValue(this::getDefaultFrameworkVersion); }
@Override public void initializeUI(UIBuilder builder) throws Exception { boolean gui = builder.getUIContext().getProvider().isGUI(); InputComponentFactory factory = builder.getInputComponentFactory(); this.addon = factory.createSelectOne("addon", AddonDescriptor.class) .setLabel("Addon") .setRequired(true) .setNote(() -> addon.hasValue() ? addon.getValue().getDescription() : null) .setValueChoices(AddonDescriptorCatalogRegistry.INSTANCE.find("")) .setItemLabelConverter(gui ? AddonDescriptor::getName : AddonDescriptor::getId); builder.add(addon); }
@Override public void initializeUI(UIBuilder builder) throws Exception InputComponentFactory factory = builder.getInputComponentFactory(); jdbcUrl = factory.createInput("jdbcUrl", String.class).setLabel("JDBC URL") .setDescription("The jdbc url for the database tables").setRequired(true); .setLabel("Hibernate Dialect") .setDescription("The Hibernate dialect to use").setRequired(true); driverClass = factory.createSelectOne("driverClass", Class.class) .setLabel("Driver Class") .setDescription("The class name of the JDBC driver").setRequired(true); final boolean gui = builder.getUIContext().getProvider().isGUI(); hibernateDialect.setItemLabelConverter(new Converter<HibernateDialect, String>() return (gui) ? dialect.getDatabaseName() + " : " + dialect.getClassName() : dialect.getClassName(); }).addValueChangeListener(new ConnectionStaleValueChangeListener()); driverClass.setValueChoices(new LocateDriverClassNamesCallable()) .setItemLabelConverter(Class::getName) .setDefaultValue(new Callable<Class>() }).addValueChangeListener(new ConnectionStaleValueChangeListener());
@Override public Result execute(UIExecutionContext context) throws Exception Result result = Results.success("Project named '" + named.getValue() + "' has been created."); DirectoryResource targetDir = getTargetDirectory(); boolean overwriteDir = overwrite.getValue() || useTargetLocationRoot.getValue(); if (targetDir.mkdirs() || overwriteDir) ProjectType value = type.getValue(); ProjectFactory projectFactory = SimpleContainer.getServices(getClass().getClassLoader(), ProjectFactory.class) .get(); ProjectProvider buildSystemValue = buildSystem.getValue(); Project project = projectFactory.createProject(targetDir, buildSystemValue); if (project != null) PackagingFacet packagingFacet = project.getFacet(PackagingFacet.class); if (finalName.hasValue()) facetFactory.install(project, stack.getValue()); if (stack.isEnabled() && stack.hasValue()) StackFacet stackFacet = stack.getValue(); if (!(stackFacet instanceof NoStackFacet)) uiContext.setSelection(project.getRoot()); uiContext.getAttributeMap().put(Project.class, project);
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory inputFactory = builder.getInputComponentFactory(); .setLabel("Package Name") .setRequired(true) .setDescription("The package name where this type will be created"); targetPackage.getFacet(HintsFacet.class).setInputType(InputType.JAVA_PACKAGE_PICKER); targetPackage.setValueConverter(new PackageRootConverter(getProjectFactory(), builder)); targetPackage.setDefaultValue(calculateDefaultPackage(builder.getUIContext())); .setLabel("Archive Type") .setDescription("Sets type of default archive") .setValueChoices(ARCHIVE_TYPES); builder.add(targetPackage) .add(named) .add(asClient)
@Override public void initializeUI(UIBuilder builder) throws Exception connectionProfile = factory.createSelectOne("connectionProfile", String.class).setLabel("Connection Profile") .setDescription("Select the database connection profile you want to use"); connectionProfilePassword = factory.createInput("connectionProfilePassword", String.class) .setLabel("Connection Profile Password") connectionProfilePassword.getFacet(HintsFacet.class).setInputType(InputType.SECRET); Project project = getSelectedProject(builder.getUIContext()); targetPackage.setDefaultValue(calculateModelPackage(project)); ConnectionProfileManagerProvider managerProvider = SimpleContainer profileNames.add(""); profileNames.addAll(profiles.keySet()); connectionProfile.setValueChoices(profileNames); connectionProfile.setValue(""); connectionProfilePassword.setEnabled(() -> { String connectionProfileName = connectionProfile.getValue(); if (Strings.isNullOrEmpty(connectionProfileName)) return false; return !profiles.get(connectionProfileName).isSavePassword(); }); builder.add(targetPackage).add(connectionProfile).add(connectionProfilePassword);
@Override public Result execute(UIExecutionContext context) throws Exception { UIContext uiContext = context.getUIContext(); Project project = (Project) uiContext.getAttributeMap().get(Project.class); if (project == null) { project = getSelectedProject(context.getUIContext()); MetadataFacet metadataFacet = project.getFacet(MetadataFacet.class); File folder = project.getRoot().reify(DirectoryResource.class).getUnderlyingResourceObject(); String fabric8Deps = csbFabric8.toString(); String bootVersion = springBootVersion.getValue() + ".RELEASE"; return Results.success("Created new Spring Boot project in directory: " + folder.getName());
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); packageName = factory.createInput("packageName", String.class).setLabel("Package Name"); packageName.getFacet(HintsFacet.class).setInputType(InputType.JAVA_PACKAGE_PICKER); named = factory.createInput("named", String.class).setLabel("Test Class Name").setRequired(true); reuseProjectAddons = factory.createInput("reuseProjectAddons", Boolean.class) .setLabel("Use Addons from current project as dependencies (automatic discovery)") .setDescription( "This will create an empty @AddonDependencies and reuse the addons in the current project's pom.xml") .setDefaultValue(true); furnaceContainer = factory.createSelectOne("furnaceContainer", AddonId.class).setLabel("Furnace container") .setRequiredMessage("You must select one Furnace container"); addonDependencies = factory.createSelectMany("addonDependencies", AddonId.class).setLabel("Dependency addons") .setDescription("Addons this test depends upon"); configureAddonDependencies(); Project project = getSelectedProject(builder.getUIContext()); packageName.setDefaultValue(project.getFacet(JavaSourceFacet.class).getBasePackage()); builder.add(packageName).add(named).add(reuseProjectAddons).add(furnaceContainer).add(addonDependencies); }
@Override public Result execute(UIExecutionContext context) throws Exception UIContext uiContext = context.getUIContext(); UIOutput uiOutput = uiContext.getProvider().getOutput(); Project project = (Project) uiContext.getAttributeMap().get(Project.class); if (project == null) project = getSelectedProject(context.getUIContext()); String bootVersion = springBootVersion.getValue(); final Integer portValue = port.getValue(); if (portValue != 8080) { final Properties properties = new Properties(); final Boolean createStatic = createStaticContent.getValue(); if (createStatic) { final ResourcesFacet resourcesFacet = project.getFacet(ResourcesFacet.class); final FileResource<?> staticDir = resourcesFacet.getResource("static"); if (!staticDir.exists()) { return Results.success( "Created new Spring Boot project in directory: " + folder.getName());
@Override public Result execute(UIExecutionContext context) throws Exception { DatabaseType chosenDbType = dbType.getValue(); String chosenScope = scope.getValue(); String chosenVersion = version.getValue(); if (chosenVersion == null) { List<String> versions = getVersionsFor(chosenDbType); if (!versions.isEmpty()) { chosenVersion = versions.get(versions.size() - 1); } } if (chosenVersion == null) { return Results.fail("No version specified or found for " + chosenDbType.getDriverCoordinate()); } Project project = getSelectedProject(context); DependencyBuilder dependency = DependencyBuilder.create() .setCoordinate(chosenDbType.getDriverCoordinate()) .setVersion(chosenVersion) .setScopeType(chosenScope); DependencyFacet dependencyFacet = project.getFacet(DependencyFacet.class); dependencyFacet.addDirectDependency(dependency); return Results.success("JDBC Driver Dependency " + dependency + " installed"); }
@Override public void initializeUI(UIBuilder builder) throws Exception { final List<String> choices = getExistingModules(); // Workaround FORGE-1639 final boolean isGui = builder.getUIContext().getProvider().isGUI(); final String createNew = (isGui) ? CREATE_A_NEW_MODULE_GUI : CREATE_A_NEW_MODULE_CLI; choices.add(createNew); moduleSelect.setValueChoices(choices); moduleSelect.setDefaultValue(createNew); builder.add(moduleSelect); }
private void configureStack(InputComponentFactory factory, final UIContext context) { NoStackFacet defaultStack = SimpleContainer.getServices(getClass().getClassLoader(), NoStackFacet.class) .get(); Imported<StackFacet> stacks = SimpleContainer.getServices(getClass().getClassLoader(), StackFacet.class); final List<StackFacet> list = Lists.toList(stacks); Collections.sort(list, new StackFacetComparator()); stack = factory.createSelectOne("stack", StackFacet.class) .setLabel("Stack") .setDescription("The technology stack to be used in this project") .setValueChoices(() -> list.stream() .filter((stackFacet) -> (type.hasValue() || type.hasDefaultValue()) && type.getValue().supports(stackFacet.getStack())) .collect(Collectors.toSet())) // Enable stack field only if any stack is available .setEnabled(() -> Sets.toSet(stack.getValueChoices()).size() > 1) .setDefaultValue(defaultStack) .setItemLabelConverter((facet) -> context.getProvider().isGUI() ? facet.getStack().getName() : Commands.shellifyOptionValue(facet.getStack().getName())); }
InputComponentFactory factory = builder.getInputComponentFactory(); .setLabel("Database Catalog") .setDescription("The database catalog for which to generate entities.") .setDefaultValue(() -> { Iterator<String> it = databaseCatalog.getValueChoices().iterator(); return it.hasNext() ? it.next() : null; }) .setValueChoices(() -> catalogValueChoices); databaseCatalog.addValueChangeListener((event) -> updateValueChoices(context, event)); .setLabel("Database Schema") .setDescription("The database schema for which to generate entities.") .setDefaultValue(() -> { Iterator<String> it = databaseSchema.getValueChoices().iterator(); return it.hasNext() ? it.next() : null; }) .setValueChoices(() -> schemaValueChoices); databaseSchema.addValueChangeListener((event) -> updateValueChoices(context, event)); databaseCatalog.setValue(database.getCatalog()); databaseSchema.setValue(database.getSchema()); builder.add(databaseCatalog).add(databaseSchema).add(databaseTables);
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); .setLabel("Archetype") .setRequired(true).setItemLabelConverter(new Converter<Archetype, String>() { @Override public String convert(Archetype source) { }).setValueChoices(new Callable<Iterable<Archetype>>() { @Override public Iterable<Archetype> call() throws Exception { }).setDescription(new Callable<String>() { @Override public String call() throws Exception {
@Override public void initializeUI(UIBuilder builder) throws Exception InputComponentFactory inputFactory = builder.getInputComponentFactory(); UIContext uiContext = builder.getUIContext(); Project project = getSelectedProject(uiContext); targetClass = inputFactory.createSelectOne("targetClass", JavaResource.class); targetClass.setDescription("The class where the field will be created"); targetClass.setRequired(true); targetClass.getFacet(HintsFacet.class).setInputType(InputType.DROPDOWN); UISelection<Object> initialSelection = uiContext.getInitialSelection(); if (initialSelection.get() instanceof JavaResource) targetClass.setValue((JavaResource) initialSelection.get()); targetClass.setValueChoices(projectOperations.getProjectClasses(project)); fields.setEnabled(() -> targetClass.hasValue()); builder.add(targetClass).add(fields);
@Override public Result execute(UIExecutionContext context) throws Exception UIContext uiContext = context.getUIContext(); Project project = getSelectedProject(uiContext); JavaClassSource javaClass = Roaster.create(JavaClassSource.class).setName(named.getValue()) .setPackage(packageName.getValue()); AnnotationSource<JavaClassSource> addonDependenciesAnn = getDeployment.addAnnotation("AddonDependencies"); if (!reuseProjectAddons.getValue()) AddonId furnaceContainerId = furnaceContainer.getValue(); addAddonDependency(project, dependenciesAnnotationBody, furnaceContainerId); Iterator<AddonId> it = addonDependencies.getValue().iterator(); .setBody("Assert.fail(\"Not yet implemented\");").addAnnotation("Test"); JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class); JavaResource javaResource = facet.saveTestJavaSource(javaClass); uiContext.setSelection(javaResource); return Results.success("Test class " + javaClass.getQualifiedName() + " created");
@Override public Result execute(UIExecutionContext uiExecutionContext) throws Exception { Project project = getSelectedProject(uiExecutionContext.getUIContext()); facet.setFaceted(project); if (! facet.isInstalled()) { return Results.fail("The project is not a vert.x project, execute 'vertx-setup' before adding a verticle."); } String verticleType = type.getValue(); if (verticleType == null || verticleType.isEmpty()) { verticleType = detectVerticleTypeFromVerticleName(name.getValue()); System.out.println("Verticle Type (detected) : " + verticleType); } String packageName = null; String verticleName = name.getValue(); if (verticleType.equalsIgnoreCase("java")) { packageName = extractPackageName(name.getValue()); verticleName = extractJavaClassName(name.getValue()); } String fileName = verticles.createNewVerticle(facet.getFaceted(), verticleName, packageName, verticleType, main.getValue()); return Results.success("Verticle " + fileName + " created"); }