statewise-chart-processor 1.0.0 → 1.0.2

package/index.js

@@ -1,3 +1,275 @@
+function processStateChartData(chartData, reportHeader, tableHeaders, areaType) {
+        if (!chartData || !chartData.length) return null;
+        const finalData = { State: {} };
+        chartData.forEach(value => {
+            if (value.district && value.district !== '(NULL)') {
+                if (!finalData.State[value.state]) {
+                    finalData.State[value.state] = { State: value.state };
+                }
+                if (!finalData.State[value.state][value.district]) {
+                    finalData.State[value.state][value.district] = { district: value.district };
+                }
+                if (!finalData.State[value.state][value.district][value.area_type]) {
+                    finalData.State[value.state][value.district][value.area_type] = { report_header: [] };
+                }
+                // Fill report_header for this area_type
+                Object.entries(reportHeader).forEach(([colname, headerName]) => {
+                    finalData.State[value.state][value.district][value.area_type].report_header.push({
+                        name: headerName,
+                        total: value[colname]
+                    });
+                });
+                // Fill missing area types with zeroes
+                areaType.forEach(type => {
+                    if (!finalData.State[value.state][value.district][type]) {
+                        finalData.State[value.state][value.district][type] = { report_header: [] };
+                        Object.entries(reportHeader).forEach(([colname, headerName]) => {
+                            finalData.State[value.state][value.district][type].report_header.push({
+                                name: headerName,
+                                total: 0
+                            });
+                        });
+                    }
+                });
+            }
+        });
+        return finalData;
+}
+async function workersChartData(parameterData, chartData, tablewiseChartData) {
+    chartData = chartData[0];
+    tablewiseChartData = tablewiseChartData[0];
+
+    // Initialize result structure
+    const result = {
+        tableheaders: [],
+        areatype: [],
+        finaldata: {},
+        grandtotal: { grandTotal: {} }
+    };
+
+    // Process chartData if exists
+    if (chartData && chartData.length > 0) {
+        // Get report headers with order
+        const reportHeaderMap = {};
+        chartData.forEach(item => {
+            if (item.report_header && item.report_order != null) {
+                reportHeaderMap[item.report_order] = item.report_header;
+            }
+        });
+        // Sort by numeric keys and get values
+        const sortedReportHeaders = Object.keys(reportHeaderMap)
+            .sort((a, b) => parseInt(a) - parseInt(b))
+            .map(key => reportHeaderMap[key]);
+        result.tableheaders = sortedReportHeaders;
+        // Get unique area_type values
+        const areaTypeSet = new Set();
+        chartData.forEach(item => {
+            if (item.area_type) {
+                areaTypeSet.add(item.area_type);
+            }
+        });
+        // Convert to array and sort
+        let areatype = Array.from(areaTypeSet)
+            .filter(type => type !== null && type !== undefined && type !== '')
+            .sort((a, b) => {
+                const numA = parseInt(a);
+                const numB = parseInt(b);
+                if (!isNaN(numA) && !isNaN(numB)) {
+                    return numA - numB;
+                }
+                return String(a).localeCompare(String(b));
+            });
+        const areaarray = ['rural', 'urban', 'combined'];
+        // Check if all areatype values are in areaarray and we have more than 1
+        const intersection = areatype.filter(type => areaarray.includes(type));
+        if (intersection.length === areatype.length && areatype.length > 1) {
+            areatype = areaarray; // Use the predefined order
+        }
+        result.areatype = areatype;
+        // Process data for specific flags
+        if ((parameterData.flag == 153 || parameterData.flag == 400 || parameterData.flag == 101)) {
+            const finaldata = { State: {} };
+            const grandtotal = { grandTotal: {} };
+            // First pass: Process chartData
+            chartData.forEach(value => {
+                if (value.disttName !== '(NULL)' && sortedReportHeaders.includes(value.report_header)) {
+                    const state = 'name';
+                    //const state = value.State;
+                    const district = value.disttName;
+                    const area = value.area_type;
+                    // Initialize state data if needed
+                    if (!finaldata.State[state]) {
+                        finaldata.State[state] = {
+                            State: state,
+                            disttName: district
+                        };
+                    }
+                    // Initialize district data if needed
+                    if (!finaldata.State[state][district]) {
+                        finaldata.State[state][district] = {
+                            disttName: district,
+                            grandTotal: 0
+                        };
+                    }
+                    // Initialize area type data if needed
+                    if (!finaldata.State[state][district][area]) {
+                        finaldata.State[state][district][area] = {
+                            report_header: []
+                        };
+                    }
+                    // Add report header data
+                    finaldata.State[state][district][area].report_header.push({
+                        name: value.report_header,
+                        total: value.total
+                    });
+                    // Process grand totals for area types
+                    if (!grandtotal.grandTotal[area]) {
+                        grandtotal.grandTotal[area] = {};
+                    }
+                    if (!grandtotal.grandTotal[area][value.report_header]) {
+                        grandtotal.grandTotal[area][value.report_header] = { total: 0 };
+                    }
+                    grandtotal.grandTotal[area][value.report_header].total += Number(value.total);
+                    // Process final total
+                    if (!grandtotal.grandTotal.finaltotal) {
+                        grandtotal.grandTotal.finaltotal = 0;
+                    }
+                    grandtotal.grandTotal.finaltotal += Number(value.total);
+                    // Update district grand total
+                    finaldata.State[state][district].grandTotal += Number(value.total);
+                }
+            });
+            // Merge grandtotal into finaldata
+            Object.assign(finaldata, grandtotal);
+            // Remove specific area types from grandTotal
+            if (areatype.length > 0) {
+                delete finaldata.grandTotal[areatype[0]];
+                if (areatype.length > 1) {
+                    delete finaldata.grandTotal[areatype[1]];
+                }
+            }
+            // Reset finaltotal
+            finaldata.grandTotal.finaltotal = 0;
+            // Second pass: Reorganize data by area types
+            Object.entries(finaldata.State).forEach(([stateKey, stateValue]) => {
+                if (typeof stateValue === 'object') {
+                    Object.entries(stateValue).forEach(([districtKey, districtValue]) => {
+                        if (typeof districtValue === 'object' && districtKey !== 'State' && districtKey !== 'disttName') {
+                            // Process each area type
+                            areatype.forEach((area, index) => {
+                                if (districtValue[area]) {
+                                    // Create map of existing totals for this area
+                                    const areaTotals = {};
+                                    districtValue[area].report_header.forEach(item => {
+                                        areaTotals[item.name] = Number(item.total);
+                                    });
+                                    // Clear and rebuild with tableheaders order
+                                    delete districtValue[area].report_header;
+                                    districtValue[area].report_header = [];
+                                    districtValue[area].areatotal = 0;
+                                    // Initialize grandTotal for this area if needed
+                                    if (!finaldata.grandTotal[area]) {
+                                        finaldata.grandTotal[area] = {};
+                                    }
+                                    sortedReportHeaders.forEach(headername => {
+                                        // Initialize grand total for this header
+                                        if (!finaldata.grandTotal[area][headername]) {
+                                            finaldata.grandTotal[area][headername] = { total: 0 };
+                                        }
+                                        if (!finaldata.grandTotal.combined) {
+                                            finaldata.grandTotal.combined = {};
+                                        }
+                                        if (!finaldata.grandTotal.combined[headername]) {
+                                            finaldata.grandTotal.combined[headername] = { total: 0 };
+                                        }
+                                        const total = areaTotals[headername] || 0;
+                                        districtValue[area].report_header.push({
+                                            name: headername,
+                                            total: total
+                                        });
+                                        districtValue[area].areatotal += Number(total);
+                                        // Update grand totals
+                                        finaldata.grandTotal[area][headername].total += Number(total);
+                                        finaldata.grandTotal.finaltotal += Number(total);
+                                        // Update area total in grandTotal
+                                        if (!finaldata.grandTotal[area].areatotal) {
+                                            finaldata.grandTotal[area].areatotal = 0;
+                                        }
+                                        finaldata.grandTotal[area].areatotal += Number(total);
+                                        // Update combined if multiple areas
+                                        if (areatype.length > 1 && index === 0) {
+                                            finaldata.grandTotal.combined[headername].total += total;
+                                        }
+                                        // Update district grand total
+                                        districtValue.grandTotal += total;
+                                    });
+                                } else {
+                                    // No data for this area - create empty entries
+                                    districtValue[area] = {
+                                        report_header: [],
+                                        areatotal: 0
+                                    };
+                                    sortedReportHeaders.forEach(headername => {
+                                        districtValue[area].report_header.push({
+                                            name: headername,
+                                            total: 0
+                                        });
+                                    });
+                                }
+                            });
+                            // Handle combined area for multiple area types
+                            if (areatype.length > 1) {
+                                const combinedArea = 'combined';
+                                districtValue[combinedArea] = { report_header: [] };
+                                sortedReportHeaders.forEach(headername => {
+                                    const ruralTotal = districtValue[areatype[0]]?.report_header?.find(item => item.name === headername)?.total || 0;
+                                    const urbanTotal = districtValue[areatype[1]]?.report_header?.find(item => item.name === headername)?.total || 0;
+                                    const combinedTotal = ruralTotal + urbanTotal;
+                                    districtValue[combinedArea].report_header.push({
+                                        name: headername,
+                                        total: combinedTotal
+                                    });
+                                });
+                            }
+                        }
+                    });
+                }
+            });
+            result.finaldata = finaldata;
+            // Process tablewiseChartData if available
+            if (tablewiseChartData && tablewiseChartData.length > 0) {
+                const tableReportHeader = [...new Set(tablewiseChartData
+                    .filter(item => item.report_header && item.report_order != null)
+                    .map(item => item.report_header)
+                )];
+                finaldata.tabledata = {};
+                tablewiseChartData.forEach(value => {
+                    if (value.disttName !== '(NULL)' && tableReportHeader.includes(value.report_header)) {
+                        const state = value.State;
+                        const district = value.disttName;
+                        const table = value.tableName;
+                        // Initialize structure
+                        if (!finaldata.tabledata[state]) {
+                            finaldata.tabledata[state] = {};
+                        }
+                        if (!finaldata.tabledata[state][district]) {
+                            finaldata.tabledata[state][district] = {};
+                        }
+                        if (!finaldata.tabledata[state][district][table]) {
+                            finaldata.tabledata[state][district][table] = { report_header: [] };
+                        }
+                        // Add data
+                        finaldata.tabledata[state][district][table].report_header.push({
+                            name: value.report_header,
+                            total: value.total
+                        });
+                    }
+                });
+            }
+        }
+    }
+    return result;
+}
 async function processstatewisechart(parameterData, chartData, tablewiseChartData) {
     // ...your function code here...
     if (!chartData || chartData.length === 0) return {};
@@ -209,4 +481,333 @@ async function processstatewisechart(parameterData, chartData, tablewiseChartDat
     return { ...finaldata, ...grandtotal };
 }
 
-module.exports = { processstatewisechart };
+async function processChartData(chartData, tablewiseChartData = null, tableheaders, reportHeader, areatype) {
+    let finaldata = { State: {} };
+    let grandtotal = { grandTotal: {} };
+
+    // -----------------------------
+    // FIRST PASS → STATE & GRAND TOTALS
+    // -----------------------------
+    for (const row of chartData) {
+        if (!row.state) continue;
+        if (!reportHeader.includes(row.report_header)) continue;
+
+        const state = row.state;
+        const area = row.area_type;
+        const header = row.report_header;
+        const total = row.total;
+
+        // Create state entry
+        if (!finaldata.State[state]) finaldata.State[state] = {};
+
+        // remarks only if flag=63
+        if (row.flag == 63) {
+            finaldata.State[state].State = state;
+            finaldata.State[state].remarks = row.remarks;
+        } else {
+            finaldata.State[state].State = state;
+        }
+
+        // Create area holder
+        if (!finaldata.State[state][area])
+            finaldata.State[state][area] = { report_header: [] };
+
+        // Push header → total
+        finaldata.State[state][area].report_header.push({
+            name: header,
+            total: total
+        });
+
+        // GRAND TOTAL by area + header
+        if (!grandtotal.grandTotal[area])
+            grandtotal.grandTotal[area] = {};
+
+        if (!grandtotal.grandTotal[area][header])
+            grandtotal.grandTotal[area][header] = { total: 0 };
+
+        grandtotal.grandTotal[area][header].total += total;
+
+        // GLOBAL final total
+        if (!grandtotal.grandTotal.finaltotal)
+            grandtotal.grandTotal.finaltotal = 0;
+
+        grandtotal.grandTotal.finaltotal += total;
+    }
+
+    finaldata = { ...finaldata, ...grandtotal };
+
+    // remove unwanted grand totals
+    if(areatype && areatype.length>0){
+        delete finaldata.grandTotal[areatype[0]];    
+    }
+    
+    finaldata.grandTotal.finaltotal = 0;
+    if (areatype.length > 1) delete finaldata.grandTotal[areatype[1]];
+
+    // -----------------------------
+    // SECOND PASS → RESHAPE BY HEADER
+    // -----------------------------
+    for (const stateKey in finaldata.State) {
+        const stateBlock = finaldata.State[stateKey];
+
+        // RURAL
+        if (stateBlock[areatype[0]]) {
+            let ruralTotals = Object.fromEntries(
+                stateBlock[areatype[0]].report_header.map(h => [h.name, h.total])
+            );
+
+            stateBlock[areatype[0]].report_header = [];
+            stateBlock[areatype[0]].areatotal = 0;
+
+            for (let header of tableheaders) {
+                let total = ruralTotals[header] || 0;
+
+                stateBlock[areatype[0]].report_header.push({
+                    name: header,
+                    total
+                });
+
+                stateBlock[areatype[0]].areatotal += total;
+
+                // init grandTotal rural for this header
+                if (!finaldata.grandTotal[areatype[0]])
+                    finaldata.grandTotal[areatype[0]] = {};
+
+                if (!finaldata.grandTotal[areatype[0]][header])
+                    finaldata.grandTotal[areatype[0]][header] = { total: 0 };
+
+                finaldata.grandTotal[areatype[0]][header].total += total;
+                finaldata.grandTotal.finaltotal += total;
+            }
+        } else {
+            // fill zero rural
+            stateBlock[areatype[0]] = { report_header: [], areatotal: 0 };
+            for (let header of tableheaders) {
+                stateBlock[areatype[0]].report_header.push({ name: header, total: 0 });
+            }
+        }
+
+        // URBAN + COMBINED
+        if (areatype.length > 1) {
+            if (stateBlock[areatype[1]]) {
+                let urbanTotals = Object.fromEntries(
+                    stateBlock[areatype[1]].report_header.map(h => [h.name, h.total])
+                );
+
+                stateBlock[areatype[1]].report_header = [];
+                stateBlock[areatype[1]].areatotal = 0;
+                stateBlock.combined = { report_header: [] };
+
+                for (let header of tableheaders) {
+                    let urban = urbanTotals[header] || 0;
+                    let rural =
+                        stateBlock[areatype[0]].report_header.find(h => h.name === header)?.total || 0;
+
+                    let combined = rural + urban;
+
+                    stateBlock[areatype[1]].report_header.push({
+                        name: header,
+                        total: urban
+                    });
+
+                    stateBlock[areatype[1]].areatotal += urban;
+
+                    stateBlock.combined.report_header.push({
+                        name: header,
+                        total: combined
+                    });
+
+                    // grand totals
+                    if (!finaldata.grandTotal[areatype[1]])
+                        finaldata.grandTotal[areatype[1]] = {};
+
+                    if (!finaldata.grandTotal[areatype[1]][header])
+                        finaldata.grandTotal[areatype[1]][header] = { total: 0 };
+
+                    finaldata.grandTotal[areatype[1]][header].total += urban;
+
+                    if (!finaldata.grandTotal.combined)
+                        finaldata.grandTotal.combined = {};
+
+                    if (!finaldata.grandTotal.combined[header])
+                        finaldata.grandTotal.combined[header] = { total: 0 };
+
+                    finaldata.grandTotal.combined[header].total += combined;
+
+                    finaldata.grandTotal.finaltotal += urban;
+                }
+            } else {
+                // NO URBAN → combined = rural
+                stateBlock[areatype[1]] = { report_header: [], areatotal: 0 };
+                stateBlock.combined = { report_header: [] };
+
+                for (let header of tableheaders) {
+                    let rural =
+                        stateBlock[areatype[0]].report_header.find(h => h.name === header)?.total || 0;
+
+                    stateBlock[areatype[1]].report_header.push({ name: header, total: 0 });
+
+                    stateBlock.combined.report_header.push({
+                        name: header,
+                        total: rural
+                    });
+                }
+            }
+        }
+    }
+
+    // -----------------------------
+    // THIRD PASS → TABLE WISE DATA
+    // -----------------------------
+    if (tablewiseChartData && tablewiseChartData.length > 0) {
+        let tableHeadersObj = {};
+
+        tablewiseChartData.forEach(row => {
+            tableHeadersObj[row.report_order] = row.report_header;
+        });
+
+        let tHeaders = Object.values(
+            Object.keys(tableHeadersObj)
+                .sort((a, b) => a - b)
+                .map(key => tableHeadersObj[key])
+        );
+
+        for (let row of tablewiseChartData) {
+            if (!tHeaders.includes(row.report_header)) continue;
+
+            const state = row.state;
+            const tableName = row.tableName;
+
+            if (!finaldata.tabledata) finaldata.tabledata = {};
+            if (!finaldata.tabledata[state]) finaldata.tabledata[state] = {};
+            if (!finaldata.tabledata[state][tableName])
+                finaldata.tabledata[state][tableName] = { report_header: [] };
+
+            finaldata.tabledata[state][tableName].report_header.push({
+                name: row.report_header,
+                total: row.total
+            });
+        }
+    }
+
+    return finaldata;
+}
+
+async function processCentralChartData(chartData, tablewiseChartData = null, tableheaders, reportHeader, areatype) {
+    const output = {
+        State: {},
+        grandTotal: {
+            rural: {},
+            urban: {},
+            combined: {},
+            finaltotal: 0
+        },
+        tabledata: {}
+    };
+
+    const AREAS = ["rural", "urban"];
+    const toNumber = v => Number(v || 0);
+
+    // ---------- INIT GRAND TOTAL ----------
+    for (const area of AREAS) {
+        output.grandTotal[area] = { areatotal: 0 };
+        for (const h of tableheaders) {
+            output.grandTotal[area][h] = { total: 0 };
+        }
+    }
+
+    output.grandTotal.combined = {};
+    for (const h of tableheaders) {
+        output.grandTotal.combined[h] = { total: 0 };
+    }
+
+    // ---------- GROUP RAW DATA ----------
+    for (const row of chartData) {
+        const { state, area_type, report_header } = row;
+        const total = toNumber(row.total);
+
+        if (!output.State[state]) {
+            output.State[state] = {
+                State: state,
+                rural: { report_header: [], areatotal: 0 },
+                urban: { report_header: [], areatotal: 0 },
+                combined: { report_header: [] },
+                grandTotal: 0
+            };
+        }
+
+        const stateObj = output.State[state];
+        stateObj[area_type][report_header] =
+            (stateObj[area_type][report_header] || 0) + total;
+    }
+
+    // ---------- NORMALIZE HEADERS + TOTALS ----------
+    for (const state in output.State) {
+        const stateObj = output.State[state];
+
+        for (const area of AREAS) {
+            for (const h of tableheaders) {
+                const val = toNumber(stateObj[area][h]);
+
+                stateObj[area].report_header.push({
+                    name: h,
+                    total: String(val)
+                });
+
+                stateObj[area].areatotal += val;
+                output.grandTotal[area][h].total += val;
+                output.grandTotal[area].areatotal += val;
+                output.grandTotal.finaltotal += val;
+            }
+        }
+
+        // ---------- COMBINED ----------
+        for (const h of tableheaders) {
+            const ruralVal = toNumber(
+                stateObj.rural.report_header.find(x => x.name === h)?.total
+            );
+            const urbanVal = toNumber(
+                stateObj.urban.report_header.find(x => x.name === h)?.total
+            );
+
+            const combined = ruralVal + urbanVal;
+
+            stateObj.combined.report_header.push({
+                name: h,
+                total: combined
+            });
+
+            output.grandTotal.combined[h].total += combined;
+            stateObj.grandTotal += combined;
+        }
+    }
+
+    // ---------- TABLEDATA (SAFE DEFAULT) ----------
+    for (const row of tablewiseChartData) {
+        const { State, tableName, report_header, total } = row;
+
+        if (!output.tabledata[State]) {
+            output.tabledata[State] = {};
+        }
+
+        if (!output.tabledata[State][tableName]) {
+            output.tabledata[State][tableName] = { report_header: [] };
+        }
+
+        output.tabledata[State][tableName].report_header.push({
+            name: report_header,
+            total: String(total)
+        });
+    }
+
+    return output;
+}
+
+
+module.exports = {
+    workersChartData,
+    processstatewisechart,
+    processChartData,
+    processCentralChartData,
+    processStateChartData
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statewise-chart-processor",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Processes statewise chart data for census reports.",
   "main": "index.js",
   "keywords": ["census", "statewise", "chart", "data", "processor"],