quality_recticel/windows_print_service/chrome_extension/content.js

/**
 * Quality Recticel Print Service - Content Script
 * Injects print service functionality into web pages
 */

// Only inject on Quality Recticel domains or localhost
const allowedDomains = [
    'localhost',
    '127.0.0.1'
];

const currentDomain = window.location.hostname;
if (!allowedDomains.includes(currentDomain)) {
    console.log('Quality Recticel Print Service: Not injecting on', currentDomain);
    // return; // Commented out for development - remove in production
}

console.log('Quality Recticel Print Service: Content script loaded');

// Inject print service API into the page
const printServiceAPI = {
    
    /**
     * Print PDF via the service
     */
    async printPDF(printData) {
        try {
            return new Promise((resolve) => {
                chrome.runtime.sendMessage({
                    action: 'print_pdf',
                    data: printData
                }, resolve);
            });
        } catch (error) {
            console.error('Print PDF error:', error);
            return { success: false, error: error.message };
        }
    },
    
    /**
     * Silent print PDF
     */
    async silentPrint(printData) {
        try {
            return new Promise((resolve) => {
                chrome.runtime.sendMessage({
                    action: 'silent_print',
                    data: printData
                }, resolve);
            });
        } catch (error) {
            console.error('Silent print error:', error);
            return { success: false, error: error.message };
        }
    },
    
    /**
     * Get available printers
     */
    async getPrinters() {
        try {
            return new Promise((resolve) => {
                chrome.runtime.sendMessage({
                    action: 'get_printers'
                }, resolve);
            });
        } catch (error) {
            console.error('Get printers error:', error);
            return { success: false, error: error.message, printers: [] };
        }
    },
    
    /**
     * Check service status
     */
    async checkService() {
        try {
            return new Promise((resolve) => {
                chrome.runtime.sendMessage({
                    action: 'check_service'
                }, resolve);
            });
        } catch (error) {
            console.error('Check service error:', error);
            return { success: false, error: error.message };
        }
    },
    
    /**
     * Print labels with Quality Recticel specific formatting
     */
    async printLabels(orderData, quantity = 1) {
        try {
            // Generate PDF URL for the labels
            const pdfUrl = `/generate_labels_pdf/${orderData.order_id}`;
            
            const printData = {
                pdf_url: window.location.origin + pdfUrl,
                printer_name: 'default',
                copies: 1,
                order_id: orderData.order_id,
                quantity: quantity,
                silent: true
            };
            
            return await this.silentPrint(printData);
            
        } catch (error) {
            console.error('Print labels error:', error);
            return { success: false, error: error.message };
        }
    }
};

// Make API available globally
window.QualityRecticelPrintService = printServiceAPI;

// Inject into page context for better compatibility
const script = document.createElement('script');
script.textContent = `
    // Quality Recticel Print Service API
    window.QualityRecticelPrintService = ${JSON.stringify(printServiceAPI)};
    
    // Enhanced print function for Quality Recticel
    window.printQualityRecticelLabels = async function(orderData, quantity) {
        try {
            // Get the PDF blob from the server
            const response = await fetch('/generate_labels_pdf/' + orderData.order_id, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' }
            });
            
            if (!response.ok) {
                throw new Error('Failed to generate PDF');
            }
            
            const blob = await response.blob();
            
            // Convert to base64
            return new Promise((resolve) => {
                const reader = new FileReader();
                reader.onloadend = async () => {
                    const base64Data = reader.result.split(',')[1];
                    
                    const printData = {
                        pdf_data: base64Data,
                        printer_name: 'default',
                        copies: 1,
                        silent: true
                    };
                    
                    // Send message to content script
                    const result = await new Promise((msgResolve) => {
                        window.postMessage({
                            type: 'QUALITY_RECTICEL_PRINT',
                            action: 'silent_print',
                            data: printData
                        }, '*');
                        
                        // Listen for response
                        const listener = (event) => {
                            if (event.data.type === 'QUALITY_RECTICEL_PRINT_RESPONSE') {
                                window.removeEventListener('message', listener);
                                msgResolve(event.data.result);
                            }
                        };
                        window.addEventListener('message', listener);
                    });
                    
                    resolve(result);
                };
                reader.readAsDataURL(blob);
            });
            
        } catch (error) {
            console.error('Print Quality Recticel labels error:', error);
            return { success: false, error: error.message };
        }
    };
    
    console.log('Quality Recticel Print Service API injected');
`;
document.documentElement.appendChild(script);

// Listen for messages from injected script
window.addEventListener('message', async (event) => {
    if (event.source !== window) return;
    
    if (event.data.type === 'QUALITY_RECTICEL_PRINT') {
        try {
            let result;
            
            switch (event.data.action) {
                case 'silent_print':
                    result = await printServiceAPI.silentPrint(event.data.data);
                    break;
                case 'print_pdf':
                    result = await printServiceAPI.printPDF(event.data.data);
                    break;
                case 'get_printers':
                    result = await printServiceAPI.getPrinters();
                    break;
                default:
                    result = { success: false, error: 'Unknown action' };
            }
            
            // Send response back
            window.postMessage({
                type: 'QUALITY_RECTICEL_PRINT_RESPONSE',
                result: result
            }, '*');
            
        } catch (error) {
            window.postMessage({
                type: 'QUALITY_RECTICEL_PRINT_RESPONSE',
                result: { success: false, error: error.message }
            }, '*');
        }
    }
});

// Notify page that extension is ready
document.addEventListener('DOMContentLoaded', () => {
    window.dispatchEvent(new CustomEvent('QualityRecticelPrintServiceReady', {
        detail: { 
            version: chrome.runtime.getManifest().version,
            api: printServiceAPI
        }
    }));
});

console.log('Quality Recticel Print Service: Content script initialized');