standardpackagevalidator.java

来自「jawe的最新版本,基于Java的图形化工作流编辑器。图形化工作流编辑器 。使用」· Java 代码 · 共 1,501 行 · 第 1/5 页

package org.enhydra.shark.xpdl;

import java.io.ByteArrayOutputStream;
import java.io.StringReader;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.apache.xerces.parsers.DOMParser;
import org.enhydra.shark.xpdl.elements.*;
import org.enhydra.shark.xpdl.elements.Package;
import org.enhydra.shark.xpdl.elements.Version;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;

/**
 * Represents coresponding element from XPDL schema.
 * 
 * @author Sasa Bojanic
 */
public class StandardPackageValidator implements XMLValidator {

   public static final String VALIDATE_SUBFLOW_REFERENCES = "ValidateSubFlowReferences";

   public static final String VALIDATE_PERFORMER_EXPRESSIONS = "ValidatePerformerExpressions";

   public static final String VALIDATE_ACTUAL_PARAMETER_EXPRESSIONS = "ValidateActualParameterExpressions";

   public static final String VALIDATE_DEADLINE_EXPRESSIONS = "ValidateDeadlineExpressions";

   public static final String VALIDATE_CONDITION_EXPRESSIONS = "ValidateConditionExpressions";

   public static final String VALIDATE_UNUSED_VARIABLES = "ValidateUnusedVariables";

   public static final String VALIDATE_CONDITION_BY_TYPE = "ValidateConditionByType";

   public static final String GET_EXISTING_SCHEMA_VALIDATION_ERRORS = "GetExistingSchemaValidationErrors";

   public static final String CHECK_EXTERNAL_PACKAGES = "CheckExternalPackages";

   public static final String ALLOW_UNDEFINED_START = "AllowUndefinedStart";

   public static final String ALLOW_UNDEFINED_END = "AllowUndefinedEnd";

   public static final String ENCODING = "Encoding";

   public static final String LOCALE = "Locale";

   protected static final String CURRENT_XPDL_VERSION = "1.0";

   protected Properties properties;

   protected XMLInterface xmlInterface;

   protected Map epsValidationErrors = new HashMap();

   protected Map schemaValidationErrors = new HashMap();

   protected Properties settings;

   public StandardPackageValidator() {
   }

   public StandardPackageValidator(Properties settings) {
      this.settings = settings;
   }

   public void init(XMLInterface pXmlInterface,
                    Package pPkg,
                    boolean pGetExistingSchemaValidationErrors,
                    String pEncoding,
                    String pLocale) {
      Properties tempProperties = new Properties();
      tempProperties.putAll(settings);
      tempProperties.put(StandardPackageValidator.GET_EXISTING_SCHEMA_VALIDATION_ERRORS,
                         String.valueOf(pGetExistingSchemaValidationErrors));
      tempProperties.put(StandardPackageValidator.CHECK_EXTERNAL_PACKAGES, "true");
      tempProperties.put(StandardPackageValidator.ENCODING, pEncoding);
      tempProperties.put(StandardPackageValidator.LOCALE, pLocale);
      init(tempProperties, pXmlInterface);
   }

   public void clearCache(Package pkg) {
      epsValidationErrors.remove(pkg);
      schemaValidationErrors.remove(pkg);
   }

   public void clearCache() {
      epsValidationErrors.clear();
      schemaValidationErrors.clear();
      xmlInterface = null;
   }

   public Map getExtPkgValidationErrors() {
      return epsValidationErrors;
   }

   public void init(Properties props) {
      this.properties = props;
      if (props == null) {
         clearCache();
      }
   }

   public void init(Properties pProps, XMLInterface pXmlInterface) {
      init(pProps);
      this.xmlInterface = pXmlInterface;
   }

   public void validateElement(XMLElement el, List existingErrors, boolean fullCheck) {
      if (!fullCheck && existingErrors.size() > 0) {
         return;
      }
      if (el.isEmpty() && !(el instanceof XMLCollection) && !el.isRequired()) {
         return;
      }

      try {
         Class cl = el.getClass();
         Method m = null;
         try {
            m = this.getClass().getMethod("validateElement", new Class[] {
                  cl, List.class, boolean.class
            });
         } catch (Exception ex) {
            if (!(cl == XMLSimpleElement.class
                  || cl == XMLAttribute.class || cl == XMLComplexChoice.class
                  || cl == XMLComplexElement.class || cl == XMLCollectionElement.class || cl == XMLCollection.class)) {
               if (XMLComplexChoice.class.isAssignableFrom(cl)) {
                  cl = XMLComplexChoice.class;
               } else if (XMLAttribute.class.isAssignableFrom(cl)) {
                  cl = XMLAttribute.class;
               } else if (XMLSimpleElement.class.isAssignableFrom(cl)) {
                  cl = XMLSimpleElement.class;
               } else if (XMLComplexElement.class.isAssignableFrom(cl)) {
                  cl = XMLComplexElement.class;
               } else if (XMLCollection.class.isAssignableFrom(cl)) {
                  cl = XMLCollection.class;
               }
            }
         }

         m = this.getClass().getMethod("validateElement", new Class[] {
               cl, List.class, boolean.class
         });
         // System.err.println("calling "+m.toString()+",
         // el=["+el.toName()+","+el.toValue()+"]");
         m.invoke(this, new Object[] {
               el, existingErrors, new Boolean(fullCheck)
         });
         return;
      } catch (Throwable e) {
         e.printStackTrace();
      }

      validateStandard(el, existingErrors, fullCheck);
   }

