Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

Doxyfile

 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = .
+INPUT                  =
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

lodel/leapi/leobject.py

 from lodel.settings import Settings
 from lodel.settings.utils import SettingsError
 from .query import LeInsertQuery, LeUpdateQuery, LeDeleteQuery, LeGetQuery
+from .exceptions import *
 from lodel.plugin.hooks import LodelHook
 
 ##@brief Stores the name of the field present in each LeObject that indicates
 #the name of LeObject subclass represented by this object
 CLASS_ID_FIELDNAME = "classname"
 
-class LeApiErrors(Exception):
-    ##@brief Instanciate a new exceptions handling multiple exceptions
-    # @param msg str : Exception message
-    # @param exceptions dict : A list of data check Exception with concerned field (or stuff) as key
-    def __init__(self, msg = "Unknow error", exceptions = None):
-        self._msg = msg
-        self._exceptions = dict() if exceptions is None else exceptions
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
-        msg = self._msg
-        for_iter = self._exceptions.items() if isinstance(self._exceptions, dict) else enumerate(self.__exceptions)
-        for obj, expt in for_iter:
-            msg += "\n\t{expt_obj} : ({expt_name}) {expt_msg}; ".format(
-                    expt_obj = obj,
-                    expt_name=expt.__class__.__name__,
-                    expt_msg=str(expt)
-            )
-        return msg
-
-
-##@brief When an error concern a query
-class LeApiQueryError(LeApiErrors):
-    pass
-
-
-##@brief When an error concerns a datas
-class LeApiDataCheckError(LeApiErrors):
-    pass
-
-
 ##@brief Wrapper class for LeObject getter & setter
 #
 # This class intend to provide easy & friendly access to LeObject fields values 
             ds_conf[k] = getattr(ds_conf_old, k)
 
         return datasource_class(**ds_conf)
+    
+    ##@brief Return the uid of the current LeObject instance
+    #@return the uid value
+    #@warning Broke multiple uid capabilities
+    def uid(self):
+        return self.data(self._uid[0])
 
     ##@brief Read only access to all datas
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
             raise RuntimeError("The field %s is not initialized yet (and have no value)" % field_name)
         return self.__datas[field_name]
     
+    ##@brief Read only access to all datas
+    #@return a dict representing datas of current instance
+    def datas(self):
+        return [self.data(fname) for fname in self.fieldnames(True)]
+        
+    
     ##@brief Datas setter
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
     # @param fname str : field name
             
         try:
             result = query.execute(datas)
-        except Exception as err;
+        except Exception as err:
             raise err
 
         return result

lodel/leapi/query.py

 
 import re
 import copy
+import inspect
 
-from .leobject import LeObject, LeApiErrors, LeApiDataCheckError
+from .exceptions import *
 from lodel.plugin.hooks import LodelHook
 from lodel import logger
 
-class LeQueryError(Exception):
-    ##@brief Instanciate a new exceptions handling multiple exceptions
-    #@param msg str : Exception message
-    #@param exceptions dict : A list of data check Exception with concerned
-    # field (or stuff) as key
-    def __init__(self, msg = "Unknow error", exceptions = None):
-        self._msg = msg
-        self._exceptions = dict() if exceptions is None else exceptions
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
-        msg = self._msg
-        if isinstance(self._exceptions, dict):
-            for_iter = self._exceptions.items()
-        else:
-            for_iter = enumerate(self.__exceptions)
-        for obj, expt in for_iter:
-            msg += "\n\t{expt_obj} : ({expt_name}) {expt_msg}; ".format(
-                    expt_obj = obj,
-                    expt_name=expt.__class__.__name__,
-                    expt_msg=str(expt)
-            )
-        return msg
 
 ##@todo check datas when running query
 class LeQuery(object):
     ##@brief Abstract constructor
     # @param target_class LeObject : class of object the query is about
     def __init__(self, target_class):
+        from .leobject import LeObject
         if self._hook_prefix is None:
             raise NotImplementedError("Abstract class")
         if not issubclass(target_class, LeObject):
 
 
 ##@brief A query to update datas for a given object
