Start multivalueFieldType implementation (in migrationhandler)

DataSource/MySQL/migrationhandler.py

     # @return True if the column was added else return False
     def _add_column(self, table_name, col_name, col_fieldtype, drop_if_exists=False):
 
+        instr, col_type, col_specs = fieldtypes_utils.fieldtype_db_init(col_fieldtype)
+
+        if instr == 'table':
+            # multivalue field. We are not going to add a column in this table
+            # but in corresponding multivalue table
+            self._add_column_multivalue(
+                                            table_name,
+                                            key_infos = col_type,
+                                            column_infos = (col_name, col_specs)
+                                        )
+
         col_name = utils.column_name(col_name)
 
         add_col = """ALTER TABLE {table_name}
         etname = utils.escape_idname(table_name)
         ecname = utils.escape_idname(col_name)
 
-        instr, col_type, col_specs = fieldtypes_utils.fieldtype_db_init(col_fieldtype)
         if instr is None:
             return True
         if instr != "column":
 
         return True
 
+    ## @brief Add a column to a multivalue table
+    #
+    # Add a column (and create a table if not existing) for storing multivalue
+    # datas. (typically i18n)
+    # @param ref_table_name str : Referenced table name
+    # @param key_infos tuple : tuple(key_name, key_fieldtype)
+    # @param column_infos tuple : tuple(col_name, col_fieldtype)
+    def _add_column_multivalue(ref_table_name, key_info, column_infos):
+        key_name, key_ftype = key_infos
+        col_name, col_ftype = column_infos
+        table_name = utils.multivalue_table_name(ref_table_name, key_name)
+        # table creation
+        self._create_table(
+                            table_name,
+                            key_name,
+                            key_ftype,
+                            self.db_engine,
+                            if_exists = 'nothing'
+        )
+        # with FK
+        self._del_fk(table_name, dst_table_name)
+        self._add_fk(table_name, dst_table_name, key_name, utils._object_pk[0])
+        # adding the column
+        self._add_column(table_name, col_name, col_ftype)
+
+
     ## @brief Add a foreign key
     # @param src_table_name str : The name of the table where we will add the FK
     # @param dst_table_name str : The name of the table the FK will point on

DataSource/MySQL/utils.py

 def r2t_table_name(class_name, type_name):
     return ("%s%s_%s" % (table_preffix['relation'], class_name, type_name)).lower()
 
+def multivalue_table_name(referenced_table_name, key_name):
+    return ("%s%s" % (key_name, referenced_table_name))
 
 ## @brief Return a column name given a field name
 # @param field_name : The EmField or LeObject field name

EditorialModel/fieldtypes/char.py

     # @brief max_length int : The maximum length of this field
     def __init__(self, max_length=64, **kwargs):
         self.max_length = max_length
-        super(EmFieldType, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 

EditorialModel/fieldtypes/generic.py

     # @param keyname str : The identifier key name
     # @param key_fieldtype SingleValueFieldType : A SingleValueFieldType child class instance
     # @param value_fieldtype SingleValueFieldType : A SingleValueFieldType child class instance
-    def __init__(self, internal, keyname, key_fieldtype, value_fieldtype, **args):
+    def __init__(self, keyname, key_fieldtype, value_fieldtype, internal = False, **args):
         super().__init__(internal)
         ## stores the keyname
         self.keyname = keyname

EditorialModel/fieldtypes/i18n.py

+#-*- coding: utf-8 -*-
+
+from .generic import MultiValueFieldType
+from . import char
+
+class EmFieldType(MutliValueFieldType):
+    
+    help = 'Fieldtype designed to handle translations'
+    
+    def __init__(self, value_max_length = 64, **args):
+        args['keyname'] = 'lang'
+        args['key_fieldtype'] = char.EmFieldType(max_length = 4)
+        args['value_fieldtype'] = char.EmFieldType(value_max_length)
+        super().__init__(**args)