1.5/plugins/org.eclipse.epf.validation/src/org/eclipse/epf/validation/LibraryEValidator.java

//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.validation;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.BasicDiagnostic;
import org.eclipse.emf.common.util.DiagnosticChain;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.util.EObjectValidator;
import org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.validation.model.Category;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IConstraintStatus;
import org.eclipse.emf.validation.service.IBatchValidator;
import org.eclipse.emf.validation.service.IConstraintDescriptor;
import org.eclipse.emf.validation.service.IConstraintFilter;
import org.eclipse.emf.validation.service.ModelValidationService;
import org.eclipse.epf.common.utils.StrUtil;
import org.eclipse.epf.library.edit.IAdapterFactoryProvider;
import org.eclipse.epf.library.edit.process.DescribableElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.util.LibraryEditUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.edit.validation.DependencyChecker;
import org.eclipse.epf.library.edit.validation.DependencyValidationMgr;
import org.eclipse.epf.library.edit.validation.IValidationManager;
import org.eclipse.epf.library.edit.validation.IValidator;
import org.eclipse.epf.library.edit.validation.IValidatorFactory;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.NamedElement;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.TeamProfile;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.WorkProductDescriptor;
import org.eclipse.epf.validation.constraints.LibraryTraversalStrategy;
import org.eclipse.epf.validation.util.ValidationStatus;

/**
 * An adapter that plugs the EMF Model Validation Service API into the
 * {@link org.eclipse.emf.ecore.EValidator} API.
 * 
 * @author Phong Nguyen Le
 * @since 1.1
 */
public class LibraryEValidator extends EObjectValidator {
	private static final boolean DEBUG = Activator.getDefault().isDebugging();
	private static final Map featureToPropertyMap = createFeatureToAttributeMap();

	public static final String CTX_ADAPTER_FACTORY_PROVIDER = "CTX_ADAPTER_FACTORY_PROVIDER"; //$NON-NLS-1$
	public static final String CTX_DEPENDENCY_VALIDATION_MGR = "CTX_DEPENDENCY_VALIDATION_MGR"; //$NON-NLS-1$
	public static final String CTX_CONSTRAINT_FILTER = "CTX_CONSTRAINT_FILTER"; //$NON-NLS-1$
	
	public static final String CONSTRAINT_CATEGORY = "org.eclipse.epf.validation.library.category"; //$NON-NLS-1$

	private static Map createFeatureToAttributeMap() {
		Map map = new HashMap();
		map.put(UmaPackage.Literals.NAMED_ELEMENT__NAME, IBSItemProvider.COL_NAME);
		map.put(UmaPackage.Literals.METHOD_ELEMENT__PRESENTATION_NAME, IBSItemProvider.COL_PRESENTATION_NAME);
		return map;
	}
	
	/**
	 * Model Validation Service interface for batch validation of EMF elements.
	 */
	private final IBatchValidator batchValidator;

	/**
	 * Initializes me.
	 */
	public LibraryEValidator() {
		super();

		batchValidator = (IBatchValidator) ModelValidationService.getInstance()
				.newValidator(EvaluationMode.BATCH);
		batchValidator.setIncludeLiveConstraints(true);
		batchValidator.setReportSuccesses(false);
		batchValidator.addConstraintFilter(new IConstraintFilter() {

			public boolean accept(IConstraintDescriptor constraint,
					EObject target) {
				Set<Category> categories = constraint.getCategories();
				if(categories != null && !categories.isEmpty()) {
					for (Iterator<Category> iterator = categories.iterator(); iterator
							.hasNext();) {
						Category category = (Category) iterator.next();
						if(CONSTRAINT_CATEGORY.equals(category.getId())) {
							return true;
						}
					}
				}
				return false;
			}
			
		});
	}

	public boolean validate(EObject eObject, DiagnosticChain diagnostics,
			Map context) {
		return validate(eObject.eClass(), eObject, diagnostics, context);
	}

