Enhancements to finalize the OpenPeerReview oemetadata-v2

dataedit/helper.py

@@ -49,9 +49,9 @@ def merge_field_reviews(current_json, new_json):
 
     Note:
         If the same key is present in both the contributor's and
-            reviewer's reviews, the function will merge the field
-            evaluations. Otherwise, it will create a new entry in
-            the Review-Dict.
+        reviewer's reviews, the function will merge the field
+        evaluations. Otherwise, it will create a new entry in
+        the Review-Dict.
     """
     merged_json = new_json.copy()
     review_dict = {}
@@ -88,18 +88,7 @@ def merge_field_reviews(current_json, new_json):
 
 
 def get_review_for_key(key, review_data):
-    """
-    Retrieve the review for a specific key from the review data.
-
-    Args:
-        key (str): The key for which to retrieve the review.
-            review_data (dict): The review data containing
-            reviews for various keys.
-
-    Returns:
-        Any: The new value associated with the specified key
-            in the review data, or None if the key is not found.
-    """
+    """Retrieve the review for a specific key from the review data."""
 
     for review in review_data["reviewData"]["reviews"]:
         if review["key"] == key:
@@ -108,20 +97,9 @@ def get_review_for_key(key, review_data):
 
 
 def recursive_update(metadata, review_data):
-    """
-    Recursively updates metadata with new values from review_data,
-    skipping or removing fields with status 'rejected'.
-
-    Args:
-    metadata (dict): The original metadata dictionary to update.
-    review_data (dict): The review data containing the new values
-    for various keys.
+    """Recursively updates metadata with new values from review_data.
 
-    Note:
-    The function iterates through the review data and for each key
-    updates the corresponding value in metadata if the new value is
-    present and is not an empty string, and if the field status is
-    not 'rejected'.
+    Skips or removes fields with status 'rejected'.
     """
 
     def delete_nested_field(data: list | dict | None, keys: list[str]):
@@ -189,18 +167,7 @@ def delete_nested_field(data: list | dict | None, keys: list[str]):
 
 
 def set_nested_value(metadata, keys, value):
-    """
-    Set a nested value in a dictionary given a sequence of keys.
-
-    Args:
-        metadata (dict): The dictionary in which to set the value.
-        keys (list): A list of keys representing the path to the nested value.
-        value (Any): The value to set.
-
-    Note:
-        The function navigates through the dictionary using the keys
-        and sets the value at the position indicated by the last key in the list.
-    """
+    """Set a nested value in a dictionary given a sequence of keys."""
 
     for key in keys[:-1]:
         if key.isdigit():
@@ -213,73 +180,93 @@ def set_nested_value(metadata, keys, value):
 
 
 def process_review_data(review_data, metadata, categories):
-    state_dict = {}
+    """Attach reviewer fields (suggestions/comments/newValue) to metadata items.
 
-    # Initialize fields
-    for category in categories:
-        for item in metadata[category]:
-            item["reviewer_suggestion"] = ""
-            item["suggestion_comment"] = ""
-            item["additional_comment"] = ""
-            item["newValue"] = ""
+    The `metadata[category]` structures may be nested (dict/list) and can contain
+    non-dict leaf values (e.g. strings). We therefore walk the structure
+    recursively and only mutate leaf dicts that represent a field item.
+    """
+
+    state_dict: dict[str, str | None] = {}
+
+    def iter_field_items(node):
+        """Yield all leaf field-item dicts inside nested list/dict structures.
 
-    for review in review_data:
+        A leaf field item is a dict with a string key `field`.
+        """
+        if isinstance(node, list):
+            for el in node:
+                yield from iter_field_items(el)
+        elif isinstance(node, dict):
+            if isinstance(node.get("field"), str):
+                yield node
+            else:
+                for v in node.values():
+                    yield from iter_field_items(v)
+        # Ignore other node types (e.g. str/int/None)
+
+    # Initialize fields safely
+    for category in categories:
+        cat_node = metadata.get(category)
+        if cat_node is None:
+            continue
+        for item in iter_field_items(cat_node):
+            item.setdefault("reviewer_suggestion", "")
+            item.setdefault("suggestion_comment", "")
+            item.setdefault("additional_comment", "")
+            item.setdefault("newValue", "")
+
+    # Apply review values
+    for review in review_data or []:
         field_key = review.get("key")
         field_review = review.get("fieldReview")
