[LeFactory] changed the way LeType and LeClass stores fieldgroups, fields and fieldtypes

leobject/leclass.py

@@ -0,0 +1,32 @@
+#-*- coding: utf-8 -*-
+
+from leobject.dyn import LeObject
+
+## @brief Represent an EmClass data instance
+class LeClass(LeObject):
+    
+    ## @brief Stores fieldtypes by field name
+    _fieldtypes = dict()
+    ## @brief Stores fieldgroups and the fields they contains
+    _fieldgroups = dict()
+
+    ## @brief Instanciate a new LeClass
+    # @param model Model : The editorial model
+    # @param datasource ? : The datasource
+    def __init__(self, **kwargs):
+        if self._cls_field is None:
+            raise NotImplementedError("Abstract class")
+        super(LeClass, self).__init__(**kwargs)
+    
+    ## @brief Get the linked objects
+    # @return an array of LeType derivated class instance
+    def linked(self):
+        pass
+    
+    ## @brief Link this class with an LeObject
+    # @param leo LeObject : The object to be linked with
+    # @return True if success False allready done
+    # @throw A Leo exception if the link is not allowed
+    def link_to(self, leo):
+        pass
+        

leobject/lefactory.py

@@ -11,6 +11,17 @@ class LeFactory(object):
     
     def __init__(self):raise NotImplementedError("Not designed (yet?) to be implemented")
 
+    ## @brief Return a call to a FieldType constructor given an EmField
+    # @param emfield EmField : An EmField
+    # @return a string representing the python code to instanciate a EmFieldType
+    @staticmethod
+    def fieldtype_construct_from_field(emfield):    
+        return '%s.EmFieldType(**%s)'%(
+            GenericFieldType.module_name(emfield.fieldtype),
+            emfield._fieldtype_args.__repr__(),
+        )
+            
+        
     ## @brief Generate python code containing the LeObject API
     # @param model_args dict : Dict of Model __init__ method arguments
     # @param datasource_args dict : Dict of datasource __init__ method arguments
@@ -46,33 +57,25 @@ class LeObject(_LeObject):\n\
         
         for emclass in model.components(EditorialModel.classes.EmClass):
             cls_fields = dict()
-            fieldgroups = emclass.fieldgroups()
-            for fieldgroup in fieldgroups:
-                cls_fields[fieldgroup.name] = dict()
+            for field in emclass.fields():
+                cls_fields[field.name] = LeFactory.fieldtype_construct_from_field(field)
+            cls_fieldgroup = dict()
+            for fieldgroup in emclass.fieldgroups():
+                cls_fieldgroup[fieldgroup.name] = list()
                 for field in fieldgroup.fields():
-                    fieldtype_constructor = '%s.EmFieldType(**%s)'%(
-                        GenericFieldType.module_name(field.fieldtype),
-                        field._fieldtype_args.__repr__(),
-                    )
-                    cls_fields[fieldgroup.name][field.name] = fieldtype_constructor
-            
+                    cls_fieldgroup[fieldgroup.name].append(field.name)
+
             result += "\n\
 class %s(LeObject, LeClass):\n\
-    _cls_fields = %s\n\
+    _fieldtypes = %s\n\
+    _fieldgroups = %s\n\
 \n\
-"%(emclass.name.title(), cls_fields.__repr__())
+"%(emclass.name.title(), cls_fields.__repr__(), cls_fieldgroup.__repr__())
 
         for emtype in model.components(EditorialModel.types.EmType):
-            type_fields = dict()
-            fieldgroups = emtype.fieldgroups()
-            for fieldgroup in fieldgroups:
-                type_fields[fieldgroup.name] = dict()
-                for field in fieldgroup.fields(emtype.uid):
-                    fieltype_constructor = '%s.EmFieldType(**%s)'%(
-                        GenericFieldType.module_name(field.fieldtype),
-                        field._fieldtype_args.__repr__(),
-                    )
-                    type_fields[fieldgroup.name][field.name] = fieldtype_constructor
+            type_fields = list()
+            for field in emtype.fields():
+                type_fields.append(field.name)
 
             result += "\n\
 class %s(%s,LeType):\n\

