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

Conflicts:
	lodel/leapi/datahandlers/base_classes.py

install/Makefile

 dyncode:
 	$(python) -c 'import lodel_admin; lodel_admin.refresh_dyncode()'
 
-init_db: dyncode
+init_db: 
 	$(python) -c 'import lodel_admin; lodel_admin.init_all_dbs()'
 
 list_hooks: dyncode

lodel/leapi/datahandlers/__init__.py

 from lodel.leapi.datahandlers.base_classes import DataHandler
 DataHandler.load_base_handlers()
+
+##@defgroup lodel2_datahandlers Datahandlers
+#@ingroup lodel2_leapi
+#@ingroup lodel2_em
+
+##@defgroup lodel2_dh_checks  Datahandlers datas checking
+#@ingroup lodel2_datahandlers
+
+##@package lodel.leapi.datahandlers Lodel2 datahandlers
+#
+#Datahandlers are object that handles datas check, construction and 
+#consistency check
+#
+
+
+##@page lodel2_dh_checks_page Datahandlers datas checking
+#@ingroup lodel2_dh_checks
+#
+#@section lodel2_dh_check_mech Datas checking mechanism
+#
+#The data checking mechanism is divided into 3 stages :
+# 1. **value checking** : a basic value check. Example : is len(value) < 52
+# 2. **data construction** : for datas that needs to be modified. Example :
+#a date that will be transformed into a Datetime object associated with
+#a timezone
+# 3. **data consistency checking** : perform a consistency checking on the 
+#object from the "point of view" of the current field. Example : is the given
+#lodel_id an identifier of a Article
+#
+#@subsection lodel2_dh_check_impl Implementation
+#
+#Those three stages are implemented by 3 datahandlers methods :
+# - @ref base_classes.DataHandler.check_data_value() "check_data_value"
+# - @ref base_classes.DataHandler.construct_data() "construct_data"
+# - @ref base_classes.DataHandler.check_data_value() "check_data_consitency"
+#
+#@note To ensure the calls of the base classes methods child classes implements
+#those method with a '_' preffix : 
+# - @ref base_classes.DataHandler._check_data_value "_check_data_value()"
+# - @ref base_classes.DataHandler._construct_data() "_construct_data"
+# - @ref base_classes.DataHandler._check_data_value() "_check_data_consitency"
+#
+#Examples of child classes can be found @ref datahandlers.datas "here"
+#
+#@subsubsection lodel2_dh_datas_construction Datas construction
+#
+#Datas construction is a bit tricky. When constructing a data handled by a
+#datahandler we may need to have access to other datas in the object (see 
+#@ref base_classes.DataHandler.construct_data() "construct_data() arguments").
+#
+#The problem reside in the construction order, if we need other datas we have
+#to be sure that they are allready constructed. To achieve this goal the datas
+#dict given as arguement to 
+#@ref base_classes.DataHandler.construct_data() "construct_data()" is an
+#@ref base_classes.DatasConstructor "DatasConstructor" instance. This class
+#check if a data is constructed when trying to access to it, if not it runs
+#the corresponding construct_data() (and have a circular dependencies detection
+#mechanism)
+#
+#@see base_classes.DatasConstructor.

lodel/leapi/datahandlers/base_classes.py

     pass
 
 ##@brief Base class for all data handlers
+#@ingroup lodel2_datahandlers
 class DataHandler(object):
     
     _HANDLERS_MODULES = ('datas_base', 'datas', 'references')
         return self.internal is not False
 
     ##@brief calls the data_field defined _check_data_value() method
-    # @return tuple (value, error|None)
+    #@ingroup lodel2_dh_checks
+    #@warning DO NOT REIMPLEMENT THIS METHOD IN A CUSTOM DATAHANDLER (see
+    #@ref _construct_data() and @ref lodel2_dh_check_impl )
+    #@return tuple (value, error|None)
     def check_data_value(self, value):
         if value is None:
             if not self.nullable:
 
             return None, None
         return self._check_data_value(value)
