Examples with StringUtils.isEmpty org.apache.commons.lang3.StringUtils.isEmpty used on opensource projects

Example 26 with StringUtils.isEmpty

use of org.apache.commons.lang3.StringUtils.isEmpty in project CzechIdMng by bcvsolutions.

the class ConsoleRunner method run.

@Override
public void run(String... args) throws ParseException, IOException {
    // 
    // available commands
    Option optionVersion = Option.builder("v").longOpt("version").desc("print tool version.").build();
    Option optionHelp = Option.builder("h").longOpt("help").desc("print this message.").build();
    Option optionBuild = Option.builder().longOpt("build").desc("Build project or build product only (under current develop version in develop branch).\n" + "Maven 'install' command is used for product build, artifact will be installed into the local maven repository (=> usable as dependency for other module).\n" + "Use '-p' argument to project build.").build();
    Option optionRelease = Option.builder().longOpt("release").desc("Release product or module under '--release-version' argument. New development version will be set as '--develop-version' argument.").build();
    Option optionPublish = Option.builder().longOpt("publish").desc("Push prepared development, production and tags into origin repository.").build();
    Option optionReleaseAndPublish = Option.builder().longOpt("release-publish").desc("Release and publish shortcut as one command, taking the same arguments as '--release' command.").build();
    Option optionGetVersion = Option.builder().longOpt("get-version").desc("Get current product version (on the development branch or set '--development-branch' argument).").build();
    Option optionSetVersion = Option.builder().longOpt("set-version").desc("Set current product version (on the development branch - development branch can be changed only).").build();
    Option optionRevertVersion = Option.builder().longOpt("revert-version").desc("Changed versions by release command can be reverted if needed (before commit, usable after change product version only).").build();
    // 
    // product root
    Option optionRepositoryLocation = Option.builder("r").longOpt("repository-location").desc("Repository root folder - should contain all modules (<repository-location>/Realization/...).\n" + "Folder 'CzechIdMng' in the same folder as idm-tool.jar will be used as default for product.\n" + "Folder '<module>' in the same folder as idm-tool.jar will be used as default for module.\n").argName("path").hasArg().build();
    // 
    // optional arguments
    Option optionMavenHome = Option.builder().required(false).longOpt("maven-home").desc("Maven home directory.\n" + "MAVEN_HOME system property will be used as default.\n" + "Maven directory should contain command <maven-home>/bin/mvn.").argName("path").hasArg().build();
    Option optionNodeHome = Option.builder().required(false).longOpt("node-home").desc("Node home directory.\n" + "Global node instalation directory should contain executable node command.\n" + "Node and npm will be dowloaded and installed localy automaticaly into tool target folder (<target>/npm) by default otherwise.\n" + "For Windows <node-home>/node/node.exe.\n" + "For Linux <node-home>/node").argName("path").hasArg().build();
    Option optionDevelopBranch = Option.builder().required(false).longOpt("develop-branch").desc("Branch with feature - working branch.\n" + "'develop' will be used as default.").argName("branchName").hasArg().build();
    Option optionMasterBranch = Option.builder().required(false).longOpt("master-branch").desc("Branch for releases - where feature has to be merged after release.\n" + "'master' will be used as default.\n" + "'none' can be given - merge don't be executed (e.g. when some old hotfix branch is released).\n").argName("masterBranch").hasArg().build();
    Option optionReleaseVersion = Option.builder().required(false).longOpt("release-version").desc("Usable with '--release' command. Release will be create under this version.\n" + "Stable semantic version will be used as default (=> current no snapshot version).").argName("version").hasArg().build();
    Option optionDevelopVersion = Option.builder().required(false).longOpt("develop-version").desc("Usable with '--release' command. After release this version will be used in development branch.\n" + "Next minor snapshot semantic version will be used as default (=> current minor snapshot version + 1).\n" + "See major, minor, patch, hotfix argument if different version is needed.").argName("snapshot version").hasArg().build();
    Option optionUsername = Option.builder().required(false).longOpt("username").desc("Git username, if https repitory is used. When ssh repository is used, then passphrase for ssh key is needed only.").argName("git username").hasArg().build();
    Option optionPassword = Option.builder().required(false).longOpt("password").desc("If ssh repository is used / cloned, then passphrase for ssh key is needed only.\n" + "If https repository is used / cloned, then git username and password is needed.\n" + "If two-factor authentication is enabled for <username>, " + "then token has to be given (see git documentation, how to generate authentication token for developers).\n" + "If ssh key is used, then put passphrase for ssh key (It loads the known hosts and private keys from their " + "default locations (identity, id_rsa and id_dsa) in the user .ssh directory.).").argName("git password / token / ssh passphrase").hasArg().build();
    // 
    // module switch
    Option optionModule = Option.builder("m").required(false).longOpt("module").desc("Switch to module release / build.").argName("moduleId").hasArg().build();
    // 
    // project switch
    Option optionProject = Option.builder("p").required(false).longOpt("project").desc("Switch to project build.").build();
    // 
    // force commit / changes is not checked
    Option optionForce = Option.builder().required(false).longOpt("force").desc(String.format("Count of files changed by release command will not be checked. Limit of changed files is [%s].", ReleaseManager.MAX_RELEASE_CHANGES)).build();
    // major / minor / patch / hotfix
    Option optionMajor = Option.builder().required(false).longOpt("major").desc("Next develop version will be major, e.g. release 1.2.3 => develop 2.0.0-SNAPSHOT.").build();
    Option optionMinor = Option.builder().required(false).longOpt("minor").desc("Next develop version will be minor, e.g. release 1.2.3 => develop 1.3.0-SNAPSHOT. Will be applied as default.").build();
    Option optionPatch = Option.builder().required(false).longOpt("patch").desc("Next develop version will be patch, e.g. release 1.2.3 => develop 1.2.4-SNAPSHOT.").build();
    Option optionHotfix = Option.builder().required(false).longOpt("hotfix").desc("Next develop version will be hotfix, e.g. release 1.2.3 => develop 1.2.3.1-SNAPSHOT.").build();
    Option optionClean = Option.builder("c").required(false).longOpt("clean").desc("Clean up dowloaded frontend libraries in node_modules.").build();
    Option optionResolveDependencies = Option.builder().required(false).longOpt("resolve-dependencies").desc("Third party module dependencies will be resolved automatically (not resolved by default), when project is built.\n" + "Dependencies will not be resolved and included in build, if feature is not enabled => \n" + "all module dependencies has to be installed manually (prepared ~ copied in 'modules' folder).\n" + "Parameter is available for build a project only.").build();
    Option optionSkipFrontendBuild = Option.builder().required(false).longOpt("skip-frontend-build").desc("Frontend build will be skipped - product provided frontend will be used for build distribution artifacts.\n" + "Parameter is available for build a project only.").build();
    Options options = new Options();
    // 
    // available commands
    OptionGroup commandGroup = new OptionGroup();
    commandGroup.setRequired(true);
    commandGroup.addOption(optionVersion);
    commandGroup.addOption(optionHelp);
    commandGroup.addOption(optionBuild);
    commandGroup.addOption(optionRelease);
    commandGroup.addOption(optionPublish);
    commandGroup.addOption(optionReleaseAndPublish);
    commandGroup.addOption(optionSetVersion);
    commandGroup.addOption(optionGetVersion);
    commandGroup.addOption(optionRevertVersion);
    options.addOptionGroup(commandGroup);
    // 
    options.addOption(optionRepositoryLocation);
    options.addOption(optionMavenHome);
    options.addOption(optionNodeHome);
    options.addOption(optionDevelopBranch);
    options.addOption(optionMasterBranch);
    options.addOption(optionReleaseVersion);
    options.addOption(optionDevelopVersion);
    options.addOption(optionUsername);
    options.addOption(optionPassword);
    options.addOption(optionModule);
    options.addOption(optionProject);
    options.addOption(optionForce);
    options.addOption(optionMajor);
    options.addOption(optionMinor);
    options.addOption(optionPatch);
    options.addOption(optionHotfix);
    options.addOption(optionClean);
    options.addOption(optionResolveDependencies);
    options.addOption(optionSkipFrontendBuild);
    // 
    // parse arguments
    CommandLineParser parser = new DefaultParser();
    CommandLine commandLine = parser.parse(options, args, false);
    // log given arguments (for bug report, without password value)
    List<String> arguments = Arrays.stream(commandLine.getOptions()).map(option -> {
        if (!option.hasArg()) {
            return option.getLongOpt();
        }
        return String.format("%s=%s", option.getLongOpt(), // prevent to print password into logs
        option.getLongOpt().equals(optionPassword.getLongOpt()) ? GuardedString.SECRED_PROXY_STRING : option.getValue());
    }).collect(Collectors.toList());
    LOG.info("Running tool with arguments {}.", arguments);
    // 
    boolean projectBuild = commandLine.hasOption(optionProject.getLongOpt());
    boolean releaseModule = commandLine.hasOption(optionModule.getLongOpt());
    // 
    if (productReleaseManager == null) {
        // Product manager will be inited by default
        // manager's methods are used by console runner
        productReleaseManager = new ProductReleaseManager();
    }
    if (releaseModule && !projectBuild && moduleReleaseManager == null) {
        moduleReleaseManager = new ModuleReleaseManager(commandLine.getOptionValue(optionModule.getLongOpt()));
    }
    // 
    if (commandLine.hasOption(optionVersion.getLongOpt())) {
        System.out.println(String.format("v%s", getVersion()));
        return;
    }
    // 
    if (commandLine.hasOption(optionHelp.getLongOpt())) {
        printHelp(options);
        return;
    }
    // 
    String rootFolder = null;
    if (commandLine.hasOption(optionRepositoryLocation.getLongOpt())) {
        rootFolder = commandLine.getOptionValue(optionRepositoryLocation.getLongOpt());
    }
    // 
    String mavenHome = null;
    if (commandLine.hasOption(optionMavenHome.getLongOpt())) {
        mavenHome = commandLine.getOptionValue(optionMavenHome.getLongOpt());
    }
    String nodeHome = null;
    if (commandLine.hasOption(optionNodeHome.getLongOpt())) {
        nodeHome = commandLine.getOptionValue(optionNodeHome.getLongOpt());
    }
    // 
    if (projectBuild) {
        if (!commandLine.hasOption(optionBuild.getLongOpt())) {
            throw new BuildException("Build a project is supported only.");
        }
        boolean clean = commandLine.hasOption(optionClean.getLongOpt());
        boolean resolveDependencies = commandLine.hasOption(optionResolveDependencies.getLongOpt());
        boolean skipFrontendBuild = commandLine.hasOption(optionSkipFrontendBuild.getLongOpt());
        // 
        if (projectManager == null) {
            projectManager = new ProjectManager();
            projectManager.setMavenHome(mavenHome);
            projectManager.setNodeHome(nodeHome);
            projectManager.setResolveDependencies(resolveDependencies);
            projectManager.setSkipFrontendBuild(skipFrontendBuild);
            projectManager.init();
        }
        // /tool folder by default => project is in parent folder.
        projectManager.build(rootFolder == null ? "../" : rootFolder, clean);
        // 
        LOG.info("Complete!");
        return;
    }
    // 
    // Release
    ReleaseManager releaseManager = getReleaseManager(releaseModule);
    releaseManager.setMavenHome(mavenHome);
    // 
    if (commandLine.hasOption(optionRepositoryLocation.getLongOpt())) {
        releaseManager.setRepositoryRoot(commandLine.getOptionValue(optionRepositoryLocation.getLongOpt()));
    }
    if (commandLine.hasOption(optionDevelopBranch.getLongOpt())) {
        releaseManager.setDevelopBranch(commandLine.getOptionValue(optionDevelopBranch.getLongOpt()));
        LOG.debug("Using develop branch [{}].", releaseManager.getDevelopBranch());
    }
    if (commandLine.hasOption(optionMasterBranch.getLongOpt())) {
        String masterBranch = commandLine.getOptionValue(optionMasterBranch.getLongOpt());
        if (masterBranch.equals("none")) {
            masterBranch = null;
        }
        releaseManager.setMasterBranch(masterBranch);
        LOG.debug("Using production branch [{}].", releaseManager.getMasterBranch());
    }
    if (commandLine.hasOption(optionUsername.getLongOpt())) {
        String username = commandLine.getOptionValue(optionUsername.getLongOpt());
        releaseManager.setUsername(username);
        LOG.debug("Using git username [{}].", username);
    }
    // 
    GuardedString password = null;
    if (commandLine.hasOption(optionPassword.getLongOpt())) {
        password = new GuardedString(commandLine.getOptionValue(optionPassword.getLongOpt()));
    } else {
        // get password from file
        String externalPassword = getProperty(PROPERTY_PASSWORD);
        if (StringUtils.isNotEmpty(externalPassword)) {
            password = new GuardedString(externalPassword);
        } else if (commandLine.hasOption(optionRelease.getLongOpt()) || commandLine.hasOption(optionReleaseAndPublish.getLongOpt())) {
            // prompt when publish / release-publish command is used
            // creates a console object
            Console cnsl = System.console();
            if (cnsl != null) {
                System.out.println(optionPassword.getDescription());
                char[] pwd = cnsl.readPassword(String.format("%s: ", optionPassword.getArgName()));
                if (pwd != null && pwd.length > 0) {
                    password = new GuardedString(new String(pwd));
                }
            }
        }
    }
    if (password != null) {
        releaseManager.setPassword(password);
        LOG.info(String.format("Password (%s) is given.", optionPassword.getArgName()));
    }
    // 
    if (commandLine.hasOption(optionForce.getLongOpt())) {
        releaseManager.setForce(true);
        LOG.debug("Force argument was given, count of files changed by release command will not be checked.");
    }
    // before run - check props is set
    releaseManager.init();
    // 
    if (commandLine.hasOption(optionBuild.getLongOpt())) {
        String currentVersion = releaseManager.build();
        // 
        LOG.info("Product version [{}] successfully built and installed into local maven repository.", currentVersion);
    } else if (commandLine.hasOption(optionRelease.getLongOpt()) || commandLine.hasOption(optionReleaseAndPublish.getLongOpt())) {
        String releaseVersion = commandLine.getOptionValue(optionReleaseVersion.getLongOpt());
        String developVersion = commandLine.getOptionValue(optionDevelopVersion.getLongOpt());
        // current [snapshot] develop version
        String currentVersion = releaseManager.getCurrentVersion(null);
        // 
        if (StringUtils.isEmpty(developVersion)) {
            // prepare next development version by major / minor / patch / hotfix switch
            ReleaseManager.VersionType versionType = null;
            if (commandLine.hasOption(optionMajor.getLongOpt())) {
                versionType = ReleaseManager.VersionType.MAJOR;
            }
            if (commandLine.hasOption(optionMinor.getLongOpt())) {
                versionType = ReleaseManager.VersionType.MINOR;
            }
            if (commandLine.hasOption(optionPatch.getLongOpt())) {
                versionType = ReleaseManager.VersionType.PATCH;
            }
            if (commandLine.hasOption(optionHotfix.getLongOpt())) {
                versionType = ReleaseManager.VersionType.HOTFIX;
            }
            // 
            if (versionType == null) {
                // minor as default
                versionType = ReleaseManager.VersionType.MINOR;
            }
            developVersion = releaseManager.getNextSnapshotVersionNumber(StringUtils.isEmpty(releaseVersion) ? currentVersion : releaseVersion, versionType);
        }
        // 
        String releasedVersion = releaseManager.release(releaseVersion, developVersion);
        // 
        LOG.info("Product version released [{}]. New development version [{}].", releasedVersion, currentVersion);
        LOG.info("Branches [{}], [{}] and tag [{}] are prepared to push into origin (use --publish command).", releaseManager.getDevelopBranch(), releaseManager.getMasterBranch(), releasedVersion);
        // publish shortcut after release
        if (commandLine.hasOption(optionReleaseAndPublish.getLongOpt())) {
            releaseManager.publish();
            LOG.info("Branches [{}], [{}] and prepared tags pushed into origin.", releaseManager.getDevelopBranch(), releaseManager.getMasterBranch());
        }
    } else if (commandLine.hasOption(optionPublish.getLongOpt())) {
        // standalone publish
        releaseManager.publish();
        LOG.info("Branches [{}], [{}] and prepared tags pushed into origin.", releaseManager.getDevelopBranch(), releaseManager.getMasterBranch());
    } else if (commandLine.hasOption(optionRevertVersion.getLongOpt())) {
        LOG.info("Current product version [{}].", releaseManager.revertVersion());
    } else if (commandLine.hasOption(optionSetVersion.getLongOpt())) {
        String developVersion = commandLine.getOptionValue(optionDevelopVersion.getLongOpt());
        // 
        LOG.info("Current product version [{}].", releaseManager.setVersion(developVersion));
    } else if (commandLine.hasOption(optionGetVersion.getLongOpt())) {
        String branch = null;
        if (commandLine.hasOption(optionDevelopBranch.getLongOpt())) {
            branch = commandLine.getOptionValue(optionDevelopBranch.getLongOpt());
        }
        String currentVersion = releaseManager.getCurrentVersion(branch);
        // 
        LOG.info("Current product version [{}].", currentVersion);
    }
    // 
    LOG.info("Complete!");
}

