446 lines
17 KiB
TypeScript
446 lines
17 KiB
TypeScript
import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
|
|
import { OracleDBService } from 'src/db/db.service';
|
|
import { InternalServerException } from 'src/exceptions/internalServerError.exception';
|
|
import * as oracledb from 'oracledb';
|
|
import { closeOracleDbConnection, fetchCursor, handleError } from 'src/utils/helper';
|
|
|
|
import {
|
|
SPID_DTO,
|
|
EMAIL_DTO, USERID_DTO,
|
|
CreateClientLoginsDTO, CreateSPLoginsDTO, CreateUSCIBLoginsDTO, SPID_CLIENTID_DTO, SPID_EMAIL_DTO
|
|
} from 'src/dto/property.dto';
|
|
import { BadRequestException } from 'src/exceptions/badRequest.exception';
|
|
import { AuthService } from 'src/auth/auth.service';
|
|
import { MailTypeDTO } from 'src/auth/auth.dto';
|
|
|
|
|
|
interface RoleDetail { [key: string]: any; }
|
|
interface MenuDetail { [key: string]: any; }
|
|
interface MenuPageDetail { [key: string]: any; }
|
|
interface UserDetail { [key: string]: any; }
|
|
|
|
export interface GetUserDetailsResult {
|
|
roleDetails: RoleDetail[];
|
|
menuDetails: MenuDetail[];
|
|
menuPageDetails: MenuPageDetail[];
|
|
userDetails: UserDetail[];
|
|
}
|
|
|
|
@Injectable()
|
|
export class UserMaintenanceService {
|
|
|
|
private readonly logger = new Logger(UserMaintenanceService.name);
|
|
|
|
constructor(
|
|
private readonly oracleDBService: OracleDBService,
|
|
@Inject(forwardRef(() => AuthService))
|
|
private readonly authService: AuthService
|
|
) { }
|
|
|
|
async GetSPUserDetails(body: USERID_DTO): Promise<any> {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
SPCLIENTUSER_PKG.GetSPUserDetails(
|
|
:P_USERID, :P_ROLECUR, :P_MENUCUR, :P_MENUPAGECUR, :P_USERDETAILS
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ROLECUR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT },
|
|
P_MENUCUR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT },
|
|
P_MENUPAGECUR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT },
|
|
P_USERDETAILS: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT },
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ROLECUR || !outBinds?.P_MENUCUR || !outBinds?.P_MENUPAGECUR || !outBinds?.P_USERDETAILS) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
let roleDetailsTemp: { "ROLENAME": "" }[] = await fetchCursor(outBinds.P_ROLECUR, UserMaintenanceService.name);
|
|
let menuDetailsTemp: { "MENUNAME": "" }[] = await fetchCursor(outBinds.P_MENUCUR, UserMaintenanceService.name);
|
|
let userdetailsTemp: any = await fetchCursor(outBinds.P_USERDETAILS, UserMaintenanceService.name);
|
|
return {
|
|
roleDetails: roleDetailsTemp.map(x => x.ROLENAME),
|
|
menuDetails: menuDetailsTemp.map(x => x.MENUNAME),
|
|
menuPageDetails: await fetchCursor(outBinds.P_MENUPAGECUR, UserMaintenanceService.name),
|
|
userDetails: userdetailsTemp[0]
|
|
};
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
}
|
|
|
|
async LockUserAccount(body: SPID_EMAIL_DTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.LockUserAccount(
|
|
:P_SPID, :P_EMAILADDR, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_EMAILADDR: { val: body.P_EMAILADDR, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
}
|
|
|
|
// USCIB_LOGINS
|
|
|
|
async GetUSCIBLogins() {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.GetUSCIBLogins(
|
|
:P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
|
|
}
|
|
|
|
async CreateUSCIBLogins(body: CreateUSCIBLoginsDTO) {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.CreateUSCIBLogins(
|
|
:P_USERID , :P_EMAILADDR , :P_LOOKUPCODE , :P_ENABLEPASSWORDPOLICY, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_EMAILADDR: { val: body.P_EMAILADDR, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LOOKUPCODE: { val: body.P_LOOKUPCODE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ENABLEPASSWORDPOLICY: { val: body.P_ENABLEPASSWORDPOLICY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
const fres: any = await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
return { statusCode: 201, message: "Created successfully", ...fres[0] };
|
|
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
|
|
}
|
|
|
|
// SP LOGINS
|
|
|
|
async GetSPLogins(body: SPID_DTO) {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.GetSPLogins(
|
|
:P_SPID , :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
|
|
}
|
|
|
|
async CreateSPLogins(body: CreateSPLoginsDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.CreateSPLogins(
|
|
:P_SPID, :P_USERID, :P_DOMAIN, :P_EMAILADDR, :P_LOOKUPCODE, :P_ENABLEPASSWORDPOLICY, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_DOMAIN: { val: body.P_DOMAIN, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_EMAILADDR: { val: body.P_EMAILADDR, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LOOKUPCODE: { val: body.P_LOOKUPCODE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ENABLEPASSWORDPOLICY: { val: body.P_ENABLEPASSWORDPOLICY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
const fres: any = await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
return { statusCode: 201, message: "Created successfully", ...fres[0] };
|
|
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
}
|
|
|
|
// CLIENT LOGINS
|
|
|
|
async GetClientloginsBySPID(body: SPID_DTO) {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.GetClientloginsBySPID(
|
|
:P_SPID , :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
|
|
}
|
|
|
|
async GetClientloginsByClientID(body: SPID_CLIENTID_DTO) {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.GetClientloginsByClientID(
|
|
:P_SPID, :p_clientid , :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
p_clientid: { val: body.P_CLIENTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
|
|
}
|
|
|
|
async CreateClientLogins(body: CreateClientLoginsDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
Userlogin_pkg.CreateClientLogins(
|
|
:P_SPID, :P_USERID, :P_CLIENTCONTACTID, :P_ENABLEPASSWORDPOLICY, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CLIENTCONTACTID: { val: body.P_CLIENTCONTACTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_ENABLEPASSWORDPOLICY: { val: body.P_ENABLEPASSWORDPOLICY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
const fres: any = await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
const mailRes = await this.authService.sendMail({ P_TO: body.P_USERID, P_MAIL_TYPE: MailTypeDTO.REGISTER_CLIENT })
|
|
|
|
if (mailRes.statusCode !== 200) {
|
|
return new InternalServerException();
|
|
}
|
|
|
|
return { statusCode: 201, message: "Client registration initiated successfully", ...fres[0] };
|
|
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
}
|
|
|
|
// validate email
|
|
|
|
async ValidateEmail(body: EMAIL_DTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
userlogin_pkg.ValidateEmail(
|
|
:P_EMAILADDR, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_EMAILADDR: { val: body.P_EMAILADDR, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_CURSOR) {
|
|
this.logger.error('One or more expected cursors are missing from stored procedure output.');
|
|
throw new InternalServerException("Incomplete data received from the database.");
|
|
}
|
|
|
|
return await fetchCursor(outBinds.P_CURSOR, UserMaintenanceService.name);
|
|
} catch (error) {
|
|
handleError(error, UserMaintenanceService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, UserMaintenanceService.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
|