/** Adds deltas for iteration and iterationToken to the focus if needed. */
private <F extends FocusType> void addIterationTokenDeltas(
LensFocusContext<F> focusContext, int iteration, String iterationToken)
throws SchemaException {
PrismObject<F> objectCurrent = focusContext.getObjectCurrent();
if (objectCurrent != null) {
Integer iterationOld = objectCurrent.asObjectable().getIteration();
String iterationTokenOld = objectCurrent.asObjectable().getIterationToken();
if (iterationOld != null
&& iterationOld == iteration
&& iterationTokenOld != null
&& iterationTokenOld.equals(iterationToken)) {
// Already stored
return;
}
}
PrismObjectDefinition<F> objDef = focusContext.getObjectDefinition();
PrismPropertyValue<Integer> iterationVal = new PrismPropertyValue<Integer>(iteration);
iterationVal.setOriginType(OriginType.USER_POLICY);
PropertyDelta<Integer> iterationDelta =
PropertyDelta.createReplaceDelta(objDef, FocusType.F_ITERATION, iterationVal);
focusContext.swallowToSecondaryDelta(iterationDelta);
PrismPropertyValue<String> iterationTokenVal = new PrismPropertyValue<String>(iterationToken);
iterationTokenVal.setOriginType(OriginType.USER_POLICY);
PropertyDelta<String> iterationTokenDelta =
PropertyDelta.createReplaceDelta(objDef, FocusType.F_ITERATION_TOKEN, iterationTokenVal);
focusContext.swallowToSecondaryDelta(iterationTokenDelta);
}
private <T> XNode serializePropertyRawValue(PrismPropertyValue<T> value) throws SchemaException {
Object rawElement = value.getRawElement();
if (rawElement instanceof XNode) {
return (XNode) rawElement;
} else {
T realValue = value.getValue();
return createPrimitiveXNode(realValue, DOMUtil.XSD_STRING);
}
}
public boolean isRealValueToAdd(PrismPropertyValue<?> value) {
if (valuesToAdd == null) {
return false;
}
for (PrismPropertyValue valueToAdd : valuesToAdd) {
if (valueToAdd.equalsRealValue(value)) {
return true;
}
}
return false;
}
public boolean evaluateConfirmationExpression(
UserType user,
ShadowType shadow,
ExpressionType expressionType,
Task task,
OperationResult result)
throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException {
Validate.notNull(user, "User must not be null.");
Validate.notNull(shadow, "Resource object shadow must not be null.");
Validate.notNull(expressionType, "Expression must not be null.");
Validate.notNull(result, "Operation result must not be null.");
ResourceType resource = resolveResource(shadow, result);
ExpressionVariables variables = getDefaultXPathVariables(user, shadow, resource);
String shortDesc = "confirmation expression for " + resource.asPrismObject();
PrismPropertyDefinition<Boolean> outputDefinition =
new PrismPropertyDefinition<>(
ExpressionConstants.OUTPUT_ELMENT_NAME, DOMUtil.XSD_BOOLEAN, prismContext);
Expression<PrismPropertyValue<Boolean>, PrismPropertyDefinition<Boolean>> expression =
expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, result);
ExpressionEvaluationContext params =
new ExpressionEvaluationContext(null, variables, shortDesc, task, result);
PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple =
ModelExpressionThreadLocalHolder.evaluateExpressionInContext(
expression, params, task, result);
Collection<PrismPropertyValue<Boolean>> nonNegativeValues = outputTriple.getNonNegativeValues();
if (nonNegativeValues == null || nonNegativeValues.isEmpty()) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
if (nonNegativeValues.size() > 1) {
throw new ExpressionEvaluationException(
"Expression returned more than one value ("
+ nonNegativeValues.size()
+ ") in "
+ shortDesc);
}
PrismPropertyValue<Boolean> resultpval = nonNegativeValues.iterator().next();
if (resultpval == null) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
Boolean resultVal = resultpval.getValue();
if (resultVal == null) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
return resultVal;
}
private PrismValue clone(PrismValue value) {
if (value == null) {
return null;
}
PrismValue cloned = value.clone();
cloned.setOriginType(OriginType.USER_ACTION);
if (value instanceof PrismPropertyValue) {
PrismPropertyValue ppValue = (PrismPropertyValue) value;
if (ppValue.getValue() instanceof ProtectedStringType) {
((PrismPropertyValue) cloned).setValue(((ProtectedStringType) ppValue.getValue()).clone());
}
if (ppValue.getValue() instanceof PolyString) {
PolyString poly = (PolyString) ppValue.getValue();
if (StringUtils.isEmpty(poly.getOrig())) {
return null;
}
((PrismPropertyValue) cloned).setValue(new PolyString(poly.getOrig(), poly.getNorm()));
}
} else if (value instanceof PrismReferenceValue) {
if (cloned == null) {
return null;
}
if (cloned.isEmpty()) {
return null;
}
}
return cloned;
}
private Object convertToIcf(PrismPropertyValue<?> pval, Class<?> expectedType)
throws ConfigurationException {
Object midPointRealValue = pval.getValue();
if (expectedType.equals(GuardedString.class)) {
// Guarded string is a special ICF beast
// The value must be ProtectedStringType
if (midPointRealValue instanceof ProtectedStringType) {
ProtectedStringType ps = (ProtectedStringType) pval.getValue();
return IcfUtil.toGuardedString(
ps, pval.getParent().getElementName().getLocalPart(), protector);
} else {
throw new ConfigurationException(
"Expected protected string as value of configuration property "
+ pval.getParent().getElementName().getLocalPart()
+ " but got "
+ midPointRealValue.getClass());
}
} else if (expectedType.equals(GuardedByteArray.class)) {
// Guarded string is a special ICF beast
// TODO
// return new GuardedByteArray(Base64.decodeBase64((ProtectedByteArrayType)
// pval.getValue()));
return new GuardedByteArray(((ProtectedByteArrayType) pval.getValue()).getClearBytes());
} else if (midPointRealValue instanceof PolyString) {
return ((PolyString) midPointRealValue).getOrig();
} else if (midPointRealValue instanceof PolyStringType) {
return ((PolyStringType) midPointRealValue).getOrig();
} else if (expectedType.equals(File.class) && midPointRealValue instanceof String) {
return new File((String) midPointRealValue);
} else if (expectedType.equals(String.class)
&& midPointRealValue instanceof ProtectedStringType) {
try {
return protector.decryptString((ProtectedStringType) midPointRealValue);
} catch (EncryptionException e) {
throw new ConfigurationException(e);
}
} else {
return midPointRealValue;
}
}
private void assertTask(PrismObject<TaskType> task) {
task.checkConsistence();
assertEquals("Wrong oid", "44444444-4444-4444-4444-000000001111", task.getOid());
PrismObjectDefinition<TaskType> usedDefinition = task.getDefinition();
assertNotNull("No task definition", usedDefinition);
PrismAsserts.assertObjectDefinition(
usedDefinition,
new QName(SchemaConstantsGenerated.NS_COMMON, "task"),
TaskType.COMPLEX_TYPE,
TaskType.class);
assertEquals("Wrong class in task", TaskType.class, task.getCompileTimeClass());
TaskType taskType = task.asObjectable();
assertNotNull("asObjectable resulted in null", taskType);
assertPropertyValue(task, "name", PrismTestUtil.createPolyString("Task2"));
assertPropertyDefinition(task, "name", PolyStringType.COMPLEX_TYPE, 0, 1);
assertPropertyValue(task, "taskIdentifier", "44444444-4444-4444-4444-000000001111");
assertPropertyDefinition(task, "taskIdentifier", DOMUtil.XSD_STRING, 0, 1);
assertPropertyDefinition(
task, "executionStatus", JAXBUtil.getTypeQName(TaskExecutionStatusType.class), 1, 1);
PrismProperty<TaskExecutionStatusType> executionStatusProperty =
task.findProperty(TaskType.F_EXECUTION_STATUS);
PrismPropertyValue<TaskExecutionStatusType> executionStatusValue =
executionStatusProperty.getValue();
TaskExecutionStatusType executionStatus = executionStatusValue.getValue();
assertEquals("Wrong execution status", TaskExecutionStatusType.RUNNABLE, executionStatus);
PrismContainer extension = task.getExtension();
PrismContainerValue extensionValue = extension.getValue();
assertTrue("Extension parent", extensionValue.getParent() == extension);
assertNull("Extension ID", extensionValue.getId());
}
// region Serializing properties - specific functionality
private <T> XNode serializePropertyValue(
PrismPropertyValue<T> value, PrismPropertyDefinition<T> definition) throws SchemaException {
QName typeQName = definition.getTypeName();
T realValue = value.getValue();
if (realValue instanceof PolyString) {
return serializePolyString((PolyString) realValue);
} else if (beanConverter.canProcess(typeQName)) {
XNode xnode = beanConverter.marshall(realValue);
if (realValue instanceof ProtectedDataType<?> && definition.isDynamic()) { // why is this?
xnode.setExplicitTypeDeclaration(true);
xnode.setTypeQName(definition.getTypeName());
}
return xnode;
} else {
// primitive value
return createPrimitiveXNode(realValue, typeQName);
}
}
public T getAnyRealValue() {
PrismPropertyValue<T> anyValue = getAnyValue();
return anyValue.getValue();
}