Example 27 with StringUtils.isEmpty

use of org.apache.commons.lang3.StringUtils.isEmpty in project CzechIdMng by bcvsolutions.

the class ProjectManager method prepareBackendMavenProject.

private void prepareBackendMavenProject(File extractedProductFolder, String productVersion, List<File> installedJarModules, File targetFolder) throws Exception {
    File projectDescriptor = new File(targetFolder, "pom.xml");
    // 
    FileUtils.copyInputStreamToFile(new ClassPathResource("eu/bcvsolutions/idm/build/war-pom.xml").getInputStream(), projectDescriptor);
    if (installedJarModules.isEmpty()) {
        return;
    }
    if (!resolveDependencies) {
        LOG.warn("Resolve and install third party dependencies is disabled. " + "Dependencies will not be included in build - all module dependencies has to be installed manually (copied in 'modules' folder).");
        return;
    }
    // append registered backend modules as dependencies => third party module libraries will be resolved by maven automatically
    // 
    // parse xml and append modules as standard maven dependencies
    // TODO: can be refactored to maven model usage ...
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
    xmlMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, false);
    xmlMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    xmlMapper.configure(ToXmlGenerator.Feature.WRITE_XML_DECLARATION, true);
    xmlMapper.enable(SerializationFeature.INDENT_OUTPUT);
    // 
    ObjectNode buildPom = (ObjectNode) xmlMapper.readTree(projectDescriptor);
    // 
    // set parent to include CzechIdM dependencies
    ObjectNode parentWrapper = xmlMapper.createObjectNode();
    parentWrapper.put("groupId", ReleaseManager.MAVEN_GROUP_ID);
    parentWrapper.put("artifactId", "idm-parent");
    parentWrapper.put("version", productVersion);
    buildPom.set("parent", parentWrapper);
    // 
    // try install parent into local repository
    File parentProjectDescriptor = new File(String.format("%s/META-INF/maven/eu.bcvsolutions.idm/idm-parent/pom.xml", extractedProductFolder.getPath()));
    if (parentProjectDescriptor.exists()) {
        Model parentModel = mavenManager.installFile(parentProjectDescriptor, null);
        // 
        if (parentModel != null) {
            LOG.info("Product parent project [{}] installed into local maven repository for backend build.", parentProjectDescriptor.getPath());
        } else {
            LOG.warn("Product parent project [{}] not installed into local maven repository for backend build.", parentProjectDescriptor.getPath());
        }
    // FIXME: code bellow work partially only => "pom"s (e.g. idm-core) ~ sub parents are not available in war (same as parent above)
    // install all product (~private) dependencies into local repository
    // File warLibs = new File(String.format("%s/WEB-INF/lib", extractedProductFolder.getPath()));
    // for (File file : FileUtils.listFiles(warLibs, null, true)) {
    // if (file.getName().startsWith("idm-")) {
    // // extract product module and get pom file
    // File extractedModuleFolder = new File(targetFolder, FilenameUtils.removeExtension(file.getName()));
    // ZipUtils.extract(file, extractedModuleFolder.getPath());
    // Model model = mavenManager.getModel(extractedModuleFolder);
    // mavenManager.installFile(model.getPomFile(), file);
    // }
    // }
    }
    // 
    // 
    // find pom.xml modules in jar
    Map<String, String> resolvedModules = new HashMap<>(ProductReleaseManager.BACKEND_MODULES.length + installedJarModules.size());
    // add all product modules as resolved => will not be registered repetitivelly
    Arrays.stream(ProductReleaseManager.BACKEND_MODULES).map(backendModule -> {
        // transform path to module to artefact id by conventions
        String productArtefactId = backendModule;
        int slashPosition = productArtefactId.lastIndexOf('/');
        if (slashPosition > 0) {
            // not at start => >
            productArtefactId = productArtefactId.substring(slashPosition + 1);
        }
        productArtefactId = String.format("idm-%s", productArtefactId);
        // 
        return getSimpleModuleId(ReleaseManager.MAVEN_GROUP_ID, productArtefactId);
    }).forEach(productModuleId -> {
        resolvedModules.put(productModuleId, "");
    });
    // 
    Map<String, Model> modules = new LinkedHashMap<>();
    for (File installedJarModule : installedJarModules) {
        // extract and install maven module
        File extractedModuleFolder = new File(targetFolder, FilenameUtils.removeExtension(installedJarModule.getName()));
        if (extractedModuleFolder.exists()) {
            Model model = mavenManager.getModel(extractedModuleFolder);
            if (model != null) {
                modules.put(model.getId(), model);
            // 
            // FIXME: code bellow work partially only => "pom"s (e.g. idm-crt, idm-scim) ~ sub parents are not available in war (same as parent above)
            // mavenManager.installFile(model.getPomFile(), installedJarModule);
            }
        }
    }
    // a module doesn't contain pom descriptor
    if (modules.isEmpty()) {
        return;
    }
    // append installed modules as dependencies
    int registeredDependencies = 0;
    ArrayNode dependencies = xmlMapper.createArrayNode();
    for (Model module : modules.values()) {
        String groupId = mavenManager.getGroupId(module);
        String artifactId = module.getArtifactId();
        String simpleModuleId = getSimpleModuleId(groupId, artifactId);
        String version = mavenManager.getVersion(module);
        // simple check dependency is fully specified
        if (StringUtils.isEmpty(groupId) || StringUtils.isEmpty(artifactId) || StringUtils.isEmpty(version)) {
            throw new BuildException(String.format("Backend module artefact [%s:%s:%s] cannot " + "be registered as maven dependency for backend build, " + "required artefact properties are not defined.", groupId, artifactId, version));
        }
        // skip already resolved modules
        if (resolvedModules.containsKey(simpleModuleId)) {
            String checkVersion = resolvedModules.get(simpleModuleId);
            if (StringUtils.isEmpty(checkVersion)) {
                LOG.debug("Module [{}] is already registered, skipping.", simpleModuleId);
                continue;
            }
            if (checkVersion.equals(version)) {
                LOG.debug("Module [{}] is already registered with the same version [{}], skipping.", simpleModuleId, checkVersion);
                continue;
            }
            throw new BuildException(String.format("Backend module artefact [%s:%s:%s] cannot " + "be registered as maven dependency for backend build, " + "the same library is already registeres with version [%s]. " + "Update module dependencies or copy third party library to modules folder to ensure concrete version is used.", groupId, artifactId, version, checkVersion));
        }
        // 
        // create target dependency
        ObjectNode targetDependency = xmlMapper.createObjectNode();
        targetDependency.put("groupId", groupId);
        targetDependency.put("artifactId", artifactId);
        targetDependency.put("version", version);
        dependencies.add(targetDependency);
        // 
        registeredDependencies++;
        resolvedModules.put(simpleModuleId, version);
        LOG.info("Backend module artefact [{}:{}:{}] registered as maven dependency for backend build.", groupId, artifactId, version);
    }
    // no additional 3th party dependencies are resolved
    if (registeredDependencies == 0) {
        return;
    }
    // 
    // add core module as dependency => all product librarioes will be resolved at first
    ObjectNode coreDependency = xmlMapper.createObjectNode();
    coreDependency.put("groupId", ReleaseManager.MAVEN_GROUP_ID);
    coreDependency.put("artifactId", "idm-core-impl");
    coreDependency.put("version", productVersion);
    // the first dependency
    dependencies.insert(0, coreDependency);
    // 
    ObjectNode dependenciesWrapper = xmlMapper.createObjectNode();
    dependenciesWrapper.set("dependency", dependencies);
    buildPom.set("dependencies", dependenciesWrapper);
    // 
    try (FileOutputStream outputStream = new FileOutputStream(projectDescriptor)) {
        JsonGenerator jGenerator = xmlMapper.getFactory().createGenerator(outputStream, JsonEncoding.UTF8);
        xmlMapper.writerWithDefaultPrettyPrinter().withRootName("project").writeValue(jGenerator, buildPom);
        jGenerator.close();
    }
    LOG.info("Backend maven project [{}] for build prepared. Modules [{}] registered as dependency.", projectDescriptor.getPath(), registeredDependencies);
}

