@webuildbots/webuildbots-sdk 11.1.1 → 11.2.0

package/lib/services/EntityService.js

@@ -0,0 +1,265 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ApiService_1 = __importDefault(require("./ApiService"));
+var EntityService = /** @class */ (function () {
+    function EntityService(token, client, rootURL) {
+        this.apiService = new ApiService_1.default(token, rootURL);
+        this.client = client;
+    }
+    EntityService.prototype.createEntity = function (title, values, name, template, module, isWbbDocument) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entity, res, options, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entity = {
+                            title: title,
+                            values: values,
+                            name: name,
+                            created: new Date(),
+                            template: template,
+                            module: module,
+                            isWbbDocument: isWbbDocument
+                        };
+                        options = {
+                            method: 'POST',
+                            data: entity
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/entity', this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        throw Error(e_1);
+                    case 4: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.updateEntity = function (_id, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var oldEntity, entity, res, options, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getEntity(_id)];
+                    case 1:
+                        oldEntity = _a.sent();
+                        entity = {
+                            _id: _id,
+                            title: body.title,
+                            values: body.values,
+                            name: body.name || oldEntity[0].name,
+                            template: body.template,
+                            module: body.module,
+                            isWbbDocument: body.isWbbDocument,
+                            created: body.created || oldEntity[0].created
+                        };
+                        options = {
+                            method: 'PUT',
+                            data: entity
+                        };
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/intent/' + _id, this.client, options)];
+                    case 3:
+                        res = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_2 = _a.sent();
+                        throw Error(e_2);
+                    case 5: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.getEntity = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fetchResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getEntities()];
+                    case 1:
+                        fetchResponse = _a.sent();
+                        return [2 /*return*/, fetchResponse.data.filter(function (entity) { return entity._id == id; })];
+                }
+            });
+        });
+    };
+    EntityService.prototype.getEntities = function (searchText) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, options, e_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            method: 'GET',
+                            params: {
+                                q: searchText
+                            }
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/entity', this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_3 = _a.sent();
+                        throw Error(e_3);
+                    case 4: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.deleteEntity = function (_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, options, e_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            method: 'DELETE'
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/intent/' + _id, this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_4 = _a.sent();
+                        throw Error(e_4);
+                    case 4: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.createMapping = function (block, entityId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, options, e_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            method: 'POST',
+                            data: {
+                                block: block,
+                                entityId: entityId
+                            }
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/entity-mapping', this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_5 = _a.sent();
+                        throw Error(e_5);
+                    case 4: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.deleteMapping = function (_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, options, e_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            method: 'DELETE'
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/entity-mapping/' + _id, this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_6 = _a.sent();
+                        throw Error(e_6);
+                    case 4: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    EntityService.prototype.getMappings = function (responseId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, options, e_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = {
+                            method: 'GET'
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/entity-mapping', this.client, options)];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_7 = _a.sent();
+                        throw Error(e_7);
+                    case 4:
+                        if (res && responseId) {
+                            res = res.filter(function (mapping) { return mapping.block.blockId == responseId; });
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    return EntityService;
+}());
+exports.default = EntityService;

package/lib/services/IntentService.d.ts

@@ -1,9 +1,19 @@
 export default class IntentService {
     private apiService;
     private client;
-    constructor(token: any, client: any, rootURL: any);
+    constructor(token: string, client: string, rootURL?: string);
     createIntent(title: string, utterances: string[], name: string, groups?: string[], parentName?: string, module?: string, isWbbDocument?: boolean): Promise<any>;
-    updateIntent(_id: string, title: string, utterances: string[], name: string, created: string, groups?: string[], parentName?: string, module?: string, isWbbDocument?: boolean): Promise<any>;
+    updateIntent(_id: string, body: {
+        title?: string;
+        utterances?: string[];
+        name?: string;
+        created?: string;
+        groups?: string[];
+        parentName?: string;
+        module?: string;
+        isWbbDocument?: boolean;
+    }): Promise<any>;
+    getIntent(id: any): Promise<any>;
     getIntents(searchText?: string): Promise<any>;
     deleteIntent(_id: string): Promise<any>;
     createMapping(block: {

package/lib/services/IntentService.js

@@ -63,7 +63,7 @@ var IntentService = /** @class */ (function () {
                         };
                         options = {
                             method: 'POST',
-                            body: intent
+                            data: intent
                         };
                         _a.label = 1;
                     case 1:
@@ -80,56 +80,73 @@ var IntentService = /** @class */ (function () {
             });
         });
     };
-    IntentService.prototype.updateIntent = function (_id, title, utterances, name, created, groups, parentName, module, isWbbDocument) {
+    IntentService.prototype.updateIntent = function (_id, body) {
         return __awaiter(this, void 0, void 0, function () {
-            var intent, res, options, e_2;
+            var oldIntent, intent, res, options, e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
+                    case 0: return [4 /*yield*/, this.getIntent(_id)];
+                    case 1:
+                        oldIntent = _a.sent();
                         intent = {
-                            title: title,
-                            utterances: utterances,
-                            name: name,
-                            groups: groups,
-                            parentName: parentName,
-                            module: module,
-                            isWbbDocument: isWbbDocument,
-                            created: created
+                            _id: _id,
+                            title: body.title,
+                            utterances: body.utterances,
+                            name: body.name || oldIntent[0].name,
+                            groups: body.groups,
+                            parentName: body.parentName,
+                            module: body.module,
+                            isWbbDocument: body.isWbbDocument,
+                            created: body.created || oldIntent[0].created
                         };
                         options = {
                             method: 'PUT',
-                            body: intent
+                            data: intent
                         };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/intent/' + _id, this.client, options)];
+                        _a.label = 2;
                     case 2:
-                        res = _a.sent();
-                        return [3 /*break*/, 4];
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/intent/' + _id, this.client, options)];
                     case 3:
+                        res = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
                         e_2 = _a.sent();
                         throw Error(e_2);
-                    case 4: return [2 /*return*/, res];
+                    case 5: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    IntentService.prototype.getIntent = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fetchResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getIntents()];
+                    case 1:
+                        fetchResponse = _a.sent();
+                        return [2 /*return*/, fetchResponse.data.intents.filter(function (intent) { return intent._id == id; })];
                 }
             });
         });
     };
     IntentService.prototype.getIntents = function (searchText) {
         return __awaiter(this, void 0, void 0, function () {
-            var res, options, query, endpoint, e_3;
+            var res, options, e_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         options = {
-                            method: 'GET'
+                            method: 'GET',
+                            params: {
+                                q: searchText
+                            }
                         };
-                        query = "?q=" + searchText;
-                        endpoint = 'api/agent/knowlbase/intent';
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.apiService.hitApi(searchText ? endpoint + query : endpoint, this.client, options)];
+                        return [4 /*yield*/, this.apiService.hitApi('api/agent/knowlbase/intent', this.client, options)];
                     case 2:
                         res = _a.sent();
                         return [3 /*break*/, 4];
@@ -173,7 +190,7 @@ var IntentService = /** @class */ (function () {
                     case 0:
                         options = {
                             method: 'POST',
-                            body: {
+                            data: {
                                 block: block,
                                 intentId: intentId
                             }

package/lib/services/ResponseService.d.ts

@@ -1,23 +1,25 @@
 import { BlockTypes } from '../const/block-enums';
-import { Languages } from '../const/languages-enums';
+import BlockObj from '../interfaces/block';
 export default class ResponseService {
     private apiService;
     private client;
-    constructor(token: any, client: any, rootURL: any);
-    createResponse(title: {
-        language: Languages;
-        value: string;
-    }, module: string, description: string, type: BlockTypes, name?: import("../const/block-enums").CommonGroups, group?: import("../const/block-enums").CommonGroups, variable?: {
-        title: string;
-        value: string;
-    }, formFieldCallbackArgs?: any, next?: string): Promise<any>;
-    updateResponse(blockId: any, title?: {
-        language: Languages;
-        value: string;
-    }, module?: string, description?: string, type?: BlockTypes, name?: string, group?: string, variable?: {
-        title: string;
-        value: string;
-    }, formFieldCallbackArgs?: any, next?: string): Promise<any>;
+    constructor(token: string, client: any, rootURL?: string);
+    private formatBlockValues;
+    createResponse(content: BlockObj['content'], module: string, description: string, type: BlockTypes, name?: string, group?: string, formFieldCallbackArgs?: BlockObj['formFieldCallback'], next?: string, functionObj?: BlockObj['function']): Promise<any>;
+    updateResponse(blockId: any, body: {
+        version?: number;
+        type?: BlockTypes;
+        created?: string;
+        content?: BlockObj['content'];
+        module?: string;
+        description?: string;
+        name?: string;
+        group?: string;
+        formFieldCallbackArgs?: any;
+        next?: string;
+        function?: BlockObj['function'];
+    }): Promise<any>;
     deleteResponse(blockId: any): Promise<any>;
     getResponses(searchText?: string, types?: any[], groups?: any[]): Promise<any>;
+    getResponse(id: any): Promise<any>;
 }