[#11] Ajout de la génération de la colonne du Field dans la table correspondante

Database/sqlwrapper.py

@@ -455,6 +455,26 @@ class SqlWrapper(object):
         self.renewMetaData()
         return ret
 
+    ## AddColumnObject
+    #
+    # Adds a column from a SQLAlchemy Column Object
+    #
+    # @param tname str: Name of the table in which to add the column
+    # @param column Column: Column object to add to the table
+    # @return True if query is successful, False if it fails
+    def addColumnObject(self, tname, column):
+        if tname not in self.meta.tables:
+            raise NameError("The table '%s' doesn't exist" % tname)
+        table = self.Table(tname)
+
+        ddl = AddColumn(table, column)
+        sql = ddl.compile(dialect=self.w_engine.dialect)
+        sql = str(sql)
+        logger.debug("Executing SQL : '%s'" % sql)
+        ret = book(self.wconn.execute(sql))
+        self.renewMetaData()
+        return ret
+
     def alterColumn(self, tname, colname, col_newtype):
         """ Change the type of a column
             @param tname str: The table name

EditorialModel/fields.py

@@ -2,43 +2,49 @@
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
 from Database import sqlutils
+from Database.sqlwrapper import SqlWrapper
+from Database.sqlquerybuilder import SqlQueryBuilder
 
 import sqlalchemy as sql
 
 import EditorialModel
+import logging
+
+logger = logging.getLogger('Lodel2.EditorialModel')
 
 """Represent one data for a lodel2 document"""
 class EmField(EmComponent):
 
     table = 'em_field'
 
+    ## __init__ (Function)
+    #
+    # Instanciates an EmField object with data fetched from the database
+    #
+    # @param id_or_name str\int: Identifier of the EmField (global_id or name)
+    # @throw TypeError
+    # @see EmComponent::__init__()
     def __init__(self, id_or_name):
-        """ Instanciate an EmField with data fetched from db
-            @param id_or_name str|int: Identify the EmType by name or by global_id
-            @throw TypeError
-            @see EmComponent::__init__()
-        """
         self.table = EmField.table
         super(EmField, self).__init__(id_or_name)
 
+    ## Create (Function)
+    #
+    # Creates a new EmField and instanciates it
+    #
+    # @static
+    #
+    # @param name str: The name of the new Type
+    # @param em_fieldgroup EmFieldGroup: The new field will belong to this fieldgroup
+    # @param em_fieldtype EmFieldType: The new field will have this type
+    # @param optional bool: Is the field optional ?
+    # @param optional bool: Is the field internal ?
+    #
+    # @throw TypeError
+    # @see EmComponent::__init__()
+    # @staticmethod
     @classmethod
     def create(c, name, em_fieldgroup, em_fieldtype, optional=True, internal=False):
-        """ Create a new EmField and instanciate it
-            @static
-
-            @param name str: The name of the new Type
-            @param em_fieldgroup EmFieldGroup: The new field will belong to this fieldgroup
-            @param ml_repr MlString|None: Multilingual representation of the type
-            @param ml_help MlString|None: Multilingual help for the type
-            @param The string|None: filename of the icon
-
-            @param optional bool: Is the field optional ?
-            @param internal bool: Is the field internal?
-
-            @throw TypeError
-            @see EmComponent::__init__()
-            @staticmethod
-        """
         try:
             exists = EmField(name)
         except EmComponentNotExistError:
@@ -50,13 +56,73 @@ class EmField(EmComponent):
                 'optional' : 1 if optional else 0,
                 'internal' : 1 if internal else 0,
             }
-            return super(EmField,c).create(values)
+
+            createdField = super(EmField,c).create(values)
+            if createdField:
+                # The field was created, we then add its column in the corresponding class' table
+                is_field_column_added = EmField.addFieldColumnToClassTable(createdField)
+                if is_field_column_added:
+                    return createdField
+
+            exists = createdField
 
         return exists
 
 
-    """ Use dictionary (from database) to populate the object
-    """
+    ## addFieldColumnToClassTable (Function)
+    #
+    # Adds a column representing the field in its class' table
+    #
+    # @static
+    #
+    # @param emField EmField: the object representing the field
+    # @return True in case of success, False if not
+    @classmethod
+    def addFieldColumnToClassTable(cls, emField):
+        field_type = EditorialModel.fieldtypes.get_field_type(emField.em_fieldtype)
+        field_sqlalchemy_args = field_type.sqlalchemy_args()
+        field_sqlalchemy_args['name'] = emField.name
+        field_sqlalchemy_column_object = sqlwrapper.createColumn(**field_sqlalchemy_args)
+        field_uid = emField.uid
+        field_class_table = emField.get_class_table()
+        return sqlwrapper.addColumnObject(tname=field_class_table, column=field_sqlalchemy_column_object)
+
+    ## get_class_table (Function)
+    #
+    # Gets the name of the table of the class corresponding to the field
+    #
+    # @return Name of the table
+    def get_class_table(self):
+        return self._get_class_tableDb()
+
+    ## _get_class_tableDb (Function)
+    #
+    # Executes a request to the database to get the name of the table in which to add the field
+    #
+    # @return Name of the table
+    def _get_class_tableDb(self):
+        dbe = self.getDbE()
+        uidtable = sql.Table('uids', sqlutils.meta(dbe))
+        conn = dbe.connect()
+        sql_wrapper = SqlWrapper(read_db='default', write_db='default', alchemy_logs=False)
+        columns=('table')
+        query_builder = SqlQueryBuilder(sql_wrapper,'uids')
+        query_builder.Select(columns)
+        query_builder.From('uids')
+        query_builder.Where('uids.uid=%s' % self.uid)
+
+        records = query.Execute().fetchall()
+        table_records = []
+        for record in records:
+            table_records.append(dict(zip(record.keys(), record)))
+        table_record = table_records[0]
+        table_name = table_record['table']
+
+        return table_name
+
+    ## Populate (Function)
+    #
+    # Sets the object's properties using the values from the database
     def populate(self):
         row = super(EmField, self).populate()
         self.em_fieldgroup = EditorialModel.fieldgroups.EmFieldGroup(int(row.fieldgroup_id))
@@ -67,6 +133,11 @@ class EmField(EmComponent):
         self.rel_to_type_id = EditorialModel.fieldtypes.EmFieldType(int(row.rel_to_type_id)) if row.rel_to_type_id else None
         self.rel_field_id = EmField(int(row.rel_field_id)) if row.rel_field_id else None
 
+    ## Save (Function)
+    #
+    # Saves the properties of the object as a record in the database
+    #
+    # @return True in case of success, False if not
     def save(self):
         # should not be here, but cannot see how to do this
         if self.name is None: