Refine search
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); named = factory.createInput("named", String.class).setLabel("Archetype catalog Name") .setDescription("The archetype catalog name to be used"); builder.add(named); }
@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); }
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); furnaceContainer = factory.createSelectOne("furnaceContainer", AddonId.class).setLabel("Furnace container") .setRequired(true).setRequiredMessage("You must select one Furnace container"); splitProjects = factory.createInput("splitProjects", Boolean.class) .setLabel("Create API, Impl, SPI, Tests, and Addon modules"); addons = factory.createSelectMany("addons", AddonId.class).setLabel("Depend on these addons"); configureAddonDependencies(); builder.add(furnaceContainer).add(splitProjects).add(addons); }
InputComponentFactory factory = builder.getInputComponentFactory(); targetPackage = factory.createInput("targetPackage", String.class).setLabel("Package Name") .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)); final JavaSourceFacet javaSourceFacet = project.getFacet(JavaSourceFacet.class); named.addValidator((context) -> { if (project.hasFacet(JavaSourceFacet.class)) targetPackage.setCompleter(Completers.fromValues(packageNames)); targetPackage.setDefaultValue(calculateDefaultPackage(builder.getUIContext())); builder.add(targetPackage).add(named); if (extendsType.isEnabled()) .collect(Collectors.toList()); extendsType.setCompleter(Completers.fromValues(extendsList)); builder.add(extendsType); .collect(Collectors.toList()); implementsType.setCompleter(Completers.fromValues(implementsList)); builder.add(implementsType); builder.add(overwrite);
@Override public void initializeUI(UIBuilder builder) throws Exception InputComponentFactory factory = builder.getInputComponentFactory(); targetPackage = factory.createInput("targetPackage", String.class).setLabel("Target package") .setDescription("The name of the target package in which to generate the entities").setRequired(true); targetPackage.getFacet(HintsFacet.class).setInputType(InputType.JAVA_PACKAGE_PICKER); targetPackage.setValueConverter(new PackageRootConverter(getProjectFactory(), builder)); 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 .getServices(getClass().getClassLoader(), ConnectionProfileManagerProvider.class).get(); ConnectionProfileManager manager = managerProvider.getConnectionProfileManager(); profiles = manager.loadConnectionProfiles(); return !profiles.get(connectionProfileName).isSavePassword(); }); builder.add(targetPackage).add(connectionProfile).add(connectionProfilePassword);
@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(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) .add(mainClass) .add(archiveType);
@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); userName = factory.createInput("userName", String.class).setLabel("User Name") .setDescription("The user name for the database connection").setRequired(true); .setDescription("Should the connection password be saved?"); hibernateDialect = factory.createSelectOne("hibernateDialect", HibernateDialect.class) .setLabel("Hibernate Dialect") .setDescription("The Hibernate dialect to use").setRequired(true); driverLocation = factory.createInput("driverLocation", FileResource.class) .setLabel("Driver Location") userName.addValueChangeListener(new ConnectionStaleValueChangeListener()); userPassword.addValueChangeListener(new ConnectionStaleValueChangeListener()); final boolean gui = builder.getUIContext().getProvider().isGUI(); hibernateDialect.setItemLabelConverter(new Converter<HibernateDialect, String>()
@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); }
public void initializeUI(final UIBuilder builder) throws Exception InputComponentFactory factory = builder.getInputComponentFactory(); pageTemplate = factory.createInput("pageTemplate", FileResource.class).setLabel("Facelet Template") .setDescription("The Facelets template file to be used in the generated facelets."); targets = factory.createSelectMany("targets", JavaClassSource.class).setLabel("Targets").setRequired(true) .setDescription("The JPA entities to use as the basis for generating the scaffold."); useCustomTemplate = factory.createInput("useCustomTemplate", Boolean.class) .setLabel("Use custom template when generating pages").setDescription( "Enabling this will allow the generated scaffold to use the specified Facelet template."); generateEqualsAndHashCode = factory.createInput("generateEqualsAndHashCode", Boolean.class) UIContext uiContext = builder.getUIContext(); JPAFacet<PersistenceCommonDescriptor> persistenceFacet = project.getFacet(JPAFacet.class); targets.setValueChoices(persistenceFacet.getAllEntities()); targets.setItemLabelConverter(source -> source.getQualifiedName()); builder.add(targets); if (uiContext.getProvider().isGUI()) useCustomTemplate.setDefaultValue(false); pageTemplate.setEnabled(() -> useCustomTemplate.getValue()); builder.add(useCustomTemplate).add(pageTemplate); builder.add(pageTemplate); builder.add(generateEqualsAndHashCode);
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); coordinate = factory.createInput("coordinate", String.class).setLabel("Coordinate") .setDescription("The addon's \"groupId:artifactId,version\" coordinate") .setNote("The addon's \"groupId:artifactId,version\" coordinate").setRequired(true); ProjectFactory projectFactory = SimpleContainer.getServices(getClass().getClassLoader(), ProjectFactory.class) .get(); Project project = Projects.getSelectedProject(projectFactory, builder.getUIContext()); if (project != null) { MetadataFacet facet = project.getFacet(MetadataFacet.class); Coordinate c = facet.getOutputDependency().getCoordinate(); coordinate.setDefaultValue(AddonId.from(c.getGroupId() + ":" + c.getArtifactId(), c.getVersion()) .toCoordinates()); } List<String> defaultCoords = Arrays.asList(CoordinateUtils.FORGE_ADDON_GROUP_ID); coordinate.setCompleter((UIContext context, InputComponent<?, String> input, String value) -> { Iterable<String> items = Collections.emptySet(); if (Strings.isNullOrEmpty(value)) { items = defaultCoords; } return items; }); builder.add(coordinate); }
@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(); 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 void initializeUI(UIBuilder builder) throws Exception final Furnace furnace = SimpleContainer.getFurnace(getClass().getClassLoader()); InputComponentFactory factory = builder.getInputComponentFactory(); named = factory.createInput("named", String.class).setLabel("Name") .setDescription("The addon's \"groupId:artifactId\" name").setRequired(true); named.setCompleter(new UICompleter<String>() builder.add(named);
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); dependencies = factory.createSelectMany("dependencies", VertxDependency.class) .setLabel("Dependency List") .setDescription("Dependency list"); UIContext uiContext = builder.getUIContext(); if (uiContext.getProvider().isGUI()) { dependencies.setItemLabelConverter(VertxDependency::getName); } else { dependencies.setItemLabelConverter(VertxDependency::getArtifactId); } Project project = Projects.getSelectedProject(getProjectFactory(), uiContext); final Collection<VertxDependency> deps; if (project != null && project.hasFacet(VertxMavenFacet.class)) { deps = project.getFacet(VertxMavenFacet.class).getNotUsedDependencies(); } else { deps = VertxMavenFacet.getAllDependencies(); } dependencies.setValueChoices(deps); builder.add(dependencies); }
@Override public void initializeUI(UIBuilder builder) throws Exception { Project project = getSelectedProject(builder.getUIContext()); InputComponentFactory factory = builder.getInputComponentFactory(); arguments = factory.createSelectMany("arguments", 'd', Dependency.class).setLabel("Coordinates").setRequired(true) .setDescription( "The coordinates of the arguments to be removed [groupId :artifactId {:version :scope :packaging}]"); removeManaged = factory.createInput("removeManaged", 'r', Boolean.class).setLabel("Remove managed arguments") .setDefaultValue(false) .setDescription("Also remove any related managed arguments from the current project, if possible."); arguments.setValueChoices(project.getFacet(DependencyFacet.class).getDependencies()); builder.add(arguments).add(removeManaged); }
@Override public void initializeUI(final UIBuilder builder) throws Exception { super.initializeUI(builder); Project project = getSelectedProject(builder.getUIContext()); JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class); targetPackage.setCompleter(new TestPackageNameCompleter(facet)); targetPackage.addValidator(new PackageNameValidator()); targetPackage.setDefaultValue("io.fabric8.itests"); className.addValidator(new ClassNameValidator(false)); className.setDefaultValue(new Callable<String>() { @Override public String call() throws Exception { return "KubernetesIT"; } }); builder.add(targetPackage).add(className).add(profile).add(integrationTestWildcard).add(itestPlugin); }
@Override public void initializeUI(UIBuilder builder) throws Exception { InputComponentFactory factory = builder.getInputComponentFactory(); .setLabel("Archetype") .setRequired(true).setItemLabelConverter(new Converter<Archetype, String>() { @Override builder.add(archetype);
@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()); Furnace furnace = SimpleContainer.getFurnace(this.getClass().getClassLoader()); ProjectOperations projectOperations = furnace.getAddonRegistry().getServices(ProjectOperations.class).get(); targetClass.setValueChoices(projectOperations.getProjectClasses(project)); fields.setEnabled(() -> targetClass.hasValue()); builder.add(targetClass).add(fields);
@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); }