Merge branch 'master' of git.labocleo.org:lodel2

Database/sqlsetup.py

@@ -27,9 +27,8 @@ class SQLSetup(object):
         uids = {
                 "name":"uids",
                 "columns":[
-                    {"name":"uid",          "type":"VARCHAR(50)", "extra":{"nullable":False, "primarykey":True}},
-                    {"name":"class",        "type":"VARCHAR(50)"},
-                    {"name":"type",         "type":"VARCHAR(50)"}
+                    {"name":"uid",          "type":"INTEGER", "extra":{"nullable":False, "primarykey":True, 'autoincrement':True}},
+                    {"name":"table",        "type":"VARCHAR(50)"}
                 ]
             }
         tables.append(uids)
@@ -38,7 +37,7 @@ class SQLSetup(object):
         # Table listing the classes
         em_class = {"name":"em_class"}
         em_class['columns'] = default_columns + [
-            {"name":"classtype",    "type":"INTEGER"},
+            {"name":"classtype",    "type":"VARCHAR(50)"},
             {"name":"sortcolumn",   "type":"VARCHAR(50)", "extra":{"default":"rank"}},
             {"name":"icon",         "type":"INTEGER"},
         ]

EditorialModel/classes.py

@@ -6,12 +6,15 @@
 """
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
-import EditorialModel.classtypes
 from Database.sqlwrapper import SqlWrapper
+from Database.sqlobject import SqlObject
+import EditorialModel
 
 class EmClass(EmComponent):
+    table = 'em_class'
+
     def __init__(self, id_or_name):
-        self.table = 'em_class'
+        self.table = EmClass.table
         super(EmClass, self).__init__(id_or_name)
 
     """ create a new class