+    
+    ##@brief Designed to be implemented in child classes
+    def _check_data_value(self, value):
+        return value, None
 
     ##@brief checks if this class can override the given data handler
     # @param data_handler DataHandler
         return True
 
     ##@brief Build field value
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname str : The field name
-    # @param datas dict : dict storing fields values (from the component)
-    # @param cur_value : the value from the current field (identified by fieldname)
-    # @return the value
-    # @throw RunTimeError if data construction fails
+    #@ingroup lodel2_dh_checks
+    #@warning DO NOT REIMPLEMENT THIS METHOD IN A CUSTOM DATAHANDLER (see
+    #@ref _construct_data() and @ref lodel2_dh_check_impl )
+    #@param emcomponent EmComponent : An EmComponent child class instance
+    #@param fname str : The field name
+    #@param datas dict : dict storing fields values (from the component)
+    #@param cur_value : the value from the current field (identified by fieldname)
+    #@return the value
+    #@throw RunTimeError if data construction fails
+    #@todo raise something else
     def construct_data(self, emcomponent, fname, datas, cur_value):
         emcomponent_fields = emcomponent.fields()
         data_handler = None
         if fname in emcomponent_fields:
             data_handler = emcomponent_fields[fname]
-
+        
+        new_val = cur_value
         if fname in datas.keys():
-            return cur_value
+            pass
         elif data_handler is not None and hasattr(data_handler, 'default'):
-                return data_handler.default
+            new_val = data_handler.default
         elif data_handler is not None and data_handler.nullable:
-                return None
+            new_val = None
+        return self._construct_data(emcomponent, fname, datas, new_val)
+    
+    ##@brief Designed to be reimplemented by child classes
+    #@param emcomponent EmComponent : An EmComponent child class instance
+    #@param fname str : The field name
+    #@param datas dict : dict storing fields values (from the component)
+    #@param cur_value : the value from the current field (identified by fieldname)
+    #@return the value
+    #@see construct_data() lodel2_dh_check_impl
+    def _construct_data(self, empcomponent, fname, datas, cur_value):
         return cur_value
+        
 
     ##@brief Check datas consistency
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname : the field name
-    # @param datas dict : dict storing fields values
-    # @return an Exception instance if fails else True
-    # @todo A implémenter
+    #@ingroup lodel2_dh_checks
+    #@warning DO NOT REIMPLEMENT THIS METHOD IN A CUSTOM DATAHANDLER (see
+    #@ref _construct_data() and @ref lodel2_dh_check_impl )
+    #@warning the datas argument looks like a dict but is not a dict
+    #see @ref base_classes.DatasConstructor "DatasConstructor" and
+    #@ref lodel2_dh_datas_construction "Datas construction section"
+    #@param emcomponent EmComponent : An EmComponent child class instance
+    #@param fname : the field name
+    #@param datas dict : dict storing fields values
+    #@return an Exception instance if fails else True
+    #@todo A implémenter
     def check_data_consistency(self, emcomponent, fname, datas):
+        return self._check_data_consistency(emcomponent, fname, datas)
+    
+    ##@brief Designed to be reimplemented by child classes
+    #@param emcomponent EmComponent : An EmComponent child class instance
+    #@param fname : the field name
+    #@param datas dict : dict storing fields values
+    #@return an Exception instance if fails else True
+    #@see check_data_consistency() lodel2_dh_check_impl
+    def _check_data_consistency(self, emcomponent, fname, datas):
         return True
- 
+
     ##@brief make consistency after a query
     # @param emcomponent EmComponent : An EmComponent child class instance
     # @param fname : the field name
         if not issubclass(data_handler, DataHandler):
             raise ValueError("A data handler HAS TO be a child class of DataHandler")
         cls.__custom_handlers[name] = data_handler
-
+    
+    ##@brief Load all datahandlers
     @classmethod
     def load_base_handlers(cls):
         if cls._base_handlers is None:
         return hash(tuple(hash_dats))
 
 ##@brief Base class for datas data handler (by opposition with references)
+#@ingroup lodel2_datahandlers
 class DataField(DataHandler):
     pass
 
 ##@brief Abstract class for all references
