Merge branch 'master' of github.com:Evolveum/midpoint

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/AssignmentEvaluator.java

@@ -73,7 +73,7 @@ public class AssignmentEvaluator<F extends FocusType> {
 	private static final Trace LOGGER = TraceManager.getTrace(AssignmentEvaluator.class);
 
 	private RepositoryService repository;
-	private ObjectDeltaObject<F> userOdo;
+	private ObjectDeltaObject<F> focusOdo;
 	private LensContext<F> lensContext;
 	private String channel;
 	private ObjectResolver objectResolver;
@@ -92,12 +92,12 @@ public void setRepository(RepositoryService repository) {
 		this.repository = repository;
 	}
 
-	public ObjectDeltaObject<F> getUserOdo() {
-		return userOdo;
+	public ObjectDeltaObject<F> getFocusOdo() {
+		return focusOdo;
 	}
 
-	public void setUserOdo(ObjectDeltaObject<F> userOdo) {
-		this.userOdo = userOdo;
+	public void setFocusOdo(ObjectDeltaObject<F> userOdo) {
+		this.focusOdo = userOdo;
 	}
 
 	public LensContext<F> getLensContext() {
@@ -189,6 +189,7 @@ public EvaluatedAssignment evaluate(AssignmentType assignmentType, ObjectType so
 			throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, PolicyViolationException {
 		assertSource(source, assignmentType);
 		EvaluatedAssignment evalAssignment = new EvaluatedAssignment();
+		evalAssignment.setAssignmentType(assignmentType);
 		AssignmentPath assignmentPath = new AssignmentPath();
 		AssignmentPathSegment assignmentPathSegment = new AssignmentPathSegment(assignmentType, null);
 		assignmentPathSegment.setSource(source);
@@ -242,7 +243,7 @@ private void evaluateAssignment(EvaluatedAssignment evalAssignment, AssignmentPa
 			if (assignmentType.getConstruction() != null) {
 
 				if (evaluateConstructions && assignmentPathSegment.isEvaluateConstructions()) {
-					evaluateConstruction(evalAssignment, assignmentPathSegment, source, sourceDescription, 
+					prepareConstructionEvaluation(evalAssignment, assignmentPathSegment, source, sourceDescription, 
 							assignmentPath, assignmentPathSegment.getOrderOneObject(), task, result);
 				}
 
@@ -272,20 +273,20 @@ private void evaluateAssignment(EvaluatedAssignment evalAssignment, AssignmentPa
 		assignmentPath.remove(assignmentPathSegment);
 	}
 
-	private void evaluateConstruction(EvaluatedAssignment evaluatedAssignment, AssignmentPathSegment assignmentPathSegment, ObjectType source, String sourceDescription,
+	private void prepareConstructionEvaluation(EvaluatedAssignment evaluatedAssignment, AssignmentPathSegment assignmentPathSegment, ObjectType source, String sourceDescription,
 			AssignmentPath assignmentPath, ObjectType orderOneObject, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException {
 		assertSource(source, evaluatedAssignment);
 
 
 		AssignmentType assignmentType = assignmentPathSegment.getAssignmentType();
 		ConstructionType constructionType = assignmentType.getConstruction();
 
-		LOGGER.trace("Evaluate construction '{}' in {}", constructionType.getDescription(), source);
+		LOGGER.trace("Preparing construction '{}' in {}", constructionType.getDescription(), source);
 
 		Construction<F> construction = new Construction<F>(constructionType, source);
 		// We have to clone here as the path is constantly changing during evaluation
 		construction.setAssignmentPath(assignmentPath.clone());
-		construction.setUserOdo(userOdo);
+		construction.setUserOdo(focusOdo);
 		construction.setLensContext(lensContext);
 		construction.setObjectResolver(objectResolver);
 		construction.setPrismContext(prismContext);
@@ -294,7 +295,7 @@ private void evaluateConstruction(EvaluatedAssignment evaluatedAssignment, Assig
 		construction.setChannel(channel);
 		construction.setOrderOneObject(orderOneObject);
 
-		construction.evaluate(task, result);
+		// Do not evaluate the construction here. We will do it in the second pass. Just prepare everything to be evaluated.
 
 		evaluatedAssignment.addConstruction(construction);
 	}
@@ -312,7 +313,7 @@ private void evaluateFocusMappings(EvaluatedAssignment evaluatedAssignment, Assi
 		AssignmentPathVariables assignmentPathVariables = LensUtil.computeAssignmentPathVariables(assignmentPath);
 
 		for (MappingType mappingType: mappingsType.getMapping()) {
-			Mapping mapping = LensUtil.createFocusMapping(mappingFactory, lensContext, mappingType, source, userOdo, 
+			Mapping mapping = LensUtil.createFocusMapping(mappingFactory, lensContext, mappingType, source, focusOdo, 
 					assignmentPathVariables, systemConfiguration, now, sourceDescription, result);
 			if (mapping == null) {
 				continue;

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/EvaluatedAssignment.java

@@ -18,16 +18,22 @@
 import java.util.ArrayList;
 import java.util.Collection;
 
+import com.evolveum.midpoint.model.common.expression.ObjectDeltaObject;
 import com.evolveum.midpoint.model.common.mapping.Mapping;
 import com.evolveum.midpoint.prism.PrismObject;
 import com.evolveum.midpoint.prism.PrismPropertyValue;
 import com.evolveum.midpoint.prism.PrismReferenceValue;
 import com.evolveum.midpoint.schema.result.OperationResult;
 import com.evolveum.midpoint.security.api.Authorization;
+import com.evolveum.midpoint.task.api.Task;
 import com.evolveum.midpoint.util.DebugDumpable;
 import com.evolveum.midpoint.util.DebugUtil;
+import com.evolveum.midpoint.util.exception.ExpressionEvaluationException;
 import com.evolveum.midpoint.util.exception.ObjectNotFoundException;
 import com.evolveum.midpoint.util.exception.SchemaException;
+import com.evolveum.midpoint.util.logging.Trace;
+import com.evolveum.midpoint.util.logging.TraceManager;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.AssignmentType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.FocusType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.OrgType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType;
@@ -39,13 +45,17 @@
  * @author Radovan Semancik
  */
 public class EvaluatedAssignment<F extends FocusType> implements DebugDumpable {
+
+	private static final Trace LOGGER = TraceManager.getTrace(EvaluatedAssignment.class);
 
+	private AssignmentType assignmentType;
 	private Collection<Construction<F>> constructions;
 	private Collection<PrismReferenceValue> orgRefVals;
 	private Collection<Authorization> authorizations;
 	private Collection<Mapping<? extends PrismPropertyValue<?>>> focusMappings;
 	private PrismObject<?> target;
 	private boolean isValid;
+	private boolean forceRecon;
 
 	public EvaluatedAssignment() {
 		constructions = new ArrayList<>();
@@ -54,6 +64,14 @@ public EvaluatedAssignment() {
 		focusMappings = new ArrayList<>();
 	}
 
+	public AssignmentType getAssignmentType() {
+		return assignmentType;
+	}
+
+	public void setAssignmentType(AssignmentType assignmentType) {
+		this.assignmentType = assignmentType;
+	}
+
 	public Collection<Construction<F>> getConstructions() {
 		return constructions;
 	}
@@ -102,13 +120,29 @@ public void setValid(boolean isValid) {
 		this.isValid = isValid;
 	}
 
+	public boolean isForceRecon() {
+		return forceRecon;
+	}
+
+	public void setForceRecon(boolean forceRecon) {
+		this.forceRecon = forceRecon;
+	}
+
 	public Collection<ResourceType> getResources(OperationResult result) throws ObjectNotFoundException, SchemaException {
 		Collection<ResourceType> resources = new ArrayList<ResourceType>();
 		for (Construction<F> acctConstr: constructions) {
 			resources.add(acctConstr.getResource(result));
 		}
 		return resources;
 	}
+
+	public void evaluateConstructions(ObjectDeltaObject<F> focusOdo, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException {
+		for (Construction<F> construction :constructions) {
+			construction.setUserOdo(focusOdo);
+			LOGGER.trace("Evaluating construction '{}' in {}", construction);
+			construction.evaluate(task, result);
+		}
+	}
 
 	@Override
 	public String debugDump() {