ontomde-java 2.0.0

data/lib/ontomde-java/jpa/jpa.rb

@@ -0,0 +1,531 @@
+#Depending on whether you annotate fields or methods, the access type used by Hibernate will be field or property.
+#The EJB3 spec requires that you declare annotations on the element type that will be accessed, i.e. the getter method if you use property access, the field if you use field access.
+#Mixing EJB3 annotations in both fields and methods should be avoided. Hibernate will guess the access type from the position of @Id or @EmbeddedId.
+#
+#NOT SUPPORTED:
+#* Qualifiers are not supported.
+#* multi-valued attributes (JPA limitation)
+#* Clashing variables with different types in same type hierarchy.
+#X and Y classes derives from Z. X has attribute c of type int and Y has attribute c of type String.
+
+module DB
+  EntityManager="javax.persistence.EntityManager"
+  EntityManagerFactory="javax.persistence.EntityManagerFactory"
+  EntityGenericInterface="xmda.jpa.XmdaEntity"
+  EntityInterface="#{EntityGenericInterface}<Long>"
+end
+
+
+module Muml_Classifier
+  #Class is meant to be a Data Access Object
+  rdf_safe_attr_reader_many :db_isDAO
+  #rdf_safe_attr_reader_many :db_isTransient
+
+  #This DAO class is associated to this persistent class
+  rdf_safe_attr_reader_many :java_persistentClass
+
+  #This peristent class is associated to this DAO class.
+  rdf_safe_attr_reader_many :java_DAOClass
+end
+module Mrdf_Repository
+  def db_addPersistence!
+    jpa_addPersistence!
+  end
+  def db_Class_persistent
+    ret=Set.new
+    uml_Class_all.each { |c|
+      next if c.kind_of?(Muml_Interface) || c.kind_of?(Muml_Enumeration)
+      next unless c.kind_of?(Muml_Class)
+      if c.umlx_hasStereotype?('DTO')
+        c.db_isTransient=RDF_TRUE
+      elsif context[:db_useStereotypeMarker,false]
+        c.db_isTransient=((c.umlx_hasStereotype?(context[:db_persistentStereotype,'Persistent'])) ? RDF_FALSE : RDF_TRUE)
+      end
+      next if c.db_isTransient?
+      if c.umlx_package.nil?
+        log.error("no package for #{c}::#{c.class.name} #{c.rdf_uri}. Skipping addPersistence!")
+        next
+      end
+      ret<< c
+    }
+    return ret
+  end
+  def jpa_addPersistence!
+    #jpa_copyInterfaceAttributesToClass!
+    uml_Class_all.each { |c|
+      next unless c.kind_of?(Muml_Interface) || c.kind_of?(Muml_Enumeration)
+      c.db_isTransient=RDF_TRUE
+    }
+    db_Class_persistent.each { |c|
+      c.jpa_addPersistence!()
+      c.jpa_addPersistenceId!
+      c.jpa_addOptimisticLockingVar!
+    }
+    uml_Class_all.each { |i|
+      i.jpa_processDTO
+      #TODO ???
+      next unless i.kind_of?(Muml_Interface)
+      i.jpa_addPersistenceId!
+      #c.jpa_addOptimisticLockingVar!
+    }
+
+
+  end
+  def jpa_copyInterfaceAttributesToClass!
+    uml_Class_all.each { |c|
+      next unless c.kind_of?(Muml_Interface)
+      puts "found interface #{c}"
+      c.uml_ownedAttribute.each { |a|
+        puts "found attribute #{a.uml_name}"
+      }
+    }
+  end
+  def db_addDAO!
+    db_Class_persistent.each { |c|
+      c.jpa_addDAO!
+    }
+  end
+end
+
+module Muml_Stereotype
+  #nop
+  def jpa_addPersistence!
+    #nop
+  end
+end
+
+
+
+module DAO
+  def jpa_addPersistenceContext!
+  end
+  def jpa_addPersist!
+    c=umlx_createAndAddOperation(rdf_uri+"_persist","persist")
+    c.java_code="getEntityManager().persist(this);"
+  end
+  def jpa_addMerge!
+    c=umlx_createAndAddOperation(rdf_uri+"_merge","merge")
+    c.java_code="return (#{self.java_qualifiedName})getEntityManager().merge(this);"
+    r=c.umlx_createAndAddReturnParameter("#{c.rdf_uri}_ret")
+    r.uml_type=self
+  end
+
+  def jpa_addRemove!
+    c=umlx_createAndAddOperation(rdf_uri+"_remove","remove")
+    c.java_code="getEntityManager().remove(this);"
+  end
+  def jpa_addDAO!
+    return if db_isDAO?
+    return if java_ignoreMe?
+
+    if !context[:db_autonomousDAO,false]
+      self.java_DAOClass=self
+      self.java_persistentClass=self
+    else
+
+      #log.debug { "adding dao for #{self}" }
+      p=umlx_package
+
+
+
+
+      #p=self
+      p=p.umlx_getOrCreatePackage(context[:dbDAOsubPackage,"dao"],p)
+      c=p.umlx_createAndAddClass(rdf_uri+"_dao")
+      c.db_isDAO=RDF_TRUE
+      c.db_isTransient=RDF_TRUE
+      self.java_DAOClass=c
+      c.java_persistentClass=self
+      c.uml_name=uml_name_one+"Dao"
+
+      #log.debug { "DAO added: #{c.uml_name} in #{c.umlx_package.uml_name}"}
+      java_DAOClass_one.jpa_addEntityManager!()
+      java_DAOClass_one.jpa_addStdImports!
+      #jpa_addGetDao!()
+    end
+    jpa_addPersist!
+    jpa_addMerge!
+    jpa_addRemove!
+    jpa_addFindByPrimaryKey!(java_DAOClass_one)
+    jpa_addFindAll!(java_DAOClass_one)
+  end
+  def jpa_addGetDao!()
+    return if uml_isAbstract?
+    umlx_classifier_generalization_indirect.each {|c|
+      return unless c.uml_isAbstract?
+    }
+    m=umlx_createAndAddOperation(rdf_uri+"_getdao")
+    m.uml_name="dao"
+    m.uml_class=self
+    m.uml_visibility=Cuml_VisibilityKind::Public
+    m.uml_isStatic=RDF_TRUE
+    #m.db_isTransient=RDF_TRUE
+
+    #em=m.umlx_createAndAddParameter(m.rdf_uri+"_entityManager","entityManager")
+    #em.uml_type=umlx_getOrCreateClass(DB::EntityManager)
+    #em.uml_direction=Cuml_ParameterDirectionKind::In
+    #em.uml_upperValue=umlx_literal(1)
+    #em.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)
+    rp.uml_type=java_DAOClass_one
+    m.java_code="return new #{java_DAOClass_one.java_qualifiedName}();"
+    return m
+  end
+end
+module Mrdf_Repository
+  def db_findNameUsingDB_URI_ALIAS(k)
+    n="-- key not found for #{k}--"
+    if self[k].nil?
+      # an uri present in old file no longer exists
+      ::Muml_Class::DB_URI_ALIAS.each {|key,v|
+        n=key if v==k
+      }
+    else
+      n=self[k].java_qualifiedName
+    end
+    return n
+  end
+
+  def db_saveDB_DISCRIMINATOR
+    return unless context[:dbTypeDiscriminator]==:int
+    mtk_writeSession("#{context[:dbDiscriminatorCacheRelFile]}") {
+      write <<END
+# saved discriminator numbers
+# This file is read and rewritten by generator
+def declarePredefinedDiscrimators()
+  # first parameter is java qualified class name
+  # second parameter is the identifier used in database
+  #    when different java type are stored in a
+  #    single table and need to be differenciated.
+END
+      ::Muml_Class::DB_DISCRIMINATOR.sort{|a,b| a[1]<=>b[1]}.each { |k|
+        n=db_findNameUsingDB_URI_ALIAS(k[0])
+        write(%{  db_disc("#{n}",#{k[1]})\n})
+      }
+      write("end\n")
+      write <<END
+# ###########################
+# END OF USER MODIFIABLE ZONE
+# ###########################
+
+
+
+# Conversion to model URI
+def db_disc(k,v)
+	::Muml_Class::DB_DISCRIMINATOR[::Muml_Class::DB_URI_ALIAS[k]]=v
+end
+::Muml_Class::DB_URI_ALIAS.merge!({
+END
+      ::Muml_Class::DB_DISCRIMINATOR.sort{|a,b| a[0]<=>b[0]}.each { |k|
+        n=db_findNameUsingDB_URI_ALIAS(k[0])
+        write("  %{#{n}} => %{#{k[0]}} ,\n")
+      }
+      write("})\n")
+      write <<END
+declarePredefinedDiscrimators();
+#free ressources
+def declarePredefinedDiscrimators()
+end
+END
+    }
+
+  end
+end
+
+module Muml_Class
+
+  JPA_TX_BEGIN=""
+  JPA_TX_COMMIT=""
+  #JPA_TX_BEGIN="javax.persistence.EntityTransaction tx=xmda.jpa.TestEnv.getEntityManager().getTransaction();\ntx.begin(); try {"
+  #JPA_TX_COMMIT="tx.commit(); } catch (RuntimeException e) {log.error(e);if(tx.isActive()){ tx.rollback();}throw(e);}"
+
+  #returns java_code enclosed in begin/commit with catch cleanup
+  def db_tx(java_code)
+    jpa_tx(java_code)
+  end
+  #returns java_code enclosed in begin/commit with catch cleanup
+  def jpa_tx(java_code)
+    return "#{JPA_TX_BEGIN}#{java_code}#{JPA_TX_COMMIT}"
+  end
+
+  JAVA_NOT_PERSISTENT_NAMESPACE=["java","javax"]
+  include DAO
+  def jpa_addPersistOperation!
+  end
+
+  DB_Context="xmda.jpa.DbContext"
+  def jpa_addEntityManager!
+
+    gem=umlx_createAndAddOperation(rdf_uri+"getEntityManager","getEntityManager")
+    gem.uml_isStatic=RDF_TRUE
+    ret=gem.umlx_createAndAddReturnParameter(DB_Context+"_ret")
+    ret.uml_upperValue=umlx_literal(1)
+    ret.uml_lowerValue=umlx_literal(0)
+    ret.uml_type=umlx_getOrCreateClass(DB::EntityManager)
+    gem.java_code="return #{DB_Context}.getEntityManager();"
+
+  end
+
+  # xMDA does *not* generate generic DAO type remove method.
+  # object should be removed using their composite object
+  def jpa_addRemoveOperation!
+    # Possible implementation
+    # get container
+    # call remove method
+  end
+
+  def jpa_addRefreshOperation!
+  end
+
+
+
+
+  def jpa_deriveFromPersistent?
+    uml_generalization.each { |c|
+      return true if c.uml_general_one.jpa_isPersistent?
+    }
+    return false
+  end
+  def jpa_isPersistent?
+    #an external class is supposed to be not persistent
+    #if umlx_external?
+    #	return false
+    #end
+    return false if db_isTransient? || db_isDAO?
+    return true if jpa_deriveFromPersistent?
+    #return false unless uml_generalization.empty?
+    return jpa_carryPersistence?
+  end
+  def jpa_carryPersistence?
+    qn=java_qualifiedName
+    JAVA_NOT_PERSISTENT_NAMESPACE.each { |ns|
+      return false if qn.index(ns)==0
+    }
+    #external is supposed not to carry persistence
+    #return false if umlx_external?
+    return true;
+  end
+
+  def jpa_hasPersistenceId?
+    return false if jpa_deriveFromPersistent?
+    return false unless jpa_carryPersistence?
+    return true
+  end
+  def log_error_db_tableName_too_long(tableName)
+    return if log_already_displayed?("#{rdf_uri}__tableName")
+    log.error {
+      <<END
+********* SGBD TABLE NAME TOO LONG **********
+** This software has detected a table name exceeding 63 character
+** ( tableName(#{tableName.length})="#{tableName}" )
+**
+** This table name is related to element:
+** #{mtk_object_message}
+**
+** Default Table name can be overidden using method call:
+** db_addTableNameOverride("#{tableName}","MYSHORTTABLENAME")
+**
+** This model element is related to these other model elements:
+#{mtk_related_message}********* SGBD TABLE NAME TOO LONG **********
+END
+    }
+  end
+
+  #Maximum allowed length for a sgbd table name
+  #cf:
+  #  Mysql: http://dev.mysql.com/doc/refman/5.0/en/identifiers.html
+  DB_MAX_TABLE_NAME_LENGTH=64
+
+  #table name override
+  DB_TABLE_NAME_OVERRIDE=Hash.new
+
+  #Table name for this element
+  def db_tableName
+    r=java_uniqueName
+    if r.length<=DB_MAX_TABLE_NAME_LENGTH
+      #ok. nothing to do
+    elsif ! DB_TABLE_NAME_OVERRIDE[r].nil?
+      #no check performed on overriden name
+      r=DB_TABLE_NAME_OVERRIDE[r]
+    elsif context[:silentlyTruncateTableName,false]
+      log.debug { "silently truncating table name #{r}" }
+      r=r[0,DB_MAX_TABLE_NAME_LENGTH]
+    else
+      log_error_db_tableName_too_long(r)
+    end
+    return r
+  end
+
+  DB_URI_ALIAS=Hash.new
+  DB_DISCRIMINATOR=Hash.new
+  def jpa_addPersistence!
+    #jpa_addDAO!
+
+    #Ajout l'interface XmdaEntity
+    ent=umlx_getOrCreateInterface(DB::EntityInterface)
+    ent.java_isGeneric=RDF_TRUE
+    umlx_createAndAddImplementation(ent)
+
+    jpa_addEntityManager! # required for query, persist,...
+    uml_ownedOperation.each { |o|
+      o.jpa_addPersistence!
+    }
+    java_makeSerializable!
+    java_annotation_add("@Entity")
+    java_import_add("javax.persistence.Entity")
+    java_uniqueName # this call enforces uniqueness
+    if jpa_hasPersistenceId?
+      java_annotation_add("@Table (name=\"#{db_tableName}\")") 
+      java_import_add("javax.persistence.Table")
+    end
+
+    if context[:dbTypeDiscriminator]==:int
+      k=rdf_uri.to_s
+      disc=DB_DISCRIMINATOR[k]
+      if disc.nil?
+        disc=0
+        DB_DISCRIMINATOR.each { |kx,v|
+          disc=v+1 if disc<=v
+        }
+        DB_DISCRIMINATOR[k]=disc
+      end
+      #TODO: generate only when necessary
+      java_annotation_add(%{@DiscriminatorColumn(discriminatorType = DiscriminatorType.INTEGER)})
+      java_import_add("javax.persistence.DiscriminatorColumn")
+      java_import_add("javax.persistence.DiscriminatorType")
+      java_annotation_add(%{@DiscriminatorValue(value = "#{disc}" )})
+      java_import_add("javax.persistence.DiscriminatorValue")
+    end
+    jpa_addStdImports!
+  end
+
+  def jpa_addStdImports!
+    #java_import_add("java.util.ArrayList")
+    #java_import_add("java.util.Set")
+    #java_import_add("java.util.List")
+    #java_import_add("javax.persistence.*")
+    #    java_import_add("javax.persistence.Entity")
+    #    java_import_add("javax.persistence.Table")
+    #    java_import_add("javax.persistence.DiscriminatorColumn")
+    #    java_import_add("javax.persistence.DiscriminatorValue")
+    #    java_import_add("javax.persistence.DiscriminatorType")
+    #    java_import_add("javax.persistence.Version")
+    #    java_import_add("javax.persistence.Basic")
+    #    java_import_add("javax.persistence.Column")
+    #    java_import_add("javax.persistence.Lob")
+    #    java_import_add("javax.persistence.Id")
+    #    java_import_add("javax.persistence.GeneratedValue")
+    #    java_import_add("javax.persistence.JoinTable")
+    #    java_import_add("javax.persistence.OneToMany")
+    #    java_import_add("javax.persistence.ManyToOne")
+    #    java_import_add("javax.persistence.ManyToMany")
+    #    java_import_add("javax.persistence.Temporal")
+    #    java_import_add("javax.persistence.CascadeType")
+    #    java_import_add("javax.persistence.FetchType")
+    #    #java_import_add("javax.persistence.OneToOne")
+    #    java_import_add("javax.persistence.JoinColumn")
+    #    java_import_add("javax.persistence.TemporalType")
+
+
+
+    #com.francetelecom.rd.cil.commons.common.CommonException
+    #com.francetelecom.rd.cil.commons.model.IdentifiedObject
+    ##{java_packageQualifiedName}.vo.#{java_Name}Value
+    ##{java_packageQualifiedName}.vo.*
+  end
+  def jpa_addPersistenceIdAnnnotation!(p)
+    p.java_annotation_add("@Id")
+    java_import_add("javax.persistence.Id")
+    p.java_annotation_add("@GeneratedValue")
+    java_import_add("javax.persistence.GeneratedValue")
+  end
+
+end
+module Muml_Classifier
+  
+  def jpa_processDTO
+    return unless self.umlx_hasStereotype?('DTO')
+    
+    puts "DTO Found : #{java_Name}"
+
+    # Add a method to<UML_Name> to the main class linked to the DTO by a dependency
+    self.uml_clientDependency.each{|dep|
+      next unless dep.kind_of?(Cuml_Dependency)
+      relatedObject = dep.uml_supplier_one
+      
+      relatedObject.java_import_add(self.java_qualifiedName)
+      relatedObject.java_import_add("org.apache.commons.beanutils.PropertyUtils")
+      me=relatedObject.umlx_createAndAddOperation(self.rdf_uri+"_to#{self.java_Name}")
+      me.uml_name="to#{self.java_Name}"
+      me.uml_visibility=Cuml_VisibilityKind::Public
+      rme=me.umlx_createAndAddReturnParameter("#{me.rdf_uri}_ret")
+      rme.uml_type=self
+      me.java_code = <<CODE
+    #{self.java_Name} dto = new #{self.java_Name}();
+    try {
+       PropertyUtils.copyProperties(dto, this);
+    } catch (Exception e) {
+       throw new RuntimeException(e);
+    }
+    return dto;
+CODE
+
+    }
+    
+  end
+
+  def jpa_addPersistenceId!
+    #return unless uml_generalization.empty?
+    return unless context[:db_useOptimisticLocking,true]
+    return unless jpa_hasPersistenceId?
+
+    p=umlx_createAndAddProperty(rdf_uri+"_auto_id","id")
+    jpa_addPersistenceIdAnnnotation!(p)
+    #p.uml_type=umlx_dataType_long
+    p.uml_type=umlx_getOrCreateDataType("Long")
+    p.uml_visibility=::Cuml_VisibilityKind::Private
+    java_addAccessorsFor!(p)
+
+    #TODO Surcharge le getter : A enlever une fois avoir corrig� incompatibilit� avec couche Struts
+    gettter = p.java_AttributeGlobalGetter
+    #removed ? : operator to make checkstyle happy.
+    gettter[0].java_code = %{if(#{p.java_Name} == null) { return Long.valueOf(0);} else {return #{p.java_Name};}}
+    
+    stereo = umlx_package.umlx_createAndAddStereotype(rdf_uri+"Equals", "EqualsValue")
+    p.uml_appliedStereotype = stereo
+    
+  end
+end
+module Muml_Property
+  def jpa_isPersistent?
+    return false if uml_isDerived?
+    return true
+  end
+end
+module Muml_Interface
+  #JPA does not support persistent interface
+  def jpa_isPersistent?
+    return false
+  end
+  def jpa_hasPersistenceId?
+    uml_ownedAttribute.each { |a|
+      next unless a.umlx_isComposite?
+      next if a.uml_type_one.db_isTransient?
+      return true ;
+    }
+    return false
+  end
+  def jpa_addPersistenceIdAnnnotation!(p)
+    #nop
+  end
+end
+
+#adds a directive for replacing default table name orgname by overridenname
+def db_addTableNameOverride(orgname,overridenname)
+  ::Muml_Class::DB_TABLE_NAME_OVERRIDE[orgname.to_s]=overridenname.to_s
+end
+