Bugfixes on back reference handling for singleRef solves #154

lodel/leapi/datahandlers/base_classes.py

 class SingleRef(Reference):
     
     def __init__(self, allowed_classes = None, **kwargs):
-        super().__init__(allowed_classes = allowed_classes)
+        super().__init__(allowed_classes = allowed_classes, **kwargs)
  
     ##@brief Check and cast value in appropriate type
     #@param value: *
         #    raise FieldValidationError("List or string expected for a set field")
         return value
 
-
-
 ##@brief This class represent a data_handler for multiple references to another object
 #@ingroup lodel2_datahandlers
 #
         if len(error_list) > 0:
             raise FieldValidationError("MultipleRef have for invalid values [%s]  :" % (",".join(error_list)))
         return new_val
-    
-    ##@brief Construct a multiple ref data
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        cur_value = super().construct_data(emcomponent, fname, datas, cur_value)
-        if cur_value is not None:
-            if self.back_reference is not None:
-                br_class = self.back_reference[0]
-                for br_id in cur_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_reference[1])
-                        if br_list is None:
-                            br_list = list()
-                        if br_id not in br_list:
-                            br_list.append(br_id)
-        return cur_value
-    
-    ## @brief Checks the backreference, updates it if it is not complete
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname : the field name
-    # @param datas dict : dict storing fields values
-    # @note Not done in case of delete
-    def make_consistency(self, emcomponent, fname, datas, type_query):
 
-        dh = emcomponent.field(fname)
 
-        logger.info('Warning : multiple uid capabilities are broken here')
-        uid = datas[emcomponent.uid_fieldname()[0]]
-        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]
-
-            if l_value is not None:
-                for value in l_value:
-                    query_filters = list()
-                    query_filters.append((target_uidfield , '=', value))
-                    obj = target_class.get(query_filters)
-                    if len(obj) == 0:
-                        logger.warning('Object referenced does not exist')
-                        return False
-                    l_uids_ref = obj[0].data(target_field)
-                    if l_uids_ref is None:
-                        l_uids_ref = list()
-                    if uid not in l_uids_ref:
-                        l_uids_ref.append(uid)
-                        obj[0].set_data(target_field, l_uids_ref)
-                        obj[0].update()
-           
-            if type_query == 'update':
-                query_filters = list()
-                query_filters.append((uid, ' in ', target_field))
-                objects = target_class.get(query_filters)
-                if l_value is None:
-                    l_value = list()
-                if len(objects) != len(l_value):
-                    for obj in objects:
-                        l_uids_ref = obj.data(target_field)
-                        if obj.data(target_uidfield) not in l_value:
-                            l_uids_ref.remove(uid)
-                            obj.set_data(target_field, l_uids_ref)
-                            obj.update()
-
-                
 ## @brief Class designed to handle datas access will fieldtypes are constructing datas
 #@ingroup lodel2_datahandlers
 #

plugins/mongodb_datasource/datasource.py

     def select(self, target, field_list, filters = None, 
             relational_filters=None, order=None, group=None, limit=None, 
             offset=0):
-        logger.debug("Select %s on %s filtered by %s and %s " % (
-            field_list, target, filters, relational_filters))
         if target.is_abstract():
             #Reccursiv calls for abstract LeObject child
             results =  self.__act_on_abstract(target, filters,
     #@return int : Number of updated records
     def update(self, target, filters, relational_filters, upd_datas):
         self._data_cast(upd_datas)
+        #fetching current datas state
+        mongo_filters = self.__process_filters(
+            target, filters, relational_filters)
+        old_datas_l = self.__collection(target).find(
+            mongo_filters)
+        old_datas_l = list(old_datas_l)
+        #Running update
         res = self.__update_no_backref(target, filters, relational_filters,
             upd_datas)
+        #updating backref
         self.__update_backref_filtered(target, filters, relational_filters,
-            upd_datas)
+            upd_datas, old_datas_l)
         return res
     
     ##@brief Designed to be called by backref update in order to avoid
         #Non abstract beahavior
         mongo_filters = self.__process_filters(
             target, filters, relational_filters)
+        self._data_cast(upd_datas)
         mongo_arg = {'$set': upd_datas }
         res = self.__collection(target).update(mongo_filters, mongo_arg)
         return res['n']
     #@param filters
     #@param relational_filters,
     #@param new_datas None | dict : optional new datas if None mean we are deleting