	/**
	 * Implements validation by delegation to the EMF validation framework.
	 */
	public boolean validate(EClass eClass, EObject eObject,
			DiagnosticChain diagnostics, Map context) {
		// first, do whatever the basic EcoreValidator does
		// super.validate(eClass, eObject, diagnostics, context);

		IStatus status = Status.OK_STATUS;

		IValidationManager validationMgr = LibraryEditUtil.getInstance().getValidationManager();
		boolean checkCircular = validationMgr == null ? false : validationMgr.isCircularDependancyCheck();
		boolean circularCheckOk = true;
		DependencyValidationMgr mgr = (DependencyValidationMgr) context.get(CTX_DEPENDENCY_VALIDATION_MGR);
		if (checkCircular && DependencyChecker.newCheck && mgr != null && 
				(eObject instanceof VariabilityElement || eObject instanceof MethodPlugin)) {
			status = mgr.checkCircularDependnecy((MethodElement) eObject);
			if(!status.isOK()) {
				circularCheckOk = false;
				String msg = status.getMessage();
				if(StrUtil.isBlank(msg)) {
					//msg = NLS.bind(ValidationResources.circularDependency_error, ref.getEContainingClass().getName(), ref.getName());
					msg = ValidationResources.circularDependency_error;
				}
				appendDiagnostics(status, diagnostics);
			}
		}
		
		// no point in validating if we can't report results
		if (diagnostics != null) {
			// if EMF Mode Validation Service already covered the sub-tree,
			// which it does for efficient computation and error reporting,
			// then don't repeat (the Diagnostician does the recursion
			// externally). If there is no context map, then we can't
			// help it
			if (!hasProcessed(eObject, context)) {
				if (getTraversalType(context) == LibraryTraversalStrategy.DEEP) {
					batchValidator
							.setTraversalStrategy(LibraryTraversalStrategy.deepTraversalStrategy);
				}
				
				IConstraintFilter filter = (IConstraintFilter) context.get(CTX_CONSTRAINT_FILTER);
				if(filter != null) {
					batchValidator.addConstraintFilter(filter);
				}
				try {
					boolean checkName = validationMgr == null ? false : validationMgr.isNameCheck();
					if (checkName) {
						status = batchValidator.validate(eObject,
							new NullProgressMonitor());
					}
				} finally {
					if (filter != null) {
						batchValidator.removeConstraintFilter(filter);
					}
				}

				processed(eObject, context, status);

				appendDiagnostics(status, diagnostics);
			}
		}

		if (eObject instanceof ProcessComponent) {
			Process proc = ((ProcessComponent) eObject).getProcess();
			if (proc != null) {
				validateProcess(proc, diagnostics, context);
			}
		}

		return circularCheckOk && status.isOK();
	}
	
	/**
	 * @param proc
	 * @param diagnostics
	 * @param context
	 */
	public void validateProcess(Process proc, final DiagnosticChain diagnostics,
			Map context) {
		Object o = context.get(CTX_ADAPTER_FACTORY_PROVIDER);
		if (!(o instanceof IAdapterFactoryProvider)) {
			return;
		}

		class FilteredAdapterFactoryTreeIterator extends AdapterFactoryTreeIterator {
			
			public FilteredAdapterFactoryTreeIterator(AdapterFactory adapterFactory, Object object) {
				super(adapterFactory, object);
			}
			
			protected boolean accept(Object child) {
				return child instanceof NamedElement;
			}
			
			/**
			 * Comment for <code>serialVersionUID</code>
			 */
			private static final long serialVersionUID = 0L;

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator#getChildren(java.lang.Object)
			 */
			protected Iterator getChildren(Object o) {
				ArrayList children = new ArrayList();
				for (Iterator iter = super.getChildren(o); iter.hasNext();) {
					Object child = iter.next();
					if (child instanceof MethodElement
							|| (child instanceof DescribableElementWrapperItemProvider
							&& !((DescribableElementWrapperItemProvider) child).isReadOnly())) {
						children.add(child);
						child = TngUtil.unwrap(child);
					}
					if (accept(child)) {
						try {
							ArrayList features = new ArrayList();
							features.add(UmaPackage.Literals.NAMED_ELEMENT__NAME);
							if(child instanceof DescribableElement) {
								features.add(UmaPackage.Literals.METHOD_ELEMENT__PRESENTATION_NAME);
							}
							NamedElement e = (NamedElement) child;
							if (e instanceof BreakdownElement) {
								//continue;
							}
							if(DEBUG) {
								System.out
										.println("FilteredAdapterFactoryTreeIterator.getChildren(): validating '" + e.getName() + "'"); //$NON-NLS-1$ //$NON-NLS-2$
							}
							for (Iterator iterator = features.iterator(); iterator
									.hasNext();) {
								EStructuralFeature feature = (EStructuralFeature) iterator.next();
								IValidator validator = IValidatorFactory.INSTANCE
										.createValidator(o, null,
												(EObject) child, feature,
												adapterFactory);
								Object itemProvider = adapterFactory.adapt(child, ITreeItemContentProvider.class);
								String prop = (String) featureToPropertyMap.get(feature);
								String name;
								if(itemProvider instanceof IBSItemProvider && prop != null) {
									name = ((IBSItemProvider)itemProvider).getAttribute(child, prop);
								}
								else {
									name = (String) e.eGet(feature);
								}
								String msg = validator.isValid(name);
								if (msg != null) {
									appendDiagnostics(new ValidationStatus(
											IStatus.ERROR, 0, msg, e, feature),
											diagnostics);
								}
							}
						} catch (Exception e) {

						}
					}
				}				
				return children.iterator();
			}
		};
		IAdapterFactoryProvider provider = (IAdapterFactoryProvider) o;
		Iterator iterator = new FilteredAdapterFactoryTreeIterator(provider
				.getWBSAdapterFactory(), proc);
		for (; iterator.hasNext(); iterator.next())
			;
		
		iterator = new FilteredAdapterFactoryTreeIterator(provider.getTBSAdapterFactory(), proc) {
			/**
			 * Comment for <code>serialVersionUID</code>
			 */
			private static final long serialVersionUID = 1L;

			/* (non-Javadoc)
			 * @see #accept(java.lang.Object)
			 */
			protected boolean accept(Object child) {
				return child instanceof RoleDescriptor || child instanceof TeamProfile;
			}
		};
		for (; iterator.hasNext(); iterator.next())
			;
		
		iterator = new FilteredAdapterFactoryTreeIterator(provider.getWPBSAdapterFactory(), proc) {
			/**
			 * Comment for <code>serialVersionUID</code>
			 */
			private static final long serialVersionUID = 1L;

			/* (non-Javadoc)
			 * @see #accept(java.lang.Object)
			 */
			protected boolean accept(Object child) {
				return child instanceof WorkProductDescriptor;
			}
		};
		for (; iterator.hasNext(); iterator.next())
			;
	}