+#@ingroup lodel2_datahandlers
 #
 # References are fields that stores a reference to another
 # editorial object
+#
+#
+#@todo Check data implementation : check_data = is value an UID or an
+#LeObject child instance
+#@todo Construct data implementation : transform the data into a LeObject
+#instance
+#@todo Check data consistency implementation : check that LeObject instance
+#is from an allowed class
 class Reference(DataHandler):
     base_type="ref"
 
             #if not issubclass(lodel.leapi.leobject.LeObject, back_reference[0]) or not isinstance(back_reference[1], str):
             #    raise TypeError("Back reference was expected to be a tuple(<class LeObject>, str) but got : (%s, %s)" % (back_reference[0], back_reference[1]))
         self.__back_reference = back_reference
-        self.back_ref = back_reference
-
         super().__init__(internal=internal, **kwargs)
     
     @property
         self.__back_reference = back_reference
 
     ##@brief Check value
-    # @param value *
-    # @return tuple(value, exception)
-    # @todo implement the check when we have LeObject to check value
-    def _check_data_value(self, value):
-        return value, None
+    #@param value *
+    #@return tuple(value, exception)
+    #@todo implement the check when we have LeObject to check value
+    def check_data_value(self, value):
+        return super().check_data_value(value)
+
+
+
         if isinstance(value, lodel.editorial_model.components.EmClass):
             value = [value]
         for elt in value:
         return value
 
     ##@brief Check datas consistency
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname : the field name
-    # @param datas dict : dict storing fields values
-    # @return an Exception instance if fails else True
-    # @todo A implémenter
+    #@param emcomponent EmComponent : An EmComponent child class instance
+    #@param fname : the field name
+    #@param datas dict : dict storing fields values
+    #@return an Exception instance if fails else True
+    #@todo check for performance issue and check logics
+    #@todo Implements consistency checking on value : Check that the given value
+    #points onto an allowed class
+    #@warning composed uid capabilities broken here
     def check_data_consistency(self, emcomponent, fname, datas):
+        rep = super().check_data_consistency(emcomponent, fname, datas)
+        if isinstance(rep, Exception):
+            return rep
+        if self.back_reference is None:
+            return True
+        #Checking back reference consistency
+
+        # !! Reimplement instance fetching in construct data !!
         dh = emcomponent.field(fname)
-        logger.debug(dh)
-        logger.info('Warning : multiple uid capabilities are broken here')
-        uid = datas[emcomponent.uid_fieldname()[0]]
-        target_class = self.back_ref[0]
-        target_field = self.back_ref[1]
-        target_uidfield = traget_class.uid_fieldname()[0]
-        value = datas[emcomponent.data(fname)]
+        uid = datas[emcomponent.uid_fieldname()[0]] #multi uid broken here
+        target_class = self.back_reference[0]
+        target_field = self.back_reference[1]
+        target_uidfield = target_class.uid_fieldname()[0] #multi uid broken here
+        value = datas[fname]
         
-        obj = target_class.get((target_uidfield , '=', value))
+        obj = target_class.get([(target_uidfield , '=', value)])
         
         if len(obj) == 0:
             logger.warning('Object referenced does not exist')
             return False
         
-        obj.set_data(target_field, uid)
-        obj.update()
         return True
 
 ##@brief This class represent a data_handler for single reference to another object
 
 
 ##@brief This class represent a data_handler for multiple references to another object
+#@ingroup lodel2_datahandlers
 #
 # The fields using this data handlers are like SingleRef but can store multiple references in one field
 # @note for the moment split on ',' chars
         super().__init__(**kwargs)
 
         
-    def _check_data_value(self, value):
+    def check_data_value(self, value):
+        value, expt = super().check_data_value(value)
+        if expt is not None:
+            #error in parent
+            return value, expt
+        elif value is None:
+            #none value
+            return value, expt
+
         expt = None
      
         if isinstance(value, str):
             value, expt = super()._check_data_value(value)
         elif not hasattr(value, '__iter__'):
