EmType: create, save and load

EditorialModel/types.py

@@ -1,6 +1,9 @@
 #-*- coding: utf-8 -*-
 
-from EditorialModel.components import EmComponent
+from EditorialModel.components import EmComponent, EmComponentNotExistError
+from Database.sqlobject import SqlObject
+
+import EditorialModel.classes
 
 class EmType(EmComponent):
     """ Represents type of documents
@@ -10,48 +13,77 @@ class EmType(EmComponent):
         EmType with special fields called relation_to_type fields
         @see EmComponent
     """
+    table = 'em_type'
 
-    def __init__(id_or_name):
+    def __init__(self, id_or_name):
         """  Instanciate an EmType 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__()
         """
-        super(EmType, self).__init__()
-        pass
+        self.table = EmType.table
+        super(EmType, self).__init__(id_or_name)
 
     @staticmethod
-    def create(name, em_class, ml_repr = None, ml_help = None, icon = None, sort_field = None):
+    def create(name, em_class):
         """ Create a new EmType and instanciate it
 
             @param name str: The name of the new type
             @param em_class EmClass: The class that the new type will specialize
-            @param ml_repr MlString: Multilingual representation of the type
-            @param ml_help MlString: Multilingual help for the type
-            @param icon str|None: The filename of the icon
-            @param sort_field EmField|None: The field used to sort by default
 
             @see EmComponent::__init__()
 
             @todo Change the icon param type
             @todo change staticmethod to classmethod
         """
-        pass
+        try:
+            exists = EmType(name)
+        except EmComponentNotExistError:
+            uids = SqlObject('uids')
+            res = uids.wexec(uids.table.insert().values(table=EmType.table))
+            uid = res.inserted_primary_key
 
-    def field_groups():
+            emtype = SqlObject(EmType.table)
+            res = emtype.wexec(emtype.table.insert().values(uid=uid, name=name, class_id=em_class.id))
+            return EmType(name)
+
+        return exists
+
+    """ Use dictionary (from database) to populate the object
+    """
+    def populate(self):
+        row = super(EmType, self).populate()
+        self.em_class = EditorialModel.classes.EmClass(int(row.class_id))
+        self.icon = row.icon
+        self.sortcolumn = row.sortcolumn
+
+    def save(self):
+        # should not be here, but cannot see how to do this
+        if self.name is None:
+            self.populate()
+
+        values = {
+            'class_id' : self.em_class.id,
+            'icon' : self.icon,
+            'sortcolumn' : self.sortcolumn,
+        }
+
+        return super(EmType, self).save(values)
+
+    def field_groups(self):
         """ Get the list of associated fieldgroups
             @return A list of EmFieldGroup
         """
         pass
 
 
-    def fields():
+    def fields(self):
         """ Get the list of associated fields
             @return A list of EmField
         """
         pass
 
-    def select_field(field):
+    def select_field(self, field):
         """ Indicate that an optionnal field is used
 
             @param field EmField: The optional field to select
@@ -60,7 +92,7 @@ class EmType(EmComponent):
         """
         pass
 
-    def unselect_field(field):
+    def unselect_field(self, field):
         """ Indicate that an optionnal field will not be used
             @param field EmField: The optional field to unselect
             @throw ValueError, TypeError
@@ -68,18 +100,17 @@ class EmType(EmComponent):
         """
         pass
 
-        
-    def hooks():
+
+    def hooks(self):
         """Get the list of associated hooks"""
         pass
 
-    def add_hook(hook):
+    def add_hook(self, hook):
         """ Add a new hook
             @param hook EmHook: A EmHook instance
             @throw TypeError
         """
         pass
-    
 
     def del_hook(hook):
         """ Delete a hook
@@ -90,16 +121,16 @@ class EmType(EmComponent):
         pass
 
 
-    def superiors():
+    def superiors(self):
         """ Get the list of superiors EmType in the type hierarchy
             @return A list of EmType
         """
         pass
 
 
-    def add_superior(em_type, relation_nature):
+    def add_superior(self, em_type, relation_nature):
         """ Add a superior in the type hierarchy
-            
+
             @param em_type EmType: An EmType instance
             @param relation_nature str: The name of the relation's nature
             @throw TypeError
@@ -107,22 +138,21 @@ class EmType(EmComponent):
         """
         pass
 
-    def del_superior(em_type):
+    def del_superior(self, em_type):
         """ Delete a superior in the type hierarchy
-            
+
             @param em_type EmType: An EmType instance
             @throw TypeError
             @todo define return value and raise condition
         """
         pass
 
-    def linked_types():
+    def linked_types(self):
         """ Get the list of linked type
-            
+
             Types are linked with special fields called relation_to_type fields
-            
+
             @return a list of EmType
             @see EmFields
         """
         pass
-