Implements delete in leapidatasource for leobjects and lerelations

DataSource/MySQL/leapidatasource.py

@@ -192,45 +192,19 @@ class LeDataSourceSQL(DummyDatasource):
 
     ## @brief delete lodel editorial components given filters
     # @param target_cls LeCrud(class): The component class concerned by the delete (a LeCrud child class (not instance !) )
-    # @param filters list : List of filters (see @ref leobject_filters)
-    # @param rel_filters list : List of relational filters (see @ref leobject_filters)
+    # @param uid int : A uniq ID to identify the object we want to delete
     # @return the number of deleted components
-    def delete(self, target_cls, filters, rel_filters):
-        query_table_name = self.datasource_utils.get_table_name_from_class(target_cls.__name__)
-        prep_filters = self._prepare_filters(filters, query_table_name)
-        prep_rel_filters = self._prepare_rel_filters(rel_filters)
-
-        if len(prep_rel_filters) > 0:
-            query = "DELETE %s FROM" % query_table_name
-            for prep_rel_filter in prep_rel_filters:
-                query += "%s INNER JOIN %s ON (%s.%s = %s.%s)" % (
-                    self.datasource_utils.relations_table_name,
-                    query_table_name,
-                    self.datasource_utils.relations_table_name,
-                    prep_rel_filter['position'],
-                    query_table_name,
-                    self.datasource_utils.field_lodel_id
-                )
-
-                if prep_rel_filter['condition_key'][0] is not None:
-                    prep_filters[("%s.%s" % (self.datasource_utils.relations_table_name, prep_rel_filter['condition_key'][0]), prep_rel_filter['condition_key'][1])] = prep_rel_filter['condition_value']
-
-            if prep_filters is not None and len(prep_filters) > 0:
-                query += " WHERE "
-                filter_counter = 0
-                for filter_item in prep_filters:
-                    if filter_counter > 1:
-                        query += " AND "
-                    query += "%s %s %s" % (filter_item[0][0], filter_item[0][1], filter_item[1])
+    def delete(self, target_cls, uid):
+        if target_cls.implements_leobject():
+            tablename = utils.common_tables['object']
+        elif target_cls.implements_lerelation():
+            tablename = utils.common_tables['relation']
         else:
-            query = delete(query_table_name, prep_filters)
-
-        query_delete_from_object = delete(self.datasource_utils.objects_table_name, {'lodel_id': filters['lodel_id']})
-        with self.connection as cur:
-            result = cur.execute(query)
-            cur.execute(query_delete_from_object)
-
-        return result
+            raise AttributeError("'%s' is not a LeObject nor a LeRelation, it's not possible to delete it")
+        uidname = target_cls.uidname()
+        sql = delete(tablename, ((uidname, uid),))
+        utils.query(self.connection, sql) #No way to check the result ?
+        return True
 
     ## @brief update ONE existing lodel editorial component
     # @param target_cls LeCrud(class) : Instance of the object concerned by the update

DataSource/dummy/leapidatasource.py

@@ -25,10 +25,9 @@ class DummyDatasource(object):
 
     ## @brief delete lodel editorial components given filters
     # @param target_cls LeCrud(class) : The component class concerned by the insert (a LeCrud child class (not instance !) )
-    # @param filters list : List of filters (see @ref leobject_filters )
-    # @param rel_filters list : List of relationnal filters (see @ref leobject_filters )
+    # @param leo_id int : The component ID (lodel_id or relation_id)
     # @return the number of deleted components
-    def delete(self, target_cls, filters, rel_filters):
+    def delete(self, target_cls, leo_id):
         pass
 
     ## @brief update an existing lodel editorial component

leapi/lecrud.py

@@ -289,17 +289,11 @@ class _LeCrud(object):
             #ERROR HANDLING
             return False
     
-    ## @brief Delete a component (instance method)
+    ## @brief Delete a component
     # @return True if success
     # @todo better error handling
-    def _delete(self):
-        filters = [self._id_filter()]
-        ret = _LeCrud.delete(self.__class__, filters)
-        if ret == 1:
-            return True
-        else:
-            #ERROR HANDLING
-            return False
+    def delete(self):
+        self._datasource.delete(self.__class__, self.uidget())
 
     ## @brief Check that datas are valid for this type
     # @param datas dict : key == field name value are field values
@@ -345,14 +339,6 @@ class _LeCrud(object):
             raise LeApiDataCheckError("Error while checking datas", err_l)
         return checked_datas
     
-    ## @brief Given filters delete editorial components
-    # @param filters list : 
-    # @return The number of deleted components
-    @staticmethod
-    def delete(cls, filters):
-        filters, rel_filters = cls._prepare_filters(filters)
-        return cls._datasource.delete(cls, filters, rel_filters)
-
     ## @brief Retrieve a collection of lodel editorial components
     #
     # @param query_filters list : list of string of query filters (or tuple (FIELD, OPERATOR, VALUE) ) see @ref leobject_filters

leapi/leobject.py

@@ -96,19 +96,6 @@ class _LeObject(_LeCrud):
             return ('class_id', '=', cls._class_id)
         else:
             raise ValueError("Cannot generate a typefilter with %s class"%cls.__name__)