@@ -20,41 +23,82 @@ class EmClass(EmComponent):
     """
     @staticmethod
     def create(name, class_type):
-        #try:
-        exists = EmClass(name)
-        #except EmComponentNotExistError:
-            #print ("bin")
-            #pass
-        print (name, class_type)
-        pass
+        try:
+            exists = EmClass(name)
+        except EmComponentNotExistError:
+            uids = SqlObject('uids')
+            res = uids.wexec(uids.table.insert().values(table=EmClass.table))
+            uid = res.inserted_primary_key
+
+            emclass = SqlObject(EmClass.table)
+            res = emclass.wexec(emclass.table.insert().values(uid=uid, name=name, classtype=class_type['name']))
+            SqlWrapper.wc().execute("CREATE TABLE %s (uid VARCHAR(50))" % name)
+            return EmClass(name)
+
+        return exists
+
+    def populate(self):
+        row = super(EmClass, self).populate()
+        self.classtype = row.classtype
+        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 = {
+            'classtype' : self.classtype,
+            'icon' : self.icon,
+            'sortcolumn' : self.sortcolumn,
+        }
+
+        return super(EmClass, self).save(values)
 
     """ retrieve list of the field_groups of this class
         @return field_groups [EmFieldGroup]:
     """
-    def field_groups():
-        pass
+    def fieldgroups(self):
+        fieldgroups_req = SqlObject(EditorialModel.fieldgroups.EmFieldGroup.table)
+        select = fieldgroups_req.sel
+        select.where(fieldgroups_req.col.class_id == self.id)
+
+        sqlresult = fieldgroups_req.rexec(select)
+        records = sqlresult.fetchall()
+        fieldgroups = [ EditorialModel.fieldgroups.EmFieldGroup(int(record.uid)) for record in records ]
+
+        return fieldgroups
 
     """ retrieve list of fields
         @return fields [EmField]:
     """
-    def fields():
+    def fields(self):
         pass
 
     """ retrieve list of type of this class
         @return types [EmType]:
     """
-    def types():
-        pass
+    def types(self):
+        emtype = SqlObject(EditorialModel.types.EmType.table)
+        select = emtype.sel
+        select.where(emtype.col.class_id == self.id)
+
+        sqlresult = emtype.rexec(select)
+        records = sqlresult.fetchall()
+        types = [ EditorialModel.types.EmType(int(record.uid)) for record in records ]
+
+        return types
 
     """ add a new EmType that can ben linked to this class
         @param  t EmType: type to link
         @return success bool: done or not
     """
-    def link_type(t):
+    def link_type(self, t):
         pass
 
     """ retrieve list of EmType that are linked to this class
         @return types [EmType]:
     """
-    def linked_types():
-        pass
+    def linked_types(self):
+        pass

EditorialModel/components.py

@@ -23,9 +23,10 @@ class EmComponent(object):
         SqlWrapper.start()
         if self is EmComponent:
             raise EnvironmentError('Abstract class')
-        if type(id_or_name) is int:
+        if isinstance(id_or_name, int):
             self.id = id_or_name
-        elif type(id_or_name) is str:
+            self.name = None
+        elif isinstance(id_or_name, str):
             self.id = None
             self.name = id_or_name
             self.populate()
@@ -35,43 +36,50 @@ class EmComponent(object):
     """ Lookup in the database properties of the object to populate the properties
     """
     def populate(self):
-        dbo = SqlObject(self.table)
-        
-        req = dbo.sel
-        
+        table = SqlObject(self.table)
+        select = table.sel
+
         if self.id is None:
-            req.where(dbo.col.name == self.name)
+            select.where(table.col.name == self.name)
         else:
-            req.where(dbo.col.id == self.id)
-
-        sqlresult = dbo.rexec(req)
+            select.where(table.col.uid == self.id)
 
-        # Transformation du résultat en une liste de dictionnaires
+        sqlresult = table.rexec(select)
         records = sqlresult.fetchall()
-        print (records)
 
-        for record in records:
-            selected_lines.append(dict(zip(record.keys(), record)))
-
-        if not row:
+        if not records:
             # could have two possible Error message for id and for name
             raise EmComponentNotExistError("Bad id_or_name: could not find the component")
 
+        for record in records:
+            row = type('row', (object,), {})()
+            for k in record.keys():
+                setattr(row, k, record[k])
+
+        self.id = int(row.uid)
         self.name = row.name
-        self.rank = int(row.rank)
+        self.rank = 0 if row.rank is None else int(row.rank)
         self.date_update = row.date_update
         self.date_create = row.date_create
-        self.string = MlString.from_json(row.string)
-        self.help = MlString.from_json(row.help)
-        self.icon = row.icon
+        self.string = MlString.load(row.string)
+        self.help = MlString.load(row.help)
 
         return row
 
     """ write the representation of the component in the database
         @return bool
     """
-    def save(self):
-        pass
+    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['string'] = str(self.string)
+        values['help']= str(self.help)
+
+        emclass = SqlObject(self.table)
+        update = emclass.table.update(values=values)
+        res = emclass.wexec(update)
 
     """ delete this component data in the database
         @return bool
@@ -85,27 +93,12 @@ class EmComponent(object):
     def modify_rank(self, new_rank):
         pass
 
-    """ set a string representation of the component for a given language
-        @param  lang str: iso 639-2 code of the language http://en.wikipedia.org/wiki/List_of_ISO_639-2_codes
-        @param  text str: text to set
-        @return bool
-    """
-    def set_string(self, lang, text):
-        pass
-
-    """ set the string representation of the component
-        @param  ml_string  MlString: strings for all language
-        @return bool
-    """
-    def set_strings(self, ml_string):
-        pass
+    def __repr__(self):
+        if self.name is None:
+            return "<%s #%s, 'non populated'>" % (type(self).__name__, self.id)
+        else:
+            return "<%s #%s, '%s'>" % (type(self).__name__, self.id, self.name)
 
-    """ get the string representation of the component for the given language
-        @param  lang   str: iso 639-2 code of the language
-        @return text   str: 
-    """
-    def get_string(self, lang):
-        pass
 
 class EmComponentNotExistError(Exception):
     pass

EditorialModel/fieldgroups.py

@@ -1,51 +1,67 @@
 #-*- coding: utf-8 -*-
 
