836 lines
37 KiB
TypeScript
836 lines
37 KiB
TypeScript
import { Injectable, Logger } from '@nestjs/common';
|
|
import { OracleDBService } from 'src/db/db.service';
|
|
import * as oracledb from 'oracledb'
|
|
import { InternalServerException } from 'src/exceptions/internalServerError.exception';
|
|
import { closeOracleDbConnection, fetchCursor, handleError, setEmptyStringsToNull } from 'src/utils/helper';
|
|
|
|
import {
|
|
CarnetProcessingCenterDTO, SaveCarnetApplicationDTO, TransmitApplicationtoProcessDTO,
|
|
CreateApplicationDTO,
|
|
UpdateExpGoodsAuthRepDTO,
|
|
AddGenerallistItemsDTO,
|
|
AddCountriesDTO,
|
|
UpdateShippingDetailsDTO,
|
|
CA_UpdateHolderDTO,
|
|
GetCarnetControlCenterDTO
|
|
} from 'src/dto/property.dto';
|
|
import { OracleService } from '../oracle.service';
|
|
|
|
@Injectable()
|
|
export class CarnetApplicationService {
|
|
|
|
private readonly logger = new Logger(CarnetApplicationService.name);
|
|
|
|
constructor(
|
|
private readonly oracleDBService: OracleDBService,
|
|
private readonly oracleService: OracleService
|
|
) { }
|
|
|
|
// [ CARNETAPPLICATION_PKG ]
|
|
|
|
async SaveCarnetApplication(body: SaveCarnetApplicationDTO) {
|
|
|
|
const newBody = {
|
|
P_SPID: null, //
|
|
P_CLIENTID: null,
|
|
P_LOCATIONID: null,
|
|
P_USERID: null, //
|
|
P_HEADERID: null,
|
|
P_APPLICATIONNAME: null,
|
|
P_HOLDERID: null,
|
|
P_COMMERCIALSAMPLEFLAG: null,
|
|
P_PROFEQUIPMENTFLAG: null,
|
|
P_EXHIBITIONSFAIRFLAG: null,
|
|
P_AUTOFLAG: null,
|
|
P_HORSEFLAG: null,
|
|
P_AUTHREP: null,
|
|
P_GLTABLE: null,
|
|
P_USSETS: null,
|
|
P_COUNTRYTABLE: null,
|
|
P_SHIPTOTYPE: null,
|
|
P_SHIPADDRID: null,
|
|
P_FORMOFSECURITY: null,
|
|
P_INSPROTECTION: null,
|
|
P_LDIPROTECTION: null,
|
|
P_DELIVERYTYPE: null,
|
|
P_DELIVERYMETHOD: null,
|
|
P_PAYMENTMETHOD: null,
|
|
P_CUSTCOURIERNO: null,
|
|
P_REFNO: null,
|
|
P_NOTES: null,
|
|
};
|
|
|
|
const reqBody = JSON.parse(JSON.stringify(body));
|
|
|
|
|
|
setEmptyStringsToNull(reqBody);
|
|
|
|
const finalBody = { ...newBody, ...reqBody };
|
|
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
// const res = await connection.execute(`SELECT CARNETSYS.GLARRAY(1, 'Description for itemno 1', 2500, 20, 12, 'LBS', 'US') FROM dual`);
|
|
|
|
// return res;
|
|
|
|
// const GLTABLE = await connection.getDbObjectClass('CARNETSYS.GLTABLE');
|
|
|
|
// if (typeof GLTABLE !== 'function') {
|
|
// throw new InternalServerException('GLTABLE is not a constructor');
|
|
// }
|
|
|
|
// async function createGLArrayInstance(
|
|
// ITEMNO,
|
|
// ITEMDESCRIPTION,
|
|
// ITEMVALUE,
|
|
// NOOFPIECES,
|
|
// ITEMWEIGHT,
|
|
// ITEMWEIGHTUOM,
|
|
// GOODSORIGINCOUNTRY,
|
|
// ) {
|
|
// const result = await connection.execute(
|
|
// `SELECT CARNETSYS.GLARRAY(:ITEMNO, :ITEMDESCRIPTION, :ITEMVALUE, :NOOFPIECES, :ITEMWEIGHT, :ITEMWEIGHTUOM, :GOODSORIGINCOUNTRY) FROM dual`,
|
|
// {
|
|
// ITEMNO,
|
|
// ITEMDESCRIPTION,
|
|
// ITEMVALUE,
|
|
// NOOFPIECES,
|
|
// ITEMWEIGHT,
|
|
// ITEMWEIGHTUOM,
|
|
// GOODSORIGINCOUNTRY,
|
|
// },
|
|
// );
|
|
// console.log(result.rows);
|
|
|
|
// return result.rows[0][0];
|
|
// }
|
|
|
|
// const GLTABLE_ARRAY: GLTABLE_DTO = {
|
|
// P_GLTABLE: await Promise.all(
|
|
// (finalBody.P_GLTABLE ?? []).map(async (x: GLTABLE_ROW_DTO) => {
|
|
// return await createGLArrayInstance(
|
|
// x.ITEMNO,
|
|
// x.ITEMDESCRIPTION,
|
|
// x.ITEMVALUE,
|
|
// x.NOOFPIECES,
|
|
// x.ITEMWEIGHT,
|
|
// x.ITEMWEIGHTUOM,
|
|
// x.GOODSORIGINCOUNTRY,
|
|
// );
|
|
// })
|
|
// )
|
|
// };
|
|
|
|
// const GLTABLE_INSTANCE = new GLTABLE(GLTABLE_ARRAY.P_GLTABLE ?? []);
|
|
const GLTABLE_INSTANCE = await this.oracleService.get_GL_TABLE_INSTANCE(finalBody);
|
|
|
|
// const COUNTRYTABLE = await connection.getDbObjectClass('CARNETSYS.CARNETCOUNTRYTABLE');
|
|
|
|
// if (typeof COUNTRYTABLE !== 'function') {
|
|
// throw new Error('COUNTRYTABLE is not a constructor');
|
|
// }
|
|
|
|
// async function createCarnetCountryArrayInstance(
|
|
// P_VISISTTRANSITIND,
|
|
// COUNTRYCODE,
|
|
// NOOFTIMESENTLEAVE,
|
|
// ) {
|
|
// const result = await connection.execute(
|
|
// `SELECT CARNETSYS.CARNETCOUNTRYARRAY(:P_VISISTTRANSITIND, :COUNTRYCODE, :NOOFTIMESENTLEAVE) FROM dual`,
|
|
// {
|
|
// P_VISISTTRANSITIND,
|
|
// COUNTRYCODE,
|
|
// NOOFTIMESENTLEAVE,
|
|
// },
|
|
// );
|
|
// console.log(result.rows);
|
|
// return result.rows[0][0];
|
|
// }
|
|
|
|
// const COUNTRYTABLE_ARRAY: COUNTRYTABLE_DTO = {
|
|
// P_COUNTRYTABLE: await Promise.all(
|
|
// (finalBody.P_COUNTRYTABLE ?? []).map(async (x: COUNTRYTABLE_ROW_DTO) => {
|
|
// return await createCarnetCountryArrayInstance(
|
|
// x.P_VISISTTRANSITIND,
|
|
// x.COUNTRYCODE,
|
|
// x.NOOFTIMESENTLEAVE,
|
|
// );
|
|
// })
|
|
// )
|
|
// };
|
|
|
|
|
|
// const COUNTRYTABLE_INSTANCE = new COUNTRYTABLE(COUNTRYTABLE_ARRAY.P_COUNTRYTABLE ?? []);
|
|
|
|
const COUNTRYTABLE_INSTANCE = await this.oracleService.get_COUNTRY_TABLE_INSTANCE(finalBody);
|
|
|
|
|
|
// return { aa:GLTABLE_ARRAY, ab:COUNTRYTABLE_ARRAY, a: GLTABLE_INSTANCE, b: COUNTRYTABLE_INSTANCE }
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.SaveCarnetApplication(
|
|
:P_SPID, :P_CLIENTID, :P_LOCATIONID, :P_USERID, :P_HEADERID, :P_APPLICATIONNAME, :P_HOLDERID, :P_COMMERCIALSAMPLEFLAG, :P_PROFEQUIPMENTFLAG, :P_EXHIBITIONSFAIRFLAG, :P_AUTOFLAG, :P_HORSEFLAG, :P_AUTHREP, :P_GLTABLE, :P_USSETS, :P_COUNTRYTABLE, :P_SHIPTOTYPE, :P_SHIPADDRID, :P_FORMOFSECURITY, :P_INSPROTECTION, :P_LDIPROTECTION, :P_DELIVERYTYPE, :P_DELIVERYMETHOD, :P_PAYMENTMETHOD, :P_CUSTCOURIERNO, :P_REFNO, :P_NOTES, :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_LOCATIONID: { val: body.P_LOCATIONID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_APPLICATIONNAME: { val: body.P_APPLICATIONNAME, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_HOLDERID: { val: body.P_HOLDERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_COMMERCIALSAMPLEFLAG: { val: body.P_COMMERCIALSAMPLEFLAG, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_PROFEQUIPMENTFLAG: { val: body.P_PROFEQUIPMENTFLAG, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_EXHIBITIONSFAIRFLAG: { val: body.P_EXHIBITIONSFAIRFLAG, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_AUTOFLAG: { val: body.P_AUTOFLAG, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_HORSEFLAG: { val: body.P_HORSEFLAG, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_AUTHREP: { val: body.P_AUTHREP, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_GLTABLE: { val: GLTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_USSETS: { val: body.P_USSETS, type: oracledb.DB_TYPE_NUMBER },
|
|
// P_COUNTRYTABLE: { val: COUNTRYTABLE_INSTANCE, type: 'CARNETSYS.CARNETCOUNTRYTABLE' },
|
|
P_COUNTRYTABLE: { val: COUNTRYTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_SHIPTOTYPE: { val: body.P_SHIPTOTYPE, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_SHIPADDRID: { val: body.P_SHIPADDRID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_FORMOFSECURITY: { val: body.P_FORMOFSECURITY, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_INSPROTECTION: { val: body.P_INSPROTECTION, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_LDIPROTECTION: { val: body.P_LDIPROTECTION, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_DELIVERYTYPE: { val: body.P_DELIVERYTYPE, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_DELIVERYMETHOD: { val: body.P_DELIVERYMETHOD, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_PAYMENTMETHOD: { val: body.P_PAYMENTMETHOD, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_CUSTCOURIERNO: { val: body.P_CUSTCOURIERNO, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_REFNO: { val: body.P_REFNO, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_NOTES: { val: body.P_NOTES, type: oracledb.DB_TYPE_VARCHAR },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async TransmitApplicationtoProcess(body: TransmitApplicationtoProcessDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.TransmitApplicationtoProcess(
|
|
:P_SPID, :P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async CreateApplication(body: CreateApplicationDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.CreateApplication(
|
|
:P_SPID, :P_CLIENTID, :P_LOCATIONID, :P_USERID,
|
|
:P_APPLICATIONNAME, :P_ORDERTYPE, :P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_SPID: { val: body.P_SPID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CLIENTID: { val: body.P_CLIENTID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_LOCATIONID: { val: body.P_LOCATIONID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_APPLICATIONNAME: { val: body.P_APPLICATIONNAME, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ORDERTYPE: { val: body.P_ORDERTYPE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async UpdateHolder(body: CA_UpdateHolderDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.UpdateHolder(
|
|
:P_HEADERID, :P_HOLDERID, :P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HOLDERID: { val: body.P_HOLDERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async UpdateExpGoodsAuthRep(body: UpdateExpGoodsAuthRepDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.UpdateExpGoodsAuthRep(
|
|
:P_HEADERID, :P_COMMERCIALSAMPLEFLAG, :P_PROFEQUIPMENTFLAG,
|
|
:P_EXHIBITIONSFAIRFLAG, :P_AUTOFLAG, :P_HORSEFLAG, :P_AUTHREP,
|
|
:P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_COMMERCIALSAMPLEFLAG: { val: body.P_COMMERCIALSAMPLEFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_PROFEQUIPMENTFLAG: { val: body.P_PROFEQUIPMENTFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_EXHIBITIONSFAIRFLAG: { val: body.P_EXHIBITIONSFAIRFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_AUTOFLAG: { val: body.P_AUTOFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_HORSEFLAG: { val: body.P_HORSEFLAG, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_AUTHREP: { val: body.P_AUTHREP, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR }
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async AddGenerallistItems(body: AddGenerallistItemsDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const GLTABLE_INSTANCE = await this.oracleService.get_GL_TABLE_INSTANCE(body);
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.AddGenerallistItems(
|
|
:P_HEADERID, :P_GLTABLE, :P_USERID, :P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_GLTABLE: { val: GLTABLE_INSTANCE, type: 'CARNETSYS.GLTABLE' },
|
|
// P_GLTABLE: { val: GLTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async AddCountries(body: AddCountriesDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const COUNTRYTABLE_INSTANCE = await this.oracleService.get_COUNTRY_TABLE_INSTANCE(body);
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.AddCountries(
|
|
:P_HEADERID, :P_USSETS, :P_COUNTRYTABLE, :P_USERID, :P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_USSETS: { val: body.P_USSETS, type: oracledb.DB_TYPE_NUMBER },
|
|
P_COUNTRYTABLE: { val: COUNTRYTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT, typeName: 'CARNETCOUNTRYTABLE' },
|
|
// P_COUNTRYTABLE: { val: COUNTRYTABLE_INSTANCE, type: 'CARNETSYS.GLTABLE' },
|
|
// P_COUNTRYTABLE: { val: COUNTRYTABLE_INSTANCE, type: oracledb.DB_TYPE_OBJECT },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
async UpdateShippingDetails(body: UpdateShippingDetailsDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETAPPLICATION_PKG.UpdateHolder(
|
|
:P_HEADERID, :P_SHIPTOTYPE, :P_SHIPADDRID, :P_FORMOFSECURITY, :P_INSPROTECTION,
|
|
:P_LDIPROTECTION, :P_DELIVERYTYPE, :P_DELIVERYMETHOD, :P_PAYMENTMETHOD,
|
|
:P_CUSTCOURIERNO, :P_REFNO, :P_NOTES, :P_USERID, :P_ERRORMESG
|
|
);
|
|
END;`,
|
|
{
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_SHIPTOTYPE: { val: body.P_SHIPTOTYPE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_SHIPADDRID: { val: body.P_SHIPADDRID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_FORMOFSECURITY: { val: body.P_FORMOFSECURITY, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_INSPROTECTION: { val: body.P_INSPROTECTION, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_LDIPROTECTION: { val: body.P_LDIPROTECTION, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_DELIVERYTYPE: { val: body.P_DELIVERYTYPE, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_DELIVERYMETHOD: { val: body.P_DELIVERYMETHOD, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_PAYMENTMETHOD: { val: body.P_PAYMENTMETHOD, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_CUSTCOURIERNO: { val: body.P_CUSTCOURIERNO, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_REFNO: { val: body.P_REFNO, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_NOTES: { val: body.P_NOTES, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NVARCHAR },
|
|
P_ERRORMESG: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// P_CURSOR: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT }
|
|
},
|
|
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
|
|
);
|
|
|
|
await connection.commit();
|
|
|
|
const outBinds = result.outBinds;
|
|
if (!outBinds?.P_ERRORMESG) {
|
|
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_ERRORMESG, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
// processing [ PROCESSINGCENTER_PKG ]
|
|
|
|
async ProcessOriginalCarnet(body: CarnetProcessingCenterDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
PROCESSINGCENTER_PKG.ProcessOriginalCarnet(
|
|
:P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async UpdatePrintCarnet(body: CarnetProcessingCenterDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
PROCESSINGCENTER_PKG.UpdatePrintCarnet(
|
|
:P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async VoidCarnet(body: CarnetProcessingCenterDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
PROCESSINGCENTER_PKG.VoidCarnet(
|
|
:P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async DuplicateCarnet(body: CarnetProcessingCenterDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
PROCESSINGCENTER_PKG.DuplicateCarnet(
|
|
:P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async CloseCarnet(body: CarnetProcessingCenterDTO) {
|
|
let connection;
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
PROCESSINGCENTER_PKG.CloseCarnet(
|
|
:P_USERID, :P_HEADERID :P_CURSOR
|
|
);
|
|
END;`,
|
|
{
|
|
P_USERID: { val: body.P_USERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_HEADERID: { val: body.P_HEADERID, type: oracledb.DB_TYPE_NUMBER },
|
|
P_CURSOR: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR },
|
|
// 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
|
|
// [ CARNETCONTROLCENTER_PKG ]
|
|
|
|
async GetHolderstoEdit(body: GetCarnetControlCenterDTO) {
|
|
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETCONTROLCENTER_PKG.GetHolderstoEdit(
|
|
:P_SPID, :P_USERID , :P_HEADERID, :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_HEADERID: { val: body.P_HEADERID, 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
|
|
}
|
|
async GetGoodsDetailstoEdit(body: GetCarnetControlCenterDTO) {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETCONTROLCENTER_PKG.GetGoodsDetailstoEdit(
|
|
:P_SPID, :P_USERID , :P_HEADERID, :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_HEADERID: { val: body.P_HEADERID, 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async GetCountryDetailstoEdit(body: GetCarnetControlCenterDTO) {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETCONTROLCENTER_PKG.GetCountryDetailstoEdit(
|
|
:P_SPID, :P_USERID , :P_HEADERID, :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_HEADERID: { val: body.P_HEADERID, 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
async GetShipPaymentDetailstoEdit(body: GetCarnetControlCenterDTO) {
|
|
let connection;
|
|
|
|
try {
|
|
connection = await this.oracleDBService.getConnection();
|
|
|
|
const result = await connection.execute(
|
|
`BEGIN
|
|
CARNETCONTROLCENTER_PKG.GetShipPaymentDetailstoEdit(
|
|
:P_SPID, :P_USERID , :P_HEADERID, :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_HEADERID: { val: body.P_HEADERID, 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, CarnetApplicationService.name);
|
|
} catch (error) {
|
|
handleError(error, CarnetApplicationService.name)
|
|
} finally {
|
|
await closeOracleDbConnection(connection, CarnetApplicationService.name)
|
|
}
|
|
}
|
|
}
|