Correct the _LeObject.get() method and add some methods to LeType

Now the _LeObject.get() method should be able to return LeType child classes instance
LeType has two new methods :
	- LeTypes.datas() @property method that returns a dict(FIELDNAME:FIELDVALUE)
	- LeType.populate() that fetch from datassource missing fieldvalues

leobject/leclass.py

@@ -12,6 +12,8 @@ class LeClass(object):
     _linked_types = dict()
     ## @brief Stores fieldgroups and the fields they contains
     _fieldgroups = dict()
+    ## @brief Stores the EM uid
+    _class_id = None
 
     ## @brief Instanciate a new LeClass
     # @param model Model : The editorial model

leobject/leobject.py

@@ -23,6 +23,16 @@ class _LeObject(object):
     # @param **kwargs dict : datas usefull to instanciate a _LeObject
     def __init__(self, **kwargs):
         raise NotImplementedError("Abstract constructor")
+    
+    ## @brief Given a ME uid return the corresponding LeClass or LeType class
+    # @return a LeType or LeClass child class
+    # @throw KeyError if no corresponding child classes
+    def uid2leobj(cls, uid):
+        uid = int(uid)
+        if uid not in cls._me_uid:
+            raise KeyError("No LeType or LeClass child classes with uid '%d'"%uid)
+        return cls._me_uid[uid]
+        
 
     ## @brief update an existing LeObject
     # @param lodel_id int | (int): lodel_id of the object(s) where to apply changes
@@ -78,6 +88,8 @@ class _LeObject(object):
         #Fetching LeType
         if typename is None:
             letype = None
+            if 'type_id' not in field_list:
+                field_list.append('type_id')
         else:
             letype = leobject.lefactory.LeFactory.leobj_from_name(typename)
 
@@ -105,8 +117,17 @@ class _LeObject(object):
         filters = [f for f in filters if not self._field_is_relational(f[0])]
         #Checking the rest of the fields
         LeFactory._check_fields(letype, leclass, [ f[0] for f in filters ])
+        
+        #Fetching datas from datasource
+        datas = self._datasource.get(emclass, emtype, field_list, filters, relational_filters)
+        
+        #Instanciating corresponding LeType child classes with datas
+        result = list()
+        for leobj_datas in datas:
+            letype = self.uid2leobj(datas['type_id']) if letype is None else letype
+            result.append(letype(datas))
 
-        return self._datasource.get(emclass, emtype, filters, relational_filters)
+        return result
 
     ## @brief Check if a fieldname is valid
     # @param letype LeType|None : The concerned type (or None)

leobject/letype.py

@@ -14,6 +14,8 @@ class LeType(object):
     _superiors = list()
     ## @brief Stores the class of LeClass
     _leclass = None
+    ## @brief Stores the EM uid
+    _type_id = None
     
     ## @brief Instanciate a new LeType
     # @param lodel_id : The lodel id
@@ -23,11 +25,37 @@ class LeType(object):
             raise NotImplementedError("Abstract class")
 
         self.lodel_id = lodel_id
+
+        if 'type_id' in kwargs:
+            if self.__class__._type_id != int(kwargs['type_id']):
+                raise RuntimeError("Trying to instanciate a %s with an EM uid that is not correct"%self.__class__.__name__)
+
         ## Populate the object from the datas received in kwargs
         for name, value in kwargs.items():
             if name not in self._fields:
                 raise AttributeError("No such field '%s' for %s"%(name, self.__class__.__name__))
             setattr(self, name, value)
+    
+    ## @brief Populate the LeType wih datas from DB
+    # @param field_list None|list : List of fieldname to fetch. If None fetch all the missing datas
+    def populate(self, field_list=None):
+        if field_list == None:
+            field_list = [ fname for fname in self._fields if not hasattr(self, fname) ]
+
+        fdatas = self._datasource.get(self._leclass, self.__class__, 'lodel_id = %d'%self.lodel_id)
+        for fname, fdats in fdatas[0].items():
+            setattr(self, name, value)
+
+    ## @brief Get a fieldname:value dict
+    # @warning Giving True as full argument can represent a performances issue
+    # @param full bool : If true populate the object before returning the datas
+    # @return A dict with field name as key and the field value as value
+    @property
+    def datas(self, full=False):
+        if full:
+            self.populate()
+        return { fname: getattr(self, fname) for fname in self._fields if hasattr(self,fname) }
+            
 
     ## @brief Delete the LeType from Db
     # @note equivalent to LeType::delete(this.lodel_id)
@@ -63,6 +91,7 @@ class LeType(object):
     # @throw InvalidArgumentError if invalid argument
     @classmethod
     def insert(self, **datas):
+        self.check_datas_or_raise(datas, complete=True)
         super(LeType, self).insert(typename=self.__class__.__name__, classname=self._leclass.__name__, **datas)
         pass