-    
-    ## @brief Delete LeObjects from db given filters and a classname
-    # @note if no classname given, take the caller class
-    # @param filters list : 
-    # @param classname None|str : the classname or None
-    # @return number of deleted LeObjects
-    # @see leapi.lecrud._LeCrud.delete()
-    @classmethod
-    def delete(cls, filters, classname = None):
-        ccls = cls if classname is None else cls.name2class(classname)
-        new_filters = copy.copy(filters)
-        new_filters.append(ccls.typefilter())
-        return _LeCrud.delete(ccls, new_filters)
 
     ## @brief Check that a relational field is valid
     # @param field str : a relational field

leapi/lerelation.py

@@ -72,18 +72,6 @@ class _LeRelation(lecrud._LeCrud):
             res_filters.append( (field, op, value) )
         return res_filters, rel_filters
 
-    @classmethod
-    ## @brief deletes a relation between two objects
-    # @param filters_list list
-    # @param target_class str
-    def delete(cls, filters_list, target_class):
-        filters, rel_filters = cls._prepare_filters(filters_list)
-        if isinstance(target_class, str):
-            target_class = cls.name2class(target_class)
-
-        ret = cls._datasource.delete(target_class, filters)
-        return True if ret == 1 else False
-
     ## @brief move to the first rank
     # @return True in case of success, False in case of failure
     def move_first(self):
@@ -143,10 +131,6 @@ class _LeRelation(lecrud._LeCrud):
 ## @brief Abstract class to handle hierarchy relations
 class _LeHierarch(_LeRelation):
     
-    ## @brief Delete current instance from DB
-    def delete(self):
-        lecrud._LeCrud._delete(self)
-    
     ## @brief modify a LeHierarch rank
     # @param new_rank int|str : The new rank can be an integer > 1 or strings 'first' or 'last'
     # @return True in case of success, False in case of failure
@@ -205,10 +189,6 @@ class _LeRel2Type(_LeRelation):
     ## @brief Stores the relation name for a rel2type
     _relation_name = None
 
-    ## @brief Delete current instance from DB
-    def delete(self):
-        lecrud._LeCrud._delete(self)
-    
     ## @brief modify a LeRel2Type rank
     # @param new_rank int|str : The new rank can be an integer > 1 or strings 'first' or 'last'
     # @return True in case of success, False in case of failure

leapi/letype.py

@@ -68,10 +68,6 @@ class _LeType(_LeClass):
         self.populate()
         return self.datas()
     
-    ## @brief Delete current instance from DB
-    def delete(self):
-        _LeCrud._delete(self)
-    
     ## @brief Add a superior
     # @param lesup LeObject : LeObject child class instance
     # @param nature str : Relation nature

leapi/test/test_leobject.py

@@ -159,32 +159,17 @@ class LeObjectMockDatasourceTestCase(TestCase):
     
     @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
     def test_delete(self, dsmock):
-        from dyncode import Publication, Numero, LeObject, LeType
-
+        from dyncode import Publication, Numero, LeObject, LeType, LeRelation
+        
         args = [
-            (
-                'Numero',
-                ['lodel_id=1'],
-                [('lodel_id', '=', '1'), ('type_id', '=', Numero._type_id)],
-                []
-            ),
-            (
-                'Publication',
-                ['subordinate.parent not in [1,2,3]', 'titre = "titre nul"'],
-                [('titre','=', '"titre nul"'), ('class_id', '=', Publication._class_id)],
-                [( (leapi.leobject.REL_SUB, 'parent'), ' not in ', '[1,2,3]')]
-            ),
+            Publication(1),
+            Numero(5),
+            LeObject(51),
+            LeRelation(1337),
         ]
 
-        for classname, filters, ds_filters, ds_relfilters in args:
-            ccls = LeObject.name2class(classname)
-
-            LeObject.delete(filters, classname)
-            dsmock.assert_called_once_with(ccls, ds_filters, ds_relfilters)
+        for instance in args:
+            instance.delete()
+            dsmock.assert_called_once_with(instance.__class__, instance.uidget())
             dsmock.reset_mock()
             
-            if not (LeType in ccls.__bases__): #tests for calls with a LeClass child
-                ccls.delete(filters)
-                dsmock.assert_called_once_with(ccls, ds_filters, ds_relfilters)
-                dsmock.reset_mock()
-        

leapi/test/test_lerelation.py

@@ -74,8 +74,8 @@ class LeRelationTestCase(TestCase):
         """ Testing LeHierarch insert method """
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
         
-        LeRelation.delete([LeRelation.sup_filter(Numero(42)), 'nature = "parent"'], 'LeHierarch')
-        dsmock.assert_called_once_with(LeHierarch, [('superior', '=', Numero(42)), ('nature','=','"parent"')])
+        LeHierarch(42).delete()
+        dsmock.assert_called_once_with(LeHierarch, 42)
         dsmock.reset_mock()
 
 
@@ -200,7 +200,7 @@ class LeHierarch(LeRelationTestCase):
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
         rel = LeHierarch(10)
         rel.delete()
-        dsmock.assert_called_once_with(LeHierarch, [(LeHierarch.uidname(), '=', 10)], [])
+        dsmock.assert_called_once_with(LeHierarch, 10)
         
     
     @unittest.skip("Wait for LeRelation.update() to unskip")

leapi/test/test_letype.py

@@ -129,5 +129,5 @@ class LeTypeMockDsTestCase(TestCase):
         
         num = Numero(lodel_id = 1)
         num.delete()
-        dsmock.assert_called_once_with(Numero, [('lodel_id','=',1)], [])
+        dsmock.assert_called_once_with(Numero, 1)