Rework DELETE method of Custom Object

dimaspirit · web-flow · commit 3ba6269e3502 · 2018-02-05T13:06:51.000+02:00
Update eslint;
Add DELETE CO by criteria;
Normalize an answer on DELETE CO for any types;
diff --git a/.eslintrc b/.eslintrc
@@ -2,7 +2,9 @@
   "extends": "eslint:recommended",
   "env": {
     "browser": true,
-    "node": true
+    "node": true,
+    "es6": true,
+    "jasmine": true
   },
   "globals": {
     "QB": true,
@@ -19,4 +21,4 @@
     "no-mixed-spaces-and-tabs": 1,
     "no-extra-boolean-cast": 1
     }
-} 
+}
diff --git a/quickblox.min.js b/quickblox.min.js
diff --git a/spec/QB-DataSpec.js b/spec/QB-DataSpec.js
@@ -80,28 +80,99 @@ describe('Custom Objects API', function() {
                 }
             });
         }, REST_REQUESTS_TIMEOUT);
+    });
 
-        it('can delete custom object', function(done){
-            QB.data.create('cars', {make: 'BMW', model: 'M5', value: 100, damaged: true}, function(err, result) {
-                if (err) {
-                    done.fail('Create custom object error: ' + JSON.stringify(err));
-                } else {
-                    QB.data.delete('cars', result._id, function(err, res) {
-                        if (err) {
-                            done.fail("Create delete object error: " + JSON.stringify(err));
+    describe('Delete custom object', function() {
+        const className = 'cars';
+
+        function createCustomObject(className, params) {
+            const defaultCarParams = {
+                make: 'BMW',
+                model: 'M5',
+                value: 100,
+                damaged: true
+            };
+
+            const carParams = Object.assign(defaultCarParams, params);
+
+            return new Promise((resolve, reject) => {
+                QB.data.create(className, carParams, function(error, result) {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        resolve(result);
+                    }
+                });
+            });
+        }
+
+        it('by ID', function(done) {
+            createCustomObject(className, {}).then((car) => {
+                QB.data.delete(className, car._id, function(error, responce) {
+                    if (error) {
+                        done.fail("Create delete object error: " + JSON.stringify(error));
+                    } else {
+                        expect(responce).not.toBeNull();
+                        expect(responce.deleted[0]).toEqual(car._id);
+
+                        done();
+                    }
+                });
+            });
+        }, REST_REQUESTS_TIMEOUT);
+
+        it('by IDs', function(done) {
+            const promiseCreateCar1 = createCustomObject(className, {});
+            const promiseCreateCar2 = createCustomObject(className, {});
+            const promiseCreateCar3 = createCustomObject(className, {});
+
+            const promisesArray = [promiseCreateCar1, promiseCreateCar2, promiseCreateCar3];
+
+            Promise.all(promisesArray).then(function(cars) {
+                const ids = cars.map(car => car._id);
+
+                QB.data.delete(className, ids, function(error, res) {
+                    if (error) {
+                        done.fail("Create delete object error: " + JSON.stringify(error));
+                    } else {
+                        expect(res).not.toBeNull();
+                        // Need sort arrays before compare
+                        // cause jasmine to compare one by one item
+                        expect(res.deleted.sort()).toEqual(ids.sort());
+
+                        done();
+                    }
+                });
+            });
+        }, REST_REQUESTS_TIMEOUT * 3);
+
+        it('by criteria', function(done) {
+            const criteria = {
+                'value': {
+                    'gt': 100
+                }
+            };
+
+            const promiseCreateCar1 = createCustomObject(className, {value: 150});
+            const promiseCreateCar2 = createCustomObject(className, {value: 150});
+            const promiseCreateCar3 = createCustomObject(className, {value: 150});
+
+            Promise.all([promiseCreateCar1, promiseCreateCar2, promiseCreateCar3])
+                .then(function(cars) {
+                    QB.data.delete(className, criteria, function(error, res) {
+                        if (error) {
+                            done.fail("Create delete object error: " + JSON.stringify(error));
                         } else {
                             expect(res).not.toBeNull();
-                            expect(res).toBe(true);
+                            expect(res.deletedCount).toEqual(cars.length);
 
                             done();
                         }
                     });
-                }
-            });
-        }, REST_REQUESTS_TIMEOUT);
+                });
+        }, REST_REQUESTS_TIMEOUT * 3);
     });
 
-
     describe('Custom Objects with files', function() {
       var paramsFile,
           paramsFor;
@@ -204,9 +275,7 @@ describe('Custom Objects API', function() {
 
     });
 
-
     describe('Some more complex searching', function() {
-
         it('can find instances of cars with a value over 50 (value: 100)', function(done){
             var filter = {
                 'value': {
@@ -249,5 +318,4 @@ describe('Custom Objects API', function() {
             });
         }, REST_REQUESTS_TIMEOUT);
     });
-
 });
diff --git a/src/modules/qbData.js b/src/modules/qbData.js
@@ -1,49 +1,45 @@
 'use strict';
 
-/*
- * QuickBlox JavaScript SDK
- *
- * Custom Objects module
- *
- */
-
-var config = require('../qbConfig'),
-    Utils = require('../qbUtils');
-
-// For server-side applications through using npm package 'quickblox' you should include the following lines
-var isBrowser = typeof window !== 'undefined';
+const config = require('../qbConfig');
+const Utils = require('../qbUtils');
 
 /**
- * Custom Objects
+ * Custom Objects Module
  * @namespace QB.data
  **/
 function DataProxy(service){
     this.service = service;
 }
 
 DataProxy.prototype = {
-
     /**
      * Create new custom object ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Create_object read more})
+     * 
      * @memberof QB.data
+     * 
      * @param {string} className - A class name to which a new object belongs
      * @param {object} data - Object of parameters (custom fields' names and their values)
      * @param {createDataCallback} callback - The createDataCallback function
+     * 
      * @example
-     * QB.data.create('GameOfThrones', {
+     * const data = {
      *     'name': 'John',
      *     'age':'20',
      *     'family': [
      *         'Stark',
      *         'Targaryen'
      *     ]
-     * }, function(error, response) {
+     * };
+     * 
+     * function createdDataCallback(error, response) {
      *     if (error) {
      *         console.log(error);
      *     } else {
      *         console.log(response);
      *     }
-     * });
+     * }
+     * 
+     * QB.data.create('GameOfThrones', data, createdDataCallback);
      */
     create: function(className, data, callback) {
         /**
@@ -71,7 +67,9 @@ DataProxy.prototype = {
 
     /**
      * Search for records of particular class ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Retrieve_objects read more})
+     * 
      * @memberof QB.data
+     * 
      * @param {string} className - A class name to which a new record belongs
      * @param {(object|string[])} filters - Search records with field which contains exactly specified value or by array of records' ids to retrieve
      * @param {number} [filters.skip=0] - Skip N records in search results. Useful for pagination. Default (if not specified) - 0
@@ -122,7 +120,7 @@ DataProxy.prototype = {
     },
 
     /**
-     * Update record by ID of particular class ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Retrieve_objects read more})
+     * Update record by ID of particular class. ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Retrieve_objects Read more})
      * @memberof QB.data
      * @param {string} className - A class name of record
      * @param {object} data - Object of parameters
@@ -165,27 +163,114 @@ DataProxy.prototype = {
     },
 
     /**
-     * Delete record by ID ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Delete_objects_by_IDs or records by ids}) of particular class ({@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Delete_object read more})
+     * Delete record / records by ID, IDs or criteria (filters) of particular class. <br />
+     * Check out {@link https://docsdev.quickblox.com/rest_api/CustomObjects_API.html#Delete_object official documentaion} to get detailed information.
+     * 
      * @memberof QB.data
-     * @param {string} className - A class name of record (records)
-     * @param {(string|array)} id - An ID of record (or an array of records' ids) to delete
-     * @param {deleteDataByIdsCallback} callback - The deleteDataByIdsCallback function
+     * 
+     * @param {string} className - A class name of record
+     * @param {(string|array|object)} requestedData - An ID of record or an array of record's ids or object of criteria rules to delete
+     * @param {deletedDataCallback} callback - The deletedDataCallback function
+     * 
+     * @example
+     * const className = 'Movie';
+     * 
+     * function deletedMovie(error, responce) {
+     *   if(error) {
+     *     throw new Error(error.toString());
+     *   } else {
+     *     console.log(`Deleted movies with ids: ${responce.deleted.toString()}`);
+     *   }
+     * }
+     * 
+     * // By ID, must be string
+     * const id = '502f7c4036c9ae2163000002';
+     * QB.data.delete(className, id, deletedMovie);
+     * 
+     * // By IDs, must be array
+     * const ids = ['502f7c4036c9ae2163000002', '502f7c4036c9ae2163000003'];
+     * QB.data.delete(className, ids, deletedMovie);
+     * 
+     * const criteria = { 'price': { 'gt': 100 };
+     * function deletedMoviesByCriteria(error, responce) {
+     *   if(error) {
+     *      throw new Error(error.toString());
+     *   } else {
+     *      // Note! Deleted by creteria doesn't return ids of deleted objects
+     *      console.log(`Deleted ${responce.deletedCount} movies`);
+     *   }
+     * }
+     * QB.data.delete(className, criteria, deletedMoviesByCriteria);
+     * 
+     * 
      */
-    delete: function(className, id, callback) {
+    delete: function(className, requestedData, callback) {
         /**
-         * Callback for QB.data.delete(className, id, callback)
-         * @callback deleteDataByIdsCallback
+         * Callback for QB.data.delete(className, requestedData, callback)
+         * @callback deletedDataCallback
          * @param {object} error - The error object
-         * @param {object} response - Empty body
+         * @param {object|null} response
+         * @param {array} response.deleted - Array of ids of deleted records. If you delete BY CRITERIA this property will be null.
+         * @param {number} response.deletedCount - count of deleted records.
          */
-        this.service.ajax({url: Utils.getUrl(config.urls.data, className + '/' + id), type: 'DELETE', dataType: 'text'},
-            function(err, result) {
-                if (err) {
-                    callback(err, null);
-                } else {
-                    callback (err, true);
+        const typesData = {
+            id: 1,
+            ids: 2,
+            criteria: 3
+        };
+
+        let requestedTypeOf;
+
+        const responceNormalized = {
+            deleted: [],
+            deletedCount: 0
+        };
+
+        const ajaxParams = {
+            type: 'DELETE',
+            dataType: 'text'
+        };
+
+        /** Define what type of data passed by client */
+        if(typeof requestedData === 'string') {
+            requestedTypeOf = typesData.id;
+        } else if(Utils.isArray(requestedData)) {
+            requestedTypeOf = typesData.ids;
+        } else if(Utils.isObject(requestedData)) {
+            requestedTypeOf = typesData.criteria;
+        }
+
+        if(requestedTypeOf === typesData.id) {
+            ajaxParams.url = Utils.getUrl(config.urls.data, className + '/' + requestedData);
+        } else if(requestedTypeOf === typesData.ids) {
+            ajaxParams.url = Utils.getUrl(config.urls.data, className + '/' + requestedData.toString());
+        } else if(requestedTypeOf === typesData.criteria) {
+            ajaxParams.url = Utils.getUrl(config.urls.data, className + '/by_criteria');
+            ajaxParams.data = requestedData;
+        }
+
+        function handleDeleteCO(error, result) {
+            if (error) {
+                callback(error, null);
+            } else {
+                if(requestedTypeOf === typesData.id) {
+                    responceNormalized.deleted.push(requestedData);
+                    responceNormalized.deletedCount = responceNormalized.deleted.length;
+                } else if(requestedTypeOf === typesData.ids) {
+                    const response = JSON.parse(result);
+                    responceNormalized.deleted = response.SuccessfullyDeleted.ids.slice(0);
+                    responceNormalized.deletedCount = responceNormalized.deleted.length;
+                } else if(requestedTypeOf === typesData.criteria) {
+                    const response = JSON.parse(result);
+                    responceNormalized.deleted = null;
+                    responceNormalized.deletedCount = response.total_deleted;
                 }
-            });
+
+                callback (error, responceNormalized);
+            }
+        }
+
+        this.service.ajax(ajaxParams, handleDeleteCO);
     },
 
     /**
