ontomde-java 2.0.0

data/lib/ontomde-java/jpdl/jpdl_deploy.rb

@@ -0,0 +1,114 @@
+
+module Mrdf_Repository
+
+  BPM_JPDL_DEPLOY_CLASS="xmda.jpdl.Deploy"
+
+  # Generates a JPDL deployer as a JUNIT class
+  # Junit provides easy diagnostic an a convenient GUI
+  def bpm_genJPDLDeploy
+    #TODO A enlever
+    return
+    mrdf=context[:umlModel,self]
+    muml=mrdf.umlx_reserved_model
+
+    deploy=muml.umlx_getOrCreateClass(BPM_JPDL_DEPLOY_CLASS)
+    return unless deploy.java_customCode.empty?
+
+    deploy.umlx_businessMethod=RDF_FALSE
+    deploy.apaCom_addLogger!
+    deploy.umlx_external=RDF_FALSE
+    deploy.java_import_add('org.junit.*')
+    deploy.java_import_add('java.io.PrintWriter');
+    deploy.java_import_add('java.io.StringWriter');
+
+    deploy.db_isTransient=RDF_TRUE
+    deploy.struts_isForm=RDF_FALSE
+
+
+    bpm_allProcess.each { |c|
+      op=deploy.umlx_createAndAddOperation("#{c.rdf_uri}_deploy","deploy_#{c.bpm_processName.to_s.tr('.','_')}")
+      op.java_annotation_add('@org.junit.Test')
+      op.umlx_businessMethod=RDF_FALSE
+      op.java_code=%{
+	#{c.bpm_javaProcessJobsClass_one.java_qualifiedName} c=new #{c.bpm_javaProcessJobsClass_one.java_qualifiedName}();
+	try {
+	c.deploy();
+	} catch (Exception e) {
+		StringWriter s=new StringWriter();
+		PrintWriter p = new PrintWriter(s);
+		e.printStackTrace(p);
+		org.junit.Assert.fail(e.toString()+"\\n\\n"+s.toString());
+	}
+      }
+    }
+    bpm_allProcess.each { |c|
+      op=deploy.umlx_createAndAddOperation("#{c.rdf_uri}_deploy}","ping_#{c.bpm_processName.to_s.tr('.','_')}")
+      op.java_annotation_add('@org.junit.Test')
+      op.umlx_businessMethod=RDF_FALSE
+      op.java_code=%{
+	#{c.bpm_javaProcessJobsClass_one.java_qualifiedName} c=new #{c.bpm_javaProcessJobsClass_one.java_qualifiedName}();
+	try {
+	c.start();
+	} catch (Exception e) {
+		StringWriter s=new StringWriter();
+		PrintWriter p = new PrintWriter(s);
+		e.printStackTrace(p);
+		org.junit.Assert.fail(e.toString()+"\\n\\n"+s.toString());
+	}
+      }
+    }
+
+
+    deploy.java_customCode= %{
+	/**
+	 * @throws java.lang.Exception
+	 */
+	@org.junit.BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+	/**
+	 * @throws java.lang.Exception
+	 */
+	@org.junit.AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+	/**
+	 * @throws java.lang.Exception
+	 */
+	@org.junit.Before
+	public void setUp() throws Exception {
+	}
+	/**
+	 * @throws java.lang.Exception
+	 */
+	@org.junit.After
+	public void tearDown() throws Exception {
+		//TODO: cleanup db
+	}
+	public static junit.framework.Test suite(){
+    		return new junit.framework.JUnit4TestAdapter(#{deploy.java_qualifiedName}.class);
+   	}
+	@Test
+	public void check_database_connection() {
+		log.error("TODO: check db connection");
+	}
+	@Test
+	public void install_jbpm_schema() {
+		log.error("TODO: install jbpm schema");
+
+
+	//private JbpmConfiguration jbpmConfiguration = null;
+	//protected void deploy(String processDef) throws Exception {
+	//	try {
+	//		jbpmContext = jbpmConfiguration.createJbpmContext();
+	//		jbpmContext.deployProcessDefinition(processDef);
+	//	} finally {
+	//		jbpmContext.close();
+	//	}
+	//}
+
+
+	}
+    }
+  end
+end

data/lib/ontomde-java/jpdl/main.rb

@@ -0,0 +1,348 @@
+#:include: main.rdoc
+
+require "rexml/document"
+
+module Mrdf_Repository
+  def java_getClassWithQualifiedName(qname)
+    uml_Class_all.each { |f|
+      return f if f.java_qualifiedName.to_s.casecmp(qname)==0
+    }
+    puts "not found #{qname}"
+    #exit 1
+    return nil
+  end
+  
+  #loads bpm meta-model from protege/2000 DSL model.
+  #
+  #You can browse bpm meta-model with protege/2000 using
+  #bpm.pprj protege/2000 project in this file directory.
+  def bpm_loadBPM
+    loadMetaModelFromFile("#{File.dirname(__FILE__)}/bpm.rdfs",true)
+  end
+  
+  def bpm_transform!
+    #mtk_writeSession("bpm.log") {
+    s=Array.new
+    each { |k,res|
+      next unless res.kind_of?(Mbpm_process)
+      s << res
+    }
+    s.each { |res|
+      res.bpm_transform!
+    }
+    #bpm_dumpJPDL
+    bpm_genJPDLDeploy
+  end
+
+  #adds ping node to all process in model
+  #(feature used for process deployement test)
+  def bpm_addPingNode!
+    bpm_allProcess.each { |c|
+      c.bpm_addPingNode!
+    }
+  end
+
+  def bpm_allProcess(ret=Array.new)
+    self.each { |k,c|
+      ret<< c if c.kind_of?(Mbpm_process)
+    }
+    return ret
+  end
+end
+
+module Muml_ClassProcess
+  #Surcharge pour les objets de type Process cette méthode
+  #afin de ne pas avoir l'id généré
+  def jpa_deriveFromPersistent?
+    return true;
+  end
+end
+
+
+module Mbpm_process
+  rdf_safe_attr_reader_many :bpm_javaProcessJobsClass
+
+  # returns a qualified name for this process
+  #(return processName itself because processName is supposed to be a qualifiedName)
+  def bpm_qualifiedName
+    return bpm_processName.to_s
+  end
+
+  def bpm_getProcessClass(muml)
+    bpmClass = BPM::BpmClass
+    bpmClass += "<#{self.bpm_processReturnTypeOrNullReturn}>"
+    ret=muml.umlx_getOrCreateClass(bpmClass)
+    ret.java_isGeneric=RDF_TRUE
+    #ret.db_isTransient=RDF_FALSE
+    ret.db_isTransient=RDF_FALSE
+    puts "ProcessClass = #{bpmClass}"
+    return ret
+  end
+
+  def bpm_transform!
+    mrdf=context[:umlModel,self.rdf_Repository]
+    muml=mrdf.umlx_reserved_model
+    j=mrdf.java_getClassWithQualifiedName(bpm_qualifiedName)
+    j=muml.umlx_getOrCreateClass("#{bpm_qualifiedName}",::Muml_Namespace::UMLX_SEARCH_EVERY_MODEL) if j.nil?
+    #TODO Gérer la récupération dans la signature de la méthode du type et la génération de deux méthodes
+    #Evite la génération de l'ID
+    j.extend(Muml_ClassProcess);
+    j.db_isTransient=RDF_FALSE
+    self.bpm_javaProcessJobsClass=j # store direct reference
+    j.umlx_external="false"
+
+    j.umlx_createAndAddGeneralization( bpm_getProcessClass(muml))
+
+
+    bpm_processNode.each {|n|
+      next if n.kind_of?(Mbpm_passive_Node)
+      if n.kind_of?(Mbpm_source_Node)
+        n.bpm_createEnumerationForTransitions!(j)
+      end
+      #n.bpm_createConnectorForNodeAction!
+      n.bpm_addJavaProcessOperation(j)
+    }
+
+    m=j.umlx_createAndAddOperation("#{j.rdf_uri}_processDefinition","getProcessDefinition")
+    m.java_annotation_add("@Override")
+    p=m.umlx_createAndAddReturnParameter("#{j.rdf_uri}_ret","return")
+    p.uml_type=j.umlx_dataType_string
+    m.java_code=%{return ""\n#{mtk_stss{bpm_writeJPDL}.gsub(/"/,'\\"').gsub(/^(.*)$/,'     +"\1"')};}
+
+    # external process name
+    m=j.umlx_createAndAddOperation("#{j.rdf_uri}_externalProcessName","getExternalProcessName")
+    p=m.umlx_createAndAddReturnParameter("#{j.rdf_uri}_ret","return")
+    p.uml_type=j.umlx_dataType_string
+    m.java_code=%{return "#{bpm_qualifiedName}";}
+
+
+    me=j.umlx_createAndAddOperation("#{j.rdf_uri}_onEnd","xmdaOnEnd")
+    me.java_annotation_add("@Override")
+    p=me.umlx_createAndAddReturnParameter("#{me.rdf_uri}_ret","return")
+
+    p.uml_type=j.umlx_getOrCreateClass("#{bpm_processReturnTypeOrNullReturn}")
+    me.java_code=%{return null;}
+
+    #    p.uml_type=j.umlx_getOrCreateClass("java.lang.Class")
+
+    # external process id
+    # moved to base class
+    #p=j.umlx_createAndAddProperty("#{j.rdf_uri}_externalBPMid","BpmExternalId")
+    #m.uml_type=j.umlx_dataType_long
+
+  end
+
+  #pingTest node is a node added to
+  #ping the process for testing purposses
+  #and deployement test purposes
+  def bpm_addPingNode!
+    return unless context[:bpm_addPingNode,true]
+    s=bpm_getOrCreateStartNode
+    e=bpm_getOrCreateEndNode
+    d=bpm_createAndAddSynchronousDecisionNode("_pingMode")
+    t=s.bpm_leavingTransition_one
+
+    #insert node d between s and first node after s
+    d.bpm_addTransition!("productionMode",t.bpm_destinationNode_one)
+    d.bpm_addTransition!("testMode",e)
+    t.bpm_destinationNode=d
+  end
+
+  #create
+  def bpm_createAndAddSynchronousDecisionNode(name)
+    ret=Cbpm_synchronousDecisionNode.new(self.rdf_Repository,"#{self.rdf_uri}_#{name}")
+    ret.bpm_nodeName=name
+    self.bpm_processNode_add(ret)
+    return ret
+  end
+
+  #returns process start node
+  #creates one if necessary
+  def bpm_getOrCreateStartNode
+    bpm_processNode.each {|n|
+      return n if n.kind_of?(Mbpm_startNode)
+    }
+    ret=Cbpm_startNode.new(self.rdf_Repository,"#{self.rdf_uri}_startNode")
+    ret.bpm_nodeName="startNode"
+    self.bpm_processNode_add(ret)
+    return ret
+  end
+  #returns process start node
+  #creates one if necessary
+  def bpm_getOrCreateEndNode
+    bpm_processNode.each {|n|
+      return n if n.kind_of?(Mbpm_endNode)
+    }
+    ret=Cbpm_startNode.new(self.rdf_Repository,"#{self.rdf_uri}_endNode")
+    ret.bpm_nodeName="endNode"
+    self.bpm_processNode_add(ret)
+    return ret
+  end
+
+  def bpm_graphGen_dot
+    mtk_writeSession("bpm.dot") {
+      write("digraph {\n")
+      bpm_processNode.each {|n|
+        n.bpm_graphGen_dot
+      }
+      write ("} // end of file\n")
+    }
+  end
+end
+module Mbpm_named_Node
+  # returns a qualified name for this node
+  def bpm_qualifiedName
+    return "#{bpm_processNode_inv_one.bpm_qualifiedName}.#{bpm_nodeName}"
+  end
+
+  def hasMultipleTransitions?
+    return false
+  end
+
+  #adds a method in java process for this node
+  def bpm_addJavaProcessOperation(j)
+    o=nil
+    j.uml_ownedOperation.each { |op|
+      o=op if op.java_Name.to_s.casecmp(op.java_safeName(self.bpm_nodeName.to_s))==0
+    }
+    o=j.umlx_createAndAddOperation(self.rdf_uri+"meth",self.bpm_nodeName) if o.nil?
+    o.uml_name=self.bpm_nodeName #case fix
+    if self.kind_of?(Mbpm_source_Node) && hasMultipleTransitions?
+      r=o.umlx_createAndAddReturnParameter(o.rdf_uri+"_return")
+      r.uml_type=self.bpm_javaTransitionNameEnum_one
+      o.java_code=<<END
+//TODO: replace this test code by real implementation
+log.debug("test method called #{o.uml_name}");
+return #{self.bpm_javaTransitionNameEnum_one.java_qualifiedName}.values()[0];
+END
+    else
+      o.java_code=<<END
+//TODO: replace this test code by real implementation
+log.debug("test method called #{o.uml_name}");
+END
+    end
+    if self.kind_of?(Mbpm_asynchronousNode)
+      #Ajout du paramètre callback
+      p=o.umlx_createAndAddParameter(o.rdf_uri+"_param", "_callback")
+      mrdf=context[:umlModel,self.rdf_Repository]
+      muml=mrdf.umlx_reserved_model
+      i=muml.umlx_getOrCreateInterface(BPM::CallbackClass)
+      i.umlx_external="true"
+      p.uml_type=i
+    end
+  end
+end
+
+module Mbpm_source_Node
+  rdf_safe_attr_reader_many :bpm_javaTransitionNameEnum
+
+  #Indique si ce noeud a plusieurs sorties et donc si on génère un Enum pour son type de retour
+  def hasMultipleTransitions?
+    return false if bpm_leavingTransition.nil?
+    nb = 0
+    bpm_leavingTransition.each { |transition|
+      nb += 1 if !transition.kind_of?(Mbpm_timeOutTransition)
+    }
+    return nb > 1
+  end
+
+  # creates an uml enumeration listing
+  # every node leaving this transition
+  # This is usefull for decision node.
+  def bpm_createEnumerationForTransitions!(processClass)
+    mrdf=context[:umlModel,self.rdf_Repository]
+    muml=mrdf.umlx_reserved_model
+    p=processClass.umlx_owner_one
+    return if !hasMultipleTransitions?
+
+    p=p.umlx_getOrCreatePackage(p.context[:bpm_javaSubPackage],p)
+    p=p.umlx_getOrCreatePackage(processClass.uml_name.to_s)
+
+    i=p.umlx_getOrCreateEnumeration("#{bpm_nodeName}_BpmTransitions",p)
+    i.umlx_external="false"
+    self.bpm_javaTransitionNameEnum=i
+    bpm_leavingTransition.each { |t|
+      i.umlx_createAndAddLiteral(t.bpm_transitionName.to_s)
+    }
+  end
+end
+module Mbpm_decision_Node
+  def not_used_bpm_createConnectorForNodeAction!
+    mrdf=context[:umlModel,self.rdf_Repository]
+    #muml=mrdf.umlx_reserved_model
+    j=muml.umlx_getOrCreateClass("#{bpm_qualifiedName} Connector")
+    j.umlx_external="false"
+
+
+    m=j.umlx_createAndAddOperation("#{self.rdf_uri}_connectorMethod","execute")
+    i=muml.umlx_getOrCreateInterface("jpdl.anInterface_tbd")
+    i.umlx_external="true"
+    j.umlx_createAndAddImplementation(i)
+
+  end
+end
+module Mbpm_node
+  def bpm_graphGen_dot
+    return # todo
+    write %{#{self.dotId} [#{bpm_dotStyle}]\n}
+    bpm_leavingTransition.each { |t|
+      e=t.bpm_enteringTransition_inv_one
+      write %{#{self.dotId} -> #{e.dotId} \n}
+    } if kind_of?(Mbpm_source_Node)
+
+  end
+
+end
+
+
+module Mbpm_startNode
+  def bpm_nodeName
+    return "start"
+  end
+end
+
+module Mbpm_endNode
+  def bpm_nodeName
+    return "end"
+  end
+end
+
+module Mbpm_source_Node
+  def bpm_addTransition!(transitionName,targetNode)
+    t=Cbpm_transition.new(self.rdf_Repository,"#{self.rdf_uri}_#{transitionName}")
+    self.bpm_leavingTransition_add(t)
+    t.bpm_destinationNode=targetNode
+    t.bpm_transitionName=transitionName
+  end
+end
+
+
+
+
+class DatatypeMappingCallback < DatatypeMapping
+  include Singleton
+
+  #default string length
+  @maxStringLength=10
+
+  MATCHING_UML_NAME=["XmdaCallbackHandler"]
+    def appliesTo?(datatype)
+    return true if MATCHING_UML_NAME.include?(datatype.uml_name_one)
+    #return true if MATCHING_JAVA_NAME.include?(datatype.java_qualifiedName)
+    return false
+  end
+
+  def java_getType
+    return "xmda.bpm.api.XmdaCallbackHandler"
+  end
+  
+  def java_getJavaToString(jsrc)
+    return "null"
+  end
+  def java_getJavaParse(jsrc)
+    return "null"
+  end
+  
+end
+DatatypeMappingCallback.instance #register
+