-from EditorialModel.components import EmComponent
+from EditorialModel.components import EmComponent, EmComponentNotExistError
+from Database.sqlobject import SqlObject
+
+import EditorialModel
 
 class EmFieldGroup(EmComponent):
     """ Represents groups of EmField
-            
+
         EmClass fields representation is organised with EmFieldGroup
         @see EmField
     """
-    
 
-    def __init__(id_or_name):
-        """ Instanciate an EmFieldGroupe with data fetched from db
+    table = 'em_fieldgroup'
+
+    def __init__(self, id_or_name):
+        """ Instanciate an EmFieldGroup with data fetched from db
             @param id_or_name str|int: Identify the EmFieldGroup by name or by global_id
             @throw TypeError
             @see component::EmComponent::__init__()
         """
-        super(EmFieldGroup, self).__init__()
-        pass
+        self.table = EmFieldGroup.table
+        super(EmFieldGroup, self).__init__(id_or_name)
 
     @staticmethod
-    def create(name, em_class, ml_repr = None, ml_help = None, icon = None):
-        """ Create a new EmType and instanciate it
-            
-            @todo Change the icon param type
-            @todo em_class == None => Error ?
-            @todo change staticmethod to classmethod ?
-            
-            @param name str: The name of the new Type
+    def create(name, em_class):
+        """ Create a new EmFieldGroup, save it and instanciate it
+
+            @param name str: The name of the new fielgroup
             @param em_class EmClass: The new EmFieldGroup will belong to this class
-            @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
-            @return An EmFieldGroup instance
-            @see EmComponent::__init__()
         """
-        pass
+        try:
+            exists = EmFieldGroup(name)
+        except EmComponentNotExistError:
+            uids = SqlObject('uids')
+            res = uids.wexec(uids.table.insert().values(table=EmFieldGroup.table))
+            uid = res.inserted_primary_key
+
+            emfieldgroup = SqlObject(EmFieldGroup.table)
+            res = emfieldgroup.wexec(emfieldgroup.table.insert().values(uid=uid, name=name, class_id=em_class.id))
+            return EmFieldGroup(name)
 
-    def fields():
+        return exists
+
+    """ Use dictionary (from database) to populate the object
+    """
+    def populate(self):
+        row = super(EmFieldGroup, self).populate()
+        self.em_class = EditorialModel.classes.EmClass(int(row.class_id))
+
+    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,
+        }
+
+        return super(EmFieldGroup, self).save(values)
+
+    def fields(self):
         """ Get the list of associated fields
             @return A list of EmField
         """
         pass
-
-    def field():
-        """ ???
-            @todo : find what this function is for
-        """
-        pass
-

EditorialModel/fields.py

@@ -1,78 +1,89 @@
 #-*- coding: utf-8 -*-
 
-from EditorialModel.components import EmComponent
+from EditorialModel.components import EmComponent, EmComponentNotExistError
+from Database.sqlobject import SqlObject
+
+import EditorialModel
 
 """Represent one data for a lodel2 document"""
 class EmField(EmComponent):
 
-    
-    def __init__(id_or_name):
-        """ Instanciate an EmType with data fetched from db
+    table = 'em_field'
+
+    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__()
         """
-        super(EmField, self).__init__()
-        pass
+        self.table = EmField.table
+        super(EmField, self).__init__(id_or_name)
 
     @staticmethod
-    def create( name, em_fieldgroup, ml_repr = None, ml_help = None,
-                icon = None, optionnal = False, type_relation = None,
-                relationnal_field = None, primary_data = False,
-                default_value = None, params = None, value = None):
-        """ Create a new EmType and instanciate it
-            
-            @todo Change the icon param type
-            @todo simplify function aguments ?
-            @todo typeof default_value argument ?
-            @todo typeof params argument ?
-            @todo typeof value argument ?
-            
+    def create(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 optionnal bool: Is the field optionnal ?
-            @param type_relation EmType|None: If not None make a link between the class of the new EmField and this EmType
-            @param relationnal_field EmField|None: If not None indicates that the new field defines the relation created by this EmField argument
-            @param primary_data bool: Is the new field a primary data field ?
-            @param default_value str: The field's default value
-            @param params str: Params of the field
-            @param value str: Value of the field
-            
+
+            @param optional bool: Is the field optional ?
+            @param internal bool: Is the field internal?
+
             @throw TypeError
             @see EmComponent::__init__()
             @staticmethod
         """
