attlaz-client 1.7.3 → 1.7.7

package/dist/Service/TriggerEndpoint.js

@@ -1,17 +1,20 @@
-import { Endpoint } from './Endpoint';
-import { Trigger } from '../Model/Trigger/Trigger';
-import { Utils } from '../Utils';
-export class TriggerEndpoint extends Endpoint {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerEndpoint = void 0;
+const Endpoint_1 = require("./Endpoint");
+const Trigger_1 = require("../Model/Trigger/Trigger");
+const Utils_1 = require("../Utils");
+class TriggerEndpoint extends Endpoint_1.Endpoint {
     async getByTask(taskId, projectEnvironmentId = null) {
         try {
             let parameters = null;
-            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
                 parameters = { environment: projectEnvironmentId };
             }
             const rawTriggers = await this.httpClient.request('/tasks/' + taskId + '/triggers', parameters);
             let triggers = [];
             for (let rawTrigger of rawTriggers) {
-                triggers.push(Trigger.parse(rawTrigger));
+                triggers.push(Trigger_1.Trigger.parse(rawTrigger));
             }
             return triggers;
         }
@@ -25,10 +28,10 @@ export class TriggerEndpoint extends Endpoint {
     async getById(id) {
         try {
             const result = await this.httpClient.request('/triggers/' + id);
-            if (Utils.isNullOrUndefined(result)) {
+            if (Utils_1.Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to get trigger');
             }
-            return Trigger.parse(result);
+            return Trigger_1.Trigger.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -41,7 +44,7 @@ export class TriggerEndpoint extends Endpoint {
         try {
             let url = '/tasks/' + trigger.task + '/triggers';
             const result = await this.httpClient.request(url, trigger, 'POST');
-            return Trigger.parse(result);
+            return Trigger_1.Trigger.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -51,3 +54,4 @@ export class TriggerEndpoint extends Endpoint {
         }
     }
 }
+exports.TriggerEndpoint = TriggerEndpoint;

package/dist/Service/UserEndpoint.js

@@ -1,15 +1,18 @@
-import { UserAuthProvider } from '../Model/User/UserAuthProvider';
-import { Endpoint } from './Endpoint';
-import { User } from '../Model/User';
-import { Utils } from '../Utils';
-export class UserEndpoint extends Endpoint {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEndpoint = void 0;
+const UserAuthProvider_1 = require("../Model/User/UserAuthProvider");
+const Endpoint_1 = require("./Endpoint");
+const User_1 = require("../Model/User");
+const Utils_1 = require("../Utils");
+class UserEndpoint extends Endpoint_1.Endpoint {
     async getUser() {
         let cmd = '/user';
         const rawUser = await this.httpClient.request(cmd);
-        if (Utils.isNullOrUndefined(rawUser)) {
+        if (Utils_1.Utils.isNullOrUndefined(rawUser)) {
             throw new Error('User not found');
         }
-        return User.parse(rawUser);
+        return User_1.User.parse(rawUser);
     }
     async authenticateByAuthProvider(providerType, data) {
         try {
@@ -53,14 +56,14 @@ export class UserEndpoint extends Endpoint {
     async getAuthProviders() {
         let cmd = '/user/auth/providers';
         const rawAuthProviders = await this.request(cmd);
-        rawAuthProviders.setData(this.parseCollection(rawAuthProviders, UserAuthProvider.parse));
+        rawAuthProviders.setData(this.parseCollection(rawAuthProviders, UserAuthProvider_1.UserAuthProvider.parse));
         return rawAuthProviders;
     }
     async update(user) {
         try {
             let url = '/user/' + user.id;
             const result = await this.httpClient.request(url, { user }, 'POST');
-            return User.parse(result);
+            return User_1.User.parse(result);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -76,7 +79,7 @@ export class UserEndpoint extends Endpoint {
             const result = await this.request(url, data, 'PUT', false);
             const resultData = result.getData();
             if (resultData !== null && resultData.createdUser !== null) {
-                result.setData({ createdUser: User.parse(resultData.createdUser) });
+                result.setData({ createdUser: User_1.User.parse(resultData.createdUser) });
             }
             return result;
         }
@@ -114,3 +117,4 @@ export class UserEndpoint extends Endpoint {
         }
     }
 }
+exports.UserEndpoint = UserEndpoint;

package/dist/Service/WorkerConfigEndpoint.js

@@ -1,12 +1,15 @@
-import { Endpoint } from './Endpoint';
-import { Utils } from '../Utils';
-import { WorkerConfig } from '../Model/Worker/WorkerConfig';
-export class WorkerConfigEndpoint extends Endpoint {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerConfigEndpoint = void 0;
+const Endpoint_1 = require("./Endpoint");
+const Utils_1 = require("../Utils");
+const WorkerConfig_1 = require("../Model/Worker/WorkerConfig");
+class WorkerConfigEndpoint extends Endpoint_1.Endpoint {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/workerconfiguration';
             const result = await this.request(url);
-            if (Utils.isNullOrUndefined(result)) {
+            if (Utils_1.Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to get project environment');
             }
             const resultData = result.getData();
@@ -15,7 +18,7 @@ export class WorkerConfigEndpoint extends Endpoint {
             }
             let workerConfigValues = [];
             for (let rawConfig of resultData) {
-                workerConfigValues.push(WorkerConfig.parse(rawConfig));
+                workerConfigValues.push(WorkerConfig_1.WorkerConfig.parse(rawConfig));
             }
             return workerConfigValues;
         }
@@ -31,7 +34,7 @@ export class WorkerConfigEndpoint extends Endpoint {
             let url = '/projectenvironments/' + workerConfig.projectEnvironment + '/workerconfiguration';
             const result = await this.request(url, workerConfig, 'POST');
             console.log(result);
-            return WorkerConfig.parse(result);
+            return WorkerConfig_1.WorkerConfig.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -41,3 +44,4 @@ export class WorkerConfigEndpoint extends Endpoint {
         }
     }
 }
+exports.WorkerConfigEndpoint = WorkerConfigEndpoint;

package/dist/Service/WorkerEndpoint.js

@@ -1,16 +1,19 @@
-import { Endpoint } from './Endpoint';
-import { Utils } from '../Utils';
-import { Worker } from '../Model/Worker/Worker';
-import { DataResult } from '../Model/Result/DataResult';
-export class WorkerEndpoint extends Endpoint {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEndpoint = void 0;
+const Endpoint_1 = require("./Endpoint");
+const Utils_1 = require("../Utils");
+const Worker_1 = require("../Model/Worker/Worker");
+const DataResult_1 = require("../Model/Result/DataResult");
+class WorkerEndpoint extends Endpoint_1.Endpoint {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/workers';
             const result = await this.httpClient.request(url);
-            if (Utils.isNullOrUndefined(result)) {
+            if (Utils_1.Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to find worker');
             }
-            return new DataResult(Worker.parse(result));
+            return new DataResult_1.DataResult(Worker_1.Worker.parse(result));
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -33,3 +36,4 @@ export class WorkerEndpoint extends Endpoint {
         }
     }
 }
+exports.WorkerEndpoint = WorkerEndpoint;

package/dist/Utils.js

@@ -1,4 +1,7 @@
-export class Utils {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+class Utils {
     static isNullOrUndefined(variable) {
         return variable === null || variable === undefined;
     }
@@ -55,3 +58,4 @@ export class Utils {
         // return typeof obj[Symbol.iterator] === 'function';
     }
 }
+exports.Utils = Utils;

package/dist/Utils.spec.js

@@ -1,38 +1,40 @@
-import { TriggerType } from './Model/Trigger/TriggerType';
-import { TaskExecutionStatus } from './Model/TaskExecutionStatus';
-import { ChannelType } from './Model/Messaging/Channel/ChannelType';
-import { ProjectDeployStatus } from './Model/Project/ProjectDeployStatus';
-import { State } from './Model/State';
-import { LogLevel } from './Model/Log/LogLevel';
-import { StorageType } from './Model/Storage/StorageType';
-import { WorkerInstanceState } from './Model/Worker/WorkerInstanceState';
-import { WorkerState } from './Model/Worker/WorkerState';
-import { Utils } from './Utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TriggerType_1 = require("./Model/Trigger/TriggerType");
+const TaskExecutionStatus_1 = require("./Model/TaskExecutionStatus");
+const ChannelType_1 = require("./Model/Messaging/Channel/ChannelType");
+const ProjectDeployStatus_1 = require("./Model/Project/ProjectDeployStatus");
+const State_1 = require("./Model/State");
+const LogLevel_1 = require("./Model/Log/LogLevel");
+const StorageType_1 = require("./Model/Storage/StorageType");
+const WorkerInstanceState_1 = require("./Model/Worker/WorkerInstanceState");
+const WorkerState_1 = require("./Model/Worker/WorkerState");
+const Utils_1 = require("./Utils");
 test('Test enum parsing', () => {
-    expect(TriggerType.fromString('webhook')).toBe(TriggerType.Webhook);
-    expect(TaskExecutionStatus.fromString('complete')).toBe(TaskExecutionStatus.Complete);
-    expect(ChannelType.fromString('slack')).toBe(ChannelType.Slack);
-    expect(LogLevel.fromString('debug')).toBe(LogLevel.Debug);
-    expect(ProjectDeployStatus.fromString('complete')).toBe(ProjectDeployStatus.Complete);
-    expect(StorageType.fromString('cache')).toBe(StorageType.Cache);
-    expect(State.fromString('active')).toBe(State.Active);
-    expect(WorkerInstanceState.fromString('started')).toBe(WorkerInstanceState.Started);
-    expect(WorkerState.fromString('active')).toBe(WorkerState.Active);
+    expect(TriggerType_1.TriggerType.fromString('webhook')).toBe(TriggerType_1.TriggerType.Webhook);
+    expect(TaskExecutionStatus_1.TaskExecutionStatus.fromString('complete')).toBe(TaskExecutionStatus_1.TaskExecutionStatus.Complete);
+    expect(ChannelType_1.ChannelType.fromString('slack')).toBe(ChannelType_1.ChannelType.Slack);
+    expect(LogLevel_1.LogLevel.fromString('debug')).toBe(LogLevel_1.LogLevel.Debug);
+    expect(ProjectDeployStatus_1.ProjectDeployStatus.fromString('complete')).toBe(ProjectDeployStatus_1.ProjectDeployStatus.Complete);
+    expect(StorageType_1.StorageType.fromString('cache')).toBe(StorageType_1.StorageType.Cache);
+    expect(State_1.State.fromString('active')).toBe(State_1.State.Active);
+    expect(WorkerInstanceState_1.WorkerInstanceState.fromString('started')).toBe(WorkerInstanceState_1.WorkerInstanceState.Started);
+    expect(WorkerState_1.WorkerState.fromString('active')).toBe(WorkerState_1.WorkerState.Active);
 });
 test('Test base64 encode/decode', () => {
-    expect(Utils.base64encode('Lorem ipsum')).toBe('TG9yZW0gaXBzdW0=');
-    expect(Utils.base64decode('TG9yZW0gaXBzdW0=')).toBe('Lorem ipsum');
+    expect(Utils_1.Utils.base64encode('Lorem ipsum')).toBe('TG9yZW0gaXBzdW0=');
+    expect(Utils_1.Utils.base64decode('TG9yZW0gaXBzdW0=')).toBe('Lorem ipsum');
 });
 test('Test if iterable', async () => {
-    expect(Utils.isIterable(null)).toBe(false);
-    expect(Utils.isIterable('')).toBe(false);
-    expect(Utils.isIterable('Lorem')).toBe(false);
-    expect(Utils.isIterable(false)).toBe(false);
-    expect(Utils.isIterable(true)).toBe(false);
-    expect(Utils.isIterable(undefined)).toBe(false);
-    expect(Utils.isIterable(12)).toBe(false);
-    expect(Utils.isIterable([])).toBe(true);
-    expect(Utils.isIterable(['L', 'O', 'R', 'E', 'M'])).toBe(true);
-    expect(Utils.isIterable({})).toBe(false);
-    expect(Utils.isIterable({ a: 'a', b: 'b' })).toBe(false);
+    expect(Utils_1.Utils.isIterable(null)).toBe(false);
+    expect(Utils_1.Utils.isIterable('')).toBe(false);
+    expect(Utils_1.Utils.isIterable('Lorem')).toBe(false);
+    expect(Utils_1.Utils.isIterable(false)).toBe(false);
+    expect(Utils_1.Utils.isIterable(true)).toBe(false);
+    expect(Utils_1.Utils.isIterable(undefined)).toBe(false);
+    expect(Utils_1.Utils.isIterable(12)).toBe(false);
+    expect(Utils_1.Utils.isIterable([])).toBe(true);
+    expect(Utils_1.Utils.isIterable(['L', 'O', 'R', 'E', 'M'])).toBe(true);
+    expect(Utils_1.Utils.isIterable({})).toBe(false);
+    expect(Utils_1.Utils.isIterable({ a: 'a', b: 'b' })).toBe(false);
 });

package/dist/auth.spec.js

@@ -1,7 +1,9 @@
-import { Client } from './Client';
-import { OAuthClientToken } from './Http/OAuthClientToken';
-import { Utils } from './Utils';
-import { HttpClient } from './Http/HttpClient';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Client_1 = require("./Client");
+const OAuthClientToken_1 = require("./Http/OAuthClientToken");
+const Utils_1 = require("./Utils");
+const HttpClient_1 = require("./Http/HttpClient");
 jest.setTimeout((60) * 1000);
 // const apiEndpoint: string = 'http://localhost:5728/';
 const apiEndpoint = 'https://api2.attlaz.com';
@@ -9,12 +11,12 @@ const clientCredentialClientId = 'zSGdVWE3FAS8kY5C';
 const clientCredentialClientSecret = '6jhYgFPAUm9HmCus';
 const passwordFlowClientId = 'MXexCeRqNrGnh5tw';
 const passwordFlowClientSecret = 'NPYYu6hgMRRzcWN4';
-const passwordFlowUsername = 'eline@attlaz.com';
-const passwordFlowPassword = 'koetjeboe';
+const passwordFlowUsername = 'demo@attlaz.com';
+const passwordFlowPassword = 'Kd9X&jKiSJDXb3@cTq';
 const tokenExpirationInSeconds = 5;
 test('Test client credentials flow', async () => {
     expect.assertions(2);
-    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const user = await client.getUserEndpoint().getUser();
@@ -41,19 +43,19 @@ test('Test client credentials flow', async () => {
         if (token === null) {
             throw new Error('Token is null');
         }
-        expect(OAuthClientToken.isExpired(token)).toBeTruthy();
+        expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
     }
     // const user2: User = await client.getUserEndpoint().getUser()
     // expect(user.email).toBe('demo@attlaz.com');
 });
 test('Test password authentication - valid', async () => {
     expect.assertions(3);
-    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate(passwordFlowUsername, passwordFlowPassword);
     const user = await client.getUserEndpoint().getUser();
     // console.log('User', user);
-    expect(user.email).toBe('eline@attlaz.com');
+    expect(user.email).toBe('demo@attlaz.com');
     // TODO: how to get the seconds to wait for the token to expire?
     const waitSecondsForTokenToExpire = tokenExpirationInSeconds + 5;
     // console.log(client.getToken().expires);
@@ -62,41 +64,41 @@ test('Test password authentication - valid', async () => {
     if (token === null) {
         throw new Error('Token is null');
     }
-    expect(OAuthClientToken.isExpired(token)).toBeTruthy();
+    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
     const user2 = await client.getUserEndpoint().getUser();
     expect(user2.email).toBe(passwordFlowUsername);
 });
 test('Test password authentication - invalid', async () => {
     expect.assertions(3);
-    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await expect(client.authenticate(passwordFlowUsername, 'wrongpassword'))
         .rejects
-        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
     await expect(client.getUserEndpoint().getUser())
         .rejects
         .toHaveProperty('message', 'Unable to perform request, access token not provided');
     await expect(client.authenticate('wrongusername', 'wrongpassword'))
         .rejects
-        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
 });
 test('Test set access token + JSON encode', async () => {
     expect.assertions(4);
-    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate(passwordFlowUsername, passwordFlowPassword);
     const token = client.getToken();
     if (token === null) {
         throw new Error('Token is null');
     }
-    expect(OAuthClientToken.isExpired(token)).toBeFalsy();
-    const encoded = OAuthClientToken.serialize(token);
+    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeFalsy();
+    const encoded = OAuthClientToken_1.OAuthClientToken.serialize(token);
     console.log(encoded);
-    const decodedToken = OAuthClientToken.deserialize(encoded);
+    const decodedToken = OAuthClientToken_1.OAuthClientToken.deserialize(encoded);
     client.setToken(decodedToken);
     const user = await client.getUserEndpoint().getUser();
     expect(user.email).toBe(passwordFlowUsername);
-    let client2 = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client2 = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client2.getHttpClient().enableDebug();
     console.log(decodedToken);
     client2.setToken(decodedToken);
@@ -120,19 +122,19 @@ test('Test set access token + JSON encode', async () => {
 });
 test('Test set expired tokens', async () => {
     expect.assertions(4);
-    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
-    const encodedToken = Utils.base64decode('eyJhY2Nlc3NfdG9rZW4iOiJvZVZpYXVhdk9wTkNpekNLRmxXUGpuaEI5aHNSdFViMFFTTVJlQWFuIiwidG9rZW5fdHlwZSI6ImJlYXJlciIsInJlZnJlc2hfdG9rZW4iOiJ4N0pINTVaR3U5OGFPN3VQaGlmS2RZME8yc3BYS0IzN296bElDUGtJIiwiZXhwaXJlcyI6IjIwMjEtMDMtMTlUMjE6MTQ6MTkuNzkyWiIsInNjb3BlIjoiYWxsIn0=');
-    const token = OAuthClientToken.deserialize(encodedToken);
+    const encodedToken = Utils_1.Utils.base64decode('eyJhY2Nlc3NfdG9rZW4iOiJvZVZpYXVhdk9wTkNpekNLRmxXUGpuaEI5aHNSdFViMFFTTVJlQWFuIiwidG9rZW5fdHlwZSI6ImJlYXJlciIsInJlZnJlc2hfdG9rZW4iOiJ4N0pINTVaR3U5OGFPN3VQaGlmS2RZME8yc3BYS0IzN296bElDUGtJIiwiZXhwaXJlcyI6IjIwMjEtMDMtMTlUMjE6MTQ6MTkuNzkyWiIsInNjb3BlIjoiYWxsIn0=');
+    const token = OAuthClientToken_1.OAuthClientToken.deserialize(encodedToken);
     client.setToken(token);
-    expect(OAuthClientToken.isExpired(token)).toBeTruthy();
+    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
     expect(client.getHttpClient().isTokenExpires()).toBeTruthy();
     await expect(client.getHttpClient().refreshToken())
         .rejects
-        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
     await expect(client.getUserEndpoint().getUser())
         .rejects
-        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
     // const user: User = await client.getUserEndpoint().getUser()
     // expect(user.email).toBe(passwordFlowUsername);
     //

package/dist/data.spec.js

@@ -1,4 +1,6 @@
-import { Client } from './Client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Client_1 = require("./Client");
 jest.setTimeout((60) * 1000);
 // const apiEndpoint: string = 'http://localhost:5728/';
 const apiEndpoint = 'https://api2.attlaz.com';
@@ -11,7 +13,7 @@ const passwordFlowPassword = 'koetjeboe';
 const tokenExpirationInSeconds = 5;
 test('Test get user', async () => {
     expect.assertions(1);
-    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const user = await client.getUserEndpoint().getUser();
@@ -20,7 +22,7 @@ test('Test get user', async () => {
 });
 test('Test get project', async () => {
     expect.assertions(1);
-    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const project = await client.getProjectEndpoint().getById('8B5C14EBB');