bx-rest 0.0.1

package/src/services/http/HttpData.ts

@@ -0,0 +1,142 @@
+import { BaseServices } from '@/services/base'
+import { HttpParams } from '@angular/common/http'
+import { iHttpParamSettings } from '@/typification/rest/settings'
+import iHttpAnswerBX from '@/typification/rest/base/httpAnswerBX'
+
+export class HttpData extends BaseServices {
+
+    defSettings: iHttpParamSettings = {
+        timeZone: {
+            calc: true,
+            levelOut: false
+        }
+    }
+
+    getHttpParamsGet( // не так уж и сложно сделать сложенный HttpParams, да гугл?
+        obj: any,
+        sendHttpParams: HttpParams = new HttpParams(),
+        thisArray = false,
+        nesting: string[] = [],
+        // settings = this.defSettings
+        _ = this.defSettings
+    ): any {
+        for (const key in obj) {
+            let setKey = ''
+            if (nesting.length) {
+                let first = nesting[0]
+                setKey = (nesting.length > 1)
+                    ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                    : first + '[' + key + ']'
+            } else {
+                setKey = key
+            }
+            switch (typeof obj[key]) {
+                case 'string':
+                    sendHttpParams = sendHttpParams.set(setKey, obj[key])
+                    break
+                case 'symbol':
+                case 'number':
+                case 'bigint':
+                case 'boolean':
+                    sendHttpParams = sendHttpParams.set(setKey, String(obj[key]))
+                    break
+                case 'object':
+                    nesting.push(key)
+                    sendHttpParams = this.getHttpParamsGet(obj[key], sendHttpParams, false, nesting)
+                    nesting.pop()
+                    break
+                case 'function':
+                case 'undefined':
+                default:
+                    console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj)
+            }
+        }
+        return sendHttpParams
+    }
+
+    getHttpParamsPost(
+        obj: any,
+        sendHttpParams: FormData = new FormData(),
+        thisArray = false,
+        nesting: string[] = [],
+        settings = this.defSettings
+    ): any {
+
+        if (obj instanceof Blob) {
+            let first = nesting[0]
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first
+            sendHttpParams.set(setKey, obj)
+            return sendHttpParams
+        } else if (obj instanceof Date) {
+            let first = nesting[0]
+            let tzoffset = (settings.timeZone.calc) ?  obj.getTimezoneOffset() * 60000 : 0 // вычисляем влияние часового пояса
+            let levelOut = (settings.timeZone.levelOut) ?  obj.getTimezoneOffset() * 60000 : 0 // вычисляем влияние часового пояса
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first
+            sendHttpParams.set(setKey, (new Date(obj.valueOf() + tzoffset - levelOut)).toISOString())
+            return sendHttpParams
+        } else {
+            for (const key in obj) {
+                let setKey = ''
+                if (nesting.length) {
+                    let first = nesting[0]
+                    setKey = (nesting.length > 1)
+                        ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                        : first + '[' + key + ']'
+                } else {
+                    setKey = key
+                }
+                switch (typeof obj[key]) {
+                    case 'string':
+                        sendHttpParams.set(setKey, obj[key])
+                        break
+                    case 'symbol':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
+                        sendHttpParams.set(setKey, String(obj[key]))
+                        break
+                    case 'object':
+                        nesting.push(key)
+                        sendHttpParams = this.getHttpParamsPost(
+                            obj[key],
+                            sendHttpParams,
+                            false,
+                            nesting,
+                            settings
+                        )
+                        nesting.pop()
+                        break
+                    case 'function':
+                    case 'undefined':
+                    default:
+                        console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj)
+                }
+            }
+        }
+        return sendHttpParams
+    }
+
+    mapResult<T>(v: iHttpAnswerBX<T> | undefined): T | undefined {
+        if (v && (v.result || typeof v.result === 'boolean')) {
+            return v.result
+        }
+        return undefined
+    }
+
+    sliceArrayIntoChunks(arr: any[], chunkSize: number) {
+        const res = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize);
+            res.push(chunk);
+        }
+        return res;
+    }
+
+    removingMultipleSlashes(str: string) {
+        return str.replace(/\/{2,}/g, '/')
+    }
+}

package/src/services/http/base/HttpData.ts

@@ -0,0 +1,140 @@
+import BaseServices from '@/lib/services/base'
+import { HttpParams } from '@angular/common/http'
+import { iHttpParamSettings } from '@/lib/typification/bitrix/api/rest/settings'
+import iHttpAnswerBX from '@/lib/typification/bitrix/api/rest/base/httpAnswerBX';
+
+export class HttpData extends BaseServices {
+
+    defSettings: iHttpParamSettings = {
+        timeZone: {
+            calc: true
+        }
+    }
+
+    getHttpParamsGet( // не так уж и сложно сделать сложенный HttpParams, да гугл?
+        obj: any,
+        sendHttpParams: HttpParams = new HttpParams(),
+        thisArray = false,
+        nesting: string[] = [],
+        // settings = this.defSettings
+        _ = this.defSettings
+    ): any {
+        for (const key in obj) {
+            let setKey = ''
+            if (nesting.length) {
+                let first = nesting[0]
+                setKey = (nesting.length > 1)
+                    ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                    : first + '[' + key + ']'
+            } else {
+                setKey = key
+            }
+            switch (typeof obj[key]) {
+                case 'string':
+                    sendHttpParams = sendHttpParams.set(setKey, obj[key])
+                    break
+                case 'symbol':
+                case 'number':
+                case 'bigint':
+                case 'boolean':
+                    sendHttpParams = sendHttpParams.set(setKey, String(obj[key]))
+                    break
+                case 'object':
+                    nesting.push(key)
+                    sendHttpParams = this.getHttpParamsGet(obj[key], sendHttpParams, false, nesting)
+                    nesting.pop()
+                    break
+                case 'function':
+                case 'undefined':
+                default:
+                    console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj)
+            }
+        }
+        return sendHttpParams
+    }
+
+    getHttpParamsPost(
+        obj: any,
+        sendHttpParams: FormData = new FormData(),
+        thisArray = false,
+        nesting: string[] = [],
+        settings = this.defSettings
+    ): any {
+
+        if (obj instanceof Blob) {
+            let first = nesting[0]
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first
+            sendHttpParams.set(setKey, obj)
+            return sendHttpParams
+        } else if (obj instanceof Date) {
+            let first = nesting[0]
+            let tzoffset = (settings.timeZone.calc) ?  obj.getTimezoneOffset() * 60000 : 0 // вычисляем влияние часового пояса
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first
+            sendHttpParams.set(setKey, (new Date(obj.valueOf() + tzoffset)).toISOString())
+            return sendHttpParams
+        } else {
+            for (const key in obj) {
+                let setKey = ''
+                if (nesting.length) {
+                    let first = nesting[0]
+                    setKey = (nesting.length > 1)
+                        ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                        : first + '[' + key + ']'
+                } else {
+                    setKey = key
+                }
+                switch (typeof obj[key]) {
+                    case 'string':
+                        sendHttpParams.set(setKey, obj[key])
+                        break
+                    case 'symbol':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
+                        sendHttpParams.set(setKey, String(obj[key]))
+                        break
+                    case 'object':
+                        nesting.push(key)
+                        sendHttpParams = this.getHttpParamsPost(
+                            obj[key],
+                            sendHttpParams,
+                            false,
+                            nesting,
+                            settings
+                        )
+                        nesting.pop()
+                        break
+                    case 'function':
+                    case 'undefined':
+                    default:
+                        console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj)
+                }
+            }
+        }
+        return sendHttpParams
+    }
+
+    mapResult<T>(v: iHttpAnswerBX<T> | undefined): T | undefined {
+        if (v && (v.result || typeof v.result === 'boolean')) {
+            return v.result
+        }
+        return undefined
+    }
+
+    sliceArrayIntoChunks(arr: any[], chunkSize: number) {
+        const res = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize);
+            res.push(chunk);
+        }
+        return res;
+    }
+
+    removingMultipleSlashes(str: string) {
+        return str.replace(/\/{2,}/g, '/')
+    }
+}

package/src/services/http/base/base.ts

