602 lines
22 KiB
TypeScript
602 lines
22 KiB
TypeScript
import { Injectable, Logger } from '@nestjs/common';
|
|
import { OracleDBService } from 'src/db/db.service';
|
|
|
|
import * as oracledb from 'oracledb';
|
|
import { BadRequestException } from 'src/exceptions/badRequest.exception';
|
|
import { InternalServerException } from 'src/exceptions/internalServerError.exception';
|
|
import { closeOracleDbConnection, fetchCursor, handleError, setEmptyStringsToNull } from 'src/utils/helper';
|
|
|
|
import {
|
|
CLIENTLOCADDRESSTABLE_ROW_DTO, CreateClientContactsDTO, CreateClientDataDTO,
|
|
CreateClientLocationsDTO, GetPreparerByClientidContactsByClientidLocByClientidDTO,
|
|
GetPreparersDTO, UpdateClientContactsDTO, UpdateClientDTO, UpdateClientLocationsDTO,
|
|
CONTACTSTABLE_ROW_DTO
|
|
} from 'src/dto/property.dto';
|
|
import { OracleService } from '../oracle.service';
|
|
|
|
@Injectable()
|
|
export class ManageClientsService {
|
|
private readonly logger = new Logger(ManageClientsService.name);
|
|
|
|
constructor(
|
|
private readonly oracleDBService: OracleDBService,
|
|
private readonly oracleService: OracleService
|
|
) { }
|
|
|
|
CreateClientData = async (body: CreateClientDataDTO) => {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTNAME: null,
|
|
P_LOOKUPCODE: null,
|
|
P_ADDRESS1: null,
|
|
P_ADDRESS2: null,
|
|
P_CITY: null,
|
|
P_STATE: null,
|
|
P_ZIP: null,
|
|
P_COUNTRY: null,
|
|
P_ISSUINGREGION: null,
|
|
P_REVENUELOCATION: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: CreateClientDataDTO = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.CreateClientData(
|
|
:P_SPID, :P_CLIENTNAME, :P_LOOKUPCODE, :P_ADDRESS1,
|
|
:P_ADDRESS2, :P_CITY, :P_STATE, :P_ZIP,
|
|
:P_COUNTRY, :P_ISSUINGREGION, :P_REVENUELOCATION, :P_USERID,
|
|
:P_CLIENTCURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTNAME: { val: finalBody.P_CLIENTNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LOOKUPCODE: { val: finalBody.P_LOOKUPCODE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS1: { val: finalBody.P_ADDRESS1, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS2: { val: finalBody.P_ADDRESS2, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CITY: { val: finalBody.P_CITY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_STATE: { val: finalBody.P_STATE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ZIP: { val: finalBody.P_ZIP, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_COUNTRY: { val: finalBody.P_COUNTRY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ISSUINGREGION: { val: finalBody.P_ISSUINGREGION, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_REVENUELOCATION: { val: finalBody.P_REVENUELOCATION, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: finalBody.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CLIENTCURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds: any = result.outBinds;
|
|
if (!outBinds?.P_CLIENTCURSOR) {
|
|
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_CLIENTCURSOR, ManageClientsService.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" };
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
UpdateClient = async (body: UpdateClientDTO) => {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTID: null,
|
|
P_PREPARERNAME: null,
|
|
P_ADDRESS1: null,
|
|
P_ADDRESS2: null,
|
|
P_CITY: null,
|
|
P_STATE: null,
|
|
P_ZIP: null,
|
|
P_COUNTRY: null,
|
|
P_REVENUELOCATION: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: UpdateClientDTO = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.UpdateClient(
|
|
:P_SPID, :P_CLIENTID, :P_PREPARERNAME, :P_ADDRESS1,
|
|
:P_ADDRESS2, :P_CITY, :P_STATE, :P_ZIP,
|
|
:P_COUNTRY, :P_REVENUELOCATION, :P_USERID, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTID: { val: finalBody.P_CLIENTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_PREPARERNAME: { val: finalBody.P_PREPARERNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS1: { val: finalBody.P_ADDRESS1, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS2: { val: finalBody.P_ADDRESS2, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CITY: { val: finalBody.P_CITY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_STATE: { val: finalBody.P_STATE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ZIP: { val: finalBody.P_ZIP, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_COUNTRY: { val: finalBody.P_COUNTRY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_REVENUELOCATION: { val: finalBody.P_REVENUELOCATION, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: finalBody.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
await connection.commit();
|
|
|
|
const outBinds: any = 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, ManageClientsService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
return { statusCode: 200, message: "Updated Successfully" };
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
UpdateClientContacts = async (body: UpdateClientContactsDTO) => {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTCONTACTID: null,
|
|
P_FIRSTNAME: null,
|
|
P_LASTNAME: null,
|
|
P_MIDDLEINITIAL: null,
|
|
P_TITLE: null,
|
|
P_PHONENO: null,
|
|
P_FAXNO: null,
|
|
P_MOBILENO: null,
|
|
P_EMAILADDRESS: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: UpdateClientContactsDTO = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
let P_CURSOR_rows: any = [];
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.UpdateClientContacts(
|
|
:P_SPID, :P_CLIENTCONTACTID, :P_FIRSTNAME, :P_LASTNAME,
|
|
:P_MIDDLEINITIAL, :P_TITLE, :P_PHONENO, :P_FAXNO,
|
|
:P_MOBILENO, :P_EMAILADDRESS, :P_USERID, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTCONTACTID: { val: finalBody.P_CLIENTCONTACTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_FIRSTNAME: { val: finalBody.P_FIRSTNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LASTNAME: { val: finalBody.P_LASTNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_MIDDLEINITIAL: { val: finalBody.P_MIDDLEINITIAL, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_TITLE: { val: finalBody.P_TITLE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_PHONENO: { val: finalBody.P_PHONENO, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_FAXNO: { val: finalBody.P_FAXNO, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_MOBILENO: { val: finalBody.P_MOBILENO, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_EMAILADDRESS: { val: finalBody.P_EMAILADDRESS, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: finalBody.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
await connection.commit();
|
|
|
|
const outBinds: any = 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, ManageClientsService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
return { statusCode: 200, message: "Updated Successfully" };
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
UpdateClientLocations = async (body: UpdateClientLocationsDTO) => {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTLOCATIONID: null,
|
|
P_LOCATIONNAME: null,
|
|
P_ADDRESS1: null,
|
|
P_ADDRESS2: null,
|
|
P_CITY: null,
|
|
P_STATE: null,
|
|
P_ZIP: null,
|
|
P_COUNTRY: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: UpdateClientLocationsDTO = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.UpdateClientLocations(
|
|
:P_SPID, :P_CLIENTLOCATIONID, :P_LOCATIONNAME, :P_ADDRESS1,
|
|
:P_ADDRESS2, :P_CITY, :P_STATE, :P_ZIP,
|
|
:P_COUNTRY, :P_USERID, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTLOCATIONID: { val: finalBody.P_CLIENTLOCATIONID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_LOCATIONNAME: { val: finalBody.P_LOCATIONNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS1: { val: finalBody.P_ADDRESS1, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ADDRESS2: { val: finalBody.P_ADDRESS2, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CITY: { val: finalBody.P_CITY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_STATE: { val: finalBody.P_STATE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ZIP: { val: finalBody.P_ZIP, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_COUNTRY: { val: finalBody.P_COUNTRY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: finalBody.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
await connection.commit();
|
|
|
|
const outBinds: any = 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, ManageClientsService.name);
|
|
|
|
if (fres.length > 0 && fres[0].ERRORMESG) {
|
|
this.logger.warn(fres[0].ERRORMESG);
|
|
throw new BadRequestException(fres[0].ERRORMESG)
|
|
}
|
|
|
|
return { statusCode: 200, message: "Updated Successfully" };
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
async CreateClientContact(body: CreateClientContactsDTO) {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTID: null,
|
|
P_CONTACTSTABLE: null,
|
|
P_DEFCONTACTFLAG: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: CreateClientContactsDTO = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const CONTACTSTABLE_INSTANCE = await this.oracleService.get_CONTACTS_TABLE_INSTANCE(finalBody);
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.CreateClientContact(
|
|
:P_SPID, :P_CLIENTID, :P_CONTACTSTABLE, :P_DEFCONTACTFLAG, :P_USERID, :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTID: { val: finalBody.P_CLIENTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CONTACTSTABLE: { val: CONTACTSTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_DEFCONTACTFLAG: { val: finalBody.P_DEFCONTACTFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: finalBody.P_USERID, 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, ManageClientsService.name);
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
}
|
|
|
|
CreateClientLocation = async (body: CreateClientLocationsDTO) => {
|
|
const newBody = {
|
|
P_SPID: null,
|
|
P_CLIENTID: null,
|
|
p_clientlocaddresstable: null,
|
|
P_USERID: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody: CreateClientLocationsDTO = { ...newBody, ...reqBody, };
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const CLIENTLOCADDRESSTABLE_INSTANCE = await this.oracleService.get_CLIENTLOCADDRESS_TABLE_INSTANCE(finalBody);
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.CreateClientLocation(
|
|
:P_SPID, :P_CLIENTID, :P_CLIENTLOCADDRESSTABLE, :P_USERID,
|
|
:P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: finalBody.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTID: { val: finalBody.P_CLIENTID, type: oracledb.DB_TYPE_NUMBER },
|
|
p_clientlocaddresstable: { val: CLIENTLOCADDRESSTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_USERID: { val: finalBody.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds: any = 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, ManageClientsService.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" };
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
GetPreparers = async (body: GetPreparersDTO) => {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.GetPreparers(
|
|
:P_SPID, :P_NAME, :P_LOOKUPCODE, :P_CITY,
|
|
:P_STATE, :P_STATUS, :P_MAINCURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_NAME: { val: body.P_NAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LOOKUPCODE: { val: body.P_LOOKUPCODE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CITY: { val: body.P_CITY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_STATE: { val: body.P_STATE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_STATUS: { val: body.P_STATUS, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_MAINCURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{
|
|
outFormat: oracledb.OUT_FORMAT_OBJECT,
|
|
},
|
|
);
|
|
|
|
const outBinds: any = result.outBinds;
|
|
if (!outBinds?.P_MAINCURSOR) {
|
|
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_MAINCURSOR, ManageClientsService.name);
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
GetPreparerByClientid = async (body: GetPreparerByClientidContactsByClientidLocByClientidDTO) => {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.GetPreparerByClientid(
|
|
: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: any = 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, ManageClientsService.name);
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
GetPreparerContactsByClientid = async (body: GetPreparerByClientidContactsByClientidLocByClientidDTO) => {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.GetPreparerContactsByClientid(
|
|
: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: any = 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, ManageClientsService.name);
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
|
|
GetPreparerLocByClientid = async (body: GetPreparerByClientidContactsByClientidLocByClientidDTO) => {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
if (!connection) {
|
|
throw new Error('No DB Connected');
|
|
}
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
MANAGEPREPARER_PKG.GetPreparerLocByClientid(
|
|
: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: any = 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, ManageClientsService.name);
|
|
|
|
} catch (error) {
|
|
handleError(error, ManageClientsService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, ManageClientsService.name)
|
|
}
|
|
};
|
|
}
|