@slavmak2486/bx24ts 1.0.0

package/dist/base/BX24.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseBX24 = void 0;
+const axios_1 = __importDefault(require("axios"));
+const callResult_1 = require("../callResult");
+const qs_1 = __importDefault(require("qs"));
+const lodash_1 = require("lodash");
+class baseBX24 {
+    constructor() {
+        this.cbArray = [];
+        this.AUTH_CONNECTOR = "";
+        this.CLIENT_ID = "";
+        this.CLIENT_SECRET = "";
+        this.isInit = false;
+        this.APP_SID = false;
+        this.PATH = "/rest";
+        this.LANG = "";
+        this.AUTH_ID = "";
+        this.REFRESH_ID = "";
+        this.MEMBER_ID = "";
+        this.PLACEMENT = "";
+        this.IS_ADMIN = false;
+        this.AUTH_EXPIRES = 0;
+        this.arrEvents = [];
+        this.logger = console;
+        this.isReadyVal = false;
+        this.userOption = {
+            get: (name) => {
+                return this.USER_OPTIONS[name];
+            },
+            set: (name, value, cb) => {
+                this.USER_OPTIONS[name] = value;
+                this.sendMessage('setUserOption', { name: name, value: value }, cb);
+            }
+        };
+        this.appOption = {
+            get: (name) => {
+                return this.APP_OPTIONS[name];
+            },
+            set: (name, value, cb) => {
+                if (this.isAdmin()) {
+                    this.APP_OPTIONS[name] = value;
+                    this.sendMessage('setAppOption', { name: name, value: value }, cb);
+                }
+                else {
+                    console.error('Access denied!');
+                }
+            }
+        };
+        this.selectAccess = (title, value, cb) => {
+            if (typeof (value) === 'function') {
+                cb = value;
+                value = [];
+            }
+            this.sendMessage('selectAccess', { value: value }, cb);
+        };
+        this.selectUser = (title, cb) => {
+            if (typeof (title) === 'function') {
+                cb = title;
+                title = '';
+            }
+            this.sendMessage('selectUser', { title: title, mult: false }, cb);
+        };
+        this.selectUsers = (title, cb) => {
+            if (typeof (title) !== 'string') {
+                cb = title;
+                title = '';
+            }
+            this.sendMessage('selectUser', { title: title, mult: true }, cb);
+        };
+        this.selectCRM = (params, cb) => {
+            this.sendMessage('selectCRM', {
+                entityType: params.entityType,
+                multiple: params.multiple,
+                value: params.value,
+            }, cb);
+        };
+        this.placement = {
+            info: () => ({
+                placement: this.PLACEMENT,
+                options: this.PLACEMENT_OPTIONS
+            }),
+            getInterface: (cb) => {
+                this.sendMessage('getInterface', {}, cb);
+            },
+            call: (cmd, params, cb) => {
+                this.sendMessage(cmd, params, cb);
+            },
+            bindEvent: (eventName, cb) => {
+                this.sendMessage('placementBindEvent', { event: eventName }, cb);
+            }
+        };
+        this.DOMAIN = "";
+        this.PROTOCOL = 1;
+    }
+    isFunction(item) {
+        return item === null ? false : (typeof (item) == "function" || item instanceof Function);
+    }
+    addEvent(event, handler) {
+        this.arrEvents.push({
+            event: event,
+            handler: handler
+        });
+    }
+    emitEvent(event, params) {
+        const arrHandler = this.arrEvents.filter(el => { return el.event == event; });
+        for (const idx in arrHandler) {
+            setTimeout(() => {
+                arrHandler[idx].handler.call(this, params);
+            }, 10);
+        }
+    }
+    uniqid() {
+        const charsList = '0123456789abcdefghijklmnopqrstuvwxyz';
+        let s = '';
+        for (let i = 0; i < 32; i++)
+            s += charsList[Math.round(Math.random() * (charsList.length - 1))];
+        return s;
+    }
+    setCallback(cb) {
+        const cbId = this.uniqid();
+        if (cb) {
+            this.cbArray.push({ uid: cbId, cb: cb });
+        }
+        return cbId;
+    }
+    doInit() {
+        this.emitEvent('init', this);
+    }
+    utilReady() {
+        if (document.readyState === "complete") {
+            return this.runReady();
+        }
+        let __readyHandler;
+        if (document.addEventListener) {
+            __readyHandler = () => {
+                document.removeEventListener("DOMContentLoaded", __readyHandler, false);
+                this.runReady();
+            };
+            document.addEventListener("DOMContentLoaded", __readyHandler, false);
+            window.addEventListener("load", () => { this.runReady(); }, false);
+        }
+        else if (document.attachEvent) {
+            __readyHandler = () => {
+                if (document.readyState === "complete") {
+                    document.detachEvent("onreadystatechange", __readyHandler);
+                    this.runReady();
+                }
+            };
+            document.attachEvent("onreadystatechange", __readyHandler);
+            window.attachEvent("onload", () => { this.runReady(); });
+        }
+        this.utilReady = () => null;
+        return null;
+    }
+    runReady() {
+        if (!this.isReadyVal) {
+            if (!document.body) {
+                setTimeout(this.runReady, 15);
+                return;
+            }
+            this.isReadyVal = true;
+            this.ready = (handler) => {
+                if (typeof handler == 'function') {
+                    setTimeout(handler, 10);
+                }
+            };
+            this.emitEvent('ready');
+        }
+        return;
+    }
+    callSuccess(xhr) {
+        return typeof xhr.status == 'undefined' || (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || xhr.status >= 400 && xhr.status < 500 || xhr.status === 1223 || xhr.status === 0;
+    }
+    call(url, config) {
+        return new Promise((resolve, reject) => {
+            config.auth = this.AUTH_ID;
+            if (this.AUTH_CONNECTOR) {
+                config.auth_connector = this.AUTH_CONNECTOR;
+            }
+            const options = {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                data: qs_1.default.stringify(config),
+                url: url
+            };
+            (0, axios_1.default)(options).then(res => {
+                const data = res.data;
+                const result = new callResult_1.CallResult(data, config, res.status);
+                resolve(result);
+            })
+                .catch(err => {
+                if ((0, lodash_1.get)(err, ['response', 'data', 'error'], undefined) == 'expired_token' && !url.includes('oauth.bitrix.info/oauth/token/')) {
+                    this.refreshAuth(() => {
+                        this.call(url, config);
+                    });
+                }
+                else {
+                    reject((0, lodash_1.get)(err, ['response', 'data'], 'unknown error'));
+                }
+            });
+        });
+    }
+    getAuth() {
+        return (this.isInit && this.AUTH_EXPIRES > (new Date()).valueOf())
+            ? { access_token: this.AUTH_ID, refresh_token: this.REFRESH_ID, expires_in: this.AUTH_EXPIRES, domain: this.DOMAIN, member_id: this.MEMBER_ID }
+            : false;
+    }
+    callBatch(cmd, cb, haltOnError = false) {
+        const startCb = cb;
+        const startHaltOnError = haltOnError;
+        if (typeof cb == 'boolean') {
+            haltOnError = cb;
+            cb = undefined;
+        }
+        const comands = {};
+        let cnt = 0;
+        for (const idx in cmd) {
+            let method = "", params = null;
+            if (Array.isArray(cmd[idx])) {
+                method = (0, lodash_1.get)(cmd[idx], 0, undefined);
+                params = (0, lodash_1.get)(cmd[idx], 1, {});
+            }
+            else if ((0, lodash_1.get)(cmd[idx], 'method', undefined) != undefined) {
+                method = (0, lodash_1.get)(cmd[idx], 'method', undefined);
+                params = (0, lodash_1.get)(cmd[idx], 'params', {});
+            }
+            if (method) {
+                cnt++;
+                comands[idx] = `${method}?${qs_1.default.stringify(params)}`;
+            }
+        }
+        if (cnt > 0) {
+            const url = `http${this.PROTOCOL ? 's' : ''}://${this.DOMAIN}${this.PATH}/batch.json`;
+            const params = {
+                cmd: comands,
+                halt: haltOnError ? 1 : 0
+            };
+            if (!startCb) {
+                if (this.AUTH_EXPIRES < (new Date()).valueOf()) {
+                    return new Promise((resolve, reject) => {
+                        this.refreshAuth(() => {
+                            this.callBatch(cmd, startHaltOnError).then(res => {
+                                resolve(res);
+                            })
+                                .catch(err => {
+                                reject(err);
+                            });
+                        });
+                    });
+                }
+                else {
+                    return new Promise((resolve, reject) => {
+                        this.call(url, params).then(res => {
+                            resolve(this.formatResultForBatch(res, params));
+                        });
+                    });
+                }
+            }
+            else if (typeof startCb == 'function') {
+                if (this.AUTH_EXPIRES < (new Date()).valueOf()) {
+                    this.refreshAuth(() => {
+                        this.callBatch(cmd, startCb, startHaltOnError);
+                    });
+                }
+                else {
+                    this.call(url, params).then(res => {
+                        if (typeof cb == 'function')
+                            cb(this.formatResultForBatch(res, params, cb));
+                    })
+                        .catch(err => {
+                        throw err;
+                    });
+                }
+            }
+        }
+        else {
+            return;
+        }
+    }
+    formatResultForBatch(res, params, callback) {
+        const data = res.data();
+        const calls = params && params.cmd ? params.cmd : [];
+        const result = {};
+        for (const idx in calls) {
+            if (typeof data.result[idx] !== 'undefined' || typeof data.result_error[idx] !== 'undefined') {
+                const query = calls[idx].split('?');
+                result[idx] = new callResult_1.CallResult({
+                    result: typeof data.result[idx] !== 'undefined' ? data.result[idx] : {},
+                    error: data.result_error[idx] || undefined,
+                    total: data.result_total[idx],
+                    next: data.result_next[idx]
+                }, {
+                    method: query[0],
+                    data: query[1],
+                    callback: callback
+                }, res.status);
+            }
+        }
+        return result;
+    }
+    callMethod(method, params, cb) {
+        const url = `http${this.PROTOCOL ? 's' : ''}://${this.DOMAIN}${this.PATH}/${method}.json`;
+        if (!cb) {
+            if (this.AUTH_EXPIRES < (new Date()).valueOf()) {
+                return new Promise((resolve, reject) => {
+                    this.refreshAuth(() => {
+                        var _a;
+                        (_a = this.callMethod(method, params)) === null || _a === void 0 ? void 0 : _a.then(res => {
+                            resolve(res);
+                        }).catch(err => {
+                            reject(err);
+                        });
+                    });
+                });
+            }
+            else {
+                return this.call(url, params);
+            }
+        }
+        else if (cb) {
+            if (this.AUTH_EXPIRES < (new Date()).valueOf()) {
+                this.refreshAuth(() => {
+                    this.callMethod(method, params, cb);
+                });
+            }
+            else {
+                this.call(url, params).then(res => {
+                    cb(res);
+                })
+                    .catch(err => {
+                    cb(new callResult_1.CallResult(err, params, 500));
+                });
+            }
+        }
+        else {
+            throw new Error("Incorrect params");
+        }
+    }
+    isAdmin() {
+        return this.IS_ADMIN;
+    }
+    getLang() {
+        return this.LANG;
+    }
+    getDomain() {
+        return this.DOMAIN;
+    }
+    isReady() {
+        return this.isReadyVal;
+    }
+    ready(handler) {
+        this.addEvent('ready', handler);
+    }
+    getScrollSize() {
+        return {
+            scrollWidth: Math.max(document.documentElement.scrollWidth, document.documentElement.offsetWidth),
+            scrollHeight: Math.max(document.documentElement.scrollHeight, document.documentElement.offsetHeight)
+        };
+    }
+    init(callback) {
+        if (callback) {
+            this.addEvent('init', callback);
+        }
+    }
+    install(callback) {
+        if (callback) {
+            this.addEvent('install', callback);
+        }
+    }
+    callBind(event, handler, auth_type, callback) {
+        if (!this.isInit) {
+            this.init(() => {
+                this.callBind(event, handler, auth_type, callback);
+            });
+        }
+        else if (this.isAdmin()) {
+            const params = {
+                event: event || '',
+                handler: handler || '',
+                auth_type: (typeof auth_type == 'undefined') ? 0 : auth_type
+            };
+            return this.callMethod('event.bind', params, callback);
+        }
+        return false;
+    }
+    installFinish() {
+        this.sendMessage('setInstallFinish', {});
+    }
+    resizeWindow(width, height, cb) {
+        if (width > 0 && height > 0) {
+            this.sendMessage('resizeWindow', { width: width, height: height }, cb);
+        }
+    }
+    fitWindow(cb) {
+        this.sendMessage('resizeWindow', {
+            width: '100%', height: this.getScrollSize().scrollHeight
+        }, cb);
+    }
+    closeApplication(cb) {
+        this.sendMessage('closeApplication', {}, cb);
+    }
+    reloadWindow(cb) {
+        this.sendMessage('reloadWindow', {}, cb);
+    }
+    setTitle(title, cb) {
+        this.sendMessage('setTitle', { title: title }, cb);
+    }
+    scrollParentWindow(scroll, cb) {
+        if (scroll > 0) {
+            this.sendMessage('setScroll', { scroll: scroll }, cb);
+        }
+    }
+}
+exports.baseBX24 = baseBX24;

package/dist/bin/test_.js

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+"use strict";
+console.log("console.log output");

package/dist/callResult.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallResult = void 0;
+class CallResult {
+    constructor(data, config, status) {
+        this.answer = data;
+        this.query = config;
+        this.status = status;
+        if (typeof this.answer.next != 'undefined') {
+            this.answer.next = parseInt(this.answer.next);
+        }
+        if (typeof this.answer.error != 'undefined') {
+            this.answer.ex = new ajaxError(this.status, typeof this.answer.error == 'string' ? this.answer : this.answer.error);
+        }
+    }
+    data() {
+        return this.answer.result;
+    }
+    error() {
+        return this.answer.ex;
+    }
+    error_description() {
+        return this.answer.error_description;
+    }
+    more() {
+        return !isNaN(this.answer.next);
+    }
+    total() {
+        return parseInt(this.answer.total);
+    }
+}
+exports.CallResult = CallResult;
+class ajaxError {
+    constructor(status, ex) {
+        this.status = status;
+        this.ex = ex;
+    }
+    getError() {
+        return this.ex;
+    }
+    getStatus() {
+        return this.status;
+    }
+    toString() {
+        return this.ex.error +
+            (this.ex.error_description ? ': ' + this.ex.error_description : '') +
+            ' (' + this.status + ')';
+    }
+}

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchHelper = exports.BX24Dev = exports.BX24Server = exports.BX24 = void 0;
+var BX24_1 = require("./BX24");
+Object.defineProperty(exports, "BX24", { enumerable: true, get: function () { return BX24_1.BX24; } });
+var BX24Server_1 = require("./BX24Server");
+Object.defineProperty(exports, "BX24Server", { enumerable: true, get: function () { return BX24Server_1.BX24Server; } });
+var BX24Dev_1 = require("./BX24Dev");
+Object.defineProperty(exports, "BX24Dev", { enumerable: true, get: function () { return BX24Dev_1.BX24Dev; } });
+var BatchHelper_1 = require("./BatchHelper");
+Object.defineProperty(exports, "BatchHelper", { enumerable: true, get: function () { return BatchHelper_1.BatchHelper; } });

package/dist/types/authBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/authBaseDev.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/authBaseServe.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/batchElement.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bitrixEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/eventElement.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/getAuth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/index.ts

@@ -0,0 +1,4 @@
+export { BX24 } from "./BX24";
+export { BX24Server } from "./BX24Server";
+export { BX24Dev} from './BX24Dev';
+export { BatchHelper} from './BatchHelper';

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@slavmak2486/bx24ts",
+  "version": "1.0.0",
+  "description": "Library for bitrix24",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "start": "ts-node index.ts",
+    "build": "tsc",
+    "test": "jest"
+  },
+  "bin": {
+    "github-pages-commit": "bin/test.js"
+  },
+  "keywords": [
+    "bitrix24",
+    "b24",
+    "rest"
+  ],
+  "author": "dc",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^27.4.1",
+    "@types/lodash": "^4.14.179",
+    "@types/qs": "^6.9.7",
+    "@typescript-eslint/eslint-plugin": "^5.13.0",
+    "@typescript-eslint/parser": "^5.13.0",
+    "axios-mock-adapter": "^1.20.0",
+    "eslint": "^8.10.0",
+    "jest": "^27.5.1",
+    "nodemon": "^2.0.15",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.6.0",
+    "typescript": "^4.6.2"
+  },
+  "dependencies": {
+    "axios": "^0.26.0",
+    "lodash": "^4.17.21",
+    "primeflex": "^3.1.3",
+    "qs": "^6.10.3"
+  }
+}