-            return None, FieldValidationError("MultipleRef has to be an iterable or a string")
+            return None, FieldValidationError("MultipleRef has to be an iterable or a string, '%s' found" % value)
         if self.max_item is not None:
             if self.max_item < len(value):
                 return None, FieldValidationError("Too many items")
         return value, expt
 
-    def check_data_consistency(self, emcomponent, fname, datas):
-        return True
-    
     def construct_data(self, emcomponent, fname, datas, cur_value):
+        cur_value = super().construct_data(emcomponent, fname, datas, cur_value)
         if cur_value == 'None' or cur_value is None or cur_value == '':
             return None
         emcomponent_fields = emcomponent.fields()
             l_value = None
 
         if l_value is not None:
-            if self.back_ref is not None:
-                br_class = self.back_ref[0]
+            if self.back_reference is not None:
+                br_class = self.back_reference[0]
                 for br_id in l_value:
                     query_filters = list()
                     query_filters.append((br_class.uid_fieldname()[0], '=', br_id))
                     br_obj = br_class.get(query_filters)
                     if len(br_obj) != 0:
-                        br_list = br_obj[0].data(self.back_ref[1])
+                        br_list = br_obj[0].data(self.back_reference[1])
                         if br_list is None:
                             br_list = list()
                         if br_id not in br_list:
     # @param emcomponent EmComponent : An EmComponent child class instance
     # @param fname : the field name
     # @param datas dict : dict storing fields values
+<<<<<<< HEAD
     # @note Not done in case of delete
     def make_consistency(self, emcomponent, fname, datas, type_query):
+=======
+    """
+    def make_consistency(self, emcomponent, fname, datas):
+>>>>>>> 4acd6f8fbeff935cfb6ba072c9fec31ccb3bbb93
         dh = emcomponent.field(fname)
 
         logger.info('Warning : multiple uid capabilities are broken here')
         uid = datas[emcomponent.uid_fieldname()[0]]
-        if self.back_ref is not None:
-            target_class = self.back_ref[0]
-            target_field = self.back_ref[1]
+        if self.back_reference is not None:
+            target_class = self.back_reference[0]
+            target_field = self.back_reference[1]
             target_uidfield = target_class.uid_fieldname()[0]
             l_value = datas[fname]
 
                         l_uids_ref.append(uid)
                         obj[0].set_data(target_field, l_uids_ref)
                         obj[0].update()
+<<<<<<< HEAD
            
             if type_query == 'update':
                 query_filters = list()
                             l_uids_ref.remove(uid)
                             obj.set_data(target_field, l_uids_ref)
                             obj.update()
+=======
+    """
+>>>>>>> 4acd6f8fbeff935cfb6ba072c9fec31ccb3bbb93
                 
 ## @brief Class designed to handle datas access will fieldtypes are constructing datas
+#@ingroup lodel2_datahandlers
 #
 # This class is designed to allow automatic scheduling of construct_data calls. 
 #

lodel/leapi/datahandlers/datas.py

         self._format_string = format_string
         super().__init__(internal='automatic',**kwargs)
 
-    def construct_data(self, emcomponent, fname, datas, cur_value):
+    def _construct_data(self, emcomponent, fname, datas, cur_value):
         ret = self._format_string % tuple(
             datas[fname] for fname in self._field_list)
         if len(ret) > self.max_length:

lodel/leapi/datahandlers/datas_base.py

             error = ValueError("Tue value has to be a string or a datetime")
         return value, error
 
-    def construct_data(self, emcomponent, fname, datas, cur_value):
+    def _construct_data(self, emcomponent, fname, datas, cur_value):
         if (self.now_on_create and cur_value is None) or self.now_on_update:
             return datetime.datetime.now()
         return cur_value

