bx-rest 0.0.1

package/.editorconfig

@@ -0,0 +1,17 @@
+# Editor configuration, see https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ts]
+quote_type = single
+semi = false
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Aricatofuka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "bx-rest",
+  "version": "0.0.1",
+  "description": "bitrix rest api",
+  "main": "index.ts",
+  "dependencies": {
+    "entities": "^4.5.0",
+    "luxon": "^3.3.0",
+    "parse5": "^7.1.2",
+    "just-clone": "^6.2.0",
+    "safevalues": "^0.3.4",
+    "just-compare": "^2.3.0",
+    "rxjs": "^7.8.1",
+    "zone.js": "^0.13.1",
+    "tslib": "^2.6.1"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aricatofuka/bx-rest.git"
+  },
+  "keywords": [
+    "bitrxi",
+    "rest",
+    "api"
+  ],
+  "author": "Aricatofuka",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Aricatofuka/bx-rest/issues"
+  },
+  "homepage": "https://github.com/Aricatofuka/bx-rest#readme"
+}

package/src/const/time.ts

@@ -0,0 +1,3 @@
+export const time = {
+  oneDayMilliseconds: 1000 * 60 * 60 * 24
+}

package/src/rest/user/user.ts

@@ -0,0 +1,341 @@
+import { Observable, of, take } from 'rxjs'
+import { first, map, mergeMap, tap } from 'rxjs/operators'
+import clone from 'just-clone'
+import compare from 'just-compare'
+import { iBXGetParam } from '@/typification/rest/user/get'
+import HttpBXServices from '@/lib/services/api/bitrix/http/HttpBX'
+import UserFilterSearch from '@/lib/typification/bitrix/api/rest/user/UserFilterSearch'
+import ImgServices from '@/lib/services/api/bitrix/custom/img'
+import { Store } from '@ngrx/store'
+import { loadAll, saveArr, saveIDLoadedDepartment, saveSelf, storeUsers } from '@/lib/store/users'
+import { iCustomUserFieldInfo } from '@/lib/typification/bitrix/api/rest/user/CustomUserFieldInfo'
+import { DatePipe } from '@angular/common'
+import { BitrixApiUserMapServices } from '@/lib/services/map/bitrix/api/rest/user'
+import DateTrace from '@/lib/services/api/trace/metods/date'
+import { $get, $list, $search, $update, $user } from '@/lib/services/api/bitrix/rest/consts/part-name-metods'
+import SnackBarService from '@/lib/services/snack-bar/snack-bar.service'
+import iHttpAnswerBX from '@/lib/typification/bitrix/api/rest/base/httpAnswerBX'
+import { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '@/lib/typification/bitrix/api/rest/user/user'
+
+export class BXRestUser {
+    url = {
+        admin: [$user, 'admin'],
+        get: [$user, $get],
+        self: [$user, 'current'],
+        update: [$user, $update],
+        search: [$user, $search],
+        access: [$user, 'access'], // U1 - пользователь с id =1
+        // AU - все авторизованные пользователи
+        // D1 - подразделение с id=1
+        // G1 - группа с id=1
+        fields: [$user, 'fields'],
+        userfield: {
+            list: [$user, 'userfield', $list]
+        }
+    }
+
+    def: { params: { ACTIVE: 1, start: 0 } } = {
+        params: {ACTIVE: 1, start: 0}
+    }
+
+    user$: Observable<storeUsers>
+
+    constructor(
+        private http: HttpBXServices,
+        private snackBar: SnackBarService,
+        private img: ImgServices,
+        private dateTrace: DateTrace,
+        private store: Store<{ users: storeUsers }>,
+        private userMap: BitrixApiUserMapServices,
+        private datePipe: DatePipe
+    ) {
+        this.user$ = this.store.select('users')
+    }
+
+    get(params: iBXGetParam = {}): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> {
+        let copyParams = clone(params)
+        this.setDefParam(copyParams)
+        return this.http.post<iHttpAnswerBX<iBXRestUserHttp[]> | undefined>
+        (this.url.get, copyParams, 'Не удалось получить пользователей')
+            .pipe(
+                tap(v => {
+                    if (v && v.result) {
+                        this.saveArrUser(v.result)
+                    }
+                })
+            )
+    }
+
+    getOnePage(page: number = 1) {
+        return this.get({start: (page - 1) * 50}).pipe(
+            map(v => {
+                let res = this.http.mapResult(v)
+                return (res) ? res.map(r => this.userMap.HttpToBX(r)) : undefined
+            })
+        )
+    }
+
+    getByID(id: number, reload = true): Observable<iBXRestUser | undefined> {
+        return this.getByIDs([id], reload).pipe(map(v => (v && v.length) ? v[0] : undefined))
+    }
+
+    getByIDs(ids: number[], reload = true): Observable<iBXRestUser[] | undefined> {
+        ids = Array.from(new Set(ids))
+        return this.user$.pipe(
+            take(1),
+            mergeMap(v => {
+                if (!reload) {
+                    let find = v.data.filter(i => ids.includes(i.ID))
+                    if (find && find.length === ids.length) {
+                        return of(find)
+                    }
+                }
+                return this.getAll({ID: ids, ACTIVE: 2}).pipe(map(v => (v && v.length) ? v : undefined))
+            })
+        )
+    }
+
+    getSelf(update = false) {
+        if (update) {
+            return this.getSelfHttp()
+        } else {
+            return this.user$.pipe(
+                mergeMap(v => {
+                    if (v && v.self) {
+                        return of(v.self)
+                    } else {
+                        return this.getSelfHttp()
+                    }
+                }),
+                first()
+            )
+        }
+    }
+
+    getSelfHttp() {
+        return this.http.get<iHttpAnswerBX<iBXRestUserHttp>>
+        (this.url.self, {}, 'Не удалось получить пользователя')
+            .pipe(
+                map(v => {
+                    if (v && v.result) {
+                        return this.userMap.HttpToBX(v.result)
+                    }
+                    return undefined
+                }),
+                tap(v => {
+                    if (v) {
+                        this.store.dispatch(saveSelf({self: v}))
+                    }
+                }),
+            )
+    }
+
+    access(access: string[], textError = 'Не удалось получить права') {
+        return this.http.get<iHttpAnswerBX<boolean> | undefined>(this.url.access, {ACCESS: access}, textError).pipe(
+            map(v => this.http.mapResult(v))
+        )
+    }
+
+    getByDepartment(id: number[] | number): Observable<iBXRestUser [] | undefined> {
+        const ids: number[] = (typeof id === 'number') ? [id] : id
+        return this.user$.pipe(
+            first(),
+            mergeMap(
+                v => {
+                    if (v.load.all) {
+                        return of(clone(v.data.filter(i => ids.find(id => i.UF_DEPARTMENT.includes(id)))))
+                    }
+                    if (ids.every(i => v.load.department.includes(i))) {
+                        return of(clone(v.data.filter(i => ids.find(id => i.UF_DEPARTMENT.includes(id)))))
+                    }
+                    return this.getAll({UF_DEPARTMENT: ids}).pipe(tap(_ => {
+                        this.store.dispatch(saveIDLoadedDepartment({id: ids}))
+                    }))
+                })
+        )
+    }
+
+    getAll(params: iBXGetParam = {}): Observable<iBXRestUser [] | undefined> {
+        if (!Object.keys(params).length) {
+            params = clone(this.def.params)
+        }
+
+        const saveAllUser = compare(params, this.def.params)
+        return this.user$.pipe(
+            take(1),
+            mergeMap(v => {
+                if (v.load.all) {
+                    if (compare(this.def.params, params)) {
+                        return of(clone(v.data))
+                    }
+                }
+
+                return this.getEndArray(params).pipe(
+                    take(1),
+                    map(v => {
+                        if (v && v.result) {
+                            let cl = clone(v.result)
+                            return this.saveArrUser(cl)
+                        }
+                        return undefined
+                    }),
+                )
+            }),
+            tap(v => {
+                if (v && v.length && saveAllUser) {
+                    this.store.dispatch(loadAll({load: true}))
+                }
+                params.start = this.def.params.start
+            })
+        )
+    }
+
+    getAllByPersonalBirthday(day: number | undefined = undefined, month: number | undefined = undefined, checkWeekend = false) {
+        return this.http.timeNowOnServer().pipe(
+            mergeMap(date => {
+                if (date) {
+                    let daySent = (day) ? day : date.getDate()
+                    let start = date.getFullYear() + 1
+                    let monthSent = (month) ? month : date.getMonth() + 1
+                    let arr: string[] = Array.from(Array(200).keys()).map(_ => {
+                        start--
+                        let res = this.datePipe.transform(new Date(start, monthSent - 1, daySent), 'YYYY-MM-dd')
+                        return (res) ? res : ''
+                    })
+                    // TODO: Упростить
+                    if (checkWeekend && date.getDay() === 1) {
+                        start = date.getFullYear() + 1
+                        arr.push(
+                            ...Array.from(Array(200).keys()).map(_ => {
+                                start--
+                                let res = this.datePipe.transform(new Date(start, monthSent - 1, daySent - 1), 'YYYY-MM-dd')
+                                return (res) ? res : ''
+                            })
+                        )
+                        start = date.getFullYear() + 1
+                        arr.push(
+                            ...Array.from(Array(200).keys()).map(_ => {
+                                start--
+                                let res = this.datePipe.transform(new Date(start, monthSent - 1, daySent - 2), 'YYYY-MM-dd')
+                                return (res) ? res : ''
+                            })
+                        )
+                    }
+                    return this.getAll({PERSONAL_BIRTHDAY: arr})
+                }
+                this.snackBar.warning('Не удалось получить время сервера')
+                return of(undefined)
+            })
+        )
+    }
+
+    saveArrUser(users: iBXRestUserHttp[]) {
+        let result: iBXRestUser [] = []
+        for (const user of users) {
+            result.push(this.userMap.HttpToBX(user))
+        }
+        this.store.dispatch(saveArr({arr: result}))
+
+        return result
+    }
+
+    search(params: string | UserFilterSearch): Observable<iBXRestUser [] | undefined> {
+        if (typeof params === 'string') {
+            params = {FIND: params}
+        }
+        if (typeof params.ACTIVE !== 'boolean') {
+            params.ACTIVE = true
+        }
+        return this.http.get<iHttpAnswerBX<iBXRestUserHttp[]>>(this.url.search, params, 'Сервер не отвечает на запрос поиска')
+            .pipe(
+                map(v => {
+                    if (v && v.result) {
+                        const mapResult = this.http.mapResult(v)
+                        if (mapResult) {
+                            return this.saveArrUser(mapResult)
+                        }
+                    }
+                    return undefined
+                })
+            )
+    }
+
+    fields(): Observable<iBXRestUserHttpField | undefined> {
+        return this.http.get<iHttpAnswerBX<iBXRestUserHttpField>>(this.url.fields).pipe(
+            map(v => this.http.mapResult(v))
+        )
+    }
+
+    update(user: iBXRestUser, fieldUpdate: string[]): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> {
+        if (fieldUpdate && fieldUpdate.length) {
+            let sendData: any = {
+                ID: user.ID,
+            }
+            const userBX = this.userMap.BXtoHttp(user)
+            for (const field of fieldUpdate) {
+                if (userBX[field]) {
+                    sendData[field] = userBX[field]
+                } else {
+                    this.snackBar.error('Одно из указанных полей отправлено не верно')
+                }
+            }
+            return this.http.post(this.url.update, sendData, 'Не удалось обновить пользователя с ID' + user.ID)
+        } else {
+            this.snackBar.error('Не указано ни одно поле для редактирования пользователя')
+            return of({})
+        }
+    }
+
+    getEndArray(params: UserFilter = {}): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> {
+        return this.get(params).pipe(
+            mergeMap(items => {
+                if (items && items.result && typeof items.result === 'object') {
+                    if (items.next) {
+                        params.start = items.next
+                        return this.getEndArray(params).pipe(map(vEnd => {
+                            if (vEnd && items.result && vEnd.result) {
+                                return {result: [...items.result, ...vEnd.result]}
+                            }
+                            return (items) ? items : undefined
+                        }))
+                    }
+                    return of(items)
+                } else {
+                    return of(undefined)
+                }
+            }),
+        )
+    }
+
+    getUrlCompressedImage(url: string, width: number, height: number) {
+        return this.img.getUrlCompressed(url, width, height)
+    }
+
+    setDefParam(params: iBXGetParam) {
+        if (!params.hasOwnProperty('ACTIVE')) {
+            params.ACTIVE = this.def.params.ACTIVE
+        }
+        if (params.ACTIVE && params.ACTIVE === 2) {
+            delete params.ACTIVE
+        }
+        if (!params.hasOwnProperty('start')) {
+            params.start = this.def.params.start
+        }
+
+        if (params.UF_DEPARTMENT && !params.UF_DEPARTMENT.length) {
+            delete params.UF_DEPARTMENT
+        }
+    }
+
+    getInfoAboutCustomFieldsBX() {
+        return this.http.get<iHttpAnswerBX<iCustomUserFieldInfo[]>>(this.url.userfield.list).pipe(
+            map(v => this.http.mapResult(v))
+        )
+    }
+
+    itIsAdmin() {
+        return this.http.get<iHttpAnswerBX<boolean>>(this.url.admin).pipe(
+            map(v => this.http.mapResult(v))
+        )
+    }
+}

package/src/services/base.ts

@@ -0,0 +1,187 @@
+import { Injectable } from '@angular/core'
+import { time } from '@/const/time'
+// import { environment } from '@/environments/environment'
+import { DateTime } from 'luxon'
+import { DateTimeOptions } from 'luxon/src/datetime'
+
+@Injectable({
+    providedIn: 'root'
+})
+export class BaseServices {
+
+    toStr(val: any): string {
+        return (val) ? String(val) : ''
+    }
+
+    toNumber(val: any): number {
+        return (val && Number(val)) ? Number(val) : 0
+    }
+
+    toDate(val: number | string | Date, format?: string, opt?: DateTimeOptions): Date {
+        if (val instanceof Date) {
+            return val
+        } else if (typeof val == 'string') {
+            if (format) {
+                if (opt) {
+                    return DateTime.fromFormat(val, format, opt).toJSDate()
+                }
+                return DateTime.fromFormat(val, format).toJSDate()
+            } else {
+                return new Date(val)
+            }
+        } else if (typeof val == 'number') {
+            return new Date(val)
+        }
+        console.error('Wrong date format', val, format)
+        throw 'Wrong date format'
+    }
+
+    getBXStrTime(date: Date): string {
+        return this.toISOStringWithTimezone(date)
+    }
+
+    toISOStringWithTimezone(date: Date): string {
+        const tzOffset = -date.getTimezoneOffset()
+        const diff = tzOffset >= 0 ? '+' : '-'
+        const pad = (n: number) => `${Math.floor(Math.abs(n))}`.padStart(2, '0')
+        return date.getFullYear() +
+            '-' + pad(date.getMonth() + 1) +
+            '-' + pad(date.getDate()) +
+            'T' + pad(date.getHours()) +
+            ':' + pad(date.getMinutes()) +
+            ':' + pad(date.getSeconds()) +
+            diff + pad(tzOffset / 60) +
+            ':' + pad(tzOffset % 60)
+    };
+
+    toBool(val: any) {
+        switch (typeof val) {
+            case 'string':
+                val = val.toLowerCase()
+                if (val === 'n' || val === 'y') { // битриксовые понятия о bool
+                    return val === 'y'
+                } else if (val === 'true' || val === 'false') { // битриксовые понятия о bool
+                    return val === 'true'
+                } else {
+                    return false
+                }
+            default:
+                return Boolean(val)
+        }
+    }
+
+    toBXYorN(val: boolean) {
+        return (val) ? 'Y' : 'N'
+    }
+
+    typeof(val: any) {
+        return typeof val
+    }
+
+    typeDefClass(val: object): undefined | null | 'date' {
+        if (val) {
+            if (val instanceof Date) {
+                return 'date'
+            }
+            return undefined
+        } else {
+            return null
+        }
+    }
+
+    toJSON(val: object) {
+        return JSON.stringify(val)
+    }
+
+    fromJSON<T>(val: string): T | undefined {
+        return JSON.parse(val)
+    }
+
+    prepareBaseAddress(url: string, add: string = '') {
+        if (url.search('https://') !== 0 && url.search('http://')) {
+            url = 'https://' + url
+        }
+
+        if (url.lastIndexOf('/') !== (url.length - 1)) {
+            url = url + '/'
+        }
+
+        url = url + add
+
+        return url
+    }
+
+    getHomeAddress() {
+        // return this.prepareBaseAddress(environment.urls.home)
+        return this.prepareBaseAddress('b24.trace-studio.com')
+    }
+
+    dateDiff(a: Date, b: Date) {
+        return new Date(a.valueOf() - b.valueOf())
+    }
+
+    dateDiffInDays(a: Date, b: Date) {
+        return Math.floor(this.dateDiff(a, b).valueOf() / time.oneDayMilliseconds);
+    }
+
+    getBase64File(file: File) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader()
+            reader.readAsDataURL(file)
+            reader.onload = () => resolve(reader.result)
+            reader.onerror = error => reject(error)
+        })
+    }
+
+    async getBase64FileLikeStr(file: File): Promise<{ header: string, val: string } | undefined> {
+        let result = await this.getBase64File(file)
+        if (typeof result === 'string') {
+            let split = result.split(',')
+            return {
+                header: split[0],
+                val: split[1]
+            }
+        }
+        return undefined
+    }
+
+    sumArray(numbers: number[]) {
+        return numbers.reduce((a, b) => {
+            return a + b;
+        })
+    }
+
+    isItTheSameDate(date1: Date, date2: Date) {
+        return date1.getDate() === date2.getDate()
+            && date1.getMonth() === date2.getMonth()
+            && date1.getFullYear() === date2.getFullYear()
+    }
+
+    toUnix(date: Date) {
+        return Math.floor(date.valueOf() / 1000)
+    }
+
+    arrSum(x: number[]) {
+        let s = 0;
+        for (let i = 0; i < x.length; i++) {
+            s += x[i]
+        }
+        return s
+    }
+
+    getBaseUrlHttps(url: string, component = false) {
+        if (component) {
+            return encodeURI(this.cropUrl(url) + '/');
+        } else {
+            return encodeURI('https://' + this.cropUrl(url) + '/');
+        }
+    }
+
+    cropUrl(url: string) {
+        url = (url) ? url.replace('https://', '') : ''
+        url = (url) ? url.replace('http://', '') : ''
+        url = (url) ? url.replace('https:', '') : ''
+        url = (url) ? url.replace('http:', '') : ''
+        return url
+    }
+}