Example 28 with StringUtils.isEmpty

use of org.apache.commons.lang3.StringUtils.isEmpty in project CzechIdMng by bcvsolutions.

the class ReportGenerateEndSendNotificationProcessor method process.

@Override
public EventResult<RptReportDto> process(EntityEvent<RptReportDto> event) {
    RptReportDto report = event.getContent();
    UUID creatorId = report.getCreatorId();
    // 
    if (report.getResult() == null) {
        return new DefaultEventResult<>(event, this);
    }
    // 
    boolean success = report.getResult().getState() == OperationState.EXECUTED;
    List<IdmIdentityDto> recipients = new ArrayList<>(1);
    if (creatorId != null) {
        // default recipient is logged user, but can be overriden by topic configuration
        recipients.add(identityService.get(creatorId));
    }
    // 
    Builder message = new IdmMessageDto.Builder(success ? NotificationLevel.SUCCESS : NotificationLevel.WARNING).addParameter("url", configurationService.getFrontendUrl(String.format("rpt/reports?id=%s", report.getId()))).addParameter("report", report).setModel(new DefaultResultModel(success ? RptResultCode.REPORT_GENERATE_SUCCESS : RptResultCode.REPORT_GENERATE_FAILED, ImmutableMap.of("reportName", report.getName())));
    // 
    if (success) {
        // rendered reports as email attachments
        List<String> rendererNames = reportManager.getRenderers(report.getExecutorName()).stream().filter(// default json will be ignored
        renderer -> !renderer.getName().equals(DefaultJsonRenderer.RENDERER_NAME)).map(RptReportRendererDto::getName).collect(Collectors.toList());
        List<IdmAttachmentDto> attachments = attachmentManager.getAttachments(report, null).stream().filter(attachment -> StringUtils.isNotEmpty(attachment.getAttachmentType()) && rendererNames.contains(attachment.getAttachmentType())).collect(Collectors.toList());
        // 
        // load topic configuration
        String topic = null;
        IdmFormDto filter = report.getFilter();
        if (filter != null) {
            IdmFormInstanceDto formInstance = new IdmFormInstanceDto(report, formService.getDefinition(filter.getFormDefinition()), report.getFilter());
            Serializable configuredTopic = formInstance.toSinglePersistentValue(AbstractReportExecutor.PROPERTY_TOPIC_REPORT_GENERATE_SUCCESS);
            if (configuredTopic != null) {
                topic = configuredTopic.toString();
            }
        } else {
            // Backward compatibility => reports generated from code (without UI form + filter).
            topic = RptModuleDescriptor.TOPIC_REPORT_GENERATE_SUCCESS;
        }
        // topic is optional => notification will not be sent, if default value is cleared / not given.
        if (StringUtils.isEmpty(topic)) {
            LOG.debug("Report result will be not sent, topic is not configured [{}].");
        } else {
            LOG.debug("Report result will be sent to topic [{}]", topic);
            // 
            notificationManager.send(topic, message.build(), null, recipients, attachments);
        }
    } else if (creatorId != null) {
        notificationManager.send(RptModuleDescriptor.TOPIC_REPORT_GENERATE_FAILED, message.build(), identityService.get(creatorId));
    }
    // 
    return new DefaultEventResult<>(event, this);
}

