Refactor review submission process to enhance GitHub integration

stephen-rowan · stephen-rowan · commit c64f87af704b · 2025-11-01T22:32:50.000Z
Updated the submitReview function to be asynchronous, allowing for the addition of reviews directly to the GitHub repository via the GitHub API. Introduced error handling for GitHub submission failures and improved user feedback for local storage saves. Renamed and modified the downloadReviewJSONForSubmission function to addReviewToReviewsFolder, which now handles file creation and updates on GitHub.
diff --git a/docs/script.js b/docs/script.js
@@ -489,7 +489,7 @@ async function loadReviewsFromJSON() {
 }
 
 // Submit review form
-function submitReview(event, methodName) {
+async function submitReview(event, methodName) {
     event.preventDefault();
     
     const form = document.getElementById(`review-form-${methodName}`);
@@ -511,13 +511,17 @@ function submitReview(event, methodName) {
     reviews.push(review);
     saveReviewsToStorage(reviews);
     
-    // Automatically download JSON file for the review
-    downloadReviewJSONForSubmission(review);
-    
-    // Show success message
-    const successDiv = document.getElementById(`review-success-${methodName}`);
-    if (successDiv) {
-        successDiv.style.display = 'block';
+    // Automatically add JSON file to reviews folder via GitHub API
+    try {
+        await addReviewToReviewsFolder(review);
+        // Show success message
+        const successDiv = document.getElementById(`review-success-${methodName}`);
+        if (successDiv) {
+            successDiv.style.display = 'block';
+        }
+    } catch (error) {
+        console.error('Error adding review to reviews folder:', error);
+        alert('Review saved locally. Could not add to reviews folder. Please use "Download Review as JSON" and commit manually.');
     }
     
     // Reset form
@@ -534,8 +538,8 @@ function submitReview(event, methodName) {
     return false;
 }
 
-// Download review as JSON file for submission to /reviews/ directory
-function downloadReviewJSONForSubmission(review) {
+// Add review JSON file to reviews/ folder via GitHub API
+async function addReviewToReviewsFolder(review) {
     // Ensure all required fields are present
     const reviewObject = {
         id: review.id || Date.now().toString(),
@@ -548,16 +552,320 @@ function downloadReviewJSONForSubmission(review) {
         timestamp: review.timestamp
     };
     
+    // Create JSON content for the file
+    const jsonContent = JSON.stringify(reviewObject, null, 2);
+    const fileName = `review_${review.method}_${review.id}.json`;
+    const filePath = `reviews/${fileName}`;
+    
+    // GitHub repository info
+    const repoOwner = 'SingularityNET-Archive';
+    const repoName = 'Graph-Python-scripts';
+    const branch = 'main';
+    
+    // Get GitHub token from localStorage or prompt user
+    let githubToken = localStorage.getItem('github_token');
+    
+    if (!githubToken) {
+        // Prompt for token
+        githubToken = prompt('GitHub Personal Access Token required to add file to reviews folder.\n\nPlease enter your token (starts with ghp_):');
+        if (!githubToken || !githubToken.startsWith('ghp_')) {
+            throw new Error('Valid GitHub token required');
+        }
+        // Verify token and store it
+        try {
+            const userResponse = await fetch('https://api.github.com/user', {
+                headers: {
+                    'Authorization': `token ${githubToken}`,
+                    'Accept': 'application/vnd.github.v3+json'
+                }
+            });
+            if (!userResponse.ok) {
+                throw new Error('Invalid token');
+            }
+            localStorage.setItem('github_token', githubToken);
+        } catch (error) {
+            throw new Error('Invalid GitHub token. Please try again.');
+        }
+    }
+    
+    // Encode file content to base64
+    const base64Content = btoa(unescape(encodeURIComponent(jsonContent)));
+    
+    try {
+        // Get the current file SHA (if it exists) for update
+        const apiUrl = `https://api.github.com/repos/${repoOwner}/${repoName}/contents/${filePath}`;
+        
+        // First, check if file exists
+        let fileSha = null;
+        try {
+            const response = await fetch(`${apiUrl}?ref=${branch}`, {
+                headers: {
+                    'Authorization': `token ${githubToken}`,
+                    'Accept': 'application/vnd.github.v3+json'
+                }
+            });
+            if (response.ok) {
+                const data = await response.json();
+                fileSha = data.sha;
+            }
+        } catch (e) {
+            // File doesn't exist, which is fine for new files
+        }
+        
+        // Create or update the file
+        const createResponse = await fetch(apiUrl, {
+            method: fileSha ? 'PUT' : 'POST',
+            headers: {
+                'Authorization': `token ${githubToken}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                message: `Add review for ${review.method} analysis [skip ci]`,
+                content: base64Content,
+                branch: branch,
+                ...(fileSha ? { sha: fileSha } : {})
+            })
+        });
+        
+        if (!createResponse.ok) {
+            const errorData = await createResponse.json();
+            // If unauthorized, clear token and ask to re-enter
+            if (createResponse.status === 401) {
+                localStorage.removeItem('github_token');
+                throw new Error('Authentication expired. Please refresh and try again.');
+            }
+            throw new Error(errorData.message || 'Failed to create file on GitHub');
+        }
+        
+        const result = await createResponse.json();
+        console.log('Review file added to reviews folder successfully:', result.content.html_url);
+        return true;
+        
+    } catch (error) {
+        console.error('Error adding file to reviews folder:', error);
+        throw error;
+    }
+}
+
+// Display reviews for a specific method
+function displayReviewsForMethod(methodName) {
+    const reviewsList = document.getElementById(`reviews-list-${methodName}`);
+    if (!reviewsList) return;
+    
+    const allReviews = loadReviewsFromStorage();
+    const methodReviews = allReviews.filter(r => r.method === methodName);
+    
+    if (methodReviews.length === 0) {
+        reviewsList.innerHTML = '<p style="color: #586069; font-size: 0.9em;">No reviews yet. Be the first to submit a review!</p>';
+        return;
+    }
+    
+    reviewsList.innerHTML = '<h4>Previous Reviews</h4>' + methodReviews.map(review => {
+        const date = new Date(review.timestamp).toLocaleString();
+        return `
+            <div class="review-item rating-${review.rating}">
+                <div class="review-item-header">
+                    <span class="review-item-rating rating-${review.rating}">${review.rating.toUpperCase()}</span>
+                    <span class="review-item-meta">${review.reviewer} • ${date}</span>
+                </div>
+                <div class="review-item-comment">${escapeHtml(review.comment)}</div>
+                ${review.suggestions ? `<div class="review-item-suggestions"><strong>Suggestions:</strong> ${escapeHtml(review.suggestions)}</div>` : ''}
+            </div>
+        `;
+    }).join('');
+}
+
+// Escape HTML to prevent XSS
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+// Download review as JSON (single review object format for GitHub workflow)
+function downloadReviewJSON(methodName) {
+    const allReviews = loadReviewsFromStorage();
+    const methodReviews = allReviews.filter(r => r.method === methodName);
+    
+    if (methodReviews.length === 0) {
+        alert('No reviews to download for this method.');
+        return;
+    }
+    
+    // Get the most recent review (or allow user to select one)
+    // For now, download the most recent review as a single object
+    const latestReview = methodReviews.sort((a, b) => 
+        new Date(b.timestamp) - new Date(a.timestamp)
+    )[0];
+    
+    // Ensure all required fields are present
+    const reviewObject = {
+        id: latestReview.id || Date.now().toString(),
+        method: latestReview.method,
+        rating: latestReview.rating,
+        comment: latestReview.comment || '',
+        reviewer: latestReview.reviewer || 'Anonymous',
+        suggestions: latestReview.suggestions || '',
+        file: latestReview.file || 'docs/index.html',
+        timestamp: latestReview.timestamp
+    };
+    
     const dataStr = JSON.stringify(reviewObject, null, 2);
     const dataBlob = new Blob([dataStr], { type: 'application/json' });
     const url = URL.createObjectURL(dataBlob);
     const link = document.createElement('a');
     link.href = url;
-    link.download = `review_${review.method}_${review.id}.json`;
+    link.download = `review_${methodName}_${latestReview.id || Date.now()}.json`;
     link.click();
     URL.revokeObjectURL(url);
 }
 
+// Load and display reviews when tab is shown
+function loadReviewsForTab(methodName) {
+    displayReviewsForMethod(methodName);
+}
+
+// Update audit tab to show reviews
+async function loadAuditData() {
+    const auditTab = document.getElementById('audit');
+    if (!auditTab || !auditTab.classList.contains('active')) {
+        return;
+    }
+    
+    // Load from localStorage
+    const localReviews = loadReviewsFromStorage();
+    
+    // Load from JSON file
+    const jsonData = await loadReviewsFromJSON();
+    
+    // Combine both sources
+    const allReviews = [...localReviews];
+    if (jsonData.methods) {
+        Object.keys(jsonData.methods).forEach(method => {
+            if (jsonData.methods[method].reviews) {
+                jsonData.methods[method].reviews.forEach(review => {
+                    // Avoid duplicates
+                    if (!allReviews.find(r => r.id === review.id)) {
+                        allReviews.push(review);
+                    }
+                });
+            }
+        });
+    }
+    
+    // Group by method
+    const reviewsByMethod = {};
+    const methodStats = {};
+    
+    ['coattendance', 'field-degree', 'path-structure', 'centrality', 'clustering', 'components'].forEach(method => {
+        const methodReviews = allReviews.filter(r => r.method === method);
+        reviewsByMethod[method] = methodReviews;
+        
+        const stats = {
+            total: methodReviews.length,
+            correct: methodReviews.filter(r => r.rating === 'correct').length,
+            incorrect: methodReviews.filter(r => r.rating === 'incorrect').length,
+            needs_review: methodReviews.filter(r => r.rating === 'needs-review').length,
+            trust_score: 0
+        };
+        
+        if (stats.total > 0) {
+            stats.trust_score = ((stats.correct - stats.incorrect) / stats.total + 1) / 2;
+        }
+        
+        methodStats[method] = stats;
+    });
+    
+    // Display audit data
+    displayAuditData(methodStats, reviewsByMethod, jsonData.last_updated);
+}
+
+// Display audit data in the audit tab
+function displayAuditData(methodStats, reviewsByMethod, lastUpdated) {
+    const auditTab = document.getElementById('audit');
+    if (!auditTab) return;
+    
+    let html = '<h2>Community Review Audit</h2>';
+    
+    if (lastUpdated) {
+        html += `<p class="explanation">Last updated from JSON: ${new Date(lastUpdated).toLocaleString()}</p>`;
+    }
+    
+    html += '<div class="audit-stats">';
+    Object.keys(methodStats).forEach(method => {
+        const stats = methodStats[method];
+        const methodName = method.replace('-', ' ').replace(/\b\w/g, l => l.toUpperCase());
+        html += `
+            <div class="method-stat-card">
+                <h3>${methodName}</h3>
+                <div class="stat-row">
+                    <span>Total Reviews:</span>
+                    <strong>${stats.total}</strong>
+                </div>
+                <div class="stat-row">
+                    <span>Trust Score:</span>
+                    <strong>${(stats.trust_score * 100).toFixed(1)}%</strong>
+                </div>
+                <div class="stat-row">
+                    <span>Ratings:</span>
+                    <span>✓ ${stats.correct} | ? ${stats.needs_review} | ✗ ${stats.incorrect}</span>
+                </div>
+            </div>
+        `;
+    });
+    html += '</div>';
+    
+    html += '<h3>All Reviews</h3>';
+    Object.keys(reviewsByMethod).forEach(method => {
+        const reviews = reviewsByMethod[method];
+        if (reviews.length === 0) return;
+        
+        const methodName = method.replace('-', ' ').replace(/\b\w/g, l => l.toUpperCase());
+        html += `<h4>${methodName}</h4>`;
+        html += reviews.map(review => {
+            const date = new Date(review.timestamp).toLocaleString();
+            return `
+                <div class="review-item rating-${review.rating}">
+                    <div class="review-item-header">
+                        <span class="review-item-rating rating-${review.rating}">${review.rating.toUpperCase()}</span>
+                        <span class="review-item-meta">${review.reviewer} • ${date}</span>
+                    </div>
+                    <div class="review-item-comment">${escapeHtml(review.comment)}</div>
+                    ${review.suggestions ? `<div class="review-item-suggestions"><strong>Suggestions:</strong> ${escapeHtml(review.suggestions)}</div>` : ''}
+                </div>
+            `;
+        }).join('');
+    });
+    
+    auditTab.innerHTML = html;
+}
+
+// Wrap the original showTab function to add review loading
+(function() {
+    // Store original showTab function
+    const originalShowTab = showTab;
+    
+    // Override showTab to load reviews when switching tabs
+    window.showTab = function(tabId) {
+        // Call original showTab
+        originalShowTab(tabId);
+        
+        // Load reviews for the current tab
+        setTimeout(() => {
+            const validMethods = ['coattendance', 'field-degree', 'path-structure', 'centrality', 'clustering', 'components'];
+            if (validMethods.includes(tabId)) {
+                if (typeof loadReviewsForTab === 'function') {
+                    loadReviewsForTab(tabId);
+                }
+            } else if (tabId === 'audit') {
+                if (typeof loadAuditData === 'function') {
+                    loadAuditData();
+                }
+            }
+        }, 100);
+    };
+})();
 
 // Load reviews on page load
 document.addEventListener('DOMContentLoaded', function() {