lodel/leapi/datahandlers/references.py

 
         return val, expt
 
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        return super().construct_data(emcomponent, fname, datas, cur_value)
-
 ##@brief Child class of MultipleRef where references are represented in the form of a python set
 class Set(MultipleRef):
 
             return None, FieldValidationError("Set or string expected for a set field")
         return val, expt
     
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        return super().construct_data(emcomponent, fname, datas, cur_value)
-    
 ##@brief Child class of MultipleRef where references are represented in the form of a python dict
 class Map(MultipleRef):
 
                 None if isinstance(expt, Exception) else value,
                 expt)
 
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        logger.info('WARNING : not well implemented...list are stored...not dict')
-        if cur_value == 'None' or cur_value is None or cur_value == '':
-            return None
-        emcomponent_fields = emcomponent.fields()
-        data_handler = None
-        if fname in emcomponent_fields:
-            data_handler = emcomponent_fields[fname]
-        u_fname = emcomponent.uid_fieldname()
-        uidtype = emcomponent.field(u_fname[0]) if isinstance(u_fname, list) else emcomponent.field(u_fname)
-
-        if isinstance(cur_value, str):
-            value = cur_value.split(',')
-            l_value = [uidtype.cast_type(uid) for uid in value]
-        elif isinstance(cur_value, list):
-            l_value = list()
-            for value in cur_value:
-                if isinstance(value,uidtype.cast_type):
-                    l_value.append(value)
-                else:
-                    raise ValueError("The items must be of the same type, string or %s" % (emcomponent.__name__))
-        else:
-            l_value = None
-
-        if l_value is not None:
-            if self.back_ref is not None:
-                br_class = self.back_ref[0]
-                for br_id in l_value:
-                    query_filters = list()
-                    query_filters.append((br_class.uid_fieldname()[0], '=', br_id))
-                    br_obj = br_class.get(query_filters)
-                    if len(br_obj) != 0:
-                        br_list = br_obj[0].data(self.back_ref[1])
-                        if br_list is None:
-                            br_list = list()
-                        if br_id not in br_list:
-                            br_list.append(br_id)
-                            logger.info('The referenced object has to be updated')
-        return l_value
-    
 ##@brief This Reference class is designed to handler hierarchy with some constraint
 class Hierarch(MultipleRef):
     
         else:
             return None, FieldValidationError("Set or string expected for a set field")
         return val, expt
-    
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        return super().construct_data(emcomponent, fname, datas, cur_value)

lodel/leapi/leobject.py

     # @param cls
     # @param datas dict : Datas that have been returned by LeCrud.prepare_datas() method
     @classmethod
-    def make_consistency(cls, datas):
+    def make_consistency(cls, datas, type_query = 'insert'):
         for fname, dh in cls._fields.items():
-            ret = dh.make_consistency(cls, fname, datas)
+            ret = dh.make_consistency(cls, fname, datas, type_query)
             
     ## @brief Add a new instance of LeObject
     # @return a new uid en case of success, False otherwise

lodel/plugin/datasource_plugin.py

 from .exceptions import *
 from lodel.settings.validator import SettingValidator
 
+
+_glob_typename = 'datasource'
 ##@brief Designed to handles datasources plugins
 #
 #A datasource provide data access to LeAPI typically a connector on a DB
 #@todo Write abstract classes for Datasource and MigrationHandler !!!
 class DatasourcePlugin(Plugin):
     
+    _type_conf_name = _glob_typename
     ##@brief Stores confspecs indicating where DatasourcePlugin list is stored
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'datasource_connectors',
         'default': None,
-        'validator': SettingValidator('strip', none_is_valid = False) }
-    _type_conf_name = 'datasource'
+        'validator': SettingValidator(
+            'plugin', none_is_valid = False,
+            ptype = _glob_typename) }
  
     ##@brief Construct a DatasourcePlugin 
     #@param name str : plugin name

lodel/plugin/extensions.py

 from .exceptions import *
 from lodel.settings.validator import SettingValidator
 
+_glob_typename = 'extension'
 class Extension(Plugin):
     
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'extensions',
         'default': [],
-        'validator': SettingValidator('list', none_is_valid = False)}
+        'validator': SettingValidator(
+            'plugin', none_is_valid = False, ptype = _glob_typename)}
 
-    _type_conf_name = 'extension'
+    _type_conf_name = _glob_typename
 

lodel/plugin/interface.py

 from .exceptions import *
 from lodel.settings.validator import SettingValidator
 
