ModelExecuteOptions.java

/*
 * Copyright (c) 2010-2017 Evolveum
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.evolveum.midpoint.model.api;


import com.evolveum.midpoint.schema.AbstractOptions;
import com.evolveum.midpoint.xml.ns._public.common.common_3.ModelExecuteOptionsType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.OperationBusinessContextType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.PartialProcessingOptionsType;

import java.io.Serializable;
import java.util.List;

/**
 * Options for execution of Model operations. These options influence the way how the operations are executed.
 * The options are not mandatory. All options have reasonable default values. They may not be specified at all.
 * 
 * @author semancik
 */
public class ModelExecuteOptions extends AbstractOptions implements Serializable, Cloneable {
	
	/**
	 * Force the operation even if it would otherwise fail due to external failure. E.g. attempt to delete an account
	 * that no longer exists on resource may fail without a FORCE option. If FORCE option is used then the operation is
	 * finished even if the account does not exist (e.g. at least shadow is removed from midPoint repository).
	 */
	private Boolean force;
	
	/**
	 * Avoid any smart processing of the data except for schema application. Do not synchronize the data, do not apply
	 * any expressions, etc.
	 */
	private Boolean raw;
	
	/**
	 * Encrypt any cleartext data on write, decrypt any encrypted data on read. Applies only to the encrypted
	 * data formats (ProtectedString, ProtectedByteArray).
	 * It is not recommended to use in production environment. This option is provided only for diagnostic
	 * purposes to be used in development environments.
	 */
	private Boolean noCrypt;
	
	/**
	 * Option to reconcile focus and all projections while executing changes.
	 * (implies reconcileFocus)
	 */
	private Boolean reconcile;
	
	/**
	 * Option to reconcile focus while executing changes.
	 * If this option is set and the reconcile option is not set then the projections
	 * reconciliation will not be forced (but it may still happen if other configuration
	 * loads full projection).
	 */
	private Boolean reconcileFocus;

    /**
     * Option to reconcile affected objects after executing changes.
     * Typical use: after a role is changed, all users that have been assigned this role
     * would be reconciled.
     *
     * Because it is difficult to determine all affected objects (e.g. users that have
     * indirectly assigned a role), midPoint does a reasonable attempt to determine
     * and reconcile them. E.g. it may be limited to a direct assignees.
     *
     * Also, because of time complexity, the reconciliation may be executed in
     * a separate background task.
     */
	private Boolean reconcileAffected;

    /**
     * Option to execute changes as soon as they are approved. (For the primary stage approvals, the default behavior
     * is to wait until all changes are approved/rejected and then execute the operation as a whole.)
     */
	private Boolean executeImmediatelyAfterApproval;

    /**
     * Option to user overwrite flag. It can be used from web service, if we want to re-import some object
     */
	private Boolean overwrite;
    
	/**
	 * Option to simulate import operation. E.g. search filters will be resolved.
	 */
	private Boolean isImport;

	/**
	 * Causes reevaluation of search filters (producing partial errors on failure).
	 */
	private Boolean reevaluateSearchFilters;
    
    /**
     * Option to limit propagation only for the source resource
     */
	private Boolean limitPropagation;

	/**
	 * Is this operation already authorized, i.e. should it be executed without any further authorization checks?
	 * EXPERIMENTAL. Currently supported only for raw executions.
	 */
	private Boolean preAuthorized;
	
	/**
	 * Business context that describes this request.
	 */
	private OperationBusinessContextType requestBusinessContext;
	
	/**
	 * Options that control selective execution of model logic.
     * Use with extreme care. Some combinations may be dangerous.
	 */
	private PartialProcessingOptionsType partialProcessing;

    public Boolean getForce() {
		return force;
	}

	public void setForce(Boolean force) {
		this.force = force;
	}
	
	public static boolean isForce(ModelExecuteOptions options) {
		if (options == null) {
			return false;
		}
		if (options.force == null) {
			return false;
		}
		return options.force;
	}
	
	public static ModelExecuteOptions createForce() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setForce(true);
		return opts;
	}

	public ModelExecuteOptions setForce() {
		setForce(true);
		return this;
	}

	public Boolean getRaw() {
		return raw;
	}

	public void setRaw(Boolean raw) {
		this.raw = raw;
	}
	
	public static boolean isRaw(ModelExecuteOptions options) {
		if (options == null) {
			return false;
		}
		if (options.raw == null) {
			return false;
		}
		return options.raw;
	}
	
	public static ModelExecuteOptions createRaw() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setRaw(true);
		return opts;
	}

	public ModelExecuteOptions setRaw() {
		setRaw(true);
		return this;
	}

	public Boolean getNoCrypt() {
		return noCrypt;
	}

	public void setNoCrypt(Boolean noCrypt) {
		this.noCrypt = noCrypt;
	}
	
	public static boolean isNoCrypt(ModelExecuteOptions options) {
		if (options == null) {
			return false;
		}
		if (options.noCrypt == null) {
			return false;
		}
		return options.noCrypt;
	}

	public static ModelExecuteOptions createNoCrypt() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setNoCrypt(true);
		return opts;
	}

	public ModelExecuteOptions setNoCrypt() {
		setNoCrypt(true);
		return this;
	}

	public Boolean getReconcile() {
		return reconcile;
	}
	
	public void setReconcile(Boolean reconcile) {
		this.reconcile = reconcile;
	}
	
	public static boolean isReconcile(ModelExecuteOptions options) {
		if (options == null){
			return false;
		}
		if (options.reconcile == null){
			return false;
		}
		return options.reconcile;
	}
	
	public static ModelExecuteOptions createReconcile() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setReconcile(true);
		return opts;
	}

	public ModelExecuteOptions setReconcile() {
		setReconcile(true);
		return this;
	}
	
	public Boolean getReconcileFocus() {
		return reconcileFocus;
	}

	public void setReconcileFocus(Boolean reconcileFocus) {
		this.reconcileFocus = reconcileFocus;
	}

	public static ModelExecuteOptions createReconcileFocus() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setReconcileFocus(true);
		return opts;
	}
	
	public static boolean isReconcileFocus(ModelExecuteOptions options) {
		if (options == null){
			return false;
		}
		if (options.reconcileFocus == null){
			return false;
		}
		return options.reconcileFocus;
	}

    public Boolean getReconcileAffected() {
        return reconcileAffected;
    }

    public void setReconcileAffected(Boolean reconcile) {
        this.reconcileAffected = reconcile;
    }

    public static boolean isReconcileAffected(ModelExecuteOptions options){
        if (options == null){
            return false;
        }
        if (options.reconcileAffected == null){
            return false;
        }
        return options.reconcileAffected;
    }

    public static ModelExecuteOptions createReconcileAffected(){
        ModelExecuteOptions opts = new ModelExecuteOptions();
        opts.setReconcileAffected(true);
        return opts;
    }

	public ModelExecuteOptions setReconcileAffected() {
		setReconcileAffected(true);
		return this;
	}

    public Boolean getOverwrite() {
		return overwrite;
	}
	
	public void setOverwrite(Boolean overwrite) {
		this.overwrite = overwrite;
	}
	
	public static boolean isOverwrite(ModelExecuteOptions options){
		if (options == null){
			return false;
		}
		if (options.overwrite == null){
			return false;
		}
		return options.overwrite;
	}
	
	public static ModelExecuteOptions createOverwrite(){
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setOverwrite(true);
		return opts;
	}

	public ModelExecuteOptions setOverwrite() {
		setOverwrite(true);
		return this;
	}

	public Boolean getIsImport() {
		return isImport;
	}
	
	public void setIsImport(Boolean isImport) {
		this.isImport = isImport;
	}
	
	public static boolean isIsImport(ModelExecuteOptions options){
		if (options == null){
			return false;
		}
		if (options.isImport == null){
			return false;
		}
		return options.isImport;
	}
	
	public static ModelExecuteOptions createIsImport(){
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setIsImport(true);
		return opts;
	}

	public ModelExecuteOptions setIsImport(){
		setIsImport(true);
		return this;
	}
	
    public void setExecuteImmediatelyAfterApproval(Boolean executeImmediatelyAfterApproval) {
        this.executeImmediatelyAfterApproval = executeImmediatelyAfterApproval;
    }

    public static boolean isExecuteImmediatelyAfterApproval(ModelExecuteOptions options){
        if (options == null){
            return false;
        }
        if (options.executeImmediatelyAfterApproval == null) {
            return false;
        }
        return options.executeImmediatelyAfterApproval;
    }

	public static ModelExecuteOptions createExecuteImmediatelyAfterApproval(){
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setExecuteImmediatelyAfterApproval(true);
		return opts;
	}

	public void setLimitPropagation(Boolean limitPropagation) {
		this.limitPropagation = limitPropagation;
	}
    
    public static boolean isLimitPropagation(ModelExecuteOptions options){
    	if (options == null){
    		return false;
    	}
    	if (options.limitPropagation == null){
    		return false;
    	}
    	return options.limitPropagation;
    }

	public static ModelExecuteOptions createLimitPropagation() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setLimitPropagation(true);
		return opts;
	}

	public ModelExecuteOptions setLimitPropagation() {
		setLimitPropagation(true);
		return this;
	}


	public Boolean getReevaluateSearchFilters() {
		return reevaluateSearchFilters;
	}

	public void setReevaluateSearchFilters(Boolean reevaluateSearchFilters) {
		this.reevaluateSearchFilters = reevaluateSearchFilters;
	}

	public static boolean isReevaluateSearchFilters(ModelExecuteOptions options){
		if (options == null){
			return false;
		}
		if (options.reevaluateSearchFilters == null){
			return false;
		}
		return options.reevaluateSearchFilters;
	}

	public static ModelExecuteOptions createReevaluateSearchFilters(){
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setReevaluateSearchFilters(true);
		return opts;
	}

	public ModelExecuteOptions setReevaluateSearchFilters(){
		setReevaluateSearchFilters(true);
		return this;
	}

	public Boolean getPreAuthorized() {
		return preAuthorized;
	}

	public void setPreAuthorized(Boolean value) {
		this.preAuthorized = value;
	}

	public static boolean isPreAuthorized(ModelExecuteOptions options) {
		if (options == null) {
			return false;
		}
		if (options.preAuthorized == null){
			return false;
		}
		return options.preAuthorized;
	}

	public static ModelExecuteOptions createPreAuthorized() {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setPreAuthorized(true);
		return opts;
	}

	public ModelExecuteOptions setPreAuthorized() {
		setPreAuthorized(true);
		return this;
	}

	public OperationBusinessContextType getRequestBusinessContext() {
		return requestBusinessContext;
	}

	public void setRequestBusinessContext(OperationBusinessContextType requestBusinessContext) {
		this.requestBusinessContext = requestBusinessContext;
	}
	
	public static OperationBusinessContextType getRequestBusinessContext(ModelExecuteOptions options) {
		if (options == null) {
			return null;
		}
		return options.getRequestBusinessContext();
	}
	
	public static ModelExecuteOptions createRequestBusinessContext(OperationBusinessContextType requestBusinessContext) {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setRequestBusinessContext(requestBusinessContext);
		return opts;
	}

	public PartialProcessingOptionsType getPartialProcessing() {
		return partialProcessing;
	}

	public void setPartialProcessing(PartialProcessingOptionsType partialProcessing) {
		this.partialProcessing = partialProcessing;
	}
	
	public static PartialProcessingOptionsType getPartialProcessing(ModelExecuteOptions options) {
		if (options == null) {
			return null;
		}
		return options.getPartialProcessing();
	}
	
	public static ModelExecuteOptions createPartialProcessing(PartialProcessingOptionsType partialProcessing) {
		ModelExecuteOptions opts = new ModelExecuteOptions();
		opts.setPartialProcessing(partialProcessing);
		return opts;
	}

	public ModelExecuteOptionsType toModelExecutionOptionsType() {
        ModelExecuteOptionsType retval = new ModelExecuteOptionsType();
        retval.setForce(force);
        retval.setRaw(raw);
        retval.setNoCrypt(noCrypt);
        retval.setReconcile(reconcile);
        retval.setReconcileFocus(reconcileFocus);
        retval.setExecuteImmediatelyAfterApproval(executeImmediatelyAfterApproval);
        retval.setOverwrite(overwrite);
        retval.setIsImport(isImport);
        retval.setLimitPropagation(limitPropagation);
		retval.setReevaluateSearchFilters(reevaluateSearchFilters);
		// preAuthorized is purposefully omitted (security reasons)
		retval.setRequestBusinessContext(requestBusinessContext);
		retval.setPartialProcessing(partialProcessing);
        return retval;
    }

    public static ModelExecuteOptions fromModelExecutionOptionsType(ModelExecuteOptionsType type) {
        if (type == null) {
            return null;
        }
        ModelExecuteOptions retval = new ModelExecuteOptions();
        retval.setForce(type.isForce());
        retval.setRaw(type.isRaw());
        retval.setNoCrypt(type.isNoCrypt());
        retval.setReconcile(type.isReconcile());
        retval.setReconcileFocus(type.isReconcileFocus());
        retval.setExecuteImmediatelyAfterApproval(type.isExecuteImmediatelyAfterApproval());
        retval.setOverwrite(type.isOverwrite());
        retval.setIsImport(type.isIsImport());
        retval.setLimitPropagation(type.isLimitPropagation());
		retval.setReevaluateSearchFilters(type.isReevaluateSearchFilters());
		// preAuthorized is purposefully omitted (security reasons)
		retval.setRequestBusinessContext(type.getRequestBusinessContext());
		retval.setPartialProcessing(type.getPartialProcessing());
        return retval;
    }
    
    public static ModelExecuteOptions fromRestOptions(List<String> options){
    	if (options == null || options.isEmpty()){
    		return null;
    	}
    	
    	ModelExecuteOptions retVal = new ModelExecuteOptions();
    	for (String option : options){
    		if (ModelExecuteOptionsType.F_RAW.getLocalPart().equals(option)){
    			retVal.setRaw(true);
    		}
    		if (ModelExecuteOptionsType.F_EXECUTE_IMMEDIATELY_AFTER_APPROVAL.getLocalPart().equals(option)){
    			retVal.setExecuteImmediatelyAfterApproval(true);
    		}
    		if (ModelExecuteOptionsType.F_FORCE.getLocalPart().equals(option)){
    			retVal.setForce(true);
    		}
    		if (ModelExecuteOptionsType.F_NO_CRYPT.getLocalPart().equals(option)){
    			retVal.setNoCrypt(true);
    		}
    		if (ModelExecuteOptionsType.F_OVERWRITE.getLocalPart().equals(option)){
    			retVal.setOverwrite(true);
    		}
    		if (ModelExecuteOptionsType.F_RECONCILE.getLocalPart().equals(option)){
    			retVal.setReconcile(true);
    		}
    		if (ModelExecuteOptionsType.F_IS_IMPORT.getLocalPart().equals(option)){
    			retVal.setIsImport(true);
    		}
    		if (ModelExecuteOptionsType.F_LIMIT_PROPAGATION.getLocalPart().equals(option)){
    			retVal.setIsImport(true);
    		}
			if (ModelExecuteOptionsType.F_REEVALUATE_SEARCH_FILTERS.getLocalPart().equals(option)){
				retVal.setReevaluateSearchFilters(true);
			}
			// preAuthorized is purposefully omitted (security reasons)
    	}
    	
    	return retVal;
    }
    
    @Override
    public String toString() {
    	StringBuilder sb = new StringBuilder("ModelExecuteOptions(");
    	appendFlag(sb, "executeImmediatelyAfterApproval", executeImmediatelyAfterApproval);
    	appendFlag(sb, "force", force);
    	appendFlag(sb, "isImport", isImport);
    	appendFlag(sb, "limitPropagation", limitPropagation);
    	appendFlag(sb, "noCrypt", noCrypt);
    	appendFlag(sb, "overwrite", overwrite);
    	appendFlag(sb, "preAuthorized", preAuthorized);
    	appendFlag(sb, "raw", raw);
    	appendFlag(sb, "reconcile", reconcile);
    	appendFlag(sb, "reconcileFocus", reconcileFocus);
    	appendFlag(sb, "reevaluateSearchFilters", reevaluateSearchFilters);
    	appendFlag(sb, "reconcileAffected", reconcileAffected);
    	appendFlag(sb, "requestBusinessContext", requestBusinessContext == null ? null : true);
    	appendFlag(sb, "partialProcessing", partialProcessing == null ? null : true);
    	removeLastComma(sb);
		sb.append(")");
		return sb.toString();
    }

    public ModelExecuteOptions clone() {
        // not much efficient, but...
        ModelExecuteOptions clone = fromModelExecutionOptionsType(toModelExecutionOptionsType());
		clone.setPreAuthorized(this.preAuthorized);
		return clone;
    }

}