Finish the new version of migrationhandler + modifications in leFactory and LeRelation (to handle generic lesup & lesub in LeRelation)

DataSource/MySQL/migrationhandler.py

@@ -197,7 +197,7 @@ class MysqlMigrationHandler(DummyMigrationHandler):
         emclass = em.component(uid)
         if not isinstance(emclass, EditorialModel.classes.EmClass):
             raise ValueError("The given uid is not an EmClass uid")
-        pkname, pktype = self._common_field_pk
+        pkname, pktype = self._object_pk
         table_name = self._emclass2table_name(emclass)
         self._create_table(table_name, pkname, pktype, engine=engine)
 
@@ -281,7 +281,7 @@ class MysqlMigrationHandler(DummyMigrationHandler):
         if_exists = 'drop' if drop_if_exist else 'nothing'
         #Object table
         tname = utils.common_tables['object']
-        pk_name, pk_ftype = self._common_field_pk
+        pk_name, pk_ftype = self._object_pk
         self._create_table(tname, pk_name, pk_ftype, engine=self.db_engine, if_exists=if_exists)
         #Adding columns
         cols = {fname: self._common_field_to_ftype(fname) for fname in EditorialModel.classtypes.common_fields}
@@ -290,6 +290,7 @@ class MysqlMigrationHandler(DummyMigrationHandler):
                 self._add_column(tname, fname, ftype)
         #Creating triggers
         self._generate_triggers(tname, cols)
+        object_tname = tname
 
         #Relation table
         tname = utils.common_tables['relation']
@@ -301,6 +302,25 @@ class MysqlMigrationHandler(DummyMigrationHandler):
         #Creating triggers
         self._generate_triggers(tname, self._relation_cols)
 
+        # Creating foreign keys between relation and object table
+        sup_cname, sub_cname = self.get_sup_and_sub_cols()
+        self._add_fk(tname, object_tname, sup_cname, self._object_pk[0], 'fk_relations_superiors')
+        self._add_fk(tname, object_tname, sub_cname, self._object_pk[0], 'fk_relations_subordinate')
+    
+    ## @brief Returns the fieldname for superior and subordinate in relation table
+    # @return a tuple (superior_name, subordinate_name)
+    @classmethod
+    def get_sup_and_sub_cols(cls):
+        sup = None
+        sub = None
+        for fname, finfo in EditorialModel.classtypes.relations_common_fields.items():
+            if finfo['fieldtype'] == 'leo':
+                if finfo['superior']:
+                    sup = fname
+                else:
+                    sub = fname
+        return utils.column_name(sup),utils.column_name(sub)
+
     ## @return true if the name changes
     def _name_change(self, initial_state, new_state):
         return 'name' in initial_state and initial_state['name'] != new_state['name']