@@ -0,0 +1,39 @@
+import { iHttpParamSettings } from '@/typification/rest/settings'
+import { HttpClient } from '@angular/common/http'
+import SnackBarService from '@/services/snack-bar/snack-bar.service'
+import { Observable, of, } from 'rxjs'
+import { HttpData } from '@/services/http/HttpData'
+import { Injectable } from '@angular/core'
+
+@Injectable({
+    providedIn: 'root'
+})
+export abstract class BaseHttp extends HttpData {
+
+    protected constructor(public http: HttpClient, public snackBar: SnackBarService) {
+        super()
+    }
+
+    abstract httpGet<T>(
+        url: string,
+        params: any,
+        textError: string,
+        settings: iHttpParamSettings
+    ): Observable<T | undefined>
+
+    abstract httpPost<T>(url: string,
+                       params: any ,
+                       textError: string,
+                       settings: iHttpParamSettings
+    ): Observable<T | undefined>
+
+    handleError<T>(
+        result?: T,
+        textError = 'получения данных') {
+        return (error: Error): Observable<T> => {
+            console.error(`failed: ${error.message}`)
+            this.snackBar.error('Ошибка: ' + textError)
+            return of(result as T)
+        };
+    }
+}

package/src/services/http/base/http.ts

@@ -0,0 +1,67 @@
+import { Observable, throwError } from 'rxjs'
+import { catchError } from 'rxjs/operators'
+import { HttpParams } from '@angular/common/http'
+import { iHttpParamSettings } from '@/typification/rest/settings'
+import { BaseHttp } from '@/services/http/base/base'
+
+export class BaseHttpServices extends BaseHttp {
+
+    public httpGet<T>(
+        url: string,
+        params = {},
+        textError = '',
+        settings: iHttpParamSettings = this.defSettings
+    ): Observable<T | undefined> {
+        return this.http.get<T | undefined>(url, {
+            params: this.getHttpParamsGet(params, new HttpParams(), false, [], settings)
+        }).pipe(
+            catchError(err => {
+                if (!textError.length && err.error.error_description) {
+                    textError = err.error.error_description
+                }
+
+                this.snackBar.error('Ошибка: ' + textError)
+                return throwError(() => err)
+            })
+        )
+    }
+
+    public httpPost<T>(url: string,
+                       params: any = {},
+                       textError = '',
+                       settings: iHttpParamSettings = this.defSettings
+    ): Observable<T | undefined> {
+        return this.http.post<T | undefined>(
+            url,
+            this.getHttpParamsPost(params, new FormData(), false, [], settings)
+        ).pipe(
+            catchError(err => {
+                if (!textError.length && err.error.error_description) {
+                    textError = err.error.error_description
+                }
+
+                this.snackBar.error('Ошибка: ' + textError)
+                console.error(err)
+                return throwError(() => err)
+            })
+        )
+    }
+
+    // TODO: доделать
+    // httpPostBaseWithFile<T>(url: string,
+    //                         params: any = {},
+    //                         textError = ''): Observable<T | undefined> {
+    //     let searchFile = Object.values(params).find((i: any) => i instanceof Blob)
+    //     if (searchFile) {
+    //         return this.http.post<T | undefined>(url, this.getHttpParamsPost(params)).pipe(
+    //             catchError(err => {
+    //                 this.snackBar.error('Ошибка: ' + textError)
+    //                 console.error(err)
+    //                 return throwError(() => err)
+    //             })
+    //         )
+    //     } else {
+    //         return this.httpPost(url, params, textError)
+    //     }
+    // }
+}

package/src/services/http/http.ts

@@ -0,0 +1,182 @@
+import { Observable, throwError, take, mergeMap, forkJoin } from 'rxjs'
+import { catchError, map } from 'rxjs/operators'
+import { Injectable } from '@angular/core'
+import { HttpClient } from '@angular/common/http'
+import SnackBarService from '@/lib/services/snack-bar/snack-bar.service'
+import SessionKeyServices from '@/lib/services/api/bitrix/http/sessionKey'
+import clone from 'just-clone'
+import { iHttpParamSettings } from '@/lib/typification/bitrix/api/rest/settings'
+import BaseHttpServices from '@/lib/services/http/http'
+import {
+    iBatchRequestAnswer, iBatchRequestParam,
+    iBatchRequestParamArr,
+    iBatchRequestParamHttp, keyBatch
+} from '@/lib/typification/bitrix/api/rest/batch/batchRequestParam'
+import flatten from 'just-flatten-it'
+
+@Injectable({
+    providedIn: 'root'
+})
+export default class HttpServices extends BaseHttpServices {
+
+    constructor(http: HttpClient, snackBar: SnackBarService, public session: SessionKeyServices) {
+        super(http, snackBar)
+    }
+
+    timeNowOnServer() {
+        return this.httpGet<{ result?: Date, error?: string }>('server.time').pipe(
+            map(v => {
+                if (v && v.result) {
+                    return new Date(v.result)
+                }
+                return undefined
+            }),
+        )
+    }
+
+    /**
+     * Это пиздец а не метод
+     * @param param
+     */
+    branch<T, A>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): Observable<iBatchRequestAnswer<A>[] | undefined> {
+        let prepareParam = Object.entries<string>(this.prepareBatch<T>(param))
+        const size = 50 // больше не отдаст
+        let subarray = [] //массив в который будет выведен результат.
+        for (let i = 0; i < Math.ceil(prepareParam.length / size); i++) {
+            subarray[i] = prepareParam.slice((i * size), (i * size) + size)
+        }
+
+        return forkJoin(
+            subarray.map(i => {
+                return this.httpPost('batch.json', {
+                    halt: 0,
+                    cmd: Object.assign({}, ...i.map(x => {
+                        return {[x[0]]: x[1]}
+                    }))
+                })
+            })
+        ) as Observable<iBatchRequestAnswer<A>[]>
+    }
+
+    prepareBatch<T>(param: iBatchRequestParamArr<T> | iBatchRequestParam<T>[]): iBatchRequestParamHttp {
+        let res: iBatchRequestParamHttp = Object.keys(param).reduce(
+            (obj, key) => {
+                obj[key] = '';
+                return obj;
+            },
+            {} as iBatchRequestParamHttp
+        );
+        for (let key in param) {
+            if(typeof key === 'string' || typeof key === 'number' && param[key].param) {
+                res[key] = param[key].name + '?' + this.getHttpParamsGet(param[key].param).toString()
+            }
+        }
+        return res
+    }
+
+    mapBranchResult<T>(res: iBatchRequestAnswer<T>[]){
+        return Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined)) as {[key:keyBatch]: T}
+    }
+
+    mapBranchResultWithoutKey<T>(res: iBatchRequestAnswer<T>[]): T[]{
+        return flatten<T>(Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined)))
+    }
+
+    post<T>(name: string[],
+            params: any = {},
+            textError = '',
+            settings: iHttpParamSettings = this.defSettings) {
+        return this.httpPost<T>(this.getNameMethod(name), params, textError, settings)
+    }
+
+    get<T>(name: string[],
+           params: any = {},
+           textError = '',
+           settings: iHttpParamSettings = this.defSettings) {
+        return this.httpGet<T>(this.getNameMethod(name), params, textError, settings)
+    }
+
+    override httpPost<T>(url: string,
+                         params: any = {},
+                         textError = '',
+                         settings: iHttpParamSettings = this.defSettings
+    ): Observable<T | undefined> {
+        return this.session.getAuthParams().pipe(
+            mergeMap(auth => {
+                if (auth) {
+                    const paramsClone = clone(params)
+                    paramsClone[this.session.getKeyAuth()] = auth
+                    return this.session.getBaseUrl().pipe(mergeMap(v => {
+                        if (v) {
+                            return this.http.post<T | undefined>(
+                                this.prepareBaseAddress(v) + url,
+                                this.getHttpParamsPost(paramsClone, new FormData(), false, [], settings))
+                                .pipe(
+                                    take(1),
+                                    catchError(err => {
+                                        if (!textError.length && err.error.error_description) {
+                                            textError = err.error.error_description
+                                        }
+
+                                        this.snackBar.error('Ошибка: ' + textError)
+                                        return throwError(() => err)
+                                    })
+                                )
+                        }
+                        return throwError(() => 'get base url error')
+                    }))
+                } else {
+                    this.snackBar.error('Error: Auth not get')
+                    return throwError(() => 'auth not get')
+                }
+            }))
+    }
+
+    override httpGet<T>(
+        url: string,
+        params: any = {},
+        textError = '',
+        settings: iHttpParamSettings = this.defSettings
+    ): Observable<T | undefined> {
+        return this.session.getAuthParams().pipe(
+            mergeMap(auth => {
+                if (auth) {
+                    if (params === null) {
+                        params = {}
+                    }
+                    const paramsClone = clone(params)
+                    paramsClone[this.session.getKeyAuth()] = auth
+                    let options = {
+                        params: this.getHttpParamsGet(paramsClone)
+                    }
+
+                    return this.session.getBaseUrl().pipe(
+                        mergeMap(v => {
+                            if (v) {
+                                return this.http.get<T>(this.prepareBaseAddress(v) + url, options).pipe(
+                                    take(1),
+                                    catchError(err => {
+                                        if (!textError.length && err.error.error_description) {
+                                            textError = err.error.error_description
+                                        }
+
+                                        this.snackBar.error('Ошибка: ' + textError)
+                                        return throwError(() => err)
+                                    }))
+                            }
+                            return throwError(() => 'get base url error')
+                        })
+                    )
+                } else {
+                    this.snackBar.error('Error: Auth not get')
+                    return throwError(() => 'auth not get')
+                }
+            })
+        )
+    }
+
+    getNameMethod(arr: string[]) {
+        return arr.join('.')
+    }
+
+}

package/src/services/snack-bar/snack-bar.service.ts

@@ -0,0 +1,40 @@
+/**
+ * Сервис для вывода сообщений пользователю
+ * TODO: логирование
+ */
+import { Injectable } from '@angular/core'
+import { ToastMessageComponent } from '@/lib/services/snack-bar/toast-message/toast-message.component'
+import { MatSnackBar } from '@angular/material/snack-bar'
+
+@Injectable({
+  providedIn: 'root'
+})
+export default class SnackBarService {
+
+  constructor(private snackBar: MatSnackBar) {
+  }
+
+  error(message: string, sec = 12): void {
+    this.standardMessage(message, sec, 'error')
+  }
+
+  warning(message: string, sec = 7): void {
+    this.standardMessage(message, sec, 'warning');
+  }
+
+  success(message: string, sec = 7): void {
+    this.standardMessage(message, sec, 'success');
+  }
+
+  standardMessage(message: string, sec = 5, name = 'error'): void{
+    this.snackBar.open(message);
+    this.snackBar.openFromComponent(ToastMessageComponent, {
+      duration: sec * 1000,
+      data: {
+        message: message,
+        type: name
+      },
+      panelClass: name + '-box'
+    });
+  }
+}

package/src/services/snack-bar/toast-message/toast-message.component.html

@@ -0,0 +1,13 @@
+<div class="w-100 d-flex">
+  <span matSnackBarLabel [class]="getClass()">
+  {{ data.message }}
+</span>
+  <span matSnackBarActions [class]="getClass()">
+  <button mat-button matSnackBarAction (click)="snackBarRef.dismissWithAction()">
+    <mat-icon>
+      close
+    </mat-icon>
+  </button>
+</span>
+</div>
+

package/src/services/snack-bar/toast-message/toast-message.component.scss

@@ -0,0 +1,53 @@
+:host {
+
+  display: flex;
+  background-color: red;
+
+  .mdc-snackbar__surface{
+    padding: 0;
+    margin: 0;
+  }
+  .error-message {
+    color: red;
+  }
+  &.error-box {
+    background-color: #eec1c1;
+
+    .error-message {
+      color: red;
+    }
+  }
+}
+
+mat-snack-bar-container.mdc-snackbar {
+
+  &.error-box {
+    .mdc-snackbar__surface{
+      background-color: #eec1c1;
+    }
+
+    .error-message {
+      color: red;
+    }
+  }
+
+  &.warning-box {
+    .mdc-snackbar__surface {
+      background-color: #f0f2b9;
+    }
+
+    .warning-message {
+      color: #15140f;
+    }
+  }
+
+  &.success-box {
+    .mdc-snackbar__surface {
+      background-color: #daf7d1;
+    }
+
+    .success-message {
+      color: #423f31;
+    }
+  }
+}