Started some method implementation form _LeObject and LeType

Methods are _LeObject.get() and LeType.check_datas()

leobject/leobject.py

@@ -81,13 +81,46 @@ class _LeObject(object):
             else:
                 filters.append(self._split_filter(query))
         #Now filters is a list of tuple (FIELD, OPERATOR, VALUE
-
-        try:
-            responses = self.datasource.get(datasource_filters)
-        except:
-            raise
-
-        return responses
+        #Begining to check the filters
+        
+        #Fetching EmType
+        if typename is None:
+            emtype = None
+        else:
+            emtype = self._model.component_from_name(typename, 'EmType')
+            if not emtype:
+                raise LeObjectQueryError("No such EmType : '%s'"%typename)
+        #Fetching EmClass
+        if classname is None:
+            emclass = None
+        else:
+            emclass = self._model.component_from_name(classname, 'EmClass')
+            if not emclass:
+                raise LeObjectQueryError("No such EmClass : '%s'"%classname)
+
+        #Checking that fields in the query_filters are correct
+        if emtype is None and emclass is None:
+            #Only fields from the object table are allowed
+            for field,_,_ in filters:
+                if field not in EditorialModel.classtype.common_fields:
+                    raise LeObjectQueryError("Not typename and no classname given, but the field %s is not in the common_fields list"%field)
+        else:
+            if emtype is None:
+                field_l = emclass.fields()
+            else:
+                if not (emclass is None):
+                    if emtype.em_class != emclass:
+                        raise LeObjectQueryError("The EmType %s is not a specialisation of the EmClass %s"%(typename, classname))
+                else:
+                    #Set emclass (to query the db ?
+                    emclass = emtype.em_class
+                field_l = emtype.fields()
+            #Checks that fields are in this type
+            for field,_,_ in filters:
+                if field not in [ f.name for f in fields_l ]:
+                    raise LeObjectQueryError("No field named '%s' in '%s'"%(field, typename))
+
+        return self._datasource.get(emclass, emtype, filters)
 
     ## @brief check if data dict fits with the model
     # @param data dict: dictionnary of field:value to check
@@ -126,3 +159,9 @@ class _LeObject(object):
         op_re_piece += ')'
         cls._query_re = re.compile('^\s*(?P<field>[a-z_][a-z0-9\-_]*)\s*'+op_re_piece+'\s*(?P<value>[^<>=!].*)\s*$', flags=re.IGNORECASE)
         pass
+
+class LeObjectError(Exception):
+    pass
+
+class LeObjectQueryError(LeObjectError):
+    pass

leobject/letype.py

@@ -1,6 +1,8 @@
 #-*- coding: utf-8 -*-
 
+from Lodel.utils.classinstancemethod import classinstancemethod
 from leobject.leclass import LeClass
+from leobject.leobject import LeObjectError
 
 ## @brief Represent an EmType data instance
 # @note Is not a derivated class of LeClass because the concrete class will be a derivated class from LeClass
@@ -25,6 +27,14 @@ class LeType(object):
                 raise AttributeError("No such field '%s' for %s"%(name, self.__class__.__name__)
             setattr(self, name, value)
     
+    @classinstancemethod
+    def delete(self):
+        pass
+    
+    @delete.classmethod
+    def delete(cls, uid):
+        pass
+
     ## @brief Insert a new LeType in the datasource
     # @param **datas : A dict containing the datas
     # @return The lodel id of the new LeType or False
@@ -32,13 +42,6 @@ class LeType(object):
     # @throw InvalidArgumentError if invalid argument
     @classmethod
     def insert(cls, **datas):
-        #check datas
-        autom_fields = ['lodel_id', 'typename', 'classname' ]
-        for forbiden in autom_fields:
-            if forbiden in datas:
-                raise AttributeError("Not allowed to give explicitly '%s' to insert method"%(forbiden))
-        self.check_datas(datas)
-
         super(LeType, self).insert(typename=self.__class__.__name__, classname=self._leclass.__name__, **datas)
         pass
     
@@ -63,14 +66,34 @@ class LeType(object):
     
     ## @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
+    # @param complete bool : if True expect that datas provide values for all non internal fields
+    # @throw TypeError If the datas are not valids
+    # @throw AttributeError if datas provides values for automatic fields
+    # @throw AttributeError if datas provides values for fields that doesn't exists
     @classmethod
-    def check_datas(cls, datas):
+    def check_datas_or_raise(cls, datas, complete = False):
+        autom_fields = [f.name for f in cls._fieldtypes if f.internal]
         for dname, dval in datas.items():
+            if dname in autom_fields:
+                raise AttributeError("The field '%s' is internal"%(dname)
             if dname not in cls._fields:
                 raise AttributeError("No such field '%s' for %s"%(dname, self.__class__.__name__)
-            cls._fields[dname].check_or_raise(dval)
-                
+            cls._fieldtypess[dname].check_or_raise(dval)
+        
+        fields = [f.name for f in cls._fieldtypes if not f.internal]
+        if complete and len(datas) < len(fields):
+            raise LeObjectError("The argument complete was True but some fields are missing : %s"%(set(fields) - set(datas.keys())))
+    
+    ## @brief Check that datas are valid for this type
+    # @param datas dict : key == field name value are field values
+    # @param complete bool : if True expect that datas provide values for all non internal fields
+    # @return True if check pass else False
+    def check_datas(cls, datas, complete = False):
+        try:
+            cls.check_datas_or_raise(datas, complete)
+        except (TypeError, AttributeError, LeObjectError):
+            return False
+        return True
 
     ## @brief Implements the automatic checks of attributes
     # @note Run data check from fieldtypes if we try to modify an field attribute of the LeType
@@ -80,7 +103,7 @@ class LeType(object):
         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):