@slavmak2486/bx24ts 1.0.0

package/.env

@@ -0,0 +1 @@
+getOptions=true

package/.eslintrc.json

@@ -0,0 +1,22 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true,
+        "node": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "no-undef":"off"
+    }
+}

package/BX24.ts

@@ -0,0 +1,131 @@
+import { baseBX24 } from "./base/BX24";
+import { AuthBase } from "./types/authBase";
+
+export class BX24 extends baseBX24{
+    constructor(cb?:(params:any)=>void){
+        super();
+        const q = window.name.split('|');
+        this.DOMAIN = q[0].replace(/:(80|443)$/, '');
+        this.PROTOCOL = parseInt(q[1])||0;
+        this.APP_SID = q[2];
+        if (window&&window instanceof Window){
+            window.addEventListener("message", (event:MessageEvent)=>{
+                this.runCallback(event);
+            });
+            
+            if(!this.DOMAIN||!this.LANG||!this.AUTH_ID){                    
+                this.sendMessage('getInitData', this.defaultValueFromIframe);
+            }
+        }            
+
+        this.utilReady();
+        if (cb){
+            this.init(cb);
+        }
+    }
+
+
+    defaultValueFromIframe(data:any){
+        if(!this.DOMAIN)
+            this.DOMAIN = data.DOMAIN;
+        if(!this.PATH)
+            this.PATH = data.PATH;
+        if(!this.LANG)
+            this.LANG = data.LANG;
+        if(!this.PLACEMENT)
+            this.PLACEMENT = data.PLACEMENT;
+
+        this.PROTOCOL = data.PROTOCOL;
+        this.DOMAIN = this.DOMAIN.replace(/:(80|443)$/, '');
+
+        if(data.AUTH_ID){
+            this.AUTH_ID = data.AUTH_ID;
+            this.REFRESH_ID = data.REFRESH_ID;
+            this.AUTH_EXPIRES = (new Date()).valueOf()+data.AUTH_EXPIRES*1000;
+            this.IS_ADMIN = !!data.IS_ADMIN;
+            this.MEMBER_ID = data.MEMBER_ID||'';
+        }
+
+        if(!this.USER_OPTIONS)
+            this.USER_OPTIONS = data.USER_OPTIONS;
+
+        if(!this.APP_OPTIONS)
+            this.APP_OPTIONS = data.APP_OPTIONS;
+
+        if(!this.PLACEMENT_OPTIONS)
+            this.PLACEMENT_OPTIONS = data.PLACEMENT_OPTIONS;
+
+        this.isInit = true;
+
+        if(data.FIRST_RUN && this.arrEvents.find(el=>{return el.event=='install'})){
+            this.emitEvent('install');
+        }
+        else
+        {
+            this.doInit();
+        }
+    }
+
+    runCallback(e:MessageEvent){
+        if(e.origin != 'http'+(this.PROTOCOL?'s':'')+'://'+this.DOMAIN)
+            return;
+    
+        if(e.data)
+        {
+            const r = e.data.split(":");
+            const cmd = [r[0],r.slice(1).join(":")];
+            let args = [];
+
+            const findedCb=this.cbArray.find(el=>{return el.uid==cmd[0]});
+    
+            if(findedCb)
+            {
+                if(findedCb)
+                    args = JSON.parse(cmd[1]);    
+                    findedCb.cb.call(this, args);
+            }
+        }
+    }
+
+    refreshAuth(cb?:(params: any) => void){
+        this.sendMessage('refreshAuth', {}, (result:any)=>{
+            this.AUTH_ID=result.AUTH_ID;
+            this.REFRESH_ID=result.REFRESH_ID;
+            this.AUTH_EXPIRES=(new Date()).valueOf()+result.AUTH_EXPIRES*1000;
+            if (cb){
+                cb(this.getAuth());
+            }
+        })
+    }
+
+    sendMessage(cmd: string, params: any, cb?: (args:any)=>void): void{
+        if(this.isFunction(params))
+        {
+            cb = params; params = null;
+        }
+    
+        cmd += ':' + (params ? JSON.stringify(params) : '')
+                + ':' + this.setCallback(cb)
+                + (this.APP_SID ? (':' + this.APP_SID) : '');
+    
+        parent.postMessage(cmd, 'http'+(this.PROTOCOL?'s':'')+'://' + this.DOMAIN);
+    }
+
+    openApplication(cb?:(params:any)=>void, settings?:any):void;
+    openApplication(params?:any, cb?:(params:any)=>void, settings?:any):void{
+        if (!params){
+            params={};
+        }
+
+        if (settings&&typeof(settings)=='object'){
+            for (const item in settings){
+                params["bx24_" + item]=settings[item];
+            }
+        }
+        this.sendMessage('openApplication', params, cb);
+    }
+
+    openPath(path:string, cb?:(params:any)=>void):void{
+        this.sendMessage('openPath', {path:path}, cb);
+    }
+}

package/BX24Dev.ts

@@ -0,0 +1,128 @@
+import { BX24Server } from "./BX24Server";
+import { AuthBaseServe} from "./types/authBaseServe";
+import qs from 'qs';
+import { set as __set } from "lodash";
+
+
+export class BX24Dev extends BX24Server{
+    constructor(param: AuthBaseServe, cb?:()=>void){
+        super(param, ()=>{
+            this.callBatch({
+                getAppOption:['app.option.get', {}],
+                getUserOption:['user.option.get', {}]
+            }, ress=>{
+                for (const idx in ress){
+                    const res=ress[idx];
+                    if (res.error()){
+                        console.error(res.error());
+                    }
+                    else{
+                        if (idx=='getAppOption'){
+                            this.APP_OPTIONS=res.data();
+                        }
+                        else{
+                            this.USER_OPTIONS=res.data();
+                        }
+                    }
+                }
+
+                if (cb){
+                    cb();
+                }
+                // this.init(cb);
+            })
+            this.getPlacementOptions();
+        });
+
+        
+    }
+
+    appOption={
+		get: (name:string)=>{
+			return this.APP_OPTIONS[name];
+		},
+		set:(name:string,value:any,cb:(params:any)=>void)=>{
+            if (this.isAdmin()){
+                const params:{[key:string]:any}={};
+                params[name]=value;
+                this.callMethod('app.option.set', params, res=>{
+                    if (res.data()===true){
+                        this.APP_OPTIONS[name] = value;
+                    }
+                    if (cb){
+                        cb(res);
+                    }
+                })
+            }
+			else{
+                console.error('Access denied!');
+            }
+		}
+	}
+
+    userOption={
+        get:(name:string)=>{
+            return this.USER_OPTIONS[name];
+        },
+        set:(name:string, value:any,cb:(params:any)=>void)=>{
+            const params:{[key:string]:any}={};
+            params[name]=value;
+            this.callMethod('user.option.set', params, res=>{
+                if (res.data()===true){
+                    this.USER_OPTIONS[name] = value;
+                }
+                if (cb){
+                    cb(res);
+                }
+            });
+        }
+    }
+
+    private getPlacementOptions(){
+        const result:{[key:string]:any}={};
+        const url=new URL(location.href) as any;
+        const entrity=url.searchParams.entries();
+        const regexp=/\[([^\]]*)]/g;
+        let done=false;
+        while(!done){
+            const el=entrity.next();
+            done=el.done===true?true:false;
+            if (el.value){
+                let tempArrPath=Array.from(el.value[0].matchAll(regexp)) as string[];
+                tempArrPath=tempArrPath.map(ell=>{return ell[1]});
+                const base=el.value[0].split('[')[0];
+                __set(result, [base, ...tempArrPath], el.value[1]);
+            }
+        }
+
+        if (result.placement){
+            this.PLACEMENT=result.placement;
+            delete(result.placement);
+        }
+        else{
+            this.PLACEMENT='DEFAULT';
+        }
+
+        this.PLACEMENT_OPTIONS=result;
+    }
+
+    openApplication(cb?:(params:any)=>void, settings?:any):void;
+    openApplication(params?:any, cb?:(params:any)=>void, settings?:any):void{
+        if (!params){
+            params={};
+        }
+
+        if (settings&&typeof(settings)=='object'){
+            for (const item in settings){
+                params["bx24_" + item]=settings[item];
+            }
+        }
+
+
+        window.open(`?${qs.stringify(params)}`);
+    }
+
+    openPath(path:string, cb?:(params:any)=>void):void{
+        window.open(`${this.PROTOCOL?'https:':'http'}${this.DOMAIN}${path}`);
+    }
+}