leobject/letype.py

@@ -0,0 +1,99 @@
+#-*- coding: utf-8 -*-
+
+from leobject.leclass import LeClass
+
+## @brief Represent an EmType data instance
+class LeType(LeClass):
+    
+    ## @brief Stores selected fields with key = name
+    _fields = list()
+    ## @brief Stores the class of LeClass
+    _leclass = None
+    
+    ## @brief Instanciate a new LeType
+    # @param model Model : The editorial model
+    # @param datasource ? : The datasource
+    def __init__(self, **kwargs):
+        if self._typename is None or self._leclass is None:
+            raise NotImplementedError("Abstract class")
+        super(LeType, self).__init__(**kwargs)
+    
+    ## @brief Insert a new LeType in the datasource
+    # @param datas dict : A dict containing the datas
+    # @return The lodel id of the new LeType or False
+    # @thorw A leo exception if invalid stuff
+    # @throw InvalidArgumentError if invalid argument
+    @classmethod
+    def insert(cls, datas):
+        pass
+    
+    ## @brief Delete a LeType from the datasource
+    # @param lodel_id int : The lodel_id identifying the LeType
+    # @param return True if deleted False if not existing
+    # @throw InvalidArgumentError if invalid parameters
+    # @throw Leo exception if the lodel_id identify an object from another type
+    @classmethod
+    def c_delete(cls, lodel_id):
+        pass
+    
+    ## @brief Update some objects in db
+    # @param lodel_id_l list : A list of lodel_id to update
+    # @param data dict : Represent the datas to update
+    # @return True if updated else False
+    # @throw InvalidArgumentError if invalid parameters
+    # @throw other Leo exceptions
+    @classmethod
+    def c_update(cls, lodel_id_l, datas):
+        pass
+    
+    ## @brief Check that datas are valid for this type
+    # @param datas dict : key == field name value are field values
+    # @throw If the datas are not valids
+    @classmethod
+    def check_datas(cls, datas):
+        for dname, dval in datas.items():
+            if dname not in cls._fields.keys():
+                raise Exception()
+            cls._fields[dname].check_or_raise(dval)
+                
+
+    ## @brief Implements the automatic checks of attributes
+    # @note Run data check from fieldtypes if we try to modify an field attribute of the LeType
+    # @param name str : The attribute name
+    # @param value * : The value
+    def __setattr__(self, name, value):
+        if name in self._fields.keys():
+            self._fields[name].check_or_raise(value)
+        return super(LeType, self).__setattr__(name, value)
+
+    ## @brief Delete the LeType
+    # @return True if deleted False if not
+    def delete(self):
+        return self.__class__.delete(self.lodel_id)
+    
+    ## @brief Update a LeType
+    # @return True if ok else False
+    def update(self):
+        return self.__class__.update(self.lodel_id, self._datas)
+        
+    ## @brief Fetch superiors
+    # @param nature str : The relation nature
+    # @return if no nature given return a dict with nature as key and arrays of LeObject as value. Else return an array of LeObject
+    def superiors(self, nature = None):
+        pass
+
+    ## @brief Fetch subordinates
+    # @param nature str : The relation nature
+    # @return if no nature given return a dict with nature as key and arrays of LeObject as value. Else return an array of LeObject
+    def subordinates(self, nature = None):
+        pass
+
+    ## @brief Add a superior
+    # @param nature str : The raltion nature
+    # @param leo LeObject : The superior
+    # @param return True if done False if already done
+    # @throw A Leo exception if trying to link with an invalid leo
+    # @throw InvalidArgumentError if invalid argument
+    def add_superior(self, nature, leo):
+        pass
+