gemcap-be-common 1.3.187 → 1.4.1

package/services/loan-payments.service.js

@@ -16,7 +16,6 @@ const collaterals_db_1 = require("../db/collaterals.db");
 const LoanTransaction_model_1 = require("../models/LoanTransaction.model");
 const LoanProducts_model_1 = require("../models/LoanProducts.model");
 const Borrower_model_1 = require("../models/Borrower.model");
-const User_model_1 = require("../models/User.model");
 const LoanPayment_model_1 = require("../models/LoanPayment.model");
 exports.paymentOrder = [
     loan_charge_type_enum_1.ELoanChargeType.RECOVERABLE,
@@ -40,7 +39,8 @@ class LoanPaymentsService {
     loanTransactionsService;
     lockService;
     termLoanService;
-    constructor(redisClient, borrowersDB, financialComplianceService, loanChargesService, loanProductsService, loanStatementBalanceService, getLoanStatementService, loanStatementStatusService, loanTransactionsService, lockService, termLoanService) {
+    usersService;
+    constructor(redisClient, borrowersDB, financialComplianceService, loanChargesService, loanProductsService, loanStatementBalanceService, getLoanStatementService, loanStatementStatusService, loanTransactionsService, lockService, termLoanService, usersService) {
         this.redisClient = redisClient;
         this.borrowersDB = borrowersDB;
         this.financialComplianceService = financialComplianceService;
@@ -52,6 +52,7 @@ class LoanPaymentsService {
         this.loanTransactionsService = loanTransactionsService;
         this.lockService = lockService;
         this.termLoanService = termLoanService;
+        this.usersService = usersService;
     }
     async getLoanPayment(paymentId) {
         return LoanPayment_model_1.LoanPaymentModel.findById(paymentId).lean();
@@ -399,7 +400,7 @@ class LoanPaymentsService {
         }
     }
     async getExpectedPayments(userId) {
-        const user = await User_model_1.UserModel.findById(userId).lean();
+        const user = await this.usersService.getUserById(userId);
         if (!user) {
             return [];
         }
@@ -429,7 +430,7 @@ class LoanPaymentsService {
             return { message: 'Incorrect list of borrowers IDs' };
         }
         await this.redisClient.set(CALCULATION_VAR, 1);
-        const user = await User_model_1.UserModel.findById(userId).lean();
+        const user = await this.usersService.getUserById(userId);
         if (!user) {
             return { message: 'Cannot find user with this id' };
         }

package/services/loan-payments.service.ts

@@ -21,7 +21,6 @@ import {
 } from '../models/LoanTransaction.model';
 import { LoanProduct } from '../models/LoanProducts.model';
 import { BorrowerModel } from '../models/Borrower.model';
-import { UserModel } from '../models/User.model';
 import {
   ICombinedPayment,
   ILoanPaymentDoc,
@@ -40,6 +39,7 @@ import { LoanStatementStatusService } from './loan-statement-status.service';
 import { LoanTransactionsService } from './loan-transactions.service';
 import { TermLoanService } from './term-loan.service';
 import { LockService } from './lock.service';
+import { UsersService } from './users.service';
 
 export const paymentOrder = [
   ELoanChargeType.RECOVERABLE,
@@ -66,6 +66,7 @@ export class LoanPaymentsService {
     private readonly loanTransactionsService: LoanTransactionsService,
     private readonly lockService: LockService,
     private readonly termLoanService: TermLoanService,
+    private readonly usersService: UsersService,
   ) {
   }
 
@@ -446,7 +447,7 @@ export class LoanPaymentsService {
   }
 
   async getExpectedPayments(userId: string) {
-    const user = await UserModel.findById(userId).lean();
+    const user = await this.usersService.getUserById(userId);
     if (!user) {
       return [];
     }
@@ -480,7 +481,7 @@ export class LoanPaymentsService {
     }
 
     await this.redisClient.set(CALCULATION_VAR, 1);
-    const user = await UserModel.findById(userId).lean();
+    const user = await this.usersService.getUserById(userId);
     if (!user) {
       return { message: 'Cannot find user with this id' };
     }

package/services/nodemailer.service.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import { Buffer } from 'buffer';
 import { IMulterFile } from '../interfaces/multer.interface';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IEmail } from '../interfaces/email.interface';
 import { IFinancialComplianceBorrowerDocumentWithMails } from '../models/FinancialComplianceBorrower.model';
 import { FileManagerService } from './file-manager.service';
@@ -65,7 +64,6 @@ export declare class NodemailerService {
     getSignatureAsync(senderType: ESenderType, organizationSubfolder?: string): Promise<string>;
     collectItemsAndNotify(borrowerId: string): Promise<void>;
     sendEmailNotification(email: EmailWithItems, borrowerId: string): Promise<void>;
-    sendPasswordEmail(user: IKeycloakUser, password: string): Promise<void>;
     sendDailyUpdates(): Promise<void>;
     sendSimpleNotificationMail(email: IEmail): Promise<void>;
     sendFinancialExternal(email: IEmail, organizationId: string, stopFunding?: boolean): Promise<void>;

package/services/nodemailer.service.js

@@ -239,34 +239,6 @@ class NodemailerService {
             }
         });
     }
-    async sendPasswordEmail(user, password) {
-        fs.readFile(path_1.default.resolve(__dirname, '../public/emails', 'password-reset.html'), 'utf8', async (error, data) => {
-            if (error) {
-                console.error({ error });
-                return;
-            }
-            const signature = await this.getSignatureAsync(ESenderType.REGULAR);
-            const replacedData = data
-                .replace('${username}', user.username)
-                .replace('${password}', password.toString())
-                .replace('${signature}', signature);
-            try {
-                this.transporter.sendMail({
-                    from: this.getSender(ESenderType.REGULAR),
-                    to: user.email,
-                    bcc: this.config.hiddenRecipient,
-                    subject: `Welcome to ${this.config.appTitle}`,
-                    text: 'non-html',
-                    html: replacedData,
-                }, async (err, info) => {
-                    await this.senderHandler(err, info);
-                });
-            }
-            catch (e) {
-                this.sentryService.catchErrorBySentry(null, e);
-            }
-        });
-    }
     async sendDailyUpdates() {
         fs.readFile(path_1.default.resolve(__dirname, '../public/emails', 'daily-updates.html'), 'utf8', async (error, data) => {
             if (error) {

package/services/nodemailer.service.ts

@@ -5,7 +5,6 @@ import nodemailer from 'nodemailer';
 import { Buffer } from 'buffer';
 
 import { IMulterFile } from '../interfaces/multer.interface';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IEmail } from '../interfaces/email.interface';
 import { ELoanTypes } from '../enums/loan-types.enum';
 import { Organization } from '../models/Organization.model';
@@ -268,40 +267,6 @@ export class NodemailerService {
       });
   }
 
-  async sendPasswordEmail(user: IKeycloakUser, password: string) {
-    fs.readFile(
-      path.resolve(__dirname, '../public/emails', 'password-reset.html'),
-      'utf8',
-      async (error, data) => {
-        if (error) {
-          console.error({ error });
-          return;
-        }
-
-        const signature = await this.getSignatureAsync(ESenderType.REGULAR);
-
-        const replacedData = data
-          .replace('${username}', user.username)
-          .replace('${password}', password.toString())
-          .replace('${signature}', signature);
-
-        try {
-          this.transporter.sendMail({
-            from: this.getSender(ESenderType.REGULAR),
-            to: user.email,
-            bcc: this.config.hiddenRecipient,
-            subject: `Welcome to ${this.config.appTitle}`,
-            text: 'non-html',
-            html: replacedData,
-          }, async (err, info) => {
-            await this.senderHandler(err, info);
-          });
-        } catch (e) {
-          this.sentryService.catchErrorBySentry(null, e);
-        }
-      });
-  }
-
   async sendDailyUpdates() {
     fs.readFile(
       path.resolve(__dirname, '../public/emails', 'daily-updates.html'),

package/services/signs.service.d.ts

@@ -24,16 +24,16 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from 'mongoose';
 import { IResult } from '../interfaces/result.interface';
-import { IUserDocument } from '../models/User.model';
+import { IUserLegacyDoc } from '../models/User.model';
 import { IAvailabilitySignView } from '../models/AvailabilitySigns.model';
 import { IBBCDateDoc } from '../models/BBCDate.model';
 import { IBorrowerDocument } from '../models/Borrower.model';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IPaginatorOptions } from '../interfaces/collaterals.interface';
 import { UsersService } from './users.service';
 import { LoanTransactionsService } from './loan-transactions.service';
 import { LockService } from './lock.service';
 import { LoanStatementService } from './loan-statement.service';
+import { IUser } from '../interfaces/auth-user.interface';
 export interface IBBCDateWithBorrower extends Document {
     borrowerId: IBorrowerDocument;
     bbcDate: Date;
@@ -49,12 +49,12 @@ export declare class SignsService {
     private readonly loanStatementService;
     private readonly usersService;
     constructor(lockService: LockService, loanTransactionsService: LoanTransactionsService, loanStatementService: LoanStatementService, usersService: UsersService);
-    keyCloakUsers: IKeycloakUser[];
+    keyCloakUsers: IUser[];
     fulfillUserList(): Promise<void>;
     clearUserList(): void;
     getAvailabilitySigns(bbcDateId: string): Promise<IAvailabilitySignView>;
     revokeAvailability(bbcDateId: string, userId: string, userIdRevoked: string): Promise<void>;
-    signAvailability(bbcDateId: string, user: IUserDocument): Promise<IResult>;
+    signAvailability(bbcDateId: string, user: IUserLegacyDoc): Promise<IResult>;
     isBBCLocked(bbcDateId: string): Promise<boolean>;
     getLatestSignedBBCDate(borrowerId: string, date?: Date): Promise<IBBCDateDoc>;
     getSavedData(bbcDateId: string): Promise<any>;

package/services/signs.service.js

@@ -34,8 +34,7 @@ class SignsService {
     }
     keyCloakUsers = null;
     async fulfillUserList() {
-        const { access_token } = await this.usersService.getKeyCloakAdminBearer();
-        this.keyCloakUsers = await this.usersService.getUserList(access_token);
+        this.keyCloakUsers = await this.usersService.getUserList();
     }
     clearUserList() {
         this.keyCloakUsers = null;
@@ -53,8 +52,7 @@ class SignsService {
         const availabilitySigns = availabilitiesSigns[0];
         let keyCloakUsers = this.keyCloakUsers;
         if (!keyCloakUsers) {
-            const { access_token } = await this.usersService.getKeyCloakAdminBearer();
-            keyCloakUsers = await this.usersService.getUserList(access_token);
+            keyCloakUsers = await this.usersService.getUserList();
         }
         availabilitySigns.signs = availabilitySigns.signs.reduce((acc, userSign) => {
             if (!userSign.userSigned) {

package/services/signs.service.ts

@@ -8,7 +8,7 @@ import {
   getAvailabilitySigns,
   updateAvailabilitySigns,
 } from '../db/availability.db';
-import { IUserDocument } from '../models/User.model';
+import { IUserLegacyDoc } from '../models/User.model';
 import {
   AvailabilitySignsModel,
   IAvailabilitySignItem,
@@ -21,15 +21,14 @@ import { getOlderBBCDates } from '../db/bbcDates.db';
 import { ELogActionType, ELogType } from '../models/UserLog.model';
 import { createLog, ICreateLogParams } from '../db/user-logs.db';
 import { IBorrowerDocument } from '../models/Borrower.model';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IPaginatorOptions } from '../interfaces/collaterals.interface';
 import { ITEMS_PAGINATION } from '../db/collaterals.db';
 import { UsersService } from './users.service';
-
 import { AvailabilitySignedData } from '../models/AvilabilitySignedData.model';
 import { LoanTransactionsService } from './loan-transactions.service';
 import { LockService } from './lock.service';
 import { LoanStatementService } from './loan-statement.service';
+import { IUser } from '../interfaces/auth-user.interface';
 
 export interface IBBCDateWithBorrower extends Document {
   borrowerId: IBorrowerDocument;
@@ -52,11 +51,10 @@ export class SignsService {
   ) {
   }
 
-  keyCloakUsers: IKeycloakUser[] = null;
+  keyCloakUsers: IUser[] = null;
 
   async fulfillUserList() {
-    const { access_token } = await this.usersService.getKeyCloakAdminBearer();
-    this.keyCloakUsers = await this.usersService.getUserList(access_token);
+    this.keyCloakUsers = await this.usersService.getUserList();
   }
 
   clearUserList() {
@@ -76,8 +74,7 @@ export class SignsService {
     const availabilitySigns = availabilitiesSigns[0];
     let keyCloakUsers = this.keyCloakUsers;
     if (!keyCloakUsers) {
-      const { access_token } = await this.usersService.getKeyCloakAdminBearer();
-      keyCloakUsers = await this.usersService.getUserList(access_token);
+      keyCloakUsers = await this.usersService.getUserList();
     }
     availabilitySigns.signs = availabilitySigns.signs.reduce((acc, userSign) => {
       if (!userSign.userSigned) {
@@ -88,14 +85,14 @@ export class SignsService {
         userSign.userSigned.firstName = foundUserSigned.firstName;
         userSign.userSigned.lastName = foundUserSigned.lastName;
       }
-      userSign.userSigned = (_.pick(userSign.userSigned, ['_id', 'firstName', 'lastName'])) as IUserDocument;
+      userSign.userSigned = (_.pick(userSign.userSigned, ['_id', 'firstName', 'lastName'])) as IUserLegacyDoc;
       if (userSign.userRevoked) {
         const foundUserRevoked = keyCloakUsers.find((user) => user.id === userSign.userRevoked.keycloakUserId);
         if (foundUserRevoked) {
           userSign.userRevoked.firstName = foundUserRevoked.firstName;
           userSign.userRevoked.lastName = foundUserRevoked.lastName;
         }
-        userSign.userRevoked = (_.pick(userSign.userRevoked, ['_id', 'firstName', 'lastName'])) as IUserDocument;
+        userSign.userRevoked = (_.pick(userSign.userRevoked, ['_id', 'firstName', 'lastName'])) as IUserLegacyDoc;
       }
       return [...acc, _.pick(userSign, ['userSigned', 'signedAt', 'userRevoked', 'revokedAt'])];
     }, []);
@@ -115,7 +112,7 @@ export class SignsService {
     await updateAvailabilitySigns(bbcDateId, updatedSigns);
   }
 
-  async signAvailability(bbcDateId: string, user: IUserDocument): Promise<IResult> {
+  async signAvailability(bbcDateId: string, user: IUserLegacyDoc): Promise<IResult> {
     const newSign = <IAvailabilitySignItem>{ userSignedId: user._id, signedAt: new Date() };
     return await addAvailabilitySign(bbcDateId, newSign);
   }

package/services/uploads.service.d.ts

@@ -37,6 +37,7 @@ import { QuickbooksService } from './quickbooks.service';
 import { UserLogsService } from './user-logs.service';
 import { LockService } from './lock.service';
 import { BorrowersDB } from './borrowers.db';
+import { UsersService } from './users.service';
 interface IMappedColumns {
     [columnName: string]: number;
 }
@@ -73,7 +74,8 @@ export declare class UploadsService {
     private readonly getLockService;
     private readonly userLogsService;
     private readonly borrowersDB;
-    constructor(rootDir: string, bankUploadedTransactionsService: BankUploadedTransactionsService, getCollateralsService: () => CollateralsService, getLoanTransactionsService: () => LoanTransactionsService, getQuickbooksService: () => QuickbooksService, getLockService: () => LockService, userLogsService: UserLogsService, borrowersDB: BorrowersDB);
+    private readonly usersService;
+    constructor(rootDir: string, bankUploadedTransactionsService: BankUploadedTransactionsService, getCollateralsService: () => CollateralsService, getLoanTransactionsService: () => LoanTransactionsService, getQuickbooksService: () => QuickbooksService, getLockService: () => LockService, userLogsService: UserLogsService, borrowersDB: BorrowersDB, usersService: UsersService);
     createUploadFile(file: IMulterFile, borrowerId: string, userId: string, uploadType: EUploadTypes): Promise<mongoose.Document<unknown, {}, IUploadedFileDoc> & IUploadedFileDoc & {
         _id: mongoose.Types.ObjectId;
     }>;

package/services/uploads.service.js

@@ -48,7 +48,6 @@ const InventoryManualEntry_model_1 = require("../models/InventoryManualEntry.mod
 const UserLog_model_1 = require("../models/UserLog.model");
 const microservice_tasks_db_1 = require("../db/microservice-tasks.db");
 const microservice_task_enum_1 = require("../enums/microservice-task.enum");
-const User_model_1 = require("../models/User.model");
 const UploadedFile_model_1 = __importDefault(require("../models/UploadedFile.model"));
 const UploadedSheet_model_1 = __importDefault(require("../models/UploadedSheet.model"));
 const UploadedData_model_1 = __importDefault(require("../models/UploadedData.model"));
@@ -101,7 +100,8 @@ class UploadsService {
     getLockService;
     userLogsService;
     borrowersDB;
-    constructor(rootDir, bankUploadedTransactionsService, getCollateralsService, getLoanTransactionsService, getQuickbooksService, getLockService, userLogsService, borrowersDB) {
+    usersService;
+    constructor(rootDir, bankUploadedTransactionsService, getCollateralsService, getLoanTransactionsService, getQuickbooksService, getLockService, userLogsService, borrowersDB, usersService) {
         this.rootDir = rootDir;
         this.bankUploadedTransactionsService = bankUploadedTransactionsService;
         this.getCollateralsService = getCollateralsService;
@@ -110,6 +110,7 @@ class UploadsService {
         this.getLockService = getLockService;
         this.userLogsService = userLogsService;
         this.borrowersDB = borrowersDB;
+        this.usersService = usersService;
     }
     async createUploadFile(file, borrowerId, userId, uploadType) {
         const borrowerIdToWrite = new mongoose_1.default.Types.ObjectId(borrowerId);
@@ -402,7 +403,7 @@ class UploadsService {
                 default: {
                     const collateralsService = this.getCollateralsService();
                     const bbcDateId = await collateralsService.saveCollateralItems(newCollateralData, collaterals_enum_1.ECollaterals[mapData.sheetType]);
-                    const user = await User_model_1.UserModel.findById(userId).lean();
+                    const user = await this.usersService.getUserById(userId);
                     if (user) {
                         const params = {
                             borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),

package/services/uploads.service.ts

@@ -27,7 +27,6 @@ import { InventoryManualEntryModel } from '../models/InventoryManualEntry.model'
 import { ELogActionType, ELogType } from '../models/UserLog.model';
 import { createMicroserviceTasks } from '../db/microservice-tasks.db';
 import { EMicroserviceTask } from '../enums/microservice-task.enum';
-import { UserModel } from '../models/User.model';
 
 import UploadedFile, { IUploadedFile, IUploadedFileDoc } from '../models/UploadedFile.model';
 import UploadedSheet, {
@@ -53,6 +52,7 @@ import { QuickbooksService } from './quickbooks.service';
 import { UserLogsService } from './user-logs.service';
 import { LockService } from './lock.service';
 import { BorrowersDB } from './borrowers.db';
+import { UsersService } from './users.service';
 
 interface IMappedColumns {
   [columnName: string]: number;
@@ -129,6 +129,7 @@ export class UploadsService {
     private readonly getLockService: () => LockService,
     private readonly userLogsService: UserLogsService,
     private readonly borrowersDB: BorrowersDB,
+    private readonly usersService: UsersService,
   ) {
   }
 
@@ -454,7 +455,7 @@ export class UploadsService {
         default: {
           const collateralsService = this.getCollateralsService();
           const bbcDateId = await collateralsService.saveCollateralItems(newCollateralData, ECollaterals[mapData.sheetType]);
-          const user = await UserModel.findById(userId).lean();
+          const user = await this.usersService.getUserById(userId);
           if (user) {
             const params = {
               borrowerId: new mongoose.Types.ObjectId(borrowerId),

package/services/users.service.d.ts

@@ -24,159 +24,37 @@
 /// <reference types="mongoose/types/inferschematype" />
 import express from 'express';
 import mongoose from 'mongoose';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
-import { IUser, IUserDocument } from '../models/User.model';
-import { IGroupedKeycloakRoles, IKeycloakRole } from '../interfaces/keycloak-role.interface';
+import { IUser } from '../interfaces/auth-user.interface';
 interface IKeycloakConfig {
     keycloakHost: string;
     realm: string;
     adminUser: string;
     adminPass: string;
+    baseUrl: string;
 }
 export declare class UsersService {
     private readonly config;
     constructor(config: IKeycloakConfig);
-    getUserByKeyCloakId(keycloakUserId: string): Promise<IUserDocument>;
-    getUserByToken(req: express.Request): Promise<IUserDocument>;
-    getUserIdByToken(req: express.Request): Promise<string>;
-    getUserRepresentationById(authorization: string, userId: string): Promise<IKeycloakUser>;
-    getUserRepresentationByUsername(authorization: string, username: string): Promise<IKeycloakUser>;
-    getKeyCloakAdminBearer(): Promise<any>;
-    getUserList(authorization: string): Promise<IKeycloakUser[]>;
-    getUsersWithRoles(authorization: string): Promise<{
-        keycloakUserId: string;
-        _id: any;
-        allBorrowers: boolean;
-        borrowersAccess: mongoose.FlattenMaps<{
-            borrower: string;
-        }>[];
-        lastLogin: Date;
-        mobileAccess: {
-            hasAccess: boolean;
-            canSignDocument: boolean;
-        };
-        email: string;
-        firstName: string;
-        lastName: string;
-        enabled: boolean;
-        username: string;
-        roles?: IGroupedKeycloakRoles;
-        emailVerified: boolean;
-        access: {
-            manageGroupMembership: boolean;
-            view: boolean;
-            mapRoles: boolean;
-            impersonate: boolean;
-            manage: boolean;
-        };
-        impersonate: boolean;
-        manage: boolean;
-        manageGroupMembership: boolean;
-        mapRoles: boolean;
-        view: boolean;
-        createdTimestamp: number;
-        disableableCredentialTypes: any[];
-        notBefore: number;
-        requiredActions: any[];
-        totp: boolean;
-        attributes?: {
-            [key: string]: string[];
-        };
-    }[]>;
-    getUserRoles(authorization: string, userId: string): Promise<{
-        realmMappings: IKeycloakRole[];
-    }>;
-    createUser(authorization: string, user: any): Promise<any>;
-    updateUser(authorization: string, userId: string, keyValue: any): Promise<any>;
+    getUserAccessByRequest(req: express.Request): Promise<IUser | null>;
+    getUserById(userId: string): Promise<IUser | null>;
+    getUserByUsername(username: string): Promise<IUser | null>;
+    getUserByToken(req: express.Request): Promise<IUser | null>;
+    getUserIdByToken(req: express.Request): Promise<string | null>;
+    getUserList(): Promise<IUser[]>;
+    getUserRoles(userId: string): Promise<Record<string, string[]>>;
     updateMobileUser(userId: string, keyValue: {
         [key: string]: string | number | boolean;
     }): Promise<void>;
-    updateUserAccess(keycloakUserId: string, userAccess: any): Promise<void>;
-    removeUserRoles(authorization: string, userId: string, roles: IKeycloakRole[]): Promise<any>;
-    addUserRoles(authorization: string, userId: string, roles: IKeycloakRole[]): Promise<any>;
-    resetPassword(authorization: string, userId: string, temporaryPassword: string): Promise<any>;
-    createNewPasswordWithEmail(authorization: string, userId: string, newPassword: string): Promise<import("axios").AxiosResponse<any, any>>;
-    deleteUser(authorization: string, userId: string): Promise<void>;
-    getRoleList(authorization: string): Promise<IKeycloakRole[]>;
-    groupRoles(roles: IKeycloakRole[]): IGroupedKeycloakRoles;
-    mapRolesToUsers(authorization: string, users: IKeycloakUser[]): Promise<{
-        roles: IGroupedKeycloakRoles;
-        id: string;
-        username: string;
-        firstName: string;
-        lastName: string;
-        enabled: boolean;
-        email: string;
-        emailVerified: boolean;
-        access: {
-            manageGroupMembership: boolean;
-            view: boolean;
-            mapRoles: boolean;
-            impersonate: boolean;
-            manage: boolean;
-        };
-        impersonate: boolean;
-        manage: boolean;
-        manageGroupMembership: boolean;
-        mapRoles: boolean;
-        view: boolean;
-        createdTimestamp: number;
-        disableableCredentialTypes: any[];
-        notBefore: number;
-        requiredActions: any[];
-        totp: boolean;
-        attributes?: {
-            [key: string]: string[];
-        };
-    }[]>;
-    addUserAccess(users: IKeycloakUser[]): Promise<{
-        keycloakUserId: string;
-        _id: any;
+    getUserAccess(userId: string): Promise<{
         allBorrowers: boolean;
-        borrowersAccess: mongoose.FlattenMaps<{
-            borrower: string;
-        }>[];
-        lastLogin: Date;
-        mobileAccess: {
-            hasAccess: boolean;
-            canSignDocument: boolean;
-        };
-        email: string;
-        firstName: string;
-        lastName: string;
-        enabled: boolean;
-        username: string;
-        roles?: IGroupedKeycloakRoles;
-        emailVerified: boolean;
-        access: {
-            manageGroupMembership: boolean;
-            view: boolean;
-            mapRoles: boolean;
-            impersonate: boolean;
-            manage: boolean;
-        };
-        impersonate: boolean;
-        manage: boolean;
-        manageGroupMembership: boolean;
-        mapRoles: boolean;
-        view: boolean;
-        createdTimestamp: number;
-        disableableCredentialTypes: any[];
-        notBefore: number;
-        requiredActions: any[];
-        totp: boolean;
-        attributes?: {
-            [key: string]: string[];
-        };
-    }[]>;
-    getUserAccess(keycloakUserId: string): Promise<IUser>;
-    getUserAccessByRequest(req: any): Promise<IUser>;
-    updateUserLastLogin(authorization: string): Promise<void>;
+        borrowersAccess: string[];
+        complianceBorrowersAccess: {
+            borrower: any;
+        }[];
+    }>;
     createUserLoginLog(): Promise<void>;
     getUserLogByDate(userId: string, date: Date): Promise<mongoose.FlattenMaps<import("../models/UserLog.model").IUserLog> & Required<{
         _id: mongoose.Types.ObjectId;
     }>>;
-    getUserSecrets(keycloakUserId: string, adminAccessToken: string): Promise<void>;
-    updateUserNames(): Promise<void>;
 }
 export {};