Adding default date for date_create and date_update columns

The dates are set in EmComponent::create() for date_create and in EmComponent::save() for date_update
The values are sets to datetime.datetime.utcnow() so we now that EVERY date in the db are in UTC, no matter django, database or even server configurations.
We will have to take care to convert dates from database to django timezone in dates fieldtypes.

Database/sqlsetup.py

             {"name":"string",       "type":"TEXT"},
             {"name":"help",         "type":"TEXT"},
             {"name":"rank",         "type":"INTEGER"},
-            {"name":"date_update",  "type":"DATE"},
-            {"name":"date_create",  "type":"DATE"}
+            {"name":"date_create",  "type":"DATETIME"},
+            {"name":"date_update",  "type":"DATETIME"},
         ]
 
         # Table listing all objects created by lodel, giving them an unique id
                 {"name":"string",      "type":"VARCHAR(50)"},
                 {"name":"class_id",    "type":"INTEGER", "extra":{"foreignkey":"em_class.uid"}},
                 {"name":"type_id",     "type":"INTEGER", "extra":{"foreignkey":"em_type.uid"}},
-                {"name":"date_update", "type":"DATE"},
-                {"name":"date_create", "type":"DATE"},
+                {"name":"date_create", "type":"DATETIME"},
+                {"name":"date_update", "type":"DATETIME"},
                 {"name":"history",     "type":"TEXT"}
             ]
         }

Database/sqlwrapper.py

 
     def renewMetaData(self):
         """ (Re)load the database schema """
-        if self.metadata == None:
-            self.metadata = sqla.MetaData(bind=self.r_engine, reflect=True)
-        else:
-            self.metadata = sqla.MetaData(bind=self.r_engine, reflect=True)
+        self.metadata = sqla.MetaData(bind=self.r_engine, reflect=True)
+        self.metadata.reflect()
 
     @property
     def rconn(self):

EditorialModel/classes.py

     @classmethod
     def _createDb(c, name, class_type):
         """ Do the db querys for EmClass::create() """
-        uid = c.newUid()
+
+        #Create a new entry in the em_class table
+        values = { 'name':name, 'classtype':class_type['name'] }
+        resclass = super(EmClass,c).create(values)
+
 
         dbe = c.getDbE()
         conn = dbe.connect()
-        #Create a new entry in the em_class table
-        dbclass = sql.Table(c.table, sqlutils.meta(dbe))
-        req = dbclass.insert().values(uid = uid, name=name, classtype=class_type['name'])
-        res = conn.execute(req)
 
         #Create a new table storing LodelObjects of this EmClass
         meta = sql.MetaData()
 
         conn.close()
 
-        return EmClass(name)
+        return resclass
 
 
     def populate(self):

EditorialModel/components.py

     @see EmClass, EmType, EmFieldGroup, EmField
 """
 
+import datetime
+
 from Lodel.utils.mlstring import MlString
 import logging
 import sqlalchemy as sql
             raise EmComponentNotExistError("No component found with "+('name '+self.name if self.id == None else 'id '+self.id ))
 
         return res
+    
+    ## Insert a new component in the database
+    # This function create and assign a new UID and handle the date_create value
+    # @param values The values of the new component
+    # @return An instance of the created component
+    #
+    # @todo Check that the query didn't failed
+    @classmethod
+    def create(c, values):
+        values['uid'] = c.newUid()
+        values['date_update'] = values['date_create'] = datetime.datetime.utcnow()
+
+        dbe = c.getDbE()
+        conn = dbe.connect()
+        table = sql.Table(c.table, sqlutils.meta(dbe))
+        req = table.insert(values)
+        res = conn.execute(req) #Check res?
+        conn.close()
+        return c(values['name']) #Maybe no need to check res because this would fail if the query failed
+        
 
     """ write the representation of the component in the database
         @return bool
     """
     def save(self, values):
+
         values['name'] = self.name
         values['rank'] = self.rank
-        values['date_update'] = self.date_update
-        values['date_create'] = self.date_create
+        values['date_update'] = datetime.datetime.utcnow()
         values['string'] = str(self.string)
         values['help']= str(self.help)
 
+        #Don't allow creation date overwritting
+        if 'date_create' in values:
+            del values['date_create']
+            logger.warning("date_create supplied for save, but overwritting of date_create not allowed, the date will not be changed")
+
         self._saveDb(values)
 
     def _saveDb(self, values):

EditorialModel/fieldgroups.py

         self.table = EmFieldGroup.table
         super(EmFieldGroup, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_class):
+    @classmethod
+    def create(c, name, em_class):
         """ Create a new EmFieldGroup, save it and instanciate it
 
             @param name str: The name of the new fielgroup
         try:
             exists = EmFieldGroup(name)
         except EmComponentNotExistError:
-            return EmFieldGroup._createDb(name, em_class)
+            return super(EmFieldGroup, c).create({'name': name, 'class_id':em_class.id}) #Check the return value ?
 
         return exists
 
-    @classmethod
-    def _createDb(c,name, em_class):
-        """ Make the Db insertion for fieldgroup creation """
-        uid = c.newUid()
-
-        dbe = c.getDbE()
-        conn = dbe.connect()
-
-        req = sql.Table(c.table, sqlutils.meta(dbe)).insert().values(uid=uid, name=name, class_id=em_class.id)
-        res = conn.execute(req)
-
-        conn.close()
-
-        return EmFieldGroup(name)
-        
-
-        
-
     """ Use dictionary (from database) to populate the object
     """
     def populate(self):

EditorialModel/fields.py

         self.table = EmField.table
         super(EmField, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_fieldgroup, em_fieldtype, optional=True, internal=False):
+    @classmethod
+    def create(c, name, em_fieldgroup, em_fieldtype, optional=True, internal=False):
         """ Create a new EmField and instanciate it
             @static
 
                 'optional' : 1 if optional else 0,
                 'internal' : 1 if internal else 0,
             }
-
-            return EmField._createDb(values)
+            return super(EmField,c).create(values)
 
         return exists
-    
-    @classmethod
-    def _createDb(c, values):
-        values['uid'] = c.newUid()
-
-        dbe = c.getDbE()
-        conn = dbe.connect()
-        req = sql.Table(c.table, sqlutils.meta(dbe)).insert(values=values)
-        res = conn.execute(req)
-
-        conn.close()
 
-        return EmField(values['name'])
 
     """ Use dictionary (from database) to populate the object
     """

EditorialModel/types.py

         self.table = EmType.table
         super(EmType, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_class):
+    @classmethod
+    def create(c, name, em_class):
         """ Create a new EmType and instanciate it
 
             @param name str: The name of the new type
             @see EmComponent::__init__()
 
             @todo Change the icon param type
-            @todo change staticmethod to classmethod
+            @todo check that em_class is an EmClass object
         """
         try:
             exists = EmType(name)
         except EmComponentNotExistError:
-            return EmType._createDb(name, em_class)
+            return super(EmType, c).create({'name':name, 'class_id': em_class.id})
 
         return exists
 
-    @classmethod
-    def _createDb(c, name, em_class):
-        uid = c.newUid()
-
-        dbe = c.getDbE()
-        conn = dbe.connect()
-
-        #Insert type in db
-        dbtype = sql.Table(c.table, sqlutils.meta(dbe))
-        req = dbtype.insert().values(uid=uid, name=name, class_id=em_class.id)
-        res = conn.execute(req)
-
-        return EmType(name)
-
     """ Use dictionary (from database) to populate the object
     """
     def populate(self):