shareneus 1.7.4 → 1.7.6

package/src/shared/table-section/pdf-table.config.ts

@@ -0,0 +1,8 @@
+export const pdfTableStyleConfig = {
+    headerFontSize: 10,
+    bodyFontSize: 9,
+    stackFieldFontSize: 8,
+    headerBgColor: '#eeeeee',
+    headerFontColor: '#111827',
+    bodyFontColor: '#111827'
+};

package/src/shared/table-section/pdf-table.header.ts

@@ -0,0 +1,396 @@
+import {  pdfTableStyleConfig } from './pdf-table.config';
+
+export function GetTableHeader(itemsHeader: any[], taxMode: string = '') {
+    const orderedHeaders = getHeadersBySequence(itemsHeader);
+    const filteredHeaders = shouldHideTaxHeaders(taxMode)
+        ? orderedHeaders.filter((item: any) => !isTaxHeaderConfig(item))
+        : orderedHeaders;
+
+    const toHeaderObject = (item: any) => {
+        const itemTitle = item?.title ?? item?.CustTitle ?? item?.Tital ?? '';
+        const itemWidth = item?.width ?? item?.Width;
+        const itemDbFields = item?.dbFields ?? item?.DBFields ?? [];
+        const stackSource = item?.stackFields ?? item?.Stacked;
+        const stackTitle = stackSource?.title ?? stackSource?.Tital ?? null;
+        const stackSeq = stackSource?.seq ?? stackSource?.Seq;
+        return {
+            text: itemTitle,
+            width: itemWidth,
+            bold: item.bold ?? true,
+            fontSize: 9,
+            alignment: resolveHeaderAlignment(itemTitle),
+            dbFields: itemDbFields,
+            stackParent: stackTitle,
+            stackSeq: typeof stackSeq === 'number' ? stackSeq : Number.MAX_SAFE_INTEGER
+        };
+    };
+
+    const visibleHeaders = filteredHeaders.filter((item: any) => (item?.show ?? item?.Show) !== false);
+
+    const headerRow = visibleHeaders
+        .filter((item: any) => !(item?.stackFields ?? item?.Stacked))
+        .map((item: any) => {
+            const parentTitle = item?.title ?? item?.CustTitle ?? item?.Tital;
+            const stackFields = visibleHeaders
+                .filter((stackedItem: any) => {
+                    const stackedParent = stackedItem?.stackFields?.title
+                        ?? stackedItem?.stackFields?.Tital
+                        ?? stackedItem?.Stacked?.title
+                        ?? stackedItem?.Stacked?.Tital;
+                    return stackedParent === parentTitle;
+                })
+                .sort((a: any, b: any) => {
+                    const aSeqRaw = a?.stackFields?.seq ?? a?.stackFields?.Seq ?? a?.Stacked?.seq ?? a?.Stacked?.Seq;
+                    const bSeqRaw = b?.stackFields?.seq ?? b?.stackFields?.Seq ?? b?.Stacked?.seq ?? b?.Stacked?.Seq;
+                    const aSeq = typeof aSeqRaw === 'number' ? aSeqRaw : Number.MAX_SAFE_INTEGER;
+                    const bSeq = typeof bSeqRaw === 'number' ? bSeqRaw : Number.MAX_SAFE_INTEGER;
+                    if (aSeq !== bSeq) {
+                        return aSeq - bSeq;
+                    }
+                    const aHeaderSeqRaw = a?.seq ?? a?.Seq;
+                    const bHeaderSeqRaw = b?.seq ?? b?.Seq;
+                    const aHeaderSeq = typeof aHeaderSeqRaw === 'number' ? aHeaderSeqRaw : Number.MAX_SAFE_INTEGER;
+                    const bHeaderSeq = typeof bHeaderSeqRaw === 'number' ? bHeaderSeqRaw : Number.MAX_SAFE_INTEGER;
+                    return aHeaderSeq - bHeaderSeq;
+                })
+                .map((stackedItem: any) => toHeaderObject(stackedItem));
+
+            return {
+                ...toHeaderObject(item),
+                stackFields
+            };
+        });
+
+    const header: any[] = [headerRow];
+
+    return header;
+}
+
+function getHeadersBySequence(headers: any[]) {
+    return headers
+        .map((header: any, index: number) => ({ header, index }))
+        .sort((a: any, b: any) => {
+            const aSeqRaw = a?.header?.seq ?? a?.header?.Seq;
+            const bSeqRaw = b?.header?.seq ?? b?.header?.Seq;
+            const aSeq = typeof aSeqRaw === 'number' ? aSeqRaw : Number.MAX_SAFE_INTEGER;
+            const bSeq = typeof bSeqRaw === 'number' ? bSeqRaw : Number.MAX_SAFE_INTEGER;
+            if (aSeq !== bSeq) {
+                return aSeq - bSeq;
+            }
+            return a.index - b.index;
+        })
+        .map((entry: any) => entry.header);
+}
+
+export function getRenderableColumns(headerConfig: any[], sType: string = '') {
+    const isInter = sType === 'Inter';
+    const hasTaxPercent = headerConfig.some((header: any) => isTaxPercentHeader(header));
+    const hasTaxAmount = headerConfig.some((header: any) => isTaxAmountHeader(header));
+    const hasTaxGroup = hasTaxPercent && hasTaxAmount;
+    const columns: any[] = [];
+    for (const header of headerConfig) {
+        // --- Inter / IGST ---
+        if (isInter && hasTaxGroup && isTaxPercentHeader(header)) {
+            columns.push(
+                {
+                    type: 'tax',
+                    taxKind: 'rate',
+                    dbField: 'IGST',
+                    width: getTaxSubWidth(header.width),
+                },
+                {
+                    type: 'tax',
+                    taxKind: 'amount',
+                    dbField: 'IGST',
+                    width: getTaxSubWidth(header.width),
+                }
+            );
+            continue;
+        }
+
+        // Tax Amt header is skipped for Inter when hasTaxGroup (IGST already handled by Tax%)
+        if (isInter && hasTaxGroup && isTaxAmountHeader(header)) {
+            continue;
+        }
+
+        if (isInter && !hasTaxGroup && isTaxPercentHeader(header)) {
+            columns.push({
+                type: 'tax',
+                taxKind: 'rate',
+                dbField: 'IGST',
+                width: header.width,
+            });
+            continue;
+        }
+
+        if (isInter && !hasTaxGroup && isTaxAmountHeader(header)) {
+            columns.push({
+                type: 'tax',
+                taxKind: 'amount',
+                dbField: 'IGST',
+                width: header.width,
+            });
+            continue;
+        }
+
+        // --- Intra / CGST + SGST ---
+        if (!isInter && hasTaxGroup && isTaxPercentHeader(header)) {
+            columns.push(
+                {
+                    type: 'tax',
+                    taxKind: 'rate',
+                    dbField: 'CGST',
+                    width: getTaxSubWidth(header.width),
+                },
+                {
+                    type: 'tax',
+                    taxKind: 'amount',
+                    dbField: 'CGST',
+                    width: getTaxSubWidth(header.width),
+                }
+            );
+            continue;
+        }
+
+        if (!isInter && hasTaxGroup && isTaxAmountHeader(header)) {
+            columns.push(
+                {
+                    type: 'tax',
+                    taxKind: 'rate',
+                    dbField: 'SGST',
+                    width: getTaxSubWidth(header.width),
+                },
+                {
+                    type: 'tax',
+                    taxKind: 'amount',
+                    dbField: 'SGST',
+                    width: getTaxSubWidth(header.width),
+                }
+            );
+            continue;
+        }
+
+        if (!isInter && !hasTaxGroup && isTaxPercentHeader(header)) {
+            columns.push(
+                {
+                    type: 'tax',
+                    taxKind: 'rate',
+                    dbField: 'CGST',
+                    width: getTaxSubWidth(header.width),
+                },
+                {
+                    type: 'tax',
+                    taxKind: 'rate',
+                    dbField: 'SGST',
+                    width: getTaxSubWidth(header.width),
+                }
+            );
+            continue;
+        }
+
+        if (!isInter && !hasTaxGroup && isTaxAmountHeader(header)) {
+            columns.push(
+                {
+                    type: 'tax',
+                    taxKind: 'amount',
+                    dbField: 'CGST',
+                    width: getTaxSubWidth(header.width),
+                },
+                {
+                    type: 'tax',
+                    taxKind: 'amount',
+                    dbField: 'SGST',
+                    width: getTaxSubWidth(header.width),
+                }
+            );
+            continue;
+        }
+
+        columns.push({
+            type: 'normal',
+            width: header.width,
+            header
+        });
+    }
+    return columns;
+}
+
+export function buildHeaderRows(headerConfig: any[], sType: string = '') {
+    const isInter = sType === 'Inter';
+    const hasTaxPercent = headerConfig.some((header: any) => isTaxPercentHeader(header));
+    const hasTaxAmount = headerConfig.some((header: any) => isTaxAmountHeader(header));
+    const hasTaxGroup = hasTaxPercent && hasTaxAmount;
+    const hasDiscPercent = headerConfig.some((header: any) => header.text === 'Disc %');
+    const hasDiscAmount = headerConfig.some((header: any) => isDiscountAmountHeader(header.text));
+    const hasDiscGroup = hasDiscPercent && hasDiscAmount;
+    const hasGroupedHeaders = hasTaxPercent || hasTaxAmount || hasDiscGroup;
+
+    if (!hasGroupedHeaders) {
+        const singleRow = headerConfig.map((header: any) => ({
+            text: header.text,
+            alignment: header.alignment,
+            dbFields: header.dbFields,
+            stackFields: header.stackFields,
+            ...getHeaderCellStyle()
+        }));
+        return [singleRow];
+    }
+
+    const topRow: any[] = [];
+    const subRow: any[] = [];
+
+    for (const header of headerConfig) {
+        // --- Inter / IGST ---
+        if (isInter && hasTaxGroup && isTaxPercentHeader(header)) {
+            topRow.push(
+                { text: 'IGST', colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: '%', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'Amt', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        // Tax Amt header is skipped for Inter when hasTaxGroup (IGST already handled by Tax%)
+        if (isInter && hasTaxGroup && isTaxAmountHeader(header)) {
+            continue;
+        }
+
+        if (isInter && !hasTaxGroup && isTaxPercentHeader(header)) {
+            topRow.push({ text: 'IGST %', rowSpan: 2, alignment: 'center', ...getHeaderCellStyle() });
+            subRow.push({});
+            continue;
+        }
+
+        if (isInter && !hasTaxGroup && isTaxAmountHeader(header)) {
+            topRow.push({ text: 'IGST Amt', rowSpan: 2, alignment: 'center', ...getHeaderCellStyle() });
+            subRow.push({});
+            continue;
+        }
+
+        // --- Intra / CGST + SGST ---
+        if (!isInter && hasTaxGroup && isTaxPercentHeader(header)) {
+            topRow.push(
+                { text: 'CGST', colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: '%', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'Amt', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        if (!isInter && hasTaxGroup && isTaxAmountHeader(header)) {
+            topRow.push(
+                { text: 'SGST/UGST', colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: '%', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'Amt', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        if (!isInter && !hasTaxGroup && isTaxPercentHeader(header)) {
+            topRow.push(
+                { text: header.text, colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: 'CGST', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'SGST/UGST', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        if (!isInter && !hasTaxGroup && isTaxAmountHeader(header)) {
+            topRow.push(
+                { text: header.text, colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: 'CGST', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'SGST/UGST', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        if (hasDiscGroup && header.text === 'Disc %') {
+            topRow.push(
+                { text: 'Discount', colSpan: 2, alignment: 'center', ...getHeaderCellStyle() },
+                {}
+            );
+            subRow.push(
+                { text: '%', alignment: 'center', ...getHeaderCellStyle() },
+                { text: 'Amt', alignment: 'center', ...getHeaderCellStyle() }
+            );
+            continue;
+        }
+
+        if (hasDiscGroup && isDiscountAmountHeader(header.text)) {
+            continue;
+        }
+
+        topRow.push({ text: header.text, rowSpan: 2, alignment: header.alignment, ...getHeaderCellStyle() });
+        subRow.push({});
+    }
+
+    return [topRow, subRow];
+}
+
+function getTaxSubWidth(width: any) {
+    if (typeof width !== 'number') {
+        return 'auto';
+    }
+    return Math.max(1, width / 2);
+}
+
+function isDiscountAmountHeader(text: string) {
+    return text === 'Disc Amount' || text === 'Adisc Amount';
+}
+
+function isTaxPercentHeader(header: any) {
+    return normalizeHeaderText(header?.text) === 'TAX%';
+}
+
+function isTaxAmountHeader(header: any) {
+    return normalizeHeaderText(header?.text) === 'TAXAMOUNT';
+}
+
+function isTaxHeaderConfig(header: any) {
+    const title = header?.title ?? header?.CustTitle ?? header?.Tital ?? header?.text;
+    const normalizedTitle = normalizeHeaderText(title);
+    return normalizedTitle === 'TAX%' || normalizedTitle === 'TAXAMOUNT';
+}
+
+function shouldHideTaxHeaders(taxMode: string) {
+    return taxMode === 'BS' || taxMode === 'NO';
+}
+
+function normalizeHeaderText(value: any) {
+    return String(value ?? '')
+        .replace(/\s+/g, '')
+        .trim()
+        .toUpperCase();
+}
+
+function resolveHeaderAlignment(title: any) {
+    const normalizedTitle = normalizeHeaderText(title);
+    if (normalizedTitle === 'LINETOTAL' || normalizedTitle === 'PRICE' || normalizedTitle === 'QTY') {
+        return 'right';
+    }
+    return undefined;
+}
+
+function getHeaderCellStyle() {
+    return {
+        bold: true,
+        fontSize: pdfTableStyleConfig.headerFontSize,
+        fillColor: pdfTableStyleConfig.headerBgColor,
+        color: pdfTableStyleConfig.headerFontColor
+    };
+}

package/src/shared/table-section/pdf-table.row.ts

@@ -0,0 +1,248 @@
+import { pdfTableStyleConfig } from './pdf-table.config';
+import { MyDate } from '../../utils/my-date';
+
+export function buildDataRow(item: any, index: number, headerConfig: any[], fixedTo: number = 2) {
+    return headerConfig.map((column: any) => {
+        if (column.type === 'tax') {
+            const taxValue = getTaxValue(item, column.dbField, column.taxKind);
+            const signedTaxValue = shouldRenderNegativeTaxAmount(item, column)
+                ? negateNumericLikeValue(taxValue)
+                : taxValue;
+            const renderedTaxValue = formatNumericLikeValue(signedTaxValue, fixedTo);
+            return { text: renderedTaxValue, fontSize: pdfTableStyleConfig.bodyFontSize, color: pdfTableStyleConfig.bodyFontColor, alignment: getNumericAlignment(renderedTaxValue) };
+        }
+
+        const header = column.header;
+        if (header.text === 'S.No') {
+            const serial = String(index + 1);
+            return { text: serial, fontSize: pdfTableStyleConfig.bodyFontSize, color: pdfTableStyleConfig.bodyFontColor, alignment: getNumericAlignment(serial) };
+        }
+
+        const mainValue = formatFieldValue(item, header, fixedTo);
+        const stackedLines = (header.stackFields ?? [])
+            .map((stackField: any) => {
+                const stackValue = formatFieldValue(item, stackField, fixedTo);
+                if (!stackValue) {
+                    return null;
+                }
+                return { text: `${stackField.text}: ${stackValue}`, fontSize: pdfTableStyleConfig.stackFieldFontSize, color: pdfTableStyleConfig.bodyFontColor, italics: true };
+            })
+            .filter((line: any) => !!line);
+
+        if (stackedLines.length === 0) {
+            return {
+                text: mainValue,
+                fontSize: pdfTableStyleConfig.bodyFontSize,
+                color: pdfTableStyleConfig.bodyFontColor,
+                alignment: getCellAlignment(header.text, mainValue)
+            };
+        }
+
+        return {
+            stack: [
+                { text: mainValue, fontSize: pdfTableStyleConfig.bodyFontSize, color: pdfTableStyleConfig.bodyFontColor },
+                ...stackedLines
+            ]
+        };
+    });
+}
+
+function formatFieldValue(item: any, fieldConfig: any, fixedTo: number) {
+    const rawValue = getFirstFieldValue(item, fieldConfig?.dbFields);
+    if (isExpiryField(fieldConfig)) {
+        return formatExpiryDateValue(rawValue);
+    }
+
+    const signedValue = shouldRenderNegativeField(item, fieldConfig)
+        ? negateNumericLikeValue(rawValue)
+        : rawValue;
+    return formatNumericLikeValue(signedValue, fixedTo, shouldSkipFixedTo(fieldConfig));
+}
+
+function getTaxValue(item: any, taxName: 'CGST' | 'SGST' | 'IGST', taxKind: 'rate' | 'amount') {
+    if (taxName === 'IGST') {
+        const fields = taxKind === 'rate' ? ['IGSTPerc'] : ['IGSTAmt'];
+        return getFirstFieldValue(item, fields);
+    }
+    const fields = taxKind === 'rate'
+        ? [`${taxName}Perc`, taxName]
+        : [`${taxName}Amt`, taxName];
+    return getFirstFieldValue(item, fields);
+}
+
+function shouldRenderNegativeTaxAmount(item: any, column: any) {
+    return !!item?.Ret && column?.taxKind === 'amount';
+}
+
+function shouldRenderNegativeField(item: any, fieldConfig: any) {
+    if (!item?.Ret) {
+        return false;
+    }
+
+    const headerText = String(fieldConfig?.text ?? '').trim().toUpperCase();
+    return headerText === 'QTY'
+        || headerText === 'OFFER QTY'
+        || headerText === 'PRICE'
+        || headerText === 'LINE TOTAL';
+}
+
+function negateNumericLikeValue(value: string) {
+    if (!isNumericLike(String(value ?? ''))) {
+        return value;
+    }
+
+    const normalized = Number(String(value).replace(/,/g, '').trim());
+    if (!Number.isFinite(normalized)) {
+        return value;
+    }
+
+    return String(normalized === 0 ? 0 : -Math.abs(normalized));
+}
+
+export function getFirstFieldValue(item: any, dbFields: string[] = []) {
+    for (const field of dbFields) {
+        const value = readValue(item, field);
+        if (value !== undefined && value !== null && value !== '') {
+            return String(value);
+        }
+    }
+    return '';
+}
+
+function readValue(item: any, field: string) {
+    if (!item || !field) {
+        return undefined;
+    }
+
+    if (item[field] !== undefined) {
+        return item[field];
+    }
+
+    const dottedPathValue = field.split('.').reduce((current: any, key: string) => {
+        if (current && current[key] !== undefined) {
+            return current[key];
+        }
+        return undefined;
+    }, item);
+
+    if (dottedPathValue !== undefined) {
+        return dottedPathValue;
+    }
+
+    return deepFindByKey(item, field);
+}
+
+function deepFindByKey(source: any, field: string): any {
+    if (!source || typeof source !== 'object') {
+        return undefined;
+    }
+
+    if (source[field] !== undefined) {
+        return source[field];
+    }
+
+    for (const key of Object.keys(source)) {
+        const value = source[key];
+        if (value && typeof value === 'object') {
+            const nestedValue = deepFindByKey(value, field);
+            if (nestedValue !== undefined) {
+                return nestedValue;
+            }
+        }
+    }
+
+    return undefined;
+}
+
+export function getNumericAlignment(value: string) {
+    return isNumericLike(value) ? 'right' : 'left';
+}
+
+export function getCellAlignment(headerText: string, value: string) {
+    if (isRightAlignedHeader(headerText)) {
+        return 'right';
+    }
+    if (isLeftAlignedHeader(headerText)) {
+        return 'left';
+    }
+    return getNumericAlignment(value);
+}
+
+function isNumericLike(value: string) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.replace(/,/g, '').trim();
+    return /^-?\d+(\.\d+)?$/.test(normalized);
+}
+
+function isLeftAlignedHeader(headerText: string) {
+    return false;
+}
+
+function isRightAlignedHeader(headerText: string) {
+    const normalizedHeader = String(headerText ?? '').replace(/\s+/g, '').trim().toUpperCase();
+    return normalizedHeader === 'QTY' || normalizedHeader === 'OFFERQTY';
+}
+
+function formatNumericLikeValue(value: string, fixedTo: number, skipFixedTo: boolean = false) {
+    if (skipFixedTo) {
+        return value;
+    }
+    if (!isNumericLike(value)) {
+        return value;
+    }
+    const normalized = Number(String(value).replace(/,/g, '').trim());
+    if (!Number.isFinite(normalized)) {
+        return value;
+    }
+    return normalized.toFixed(fixedTo);
+}
+
+function isExpiryField(fieldConfig: any) {
+    const text = String(fieldConfig?.text ?? '').trim().toUpperCase();
+    if (text === 'EXPIRY' || text === 'EXPIRY DATE' || text === 'EXDT') {
+        return true;
+    }
+
+    const dbFields = Array.isArray(fieldConfig?.dbFields) ? fieldConfig.dbFields : [];
+    return dbFields.some((field: any) => {
+        const normalized = String(field ?? '').trim().toUpperCase();
+        return normalized === 'EXDT' || normalized.endsWith('.EXDT') || normalized.endsWith('.EXPIRY');
+    });
+}
+
+function formatExpiryDateValue(value: string) {
+    if (!value) {
+        return value;
+    }
+
+    const input = String(value).trim();
+    if (!input) {
+        return '';
+    }
+
+    if (/^\d{2}\/\d{2}$/.test(input)) {
+        return input;
+    }
+
+    const parsed = new Date(input);
+    if (Number.isNaN(parsed.getTime())) {
+        return input;
+    }
+
+    return MyDate.ConvertUTCDateToReadableExDate(input) || input;
+}
+
+function shouldSkipFixedTo(header: any) {
+    const text = String(header?.text ?? '').trim().toUpperCase();
+    if (text === 'HSN/SAC' || text === 'BN' || text === 'BNO') {
+        return true;
+    }
+
+    const dbFields = Array.isArray(header?.dbFields) ? header.dbFields : [];
+    return dbFields.some((field: any) => {
+        const normalized = String(field ?? '').trim().toUpperCase();
+        return normalized === 'BN' || normalized === 'BNO' || normalized.endsWith('.BN');
+    });
+}