Java Code Examples for org.apache.commons.lang3.StringUtils#containsWhitespace()

/**
 * Validates form data in repository triggers tab
 *
 * @param settings - to be validated.
 * @param errors - callback for reporting validation errors.
 * @throws IOException if JSON parsing error occurs
 */
private void validaterepositoryTriggersTab(final Settings settings, final SettingsValidationErrors errors) throws IOException {
    final String repositoryTriggersJson = settings.getString(Field.REPOSITORY_TRIGGERS_JSON, StringUtils.EMPTY);
    final ObjectMapper mapper = new ObjectMapper();
    final Map<String, Trigger> triggerMap = mapper.readValue(repositoryTriggersJson, mapper.getTypeFactory().constructParametricType(HashMap.class, String.class, Trigger.class));
    for (final Map.Entry<String, Trigger> triggerEntry : triggerMap.entrySet()) {
        final Trigger trigger = triggerEntry.getValue();
        if (StringUtils.isBlank(trigger.getTarget())) {
            errors.addFieldError(triggerEntry.getKey(), this.i18n.getText("error.string.empty"));
        } else if (StringUtils.containsWhitespace(trigger.getTarget())) {
            errors.addFieldError(triggerEntry.getKey(), this.i18n.getText("error.string.contains.whitespace"));
        }
        try {
            final Pattern pattern = Pattern.compile(triggerEntry.getValue().getRegex(), Pattern.CASE_INSENSITIVE);
            final Matcher matcher = pattern.matcher(BRANCH_TEST_STRING);
            if (matcher.groupCount() != 1) {
                errors.addFieldError(triggerEntry.getKey(), this.i18n.getText("error.regex.needs.capturing"));
            }
        } catch (final PatternSyntaxException e) {
            errors.addFieldError(triggerEntry.getKey(), e.getLocalizedMessage());
        }
    }
}
 

/**
 * Updates the table settings (read and write capacities).
 * @param appid name of the {@link com.erudika.para.core.App}
 * @param readCapacity read capacity
 * @param writeCapacity write capacity
 * @return true if updated
 */
public static boolean updateTable(String appid, long readCapacity, long writeCapacity) {
	if (StringUtils.isBlank(appid) || StringUtils.containsWhitespace(appid)) {
		return false;
	}
	String table = getTableNameForAppid(appid);
	try {
		// AWS throws an exception if the new read/write capacity values are the same as the current ones
		getClient().updateTable(b -> b.tableName(table).
				provisionedThroughput(b1 -> b1.readCapacityUnits(readCapacity).writeCapacityUnits(writeCapacity)));
		return true;
	} catch (Exception e) {
		logger.error("Could not update table '{}' - table is not active or no change to capacity: {}",
				table, e.getMessage());
	}
	return false;
}
 

private static void createArguments(Commandline command, Object... arguments) {
	for (Object argument : arguments) {
		
		if (argument == null)
			continue;
		
		if (argument.getClass().isArray()) {
			createArguments(command, (Object[])argument);
			continue;
		}
		
		if (argument instanceof File) {
			
			File argFile = (File) argument;
			if (argFile.getName().contains("*")) {
				argument = org.codehaus.plexus.util.StringUtils.quoteAndEscape(argFile.getParentFile().getAbsolutePath(), '\"') + File.separator + argFile.getName();
			} else {
				argument = ((File) argument).getAbsolutePath();
			}
			
		}

		String arg = argument.toString().trim(); 
		if (!arg.contains("\"") && StringUtils.containsWhitespace(arg)) {
			arg = org.codehaus.plexus.util.StringUtils.quoteAndEscape(arg, '\"');
		}
		command.createArg().setValue(arg);

	}
}
 

private boolean validateNoSpaces() {
   if (StringUtils.containsWhitespace(firstPass.getText().toString())) {
      setError(firstPassLayout, firstPass, R.string.account_registration_password_contains_space_error_msg);
      return false;
   }

   return true;
}
 

public static Matcher<String> hasNoSpace() {
    return new BaseMatcher<String>() {
        @Override
        public boolean matches(final Object item) {
            return !StringUtils.containsWhitespace(item.toString());
        }
        @Override
        public void describeTo(final Description description) {
            description.appendText("Should not contain space");
        }
    };
}
 