Example 29 with StringUtils.isEmpty

use of org.apache.commons.lang3.StringUtils.isEmpty in project knime-core by knime.

the class TableView method registerFindAction.

/**
 * Creates and registers the "Find ..." action on this component. Multiple invocation of this method have no effect
 * (lazy initialization).
 *
 * @return The non-null action representing the find task.
 * @see #registerNavigationActions()
 */
public TableAction registerFindAction() {
    if (m_findAction == null) {
        String name = "Find...";
        KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_F, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask());
        TableAction action = new TableAction(stroke, name) {

            @Override
            public void actionPerformed(final ActionEvent e) {
                if (!hasData()) {
                    return;
                }
                if (m_searchPosition == null) {
                    initNewSearchPostion(new SearchOptions(true, true, true));
                }
                m_searchPosition.reset();
                SearchOptions searchOptions = m_searchPosition.getSearchOptions();
                boolean isSearchRowID = searchOptions.isSearchRowID();
                boolean isSearchColumnName = searchOptions.isSearchColumnName();
                boolean isSearchData = searchOptions.isSearchData();
                JCheckBox rowKeyBox = new JCheckBox("Search RowID Column", isSearchRowID);
                JCheckBox colNameBox = new JCheckBox("Search Column Names", isSearchColumnName);
                JCheckBox dataBox = new JCheckBox("Search Data", isSearchData);
                JCheckBox[] asArray = new JCheckBox[] { rowKeyBox, colNameBox, dataBox };
                rowKeyBox.addItemListener(new AtLeastOnButtonSelectedItemListener(dataBox, asArray));
                colNameBox.addItemListener(new AtLeastOnButtonSelectedItemListener(rowKeyBox, asArray));
                dataBox.addItemListener(new AtLeastOnButtonSelectedItemListener(rowKeyBox, asArray));
                JCheckBox caseSensitiveBox = new JCheckBox("Case sensitive", m_searchString.map(i -> !i.isIgnoreCase()).orElse(false));
                JCheckBox regexBox = new JCheckBox("Regular Expression", m_searchString.map(i -> i.isRegex()).orElse(false));
                JPanel panel = new JPanel(new BorderLayout());
                panel.add(new JLabel("Options: "), BorderLayout.NORTH);
                JPanel centerPanel = new JPanel(new GridLayout(0, 1));
                centerPanel.add(rowKeyBox);
                centerPanel.add(colNameBox);
                centerPanel.add(dataBox);
                centerPanel.add(new JLabel());
                centerPanel.add(caseSensitiveBox);
                centerPanel.add(regexBox);
                centerPanel.add(new JLabel());
                panel.add(centerPanel, BorderLayout.CENTER);
                panel.add(new JLabel("    "), BorderLayout.WEST);
                panel.add(new JLabel("Find String: "), BorderLayout.SOUTH);
                SearchString newSearchString;
                while (true) {
                    String in = (String) JOptionPane.showInputDialog(TableView.this, panel, "Search", JOptionPane.QUESTION_MESSAGE, null, null, m_searchString.map(s -> s.getSearchString()).orElse(""));
                    if (StringUtils.isEmpty(in)) {
                        // canceled
                        return;
                    }
                    try {
                        newSearchString = new SearchString(in, !caseSensitiveBox.isSelected(), regexBox.isSelected());
                        break;
                    } catch (PatternSyntaxException pse) {
                        JOptionPane.showMessageDialog(TableView.this, pse.getMessage(), "Invalid regular expression", JOptionPane.ERROR_MESSAGE);
                    }
                }
                searchOptions = new SearchOptions(rowKeyBox.isSelected(), colNameBox.isSelected(), dataBox.isSelected());
                find(newSearchString, searchOptions);
            }
        };
        registerAction(action);
        m_findAction = action;
    }
    return m_findAction;
}