package/BX24Server.ts

@@ -0,0 +1,161 @@
+import { baseBX24 } from "./base/BX24";
+import { AuthBaseServe, logger } from "./types/authBaseServe";
+import {getAuth} from './types/getAuth';
+import { get as __get } from "lodash";
+import { CallResult } from "./callResult";
+import { BitrixEvent } from "./types/bitrixEvent";
+
+
+export class BX24Server extends baseBX24{
+
+    logger:logger=console;
+
+    constructor(param: AuthBaseServe, cb?:(params:any)=>void){
+        super();
+
+        if (param.auth_connector)
+            this.AUTH_CONNECTOR=param.auth_connector;
+            
+        if (param.logger)
+            this.logger=param.logger;
+
+        this.IS_ADMIN=param.isAdmin===false?false:true;
+        this.init(cb);
+        this.DOMAIN=param.domain;
+        if (param.member_id){
+            this.MEMBER_ID=param.member_id;
+        }
+        this.AUTH_EXPIRES=param.expires_in??0;
+        this.REFRESH_ID=param.refresh_token;
+        this.PROTOCOL=1;
+        this.AUTH_ID=param.access_token;
+
+
+        this.CLIENT_ID=param.client_id;
+        this.CLIENT_SECRET=param.client_secret;
+        this.isInit=true;
+
+        if (new Date().getTime()-5*60*1000>this.AUTH_EXPIRES && !param.noUpdateRefresh){
+            this.refreshAuth(()=>{
+                this.doInit();
+            });
+        }
+        else{            
+            this.doInit();
+        }
+
+    }
+
+    getOfflineEvents(debug=false, clear=true):Promise<CallResult>{
+        return new Promise((resolve)=>{
+            if (debug){
+                this.callMethod('event.offline.list', {}, ress=>{
+                    ress.answer.result={events:this.formatEvents(ress.answer.result)};
+                    resolve(ress);
+                });
+            }
+            else{
+                this.callMethod('event.offline.get', {clear:clear?1:0}, ress=>{
+                    ress.answer.result.events=this.formatEvents(ress.answer.result.events);
+                    resolve(ress);
+                })
+            }
+        });
+    }
+
+
+        // arrOfflineEvents [
+        //   {
+        //     ID: '133245',
+        //     TIMESTAMP_X: '2022-07-17T15:23:56+03:00',
+        //     EVENT_NAME: 'ONTASKUPDATE',
+        //     EVENT_DATA: {
+        //       FIELDS_BEFORE: [Object],
+        //       FIELDS_AFTER: [Object],
+        //       IS_ACCESSIBLE_BEFORE: 'undefined',
+        //       IS_ACCESSIBLE_AFTER: 'undefined'
+        //     },
+        //     EVENT_ADDITIONAL: { user_id: '41' },
+        //     MESSAGE_ID: '3d1c2a472b1c775f4d80a1c5918aa3c8',
+        //     PROCESS_ID: 'yxq61pfx5ikr7xw4csc6gsox9m3i1q8p',
+        //     ERROR: '0'
+        //   }
+        // ]
+    formatEvents(rawEvents:any):BitrixEvent[]{
+        const result:BitrixEvent[]=[];
+        for (const idx in rawEvents){
+            const tempEvent:BitrixEvent={
+                ID:Number(rawEvents[idx].ID),
+                TIMESTAMP_X:new Date(rawEvents[idx].TIMESTAMP_X),
+                EVENT_NAME:rawEvents[idx].EVENT_NAME                
+            }
+            if (rawEvents[idx].EVENT_DATA)
+                tempEvent.EVENT_DATA=rawEvents[idx].EVENT_DATA;
+            
+            if (rawEvents[idx].EVENT_ADDITIONAL)
+                tempEvent.EVENT_ADDITIONAL=rawEvents[idx].EVENT_ADDITIONAL;
+            
+            if (rawEvents[idx].MESSAGE_ID)
+                tempEvent.MESSAGE_ID=rawEvents[idx].MESSAGE_ID;
+
+            if (rawEvents[idx].PROCESS_ID)
+                tempEvent.PROCESS_ID=rawEvents[idx].PROCESS_ID;
+
+            if (rawEvents[idx].ERROR)
+                tempEvent.ERROR=Boolean(Number(rawEvents[idx].ERROR));
+            
+            result.push(tempEvent);
+        }
+        return result;
+    }
+
+    runCallback(e:MessageEvent){
+        this.logger.debug('callBack not allowed!');
+    }
+
+    onRefresh(cb:(params:getAuth)=>void){
+        this.addEvent('refreshAuth', cb);
+    }
+
+    refreshAuth(cb?:CallableFunction){
+        this.refreshAuthAsync()
+        .then(newAuth=>{
+            if (cb) cb(newAuth);
+        })
+        .catch(err=>{
+            throw err;
+        });
+    }
+
+    refreshAuthAsync():Promise<getAuth|false> {
+        return new Promise((resolve, reject) => {
+            this.call("https://oauth.bitrix.info/oauth/token/", {
+                grant_type: 'refresh_token',
+                client_id: this.CLIENT_ID,
+                client_secret: this.CLIENT_SECRET,
+                refresh_token: this.REFRESH_ID
+            })
+            .then(data=>{
+                this.AUTH_ID=data.answer.access_token;
+                this.REFRESH_ID=data.answer.refresh_token;
+                this.AUTH_EXPIRES=data.answer.expires*1000;
+                this.emitEvent('refreshAuth', this.getAuth());
+                resolve(this.getAuth());
+            })
+            .catch(err=>{
+                reject (err);
+            })
+        });
+    }
+
+
+
+    sendMessage(cmd: string, params: any, cb?: CallableFunction): void {
+        this.logger.log('sendMessage',{
+            cmd:cmd,
+            params:params,
+            cb:cb
+        });
+        if (cb) cb();
+    }
+}