package/tests/batchHelper.test.ts

@@ -0,0 +1,47 @@
+import {BatchHelper} from '../BatchHelper';
+import {batchCmdElement} from '../types/batchElement';
+
+test('batchHelper test 50', async () => {
+    const testBatch:batchCmdElement={};
+    for (let idx=0; idx<50; idx++){
+        testBatch[`test_${idx}`]=['method', {params:true}];
+    }
+
+    let helper=new BatchHelper();
+    const arrBatch=helper.addToBatch(testBatch).getArrBatches();
+    expect(Array.isArray(arrBatch)).toBe(true);
+    expect(JSON.stringify(arrBatch)).toBe(JSON.stringify([testBatch]));
+});
+
+test('batchHelper test 100', async () => {
+    let helper=new BatchHelper();
+    let testBatch:batchCmdElement={};
+    for (let idx=0; idx<50; idx++){
+        testBatch[`test_${idx}`]=['method', {params:true}];
+    }
+    helper.addToBatch(testBatch);
+    let testBatch2:batchCmdElement={};
+    for (let idx=0; idx<50; idx++){
+        testBatch2[`test2_${idx}`]=['method', {params:true}];
+    }
+    const arrBatch=helper.addToBatch(testBatch2).getArrBatches();
+    expect(Array.isArray(arrBatch)).toBe(true);
+    expect(JSON.stringify(arrBatch)).toBe(JSON.stringify([testBatch, testBatch2]));
+});
+
+test('batchHelper test 3', async () => {
+    let helper=new BatchHelper();
+    helper.addToBatch({test_1:['method', {params:true}]});
+    helper.addToBatch({test_2:['method', {params:true}]});
+    helper.addToBatch({test_3:['method', {params:true}]});
+    const arrBatch=helper.getArrBatches();
+
+    const result=[{
+        test_1:['method', {params:true}],
+        test_2:['method', {params:true}],
+        test_3:['method', {params:true}]
+    }];
+
+    expect(Array.isArray(arrBatch)).toBe(true);
+    expect(JSON.stringify(arrBatch)).toBe(JSON.stringify(result));
+});