-        category = review.get("category")  # Get the category from the review
+        category = review.get("category")
+
+        state = None
+        reviewer_suggestion = ""
+        reviewer_suggestion_comment = ""
+        newValue = ""
+        additional_comment = ""
 
         if isinstance(field_review, list):
-            # Sort and get the latest field review
             sorted_field_review = sorted(
-                field_review, key=lambda x: x.get("timestamp"), reverse=True
-            )
-            latest_field_review = (
-                sorted_field_review[0] if sorted_field_review else None
+                field_review,
+                key=lambda x: (x.get("timestamp") or 0) if isinstance(x, dict) else 0,
+                reverse=True,
             )
+            latest = sorted_field_review[0] if sorted_field_review else None
+            if isinstance(latest, dict):
+                state = latest.get("state")
+                reviewer_suggestion = latest.get("reviewerSuggestion") or ""
+                reviewer_suggestion_comment = latest.get("comment") or ""
+                newValue = latest.get("newValue") or ""
+                additional_comment = latest.get("additionalComment") or ""
 
-            if latest_field_review:
-                state = latest_field_review.get("state")
-                reviewer_suggestion = latest_field_review.get("reviewerSuggestion")
-                reviewer_suggestion_comment = latest_field_review.get("comment")
-                newValue = latest_field_review.get("newValue")
-                additional_comment = latest_field_review.get("additionalComment")
-            else:
-                state = None
-                reviewer_suggestion = ""
-                reviewer_suggestion_comment = ""
-                newValue = ""
-                additional_comment = ""
-        else:
+        elif isinstance(field_review, dict):
             state = field_review.get("state")
-            reviewer_suggestion = field_review.get("reviewerSuggestion")
-            reviewer_suggestion_comment = field_review.get("comment")
-            newValue = field_review.get("newValue")
-            additional_comment = field_review.get("additionalComment")
-
-        # Update the item in the correct category
-        if category in metadata:
-            for item in metadata[category]:
-                if item["field"] == field_key:
-                    item["reviewer_suggestion"] = reviewer_suggestion or ""
-                    item["suggestion_comment"] = reviewer_suggestion_comment or ""
-                    item["additional_comment"] = additional_comment or ""
-                    item["newValue"] = newValue or ""
+            reviewer_suggestion = field_review.get("reviewerSuggestion") or ""
+            reviewer_suggestion_comment = field_review.get("comment") or ""
+            newValue = field_review.get("newValue") or ""
+            additional_comment = field_review.get("additionalComment") or ""
+
+        # Update the matching item in metadata for this category
+        if category in metadata and field_key:
+            for item in iter_field_items(metadata.get(category)):
+                if item.get("field") == field_key:
+                    item["reviewer_suggestion"] = reviewer_suggestion
+                    item["suggestion_comment"] = reviewer_suggestion_comment
+                    item["additional_comment"] = additional_comment
+                    item["newValue"] = newValue
                     break
 
-        state_dict[field_key] = state
+        if field_key:
+            state_dict[field_key] = state
 
     return state_dict
 
 
 def delete_peer_review(review_id):
-    """
-    Remove Peer Review by review_id.
-    Args:
-        review_id (int): ID review.
-
-    Returns:
-        JsonResponse: JSON response about successful deletion or error.
-    """
+    """Remove Peer Review by review_id."""
     if review_id:
         peer_review = PeerReview.objects.filter(id=review_id).first()
         if peer_review:

dataedit/static/peer_review/main.js

@@ -3,20 +3,40 @@
 
 import * as common from "./peer_review.js";
 import { selectState } from './peer_review.js';
-window.selectState = selectState;
+import { selectNextField, selectPreviousField } from './navigation.js';
+import { setGetFieldState } from './state_current_review.js';
 
