standardpanelvalidator.java

jawe的最新版本,基于Java的图形化工作流编辑器。图形化工作流编辑器 。使用JAVA语言开发

   public boolean validatePanel(Tool el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(Tools el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(Transition el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TransitionRef el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TransitionRefs el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TransitionRestriction el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TransitionRestrictions el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(Transitions el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TypeDeclaration el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(TypeDeclarations el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(UnionType el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(ValidFrom el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(ValidTo el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(Vendor el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(Version el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(WaitingTime el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(WorkflowProcess el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(WorkflowProcesses el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(WorkingTime el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XPDLVersion el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLComplexChoice el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLCollection el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLCollectionElement el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLComplexElement el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLSimpleElement el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLAttribute el, XMLPanel panel) {
      return standardPanelValidation(el, panel);
   }

   public boolean validatePanel(XMLElement el, XMLPanel panel) {
      try {
         Class cl = el.getClass();
         Method m = null;
         try {
            m = this.getClass().getMethod("validatePanel", new Class[] { cl, XMLPanel.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("validatePanel", new Class[] { cl, XMLPanel.class });
         // System.err.println("calling "+m.toString());
         return ((Boolean) m.invoke(this, new Object[] { el, panel })).booleanValue();
      } catch (Throwable e) {
         e.printStackTrace();
      }

      return standardPanelValidation(el, panel);
   }

   public boolean standardPanelValidation(XMLElement el, XMLPanel panel) {
      boolean idValidation = false;
      if (el instanceof Tool) {
         idValidation = false;
      } else if (el instanceof XMLCollectionElement || el instanceof Package) {
         idValidation = true;
      } else if (el instanceof XMLAttribute && el.toName().equals("Id")
            && (el.getParent() instanceof XMLCollectionElement || el.getParent() instanceof Package)) {
         idValidation = true;
      }
      if (idValidation) {
         if (!validateId(panel, el)) {
            return false;
         }
      }

      if (el instanceof Transition || el instanceof Condition || el.getParent() instanceof Transition || el.getParent() instanceof Condition) {
         if (!validateTransition(panel, el)) {
            return false;
         }
      }
      return true;
   }

   protected boolean validateId(XMLPanel pnl, XMLElement el) {
      XMLComplexElement cel = null;
      String newId = null;
      XMLPanel idPanel = null;
      if (el instanceof XMLAttribute) {
         XMLElement parent = el.getParent();
         if (parent instanceof XMLCollectionElement) {
            cel = (XMLCollectionElement) parent;
            newId = cel.get("Id").toValue();
            if (pnl.getValue() instanceof String) {
               newId = ((String) pnl.getValue()).trim();
               idPanel = pnl;
            }
         } else if (parent instanceof Package) {
            cel = (Package) parent;
            newId = cel.get("Id").toValue();
            if (pnl.getValue() instanceof String) {
               newId = ((String) pnl.getValue()).trim();
               idPanel = pnl;
            }
         }
      } else if (el instanceof XMLComplexElement) {
         cel = (XMLComplexElement) el;
         newId = cel.get("Id").toValue();
         idPanel = findPanel(pnl, cel.get("Id"));
         if (idPanel==null) {
            idPanel=pnl;
         }
         if (idPanel != null) {
            if (idPanel.getValue() instanceof String) {
               newId = ((String) idPanel.getValue()).trim();
            }
            if (idPanel.getValue() instanceof XMLCollectionElement) {
               newId = ((XMLCollectionElement) idPanel.getValue()).getId().trim();
            }
         } else {
            // System.err.println("CCCCCCFFFFFFFIDPPPPPPPPPPPPP");
         }
      }

      System.err.println("Valid for " + el + ", par=" + el.getParent() + ", newid=" + newId + ", idp=" + idPanel);
      boolean isValid = XMLUtil.isIdValid(newId);
      if (!isValid) {
         XMLBasicPanel.errorMessage(pnl.getWindow(), ResourceManager.getLanguageDependentString("ErrorMessageKey"), "",
               ResourceManager.getLanguageDependentString(XPDLValidationErrorIds.ERROR_INVALID_ID));
         idPanel.requestFocus();
         return false;
      }

      if (cel != null) {

         boolean isUniqueId = true;
         if (cel instanceof XMLCollectionElement) {
            isUniqueId = JaWEManager.getInstance().getIdFactory().isIdUnique((XMLCollectionElement) cel, newId);
         } else {
            Package fp = JaWEManager.getInstance().getXPDLHandler().getPackageById(newId);
            if (fp != null && fp != cel && fp.getId().equals(newId)) {
               isUniqueId = false;
            }
         }

         if (!isUniqueId) {
            XMLBasicPanel.errorMessage(pnl.getWindow(), ResourceManager.getLanguageDependentString("ErrorMessageKey"),
                  "", ResourceManager.getLanguageDependentString(XPDLValidationErrorIds.ERROR_NON_UNIQUE_ID));
            idPanel.requestFocus();
            return false;
         }
      }
      return true;
   }

   protected boolean validateTransition(XMLPanel pnl, XMLElement el) {
      Transition tra = XMLUtil.getTransition(el);
      String oldFrom = tra.getFrom();
      String oldTo = tra.getTo();
      String newFrom = oldFrom;
      String newTo = oldTo;
      String newType = tra.getCondition().getType();

      if (el instanceof Transition) {
         XMLPanel ftPanel = findPanel(pnl, tra.get("From"));
         // System.err.println("Found panel From ->"+ftPanel);
         if (ftPanel != null) {
            Object v = ftPanel.getValue();
            // System.err.println("..... panel val ->"+v);
            if (v instanceof XMLElement) {
               if (v instanceof Activity) {
                  newFrom = ((Activity) v).getId();
               }
            } else if (v instanceof String) {
               newFrom = ((String) v).trim();
            }
         }
         ftPanel = findPanel(pnl, tra.get("To"));
         // System.err.println("Found panel To ->"+ftPanel);
         if (ftPanel != null) {
            Object v = ftPanel.getValue();
            // System.err.println("..... panel val ->"+v);
            if (v instanceof XMLElement) {
               if (v instanceof Activity) {
                  newTo = ((Activity) v).getId();
               }
            } else if (v instanceof String) {
               newTo = ((String) v).trim();
            }
         }
         ftPanel = findPanel(pnl, ((Condition)tra.get("Condition")).getTypeAttribute());
         // System.err.println("Found panel From ->"+ftPanel);
         if (ftPanel != null) {
            Object v = ftPanel.getValue();
            // System.err.println("..... panel val ->"+v);
            if (v instanceof String) {
               newType = ((String) v).trim();
            }
         }
      } else if (el instanceof XMLAttribute && (el.toName().equals("From") || el.toName().equals("To"))) {
         Object v = pnl.getValue();
         String toOrFrom = null;
         if (v instanceof XMLElement) {
            if (v instanceof Activity) {
               toOrFrom = ((Activity) v).getId();
            }
         } else if (v instanceof String) {
            toOrFrom = ((String) v).trim();
         }
         if (toOrFrom != null) {
            if (el.toName().equals("From")) {
               newFrom = toOrFrom;
            } else {
               newTo = toOrFrom;
            }
         }
      } else if (el instanceof Condition) {
         XMLPanel ftPanel = findPanel(pnl, ((Condition)tra.get("Condition")).getTypeAttribute());
         // System.err.println("Found panel From ->"+ftPanel);
         if (ftPanel != null) {
            Object v = ftPanel.getValue();
            // System.err.println("..... panel val ->"+v);
            if (v instanceof String) {
               newType = ((String) v).trim();
            }
         }
      } else if (el instanceof XMLAttribute && el.getParent() instanceof Condition && el.toName().equals("Type")) {
         Object v = pnl.getValue();
         if (v instanceof String) {
            newType=((String)v).trim();
         }
      }

      boolean isExcTra=false;
      if (newType.equals(XPDLConstants.CONDITION_TYPE_EXCEPTION) || 
            newType.equals(XPDLConstants.CONDITION_TYPE_DEFAULTEXCEPTION)) {
         isExcTra=true;
      }
//      System.err.println("T=" + oldTo + ", F=" + oldFrom + ", NT=" + newTo + ", NF=" + newFrom+", NT="+newType);

      Activities acts = (Activities) ((XMLCollectionElement) tra.getParent().getParent()).get("Activities");
      Activity actFrom = acts.getActivity(newFrom);
      Activity actTo = acts.getActivity(newTo);
//System.err.println("AF=="+actFrom+", aTO="+actTo);
      if (actFrom == null || actTo == null)
         return false;

      TransitionHandler th = JaWEManager.getInstance().getTransitionHandler();
      List status = new ArrayList();
      boolean ac = th.allowsConnection(actFrom, actTo, tra, isExcTra, status);
//System.err.println("ALLOW C="+ac);

      if (!ac) {
         String errorMsg = "WarningSourceActivityCannotHaveMoreOutgoingTransitions";
         if (((Integer) status.get(0)).intValue() == 2) {
            errorMsg = "WarningTargetActivityCannotHaveMoreIncomingTransitions";
         } else if (((Integer) status.get(0)).intValue() == 3) {
            errorMsg = "ErrorActivityCannotHaveMoreThenOneIncomingOutgoingTransitionFromToTheSameActivity";
         }
         XMLBasicPanel.errorMessage(pnl.getWindow(), ResourceManager.getLanguageDependentString("ErrorMessageKey"), "",
               ResourceManager.getLanguageDependentString(errorMsg));

      }
      return ac;
   }

   public static XMLPanel findPanel(XMLPanel p, XMLElement idEl) {
      if (p instanceof XMLTabbedPanel) {
         return ((XMLTabbedPanel) p).getPanelForElement(idEl);
      } else if (p instanceof XMLGroupPanel) {
         return ((XMLGroupPanel) p).getPanelForElement(idEl);
      }
      return null;
   }

   public Settings getSettings() {
      return null;
   }

}