+_glob_typename = 'ui'
+
+##@brief Handles interfaces plugin
+#@note It's a singleton class. Only 1 interface allowed by instance.
 class InterfacePlugin(Plugin):
     
     ##@brief Singleton instance storage
         'section': 'lodel2',
         'key': 'interface',
         'default': None,
-        'validator': SettingValidator('strip', none_is_valid = True)}
+        'validator': SettingValidator(
+            'plugin', none_is_valid = True, ptype = _glob_typename)}
 
-    _type_conf_name = 'ui'
+    _type_conf_name = _glob_typename
     
     def __init__(self, name):
         if InterfacePlugin._instance is not None:

lodel/plugin/sessionhandler.py

         return super().__getattribute__(name)
 
 
+_glob_typename = 'session_handler'
 ##@brief Singleton class designed to handle session handler plugin
 #
 #@note This class is a singleton because only one session handler can be
         'section': 'lodel2',
         'key': 'session_handler',
         'default': None,
-        'validator': SettingValidator('string', none_is_valid=False)}
+        'validator': SettingValidator(
+            'plugin', none_is_valid=False,ptype = _glob_typename)}
 
-    _type_conf_name = 'session_handler'
+    _type_conf_name = _glob_typename
             
     def __init__(self, plugin_name):
         if self._instance is None:

lodel/settings/validator.py

 import inspect
 import copy
 
-
 ## @package lodel.settings.validator Lodel2 settings validators/cast module
 #
 # Validator are registered in the SettingValidator class.
     _description = dict()
     
     ##@brief Instanciate a validator
-    def __init__(self, name, none_is_valid = False):
+    #@param name str : validator name
+    #@param none_is_valid bool : if True None will be validated
+    #@param **kwargs : more arguement for the validator
+    def __init__(self, name, none_is_valid = False, **kwargs):
         if name is not None and name not in self._validators:
             raise NameError("No validator named '%s'" % name)
         self.__none_is_valid = none_is_valid
         self.__name = name
+        self._opt_args = kwargs
 
     ##@brief Call the validator
     # @param value *
         if self.__none_is_valid and value is None:
             return None
         try:
-            return self._validators[self.__name](value)
+            return self._validators[self.__name](value, **self._opt_args)
         except Exception as e:
             raise SettingsValidationError(e)
     
         msg = "The value '%s' is not a valid host"
         raise SettingsValidationError(msg % value)
 
+##@brief Validator for Editorial model component
+#
+# Designed to validate a conf that indicate a class.field in an EM
 def emfield_val(value):
     from lodel.plugin.hooks import LodelHook
     spl = value.split('.')
             raise SettingsValidationError(msg % value)
     return value
 
-def plugin_val(value):
+##@brief Validator for plugin name & optionnaly type
+#
+#Able to check that the value is a plugin and if it is of a specific type
+def plugin_validator(value, ptype = None):
     from lodel.plugin.hooks import LodelHook
-    spl = value.split('.')
-    if len(spl) != 2:
-        msg = "Expected a value in the form PLUGIN.TYPE but got : %s"
-        raise SettingsValidationError(msg % value)
-    value = tuple(spl)
-    #Late validation hook
     @LodelHook('lodel2_dyncode_bootstraped')
