@colijnit/ioneconnector 1.0.141 → 1.0.142

package/build/connector.js

@@ -617,7 +617,7 @@ class Connector {
         return frozenart;
     }
     static createConnector(options, externalStorage) {
-        if (options.username && options.password) {
+        if ((options.username && options.password) || options.session) {
             return new connector_auth_1.ConnectorAuth(options, externalStorage);
         }
         else {

package/build/model/session.d.ts

@@ -3,4 +3,5 @@ export declare class Session {
     dataSessionId: string;
     windowsId: string;
     created: boolean;
+    loggingIn: boolean;
 }

package/build/model/session.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 class Session {
     constructor() {
         this.created = false;
+        this.loggingIn = false;
     }
 }
 exports.Session = Session;

package/build/provider/ajax.service.d.ts

@@ -6,7 +6,6 @@ import { BaseBackendConnectionService } from "./base-backend-connection.service"
 import { Session } from "../model/session";
 export declare class AjaxService extends BaseBackendConnectionService {
     private _showLoaderRequests;
-    private _timeout;
     constructor(url: string, options: Options, session?: Session, externalStorage?: ExternalStorage, secure?: boolean);
     call(method: string, data?: DataServiceData, showLoader?: boolean, service?: BackendServiceName): Promise<any>;
     protected waitForLogin(): Promise<boolean>;

package/build/provider/ajax.service.js

@@ -11,30 +11,24 @@ class AjaxService extends base_backend_connection_service_1.BaseBackendConnectio
     constructor(url, options, session = undefined, externalStorage = undefined, secure = false) {
         super(url, options, session, externalStorage, secure);
         this._showLoaderRequests = 0;
-        this._timeout = 180000;
         if (options && options.timeoutInMs) {
-            this._timeout = options.timeoutInMs;
+            this.timeout = options.timeoutInMs;
         }
     }
     async call(method, data = {}, showLoader = true, service = backend_service_name_enum_1.BackendServiceName.LoginService) {
-        if (service === backend_service_name_enum_1.BackendServiceName.PublicService ||
-            service === backend_service_name_enum_1.BackendServiceName.LoginService ||
-            service === backend_service_name_enum_1.BackendServiceName.DatasessionService) {
-            return this._doCall(method, data, showLoader, service);
-        }
-        else {
-            await this.waitForLogin();
-            return this._doCall(method, data, showLoader, service);
-        }
+        await this.waitForLogin();
+        return this._doCall(method, data, showLoader, service);
     }
     async waitForLogin() {
         if (this.session && this.session.created) {
             return true;
         }
-        if (!this.loginService.initialized) {
-            await this.loginService.loginAndCreateDataSession();
+        if (this.session.loggingIn) {
+            return await this.loginService.waitForLoginToFinish();
         }
-        return true;
+        this.session.loggingIn = true;
+        await this.loginService.loginAndCreateDataSession();
+        this.session.loggingIn = false;
     }
     _doCall(method, data = {}, showLoader = true, service = backend_service_name_enum_1.BackendServiceName.LoginService) {
         if (showLoader) {
@@ -55,7 +49,7 @@ class AjaxService extends base_backend_connection_service_1.BaseBackendConnectio
                 method: 'post',
                 url: url,
                 data: message,
-                timeout: this._timeout
+                timeout: this.timeout
             }).then(response => {
                 resolve(response.data);
             }).catch(error => {

package/build/provider/base-backend-connection.service.d.ts

@@ -8,11 +8,12 @@ import { ConnectionEndpoint } from "./connection-endpoint";
 export declare abstract class BaseBackendConnectionService implements ConnectionEndpoint {
     readonly showLoader: Subject<boolean>;
     readonly connectionResetInactivity: Subject<void>;
+    timeout: number;
     session: Session;
     options: Options;
     externalStorage: ExternalStorage;
-    protected callId: string;
-    protected url: string;
+    callId: string;
+    url: string;
     protected secure: boolean;
     protected loginService: LoginService;
     private _datasessionService;

package/build/provider/base-backend-connection.service.js

@@ -10,6 +10,7 @@ class BaseBackendConnectionService {
     constructor(url, options, session = undefined, externalStorage = undefined, secure = false) {
         this.showLoader = new rxjs_1.Subject();
         this.connectionResetInactivity = new rxjs_1.Subject();
+        this.timeout = 180000;
         this.callId = "1";
         this.url = this.addEndpointToUrl(url);
         this.options = options;
@@ -23,7 +24,7 @@ class BaseBackendConnectionService {
             this.session = this._createNewSession();
         }
         this.loginService = new login_service_1.LoginService(this);
-        this._datasessionService = new datasession_service_1.DatasessionService(this);
+        this._datasessionService = new datasession_service_1.DatasessionService(this.loginService);
     }
     async commit() {
         return this._datasessionService.commit();

package/build/service/datasession.service.d.ts

@@ -1,7 +1,7 @@
-import { BaseBackendConnectionService } from "../provider/base-backend-connection.service";
+import { LoginService } from './login.service';
 export declare class DatasessionService {
-    protected backendConnection: BaseBackendConnectionService;
-    constructor(backendConnection: BaseBackendConnectionService);
+    protected loginService: LoginService;
+    constructor(loginService: LoginService);
     createDataSession(id: string): Promise<any>;
     commit(): Promise<boolean>;
     private _call;

package/build/service/datasession.service.js

@@ -3,23 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const backend_service_name_enum_1 = require("../enum/backend-service-name.enum");
 const datasession_service_method_enum_1 = require("../enum/datasession-service-method.enum");
 class DatasessionService {
-    constructor(backendConnection) {
-        this.backendConnection = backendConnection;
+    constructor(loginService) {
+        this.loginService = loginService;
     }
     createDataSession(id) {
-        return this._call(datasession_service_method_enum_1.DatasessionServiceMethod.OpenDataSession, { moduleName: id }, true);
+        return this._call(datasession_service_method_enum_1.DatasessionServiceMethod.OpenDataSession, { moduleName: id });
     }
     async commit() {
-        return await this._call(datasession_service_method_enum_1.DatasessionServiceMethod.Commit, {}, false);
+        return await this._call(datasession_service_method_enum_1.DatasessionServiceMethod.Commit, {});
     }
-    _call(method, data, showLoader) {
+    _call(method, data) {
         if (data === undefined) {
             data = {};
         }
-        if (showLoader === undefined) {
-            showLoader = true;
-        }
-        return this.backendConnection.call(method, data, showLoader, backend_service_name_enum_1.BackendServiceName.DatasessionService);
+        return this.loginService.call(method, data, backend_service_name_enum_1.BackendServiceName.DatasessionService);
     }
 }
 exports.DatasessionService = DatasessionService;

package/build/service/login.service.d.ts

@@ -1,5 +1,7 @@
+import { BackendServiceName } from "../enum/backend-service-name.enum";
 import { Login } from "../model/login";
 import { BaseBackendConnectionService } from "../provider/base-backend-connection.service";
+import { DataServiceData } from '../model/data-service-data';
 export declare class LoginService {
     private static HEARTBEAT_INTERVAL_MS;
     initialized: boolean;
@@ -13,9 +15,12 @@ export declare class LoginService {
     private _useEncryption;
     private _publicService;
     private _datasessionService;
+    private _dataSessionCreated;
     constructor(backendConnection: BaseBackendConnectionService);
     loginAndCreateDataSession(): Promise<any>;
+    waitForLoginToFinish(): Promise<boolean>;
     logout(): Promise<any>;
+    call(method: string, data?: DataServiceData, service?: BackendServiceName): Promise<any>;
     private _login;
     private _startHeartBeat;
     private _stopHeartBeat;

package/build/service/login.service.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const login_service_method_enum_1 = require("../enum/login-service-method.enum");
 const backend_service_name_enum_1 = require("../enum/backend-service-name.enum");
@@ -6,6 +9,9 @@ const login_1 = require("../model/login");
 const encrypt_service_1 = require("./encrypt.service");
 const public_service_1 = require("./public.service");
 const datasession_service_1 = require("./datasession.service");
+const rxjs_1 = require("rxjs");
+const url_utils_1 = require("../utils/url-utils");
+const axios_1 = __importDefault(require("axios"));
 class LoginService {
     constructor(backendConnection) {
         this.initialized = false;
@@ -13,6 +19,7 @@ class LoginService {
         this.loggingOut = false;
         this.windowsSessionId = 1;
         this._useEncryption = false;
+        this._dataSessionCreated = new rxjs_1.Subject();
         this.backendConnection = backendConnection;
         this.loginModel = new login_1.Login();
         if (this.backendConnection.options.schema === "") {
@@ -30,8 +37,8 @@ class LoginService {
         this.loginModel.clientLanguage = this.backendConnection.options.languageCode;
         this._useEncryption = this.backendConnection.options.useLoginEncryption;
         this._encryptionService = new encrypt_service_1.EncryptService();
-        this._publicService = new public_service_1.PublicService(this.backendConnection, this._encryptionService);
-        this._datasessionService = new datasession_service_1.DatasessionService(this.backendConnection);
+        this._publicService = new public_service_1.PublicService(this, this._encryptionService);
+        this._datasessionService = new datasession_service_1.DatasessionService(this);
     }
     loginAndCreateDataSession() {
         this.loggingIn = true;
@@ -43,6 +50,7 @@ class LoginService {
                     if (response.data === true) {
                         this.backendConnection.session.created = true;
                         this.loggingIn = false;
+                        this._dataSessionCreated.next();
                         this._startHeartBeat();
                         resolve();
                     }
@@ -61,13 +69,49 @@ class LoginService {
             });
         });
     }
+    async waitForLoginToFinish() {
+        return new Promise((resolve) => {
+            this._dataSessionCreated.subscribe(() => {
+                resolve(true);
+            });
+        });
+    }
     logout() {
         this.loggingOut = true;
-        return this._call(login_service_method_enum_1.LoginServiceMethod.LogoutUser, {}, false).then((userData) => {
+        return this._call(login_service_method_enum_1.LoginServiceMethod.LogoutUser, {}).then((userData) => {
             this.loggingOut = false;
             this._stopHeartBeat();
         });
     }
+    call(method, data = {}, service = backend_service_name_enum_1.BackendServiceName.LoginService) {
+        return new Promise((resolve, reject) => {
+            const url = url_utils_1.UrlUtils.createReadableUrl(method, data, this.backendConnection.url);
+            const message = JSON.stringify({
+                service: service,
+                method: method,
+                id: this.backendConnection.callId,
+                data: data,
+                dataSessionId: this.backendConnection.session ? this.backendConnection.session.dataSessionId : "",
+                windowSessionId: this.backendConnection.session ? this.backendConnection.session.windowsId : "1",
+                sessionId: this.backendConnection.session ? this.backendConnection.session.id : ""
+            });
+            axios_1.default({
+                method: 'post',
+                url: url,
+                data: message,
+                timeout: this.backendConnection.timeout
+            }).then(response => {
+                resolve(response.data);
+            }).catch(error => {
+                if (error.code === "ECONNABORTED") {
+                    reject("ECONNABORTED");
+                }
+                reject(error);
+            });
+        }).then(response => {
+            return new Promise((resolve) => { return resolve(response); });
+        });
+    }
     _login() {
         return new Promise((resolve, reject) => {
             this._callLogin()
@@ -92,7 +136,7 @@ class LoginService {
     _startHeartBeat() {
         if (!this.heartbeatTimer) {
             this.heartbeatTimer = setInterval(() => {
-                this._call(login_service_method_enum_1.LoginServiceMethod.GetHeartBeat, {}, false);
+                this._call(login_service_method_enum_1.LoginServiceMethod.GetHeartBeat, {});
             }, LoginService.HEARTBEAT_INTERVAL_MS);
         }
     }
@@ -118,17 +162,14 @@ class LoginService {
     }
     _callLogin() {
         return this._checkEncryption().then(() => {
-            return this._call(login_service_method_enum_1.LoginServiceMethod.Login, this.loginModel.getSerialized(), true);
+            return this._call(login_service_method_enum_1.LoginServiceMethod.Login, this.loginModel.getSerialized());
         });
     }
-    _call(method, data, showLoader) {
+    _call(method, data) {
         if (data === undefined) {
             data = {};
         }
-        if (showLoader === undefined) {
-            showLoader = true;
-        }
-        return this.backendConnection.call(method, data, showLoader, backend_service_name_enum_1.BackendServiceName.LoginService);
+        return this.call(method, data, backend_service_name_enum_1.BackendServiceName.LoginService);
     }
 }
 exports.LoginService = LoginService;

package/build/service/public.service.d.ts

@@ -1,9 +1,9 @@
-import { BaseBackendConnectionService } from '../provider/base-backend-connection.service';
 import { EncryptService } from './encrypt.service';
+import { LoginService } from './login.service';
 export declare class PublicService {
-    protected backendConnection: BaseBackendConnectionService;
+    protected loginService: LoginService;
     private _encryptionService;
-    constructor(backendConnection: BaseBackendConnectionService, encryptionService: EncryptService);
+    constructor(loginService: LoginService, encryptionService: EncryptService);
     getPublicKey(): Promise<void>;
     private _call;
 }

package/build/service/public.service.js

@@ -3,26 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const backend_service_name_enum_1 = require("../enum/backend-service-name.enum");
 const public_service_method_enum_1 = require("../enum/public-service-method.enum");
 class PublicService {
-    constructor(backendConnection, encryptionService) {
-        this.backendConnection = backendConnection;
+    constructor(loginService, encryptionService) {
+        this.loginService = loginService;
         this._encryptionService = encryptionService;
     }
     getPublicKey() {
         return new Promise((resolve) => {
-            this._call(public_service_method_enum_1.PublicServiceMethod.GetPublicKey, {}, false).then((result) => {
+            this._call(public_service_method_enum_1.PublicServiceMethod.GetPublicKey, {}).then((result) => {
                 this._encryptionService.publicKey = result.data;
                 resolve();
             });
         });
     }
-    _call(method, data, showLoader) {
+    _call(method, data) {
         if (data === undefined) {
             data = {};
         }
-        if (showLoader === undefined) {
-            showLoader = true;
-        }
-        return this.backendConnection.call(method, data, showLoader, backend_service_name_enum_1.BackendServiceName.PublicService);
+        return this.loginService.call(method, data, backend_service_name_enum_1.BackendServiceName.PublicService);
     }
 }
 exports.PublicService = PublicService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colijnit/ioneconnector",
-  "version": "1.0.141",
+  "version": "1.0.142",
   "scripts": {
     "build": "grunt clean && tsc",
     "browserify": "browserify build/connector.js --s colijn -o dist/out-tsc/bundle.js",