   public void validateElement(XMLAttribute el, List existingErrors, boolean fullCheck) {
      XMLElement parent = el.getParent();

      boolean isValid = true;
      if (el.toName().equals("Id")) {
         if (parent instanceof SubFlow) {
            checkSubFlowId(el, existingErrors, fullCheck);
         } else if (parent instanceof Tool) {
            checkToolId(el, existingErrors, fullCheck);
         } else if (parent instanceof TransitionRef) {
            checkTransitionRefId(el, existingErrors, fullCheck);
         } else if (parent instanceof DeclaredType) {
            checkDeclaredTypeId(el, existingErrors);
         } else {
            if (!isIdValid(el.toValue())) {
               isValid = false;
               XMLValidationError verr = new XMLValidationError(XMLValidationError.TYPE_ERROR,
                                                                XMLValidationError.SUB_TYPE_LOGIC,
                                                                XPDLValidationErrorIds.ERROR_INVALID_ID,
                                                                el.toValue(),
                                                                el);
               existingErrors.add(verr);
            }
            if ((parent instanceof XMLCollectionElement) && (fullCheck || isValid)) {
               if (!isIdUnique((XMLCollectionElement) parent)) {
                  isValid = false;
                  XMLValidationError verr = new XMLValidationError(XMLValidationError.TYPE_ERROR,
                                                                   XMLValidationError.SUB_TYPE_LOGIC,
                                                                   XPDLValidationErrorIds.ERROR_NON_UNIQUE_ID,
                                                                   el.toValue(),
                                                                   el);
                  existingErrors.add(verr);
               }
            }
         }
      } else if (el.toName().equals("href")) {
         if (parent instanceof ExternalPackage) {
            String val = el.toValue();
            Package pkg = XMLUtil.getPackage(el);
            String epId = pkg.getExternalPackageId(val);
            if (epId == null || epId.equals("")) {
               XMLValidationError verr = new XMLValidationError(XMLValidationError.TYPE_ERROR,
                                                                XMLValidationError.SUB_TYPE_LOGIC,
                                                                XPDLValidationErrorIds.ERROR_NON_EXISTING_EXTERNAL_PACKAGE_REFERENCE,
                                                                val,
                                                                el);
               existingErrors.add(verr);
            }
         }
      } else if (parent instanceof Transition) {
         if (el.toName().equals("From")) {
            checkTransitionFrom(el, existingErrors);
         } else if (el.toName().equals("To")) {
            checkTransitionTo(el, existingErrors);
         }
      } else if (parent instanceof BlockActivity) {
         checkBlockId(el, existingErrors);
      }

   }

   public void validateElement(XMLComplexChoice el, List existingErrors, boolean fullCheck) {
      validateElement(el.getChoosen(), existingErrors, fullCheck);
   }

   public void validateElement(XMLEmptyChoiceElement el,
                               List existingErrors,
                               boolean fullCheck) {
   }

   public void validateElement(XMLCollection el, List existingErrors, boolean fullCheck) {
      for (Iterator it = el.toElements().iterator(); it.hasNext();) {
         XMLElement cel = (XMLElement) it.next();
         validateElement(cel, existingErrors, fullCheck);
      }
   }

   public void validateElement(XMLCollectionElement el,
                               List existingErrors,
                               boolean fullCheck) {
      validateElement((XMLComplexElement) el, existingErrors, fullCheck);
   }

   public void validateElement(XMLComplexElement el,
                               List existingErrors,
                               boolean fullCheck) {
      for (Iterator it = el.toElements().iterator(); it.hasNext();) {
         XMLElement cel = (XMLElement) it.next();
         validateElement(cel, existingErrors, fullCheck);
      }
   }

   public void validateElement(XMLSimpleElement el, List existingErrors, boolean fullCheck) {
   }

   protected void validateStandard(XMLElement el, List existingErrors, boolean fullCheck) {
      if (el instanceof XMLAttribute) {
         validateElement((XMLAttribute) el, existingErrors, fullCheck);
      } else if (el instanceof XMLSimpleElement) {
         validateElement((XMLSimpleElement) el, existingErrors, fullCheck);
      } else if (el instanceof XMLCollectionElement) {
         validateElement((XMLCollectionElement) el, existingErrors, fullCheck);
      } else if (el instanceof XMLComplexElement) {
         validateElement((XMLComplexElement) el, existingErrors, fullCheck);
      } else if (el instanceof XMLComplexChoice) {
         validateElement((XMLComplexChoice) el, existingErrors, fullCheck);
      } else if (el instanceof XMLCollection) {
         validateElement((XMLCollection) el, existingErrors, fullCheck);
      }
   }

   public void validateElement(Activities el, List existingErrors, boolean fullCheck) {
      validateStandard(el, existingErrors, fullCheck);
   }

   public void validateElement(Activity el, List existingErrors, boolean fullCheck) {
      validateStandard(el, existingErrors, fullCheck);

      boolean isValid = existingErrors.size() == 0;

      if (!(isValid || fullCheck)) {
         return;
      }

      Set ets = XMLUtil.getExceptionalOutgoingTransitions(el);
      if (el.getDeadlines().size() > 0) {
         if (ets.size() == 0) {