-    def type_check(hookname, caller, payload):
-        from lodel import plugin
-        typesname = { cls.__name__.lower():cls for cls in plugin.PLUGINS_TYPE}
-        if value[1].lower() not in typesname:
-            msg = "Following plugin type do not exist in plugin list %s : %s"
-            raise SettingsValidationError(msg % value)
-        return value
-    plug_type_val = plugin_val(value)
-    return plug_type_val
-
+    def plugin_type_checker(hookname, caller, payload):
+        from lodel.plugin.plugins import Plugin
+        from lodel.plugin.exceptions import PluginError
+        try:
+            plugin = Plugin.get(value)
+        except PluginError:
+            msg = "No plugin named %s found"
+            msg %= value
+            raise SettingsValidationError(msg)
+        if plugin._type_conf_name.lower() != ptype.lower():
+            msg = "A plugin of type '%s' was expected but found a plugin \
+named  '%s' that is a '%s' plugin"
+            msg %= (ptype, value, plugin._type_conf_name)
+            raise SettingsValidationError(msg)
+    return value
+        
 
 #
 #   Default validators registration
 
 SettingValidator.register_validator(
     'plugin',
-    plugin_val,
-    'plugin validator')
+    plugin_validator,
+    'plugin name & type validator')
 
 SettingValidator.register_validator(
     'dummy',

plugins/mongodb_datasource/datasource.py

         mongo_filters = self.__process_filters(
             target, filters, relational_filters)
         res = self.__collection(target).update(mongo_filters, upd_datas)
+        target.make_consistency(datas=upd_datas, type_query='update')
         return res['n']
 
     ## @brief Inserts a record in a given collection
     # @return the inserted uid
     def insert(self, target, new_datas):
         res = self.__collection(target).insert(new_datas)
+        target.make_consistency(datas=new_datas)
         return str(res)
 
     ## @brief Inserts a list of records in a given collection
     # @return list : list of the inserted records' ids
     def insert_multi(self, target, datas_list):
         res = self.__collection(target).insert_many(datas_list)
+        for new_datas in datas_list:
+            target.make_consistency(datas=new_datas)
         return list(res.inserted_ids)
     
     ##@brief Act on abstract LeObject child

plugins/webui/interface/urls.py

     (r'^/admin/class_admin$', admin_class),
     (r'/test/(?P<id>.*)$', test),
     (r'^/test/?$', test),
-    #(r'/show/(?P<id>.*)$', show_document),
     (r'^/list_classes', list_classes),
     (r'^/list_classes?$', list_classes),
-    #(r'^/show_object/(.+)$', show_object),
     (r'^/show_object?$', show_object),
-    #(r'^/show_class/(.+)$', show_class),
     (r'^/show_class?$', show_class)
 )

plugins/webui/templates/admin/admin.html

 {% block title %}- Index{% endblock %}
 {% block body %}
 <h1>{{settings.sitename}} administration</h1>
-{{url('admin')}}
 <ul>
-    <li><a href="classes_admin">Edit object</a></li>
-    <li><a href="object_create">Create object</a></li>
+    <li><a href="admin/classes_admin">Edit object</a></li>
+    <li><a href="admin/object_create">Create object</a></li>
 </ul>
 
 {% endblock %}

plugins/webui/templates/admin/editable_component.html

         {% endif %}
         {% if field.directly_editable %}
             <input id="{{fieldname}}" name="field_input_{{fieldname}}" type="text" value="{{sval}}" >
-            {% set l_classe = field.allowed_classes %}
+            {% set l_classe = field.linked_classes %}
             <p> Please enter uids to instances of {{ l_classe.__name__ }} separated by commas </p>
         {% else %}
             <input id="{{fieldname}}" name="field_input_{{fieldname}}" type="text" value="{{sval}}" readonly >

plugins/webui/templates/base.html

     <meta charset="UTF-8" />
     <title>{% block title %}{% endblock %}</title>
     
-    <!-- Bootstrap -->
-    <link href="bootstrap/css/bootstrap.min.css" rel="stylesheet">
-    
+   <!-- Latest compiled and minified CSS -->
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+<!--{{url('/')}} -->
+<!-- Optional theme -->
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">
+    <link href="http://127.0.0.1/css/template.css" rel="stylesheet">
     {% block style %}{% endblock %}
     {% block scripts %}{% endblock %}
 </head>
 <body>
+        <!-- Fixed navbar -->
+    <nav class="navbar navbar-default navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+            <span class="sr-only">Toggle navigation</span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </button>
+          <a class="navbar-brand" href="#">Lodel 2</a>
+        </div>
+        <div id="navbar" class="navbar-collapse collapse">
+          <ul class="nav navbar-nav">
+            <li class="active"><a href="lodel_i/">Home</a></li>
+            <li><a href="list_classes">All types</a></li>
+          </ul>
+          <ul class="nav navbar-nav navbar-right">
+            <li><a href="admin">Back-end</a></li>
+              <li id="signin-nav"><a href="signin">Sign In</a></li>
+          </ul>
+        </div><!--/.nav-collapse -->
+      </div>
+    </nav>
     <div id="content">
         {% block content %}{% endblock %}
     </div>
     <script type="text/javascript">{% block javascript %}{% endblock %}</script>