public static String escapeForStandardTokenizer(String search) {
  if (search == null) {
    return null;
  }
  String newSearch = escapeQueryChars(search.trim());
  if (StringUtils.containsWhitespace(newSearch)) {
    newSearch = "\"" + newSearch + "\"";
  }

  return newSearch;
}
 

/**
 * Creates a table in AWS DynamoDB.
 * @param appid name of the {@link com.erudika.para.core.App}
 * @param readCapacity read capacity
 * @param writeCapacity write capacity
 * @return true if created
 */
public static boolean createTable(String appid, long readCapacity, long writeCapacity) {
	if (StringUtils.isBlank(appid)) {
		return false;
	} else if (StringUtils.containsWhitespace(appid)) {
		logger.warn("DynamoDB table name contains whitespace. The name '{}' is invalid.", appid);
		return false;
	} else if (existsTable(appid)) {
		logger.warn("DynamoDB table '{}' already exists.", appid);
		return false;
	}
	try {
		String table = getTableNameForAppid(appid);
		CreateTableResponse tbl = getClient().createTable(b -> b.tableName(table).
				sseSpecification(b2 -> b2.enabled(ENCRYPTION_AT_REST_ENABLED)).
				provisionedThroughput(b4 -> b4.readCapacityUnits(readCapacity).writeCapacityUnits(writeCapacity)).
				keySchema(KeySchemaElement.builder().attributeName(Config._KEY).keyType(KeyType.HASH).build()).
				attributeDefinitions(AttributeDefinition.builder().
						attributeName(Config._KEY).attributeType(ScalarAttributeType.S).build()));

		logger.info("Waiting for DynamoDB table to become ACTIVE...");
		waitForActive(table);
		// NOT IMPLEMENTED in SDK v2:
		// String status = tbl.waitForActive().getTableStatus();
		logger.info("Created DynamoDB table '{}', status {}.", table, tbl.tableDescription().tableStatus());
	} catch (Exception e) {
		logger.error(null, e);
		return false;
	}
	return true;
}
 

/**
 * Creates a table in AWS DynamoDB which will be shared between apps.
 * @param readCapacity read capacity
 * @param writeCapacity write capacity
 * @return true if created
 */
public static boolean createSharedTable(long readCapacity, long writeCapacity) {
	if (StringUtils.isBlank(SHARED_TABLE) || StringUtils.containsWhitespace(SHARED_TABLE) ||
			existsTable(SHARED_TABLE)) {
		return false;
	}
	String table = getTableNameForAppid(SHARED_TABLE);
	try {
		GlobalSecondaryIndex secIndex = GlobalSecondaryIndex.builder().
				indexName(getSharedIndexName()).
				provisionedThroughput(b -> b.readCapacityUnits(1L).writeCapacityUnits(1L)).
				projection(Projection.builder().projectionType(ProjectionType.ALL).build()).
				keySchema(KeySchemaElement.builder().attributeName(Config._APPID).keyType(KeyType.HASH).build(),
						KeySchemaElement.builder().attributeName(Config._ID).keyType(KeyType.RANGE).build()).build();

		AttributeDefinition[] attributes = new AttributeDefinition[] {
			AttributeDefinition.builder().attributeName(Config._KEY).attributeType(ScalarAttributeType.S).build(),
			AttributeDefinition.builder().attributeName(Config._APPID).attributeType(ScalarAttributeType.S).build(),
			AttributeDefinition.builder().attributeName(Config._ID).attributeType(ScalarAttributeType.S).build()
		};

		CreateTableResponse tbl = getClient().createTable(b -> b.tableName(table).
				keySchema(KeySchemaElement.builder().attributeName(Config._KEY).keyType(KeyType.HASH).build()).
				sseSpecification(b2 -> b2.enabled(ENCRYPTION_AT_REST_ENABLED)).
				attributeDefinitions(attributes).
				globalSecondaryIndexes(secIndex).
				provisionedThroughput(b6 -> b6.readCapacityUnits(readCapacity).writeCapacityUnits(writeCapacity)));
		logger.info("Waiting for DynamoDB table to become ACTIVE...");
		waitForActive(table);
		logger.info("Created shared table '{}', status {}.", table, tbl.tableDescription().tableStatus());
	} catch (Exception e) {
		logger.error(null, e);
		return false;
	}
	return true;
}
 