package/BatchHelper.ts

@@ -0,0 +1,58 @@
+import {batchCmdElement} from './types/batchElement'
+
+export class BatchHelper{
+    arrBatch:batchCmdElement[];
+    currBatch:batchCmdElement;
+
+    constructor(){
+        this.arrBatch=[];
+        this.currBatch={};
+    }
+
+    addToBatch(batchElement:batchCmdElement){
+        if (Object.keys(batchElement).length>50){
+            throw new Error("batchElement more 50");            
+        }
+
+        if (50-Object.keys(this.currBatch).length<Object.keys(batchElement).length){
+            this.arrBatch.push(this.currBatch);
+            this.currBatch={};
+        }
+
+        for(const keyBatch in batchElement){
+            this.currBatch[keyBatch]=batchElement[keyBatch];
+        }
+
+        return this;
+    }
+
+    getArrBatches(){
+        if (Object.keys(this.currBatch).length>0){
+            this.arrBatch.push(this.currBatch);
+            this.currBatch={};
+        }
+
+        return this.arrBatch;
+    }
+
+    /**
+     * @param action - метод Bitrix24
+     * @param requestName - имя запроса в батче
+     * @param countRows - количество строк списочного метода
+     * @param params - дополнительные параметры
+     */
+    getBatchForLength(action:string, requestName:string, countRows:number, params = {}) {
+        var countBatch = Math.ceil(countRows / (50 * 50))
+        for (var i = 0; i < countBatch; i++) {
+            for (var j = 0; j < 50; j++) {
+                if (50 * 50 * i + j * 50 >= countRows) {
+                    break
+                }
+                const curParams = Object.assign({start:0}, params)
+                curParams['start'] = 50 * 50 * i + j * 50;
+                this.addToBatch({[requestName + j]:[action, curParams]});
+            }
+        }
+    }
+    
+}