	private static int getTraversalType(Map context) {
		Object type = context.get(LibraryTraversalStrategy.TRAVERSAL_TYPE);
		return (type instanceof Number && ((Number) type).intValue() == LibraryTraversalStrategy.DEEP) ? LibraryTraversalStrategy.DEEP
				: LibraryTraversalStrategy.SHADOW;
	}

	/**
	 * Direct validation of {@link EDataType}s is not supported by the EMF
	 * validation framework; they are validated indirectly via the
	 * {@link EObject}s that hold their values.
	 */
	public boolean validate(EDataType eDataType, Object value,
			DiagnosticChain diagnostics, Map context) {
		return super.validate(eDataType, value, diagnostics, context);
	}

	/**
	 * If we have a context map, record this object's <code>status</code> in
	 * it so that we will know later that we have processed it and its sub-tree.
	 * 
	 * @param eObject
	 *            an element that we have validated
	 * @param context
	 *            the context (may be <code>null</code>)
	 * @param status
	 *            the element's validation status
	 */
	private void processed(EObject eObject, Map context, IStatus status) {
		if (context != null) {
			context.put(eObject, status);
		}
	}

	/**
	 * Determines whether we have processed this <code>eObject</code> before,
	 * by automatic recursion of the EMF Model Validation Service. This is only
	 * possible if we do, indeed, have a context.
	 * 
	 * @param eObject
	 *            an element to be validated (we hope not)
	 * @param context
	 *            the context (may be <code>null</code>)
	 * @return <code>true</code> if the context is not <code>null</code> and
	 *         the <code>eObject</code> or one of its containers has already
	 *         been validated; <code>false</code>, otherwise
	 */
	private boolean hasProcessed(EObject eObject, Map context) {
		boolean result = false;

		if (context != null) {
			// this is O(NlogN) but there's no helping it
			while (eObject != null) {
				if (context.containsKey(eObject)) {
					result = true;
					eObject = null;
				} else {
					eObject = eObject.eContainer();
				}
			}
		}

		return result;
	}

	/**
	 * Converts a status result from the EMF validation service to diagnostics.
	 * 
	 * @param status
	 *            the EMF validation service's status result
	 * @param diagnostics
	 *            a diagnostic chain to accumulate results on
	 */
	public static void appendDiagnostics(IStatus status, DiagnosticChain diagnostics) {
		if (status.isMultiStatus()) {
			IStatus[] children = status.getChildren();

			for (int i = 0; i < children.length; i++) {
				appendDiagnostics(children[i], diagnostics);
			}
		} else if (status instanceof IConstraintStatus) {
			diagnostics.add(new BasicDiagnostic(status.getSeverity(), status
					.getPlugin(), status.getCode(), status.getMessage(),
					((IConstraintStatus) status).getResultLocus().toArray()));
		} else if (status instanceof org.eclipse.epf.library.edit.validation.ValidationStatus) {
			diagnostics.add(new BasicDiagnostic(status.getSeverity(), status
					.getPlugin(), status.getCode(), status.getMessage(),
					new Object[] { ((org.eclipse.epf.library.edit.validation.ValidationStatus) status)
							.getCheckedObject() }));
		} else {
			diagnostics.add(new BasicDiagnostic(status.getSeverity(), status
					.getPlugin(), status.getCode(), status.getMessage(),
					null));
		}
	}

}