attlaz-client 1.8.6 → 1.8.9

package/dist/Model/Project/Project.d.ts

@@ -4,11 +4,14 @@ export declare class Project implements StateAware {
     id: string;
     key: string;
     name: string;
-    team: string;
+    teamId: string;
     default: boolean;
     defaultEnvironmentId: string;
+    /** @deprecated **/
     source_account: number;
+    /** @deprecated **/
     source_repository: string;
+    /** @deprecated **/
     language: number;
     state: State;
     constructor(id: string, key: string, name: string);

package/dist/Model/Project/Project.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Project = void 0;
 const State_1 = require("../State");
+const Utils_1 = require("../../Utils");
 class Project {
     constructor(id, key, name) {
         this.default = false;
@@ -12,9 +13,14 @@ class Project {
     }
     static parse(rawProject) {
         let project = new Project(rawProject.id, rawProject.key, rawProject.name);
-        project.team = rawProject.team;
+        if (rawProject.team !== undefined) {
+            project.teamId = rawProject.team;
+        }
+        else {
+            project.teamId = rawProject.teamId;
+        }
         if (rawProject.default !== null && rawProject.default !== undefined) {
-            project.default = (rawProject.default.toString() === '1');
+            project.default = Utils_1.Utils.isTrue(rawProject.default);
         }
         project.defaultEnvironmentId = rawProject.defaultEnvironmentId;
         project.source_account = rawProject.source_account;

package/dist/Model/Project/ProjectEnvironment.d.ts

@@ -5,8 +5,9 @@ export declare class ProjectEnvironment implements StateAware {
     key: string;
     projectId: string;
     name: string;
+    /** @deprecated **/
     sourceBranch: string;
-    parent: string | null;
+    parentId: string | null;
     isLocal: boolean;
     state: State;
     static parse(rawProjectEnvironment: any): ProjectEnvironment;

package/dist/Model/Project/ProjectEnvironment.js

@@ -5,7 +5,7 @@ const State_1 = require("../State");
 const Utils_1 = require("../../Utils");
 class ProjectEnvironment {
     constructor() {
-        this.parent = null;
+        this.parentId = null;
         this.isLocal = false;
         this.state = State_1.State.Active;
     }
@@ -13,10 +13,20 @@ class ProjectEnvironment {
         const projectEnvironment = new ProjectEnvironment();
         projectEnvironment.id = rawProjectEnvironment.id;
         projectEnvironment.key = rawProjectEnvironment.key;
-        projectEnvironment.projectId = rawProjectEnvironment.project;
+        if (rawProjectEnvironment.project !== undefined) {
+            projectEnvironment.projectId = rawProjectEnvironment.project;
+        }
+        else {
+            projectEnvironment.projectId = rawProjectEnvironment.projectId;
+        }
         projectEnvironment.name = rawProjectEnvironment.name;
         projectEnvironment.sourceBranch = rawProjectEnvironment.source_branch;
-        projectEnvironment.parent = rawProjectEnvironment.parent;
+        if (rawProjectEnvironment.parent !== undefined) {
+            projectEnvironment.parentId = rawProjectEnvironment.parent;
+        }
+        else {
+            projectEnvironment.parentId = rawProjectEnvironment.parentId;
+        }
         projectEnvironment.isLocal = Utils_1.Utils.isTrue(rawProjectEnvironment.is_local);
         projectEnvironment.state = State_1.State.fromString(rawProjectEnvironment.state);
         return projectEnvironment;

package/dist/Model/Result/DataResult.js

@@ -11,14 +11,17 @@ class DataResult {
         if (raw === null || raw === undefined) {
             throw new Error('Unable to parse DataResult: result: empty');
         }
-        if (!raw.hasOwnProperty('data') || raw.data === undefined) {
-            throw new Error('Unable to parse DataResult: data is not defined');
-        }
-        else {
-            result.setData(raw.data);
-        }
-        if (!raw.hasOwnProperty('errors') || raw.errors === undefined || raw.errors === null) {
-            console.error('Unable to parse DataResult (ignore for now, not setting any errors): errors is not defined');
+        if (raw.hasOwnProperty('errors')) {
+            if (raw.errors === undefined || raw.errors === null) {
+                console.error('Unable to parse DataResult: errors defined but invalid value', raw);
+            }
+            else {
+                const errors = raw.errors;
+                for (const error of errors) {
+                    result.addError(error);
+                }
+            }
+            return result;
         }
         else {
             const errors = raw.errors;
@@ -26,6 +29,12 @@ class DataResult {
                 result.addError(error);
             }
         }
+        if (!raw.hasOwnProperty('data') || raw.data === undefined) {
+            throw new Error('Unable to parse DataResult: data is not defined');
+        }
+        else {
+            result.setData(raw.data);
+        }
         return result;
     }
     setData(data) {

package/dist/Model/Task.d.ts

@@ -5,8 +5,8 @@ export declare class Task implements StateAware {
     key: string;
     name: string;
     description: string;
-    project: string;
-    direct: boolean;
+    projectId: string;
+    isDirect: boolean;
     state: State;
     /** The maximum number of tasks to run at any time (0 = no limit) **/
     parallelLimit: number;

package/dist/Model/Task.js

@@ -5,7 +5,7 @@ const State_1 = require("./State");
 const Utils_1 = require("../Utils");
 class Task {
     constructor() {
-        this.direct = false;
+        this.isDirect = false;
         this.state = State_1.State.Active;
         /** The maximum number of tasks to run at any time (0 = no limit) **/
         this.parallelLimit = 0;
@@ -14,10 +14,20 @@ class Task {
         const task = new Task();
         task.id = rawTask.id;
         task.key = rawTask.key;
-        task.project = rawTask.project;
+        if (rawTask.project !== undefined) {
+            task.projectId = rawTask.project;
+        }
+        else {
+            task.projectId = rawTask.projectId;
+        }
         task.name = rawTask.name;
         task.description = rawTask.description;
-        task.direct = rawTask.direct;
+        if (rawTask.direct !== undefined) {
+            task.isDirect = Utils_1.Utils.isTrue(rawTask.direct);
+        }
+        else {
+            task.isDirect = rawTask.isDirect;
+        }
         task.state = State_1.State.fromString(rawTask.state);
         task.parallelLimit = 0;
         if (rawTask.parallelLimit !== null && rawTask.parallelLimit !== undefined) {

package/dist/Model/TaskExecution.d.ts

@@ -1,12 +1,12 @@
 import { LogLevel } from './Log/LogLevel';
 export declare class TaskExecution {
     id: string;
-    code: string;
-    name: string;
     taskId: string;
+    name: string;
+    parentId: string | null;
     arguments: any;
-    projectEnvironment: string;
-    trigger: string;
+    projectEnvironmentId: string;
+    triggerId: string;
     deployId: number;
     logLevelCount: Map<LogLevel, number>;
     logsPurged: boolean;

package/dist/Model/TaskExecution.js

@@ -3,22 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskExecution = void 0;
 class TaskExecution {
     constructor() {
+        this.parentId = null;
         this.logsPurged = false;
     }
     static parse(rawTaskExecution) {
         let taskExecution = new TaskExecution();
         taskExecution.id = rawTaskExecution.id;
-        taskExecution.code = rawTaskExecution.code;
+        // taskExecution.code = rawTaskExecution.code;
         taskExecution.name = rawTaskExecution.name;
-        if (rawTaskExecution.task === undefined) {
+        if (rawTaskExecution.task !== undefined) {
             taskExecution.taskId = rawTaskExecution.task;
         }
         else {
             taskExecution.taskId = rawTaskExecution.taskId;
         }
         taskExecution.arguments = rawTaskExecution.arguments;
-        taskExecution.projectEnvironment = rawTaskExecution.projectEnvironment;
-        taskExecution.trigger = rawTaskExecution.trigger;
+        if (rawTaskExecution.projectEnvironment !== undefined) {
+            taskExecution.projectEnvironmentId = rawTaskExecution.projectEnvironment;
+        }
+        else {
+            taskExecution.projectEnvironmentId = rawTaskExecution.projectEnvironmentId;
+        }
+        if (rawTaskExecution.trigger !== undefined) {
+            taskExecution.triggerId = rawTaskExecution.trigger;
+        }
+        else {
+            taskExecution.triggerId = rawTaskExecution.triggerId;
+        }
         taskExecution.deployId = rawTaskExecution.deployId;
         taskExecution.logLevelCount = rawTaskExecution.logLevelCount;
         taskExecution.logsPurged = rawTaskExecution.logsPurged;

package/dist/Model/Team/Team.d.ts

@@ -4,4 +4,5 @@ export declare class Team implements StateAware {
     id: string;
     name: string;
     state: State;
+    static parse(rawTeam: any): Team;
 }

package/dist/Model/Team/Team.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Team = void 0;
+const State_1 = require("../State");
 class Team {
+    static parse(rawTeam) {
+        const team = new Team();
+        team.id = rawTeam.id;
+        team.name = rawTeam.name;
+        team.state = State_1.State.fromString(rawTeam.state);
+        return team;
+    }
 }
 exports.Team = Team;

package/dist/Service/ProjectEndpoint.js

@@ -5,37 +5,31 @@ const Endpoint_1 = require("./Endpoint");
 const Project_1 = require("../Model/Project/Project");
 const Utils_1 = require("../Utils");
 class ProjectEndpoint extends Endpoint_1.Endpoint {
-    getAll() {
-        return new Promise((resolve, reject) => {
-            this.httpClient.request('projects').then((rawProjects) => {
-                let projects = [];
-                for (let rawProject of rawProjects) {
-                    projects.push(Project_1.Project.parse(rawProject));
-                }
-                resolve(projects);
-            }).catch((reason) => {
-                if (this.httpClient.isDebugEnabled()) {
-                    console.error('Failed to load projects: ' + reason);
-                }
-                reject(reason);
-            });
-        });
+    async getAll() {
+        try {
+            const result = await this.request('/projects');
+            result.setData(this.parseCollection(result, Project_1.Project.parse));
+            return result.getData();
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load projects: ' + e);
+            }
+            throw e;
+        }
     }
-    getByTeam(teamId) {
-        return new Promise((resolve, reject) => {
-            this.httpClient.request('teams/' + teamId + '/projects').then((rawProjects) => {
-                let projects = [];
-                for (let rawProject of rawProjects) {
-                    projects.push(Project_1.Project.parse(rawProject));
-                }
-                resolve(projects);
-            }).catch((reason) => {
-                if (this.httpClient.isDebugEnabled()) {
-                    console.error('Failed to load projects: ' + reason);
-                }
-                reject(reason);
-            });
-        });
+    async getByTeam(teamId) {
+        try {
+            const result = await this.request('teams/' + teamId + '/projects');
+            result.setData(this.parseCollection(result, Project_1.Project.parse));
+            return result.getData();
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load projects: ' + e);
+            }
+            throw e;
+        }
     }
     async getById(projectId) {
         try {

package/dist/Service/ProjectEnvironmentEndpoint.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectEnvironmentEndpoint = void 0;
 const Endpoint_1 = require("./Endpoint");
+const ProjectEnvironment_1 = require("../Model/Project/ProjectEnvironment");
 class ProjectEnvironmentEndpoint extends Endpoint_1.Endpoint {
     async getByProject(id) {
         try {
-            const rawProjectEnvironments = await this.httpClient.request('/projects/' + id + '/environments');
-            let projectEnvironment = [];
-            for (let rawProjectEnvironment of rawProjectEnvironments) {
-                //TODO: add parsing
-                projectEnvironment.push(rawProjectEnvironment);
-            }
-            return projectEnvironment;
+            const result = await this.request('/projects/' + id + '/environments');
+            result.setData(this.parseCollection(result, ProjectEnvironment_1.ProjectEnvironment.parse));
+            return result.getData();
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -23,7 +20,7 @@ class ProjectEnvironmentEndpoint extends Endpoint_1.Endpoint {
     async getById(id) {
         try {
             const rawProjectEnvironment = await this.httpClient.request('/projectenvironments/' + id + '');
-            const projectEnvironment = rawProjectEnvironment;
+            const projectEnvironment = ProjectEnvironment_1.ProjectEnvironment.parse(rawProjectEnvironment);
             return projectEnvironment;
         }
         catch (error) {
@@ -37,7 +34,7 @@ class ProjectEnvironmentEndpoint extends Endpoint_1.Endpoint {
         try {
             const rawProjectEnvironment = await this.httpClient.request('projectenvironments/', projectEnvironment, 'POST');
             // TODO: parse result
-            const savedProjectEnvironment = rawProjectEnvironment;
+            const savedProjectEnvironment = ProjectEnvironment_1.ProjectEnvironment.parse(rawProjectEnvironment);
             return savedProjectEnvironment;
         }
         catch (error) {

package/dist/Service/TaskEndpoint.js

@@ -78,7 +78,7 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
     }
     save(task) {
         return new Promise((resolve, reject) => {
-            let url = '/projects/' + task.project + '/tasks';
+            let url = '/projects/' + task.projectId + '/tasks';
             this.httpClient.request(url, task, 'POST').then((result) => {
                 resolve(Task_1.Task.parse(result));
             }).catch((reason) => {

package/dist/Service/TeamsEndpoint.js

@@ -3,20 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TeamsEndpoint = void 0;
 const Endpoint_1 = require("./Endpoint");
 const Team_1 = require("../Model/Team/Team");
-const State_1 = require("../Model/State");
 class TeamsEndpoint extends Endpoint_1.Endpoint {
     async getAll() {
         try {
-            const rawTeams = await this.httpClient.request('/teams');
-            let teams = [];
-            for (let rawTeam of rawTeams) {
-                let team = new Team_1.Team();
-                team.id = rawTeam.id;
-                team.name = rawTeam.name;
-                team.state = State_1.State.fromString(rawTeam.state);
-                teams.push(team);
-            }
-            return teams;
+            const result = await this.request('/teams');
+            result.setData(this.parseCollection(result, Team_1.Team.parse));
+            return result.getData();
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.8.6";
+export declare const VERSION = "1.8.9";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = "1.8.6";
+exports.VERSION = "1.8.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attlaz-client",
-  "version": "1.8.6",
+  "version": "1.8.9",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",