@@ -377,13 +397,14 @@ ADD COLUMN {col_name} {col_type} {col_specs};"""
     # @param dst_table_name str : The name of the table the FK will point on
     # @param src_col_name str : The name of the concerned column in the src_table
     # @param dst_col_name str : The name of the concerned column in the dst_table
-    def _add_fk(self, src_table_name, dst_table_name, src_col_name, dst_col_name):
+    def _add_fk(self, src_table_name, dst_table_name, src_col_name, dst_col_name, fk_name = None):
         stname = utils.escape_idname(src_table_name)
         dtname = utils.escape_idname(dst_table_name)
         scname = utils.escape_idname(src_col_name)
         dcname = utils.escape_idname(dst_col_name)
 
-        fk_name = utils.get_fk_name(src_table_name, dst_table_name)
+        if fk_name is None:
+            fk_name = utils.get_fk_name(src_table_name, dst_table_name)
 
         self._del_fk(src_table_name, dst_table_name)
 
@@ -530,7 +551,7 @@ FOR EACH ROW SET {col_val_list};""".format(
 
     ## @brief Returns a tuple (pkname, pk_ftype)
     @property
-    def _common_field_pk(self):
+    def _object_pk(self):
         return self.extract_pk(EditorialModel.classtypes.common_fields)
 
     ## @brief Returns a tuple (rel_pkname, rel_ftype)

leapi/lefactory.py

@@ -221,6 +221,15 @@ import %s
         """
         #Building the fieldtypes dict for LeRelation
         (lerel_uid_fieldtype, lerel_fieldtypes) = self.concret_fieldtypes(EditorialModel.classtypes.relations_common_fields)
+        # Fetching superior and subordinate fieldname for LeRelation
+        lesup = None
+        lesub = None
+        for fname, finfo in EditorialModel.classtypes.relations_common_fields.items():
+            if finfo['fieldtype'] == 'leo':
+                if finfo['superior']:
+                    lesup = fname
+                else:
+                    lesub = fname
         """
         lerel_fieldtypes = list()
         lerel_uid_fieldtype = None
@@ -252,6 +261,8 @@ class LeObject(LeCrud, leapi.leobject._LeObject):
 class LeRelation(LeCrud, leapi.lerelation._LeRelation):
     _uid_fieldtype = {lerel_uid_fieldtype}
     _rel_fieldtypes = {lerel_fieldtypes}
+    _lesup_name = {lesup_name}
+    _lesub_name = {lesub_name}
 
 class LeHierarch(LeRelation, leapi.lerelation._LeHierarch):
     pass
@@ -272,6 +283,8 @@ class LeType(LeClass, _LeType):
             leo_fieldtypes = '{\n\t' + (',\n\t'.join(leobj_fieldtypes))+ '\n\t}',
             lerel_fieldtypes = '{\n\t' + (',\n\t'.join(lerel_fieldtypes))+ '\n\t}',
             lerel_uid_fieldtype = lerel_uid_fieldtype,
+            lesup_name = repr(lesup),
+            lesub_name = repr(lesub),
         )
 
         emclass_l = model.components(EditorialModel.classes.EmClass)

leapi/lerelation.py

@@ -11,10 +11,8 @@ from . import lefactory
 ## @brief Main class for relations
 class _LeRelation(lecrud._LeCrud):
 
-    ## @brief Handles the superior
-    _lesup_fieldtype = {'lesup': ft_leo.EmFieldType(True)}
-    ## @brief Handles the subordinate
-    _lesub_fieldtype = {'lesub': ft_leo.EmFieldType(False) }
+    _lesup_name = None
+    _lesub_name = None
     ## @brief Stores the list of fieldtypes that are common to all relations
     _rel_fieldtypes = dict()
 
@@ -25,13 +23,13 @@ class _LeRelation(lecrud._LeCrud):
     @classmethod
     def sup_filter(self, leo):
         if isinstance(leo, leobject._LeObject):
-            return ('lesup', '=', leo)
+            return (self._lesup_name, '=', leo)
 
     ## @brief Forge a filter to match the superior
     @classmethod
     def sub_filter(self, leo):
         if isinstance(leo, leobject._LeObject):
-            return ('lesub', '=', leo)
+            return (self._lesub_name, '=', leo)
 
     ## @return a dict with field name as key and fieldtype instance as value
     @classmethod
@@ -60,7 +58,7 @@ class _LeRelation(lecrud._LeCrud):
         filters, rel_filters = super()._prepare_filters(filters_l)
         res_filters = list()
         for field, op, value in filters:
-            if field in ['lesup', 'lesub']:
+            if field in [self._lesup_name, self._lesub_name]:
                 if isinstance(value, str):
                     try:
                         value = int(value)
@@ -162,7 +160,7 @@ class _LeRel2Type(_LeRelation):
             datas['nature'] = None
         if cls == cls.name2class('LeRel2Type') and classname is None:
             # autodetect the rel2type child class
-            classname = relname(datas['lesup'], datas['lesub'])
+            classname = relname(datas[self._lesup_name], datas[self._lesub_name])
         return super().insert(datas, classname)
 
     ## @brief Given a superior and a subordinate, returns the classname of the give rel2type