assignRole response value must be void (#28)

* fix (users) assignRole and unassignRole must be void in async

- fix (ajax) empty string in async callback if server response has no body in node env. Must be undefined

* fixed typescript definition according to change

Author: vengrov

libs/backendless.d.ts

@@ -773,11 +773,11 @@ declare module __Backendless {
         restorePassword(email:string):Backendless.User ;
         restorePassword(email:string, async:Backendless.Async):XMLHttpRequest;
 
-        assignRole(userName:string, roleName:string):Backendless.User ;
-        assignRole(userName:string, roleName:string, async:Backendless.Async):XMLHttpRequest;
+        assignRole(identity:string, roleName:string):Backendless.User ;
+        assignRole(identity:string, roleName:string, async:Backendless.Async):XMLHttpRequest;
 
-        unassignRole(userName:string, roleName:string):Backendless.User ;
-        unassignRole(userName:string, roleName:string, async:Backendless.Async):XMLHttpRequest;
+        unassignRole(identity:string, roleName:string):Backendless.User ;
+        unassignRole(identity:string, roleName:string, async:Backendless.Async):XMLHttpRequest;
 
         login(userName:string, password:string):Backendless.User ;
         login(userName:string, password:string, stayLoggedIn:boolean):Backendless.User ;

libs/backendless.js

@@ -409,8 +409,6 @@
             }
         };
 
-        var buffer = '';
-
         if (currentUser != null && !!currentUser["user-token"]) {
             options.headers["user-token"] = currentUser["user-token"];
         }
@@ -419,23 +417,23 @@
             throw new Error('Use Async type of request using Backendless with NodeJS. Add Backendless.Async(successCallback, errorCallback) as last argument');
         }
 
+        var buffer;
         var httpx = require(https ? 'https' : 'http');
-
         var req = httpx.request(options, function(res) {
             res.setEncoding('utf8');
             res.on('data', function(chunk) {
-                buffer += chunk;
+                buffer = buffer ? buffer + chunk : chunk;
             });
             res.on('end', function() {
-                var contentType = res.headers['content-type'];
-
-                if (contentType && contentType.indexOf('application/json') !== -1) {
-                    buffer = tryParseJSON(buffer);
-                }
-
                 var callback = config.asyncHandler[res.statusCode >= 200 && res.statusCode < 300 ? "success" : "fault"];
 
                 if (Utils.isFunction(callback)) {
+                    var contentType = res.headers['content-type'];
+
+                    if (buffer !== undefined && contentType && contentType.indexOf('application/json') !== -1) {
+                        buffer = tryParseJSON(buffer);
+                    }
+
                     callback(buffer);
                 }
             });
@@ -1499,42 +1497,32 @@
             return isAsync ? result : this._parseResponse(result);
         },
 
-        roleHelper: function(username, rolename, async, operation) {
-            if (!username) {
-                throw new Error('Username can not be empty');
+        roleHelper: function(identity, rolename, async, operation) {
+            if (!identity) {
+                throw new Error('User identity can not be empty');
             }
 
             if (!rolename) {
                 throw new Error('Rolename can not be empty');
             }
 
             var responder = extractResponder(arguments);
-            var isAsync = responder != null;
-
-            if (responder) {
-                responder = this._wrapAsync(responder);
-            }
-
-            var data = {
-                user    : username,
-                roleName: rolename
-            };
 
             return Backendless._ajax({
                 method      : 'POST',
                 url         : this.restUrl + '/' + operation,
-                isAsync     : isAsync,
+                isAsync     : !!responder,
                 asyncHandler: responder,
-                data        : JSON.stringify(data)
+                data        : JSON.stringify({user : identity, roleName: rolename})
             });
         },
 
-        assignRole: function(username, rolename, async) {
-            return this.roleHelper(username, rolename, async, 'assignRole');
+        assignRole: function(identity, rolename, async) {
+            return this.roleHelper(identity, rolename, async, 'assignRole');
         },
 
-        unassignRole: function(username, rolename, async) {
-            return this.roleHelper(username, rolename, async, 'unassignRole');
+        unassignRole: function(identity, rolename, async) {
+            return this.roleHelper(identity, rolename, async, 'unassignRole');
         },
 
         login: function(username, password, stayLoggedIn, async) {

tests/tsd.ts

@@ -303,6 +303,7 @@ function testUser() {
 
 function testUserService() {
     var userName:string = 'userName';
+    var identity:string = 'identity';
     var roleName:string = 'rolename';
     var password:string = 'password';
     var div:HTMLElement = document.createElement('div');
@@ -326,11 +327,11 @@ function testUserService() {
     newUser = Backendless.UserService.getUserRoles();
     resultXHR = Backendless.UserService.getUserRoles(async);
 
-    newUser = Backendless.UserService.assignRole(userName, roleName);
-    resultXHR = Backendless.UserService.assignRole(userName, roleName, async);
+    newUser = Backendless.UserService.assignRole(identity, roleName);
+    resultXHR = Backendless.UserService.assignRole(identity, roleName, async);
 
-    newUser = Backendless.UserService.unassignRole(userName, roleName);
-    resultXHR = Backendless.UserService.unassignRole(userName, roleName, async);
+    newUser = Backendless.UserService.unassignRole(identity, roleName);
+    resultXHR = Backendless.UserService.unassignRole(identity, roleName, async);
 
     newUser = Backendless.UserService.login(userName, password);
     newUser = Backendless.UserService.login(userName, password, bol);