Added main functianality to build request url and make a call. Added unit tests.

Author: Hamlet Hakobyan

src/ApiServiceProvider.js

@@ -13,6 +13,9 @@ function streamApiServiceFactory($http, $q) {
         factory = {},
         _instance;
 
+    Api.prototype.http = $http;
+    Api.prototype.promise = $q;
+    
     factory.getInstance = function(config, returnNewInstance) {
         if(returnNewInstance) {
             return new Api(config);

src/service/Api.js

@@ -30,12 +30,15 @@ function Api(config) {
         }
     }
 
-    this.config = {
-        url: parsedUrl.protocol + '//' + parsedUrl.host + path
-    };
-    
-    this.Constants = require('./ApiConstants');
-    this.Methods = require('./ApiMethods');
+    this.baseUrl = parsedUrl.protocol + '//' + parsedUrl.host + path;
 }
 
+Api.prototype.Constants = require('./ApiConstants');
+Api.prototype.Methods = require('./ApiMethods');
+
+require('./request')(Api);
+require('./get')(Api);
+require('./copy')(Api);
+require('./count')(Api);
+
 module.exports = Api;

src/service/ApiServiceFactory.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function(Api) {
+    Api.prototype.copy = function (objCode, objID, updates, fields) {
+        var params = {
+            copySourceID: objID
+        };
+        
+        return this.request(objCode, updates, params, fields, this.Methods.POST);
+    };
+};

src/service/copy.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function(Api) {
+    Api.prototype.count = function(objCode, query) {
+        var path = objCode + '/count';
+        return this.request(path, null, query, null, this.Methods.GET)
+        .then(function(response) {
+            return response.data.count;
+        });
+    };
+};

src/service/count.js

@@ -0,0 +1,18 @@
+'use strict';
+
+module.exports = function(Api) {
+    Api.prototype.get = function(objCode, IDs, fields) {
+        var params;
+        if(typeof IDs === 'string') {
+            IDs = [IDs];
+        }
+
+        if(IDs.length !== 0) {
+            params = {
+                ID: IDs
+            };
+        }
+
+        return this.request(objCode, null, params, fields, this.Methods.GET);
+    };
+};

src/service/get.js

@@ -1,7 +1,41 @@
 'use strict';
 
+var angular = require('angular');
+
 module.exports = function(Api) {
-    Api.prototype.request = function(path, params, fields, method) {
+    Api.prototype.request = function(path, data, params, fields, method) {
+        this.config = {};
+        this.config.url = this.baseUrl;
+        path = path.indexOf('/') === 0 ? path : '/' + path;
+        this.config.url = this.config.url + path;
+
+        fields = fields || [];
+        if(typeof fields === 'string') {
+            fields = [fields];
+        }
+
+        this.config.method = method;
+        if(method === this.Methods.POST || method === this.Methods.PUT) {
+            if(!data) {
+                throw new Error('You must specify \'data\' in case you have used PUT or POST');
+            }
+
+            this.config.data = data;
+            this.config.headers = {};
+            this.config.headers['Content-Type'] = 'application/json;charset=utf-8';
+        } else {
+            if(data) {
+                throw new Error('You must specify method PUT or POST in case have passed \'data\'');
+            }
+        }
+
+        params = params || {};
+        if(fields.length !== 0) {
+            params.fields = fields.join();
+        }
+
+        this.config.params = params;
 
+        return this.http(this.config);
     };
 };

src/service/request.js

@@ -55,25 +55,39 @@ describe('Api', function() {
 
     it('should set it\'s config.url correctly when passed correct url and not passed version', function() {
         var api = streamApiService.getInstance({url: 'https://foo'});
-        expect(api.config.url)
+        expect(api.baseUrl)
             .toBe('https://foo/attask/api');
     });
 
     it('should set it\'s config.url  when passed valid url and version unsupported', function() {
         var api = streamApiService.getInstance({url: 'https://foo', version: 'unsupported'});
-        expect(api.config.url)
+        expect(api.baseUrl)
             .toBe('https://foo/attask/api-unsupported');
     });
 
     it('should set it\'s config.url  when passed valid url and version internal', function() {
         var api = streamApiService.getInstance({url: 'https://foo', version: 'internal'});
-        expect(api.config.url)
+        expect(api.baseUrl)
             .toBe('https://foo/attask/api-internal');
     });
 
     it('should set it\'s config.url  when passed valid url and version number', function() {
         var api = streamApiService.getInstance({url: 'https://foo', version: '5.0'});
-        expect(api.config.url)
+        expect(api.baseUrl)
             .toBe('https://foo/attask/api/v5.0');
     });
+    
+    it('should return the same object on each getInstance regardless of passed config and version', function() {
+        var api1 = streamApiService.getInstance({url: 'https://foo', version: '5.0'});
+        var api2 = streamApiService.getInstance({url: 'https://bar', version: '4.0'});
+        expect(api1).toBe(api2);
+    });
+    
+    it('should return new Api object when requested new', function() {
+        var api1 = streamApiService.getInstance({url: 'https://foo', version: '5.0'});
+        var api2 = streamApiService.getInstance({url: 'https://bar', version: '4.0'}, true);
+        expect(api1).not.toBe(api2);
+    });
+    
+    
 });

src/spec/Api.spec.js

@@ -0,0 +1,40 @@
+/* eslint-env jasmine */
+
+'use strict';
+
+var angular = require('angular');
+
+describe('get', function() {
+    beforeEach(function() {
+        var ngModule = angular.module('mockModule', []);
+        require('./../ApiServiceProvider')(ngModule);
+    });
+
+    beforeEach(angular.mock.module('mockModule'));
+    
+    var streamApiService,
+        $httpBackend;
+    beforeEach(angular.mock.inject(function(_streamApiService_, _$httpBackend_) {
+        streamApiService = _streamApiService_;
+        $httpBackend = _$httpBackend_;
+    }));
+    
+    var streamApi;
+    beforeEach(function() {
+        streamApi = streamApiService.getInstance({url: 'https://foo'});
+    });
+
+    it('should make call to requested object', function() {
+        var requestedUrl = 'https://foo/attask/api/task?copySourceID=12345678&fields=*';
+        var headerData = function(headers) {
+            return headers['Content-Type'] === 'application/json;charset=utf-8';
+        };
+        
+        $httpBackend.expectPOST(requestedUrl, {name:'copied task'}, headerData)
+        .respond(200);
+        
+        streamApi.copy('task', '12345678', {name:'copied task'}, '*');
+        
+        $httpBackend.flush();
+    });
+});

src/spec/copy.spec.js

@@ -0,0 +1,52 @@
+/* eslint-env jasmine */
+/* global dump */
+
+'use strict';
+
+var angular = require('angular');
+
+describe('count', function() {
+    beforeEach(function() {
+        var ngModule = angular.module('mockModule', []);
+        require('./../ApiServiceProvider')(ngModule);
+    });
+
+    beforeEach(angular.mock.module('mockModule'));
+    
+    var streamApiService,
+        $httpBackend;
+    beforeEach(angular.mock.inject(function(_streamApiService_, _$httpBackend_) {
+        streamApiService = _streamApiService_;
+        $httpBackend = _$httpBackend_;
+    }));
+    
+    var streamApi;
+    beforeEach(function() {
+        streamApi = streamApiService.getInstance({url: 'https://foo'});
+    });
+
+
+    // it('should make call to correct url', function() {
+    //     var requestedUrl = 'https://foo/attask/api/task/count?name=some+task+name&name_Mod=cicontains';
+    //     $httpBackend.expectGET(requestedUrl)
+    //     .respond(200);
+    //     var query = {};
+    //     query['name'] = 'some task name';
+    //     query['name' + streamApi.Constants.MOD] = streamApi.Constants.Operators.CICONTAINS;
+    //     streamApi.count('task', query);
+        
+    //     $httpBackend.flush();
+    // });
+
+    it('should extract correct count from returend data', function(done) {
+        var data = {count: 5};
+        $httpBackend.whenGET()
+        .respond(200, data);
+        streamApi.count('task', {})
+        .then(function(count) {
+            expect(count).toBe(data.count);
+            done();
+        });
+        $httpBackend.flush();
+    });
+});