ontomde-uml2-jpdl 1.0.4

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

@@ -0,0 +1,114 @@
+
+module Mrdf_Model
+
+  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-uml2-jpdl/main.rb

@@ -0,0 +1,311 @@
+#:include: main.rdoc
+
+require "rexml/document"
+
+module Mrdf_Model
+  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
+  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_model]
+    muml=mrdf.umlx_reserved_model
+    j=mrdf.java_getClassWithQualifiedName(bpm_qualifiedName.to_s)
+    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_model,"#{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_model,"#{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_model,"#{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_model]
+      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_model]
+    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_model]
+    #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_model,"#{self.rdf_uri}_#{transitionName}")
+    self.bpm_leavingTransition_add(t)
+    t.bpm_destinationNode=targetNode
+    t.bpm_transitionName=transitionName
+  end
+end

data/lib/ontomde-uml2-jpdl/main.rdoc

@@ -0,0 +1,2 @@
+
+TODO: documentation 

data/lib/ontomde-uml2-jpdl/processOperationToClass.rb

@@ -0,0 +1,316 @@
+
+
+#module Muml_Classifier
+#  STRUTS_APPLY_TO_PARAM="applyTo"
+#  STRUTS_APPLY_TO_PROP="ApplyTo"
+#end
+
+module Muml_Operation
+  rdf_safe_attr_reader_many :bpm_bizOperationReverse
+end
+
+module Muml_Parameter
+  #the method parameter
+  rdf_safe_attr_reader_many :bpm_sourceParameter
+end
+
+
+module Mrdf_Model
+  def bpm_handleProcessMethods!
+    #return unless context[:withGenerateMethodForm]
+    uml_Class_all.each { |c|
+      next unless c.kind_of?(Muml_Class)
+      c.uml_ownedOperation.each {|biz|
+        next unless biz.kind_of?(Muml_Operation)
+        #next unless biz.umlx_businessMethod?
+
+        next if biz.umlx_isConstructor?
+        bpm_processMethods(c, biz) if biz.umlx_hasStereotype?("Process")
+        c.bpm_asyncMethods(biz) if biz.umlx_hasStereotype?("Async")
+        c.bpm_callbackMethods(biz) if biz.umlx_hasStereotype?("Callback")
+      }}
+  end
+
+
+  def bpm_processMethods(c, biz)
+
+    p=c.umlx_package
+    if p.nil?
+      log.error{"Model modification required !!! class #{c} is in root model element. Classes should be in a package."}
+      next
+    end
+    #Type de retour dans le mod�le
+    initialReturnParam = biz.uml_getReturnParameter
+    mpc=java_getClassWithQualifiedName("#{c.umlx_owner_one.java_qualifiedName}.#{biz.java_Name}")
+    mpc=p.umlx_createAndAddClass(biz.rdf_uri+"_proc") if mpc.nil?
+    mpc.umlx_businessMethod=RDF_TRUE
+    mpc.bpm_addAllOperationAggregateParameterClass!(biz)
+    code=%{ #{mpc.java_qualifiedName} proc=new #{mpc.java_qualifiedName}();}
+    biz.uml_ownedParameter.each { |param|
+      code=code+"proc.set#{param.java_NameBean}(#{param.java_Name});\n"
+    }
+
+    #Set the right Return Type on the Process
+    #If already specified in the Process definition, not overhide
+    #find the corresponding process
+    self.each { |k,p|
+      next if !p.kind_of?(Mbpm_process)
+      if "#{p.bpm_processName}" == "#{mpc.java_qualifiedName}"
+        # bpm_processReturnType is a string
+        p.bpm_processReturnType = initialReturnParam.uml_type.to_s if !initialReturnParam.nil? && p.bpm_processReturnType_one0.nil?
+        break
+      end
+    }
+
+    #If return set handler
+    code_getCallBackMethod = ""
+    if !initialReturnParam.nil?
+      c.bpm_manageAsynchronousMethods(biz)
+      code_getCallBackMethod = "handler"
+    end
+
+
+    #Modifiy the code of the method to manage the asynchronous
+    code=code+"proc.persist();proc.startAsynchronously(#{code_getCallBackMethod});\n"
+    biz.java_code=code
+
+    #Ajoute un champ calcul� pour la visualization de la console
+    console=mpc.umlx_createAndAddProperty(mpc.rdf_uri+"_console","console")
+    console.uml_isDerived=RDF_TRUE
+    console.uml_type=mpc.umlx_getOrCreateDataType("URL")
+    mpc.java_addAccessorsFor!(console)
+    getter = console.java_AttributeGlobalGetter
+    getter[0].java_code = <<END_OF_STRING
+    if (this.getProcessId() != null) {
+        return "/ontomde-bpm-console/processimage?id=" + this.getProcessId();
+    } else {
+        return "#";
+    }
+END_OF_STRING
+
+
+    #    biz.uml_appliedStereotype.each {|s|
+    #      #TODO: utiliser processImpl
+    #      puts "add stereotype #{s} to #{mpc}::#{mpc.class}"
+    #      mpc.uml_appliedStereotype_add(s)
+    #    }
+
+  end
+
+
+end
+
+module Muml_Class
+
+  alias super_jpa_addStdImports! jpa_addStdImports!
+  def jpa_addStdImports!
+    super_jpa_addStdImports!
+
+    java_import_add("xmda.bpm.api.XmdaCallbackHandler")
+    java_import_add("xmda.bpm.api.client.EntityInstanceDescription")
+    java_import_add("xmda.bpm.api.client.EntityTaskDescription")
+    java_import_add("xmda.bpm.api.client.EntityTaskWithoutCallbackDescription")
+    java_import_add("xmda.bpm.api.jms.JmsCallbackHandler")
+    java_import_add(::DB::EntityGenericInterface)
+
+  end
+
+  #Ajoute une m�thode utilitaire pour r�cup�rer un handler correspondant � la m�thode
+  def bpm_callbackMethods(biz)
+    c=self
+    p=c.umlx_package
+    if p.nil?
+      log.error{"Model modification required !!! class #{c} is in root model element. Classes should be in a package."}
+      next
+    end
+    biz.java_annotation_add(%{@xmda.common.Callback})
+    type_callback=biz.bpm_callbackType
+
+    m=c.umlx_createAndAddOperation(biz.rdf_uri+"_handler","getOntomdeHandlerFor#{biz.uml_name}")#+self.java_NameBean)
+    m.uml_isStatic=RDF_TRUE
+    #m.uml_class=self
+    m.uml_visibility=Cuml_VisibilityKind::Public
+    #m.uml_isStatic=RDF_TRUE
+
+    param=m.umlx_createAndAddParameter(m.rdf_uri+"_this","_this")
+    i=c.umlx_getOrCreateInterface(DB::EntityInterface)
+    i.java_isGeneric=RDF_TRUE
+    param.uml_type=i
+    param.uml_direction=Cuml_ParameterDirectionKind::In
+    param.uml_upperValue=umlx_literal(1)
+    param.uml_lowerValue=umlx_literal(1)
+
+    rp=m.umlx_createAndAddParameter(m.rdf_uri+"_ret_param","return")
+    rp.uml_direction=Cuml_ParameterDirectionKind::Return
+    rp.uml_upperValue=umlx_literal(1)
+    rp.uml_lowerValue=umlx_literal(1)
+    i=c.umlx_getOrCreateInterface("xmda.bpm.api.XmdaCallbackHandler<#{type_callback}>")
+    i.java_isGeneric=RDF_TRUE
+    rp.uml_type=i
+    rp.uml_isOrdered=RDF_TRUE
+
+    m.java_annotation_add(%{@SuppressWarnings("unchecked")})
+
+    m.java_code=<<END_OF_STRING
+    return JmsCallbackHandler.Factory.createCallbackHandler(xmda.bpm.async.AsyncUtils.createAsyncTaskDescription(_this,"#{biz.uml_name}", new String[] {#{type_callback}.class.getName()}));
+END_OF_STRING
+
+  end
+
+  def bpm_manageAsynchronousMethods(biz, not_delete_param=false)
+    returnParam = nil
+    biz.uml_returnResult.each { |p|
+      #pour RSM (non conformite de l'export)
+      next unless p.uml_direction_one.isReturn?
+      returnParam=p
+      biz.uml_returnResult.delete(p) if !not_delete_param
+    }
+    biz.uml_ownedParameter.each { |p|
+      next unless p.uml_direction_one.isReturn?
+      returnParam=p
+      biz.uml_ownedParameter.delete(p) if !not_delete_param
+    }
+    return if returnParam.nil?
+
+    downcaseName=biz.uml_name_one0
+    if downcaseName[0..0].downcase!=downcaseName[0..0]
+      downcaseName="#{downcaseName[0..0].downcase}#{downcaseName[1,downcaseName.length]}"
+    end
+
+    param=biz.umlx_createAndAddParameter(biz.rdf_uri+"_handler_param","handler")
+    i=self.umlx_getOrCreateInterface("xmda.bpm.api.XmdaCallbackHandler<#{returnParam.uml_type}>")
+    i.java_isGeneric=RDF_TRUE
+    param.uml_type=i
+    param.uml_direction=Cuml_ParameterDirectionKind::In
+  end
+
+
+  def bpm_asyncMethods(biz)
+    biz.java_annotation_add(%{@xmda.bpm.async.Async})
+    bpm_manageAsynchronousMethods(biz, true)
+  end
+
+end
+
+module Muml_Operation
+
+  def uml_getReturnParameter
+    fp=nil
+    uml_returnResult.each { |p|
+      #pour RSM (non conformite de l'export)
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    uml_ownedParameter.each { |p|
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    return fp
+  end
+
+  def bpm_returnType
+    fp = uml_getReturnParameter
+    if !fp
+      return "#{BPM::NullReturn}"
+    else
+      return "#{fp.uml_type}"
+    end
+  end
+
+  def bpm_callbackType
+    fp=nil
+    uml_ownedParameter.each { |p|
+      next if p.uml_direction_one.isReturn?
+      if !fp.nil?
+        log.error("Method #{self.uml_name} : Should not define Callback method with multiple parameters")
+        raise Warning.new(),"Method #{self.uml_name} : Should not define Callback method with multiple parameters"
+      else
+        fp=p
+      end
+
+    }
+    if !fp
+      return "#{BPM::NullReturn}"
+    else
+      return "#{fp.uml_type}"
+    end
+  end
+
+end
+
+
+module Muml_Classifier
+
+  rdf_safe_attr_reader_many :bpm_bizOperation
+  #
+  #Creates a class for every business method holding every parameters
+  #and
+  #
+  #
+
+  #STRUTS_RESULT_PARAM_NAME="_result"
+
+  def bpm_addAllOperationAggregateParameterClass!(biz)
+    mpc=self
+    mpc.bpm_bizOperation=biz
+    biz.bpm_bizOperationReverse_add(mpc)
+    #biz.bpm_bizForm=mpc
+    #mpc.uml_name="#{biz.umlx_owner_one.java_Name}#{biz.java_Name}PROC"
+    #method process is expected to be unique
+    #in namespace
+    mpc.uml_name="#{biz.java_Name.to_s}"
+
+    (biz.uml_ownedParameter+biz.uml_returnResult).each { |param|
+      next if param.uml_direction_one.isReturn?
+      mpcp=mpc.umlx_createAndAddProperty(param.rdf_uri+"_proc")
+      param.umlx_copyToAttributeProperty(mpcp)
+      mpcp.uml_name= param.uml_direction_one.isReturn? ? STRUTS_RESULT_PARAM_NAME : param.uml_name
+    }
+    mpc.bpm_addApplyToParameter!(biz)
+    mpc.bpm_addProceed!(biz)
+    #mpc.apaCom_addLogger!
+  end
+
+  def bpm_addApplyToParameter!(biz)
+    return
+    mpc=self
+    m,m1,m2=mpc.umlx_createAndAddAssociation(mpc.rdf_uri+"_apply",biz.umlx_owner_one)
+    m1.uml_name=STRUTS_APPLY_TO_PARAM
+    m2.uml_name="#{STRUTS_APPLY_TO_PARAM}_inv"
+  end
+
+  def bpm_addProceed!(biz)
+    return
+    mpc=self
+    cpt=mpc.umlx_createAndAddOperation(mpc.rdf_uri+"_proceed","proceed")
+    params=""; sep=""
+    hasRP=false
+    (biz.uml_ownedParameter+biz.uml_returnResult).each { |param|
+      if param.uml_direction_one.isReturn?
+        hasRP=true
+        next
+      end
+      params="#{params}#{sep}#{param.java_Name}"
+      sep=","
+    }
+    if(biz.uml_raisedException.empty?)
+      cpt.java_code=%{
+			#{hasRP ? "#{STRUTS_RESULT_PARAM_NAME}=" : ""} #{STRUTS_APPLY_TO_PARAM}.#{biz.java_Name}(#{params});
+      }
+    else
+      cpt.java_code=%{
+		try {
+			//log.error("before biz method");
+			//log.error("applyTo="+#{STRUTS_APPLY_TO_PARAM});
+      #{hasRP ? "#{STRUTS_RESULT_PARAM_NAME}=" : ""} #{STRUTS_APPLY_TO_PARAM}.#{biz.java_Name}(#{params});
+      //log.error("after biz method");
+      //log.error("result="+#{hasRP ? STRUTS_RESULT_PARAM_NAME : %{"-none-"}});
+		} catch(Exception e) {
+			//TODO: implement proper exception handling
+			throw new java.lang.RuntimeException(e);
+		}
+      }
+    end
+
+  end
+end