-        pass
+        try:
+            exists = EmField(name)
+        except EmComponentNotExistError:
+            uids = SqlObject('uids')
+            res = uids.wexec(uids.table.insert().values(table=EmField.table))
+            uid = res.inserted_primary_key
 
-    def set_default(default_value):
-        """ Set the default value
-            @todo argument type ?
-            @todo return type ?
-            @param default_value anytype: The default value
-        """
-        pass
+            values = {
+                'uid' : uid,
+                'name' : name,
+                'fieldgroup_id' : em_fieldgroup.id,
+                'fieldtype_id' : em_fieldtype.id,
+                'optional' : 1 if optional else 0,
+                'internal' : 1 if internal else 0,
+            }
 
-    def set_param(params):
-        """ Set the field parameters
-            @todo argument type ? EmFieldParam ?
-            @todo return type ?
-            @param params anytype: The field parameters
-        """
-        pass
-
-    def set_value(v):
-        """ Set the field value
-            
-            @todo Better explanations
-            
-            Don't set the field value in a document, it's a special kind of value
-            
-            @param The v: value
-        """
-        pass
+            emfield_req = SqlObject(EmField.table)
+            res = emfield_req.wexec(emfield_req.table.insert(values=values))
+            return EmField(name)
+
+        return exists
+
+    """ Use dictionary (from database) to populate the object
+    """
+    def populate(self):
+        row = super(EmField, self).populate()
+        self.em_fieldgroup = EditorialModel.fieldgroups.EmFieldGroup(int(row.fieldgroup_id))
+        self.em_fieldtype = EditorialModel.fieldtypes.EmFieldType(int(row.fieldtype_id))
+        self.optional = True if row.optional == 1 else False;
+        self.internal = True if row.internal == 1 else False;
+        self.icon = row.icon
+        self.rel_to_type_id = EditorialModel.fieldtypes.EmFieldType(int(row.rel_to_type_id)) if row.rel_to_type_id else ''
+        self.rel_field_id = EmField(int(row.rel_field_id)) if row.rel_field_id else ''
+
+    def save(self):
+        # should not be here, but cannot see how to do this
+        if self.name is None:
+            self.populate()
+
+        values = {
+            'fieldgroup_id' : self.em_fieldgroup.id,
+            'fieldtype_id' : self.em_fieldtype.id,
+            'optional' : 1 if self.optional else 0,
+            'internal' : 1 if self.internal else 0,
+            'icon' : self.icon,
+            'rel_to_type_id' : self.rel_to_type_id,
+            'rel_field_id' : self.rel_field_id
+        }
+
+        return super(EmField, self).save(values)

EditorialModel/fieldtypes.py

@@ -0,0 +1,8 @@
+#-*- coding: utf-8 -*-
+
+from EditorialModel.components import EmComponent, EmComponentNotExistError
+
+class EmFieldType():
+
+    def __init__(self, id):
+        self.id = id

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
-

Lodel/utils/mlstring.py

@@ -1,7 +1,36 @@
 # -*- coding: utf-8 -*-
 
+import json
+
 class MlString(object):
     """ Handle string with translations """
 
-    def __init__(self, default_str, translations = dict()):
-        pass
+    def __init__(self, translations = dict()):
+        self.translations = translations
+
+    def get(self, lang):
+        if not lang in self.translations:
+            return ''
+
+        return self.translations[lang]
+
+    def set(self, lang, text):
+        if not text:
+            if lang in self.translations:
+                del(self.translations[lang])
+        else:
+            self.translations[lang] = text
+
+    def __str__(self):
+        if self.translations:
+            return json.dumps(self.translations)
+        else:
+            return ""
+
+    @staticmethod
+    def load(json_string):
+        if isinstance(json_string, str) and json_string != '':
+            translations = json.loads(json_string)
+        else:
+            translations = dict()
+        return MlString(translations)