@slavmak2486/bx24ts 1.0.8 → 1.1.0

package/BX24.ts

@@ -1,5 +1,7 @@
+import { reject } from "lodash";
 import { baseBX24 } from "./base/BX24";
 import { AuthBase } from "./types/authBase";
+import { getAuth } from "./types/getAuth";
 
 export class BX24 extends baseBX24{
     constructor(cb?:(params:any)=>void){
@@ -87,6 +89,19 @@ export class BX24 extends baseBX24{
         }
     }
 
+    refreshAuthAsync(): Promise<getAuth> {
+        return new Promise((resolve, reject)=>{
+            let isExeted=false;
+            this.refreshAuth(newAuth=>{
+                isExeted=true;
+                resolve(newAuth);
+            })
+            setTimeout(() => {
+                if (!isExeted) reject('refresh auth timeout!')
+            }, 5000);
+        });
+    }
+
     refreshAuth(cb?:(params: any) => void){
         this.sendMessage('refreshAuth', {}, (result:any)=>{
             this.AUTH_ID=result.AUTH_ID;

package/BX24Dev.ts

@@ -1,5 +1,4 @@
 import { BX24Server } from "./BX24Server";
-import qs from 'qs';
 import { set as __set } from "lodash";
 import { AuthBaseDev } from "./types/authBaseDev";
 
@@ -13,10 +12,12 @@ export class BX24Dev extends BX24Server{
                 getAppOption:['app.option.get', {}],
                 getUserOption:['user.option.get', {}]
             }, ress=>{
-                for (const idx in ress){
+                let idx: keyof typeof ress;
+                let textError='';
+                for (idx in ress){
                     const res=ress[idx];
                     if (res.error()){
-                        console.error(res.error());
+                        textError+=`Init error. Check auth data. ${res.error()} for ${idx}\n`;
                     }
                     else{
                         if (idx=='getAppOption'){
@@ -27,7 +28,9 @@ export class BX24Dev extends BX24Server{
                         }
                     }
                 }
-
+                if (textError)
+                    console.error(textError);
+                    
                 if (cb){
                     cb();
                 }
@@ -36,13 +39,12 @@ export class BX24Dev extends BX24Server{
         });
 
         if (new Date().getTime()-5*60*1000>this.AUTH_EXPIRES && !param.noUpdateRefresh){
-            try {
-                this.refreshAuth(()=>{
-                    this.doInit();
-                });
-            } catch (error) {
+            this.refreshAuthAsync().then(()=>{
+                this.doInit();
+            })
+            .catch((error:Error)=>{
                 this.logger.error(error);
-            }
+            });
         }
         else{            
             this.doInit();
@@ -93,10 +95,10 @@ export class BX24Dev extends BX24Server{
 
     private getPlacementOptions(){
         const result:{[key:string]:any}={};
-        const url=new URL(location.href) as any;
-        const entrity=url.searchParams.entries();
+        const url=typeof location!=='undefined'?new URL(location.href) as any:undefined;
+        const entrity=url?url.searchParams.entries():undefined;
         const regexp=/\[([^\]]*)]/g;
-        let done=false;
+        let done=entrity?false:true;
         while(!done){
             const el=entrity.next();
             done=el.done===true?true:false;
@@ -132,7 +134,7 @@ export class BX24Dev extends BX24Server{
         }
 
 
-        window.open(`?${qs.stringify(params)}`);
+        window.open(`?${this.getHttpString(params)}`);
     }
 
     openPath(path:string, cb?:(params:any)=>void):void{

package/BX24Server.ts

@@ -1,7 +1,6 @@
 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";
 
@@ -116,20 +115,29 @@ export class BX24Server extends baseBX24{
         });
     }
 
-    refreshAuthAsync():Promise<getAuth|false> {
+    refreshAuthAsync():Promise<getAuth> {
         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
+                method:'refresh_token',
+                data:{
+                    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());
+                const authArr=this.getAuth();
+                if (authArr===false){
+                    reject('Refresh auth undefined error!');
+                }
+                else{
+                    resolve(authArr);
+                }
             })
             .catch(err=>{
                 reject (err);

package/auth.ts

@@ -0,0 +1,13 @@
+export default {
+    access_token: 'a123b123c123d123e123f123g123h123a123b123c123d123e123f123g123h123456789',
+    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://example.bitrix24.ru/rest/',
+    member_id: 'a123b123c123d123e123f123g123h123',
+    user_id: 1,
+    refresh_token: 'abc123456789d123456789ef123456789g123456789h123456789i123456789j123456'
+}

package/base/BX24.ts

@@ -1,12 +1,11 @@
-import { AuthBase } from "../types/authBase";
 import { batchCmdElement } from "../types/batchElement";
 import { eventElement } from "../types/eventElement";
 
-import axios, { Axios, AxiosRequestConfig, AxiosResponse } from 'axios';
+import axios, { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 import { CallResult } from "../callResult";
-import qs from 'qs';
-import {get as __get} from 'lodash'
+import {cloneDeep, get as __get} from 'lodash'
 import { logger } from "../types/authBaseServe";
+import { getAuth } from "../types/getAuth";
 
 // проблемы декларирования методов HTMLElement
 declare global{
@@ -57,6 +56,23 @@ export abstract class baseBX24{
 
     isReadyVal=false; //check
 
+    getHttpString(value:any, prefix=''):string{
+        if (value instanceof Date){
+            return prefix+'='+value.toISOString();
+        }
+        else if (typeof value=='object'){
+            const resultObj=[];
+            for (const field in value){
+                resultObj.push(this.getHttpString(value[field], prefix+`${prefix!=''?'[':""}${field}${prefix!=''?']':''}`));
+            }
+            return resultObj.join('&');
+        }
+        else if (prefix!=''){
+            return prefix+'='+value;
+        }
+        return value;
+    }
+
 
     isFunction(item:any){
         return item === null ? false : (typeof (item) == "function" || item instanceof Function);
@@ -104,7 +120,7 @@ export abstract class baseBX24{
     }
 
     abstract sendMessage(cmd:string, params:any, cb?:(params:any)=>void):void
- 
+
     constructor(){
         this.DOMAIN="";
         this.PROTOCOL=1;
@@ -193,32 +209,41 @@ export abstract class baseBX24{
 		return;
 	}
 
-    abstract refreshAuth(cb?:(params:any)=>void):void
+    abstract refreshAuth(cb?:(params:any)=>void):void;
+    abstract refreshAuthAsync():Promise<getAuth>;
 
     protected callSuccess(xhr:AxiosResponse):boolean{
         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;
     }
 
-    protected call(url:string, config:any):Promise<CallResult>{
+    protected call(url:string, config:{
+        method:string,
+        data:any,
+        callback?:(params: any)=>void
+    }):Promise<CallResult>{
         return new Promise((resolve, reject)=>{
-            config.auth=this.AUTH_ID;
+            const params=cloneDeep(config.data);
+            params.auth=this.AUTH_ID;
             if (this.AUTH_CONNECTOR){
-                config.auth_connector=this.AUTH_CONNECTOR;
+                params.auth_connector=this.AUTH_CONNECTOR;
             }
             const options:AxiosRequestConfig = {
                 method: 'POST',
                 headers: { 'content-type': 'application/x-www-form-urlencoded' },
-                data: qs.stringify(config),
+                data: this.getHttpString(params),
                 url:url
             };
 
             axios(options).then(res=>{
                 const data = res.data;
-                const result = new CallResult(data, config, res.status);
+                const result = new CallResult(data, config, this, res.status);
                 resolve(result);
             })
-            .catch(err=>{
-                if (__get(err, ['response','data','error'], undefined)=='expired_token'&&!url.includes('oauth.bitrix.info/oauth/token/')){
+            .catch((err:AxiosError)=>{
+                if (!err?.response?.data){
+                    reject(err);
+                }
+                else if (__get(err, ['response','data','error'], undefined)=='expired_token'&&!url.includes('oauth.bitrix.info/oauth/token/')){
                     try {
                         this.refreshAuth(()=>{
                             this.call(url, config).then(resolve).catch(reject);
@@ -228,7 +253,7 @@ export abstract class baseBX24{
                     }
                 }
                 else{
-                    reject(__get(err, ['response','data'], 'unknown error')); 
+                    reject(__get(err, ['response','data'], err.message)); 
                 }           
             });
         });
@@ -240,25 +265,37 @@ export abstract class baseBX24{
 		: false;
     }
 
-    callBatch(cmd:batchCmdElement, haltOnError?:boolean):Promise<{[key:string|number]:CallResult}>;
-    callBatch(cmd:batchCmdElement, cb:(params:{[key:string|number]:CallResult})=>void|boolean, haltOnError?:boolean):void;
-    callBatch(cmd:batchCmdElement, haltOnError?:boolean):Promise<{[key:string|number]:CallResult}>;
-    callBatch(cmd:batchCmdElement, cb:(params:{[key:string|number]:CallResult})=>void|boolean, haltOnError?:boolean):void;
-    callBatch(
-            cmd:batchCmdElement, 
-            cb?:((params:{[key:string|number]:CallResult})=>void)|boolean, 
-            haltOnError=false):void|Promise<{[key:string|number]:CallResult
-            }>{
+    // callBatch(cmd:batchCmdElement, haltOnError?:boolean):Promise<{[key:string|number]:CallResult}>;
+    // callBatch(cmd:batchCmdElement, cb:(params:{[key:string|number]:CallResult})=>void|boolean, haltOnError?:boolean):void;
+    // callBatch(cmd:batchCmdElement, haltOnError?:boolean):Promise<{[key:string|number]:CallResult}>;
+    // callBatch(cmd:batchCmdElement, cb:(params:{[key:string|number]:CallResult})=>void|boolean, haltOnError?:boolean):void;
+    // callBatch(
+    //         cmd:batchCmdElement, 
+    //         cb?:((params:{[key:string|number]:CallResult})=>void)|boolean, 
+    //         haltOnError=false):void|Promise<{[key:string|number]:CallResult
+    //         }>
+    callBatch<T extends batchCmdElement>(cmd:T, haltOnError?:boolean):Promise<{[key in keyof T]:CallResult}>
+    callBatch<T extends batchCmdElement>(cmd:T, cb:(params:{[key in keyof T]:CallResult})=>void):void
+    callBatch<T extends batchCmdElement>(cmd:T, cb:(params:{[key in keyof T]:CallResult})=>void, haltOnError:boolean):void
+    callBatch<T extends batchCmdElement>(
+        cmd:T,
+        cb?:((params:{[key in keyof T]:CallResult})=>void)|boolean,
+        haltOnError=false
+    ):void|Promise<{[key in keyof T]:CallResult}>
+            {
                 const startCb=cb;
                 const startHaltOnError=haltOnError;
                 if (typeof cb == 'boolean'){
                     haltOnError=cb;
                     cb=undefined;
                 }
+                else{
+                    cb=cb as (params:{[key in keyof T]:CallResult})=>void;
+                }
         
-                const comands:{
-                    [key:number|string]:string
-                }={};
+                const comands:Partial<{
+                    [key in keyof T]:string
+                }>={};
                 let cnt=0;
                 
                 for(const idx in cmd){
@@ -274,56 +311,80 @@ export abstract class baseBX24{
                     if(method)
                     {
                         cnt++;
-                        comands[idx] = `${method}?${qs.stringify(params)}`;
+                        comands[idx] = `${method}?${this.getHttpString(params)}`;
                     }
                 }
 
                 if (cnt>0){
                     const url=`http${this.PROTOCOL?'s':''}://${this.DOMAIN}${this.PATH}/batch.json`;
                     const params={
-                        cmd:comands,
+                        cmd:comands as {
+                            [key in keyof T]:string
+                        },
                         halt:haltOnError?1:0
                     };
 
                     if (!startCb){
                         if (this.AUTH_EXPIRES<(new Date()).valueOf()){
                             return new Promise((resolve, reject)=>{
-                                try {
-                                    this.refreshAuth(()=>{
-                                        this.callBatch(cmd, startHaltOnError).then(res=>{                            
-                                            resolve(res);
-                                        })
-                                        .catch(err=>{
-                                            reject(err);
-                                        })
-                                    });
-                                } catch (error) {
+                                this.refreshAuthAsync().then(()=>{
+                                    this.callBatch(cmd, startHaltOnError).then(res=>{                            
+                                        resolve(res);
+                                    })
+                                    .catch(err=>{
+                                        reject(err);
+                                    })
+                                })
+                                .catch((error:Error)=>{
                                     reject(error);
-                                }
-                                
-                            });                
+                                });
+                            });
                         }
                         else{
                             return new Promise((resolve, reject)=>{
-                                this.call(url, params).then(res=>{
-                                    resolve(this.formatResultForBatch(res, params));
+                                this.call(url, {
+                                    method:'batch',
+                                    data: params,
+                                }).then(res=>{
+                                    resolve(this.formatResultForBatch(res, cmd));
                                 })
+                                .catch(reject)
                             });
                         }
                     }
                     else if (typeof startCb=='function'){
                         if (this.AUTH_EXPIRES<(new Date()).valueOf()){
-                            this.refreshAuth(()=>{
+                            this.refreshAuthAsync().then(()=>{
                                 this.callBatch(cmd, startCb, startHaltOnError);
+                            })
+                            .catch(error=>{
+                                console.error(error);
                             });
                         }
                         else{
-                            this.call(url, params).then(res=>{
+                            this.call(url, {
+                                method:'batch',
+                                data:params,
+                                callback: startCb
+                            }).then(res=>{
                                 if (typeof cb =='function')
-                                    cb(this.formatResultForBatch(res, params, cb));
+                                    cb(this.formatResultForBatch(res, cmd, cb));
                             })
                             .catch(err=>{
-                                throw err;
+                                if (err instanceof Error){
+                                    throw err;
+                                }
+                                const result=this.formatResultForBatch(
+                                    new CallResult(err, {
+                                        method:'batch',
+                                        data:params
+                                    }, this, 500),
+                                    cmd,
+                                    cb as (params:any)=>void
+                                );
+                                if (typeof cb ==='function')
+                                    cb(result);
+                                return false;
                             })
                         }
                     }
@@ -331,32 +392,54 @@ export abstract class baseBX24{
                 else{
                     return;
                 }
-
-
     }
 
-    formatResultForBatch(res:any, params:any, callback?:(params:any)=>void):{[key:string|number]:CallResult}{
+    formatResultForBatch<T extends CallResult, R extends batchCmdElement>(
+        res:T, 
+        calls:R,
+        callback?:(params:any)=>void)
+        :{[key in keyof R]:CallResult}
+    {
         const data = res.data();
-        const calls=params&&params.cmd?params.cmd:[];
 
-        const result:{[key:string|number]:CallResult}={};
+        const result:Partial<{[key in keyof R]:CallResult}>={};
         for(const idx in calls){
-            if (typeof data.result[idx]!=='undefined'|| typeof data.result_error[idx]!=='undefined'){
-                const query=calls[idx].split('?');
+            const cmd=calls[idx];
+            if (data?.result?.[idx]|| data?.result_error?.[idx]){
                 result[idx]=new CallResult({
-                    result: typeof data.result[idx]!=='undefined'?data.result[idx]:{},
+                    result: data.result?.[idx]||{},
                     error:data.result_error[idx]||undefined,
                     total:data.result_total[idx],
+                    time:data.result_time[idx],
                     next: data.result_next[idx]
                 }, {
-                    method:query[0],
-                    data: query[1],
+                    method:Array.isArray(cmd)?cmd[0]:cmd?.method,
+                    data: Array.isArray(cmd)?cmd[1]:cmd?.params,
                     callback:callback
-                }, res.status)
+                }, this, res.status)
+            }
+            else{
+                result[idx]={
+                    data:()=>({}),
+                    total:()=>0,
+                    error_description:()=>'Incorrect response from bitrix24',
+                    answer:data?.result?.[idx],
+                    query: {
+                        method:Array.isArray(cmd)?cmd[0]:cmd?.method,
+                        data: Array.isArray(cmd)?cmd[1]:cmd?.params,
+                        callback:callback
+                    },
+                    next:()=>false,
+                    bx24:this,
+                    time:()=>({}),
+                    status:res.status,
+                    more:()=>false,
+                    error:()=>`Incorect response from bitrix24`
+                };
             }
         }
         
-        return result;
+        return result as { [key in keyof R]: CallResult; };
     }
 
     
@@ -383,27 +466,40 @@ export abstract class baseBX24{
                 });                
             }
             else{
-                return this.call(url, params);
+                return this.call(url, {
+                    method,
+                    data:params
+                });
             }
         }
-        else if (cb){
+        else {
             if (this.AUTH_EXPIRES<(new Date()).valueOf()){
                 this.refreshAuth(()=>{
                     this.callMethod(method, params, cb);
                 });
             }
             else{
-                this.call(url, params).then(res=>{
-                    cb(res);
+                this.call(url, {
+                    method,
+                    data:params,
+                    callback:cb
+                }).then(res=>{
+                    return cb(res);
                 })
                 .catch(err=>{
-                    cb(new CallResult(err, params, 500));
+                    if (err instanceof Error){
+                        throw err;
+                    }
+                    else{
+                        cb(new CallResult(err, {
+                            data:params,
+                            method,
+                            callback:cb
+                        }, this, 500));
+                    }
                 })
             }
         }
-        else{
-            throw new Error("Incorrect params");                
-        }
     }
 
     //Getters

package/batchAppOption.ts

@@ -0,0 +1,40 @@
+export default {
+    result: {
+        result: { getAppOption: [], getUserOption: [] },
+        result_error: [],
+        result_total: [],
+        result_next: [],
+        result_time: {
+            getAppOption: {
+                start: 1670906729.0897441,
+                finish: 1670906729.090286,
+                duration: 0.00054192543029785156,
+                processing: 5.6028366088867188e-5,
+                date_start: "2022-12-13T07:45:29+03:00",
+                date_finish: "2022-12-13T07:45:29+03:00",
+                operating_reset_at: 1670907329,
+                operating: 0,
+            },
+            getUserOption: {
+                start: 1670906729.0914669,
+                finish: 1670906729.096303,
+                duration: 0.0048360824584960938,
+                processing: 0.0002598762512270312,
+                date_start: "2022-12-13T07:45:29+03:00",
+                date_finish: "2022-12-13T07:45:29+03:00",
+                operating_reset_at: 1670907329,
+                operating: 0,
+            },
+        },
+    },
+    time: {
+        start: 1670906729.028657,
+        finish: 1670906729.100661,
+        duration: 0.072004079818725586,
+        processing: 0.010973930358886719,
+        date_start: "2022-12-13T07:45:29+03:00",
+        date_finish: "2022-12-13T07:45:29+03:00",
+        operating_reset_at: 1670907329,
+        operating: 0,
+    },
+};

package/callResult.ts

@@ -1,30 +1,42 @@
+import { baseBX24 } from "./base/BX24";
+import { cloneDeep } from "lodash";
 
 
 export class CallResult{
     answer:any;
-    query:any;
+    query:{
+        method:string,
+        data:any,
+        callback?:(params: any)=>void
+    };
     status:number;
+    bx24:baseBX24;
 
-    constructor(data:any, config:any, status:number){
+    constructor(data:any, config:{
+        method:string,
+        data:any,
+        callback?:(params: any)=>void
+    }, bx24:baseBX24, status:number){
         this.answer=data;
         this.query=config;
         this.status=status;
+        this.bx24=bx24;
 
-        if(typeof this.answer.next != 'undefined'){
+        if(this.answer?.next){
             this.answer.next = parseInt(this.answer.next);
         }
 
-        if(typeof this.answer.error != 'undefined'){
+        if(this.answer?.error){
             this.answer.ex = new ajaxError(this.status, typeof this.answer.error == 'string' ? this.answer : this.answer.error)
         }
     }
 
     data(){
-        return this.answer.result;
+        return this.answer?.result;
     }
 
     error(){
-        return this.answer.ex;
+        return this.answer?.ex;
     }
 
     error_description(){
@@ -35,25 +47,27 @@ export class CallResult{
         return !isNaN(this.answer.next);
     }
 
+    time(){
+        return this.answer.time;
+    }
+
     total(){
         return parseInt(this.answer.total);
     }
 
-    // next(cb:CallableFunction){
-    //     if(this.more())
-    //     {
-    //         this.query.start = this.answer.next;
-
-    //         if(!!cb && util.type.isFunction(cb))
-    //         {
-    //             this.query.callback = cb;
-    //         }
-
-    //         return ajax(this.query);
-    //     }
+    next(){
+        if(!this.more()) return false;
 
-    //     return false;
-    // }
+        const params=cloneDeep(this.query.data);
+        params.start=this.answer.next;
+        if (this.query.callback){
+            this.bx24.callMethod(this.query.method, params, this.query.callback);
+            return true;
+        }
+        else{
+            return this.bx24.callMethod(this.query.method, params);
+        }
+    }
 }
 
 interface exErrorInterface{