How to use

ValuePolicyType

in

com.evolveum.midpoint.xml.ns._public.common.common_3

public ValuePolicyType clone() {
  ValuePolicyType object = new ValuePolicyType();
  PrismObject value = asPrismObject().clone();
  object.setupContainer(value);
  return object;
}

private boolean isNotEmptyMinLength(ValuePolicyType policy) {
  StringPolicyType stringPolicy = policy.getStringPolicy();
  if (stringPolicy == null) {
    return false;
  }
  Integer minLength = stringPolicy.getLimitations().getMinLength();
  if (minLength != null) {
    if (minLength.intValue() == 0) {
      return false;
    }
    return true;
  }
  return false;
}

public ValuePolicyType stringPolicy(StringPolicyType value) {
  setStringPolicy(value);
  return this;
}

result.addArbitraryObjectAsParam("policyName", pp.getName());
normalize(pp);
    defaultIfNull(XsdTypeMapper.multiplicityToInteger(pp.getMinOccurs()), 0) == 0) {
LimitationsType lims = pp.getStringPolicy().getLimitations();
testProhibitedValues(newValue, pp.getProhibitedValues(), originResolver, shortDesc, task, result, messages);
testCheckExpression(newValue, lims, originResolver, shortDesc, task, result, messages);

  policy = new ValuePolicyType().stringPolicy(new StringPolicyType().limitations(new LimitationsType().maxLength(defaultLength).minLength(defaultLength)));
StringPolicyType stringPolicy = policy.getStringPolicy();
int maxAttempts = DEFAULT_MAX_ATTEMPTS;
if (stringPolicy.getLimitations() != null && stringPolicy.getLimitations().getMaxAttempts() != null) {

/**
 * add defined default values
 */
private void normalize(ValuePolicyType pp) {
  if (null == pp) {
    throw new IllegalArgumentException("Password policy cannot be null");
  }
  if (null == pp.getStringPolicy()) {
    StringPolicyType sp = new StringPolicyType();
    pp.setStringPolicy(StringPolicyUtils.normalize(sp));
  } else {
    pp.setStringPolicy(StringPolicyUtils.normalize(pp.getStringPolicy()));
  }
  if (null == pp.getLifetime()) {
    PasswordLifeTimeType lt = new PasswordLifeTimeType();
    lt.setExpiration(-1);
    lt.setWarnBeforeExpiration(0);
    lt.setLockAfterExpiration(0);
    lt.setMinPasswordAge(0);
    lt.setPasswordHistoryLength(0);
  }
}
 

/**
 * Create an instance of {@link ValuePolicyType }
 * 
 */
public ValuePolicyType createValuePolicyType() {
  return new ValuePolicyType();
}

private <O extends ObjectType> boolean checkAttempt(String generatedValue, ValuePolicyType policy, AbstractValuePolicyOriginResolver<O> originResolver, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException {
  StringPolicyType stringPolicy = policy.getStringPolicy();
  if (stringPolicy != null) {
    LimitationsType limitationsType = stringPolicy.getLimitations();
    if (limitationsType != null) {
      List<CheckExpressionType> checkExpressionTypes = limitationsType.getCheckExpression();
      if (!checkExpressions(generatedValue, checkExpressionTypes, originResolver, shortDesc, task, result)) {
        LOGGER.trace("Check expression returned false for generated value in {}", shortDesc);
        return false;
      }
    }
  }
  if (!checkProhibitedValues(generatedValue, policy.getProhibitedValues(), originResolver, null, shortDesc, task, result)) {
    LOGGER.trace("Generated value is prohibited in {}", shortDesc);
    return false;
  }
  // TODO Check pattern
  return true;
}
 

  public static void copyFromJAXB(ValuePolicyType jaxb, RValuePolicy repo, RepositoryContext repositoryContext,
      IdGeneratorResult generatorResult) throws DtoTranslationException {
    copyAssignmentHolderInformationFromJAXB(jaxb, repo, repositoryContext, generatorResult);

    repo.setNameCopy(RPolyString.copyFromJAXB(jaxb.getName()));
  }
}

private void setDeprecatedPasswordPolicyProperties(ValuePolicyType passwordPolicyType,
    PasswordCredentialsPolicyType passwd) {
  PasswordLifeTimeType lifetime = passwordPolicyType.getLifetime();
  if (lifetime != null) {
    Integer expiration = lifetime.getExpiration();
    if (expiration != null && expiration != 0 && passwd.getMaxAge() == null) {
      passwd.setMaxAge(daysToDuration(expiration));
    }
    Integer minPasswordAge = lifetime.getMinPasswordAge();
    if (minPasswordAge != null && minPasswordAge != 0 && passwd.getMinAge() == null) {
      passwd.setMinAge(daysToDuration(minPasswordAge));
    }
    Integer passwordHistoryLength = lifetime.getPasswordHistoryLength();
    if (passwordHistoryLength != null && passwd.getHistoryLength() == null) {
      passwd.setHistoryLength(passwordHistoryLength);
    }
  }
  String minOccurs = passwordPolicyType.getMinOccurs();
  if (minOccurs != null && passwd.getMinOccurs() == null) {
    passwd.setMinOccurs(minOccurs);
  }
}

private ValuePolicyType postProcessCredentialPolicy(SecurityPolicyType securityPolicyType, CredentialPolicyType credPolicy, String credShortDesc, Task task, OperationResult result) {
  ObjectReferenceType valuePolicyRef = credPolicy.getValuePolicyRef();
  if (valuePolicyRef == null) {
    return null;
  }
  ValuePolicyType valuePolicyType;
  try {
    valuePolicyType = objectResolver.resolve(valuePolicyRef, ValuePolicyType.class, null, credShortDesc + " in " + securityPolicyType, task, result);
  } catch (ObjectNotFoundException | SchemaException | CommunicationException | ConfigurationException | SecurityViolationException | ExpressionEvaluationException e) {
    LOGGER.warn("{} {} referenced from {} was not found", credShortDesc, valuePolicyRef.getOid(), securityPolicyType);
    return null;
  }
  valuePolicyRef.asReferenceValue().setObject(valuePolicyType.asPrismObject());
  return valuePolicyType;
}

public StringPolicyType beginStringPolicy() {
  StringPolicyType value = new StringPolicyType();
  stringPolicy(value);
  return value;
}

private int getMinOccurs() {
  if (credentialPolicy == null) {
    return 0;
  }
  String minOccursPhrase = credentialPolicy.getMinOccurs();
  if (minOccursPhrase == null && valuePolicy != null) {
    minOccursPhrase = valuePolicy.getMinOccurs();       // deprecated but let's consider it
  }
  Integer minOccurs = XsdTypeMapper.multiplicityToInteger(minOccursPhrase);
  return defaultIfNull(minOccurs, 0);
}

/**
 * Create an instance of {@link ValuePolicyType }
 * 
 */
public ValuePolicyType createValuePolicyType() {
  return new ValuePolicyType();
}

  private boolean pwdValidHelper(String password, ValuePolicyType pp) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException {
    Task task = createTask("pwdValidHelper");
    OperationResult result = task.getResult();
    valuePolicyProcessor.validateValue(password, pp, null, "pwdValidHelper", task, result);
    result.computeStatus();
    String msg = "-> Policy "+pp.getName()+", password '"+password+"': "+result.getStatus();
    System.out.println(msg);
    LOGGER.info(msg);
    LOGGER.trace(result.debugDump());
    return (result.isSuccess());
  }
}

private SecurityPolicyType postProcessPasswordPolicy(ValuePolicyType passwordPolicyType) {
  SecurityPolicyType securityPolicyType = new SecurityPolicyType();
  CredentialsPolicyType creds = new CredentialsPolicyType();
  PasswordCredentialsPolicyType passwd = new PasswordCredentialsPolicyType();
  ObjectReferenceType passwordPolicyRef = new ObjectReferenceType();
  passwordPolicyRef.asReferenceValue().setObject(passwordPolicyType.asPrismObject());
  passwd.setValuePolicyRef(passwordPolicyRef);
  creds.setPassword(passwd);
  securityPolicyType.setCredentials(creds);
  setDeprecatedPasswordPolicyProperties(passwordPolicyType, passwd);
  return securityPolicyType;
}

private HashSet<String> getValidCharacters(CharacterClassType characterClassType,
    ValuePolicyType passwordPolicy) {
  if (null != characterClassType.getValue()) {
    return new HashSet<>(StringPolicyUtils.stringTokenizer(characterClassType.getValue()));
  } else {
    return new HashSet<>(StringPolicyUtils.stringTokenizer(StringPolicyUtils
        .collectCharacterClass(passwordPolicy.getStringPolicy().getCharacterClass(),
            characterClassType.getRef())));
  }
}

/**
 * Create an instance of {@link ValuePolicyType }
 * 
 */
public ValuePolicyType createValuePolicyType() {
  return new ValuePolicyType();
}

@Test
public void stringPolicyUtilsComplexTest() {
  final String TEST_NAME = "stringPolicyUtilsComplexTest";
  TestUtil.displayTestTitle(TEST_NAME);
  
  File file = new File(TEST_DIR, "password-policy-complex.xml");
  ValuePolicyType pp = null;
  try {
    pp = (ValuePolicyType) PrismTestUtil.parseObject(file).asObjectable();
  } catch (Exception e) {
    e.printStackTrace();
  }
  StringPolicyType sp = pp.getStringPolicy();
  StringPolicyUtils.normalize(sp);
}
 

public ValuePolicyType beginGlobalPasswordPolicy() {
  ValuePolicyType value = new ValuePolicyType();
  globalPasswordPolicy(value);
  return value;
}