+
     <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
     <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
     <!-- Include all compiled plugins (below), or include individual files as needed -->
-    <script src="bootstrap/js/bootstrap.min.js"></script>
+   <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
 </body>
 </html>

plugins/webui/templates/base_backend.html

 <head>
     <meta charset="UTF-8" />
     <title>{{ settings.sitename }} Admin{% block title %}{% endblock %}</title>
-    {% block style %}{% endblock %}
+     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">
+     <link href="http://127.0.0.1/css/template.css" rel="stylesheet">
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+    {% block style %}
+    {% endblock %}
     {% block scripts %}{% endblock %}
 </head>
 <body>
+           <!-- Fixed navbar -->
+    <nav class="navbar navbar-default navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+            <span class="sr-only">Toggle navigation</span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </button>
+          <a class="navbar-brand" href="#">Lodel 2 Administration</a>
+        </div>
+        <div id="navbar" class="navbar-collapse collapse">
+          <ul class="nav navbar-nav">
+            <li class="active"><a href="admin">Home</a></li>
+            <li><a href="admin/object_create">Create</a></li>
+            <li><a href="admin/classes_admin">Edit</a></li>
+          </ul>
+          <ul class="nav navbar-nav navbar-right">
+            <li><a href="/lodel_i/">Front-End</a></li>
+            <li id="signin-nav"><a href="signin">Sign In</a></li>
+          </ul>
+        </div><!--/.nav-collapse -->
+      </div>
+    </nav>
     {% block body %}{% endblock %}
     <script type="text/javascript">{% block javascript %}{% endblock %}</script>
+    <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
+    <!-- Include all compiled plugins (below), or include individual files as needed -->
+   <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
 </body>
 </html>

plugins/webui/templates/index/index.html

 {% extends "base.html" %}
 {% block title %}Lodel 2 - DASHBOARD{% endblock %}
 {% block content %}
-    DASHBOARD <br />
-    {{ lodel.Test().ok() }}
 <ul>
     <li><a href="list_classes">Tous les types</a></li>
 </ul>

settings.ini

-[lodel2]
-lib_path = /usr/lib/python/lodel2
-plugins_path = /usr/lib/python/lodel2/plugins, /usr/share/custom_lodel2/plugins

settings.py

-#-*- coding:utf8 -*-
-## @package settings Configuration file
-
-import os
-import os.path
-
-lodel2_lib_path = os.path.dirname(os.path.abspath(__file__))
-base_path = os.path.dirname(os.path.abspath(__file__))
-debug = False
-debug_sql = False
-
-plugins = ['dummy', 'dummy_auth']
-
-datasource = {
-    'default': {
-        'module':None,
-        'host': None,
-        'user': None,
-        'passwd': None,
-        'db': None,
-    }
-}
-
-migration_options = {
-    'dryrun': False,
-    'foreign_keys': True,
-    'drop_if_exists': False,
-}
-
-em_graph_format = 'png'
-em_graph_output = '/tmp/em_%s_graph.png'
-
-logging = {
-    'stderr': {
-        'level': 'INFO',
-        'context': False,
-    },
-    'logfile': {
-        'level': 'DEBUG',
-        'filename': '/tmp/lodel2.log',
-        'maxBytes': 1024 * 50, # rotate at 50MB
-        'backupCount': 10, # keep at most 10 backup
-        'context': True, # if false use a simpler format string
-    }
-}

tests/leapi/query/test_datasource.py

             [(('alias', {cls: 'firstname'}), '=', 'foo')])
         self.check_nocall(read = False, exclude = ['delete'])
         self.check_nocall(read = True)
-
+    
+    @unittest.skip("Waiting references checks stack implementation")
     def test_insert(self):
         """ Testing LeInsertQuery mocking datasource """
         cls = self.dyncode['Person']