/**
 * Generates and returns a short name based on the given display name.<br>
 * The generated short name will be returned only if it was not already used.<br>
 * The input parameter will be clean from "evil" characters such as punctuation and accents
 *
 * 1) if the {@code displayName} is a one-word name, then no further calculation will be done and it will be returned as it is, to lower case
 * 2) the {@code displayName} will be split by word and transformed to lower case. If the total length is less than 15, then it will be joined using "-" and returned
 * 3) the first letter of each word will be taken, excluding numbers
 * 4) a random code will be returned
 *
 * @param displayName
 * @return
 */
public String generateShortName(String displayName) {
    Validate.isTrue(StringUtils.isNotBlank(displayName));
    String cleanDisplayName = StringUtils.stripAccents(StringUtils.normalizeSpace(displayName)).toLowerCase(Locale.ENGLISH).replaceAll(FIND_EVIL_CHARACTERS, "-");
    if(!StringUtils.containsWhitespace(cleanDisplayName) && isUnique(cleanDisplayName)) {
        return cleanDisplayName;
    }
    Optional<String> dashedName = getDashedName(cleanDisplayName);
    if(dashedName.isPresent()) {
        return dashedName.get();
    }
    Optional<String> croppedName = getCroppedName(cleanDisplayName);
    return croppedName.orElseGet(this::generateRandomName);
}
 

private boolean isValidPath(String path) {
    try {
        Paths.get(path);
    } catch (InvalidPathException ex) {
        return false;
    }
    return !StringUtils.containsWhitespace(path);
}
 

public NamespaceBuilder setName(String namespaceName) {

				if (namespaceName != null) {
					if (namespaceName.contains("|") || namespaceName.contains(":") || StringUtils.containsWhitespace(namespaceName)) {
						throw new ExampleFormatException("The namespace name cannot contain whitespace, '|' or ':'! Namespace passed in was: " + namespaceName);
					}
				}

				this.namespaceName = namespaceName;
				return this;
			}
 

public NamespaceBuilder addFeature(String feature, Float value) {
	if (StringUtils.isBlank(feature)) throw new ExampleFormatException("The feature name must be provided!");

	if (feature.contains("|") || feature.contains(":") || StringUtils.containsWhitespace(feature))
		throw new ExampleFormatException("The feature name cannot contain whitespace, '|' or ':'! Feature name passed in was: " + feature);

	if (features == null) features = new ArrayList<StructuredExample.Namespace.Feature>();
	features.add(new Feature(feature, value));
	return this;
}
 

/**
 * The method will get triggered from Rule Engine with following parameters
 * 
 * @param ruleParam
 * 
 *            ************* Following are the Rule Parameters********* <br>
 * <br>
 * 
 *            ruleKey : check-for-improper-roles-name <br>
 * <br>
 * 
 *            threadsafe : if true , rule will be executed on multiple
 *            threads <br>
 * <br>
 * 
 *            severity : Enter the value of severity <br>
 * <br>
 * 
 *            ruleCategory : Enter the value of category <br>
 * <br>
 * 
 * @param resourceAttributes
 *            this is a resource in context which needs to be scanned this
 *            is provided by execution engine
 *
 */
@Override
public RuleResult execute(Map<String, String> ruleParam,
        Map<String, String> resourceAttributes) {

    logger.debug("========CheckImproperRolesNamesRule started=========");
    Annotation annotation = null;
    String resourceId = null;

    String severity = ruleParam.get(PacmanRuleConstants.SEVERITY);
    String category = ruleParam.get(PacmanRuleConstants.CATEGORY);

    MDC.put("executionId", ruleParam.get("executionId"));
    MDC.put("ruleId", ruleParam.get(PacmanSdkConstants.RULE_ID));

    List<LinkedHashMap<String, Object>> issueList = new ArrayList<>();
    LinkedHashMap<String, Object> issue = new LinkedHashMap<>();

    if (!PacmanUtils.doesAllHaveValue(severity, category)) {
        logger.info(PacmanRuleConstants.MISSING_CONFIGURATION);
        throw new InvalidInputException(PacmanRuleConstants.MISSING_CONFIGURATION);
    }

    if (resourceAttributes != null) {
        resourceId = resourceAttributes.get(PacmanSdkConstants.RESOURCE_ID);
        if (StringUtils.containsWhitespace(resourceId)) {
            annotation = Annotation.buildAnnotation(ruleParam,
                    Annotation.Type.ISSUE);
            annotation.put(PacmanSdkConstants.DESCRIPTION,
                    "Improper roles name found !!");
            annotation.put(PacmanRuleConstants.SEVERITY, severity);
            annotation.put(PacmanRuleConstants.CATEGORY, category);

            issue.put(PacmanRuleConstants.VIOLATION_REASON,
                    " Role name with space found");
            issueList.add(issue);
            annotation.put("issueDetails", issueList.toString());
            logger.debug(
                    "========CheckImproperRolesNamesRule with annotation : {} =========",
                    annotation);
            return new RuleResult(PacmanSdkConstants.STATUS_FAILURE,
                    PacmanRuleConstants.FAILURE_MESSAGE, annotation);
        }
    }
    logger.debug("========CheckImproperRolesNamesRule ended=========");
    return new RuleResult(PacmanSdkConstants.STATUS_SUCCESS,
            PacmanRuleConstants.SUCCESS_MESSAGE);
}
 