+#
+#@todo Change behavior, Huge optimization problem when updating using filters
+#and not instance. We have to run a GET and then 1 update by fecthed object...
 class LeUpdateQuery(LeFilteredQuery):
     
     _hook_prefix = 'leapi_update_'
     _data_check_args = { 'complete': True, 'allow_internal': False }
-
-    def __init__(self, target_class, query_filter):
-        super().__init__(target_class, query_filter)
     
-    ##@brief Called by __query to do severals checks before running the update
-    #@warning Optimization issue : each time this method is called we do 
-    #a LeGetQuery to fetch ALL datas and construct instances for being able to
-    #construct datas and check consistency
-    #@todo implementation (waiting for LeApi to be plugged to LeQuery)
-    def __fetch_construct_check_update(self, filters, rel_filters, datas):
-        """
-        instances = self._target_class.get(filters, rel_filters)
-        for instance in instances:
-            instance.check_datas_value(instance.
-        """
-        pass
-        
+    ##@brief Instanciate an update query
+    #
+    #If a class and not an instance is given, no query_filters are expected
+    #and the update will be fast and simple. Else we have to run a get query
+    #before updating (to fetch datas, update them and then, construct them
+    #and check their consistency)
+    #@param target LeObject clas or instance
+    #@param query_filters list|None
+    #@todo change strategy with instance update. We have to accept datas for
+    #the execute method
+    def __init__(self, target, query_filters = None):
+        ##@brief This attr is set only if the target argument is an 
+        #instance of a LeObject subclass
+        self.__leobject_datas = None
+        target_class = target
+        if not inspect.isclass(target):
+            if query_filters is not None:
+                msg = "No query_filters accepted when an instance is given as \
+target to LeUpdateQuery constructor"
+                raise AttributeError(msg)
+            target_class = target.__class__
+            if self.initialized():
+                self.__leobject_instance_datas = target.datas()
+            else:
+                filters = [(target._uid[0], '=', target.uid())]
+    
+        super().__init__(target_class, query_filters)
 
     ##@brief Implements an update query
     #@param filters list : see @ref LeFilteredQuery
     #@param rel_filters list : see @ref LeFilteredQuery
     #@param datas dict : datas to update
     #@returns the number of updated items
+    #@todo change stategy for instance update. Datas should be allowed 
+    #for execute method (and query)
     def __query(self, filters, rel_filters, datas):
-        self.__fetch_construct_check_update(filters, rel_filters, datas)
-        nb_updated = self._rw_datasource.update(
-            self._target_class, filters, rel_filters, datas)
+        uid_name = self._target_class._uid[0]
+        if self.__leobject_instance is not None:
+            #Instance update
+            #Building query_filter
+            filters = [(
+                uid_name, '=', self.__leobject_instance_datas[uid_name])]
+            self._rw_datasource.update(
+                self._target_class, filters, [],
+                self.__leobject_instance_datas)
+        else:
+            #Update by filters, we have to fetch datas before updating
+            res = self._ro_datasource.select(
+                self._target_class, self._target_class.fieldnames(True),
+                filters, rel_filters)
+            #Checking and constructing datas
+            upd_datas = dict()
+            for res_data in res:
+                res_data.update(datas)
+                res_datas = self._target_class.prepare_datas(
+                    res_data, True, True)
+                filters = [(uid_name, '=', res_data[uid_name])]
+                self._rw_datasource.update(
+                    self._target_class, filters, [],
+                    res_datas)
         return nb_updated
     
     ## @brief Execute the update query
-    def execute(self, datas):
+    def execute(self, datas = None):
+        if self.__leobject_instance is not None and datas is not None:
+            raise AttributeError("No datas expected when running an update \
+query on an instance")
         return super().execute(datas = datas)
 
 ##@brief A query to delete an object
                 err_l[fieldname] =  expt
         if len(err_l) > 0:
             msg = "Error while setting field_list in a get query"
-            raise LeQueryError(msg = msg, exceptions = err_l)
+            raise LeApiQueryErrors(msg = msg, exceptions = err_l)
         self.__field_list = list(set(field_list))
     
     ##@brief Execute the get query

plugins/mongodb_datasource/__init__.py

-from lodel.settings.validator import SettingValidator
-
+from .utils import connect, get_connection_args
 
 __loader__ = "main.py"
 __confspec__ = "confspec.py"
 #
 # @return bool|str : True if all the checks are OK, an error message if not
 def _activate():