-import { selectNextField } from './navigation.js'
-window.selectNextField = selectNextField;
+// Static imports avoid the "Failed to fetch" dynamic import errors
+import { initReviewer } from './opr_reviewer.js';
+import { initContributor } from './opr_contributor.js';
 
-import { selectPreviousField } from './navigation.js'
+// Expose functions to global window scope for HTML onclick events
+window.selectState = selectState;
+window.selectNextField = selectNextField;
 window.selectPreviousField = selectPreviousField;
 
-import { setGetFieldState } from './state_current_review.js';
-import './opr_reviewer.js';
+// Initialize the state getter
 setGetFieldState((fieldKey) => {
   return window.state_dict?.[fieldKey] ?? null;
 });
+
 document.addEventListener('DOMContentLoaded', function () {
-  common.initCurrentReview(config);
-  common.peerReview(config, true);
+  // Initialize common logic
+  // 'config' is defined in the HTML template
+  if (typeof config !== 'undefined') {
+    common.initCurrentReview(config);
+    common.peerReview(config, true);
+  }
+
+  // Initialize role-specific logic based on the HTML marker
+  const marker = document.getElementById('opr-page-marker');
+  const oprPage = marker?.dataset?.oprPage;
+
+  if (oprPage === 'reviewer') {
+    initReviewer();
+  } else if (oprPage === 'contributor') {
+    initContributor();
+  } else {
+    console.warn('OPR page marker not found or invalid; skipping role-specific initialization');
+  }
 });

dataedit/static/peer_review/navigation.js

@@ -1,16 +1,47 @@
 // SPDX-FileCopyrightText: 2025 Reiner Lemoine Institut
 // SPDX-License-Identifier: AGPL-3.0-or-later
-import {getCategoryToTabIdMapping, makeFieldList, selectField} from "./peer_review.js";
+
+import { getCategoryToTabIdMapping, makeFieldList, selectField } from "./peer_review.js";
+
+export function updateTabProgress() {
+  const allFields = document.querySelectorAll('.review__item');
+  const total = allFields.length;
+  let completed = 0;
+
+  allFields.forEach(field => {
+    // Check for any of the completed states (ok, rejected, suggestion)
+    if (field.classList.contains('field-ok') || 
+        field.classList.contains('field-rejected') || 
+        field.classList.contains('field-suggestion')) {
+      completed++;
+    }
+  });
+
+  const percentage = total === 0 ? 0 : Math.round((completed / total) * 100);
+
+  // Update the circular progress bar
+  const circle = document.getElementById('okProgressCircle');
+  const text = document.getElementById('okPercentageText');
+
+  if (circle && text) {
+    // 326.72 is 2*PI*r where r=52 (from your SVG)
+    const circumference = 326.72; 
+    const offset = circumference - (percentage / 100) * circumference;
+    circle.style.strokeDashoffset = offset;
+    text.textContent = `${percentage}%`;
+  }
+}
+
+// Alias to fix the ReferenceError in summary.js
+export const updatePercentageDisplay = updateTabProgress;
 
 export function switchCategoryTab(category) {
-  const currentTab = document.querySelector('.tab-pane.active'); // Get the currently active tab
+  const currentTab = document.querySelector('.tab-pane.active');
   const tabIdForCategory = getCategoryToTabIdMapping()[category];
-  console.log("tabID", tabIdForCategory);
-  if (currentTab.getAttribute('id') !== tabIdForCategory) {
-    // The clicked field does not belong to the current tab, switch to the next tab
+
+  if (currentTab && currentTab.getAttribute('id') !== tabIdForCategory) {
     const targetTab = document.getElementById(tabIdForCategory);
     if (targetTab) {
-      // The target tab exists, click the tab link to switch to it
       targetTab.click();
     }
   }
@@ -22,9 +53,6 @@ export function selectNextField() {
   selectField(fieldList, next);
 }
 
-/**
- * Selects the HTML field element previous to the current one and clicks it
- */
 export function selectPreviousField() {
   var fieldList = makeFieldList();
   var prev = fieldList.indexOf('field_' + window.selectedField) - 1;