package/tests/callBatch.test.ts

@@ -0,0 +1,69 @@
+import {BX24Dev} from '../index';
+import axios from 'axios';
+import MockAdapter from "axios-mock-adapter";
+import batch from './mocks/batch'
+import dealList from './mocks/dealList';
+import leadList from './mocks/leadList';
+
+
+let mock:MockAdapter;
+
+beforeAll(() => {
+    mock = new MockAdapter(axios);
+});
+
+afterEach(() => {
+    mock.reset();
+});
+
+test('Test callMethod Promise', async () => {
+    mock.onPost('https://oauth.bitrix.info/oauth/token/').reply(201, {
+        access_token: 'fd3228620053e0720050316c00000035403803bb4a6d911ce347871d1b0234b40e5ddf',
+        expires: Math.ceil((new Date().valueOf()+3*60*1000)/1000),
+        expires_in: 3600,
+        scope: 'app',
+        domain: 'oauth.bitrix.info',
+        server_endpoint: 'https://oauth.bitrix.info/rest/',
+        status: 'F',
+        client_endpoint: 'https://d-clouds.bitrix24.ru/rest/',
+        member_id: 'a76802b13260c2689c0bf5ac801b714c',
+        user_id: 53,
+        refresh_token: 'edb14f620053e0720050316c000000354038034cf993a3d9379c29b612936b7112a9e2'
+    });
+    mock.onPost('https://d-clouds.bitrix24.ru/rest/batch.json').reply(200, batch);
+
+    const bx24=new BX24Dev({
+        access_token: "b0a727620053e0720050316c00000035403803b931cc9602df09ed4f1eb241c4a94505",
+        domain: "d-clouds.bitrix24.ru",
+        expires_in: 1614674265580,
+        member_id: "a76802b13260c2689c0bf5ac801b714c",
+        refresh_token: "a0264f620053e0720050316c00000035403803d6bcb8f3b4d91a311957f0b24c3b3b2e",
+        client_id:'app.60791f505183d4.54860773',
+        client_secret:'FtMCVDUy5NE28jk0AgqykSlddlAFymlGI6jY0ALbJqlORY0t2m'
+    });
+    const promise= bx24.callBatch({
+        getDeals:['crm.deal.list', {}],
+        getLeads:['crm.lead.list', {}],
+        getByID:['crm.deal.get', {id:123123}]
+    });
+    // .data()).toEqual();
+
+    
+    const result=await promise;
+    expect(result['getDeals'].data()).toEqual(dealList.result);
+    expect(result['getLeads'].data()).toEqual(leadList.result);
+
+    expect(result['getDeals'].total()).toEqual(dealList.total);
+    expect(result['getLeads'].total()).toEqual(leadList.total);
+
+    expect(result['getDeals'].error()).toBeUndefined();
+    expect(result['getLeads'].error()).toBeUndefined();
+    expect(result.getByID.error()).toEqual({
+        status: 200,
+        ex: { error: '', error_description: 'Not found' }
+    });
+
+
+    // expect(result).toEqual(batchFormated);
+    // expect(result.total()).toEqual(dealList.total);
+});