/**
 * The method will get triggered from Rule Engine with following parameters
 * @param ruleParam 
 * 
 * ************* Following are the Rule Parameters********* <br><br>
 * 
 * ruleKey : check-for-improper-account-name <br><br>
 * 
 * threadsafe : if true , rule will be executed on multiple threads <br><br>
 *  
 * severity : Enter the value of severity <br><br>
 * 
 * ruleCategory : Enter the value of category <br><br>
 * 
 * @param resourceAttributes this is a resource in context which needs to be scanned this is provided by execution engine
 *
 */
@Override
public RuleResult execute(Map<String, String> ruleParam, Map<String, String> resourceAttributes) {
	
	logger.debug("========CheckImproperAccountNamesRule started=========");
	Annotation annotation = null;
	String resourceId = null;
	
	String severity = ruleParam.get(PacmanRuleConstants.SEVERITY);
	String category = ruleParam.get(PacmanRuleConstants.CATEGORY);
	
	
	MDC.put("executionId", ruleParam.get("executionId")); 
	MDC.put("ruleId", ruleParam.get(PacmanSdkConstants.RULE_ID));
	
	List<LinkedHashMap<String,Object>>issueList = new ArrayList<>();
	LinkedHashMap<String,Object>issue = new LinkedHashMap<>();
	
	if (!PacmanUtils.doesAllHaveValue(severity,category)) {
		logger.info(PacmanRuleConstants.MISSING_CONFIGURATION);
		throw new InvalidInputException(PacmanRuleConstants.MISSING_CONFIGURATION);
	}
	
	if (resourceAttributes != null) {
		resourceId = resourceAttributes.get(PacmanSdkConstants.RESOURCE_ID);
		if(StringUtils.containsWhitespace(resourceId)){
		logger.info(resourceId, "=========_resourceId");
			annotation = Annotation.buildAnnotation(ruleParam, Annotation.Type.ISSUE);
			annotation.put(PacmanSdkConstants.DESCRIPTION,"Improper account name found !!");
			annotation.put(PacmanRuleConstants.SEVERITY, severity);
			annotation.put(PacmanRuleConstants.CATEGORY, category);
			
			issue.put(PacmanRuleConstants.VIOLATION_REASON, "Account name with space found");
			issueList.add(issue);
			annotation.put("issueDetails",issueList.toString());
			
			logger.debug("========CheckImproperAccountNamesRule ended with an annotation : {}=========", annotation);
			return new RuleResult(PacmanSdkConstants.STATUS_FAILURE,PacmanRuleConstants.FAILURE_MESSAGE, annotation);
	}
		}
	logger.debug("========CheckImproperAccountNamesRule ended=========");
	return new RuleResult(PacmanSdkConstants.STATUS_SUCCESS,PacmanRuleConstants.SUCCESS_MESSAGE);
}
 

public static String toArg( final Object key, final Object val ) {
	return toArg( key ) + "=" + (StringUtils.containsWhitespace( val.toString() ) ? "\"" + val + "\"" : val);
}
 

private void checkNotWhitespaces(String path) {
  if (StringUtils.containsWhitespace(path)) {
    throw new RuntimeException("Can not create path with whitespace.");
  }
}