1299 lines
51 KiB
TypeScript
1299 lines
51 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
InternalServerErrorException,
|
|
Logger,
|
|
} from '@nestjs/common';
|
|
import * as oracledb from 'oracledb';
|
|
|
|
const PDFDocument = require('pdfkit');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const PDFMerger = require('pdf-merger-js').default;
|
|
import * as fsPromises from 'fs/promises';
|
|
import { BadRequestException as BR } from 'src/exceptions/badRequest.exception';
|
|
import { existsSync, readFileSync } from 'fs';
|
|
import { PDFDocument as pdfl, TextAlignment, PDFTextField, PDFCheckBox, PDFRadioGroup, PDFDropdown, PDFOptionList } from 'pdf-lib';
|
|
|
|
const logger = new Logger('Helper');
|
|
|
|
export const handleError = (error: any, context: string = 'UnknownService'): never => {
|
|
if (error instanceof BadRequestException || error instanceof BR) {
|
|
logger.warn(`[${context}] ${error.message}`);
|
|
throw error;
|
|
}
|
|
|
|
if (error.message?.includes('NJS-107')) {
|
|
logger.warn(`[${context}] Invalid cursor encountered: ${error.message}`);
|
|
throw new BadRequestException('Invalid database response.');
|
|
}
|
|
|
|
if (error.message?.includes('ORA-')) {
|
|
logger.error(`[${context}] Oracle error occurred: ${error.message}`);
|
|
throw new InternalServerErrorException(error.message);
|
|
}
|
|
|
|
logger.error(`[${context}] Unexpected error:`, error.stack || error);
|
|
throw new InternalServerErrorException(error.message || 'Internal error');
|
|
};
|
|
|
|
export const closeOracleDbConnection = async (connection: any, context: string = 'UnknownService'): Promise<void> => {
|
|
if (connection) {
|
|
try {
|
|
await connection.close();
|
|
} catch (closeErr) {
|
|
logger.error(`[${context}] Failed to close DB connection`, closeErr.stack || closeErr);
|
|
}
|
|
}
|
|
};
|
|
|
|
export const fetchCursor = async <T>(cursor: oracledb.ResultSet<T>, context: string = 'UnknownService'): Promise<T[]> => {
|
|
try {
|
|
const rows = await cursor.getRows();
|
|
await cursor.close();
|
|
return rows;
|
|
} catch (err) {
|
|
logger.error(`[${context}] Failed to fetch from cursor`, err.stack || err);
|
|
throw new InternalServerErrorException('Error reading data from database.');
|
|
}
|
|
};
|
|
|
|
export const setEmptyStringsToNull = (obj: any): void => {
|
|
Object.keys(obj).forEach((key) => {
|
|
if (typeof obj[key] === 'object' && obj[key] !== null) {
|
|
setEmptyStringsToNull(obj[key]);
|
|
} else if (obj[key] === '') {
|
|
obj[key] = null;
|
|
}
|
|
});
|
|
}
|
|
|
|
export interface pdfGLData {
|
|
itemNo: number;
|
|
description: string;
|
|
noOfPieces: number;
|
|
weight: string;
|
|
itemValue: number;
|
|
countryOfOrigin: string
|
|
}
|
|
|
|
export interface pdfCarnetData {
|
|
carnetNo: string;
|
|
ISSUEDBY: string;
|
|
ISSUEDATE: string;
|
|
EXPDATE: string;
|
|
AUTHREP: string;
|
|
NOOFUSSETS: number;
|
|
NOOFFOREIGNSETS: number;
|
|
NOOFTRANSITSETS: number;
|
|
PRINTGOODSTOBEEXPORTED: string;
|
|
HOLDERDATATOPRINT: string;
|
|
CONTINUATIONSHEETS: number;
|
|
NEXTUSCFNO: number;
|
|
NEXTFOREIGNCFNO: number;
|
|
NEXTTRANSITCFNO: number;
|
|
contPageNo: number; // for GL table only
|
|
}
|
|
|
|
function formatNumber(num) {
|
|
if (isNaN(num)) return 'N/A';
|
|
return num.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
|
|
}
|
|
|
|
function toUSDateTime(isoString) {
|
|
const date = new Date(isoString);
|
|
|
|
const month = String(date.getMonth() + 1).padStart(2, '0');
|
|
const day = String(date.getDate()).padStart(2, '0');
|
|
const year = date.getFullYear();
|
|
|
|
let hours = date.getHours();
|
|
const minutes = String(date.getMinutes()).padStart(2, '0');
|
|
const seconds = String(date.getSeconds()).padStart(2, '0');
|
|
|
|
const ampm = hours >= 12 ? 'PM' : 'AM';
|
|
hours = hours % 12 || 12;
|
|
|
|
// return `${month}-${day}-${year}, ${hours}:${minutes}:${seconds} ${ampm}`;
|
|
return `${year}-${month}-${day}`;
|
|
}
|
|
|
|
export function replaceSlashWithDash(input) {
|
|
return input.replace(/\//g, '-');
|
|
}
|
|
|
|
export const generateGreenCoverPDF = (carnetData: pdfCarnetData) => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '1GreenCover.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'AuthBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.AUTHREP);
|
|
}
|
|
else if (x.type === "text" && x.name === 'ContnSheetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.CONTINUATIONSHEETS + "");
|
|
}
|
|
else if (x.type === "text" && x.name === 'GoodstobeExportedas') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.PRINTGOODSTOBEEXPORTED);
|
|
}
|
|
else if (x.type === "text" && x.name === 'IssuedOn') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.ISSUEDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
else if (x.type === "text" && x.name === 'IssuedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.ISSUEDBY);
|
|
}
|
|
else if (x.type === "text" && x.name === 'ValidUntil') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.EXPDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
else if (x.type === "text" && x.name === 'HolderNameAddress') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.enableMultiline();
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const multilineAddress = carnetData.HOLDERDATATOPRINT.replace(/~/g, "\n");
|
|
nameField.setText(multilineAddress);
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}p1.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log("PDF has been successfully created and saved.");
|
|
resolve("p1 done"); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
};
|
|
|
|
export const generateUSCounterFoilFront = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '3USCounterFoilFront.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'Document No1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'Document No2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t2);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}USFront.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}USFront.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateUSCounterFoilBack = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '4USCounterFoilBack.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'Document No1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'Document No2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}USBack.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
pn++
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${pn}USBack.pdf` + " has been successfully created and saved.");
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateFNCounterFoilFront = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '6ForeignCounterfoilFront.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'DocumentNo1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'DocumentNo2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t2);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}FNFront.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}FNFront.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateFNCounterFoilBack = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '7ForeignCounterFoilBack.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'DocumentNo1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'DocumentNo2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}FNBack.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
pn++
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${pn}FNBack.pdf` + " has been successfully created and saved.");
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateTSCounterFoilFront = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '8TransitCounterFoilFront.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'DocumentNo1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'DocumentNo2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t2);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}TSFront.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}TSFront.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateTSCounterFoilBack = (carnetData: pdfCarnetData, t1: string, t2: string, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '9TransitCounterfoilBack.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'DocumentNo1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'DocumentNo2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t2 === "VALUE") {
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else {
|
|
nameField.setText("VOID");
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText1') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
else if (x.type === "text" && x.name === 'PrintVoidText2') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
if (t1 === "VOID") {
|
|
nameField.setAlignment(TextAlignment.Center);
|
|
nameField.setText(t1);
|
|
}
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}TSBack.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
pn++
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${pn}TSBack.pdf` + " has been successfully created and saved.");
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateFNImportV = (carnetData: pdfCarnetData, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '10ImportVoucher.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'Valid Until') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.EXPDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'VoucherNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else if (x.type === "text" && x.name === 'AuthorizedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.AUTHREP);
|
|
}
|
|
else if (x.type === "text" && x.name === 'GoodsDescription') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.PRINTGOODSTOBEEXPORTED);
|
|
}
|
|
else if (x.type === "text" && x.name === 'IssuedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.ISSUEDBY);
|
|
}
|
|
else if (x.type === "text" && x.name === 'Issued') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.ISSUEDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}FNImportV.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}FNImportV.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateFNExportV = (carnetData: pdfCarnetData, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '11ExportVoucher.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'Valid Until') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.EXPDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'VoucherNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else if (x.type === "text" && x.name === 'AuthorizedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.AUTHREP);
|
|
}
|
|
else if (x.type === "text" && x.name === 'GoodsDescription') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.PRINTGOODSTOBEEXPORTED);
|
|
}
|
|
else if (x.type === "text" && x.name === 'IssuedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.ISSUEDBY);
|
|
}
|
|
else if (x.type === "text" && x.name === 'Issued') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.ISSUEDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}FNExportV.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}FNExportV.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
export const generateTNV = (carnetData: pdfCarnetData, dn: number, pn: number): Promise<number | any> => {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
const templatePath = path.join(__dirname, '../..', 'public/carnet-pdf', '12TransitVoucher.pdf');
|
|
const existingPdfBytes = fs.readFileSync(templatePath);
|
|
|
|
const pdfDoc = await pdfl.load(existingPdfBytes);
|
|
const form = pdfDoc.getForm();
|
|
const CURRENT_FONT = 11;
|
|
|
|
const fields = form.getFields();
|
|
const fieldInfo = fields.map(f => {
|
|
let type = 'unknown';
|
|
if (f instanceof PDFTextField) type = 'text';
|
|
else if (f instanceof PDFCheckBox) type = 'checkbox';
|
|
else if (f instanceof PDFRadioGroup) type = 'radio';
|
|
else if (f instanceof PDFDropdown) type = 'dropdown';
|
|
else if (f instanceof PDFOptionList) type = 'option-list';
|
|
return { name: f.getName(), type };
|
|
});
|
|
|
|
// console.log(fieldInfo);
|
|
|
|
|
|
fieldInfo.forEach(x => {
|
|
if (x.type === "text" && x.name === 'Valid Until') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.EXPDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
else if (x.type === "text" && x.name === 'CarnetNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.carnetNo);
|
|
}
|
|
else if (x.type === "text" && x.name === 'VoucherNo') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(dn + "");
|
|
dn++;
|
|
}
|
|
else if (x.type === "text" && x.name === 'AuthorizedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.AUTHREP);
|
|
}
|
|
else if (x.type === "text" && x.name === 'GoodsDescription') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.PRINTGOODSTOBEEXPORTED);
|
|
}
|
|
else if (x.type === "text" && x.name === 'IssuedBy') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
nameField.setText(carnetData.ISSUEDBY);
|
|
}
|
|
else if (x.type === "text" && x.name === 'Issued') {
|
|
const nameField = form.getTextField(x.name);
|
|
nameField.setFontSize(CURRENT_FONT);
|
|
const formattedDate = toUSDateTime(carnetData.ISSUEDATE)
|
|
nameField.setText(formattedDate);
|
|
}
|
|
});
|
|
|
|
form.flatten();
|
|
const filledPdfBytes = await pdfDoc.save();
|
|
|
|
const outputPath = path.join(__dirname, '../..', 'public/carnet-pdf', `${replaceSlashWithDash(carnetData.carnetNo)}${pn}TNV.pdf`);
|
|
const writeStream = fs.createWriteStream(outputPath);
|
|
|
|
writeStream.write(filledPdfBytes);
|
|
writeStream.end();
|
|
|
|
pn++;
|
|
|
|
writeStream.on('finish', () => {
|
|
// console.log(`${dn}TNV.pdf has been successfully created and saved.`);
|
|
resolve(Number(dn)); // wait until file fully written
|
|
});
|
|
|
|
writeStream.on('error', err => {
|
|
console.error("Error writing PDF to file:", err);
|
|
reject(err);
|
|
});
|
|
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
function getPatternArray(n) {
|
|
if (n < 1) {
|
|
return [];
|
|
}
|
|
|
|
const numFours = Math.floor((n - 1) / 4);
|
|
|
|
// Create an array with the leading 4s
|
|
const result = Array(numFours).fill(4);
|
|
|
|
// Calculate and add the final number
|
|
const lastNumber = (n - 1) % 4 + 1;
|
|
result.push(lastNumber);
|
|
|
|
return result;
|
|
}
|
|
|
|
export async function usCounterFoil(carnetData: pdfCarnetData) {
|
|
let documentNo = carnetData.NEXTUSCFNO;
|
|
let fpdf = 1;
|
|
const set = getPatternArray(carnetData.NOOFUSSETS)
|
|
|
|
const generatedFiles: any = [];
|
|
|
|
for (const s of set) {
|
|
// console.log(" Current pattern value (s): ", s);
|
|
|
|
// This is where you would use the 's' value to determine arguments
|
|
// For now, let's keep the arguments constant as per your example
|
|
const funFrontSecondArg = s > 1 ? "VALUE" : "VOID";
|
|
const funBackFirstArg = s > 2 ? "VALUE" : "VOID";
|
|
const funBackSecondArg = s > 3 ? "VALUE" : "VOID";
|
|
|
|
// Step 1: Await front PDF generation
|
|
let inc1: number = await generateUSCounterFoilFront(carnetData, "VALUE", funFrontSecondArg, documentNo, fpdf);
|
|
documentNo = inc1;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}USFront.pdf`);
|
|
|
|
// Step 2: Await back PDF generation
|
|
let inc2: number = await generateUSCounterFoilBack(carnetData, funBackFirstArg, funBackSecondArg, documentNo, fpdf);
|
|
documentNo = inc2;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}USBack.pdf`);
|
|
|
|
// Increment fpdf for the next loop
|
|
fpdf++;
|
|
}
|
|
|
|
// console.log("All US Counter Foil PDFs have been completely generated.");
|
|
// console.log(generatedFiles);
|
|
|
|
|
|
// Return the list of generated filenames
|
|
return generatedFiles;
|
|
}
|
|
|
|
export async function fnCounterFoil(carnetData: pdfCarnetData) {
|
|
let documentNo = carnetData.NEXTFOREIGNCFNO;
|
|
let fpdf = 1;
|
|
const set = getPatternArray(carnetData.NOOFFOREIGNSETS)
|
|
|
|
const generatedFiles: any = [];
|
|
|
|
for (const s of set) {
|
|
|
|
// This is where you would use the 's' value to determine arguments
|
|
// For now, let's keep the arguments constant as per your example
|
|
const funFrontSecondArg = s > 1 ? "VALUE" : "VOID";
|
|
const funBackFirstArg = s > 2 ? "VALUE" : "VOID";
|
|
const funBackSecondArg = s > 3 ? "VALUE" : "VOID";
|
|
|
|
// Step 1: Await front PDF generation
|
|
let inc1: number = await generateFNCounterFoilFront(carnetData, "VALUE", funFrontSecondArg, documentNo, fpdf);
|
|
documentNo = inc1;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}FNFront.pdf`);
|
|
|
|
// Step 2: Await back PDF generation
|
|
let inc2: number = await generateFNCounterFoilBack(carnetData, funBackFirstArg, funBackSecondArg, documentNo, fpdf);
|
|
documentNo = inc2;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}FNBack.pdf`);
|
|
|
|
// Increment fpdf for the next loop
|
|
fpdf++;
|
|
}
|
|
|
|
// console.log("All US Counter Foil PDFs have been completely generated.");
|
|
// console.log(generatedFiles);
|
|
|
|
// Return the list of generated filenames
|
|
return generatedFiles;
|
|
}
|
|
|
|
export async function tsCounterFoil(carnetData: pdfCarnetData) {
|
|
let documentNo = carnetData.NEXTTRANSITCFNO;
|
|
let fpdf = 1;
|
|
const set = getPatternArray(carnetData.NOOFTRANSITSETS)
|
|
|
|
const generatedFiles: any = [];
|
|
|
|
for (const s of set) {
|
|
// console.log(" Current pattern value (s): ", s);
|
|
|
|
// This is where you would use the 's' value to determine arguments
|
|
// For now, let's keep the arguments constant as per your example
|
|
const funFrontSecondArg = s > 1 ? "VALUE" : "VOID";
|
|
const funBackFirstArg = s > 2 ? "VALUE" : "VOID";
|
|
const funBackSecondArg = s > 3 ? "VALUE" : "VOID";
|
|
|
|
// console.log("document no : ", s, " : ", documentNo);
|
|
|
|
|
|
// Step 1: Await front PDF generation
|
|
let inc1: number = await generateTSCounterFoilFront(carnetData, "VALUE", funFrontSecondArg, documentNo, fpdf);
|
|
|
|
documentNo = inc1;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}TSFront.pdf`);
|
|
|
|
// Step 2: Await back PDF generation
|
|
let inc2: number = await generateTSCounterFoilBack(carnetData, funBackFirstArg, funBackSecondArg, documentNo, fpdf);
|
|
|
|
documentNo = inc2;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}TSBack.pdf`);
|
|
|
|
|
|
// Increment fpdf for the next loop
|
|
fpdf++;
|
|
}
|
|
|
|
// console.log("All US Counter Foil PDFs have been completely generated.");
|
|
// console.log(generatedFiles);
|
|
|
|
// Return the list of generated filenames
|
|
return generatedFiles;
|
|
}
|
|
|
|
export async function fnVochers(carnetData: pdfCarnetData) {
|
|
let importNo = 1;
|
|
let exportNo = 1;
|
|
let fpdf = 1;
|
|
const set = getPatternArray(carnetData.NOOFFOREIGNSETS)
|
|
|
|
const generatedFiles: any = [];
|
|
|
|
for (const s of set) {
|
|
|
|
// Step 1: Await back PDF generation
|
|
let inc1: number = await generateFNImportV(carnetData, importNo, fpdf);
|
|
importNo = inc1;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}FNImportV.pdf`);
|
|
generatedFiles.push(`2GeneralList.pdf`);
|
|
|
|
// Step 2: Await back PDF generation
|
|
let inc2: number = await generateFNExportV(carnetData, exportNo, fpdf);
|
|
exportNo = inc2;
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}FNExportV.pdf`);
|
|
generatedFiles.push(`2GeneralList.pdf`);
|
|
|
|
|
|
// Increment fpdf for the next loop
|
|
fpdf++;
|
|
}
|
|
|
|
// console.log("All US Counter Foil PDFs have been completely generated.");
|
|
// console.log(generatedFiles);
|
|
|
|
|
|
// Return the list of generated filenames
|
|
return generatedFiles;
|
|
}
|
|
|
|
export async function tnVochers(carnetData: pdfCarnetData) {
|
|
let tnNo = 1;
|
|
let fpdf = 1;
|
|
const set = getPatternArray(carnetData.NOOFTRANSITSETS)
|
|
|
|
const generatedFiles: any = [];
|
|
|
|
for (const s of set) {
|
|
// console.log(" Current pattern value (s): ", s);
|
|
|
|
await generateTNV(carnetData, tnNo, fpdf);
|
|
|
|
generatedFiles.push(`${replaceSlashWithDash(carnetData.carnetNo)}${fpdf}TNV.pdf`);
|
|
generatedFiles.push(`2GeneralList.pdf`);
|
|
|
|
fpdf++;
|
|
}
|
|
|
|
// console.log("All US Counter Foil PDFs have been completely generated.");
|
|
// console.log(generatedFiles);
|
|
|
|
return generatedFiles;
|
|
}
|
|
|
|
export const generateFinalPDF = async (inputFiles: string[], outputFile: string) => {
|
|
|
|
const merger = new PDFMerger();
|
|
|
|
for (const fileName of inputFiles) {
|
|
const filePath = path.join(__dirname, '../../public/carnet-pdf', fileName);
|
|
// console.log(`Does the file exist? ${existsSync(filePath)}`);
|
|
// console.log(`📄 Adding: ${filePath}`);
|
|
|
|
try {
|
|
const fileData = readFileSync(filePath);
|
|
await merger.add(fileData);
|
|
} catch (err) {
|
|
console.error(`❌ Failed to add PDF: ${fileName}`, err);
|
|
}
|
|
}
|
|
|
|
const outputPath = path.join(__dirname, '../../public/carnet-pdf', outputFile);
|
|
|
|
try {
|
|
await merger.save(outputPath);
|
|
// console.log(`✅ Merged PDF saved to ${outputPath}`);
|
|
} catch (err) {
|
|
console.error(`❌ Failed to save merged PDF`, err);
|
|
throw new Error("Failed to save merged PDF");
|
|
}
|
|
};
|
|
|
|
export const deleteFilesAsync = async (relativeFilePaths: string[]): Promise<void> => {
|
|
for (const relativeFilePath of relativeFilePaths) {
|
|
const filePath = path.join(__dirname, '../../public/carnet-pdf', relativeFilePath);
|
|
|
|
if (fs.existsSync(filePath)) {
|
|
try {
|
|
await fsPromises.unlink(filePath);
|
|
// console.log(`🗑️ Deleted: ${filePath}`);
|
|
} catch (err) {
|
|
console.error(`❌ Error deleting file: ${filePath}`, err);
|
|
}
|
|
} else {
|
|
console.warn(`⚠️ File not found: ${filePath}`);
|
|
}
|
|
}
|
|
}; |