+    #@param old_datas_l None | list : if None fetch old datas from db (usefull
+    #when modifications are made on instance before updating backrefs)
     #@return nothing (for the moment
     def __update_backref_filtered(self, target,
-            filters, relational_filters, new_datas = None):
+            filters, relational_filters, new_datas = None, old_datas_l = None):
         #Getting all the UID of the object that will be deleted in order
         #to update back_references
-        mongo_filters = self.__process_filters(
-            target, filters, relational_filters)
-        old_datas_l = self.__collection(target).find(
-            mongo_filters)
-        old_datas_l = list(old_datas_l)
+        if old_datas_l is None:
+            mongo_filters = self.__process_filters(
+                target, filters, relational_filters)
+            old_datas_l = self.__collection(target).find(
+                mongo_filters)
+            old_datas_l = list(old_datas_l)
+            
         uidname = target.uid_fieldname()[0] #MULTIPLE UID BROKEN HERE
         for old_datas in old_datas_l:
             self.__update_backref(
         upd_dict = {}
         for fname, fdh in target.reference_handlers().items():
             oldd = old_datas is not None and fname in old_datas and \
-                hasattr(fdh, 'default') and old_datas[fname] != fdh.default
+                (not hasattr(fdh, 'default') or old_datas[fname] != fdh.default) \
+                and not old_datas[fname] is None
             newd = new_datas is not None and fname in new_datas and \
-                hasattr(fdh, 'default') and new_datas[fname] != fdh.default
+                (not hasattr(fdh, 'default') or new_datas[fname] != fdh.default) \
+                and not new_datas[fname] is None
             if (oldd and newd and old_datas[fname] == new_datas[fname])\
                     or not(oldd or newd):
                 #No changes or not concerned
                 #value
                 vdict = {}
                 if oldd:
-                    vdict['old'] = new_datas[fname]
+                    vdict['old'] = old_datas[fname]
                     uid_val = vdict['old']
                 if newd:
                     vdict['new'] = new_datas[fname]
                     upd_dict, bref_infos, bref_fname, uid_val)
                 #forging update bref_infos
                 bref_cls, bref_leo, bref_dh, bref_value = bref_infos
-                bref_infos = tuple(bref_cls, bref_leo, bref_dh,
+                bref_infos = (bref_cls, bref_leo, bref_dh,
                         upd_dict[bref_cls][uid_val][1][bref_fname])
                 #fetche and store updated value
                 new_bref_val = self.__back_ref_upd_one_value(
-                    fname, fdh, tuid, **vdict)
+                    fname, fdh, tuid, bref_infos, **vdict)
                 upd_dict[bref_cls][uid_val][1][bref_fname] = new_bref_val
         #Now we've got our upd_dict ready.
         #running the updates
                     raise MongoDbConsistencyError("The value we want to \
 delete in this back reference update was not found in the back referenced \
 object : %s. Value was : '%s'" % (bref_leo, tuid))
+                if isinstance(bref_val, tuple):
+                    bref_val = set(bref_val)
                 if isinstance(bref_val, set):
                     bref_val -= set([tuid])
                 else:
                     raise MongoDbConsistencyError("The value we want to \
 add in this back reference update was found in the back referenced \
 object : %s. Value was : '%s'" % (bref_leo, tuid))
+                if isinstance(bref_val, tuple):
+                    bref_val = set(bref_val)
                 if isinstance(bref_val, set):
                     bref_val |= set([tuid])
                 else:
                 if not hasattr(bref_dh, "default"): 
                     raise MongoDbConsistencyError("Unable to delete a \
 value for a back reference update. The concerned field don't have a default \
-value : in %s field %s" % (bref_leo, bref_fname))
+value : in %s field %s" % (bref_leo,fname))
                 bref_val = getattr(bref_dh, "default")
             elif not oldd and newdd:
                 bref_val = tuid

plugins/webui/interface/controllers/admin.py

                     value=[spl for spl in [
                            v.strip() for v in value.split(LIST_SEPARATOR)]
                         if len(spl) > 0]
+                elif len(value.strip()) == 0:
+                    value = None
                 try:
                     leo_to_update.set_data(fieldname, value)
                 except Exception as e:
                     fname, error)
             custom_msg += '</ul>'
             raise HttpException(400, custom = custom_msg)
-        try:
-            leo_to_update.update()
-        except Exception as e:
-            raise HttpException(
-                500, custom = "Something goes wrong during update : %s" % e)
+        leo_to_update.update()
 
     # Display of the form with the object's values to be updated
     if 'classname' in request.GET: