tnx-shared 5.1.310 → 5.1.313

package/esm2015/services/user.service.js

@@ -96,6 +96,9 @@ export class UserService extends BaseService {
         const decoded = JWT.default(this._oauthService.getAccessToken());
         return decoded[key];
     }
+    getJwtDecoded() {
+        return JWT.default(this._oauthService.getAccessToken());
+    }
     handleUserInfoChange(data) {
         let dataObj;
         if (typeof data == 'string') {
@@ -588,4 +591,4 @@ UserService.ctorParameters = () => [
     { type: ExceptionHandlerService },
     { type: ApplicationContextService }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"../../../../projects/tnx-shared/src/lib/","sources":["services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\r\nimport { Injectable, Injector } from '@angular/core';\r\nimport { OAuthService } from 'angular-oauth2-oidc';\r\nimport * as JWT_ from 'jwt-decode';\r\nimport { catchError, map, retry, shareReplay } from 'rxjs/operators';\r\nimport { ApplicationContextService } from '../app-context/application-context.service';\r\nimport { ComCtxConstants } from '../configs/component-context.constant';\r\nimport { ModuleConfig } from '../configs/module-config';\r\nimport { BasicUserInfo } from '../models/basic-user-info';\r\nimport { Filter, GridInfo } from '../models/grid-info';\r\nimport { PageOptionBase } from '../models/page-option';\r\nimport { ResponseResult } from '../models/response-result';\r\nimport { TnUser } from '../models/tn-user';\r\nimport { AuthenService } from './authen.service';\r\nimport { BaseService } from './base.service';\r\nimport { CommonService } from './common.service';\r\nimport { ExceptionHandlerService } from './exception-handler.service';\r\nimport { ModuleConfigService } from './module-config.service';\r\nimport { SignalRService } from './signalr.service';\r\n\r\n// fix for prod build\r\nconst JWT = JWT_;\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class UserService extends BaseService {\r\n    readonly USER_INFO_KEY = 'user_info';\r\n    readonly CURRENT_USER_KEY = 'current_user_info';\r\n    readonly RETRY_COUNT: number = 0;\r\n    readonly REPLAY_COUNT: number = 10;\r\n    readonly DEFAULT_AVATAR_MALE;\r\n    readonly DEFAULT_AVATAR_FEMALE;\r\n    readonly organizationEndpoint;\r\n    readonly _moduleConfig: ModuleConfig;\r\n\r\n    constructor(http: HttpClient,\r\n                injector: Injector,\r\n                _moduleConfigService: ModuleConfigService,\r\n                private _authenService: AuthenService,\r\n                private _oauthService: OAuthService,\r\n                private _signalrService: SignalRService,\r\n                private _exceptionHandlerService: ExceptionHandlerService,\r\n                private _applicationContext: ApplicationContextService\r\n    ) {\r\n        super(http, injector, `${_moduleConfigService.getConfig().environment.apiDomain.userOrgEndpoint}/${_moduleConfigService.getConfig().environment.apiVersion}/user`);\r\n        this.endPoint = _moduleConfigService.getConfig().environment.apiDomain.userOrgEndpoint;\r\n\r\n        this._moduleConfig = _moduleConfigService.getConfig();\r\n        this.serviceUri = this.getServiceUrl();\r\n        this.organizationEndpoint = this.getServiceUrl();\r\n\r\n        this.DEFAULT_AVATAR_MALE = this._moduleConfig.environment.appMetadata.main.defaultMaleAvatar;\r\n        this.DEFAULT_AVATAR_FEMALE = this._moduleConfig.environment.appMetadata.main.defaultFemaleAvatar;\r\n\r\n        const rootContextSub = this._applicationContext.rootContextLoaded.subscribe(rs1 => {\r\n            if (rs1) {\r\n                // binding event user change\r\n                this._applicationContext.getRootContext().subscribe(ComCtxConstants.ROOT.USER_INFO_CHANGED, rs => {\r\n                    if (rs) {\r\n                        localStorage.removeItem(this.CURRENT_USER_KEY);\r\n                        this.populateCurrentUser();\r\n                    }\r\n                });\r\n\r\n                rootContextSub.unsubscribe();\r\n            }\r\n        });\r\n\r\n        this._signalrService.start(null, 'USER_INFO_EDITED', data => {\r\n            this.handleUserInfoChange(data);\r\n        });\r\n    }\r\n\r\n    private getServiceUrl() {\r\n        if (this.isUseOldOrganization()) {\r\n            const userOldOrganization = this._moduleConfig.environment.apiDomain.organizationEndpoint;\r\n            return `${userOldOrganization}/user`;\r\n        }\r\n        else {\r\n            const userOrgEndpoint = this._moduleConfig.environment.apiDomain.userOrgEndpoint;\r\n            return `${userOrgEndpoint}/${this._moduleConfig.environment.apiVersion}/user`;\r\n        }\r\n    }\r\n\r\n    private isUseOldOrganization() {\r\n        const useOldOrganization = this._moduleConfig.environment.useOldOrganization;\r\n        if (useOldOrganization) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    getFullCanBoLabel(item, getDisplayName = false) {\r\n        let label = getDisplayName && item.displayName ? item.displayName : this.getUserName(item);\r\n        label = (item.maChucVu ? `${item.maChucVu}. ` : '') + `${label}` + (item.tenDonVi ? ` - ${item.tenDonVi}` : '');\r\n        return label;\r\n    }\r\n\r\n    getAllWithInfo(filters: Filter[]) {\r\n        return this.getDataCustomRoute('WithInfo', filters);\r\n    }\r\n\r\n    getPageWithInfo(gridInfo: GridInfo) {\r\n        return this.getByGridRequest(gridInfo, 'WithInfo');\r\n    }\r\n\r\n    getInfo(id: string) {\r\n        return this.defaultGet(`${this.serviceUri}/GetInfo/${id}`);\r\n    }\r\n\r\n    getInfoForWorkflow(id: string) {\r\n        return this.defaultGet(`${this.serviceUri}/GetInfoForWorkflow/${id}`);\r\n    }\r\n\r\n    getClaim(key: string) {\r\n        const decoded = JWT.default(this._oauthService.getAccessToken());\r\n        return decoded[key];\r\n    }\r\n\r\n    handleUserInfoChange(data) {\r\n        let dataObj;\r\n        if (typeof data == 'string') {\r\n            dataObj = JSON.parse(data);\r\n        }\r\n        const infoUser = JSON.parse(dataObj.message.content);\r\n        if (infoUser.Id) {\r\n            localStorage.removeItem(this.USER_INFO_KEY + '_' + infoUser.Id);\r\n            this.getBasicUserInfo(infoUser.Id);\r\n        }\r\n    }\r\n\r\n    getForAutoComplete(key: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetForAutoComplete?key=${key}`;\r\n\r\n        return this._http.get<ResponseResult>(apiUrl)\r\n                   .pipe(\r\n                       catchError((err: HttpErrorResponse) => this._exceptionHandlerService.handleError(err, this._injector))\r\n                   ).toPromise();\r\n    }\r\n\r\n    populateCurrentUser() {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            if (!user.userId) {\r\n                this._authenService.logout();\r\n                localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n            }\r\n            else {\r\n                const rawUserId = user.userId;\r\n                const userId = Number(rawUserId);\r\n                if (!isNaN(userId)) {\r\n                    user.originId = user.userId;\r\n                    user.userId = user.instanceid;\r\n                    localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n                }\r\n            }\r\n            this._applicationContext.getRootContext().data.currentUser = user;\r\n            this._applicationContext.getRootContext().fireReplayEvent(ComCtxConstants.ROOT.USER_LOADED, true);\r\n        }\r\n        else {\r\n            this._applicationContext.getRootContext().replaySubscribeOnce(ComCtxConstants.ROOT.USER_READY, rs => {\r\n                const firstTimeLogin = rs ?? false;\r\n                const accessToken = this._oauthService.getAccessToken();\r\n                const decoded: any = JWT.default(accessToken);\r\n                // Chuyển đổi sang dùng instanceId nếu đăng nhập bằng identityv4 nhưng phải sử dụng base userOrgv5\r\n                const rawUserId = decoded.sub;\r\n                const userId = Number(rawUserId);\r\n                let userIdResult = '';\r\n                if (!isNaN(userId)) {\r\n                    userIdResult = decoded.instanceid;\r\n                }\r\n                else {\r\n                    userIdResult = rawUserId;\r\n                }\r\n                this.getStaffInfo(userIdResult).then(rs1 => {\r\n                    const user = new TnUser();\r\n                    if (rs1) {\r\n                        user.issuperuser = decoded.issuperuser;\r\n                        user.isadmin = decoded.isadmin;\r\n                        user.userId = userIdResult;\r\n                        user.fullName = decoded.fullname;\r\n                        user.userName = decoded.username;\r\n                        user.maCanBo = decoded.maCanBo;\r\n                        user.maNguoiHoc = decoded.maNguoiHoc;\r\n                        user.avatar = rs1.avatar;\r\n                        user.position = rs1.position;\r\n                        user.role = rs1.role;\r\n                        user.gender = rs1.gender;\r\n                        user.positionCode = rs1.positionCode;\r\n                        user.instanceid = decoded.instanceid;\r\n                        user.idCanBo = decoded.idCanBo;\r\n                        user.originId = decoded.sub;\r\n\r\n                        if (!user.avatar || user.avatar == '') {\r\n                            if (user.gender == 0) {\r\n                                user.avatar = this.DEFAULT_AVATAR_FEMALE;\r\n                            }\r\n                            else {\r\n                                user.avatar = this.DEFAULT_AVATAR_MALE;\r\n                            }\r\n                        }\r\n                        localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n                    }\r\n                    this._applicationContext.getRootContext().data.currentUser = user;\r\n\r\n                    if (firstTimeLogin) {\r\n                        this._applicationContext.getRootContext().fireEvent(ComCtxConstants.ROOT.NEED_CLEAR_PERMISSION_CACHE);\r\n                    }\r\n                    else {\r\n                        this._applicationContext.getRootContext().fireReplayEvent(ComCtxConstants.ROOT.USER_LOADED, true);\r\n                    }\r\n                }, err => {\r\n\r\n                });\r\n            });\r\n        }\r\n    }\r\n\r\n    getProfileInfo() {\r\n        return JSON.parse(sessionStorage.getItem('profiles'));\r\n    }\r\n\r\n    isKhoaVien(idLoaiDonVi) {\r\n        return idLoaiDonVi == '20' || idLoaiDonVi == '60';\r\n    }\r\n\r\n    isBoMon(idLoaiDonVi) {\r\n        return idLoaiDonVi == '21';\r\n    }\r\n\r\n    getCurrentUser(): TnUser {\r\n        return <TnUser>(this._applicationContext.getRootContext().data.currentUser);\r\n    }\r\n\r\n    getUserName(item): string {\r\n        return item.fullNameNew\r\n            ? `${item.fullNameNew}`\r\n            : `${item.lastName} ${item.fistName}`;\r\n    }\r\n\r\n    getUserIdCombine() {\r\n        const rawUserId = this.getId();\r\n        const userId = Number(rawUserId);\r\n        let userIdResult = '';\r\n        if (!isNaN(userId)) {\r\n            userIdResult = this.getInstanceId();\r\n        }\r\n        else {\r\n            userIdResult = rawUserId;\r\n        }\r\n        return userIdResult.toString();\r\n    }\r\n\r\n    getStaffInfo(userId): Promise<TnUser> {\r\n        const url = `${this.serviceUri}/${userId}`;\r\n        return this._http.get<ResponseResult>(url)\r\n                   .pipe(\r\n                       catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                       map(rs => {\r\n                           const op = <TnUser>{\r\n                               fullName: rs.data ? rs.data.fullName : '',\r\n                               role: rs.data ? rs.data.role : '',\r\n                               avatar: rs.data ? rs.data.avatar : '',\r\n                               gender: rs.data ? rs.data.gender : 0,\r\n                               positionCode: rs.data.positionCode ? rs.data.positionCode : '',\r\n                               instanceid: rs.data.instanceid\r\n                           };\r\n\r\n                           if (!op.avatar || op.avatar == '') {\r\n                               if (op.gender == 0) {\r\n                                   op.avatar = this.DEFAULT_AVATAR_FEMALE;\r\n                               }\r\n                               else {\r\n                                   op.avatar = this.DEFAULT_AVATAR_MALE;\r\n                               }\r\n                           }\r\n\r\n                           return op;\r\n                       }))\r\n                   .toPromise();\r\n    }\r\n\r\n    getId(): string {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            return user.userId;\r\n        }\r\n        else {\r\n            return this.getCurrentUser().userId;\r\n        }\r\n    }\r\n\r\n    getInstanceId(): string {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            return user.instanceid;\r\n        }\r\n        else {\r\n            return this.getCurrentUser().instanceid;\r\n        }\r\n    }\r\n\r\n    registerOnline(formData: FormData): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/registerOnline`;\r\n        return this._http\r\n                   .post<ResponseResult>(apiUrl, formData)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    getBasicUserInfo(userId: number): Promise<BasicUserInfo> {\r\n\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY + '_' + userId);\r\n        // const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n        // const user = userInfos ? userInfos.find(item => item.id === userId) : null;\r\n        const user = <BasicUserInfo>JSON.parse(storageItem);\r\n        if (user) {\r\n            return new Promise((resolve, reject) => resolve(user));\r\n        }\r\n        else {\r\n            return new Promise(async (resolve, reject) => {\r\n                if (userId == null) {\r\n                    reject(<BasicUserInfo>{});\r\n                }\r\n                else {\r\n                    if (userId > 0) {\r\n                        const svUrl = `${this.serviceUri}/GetBasicUserInfo?id=${userId}`;\r\n                        try {\r\n                            const result = await this._http.get<ResponseResult>(svUrl).pipe(\r\n                                shareReplay(this.REPLAY_COUNT),\r\n                                retry(this.RETRY_COUNT),\r\n                                map(repsonse => {\r\n                                        // save response to local storage here\r\n                                        localStorage.setItem(this.USER_INFO_KEY + '_' + repsonse.data.id, JSON.stringify(repsonse.data));\r\n                                        return <BasicUserInfo>repsonse.data;\r\n                                    },\r\n                                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector))\r\n                                )).toPromise();\r\n\r\n                            resolve(result);\r\n                        }\r\n                        catch {\r\n                            reject(<BasicUserInfo>{});\r\n                        }\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    getBasicUsersInfo(userIds: string): Promise<BasicUserInfo[]> {\r\n        if (!userIds || userIds === '') {\r\n            return new Promise((resolve, reject) => {\r\n                resolve(<BasicUserInfo[]>[]);\r\n            });\r\n        }\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n\r\n        // const users = userInfos ? userInfos.filter(item => userIds.indexOf(`,${item.id},`) > -1) : null;\r\n        const check = userInfos ? userIds.indexOf(userInfos['id']) > -1 : null;\r\n        if (check) {\r\n            return new Promise((resolve, reject) => resolve(userInfos));\r\n        }\r\n        else {\r\n            return new Promise((resolve, reject) => {\r\n                const svUrl = `${this.serviceUri}/GetBasicUsersInfo?userIds=${userIds}`;\r\n                this._http.get<ResponseResult>(svUrl).pipe(\r\n                    shareReplay(this.REPLAY_COUNT),\r\n                    retry(this.RETRY_COUNT),\r\n                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                    map(repsonse => <BasicUserInfo[]>repsonse.data)\r\n                ).toPromise().then(success => {\r\n                    resolve(success);\r\n                }).catch(err => {\r\n                    resolve(<BasicUserInfo[]>[]);\r\n                });\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Hàm dùng để lấy thông tin cơ bản nhiều người dùng dựa vào userName,\r\n     * hiện tại chưa có thông tin về đơn vị và chức vụ người dùng để giảm load và vì chưa dùng đến\r\n     * @param {string} userName\r\n     * @return {Promise<BasicUserInfo[]>\r\n     */\r\n    getBasicUserInfoByUserName(userName: string): Promise<BasicUserInfo> {\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY + '_' + userName);\r\n        const user = <BasicUserInfo>JSON.parse(storageItem);\r\n        if (user) {\r\n            return new Promise((resolve, reject) => resolve(user));\r\n        }\r\n        else {\r\n            return new Promise(async (resolve, reject) => {\r\n                if (userName == null) {\r\n                    resolve(<BasicUserInfo>{});\r\n                }\r\n                else {\r\n                    if (userName != '') {\r\n                        const svUrl = `${this.serviceUri}/GetBasicUserInfoByUserName?userName=${userName}`;\r\n                        this._http.get<ResponseResult>(svUrl).pipe(\r\n                            shareReplay(this.REPLAY_COUNT),\r\n                            retry(this.RETRY_COUNT),\r\n                            map(repsonse => {\r\n                                    // save response to local storage here\r\n                                    localStorage.setItem(this.USER_INFO_KEY + '_' + repsonse.data.userName, JSON.stringify(repsonse.data));\r\n                                    return <BasicUserInfo>repsonse.data;\r\n                                },\r\n                                catchError((err: HttpErrorResponse) => this.handleError(err, this._injector))\r\n                            )).toPromise().then(rss => {\r\n                            resolve(rss);\r\n                        }).catch(errr => {\r\n                            resolve(<any>{});\r\n                        });\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Hàm dùng để lấy thông tin cơ bản nhiều người dùng dựa vào userName,\r\n     * hiện tại chưa có thông tin về đơn vị và chức vụ người dùng để giảm load và vì chưa dùng đến\r\n     * @param {string} userNames\r\n     * @return {Promise<BasicUserInfo[]>\r\n     */\r\n    async getBasicUsersInfoByUserNames(userNames: string): Promise<BasicUserInfo[]> {\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n        const check = userInfos ? userNames.indexOf(userInfos['userName']) > -1 : null;\r\n        if (check) {\r\n            return userInfos;\r\n        }\r\n        else {\r\n            const svUrl = `${this.serviceUri}/GetBasicUsersInfoByUserNames?userNames=${userNames}`;\r\n            return await this._http.get<ResponseResult>(svUrl).pipe(\r\n                shareReplay(this.REPLAY_COUNT),\r\n                retry(this.RETRY_COUNT),\r\n                catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                map(repsonse => {\r\n                    localStorage.setItem(this.USER_INFO_KEY + '_' + (<BasicUserInfo[]>repsonse.data).map(x => {\r\n                        if (x.userName) return x.userName;\r\n                    }), JSON.stringify(repsonse.data));\r\n                    return <BasicUserInfo[]>repsonse.data;\r\n                })\r\n            ).toPromise().catch(err => []);\r\n        }\r\n    }\r\n\r\n    convertListUserIdToString(userIds: number[]): string {\r\n        if (userIds.length > 0) {\r\n            return `,${userIds.join(',')},`;\r\n        }\r\n        return ',';\r\n    }\r\n\r\n    fillBasicUserInfo(dataSource: any[], propertyName: string): any[] {\r\n        dataSource.forEach(item => {\r\n            const userId = item[propertyName].id ? item[propertyName].id : item[propertyName];\r\n            // tslint:disable-next-line:no-shadowed-variable\r\n            // const user = users.find(user => user.id === userId);\r\n            // if (user) {\r\n            //     item[propertyName] = user;\r\n            // }\r\n        });\r\n\r\n        return dataSource;\r\n    }\r\n\r\n\r\n    restorePassword(item: any) {\r\n        return this._http.put<ResponseResult>(`${this.serviceUri}/restorePassword`, item)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    changePassword(userId: string, item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/ChangePassword`;\r\n        return this._http\r\n                   .post<ResponseResult>(apiUrl, item)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    resetPassword(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/resetPassword`;\r\n        return this._http\r\n                   .put<ResponseResult>(apiUrl, item)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    GetsByManagerIdArrayId(id: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetLowerStaffsByUserId?userId=${id}`;\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    markAsAdmin(userId: number, isAdmin: boolean) {\r\n        const url = `${this.serviceUri}/markAsAdmin/${userId}/${isAdmin}`;\r\n        return this._http\r\n                   .put<ResponseResult>(url, isAdmin)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    markAsRepresent(userId: number, isRepresent: number) {\r\n        const url = `${this.serviceUri}/markAsRepresent/${userId}/${isRepresent}`;\r\n\r\n        return this._http\r\n                   .put<ResponseResult>(url, isRepresent)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    getsByOrganizationListId(pageOption: PageOptionBase, funGetName: string = '', optionParameter: string = '', defaultParameter: string = ''): Promise<ResponseResult> {\r\n\r\n        let queryString = `?key=${pageOption.query}`;\r\n\r\n        if (!pageOption.offset) {\r\n            pageOption.offset = 0;\r\n        }\r\n\r\n        queryString += `&offset=${pageOption.offset}`;\r\n\r\n\r\n        if (!pageOption.limit) {\r\n            pageOption.limit = this.LIMIT_DEFAULT;\r\n        }\r\n        queryString += `&limit=${pageOption.limit + 1}`;\r\n\r\n\r\n        if (pageOption.sortField) {\r\n            queryString += `&sortField=${pageOption.sortField}&isAsc=${pageOption.isAsc}`;\r\n        }\r\n        if (defaultParameter != '') {\r\n            queryString += `&${defaultParameter}`;\r\n        }\r\n        if (optionParameter != '') {\r\n            queryString += `&${optionParameter}`;\r\n        }\r\n        const apiUrl = `${this.organizationEndpoint}${funGetName}${queryString}`;\r\n        if (pageOption.isIgnoreClientCache) {\r\n            return this.getIgnoreClientCache(apiUrl);\r\n        }\r\n\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    getsByOrganizationId(organizationId: string, keyword?: string, offset?: number, limit?: number): Promise<ResponseResult> {\r\n\r\n        if (!keyword) {\r\n            keyword = '';\r\n        }\r\n\r\n        if (!offset) {\r\n            offset = 0;\r\n        }\r\n\r\n        if (!offset) {\r\n            offset = 0;\r\n        }\r\n\r\n        if (!limit) {\r\n            limit = 10;\r\n        }\r\n\r\n        const apiUrl = `${this.serviceUri}/GetsByOrganizationId`\r\n                       + `?organizationId=${organizationId}`\r\n                       + `&keyword=${keyword}`\r\n                       + `&offset=${offset}`\r\n                       + `&limit=${limit}`;\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    getDefaultAvatar() {\r\n        return this.DEFAULT_AVATAR_MALE;\r\n    }\r\n\r\n    handleError(error: any, injector: Injector) {\r\n        const commonService = injector.get(CommonService);\r\n        return commonService.handleError(error, injector);\r\n    }\r\n\r\n    lockUser(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/lockUserAccount`;\r\n        return this._http\r\n                   .post<ResponseResult>(apiUrl, item)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    unlockUser(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/unlockUserAccount`;\r\n        return this._http\r\n                   .post<ResponseResult>(apiUrl, item)\r\n                   .pipe(catchError(err => this.handleError(err, this._injector)))\r\n                   .toPromise();\r\n    }\r\n\r\n    isSuperUser() {\r\n        return this._applicationContext.getRootContext().data.currentUser\r\n               && this._applicationContext.getRootContext().data.currentUser.issuperuser === 'True';\r\n    }\r\n\r\n    isAdmin() {\r\n        return this._applicationContext.getRootContext().data.currentUser\r\n               && this._applicationContext.getRootContext().data.currentUser.isadmin === 'True';\r\n    }\r\n\r\n    isValidAccessToken() {\r\n        return this._oauthService.hasValidAccessToken();\r\n    }\r\n\r\n    getUsersByGroupCode(groupCode: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetUsersByGroupCode?groupCode=${groupCode}`;\r\n        return this._http.get<ResponseResult>(apiUrl)\r\n                   .pipe(\r\n                       catchError((err: HttpErrorResponse) => this._exceptionHandlerService.handleError(err, this._injector))\r\n                   ).toPromise();\r\n    }\r\n\r\n    getServiceEndpoint() {\r\n        return `${this.serviceUri}`;\r\n    }\r\n\r\n    isSinhVienAccount() {\r\n        const userLogin = this.getCurrentUser();\r\n        if (userLogin) {\r\n            if (userLogin.maNguoiHoc) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    getPageUserInfo(userIds: string): Promise<BasicUserInfo[]> {\r\n        if (!userIds || userIds === '') {\r\n            return new Promise((resolve, reject) => {\r\n                resolve(<BasicUserInfo[]>[]);\r\n            });\r\n        }\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n\r\n        // const users = userInfos ? userInfos.filter(item => userIds.indexOf(`,${item.id},`) > -1) : null;\r\n        const check = userInfos ? userIds.indexOf(userInfos['id']) > -1 : null;\r\n        if (check) {\r\n            return new Promise((resolve, reject) => resolve(userInfos));\r\n        }\r\n        else {\r\n            return new Promise((resolve, reject) => {\r\n                const svUrl = `${this.serviceUri}/GetPaged`;\r\n                const filters = [];\r\n                const itemFilter = {\r\n                    field: 'id',\r\n                    operator: 'in',\r\n                    value: userIds\r\n                };\r\n                filters.push(itemFilter);\r\n                const gridInfo = new GridInfo({\r\n                    fields: '',\r\n                    pageInfo: {\r\n                        page: 1,\r\n                        pageSize: 10000\r\n                    },\r\n                    sorts: [],\r\n                    filters: filters\r\n                });\r\n\r\n                this._http.post<ResponseResult>(svUrl, gridInfo).pipe(\r\n                    shareReplay(this.REPLAY_COUNT),\r\n                    retry(this.RETRY_COUNT),\r\n                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                    map(repsonse => <BasicUserInfo[]>repsonse.data)\r\n                ).toPromise().then(success => {\r\n                    resolve(success);\r\n                }).catch(err => {\r\n                    resolve(<BasicUserInfo[]>[]);\r\n                });\r\n            });\r\n        }\r\n    }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"../../../../projects/tnx-shared/src/lib/","sources":["services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\r\nimport { Injectable, Injector } from '@angular/core';\r\nimport { OAuthService } from 'angular-oauth2-oidc';\r\nimport * as JWT_ from 'jwt-decode';\r\nimport { catchError, map, retry, shareReplay } from 'rxjs/operators';\r\nimport { ApplicationContextService } from '../app-context/application-context.service';\r\nimport { ComCtxConstants } from '../configs/component-context.constant';\r\nimport { ModuleConfig } from '../configs/module-config';\r\nimport { BasicUserInfo } from '../models/basic-user-info';\r\nimport { Filter, GridInfo } from '../models/grid-info';\r\nimport { PageOptionBase } from '../models/page-option';\r\nimport { ResponseResult } from '../models/response-result';\r\nimport { TnUser } from '../models/tn-user';\r\nimport { AuthenService } from './authen.service';\r\nimport { BaseService } from './base.service';\r\nimport { CommonService } from './common.service';\r\nimport { ExceptionHandlerService } from './exception-handler.service';\r\nimport { ModuleConfigService } from './module-config.service';\r\nimport { SignalRService } from './signalr.service';\r\n\r\n// fix for prod build\r\nconst JWT = JWT_;\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class UserService extends BaseService {\r\n    readonly USER_INFO_KEY = 'user_info';\r\n    readonly CURRENT_USER_KEY = 'current_user_info';\r\n    readonly RETRY_COUNT: number = 0;\r\n    readonly REPLAY_COUNT: number = 10;\r\n    readonly DEFAULT_AVATAR_MALE;\r\n    readonly DEFAULT_AVATAR_FEMALE;\r\n    readonly organizationEndpoint;\r\n    readonly _moduleConfig: ModuleConfig;\r\n\r\n    constructor(http: HttpClient,\r\n        injector: Injector,\r\n        _moduleConfigService: ModuleConfigService,\r\n        private _authenService: AuthenService,\r\n        private _oauthService: OAuthService,\r\n        private _signalrService: SignalRService,\r\n        private _exceptionHandlerService: ExceptionHandlerService,\r\n        private _applicationContext: ApplicationContextService\r\n    ) {\r\n        super(http, injector, `${_moduleConfigService.getConfig().environment.apiDomain.userOrgEndpoint}/${_moduleConfigService.getConfig().environment.apiVersion}/user`);\r\n        this.endPoint = _moduleConfigService.getConfig().environment.apiDomain.userOrgEndpoint;\r\n\r\n        this._moduleConfig = _moduleConfigService.getConfig();\r\n        this.serviceUri = this.getServiceUrl();\r\n        this.organizationEndpoint = this.getServiceUrl();\r\n\r\n        this.DEFAULT_AVATAR_MALE = this._moduleConfig.environment.appMetadata.main.defaultMaleAvatar;\r\n        this.DEFAULT_AVATAR_FEMALE = this._moduleConfig.environment.appMetadata.main.defaultFemaleAvatar;\r\n\r\n        const rootContextSub = this._applicationContext.rootContextLoaded.subscribe(rs1 => {\r\n            if (rs1) {\r\n                // binding event user change\r\n                this._applicationContext.getRootContext().subscribe(ComCtxConstants.ROOT.USER_INFO_CHANGED, rs => {\r\n                    if (rs) {\r\n                        localStorage.removeItem(this.CURRENT_USER_KEY);\r\n                        this.populateCurrentUser();\r\n                    }\r\n                });\r\n\r\n                rootContextSub.unsubscribe();\r\n            }\r\n        });\r\n\r\n        this._signalrService.start(null, 'USER_INFO_EDITED', data => {\r\n            this.handleUserInfoChange(data);\r\n        });\r\n    }\r\n\r\n    private getServiceUrl() {\r\n        if (this.isUseOldOrganization()) {\r\n            const userOldOrganization = this._moduleConfig.environment.apiDomain.organizationEndpoint;\r\n            return `${userOldOrganization}/user`;\r\n        }\r\n        else {\r\n            const userOrgEndpoint = this._moduleConfig.environment.apiDomain.userOrgEndpoint;\r\n            return `${userOrgEndpoint}/${this._moduleConfig.environment.apiVersion}/user`;\r\n        }\r\n    }\r\n\r\n    private isUseOldOrganization() {\r\n        const useOldOrganization = this._moduleConfig.environment.useOldOrganization;\r\n        if (useOldOrganization) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    getFullCanBoLabel(item, getDisplayName = false) {\r\n        let label = getDisplayName && item.displayName ? item.displayName : this.getUserName(item);\r\n        label = (item.maChucVu ? `${item.maChucVu}. ` : '') + `${label}` + (item.tenDonVi ? ` - ${item.tenDonVi}` : '');\r\n        return label;\r\n    }\r\n\r\n    getAllWithInfo(filters: Filter[]) {\r\n        return this.getDataCustomRoute('WithInfo', filters);\r\n    }\r\n\r\n    getPageWithInfo(gridInfo: GridInfo) {\r\n        return this.getByGridRequest(gridInfo, 'WithInfo');\r\n    }\r\n\r\n    getInfo(id: string) {\r\n        return this.defaultGet(`${this.serviceUri}/GetInfo/${id}`);\r\n    }\r\n\r\n    getInfoForWorkflow(id: string) {\r\n        return this.defaultGet(`${this.serviceUri}/GetInfoForWorkflow/${id}`);\r\n    }\r\n\r\n    getClaim(key: string) {\r\n        const decoded = JWT.default(this._oauthService.getAccessToken());\r\n        return decoded[key];\r\n    }\r\n\r\n    getJwtDecoded() {\r\n        return JWT.default(this._oauthService.getAccessToken());\r\n    }\r\n\r\n    handleUserInfoChange(data) {\r\n        let dataObj;\r\n        if (typeof data == 'string') {\r\n            dataObj = JSON.parse(data);\r\n        }\r\n        const infoUser = JSON.parse(dataObj.message.content);\r\n        if (infoUser.Id) {\r\n            localStorage.removeItem(this.USER_INFO_KEY + '_' + infoUser.Id);\r\n            this.getBasicUserInfo(infoUser.Id);\r\n        }\r\n    }\r\n\r\n    getForAutoComplete(key: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetForAutoComplete?key=${key}`;\r\n\r\n        return this._http.get<ResponseResult>(apiUrl)\r\n            .pipe(\r\n                catchError((err: HttpErrorResponse) => this._exceptionHandlerService.handleError(err, this._injector))\r\n            ).toPromise();\r\n    }\r\n\r\n    populateCurrentUser() {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            if (!user.userId) {\r\n                this._authenService.logout();\r\n                localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n            }\r\n            else {\r\n                const rawUserId = user.userId;\r\n                const userId = Number(rawUserId);\r\n                if (!isNaN(userId)) {\r\n                    user.originId = user.userId;\r\n                    user.userId = user.instanceid;\r\n                    localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n                }\r\n            }\r\n            this._applicationContext.getRootContext().data.currentUser = user;\r\n            this._applicationContext.getRootContext().fireReplayEvent(ComCtxConstants.ROOT.USER_LOADED, true);\r\n        }\r\n        else {\r\n            this._applicationContext.getRootContext().replaySubscribeOnce(ComCtxConstants.ROOT.USER_READY, rs => {\r\n                const firstTimeLogin = rs ?? false;\r\n                const accessToken = this._oauthService.getAccessToken();\r\n                const decoded: any = JWT.default(accessToken);\r\n                // Chuyển đổi sang dùng instanceId nếu đăng nhập bằng identityv4 nhưng phải sử dụng base userOrgv5\r\n                const rawUserId = decoded.sub;\r\n                const userId = Number(rawUserId);\r\n                let userIdResult = '';\r\n                if (!isNaN(userId)) {\r\n                    userIdResult = decoded.instanceid;\r\n                }\r\n                else {\r\n                    userIdResult = rawUserId;\r\n                }\r\n                this.getStaffInfo(userIdResult).then(rs1 => {\r\n                    const user = new TnUser();\r\n                    if (rs1) {\r\n                        user.issuperuser = decoded.issuperuser;\r\n                        user.isadmin = decoded.isadmin;\r\n                        user.userId = userIdResult;\r\n                        user.fullName = decoded.fullname;\r\n                        user.userName = decoded.username;\r\n                        user.maCanBo = decoded.maCanBo;\r\n                        user.maNguoiHoc = decoded.maNguoiHoc;\r\n                        user.avatar = rs1.avatar;\r\n                        user.position = rs1.position;\r\n                        user.role = rs1.role;\r\n                        user.gender = rs1.gender;\r\n                        user.positionCode = rs1.positionCode;\r\n                        user.instanceid = decoded.instanceid;\r\n                        user.idCanBo = decoded.idCanBo;\r\n                        user.originId = decoded.sub;\r\n\r\n                        if (!user.avatar || user.avatar == '') {\r\n                            if (user.gender == 0) {\r\n                                user.avatar = this.DEFAULT_AVATAR_FEMALE;\r\n                            }\r\n                            else {\r\n                                user.avatar = this.DEFAULT_AVATAR_MALE;\r\n                            }\r\n                        }\r\n                        localStorage.setItem(this.CURRENT_USER_KEY, JSON.stringify(user));\r\n                    }\r\n                    this._applicationContext.getRootContext().data.currentUser = user;\r\n\r\n                    if (firstTimeLogin) {\r\n                        this._applicationContext.getRootContext().fireEvent(ComCtxConstants.ROOT.NEED_CLEAR_PERMISSION_CACHE);\r\n                    }\r\n                    else {\r\n                        this._applicationContext.getRootContext().fireReplayEvent(ComCtxConstants.ROOT.USER_LOADED, true);\r\n                    }\r\n                }, err => {\r\n\r\n                });\r\n            });\r\n        }\r\n    }\r\n\r\n    getProfileInfo() {\r\n        return JSON.parse(sessionStorage.getItem('profiles'));\r\n    }\r\n\r\n    isKhoaVien(idLoaiDonVi) {\r\n        return idLoaiDonVi == '20' || idLoaiDonVi == '60';\r\n    }\r\n\r\n    isBoMon(idLoaiDonVi) {\r\n        return idLoaiDonVi == '21';\r\n    }\r\n\r\n    getCurrentUser(): TnUser {\r\n        return <TnUser>(this._applicationContext.getRootContext().data.currentUser);\r\n    }\r\n\r\n    getUserName(item): string {\r\n        return item.fullNameNew\r\n            ? `${item.fullNameNew}`\r\n            : `${item.lastName} ${item.fistName}`;\r\n    }\r\n\r\n    getUserIdCombine() {\r\n        const rawUserId = this.getId();\r\n        const userId = Number(rawUserId);\r\n        let userIdResult = '';\r\n        if (!isNaN(userId)) {\r\n            userIdResult = this.getInstanceId();\r\n        }\r\n        else {\r\n            userIdResult = rawUserId;\r\n        }\r\n        return userIdResult.toString();\r\n    }\r\n\r\n    getStaffInfo(userId): Promise<TnUser> {\r\n        const url = `${this.serviceUri}/${userId}`;\r\n        return this._http.get<ResponseResult>(url)\r\n            .pipe(\r\n                catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                map(rs => {\r\n                    const op = <TnUser>{\r\n                        fullName: rs.data ? rs.data.fullName : '',\r\n                        role: rs.data ? rs.data.role : '',\r\n                        avatar: rs.data ? rs.data.avatar : '',\r\n                        gender: rs.data ? rs.data.gender : 0,\r\n                        positionCode: rs.data.positionCode ? rs.data.positionCode : '',\r\n                        instanceid: rs.data.instanceid\r\n                    };\r\n\r\n                    if (!op.avatar || op.avatar == '') {\r\n                        if (op.gender == 0) {\r\n                            op.avatar = this.DEFAULT_AVATAR_FEMALE;\r\n                        }\r\n                        else {\r\n                            op.avatar = this.DEFAULT_AVATAR_MALE;\r\n                        }\r\n                    }\r\n\r\n                    return op;\r\n                }))\r\n            .toPromise();\r\n    }\r\n\r\n    getId(): string {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            return user.userId;\r\n        }\r\n        else {\r\n            return this.getCurrentUser().userId;\r\n        }\r\n    }\r\n\r\n    getInstanceId(): string {\r\n        const storageItem = localStorage.getItem(this.CURRENT_USER_KEY);\r\n        const user = <TnUser>JSON.parse(storageItem);\r\n        if (user) {\r\n            return user.instanceid;\r\n        }\r\n        else {\r\n            return this.getCurrentUser().instanceid;\r\n        }\r\n    }\r\n\r\n    registerOnline(formData: FormData): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/registerOnline`;\r\n        return this._http\r\n            .post<ResponseResult>(apiUrl, formData)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    getBasicUserInfo(userId: number): Promise<BasicUserInfo> {\r\n\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY + '_' + userId);\r\n        // const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n        // const user = userInfos ? userInfos.find(item => item.id === userId) : null;\r\n        const user = <BasicUserInfo>JSON.parse(storageItem);\r\n        if (user) {\r\n            return new Promise((resolve, reject) => resolve(user));\r\n        }\r\n        else {\r\n            return new Promise(async (resolve, reject) => {\r\n                if (userId == null) {\r\n                    reject(<BasicUserInfo>{});\r\n                }\r\n                else {\r\n                    if (userId > 0) {\r\n                        const svUrl = `${this.serviceUri}/GetBasicUserInfo?id=${userId}`;\r\n                        try {\r\n                            const result = await this._http.get<ResponseResult>(svUrl).pipe(\r\n                                shareReplay(this.REPLAY_COUNT),\r\n                                retry(this.RETRY_COUNT),\r\n                                map(repsonse => {\r\n                                    // save response to local storage here\r\n                                    localStorage.setItem(this.USER_INFO_KEY + '_' + repsonse.data.id, JSON.stringify(repsonse.data));\r\n                                    return <BasicUserInfo>repsonse.data;\r\n                                },\r\n                                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector))\r\n                                )).toPromise();\r\n\r\n                            resolve(result);\r\n                        }\r\n                        catch {\r\n                            reject(<BasicUserInfo>{});\r\n                        }\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    getBasicUsersInfo(userIds: string): Promise<BasicUserInfo[]> {\r\n        if (!userIds || userIds === '') {\r\n            return new Promise((resolve, reject) => {\r\n                resolve(<BasicUserInfo[]>[]);\r\n            });\r\n        }\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n\r\n        // const users = userInfos ? userInfos.filter(item => userIds.indexOf(`,${item.id},`) > -1) : null;\r\n        const check = userInfos ? userIds.indexOf(userInfos['id']) > -1 : null;\r\n        if (check) {\r\n            return new Promise((resolve, reject) => resolve(userInfos));\r\n        }\r\n        else {\r\n            return new Promise((resolve, reject) => {\r\n                const svUrl = `${this.serviceUri}/GetBasicUsersInfo?userIds=${userIds}`;\r\n                this._http.get<ResponseResult>(svUrl).pipe(\r\n                    shareReplay(this.REPLAY_COUNT),\r\n                    retry(this.RETRY_COUNT),\r\n                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                    map(repsonse => <BasicUserInfo[]>repsonse.data)\r\n                ).toPromise().then(success => {\r\n                    resolve(success);\r\n                }).catch(err => {\r\n                    resolve(<BasicUserInfo[]>[]);\r\n                });\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Hàm dùng để lấy thông tin cơ bản nhiều người dùng dựa vào userName,\r\n     * hiện tại chưa có thông tin về đơn vị và chức vụ người dùng để giảm load và vì chưa dùng đến\r\n     * @param {string} userName\r\n     * @return {Promise<BasicUserInfo[]>\r\n     */\r\n    getBasicUserInfoByUserName(userName: string): Promise<BasicUserInfo> {\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY + '_' + userName);\r\n        const user = <BasicUserInfo>JSON.parse(storageItem);\r\n        if (user) {\r\n            return new Promise((resolve, reject) => resolve(user));\r\n        }\r\n        else {\r\n            return new Promise(async (resolve, reject) => {\r\n                if (userName == null) {\r\n                    resolve(<BasicUserInfo>{});\r\n                }\r\n                else {\r\n                    if (userName != '') {\r\n                        const svUrl = `${this.serviceUri}/GetBasicUserInfoByUserName?userName=${userName}`;\r\n                        this._http.get<ResponseResult>(svUrl).pipe(\r\n                            shareReplay(this.REPLAY_COUNT),\r\n                            retry(this.RETRY_COUNT),\r\n                            map(repsonse => {\r\n                                // save response to local storage here\r\n                                localStorage.setItem(this.USER_INFO_KEY + '_' + repsonse.data.userName, JSON.stringify(repsonse.data));\r\n                                return <BasicUserInfo>repsonse.data;\r\n                            },\r\n                                catchError((err: HttpErrorResponse) => this.handleError(err, this._injector))\r\n                            )).toPromise().then(rss => {\r\n                                resolve(rss);\r\n                            }).catch(errr => {\r\n                                resolve(<any>{});\r\n                            });\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Hàm dùng để lấy thông tin cơ bản nhiều người dùng dựa vào userName,\r\n     * hiện tại chưa có thông tin về đơn vị và chức vụ người dùng để giảm load và vì chưa dùng đến\r\n     * @param {string} userNames\r\n     * @return {Promise<BasicUserInfo[]>\r\n     */\r\n    async getBasicUsersInfoByUserNames(userNames: string): Promise<BasicUserInfo[]> {\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n        const check = userInfos ? userNames.indexOf(userInfos['userName']) > -1 : null;\r\n        if (check) {\r\n            return userInfos;\r\n        }\r\n        else {\r\n            const svUrl = `${this.serviceUri}/GetBasicUsersInfoByUserNames?userNames=${userNames}`;\r\n            return await this._http.get<ResponseResult>(svUrl).pipe(\r\n                shareReplay(this.REPLAY_COUNT),\r\n                retry(this.RETRY_COUNT),\r\n                catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                map(repsonse => {\r\n                    localStorage.setItem(this.USER_INFO_KEY + '_' + (<BasicUserInfo[]>repsonse.data).map(x => {\r\n                        if (x.userName) return x.userName;\r\n                    }), JSON.stringify(repsonse.data));\r\n                    return <BasicUserInfo[]>repsonse.data;\r\n                })\r\n            ).toPromise().catch(err => []);\r\n        }\r\n    }\r\n\r\n    convertListUserIdToString(userIds: number[]): string {\r\n        if (userIds.length > 0) {\r\n            return `,${userIds.join(',')},`;\r\n        }\r\n        return ',';\r\n    }\r\n\r\n    fillBasicUserInfo(dataSource: any[], propertyName: string): any[] {\r\n        dataSource.forEach(item => {\r\n            const userId = item[propertyName].id ? item[propertyName].id : item[propertyName];\r\n            // tslint:disable-next-line:no-shadowed-variable\r\n            // const user = users.find(user => user.id === userId);\r\n            // if (user) {\r\n            //     item[propertyName] = user;\r\n            // }\r\n        });\r\n\r\n        return dataSource;\r\n    }\r\n\r\n\r\n    restorePassword(item: any) {\r\n        return this._http.put<ResponseResult>(`${this.serviceUri}/restorePassword`, item)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    changePassword(userId: string, item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/ChangePassword`;\r\n        return this._http\r\n            .post<ResponseResult>(apiUrl, item)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    resetPassword(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/resetPassword`;\r\n        return this._http\r\n            .put<ResponseResult>(apiUrl, item)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    GetsByManagerIdArrayId(id: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetLowerStaffsByUserId?userId=${id}`;\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    markAsAdmin(userId: number, isAdmin: boolean) {\r\n        const url = `${this.serviceUri}/markAsAdmin/${userId}/${isAdmin}`;\r\n        return this._http\r\n            .put<ResponseResult>(url, isAdmin)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    markAsRepresent(userId: number, isRepresent: number) {\r\n        const url = `${this.serviceUri}/markAsRepresent/${userId}/${isRepresent}`;\r\n\r\n        return this._http\r\n            .put<ResponseResult>(url, isRepresent)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    getsByOrganizationListId(pageOption: PageOptionBase, funGetName: string = '', optionParameter: string = '', defaultParameter: string = ''): Promise<ResponseResult> {\r\n\r\n        let queryString = `?key=${pageOption.query}`;\r\n\r\n        if (!pageOption.offset) {\r\n            pageOption.offset = 0;\r\n        }\r\n\r\n        queryString += `&offset=${pageOption.offset}`;\r\n\r\n\r\n        if (!pageOption.limit) {\r\n            pageOption.limit = this.LIMIT_DEFAULT;\r\n        }\r\n        queryString += `&limit=${pageOption.limit + 1}`;\r\n\r\n\r\n        if (pageOption.sortField) {\r\n            queryString += `&sortField=${pageOption.sortField}&isAsc=${pageOption.isAsc}`;\r\n        }\r\n        if (defaultParameter != '') {\r\n            queryString += `&${defaultParameter}`;\r\n        }\r\n        if (optionParameter != '') {\r\n            queryString += `&${optionParameter}`;\r\n        }\r\n        const apiUrl = `${this.organizationEndpoint}${funGetName}${queryString}`;\r\n        if (pageOption.isIgnoreClientCache) {\r\n            return this.getIgnoreClientCache(apiUrl);\r\n        }\r\n\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    getsByOrganizationId(organizationId: string, keyword?: string, offset?: number, limit?: number): Promise<ResponseResult> {\r\n\r\n        if (!keyword) {\r\n            keyword = '';\r\n        }\r\n\r\n        if (!offset) {\r\n            offset = 0;\r\n        }\r\n\r\n        if (!offset) {\r\n            offset = 0;\r\n        }\r\n\r\n        if (!limit) {\r\n            limit = 10;\r\n        }\r\n\r\n        const apiUrl = `${this.serviceUri}/GetsByOrganizationId`\r\n            + `?organizationId=${organizationId}`\r\n            + `&keyword=${keyword}`\r\n            + `&offset=${offset}`\r\n            + `&limit=${limit}`;\r\n        return this.defaultGet(apiUrl);\r\n    }\r\n\r\n    getDefaultAvatar() {\r\n        return this.DEFAULT_AVATAR_MALE;\r\n    }\r\n\r\n    handleError(error: any, injector: Injector) {\r\n        const commonService = injector.get(CommonService);\r\n        return commonService.handleError(error, injector);\r\n    }\r\n\r\n    lockUser(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/lockUserAccount`;\r\n        return this._http\r\n            .post<ResponseResult>(apiUrl, item)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    unlockUser(item: any): Promise<ResponseResult> {\r\n\r\n        const apiUrl = `${this.serviceUri}/unlockUserAccount`;\r\n        return this._http\r\n            .post<ResponseResult>(apiUrl, item)\r\n            .pipe(catchError(err => this.handleError(err, this._injector)))\r\n            .toPromise();\r\n    }\r\n\r\n    isSuperUser() {\r\n        return this._applicationContext.getRootContext().data.currentUser\r\n            && this._applicationContext.getRootContext().data.currentUser.issuperuser === 'True';\r\n    }\r\n\r\n    isAdmin() {\r\n        return this._applicationContext.getRootContext().data.currentUser\r\n            && this._applicationContext.getRootContext().data.currentUser.isadmin === 'True';\r\n    }\r\n\r\n    isValidAccessToken() {\r\n        return this._oauthService.hasValidAccessToken();\r\n    }\r\n\r\n    getUsersByGroupCode(groupCode: string): Promise<ResponseResult> {\r\n        const apiUrl = `${this.serviceUri}/GetUsersByGroupCode?groupCode=${groupCode}`;\r\n        return this._http.get<ResponseResult>(apiUrl)\r\n            .pipe(\r\n                catchError((err: HttpErrorResponse) => this._exceptionHandlerService.handleError(err, this._injector))\r\n            ).toPromise();\r\n    }\r\n\r\n    getServiceEndpoint() {\r\n        return `${this.serviceUri}`;\r\n    }\r\n\r\n    isSinhVienAccount() {\r\n        const userLogin = this.getCurrentUser();\r\n        if (userLogin) {\r\n            if (userLogin.maNguoiHoc) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    getPageUserInfo(userIds: string): Promise<BasicUserInfo[]> {\r\n        if (!userIds || userIds === '') {\r\n            return new Promise((resolve, reject) => {\r\n                resolve(<BasicUserInfo[]>[]);\r\n            });\r\n        }\r\n        const storageItem = localStorage.getItem(this.USER_INFO_KEY);\r\n        const userInfos = <BasicUserInfo[]>JSON.parse(storageItem);\r\n\r\n        // const users = userInfos ? userInfos.filter(item => userIds.indexOf(`,${item.id},`) > -1) : null;\r\n        const check = userInfos ? userIds.indexOf(userInfos['id']) > -1 : null;\r\n        if (check) {\r\n            return new Promise((resolve, reject) => resolve(userInfos));\r\n        }\r\n        else {\r\n            return new Promise((resolve, reject) => {\r\n                const svUrl = `${this.serviceUri}/GetPaged`;\r\n                const filters = [];\r\n                const itemFilter = {\r\n                    field: 'id',\r\n                    operator: 'in',\r\n                    value: userIds\r\n                };\r\n                filters.push(itemFilter);\r\n                const gridInfo = new GridInfo({\r\n                    fields: '',\r\n                    pageInfo: {\r\n                        page: 1,\r\n                        pageSize: 10000\r\n                    },\r\n                    sorts: [],\r\n                    filters: filters\r\n                });\r\n\r\n                this._http.post<ResponseResult>(svUrl, gridInfo).pipe(\r\n                    shareReplay(this.REPLAY_COUNT),\r\n                    retry(this.RETRY_COUNT),\r\n                    catchError((err: HttpErrorResponse) => this.handleError(err, this._injector)),\r\n                    map(repsonse => <BasicUserInfo[]>repsonse.data)\r\n                ).toPromise().then(success => {\r\n                    resolve(success);\r\n                }).catch(err => {\r\n                    resolve(<BasicUserInfo[]>[]);\r\n                });\r\n            });\r\n        }\r\n    }\r\n}\r\n"]}