Example 30 with StringUtils.isEmpty

use of org.apache.commons.lang3.StringUtils.isEmpty in project kie-wb-common by kiegroup.

the class BackendFormRenderingContextManagerImpl method registerContext.

@Override
public BackendFormRenderingContext registerContext(FormDefinition rootForm, Map<String, Object> formData, ClassLoader classLoader, Map<String, String> params, FormDefinition... nestedForms) {
    MapModelRenderingContext clientRenderingContext = new MapModelRenderingContext(String.valueOf(System.currentTimeMillis()));
    clientRenderingContext.setRootForm(rootForm);
    Arrays.stream(nestedForms).forEach(form -> clientRenderingContext.getAvailableForms().put(form.getId(), form));
    BackendFormRenderingContextImpl context = new BackendFormRenderingContextImpl(System.currentTimeMillis(), clientRenderingContext, formData, classLoader, params);
    Map<String, Object> clientFormData = new HashMap<>();
    rootForm.getFields().stream().filter(fieldDefinition -> !StringUtils.isEmpty(fieldDefinition.getBinding())).forEach(fieldDefinition -> {
        Object value = formData.get(fieldDefinition.getBinding());
        FieldValueMarshaller marshaller = registry.getMarshaller(fieldDefinition);
        if (marshaller != null) {
            marshaller.init(value, fieldDefinition, rootForm, context);
            context.getRootFormMarshallers().put(fieldDefinition.getBinding(), marshaller);
            value = marshaller.toFlatValue();
        }
        clientFormData.put(fieldDefinition.getBinding(), value);
    });
    constraintsExtractor.readModelConstraints(clientRenderingContext, classLoader);
    clientRenderingContext.setModel(clientFormData);
    contexts.put(context.getTimestamp(), context);
    return context;
}