Extract Qualtrics Dashboard Data Field Mappings - Complete Guide

/**
 * Qualtrics Dashboard Field Extractor
 * Extracts Field Type, Field Name, and ALL Data Source Mappings
 */

(function() {
    console.log('=== Qualtrics Field Extractor Started ===');
    
    function getDataSourceNames() {
        const sourceNames = [];
        const sourceContainers = document.querySelectorAll('.source-menu-container');
        
        console.log(`Found ${sourceContainers.length} source containers`);
        
        sourceContainers.forEach((container, index) => {
            try {
                const labelContainer = container.querySelector('.source-label-container');
                if (labelContainer) {
                    const sourceName = labelContainer.textContent.trim();
                    sourceNames.push({
                        index: index,
                        name: sourceName
                    });
                    console.log(`Source ${index + 1}: ${sourceName}`);
                }
            } catch (error) {
                console.warn(`Error getting source name ${index}:`, error);
                sourceNames.push({
                    index: index,
                    name: `Source ${index + 1}`
                });
            }
        });
        
        return sourceNames;
    }
    
    function extractFieldData() {
        const fields = [];
        const dataSources = getDataSourceNames();
        
        console.log(`\nData Sources Found: ${dataSources.length}`);
        dataSources.forEach(ds => console.log(`  - ${ds.name}`));
        
        const fieldRows = document.querySelectorAll('li.grid-field-info');
        
        console.log(`\nFound ${fieldRows.length} field rows\n`);
        
        fieldRows.forEach((row, index) => {
            try {
                let fieldType = 'Unknown';
                let fieldName = 'Unknown';
                const sourceMappings = {};
                
                const fieldTypeElement = row.querySelector('field-type .type-text');
                if (fieldTypeElement) {
                    fieldType = fieldTypeElement.textContent.trim();
                }
                
                const fieldNameElement = row.querySelector('field-name .no-wrap-ellipsis-text.no-input');
                if (fieldNameElement) {
                    fieldName = fieldNameElement.textContent.trim();
                }
                
                const sourceFields = row.querySelectorAll('.sources-side-row');
                
                sourceFields.forEach((sourceField, sourceIndex) => {
                    try {
                        let mappingText = '';
                        
                        const notMappedElement = sourceField.querySelector('[data-key="NOT_MAPPED"]');
                        if (notMappedElement) {
                            mappingText = 'Not mapped';
                        } else {
                            const sourceNameSpan = sourceField.querySelector('.source-field-name span');
                            if (sourceNameSpan) {
                                const allSpans = sourceField.querySelectorAll('.source-field-name span');
                                for (let span of allSpans) {
                                    const text = span.textContent.trim();
                                    if (text && text !== 'Not mapped') {
                                        mappingText = text;
                                        break;
                                    }
                                }
                            }
                        }
                        
                        const sourceName = dataSources[sourceIndex] ? dataSources[sourceIndex].name : `Source ${sourceIndex + 1}`;
                        sourceMappings[sourceName] = mappingText || 'Not mapped';
                        
                    } catch (error) {
                        console.warn(`Error processing source ${sourceIndex} for field ${index}:`, error);
                        const sourceName = dataSources[sourceIndex] ? dataSources[sourceIndex].name : `Source ${sourceIndex + 1}`;
                        sourceMappings[sourceName] = 'Error';
                    }
                });
                
                if (fieldType !== 'Unknown' || fieldName !== 'Unknown') {
                    const fieldData = {
                        index: index + 1,
                        fieldType: fieldType,
                        fieldName: fieldName,
                        ...sourceMappings
                    };
                    
                    fields.push(fieldData);
                    
                    if ((index + 1) % 5 === 0) {
                        console.log(`Processed ${index + 1} fields...`);
                    }
                }
            } catch (error) {
                console.warn(`Error processing row ${index}:`, error);
            }
        });
        
        return fields;
    }
    
    function displayAsTable(fields) {
        console.log('\n=== EXTRACTED FIELDS ===\n');
        console.table(fields);
        console.log(`\nTotal fields extracted: ${fields.length}`);
    }
    
    function convertToCSV(fields) {
        if (fields.length === 0) return '';
        
        const allKeys = new Set();
        fields.forEach(field => {
            Object.keys(field).forEach(key => allKeys.add(key));
        });
        
        const keys = Array.from(allKeys).filter(key => key !== 'index');
        const orderedHeaders = ['fieldType', 'fieldName', ...keys.filter(h => h !== 'fieldType' && h !== 'fieldName')];
        
        const headerRow = orderedHeaders.map(h => {
            if (h === 'fieldType') return 'Field Type';
            if (h === 'fieldName') return 'Field Name';
            return h;
        }).map(h => `"${h}"`).join(',');
        
        const dataRows = fields.map(field => {
            return orderedHeaders.map(key => {
                const value = field[key] || '';
                return `"${String(value).replace(/"/g, '""')}"`;
            }).join(',');
        }).join('\n');
        
        return headerRow + '\n' + dataRows;
    }
    
    function downloadCSV(csv, filename = 'qualtrics_fields.csv') {
        const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement('a');
        const url = URL.createObjectURL(blob);
        
        link.setAttribute('href', url);
        link.setAttribute('download', filename);
        link.style.visibility = 'hidden';
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        
        console.log(`✓ Downloaded: ${filename}`);
    }
    
    function copyToClipboard(text) {
        const textarea = document.createElement('textarea');
        textarea.value = text;
        textarea.style.position = 'fixed';
        textarea.style.opacity = '0';
        document.body.appendChild(textarea);
        textarea.select();
        
        try {
            document.execCommand('copy');
            console.log('✓ CSV data copied to clipboard!');
            return true;
        } catch (err) {
            console.error('Failed to copy to clipboard:', err);
            return false;
        } finally {
            document.body.removeChild(textarea);
        }
    }
    
    console.log('Starting extraction...\n');
    const extractedFields = extractFieldData();
    
    if (extractedFields.length === 0) {
        console.error('❌ No fields found! Make sure you are on the Qualtrics Dashboard Data mapping page.');
        return;
    }
    
    displayAsTable(extractedFields);
    
    const csvData = convertToCSV(extractedFields);
    
    window.qualtricsFieldData = extractedFields;
    window.qualtricsFieldCSV = csvData;
    
    window.downloadQualtricsCSV = function(filename) {
        downloadCSV(csvData, filename || 'qualtrics_fields.csv');
    };
    
    window.copyQualtricsCSV = function() {
        return copyToClipboard(csvData);
    };
    
    window.getQualtricsJSON = function() {
        return JSON.stringify(extractedFields, null, 2);
    };
    
    window.downloadQualtricsJSON = function(filename) {
        const json = JSON.stringify(extractedFields, null, 2);
        const blob = new Blob([json], { type: 'application/json' });
        const link = document.createElement('a');
        const url = URL.createObjectURL(blob);
        
        link.setAttribute('href', url);
        link.setAttribute('download', filename || 'qualtrics_fields.json');
        link.style.visibility = 'hidden';
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        
        console.log(`✓ Downloaded: ${filename || 'qualtrics_fields.json'}`);
    };
    
    console.log('\n=== ACTIONS AVAILABLE ===');
    console.log('1. Download CSV:  downloadQualtricsCSV()');
    console.log('2. Download JSON: downloadQualtricsJSON()');
    console.log('3. Copy CSV:      copyQualtricsCSV()');
    console.log('4. View data:     qualtricsFieldData');
    console.log('5. View CSV:      qualtricsFieldCSV');
    console.log('6. View JSON:     getQualtricsJSON()');
    
    console.log('\n✓ Extraction complete! Use the commands above to export the data.');
    
})();