+    default_connection_args = get_connection_args()
+    connection_check = connect(
+        default_connection_args['host'],
+        default_connection_args['port'],
+        default_connection_args['db_name'],
+        default_connection_args['username'],
+        default_connection_args['password'])
+    if not connection_check:
+        return False
     return True

plugins/mongodb_datasource/datasource.py

 
 from lodel import logger
 
-from .utils import mongodbconnect, object_collection_name, \
-    connect, MONGODB_SORT_OPERATORS_MAP, connection_string
+from .utils import object_collection_name, connect, \
+    MONGODB_SORT_OPERATORS_MAP, connection_string
 
 class MongoDbDataSourceError(Exception):
     pass
     #@param instanciate bool : If true, the records are returned as instances, else they are returned as dict
     #@return list
     #@todo Implement the relations
-    def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+    def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0):
         collection_name = object_collection_name(target)
         collection = self.database[collection_name]
         query_filters = self.__process_filters(

plugins/mongodb_datasource/main.py

 from lodel.plugin import LodelHook
 
+
 @LodelHook('mongodb_mh_init')
 def mongodb_migration_handler_init():
     import plugins.mongodb_datasource.migration_handler as migration_handler
 
+
 @LodelHook('mongodb_ds_init')
 def mongodb_datasource_init():
     import plugins.mongodb_datasource.datasource as datasource

plugins/mongodb_datasource/utils.py

     return connect(host, port, dbname, login, password)
 '''
 
+
 def connection_string(host, port, db_name, username, password):
     return 'mongodb://%s:%s@%s:%s' % (username, password, host, port)
 
+
 def connect(host, port, db_name, username, password):
     connection = MongoClient(
         connection_string(host, port, db_name, username, password))
     return database
 
 
-
 ## @brief Returns a collection name given a EmClass
 # @param class_object EmClass
 # @return str
 
     return collection_name
 
-##@brief Determine a collection field name given a lodel2 fieldname
-#@note For the moment this method only return the argument but EVERYWHERE
-#in the datasource we should use this method to gather proper fieldnames
-#@param fieldname str : A lodel2 fieldname
-#@return A string representing a well formated mongodb fieldname
-#@see mongo_filednames
+
+## @brief Determine a collection field name given a lodel2 fieldname
+# @note For the moment this method only return the argument but EVERYWHERE
+# in the datasource we should use this method to gather proper fieldnames
+# @param fieldname str : A lodel2 fieldname
+# @return A string representing a well formated mongodb fieldname
+# @see mongo_filednames
 def mongo_fieldname(fieldname):
     return fieldname
-##@brief Same as mongo_fieldname but for list of fields
+
+
+## @brief Same as mongo_fieldname but for list of fields
 #
-#A small utility function
-#@param fieldnames iterable : contains str only
-#@return a list of converted fildnames (str)
-#@see mongo_fieldname
-def mongo_filednames(fieldnames):
+# A small utility function
+# @param fieldnames iterable : contains str only
+# @return a list of converted fildnames (str)
+# @see mongo_fieldname
+def mongo_fieldnames(fieldnames):
     return [mongo_fieldname(fname) for fname in fieldnames]
 
+
 ## @brief Returns a list of orting options
 # @param query_filters_order list
 # @return list
 def parse_query_order(query_filters_order):
-    return [    (field, LODEL_SORT_OPERATORS_MAP[direction])
-                for field, direction in query_filters_order]
+    return [(field, LODEL_SORT_OPERATORS_MAP[direction])
+            for field, direction in query_filters_order]

tests/leapi/query/test_get.py

 import tests.loader_utils
 from tests.leapi.query.utils import dyncode_module as dyncode
 
-from lodel.leapi.leobject import LeApiDataCheckError
-from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery, LeQueryError
+from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery
+from lodel.leapi.exceptions import LeApiQueryError
 
 class LeGetQueryTestCase(unittest.TestCase):
     
                             ('lodel_id', None,) )
 
         for bad_field_list in bad_field_lists:
-            with self.assertRaises(LeQueryError):
+            with self.assertRaises(LeApiQueryError):
                 LeGetQuery(dyncode.Object, [], field_list = bad_field_list)