✨ Partial and negative marking support for quizzes

assets/core/ts/components/form.ts

@@ -227,12 +227,12 @@ async function validateFieldValue(name: string, value: unknown, rules?: Validati
   }
 
   // Numeric validations
-  if (rules.min && !isNaN(numericValue)) {
+  if (typeof rules.min !== 'undefined' && !isNaN(numericValue)) {
     const error = ValidationHelpers.validateMin(numericValue, rules.min);
     if (error) return error;
   }
 
-  if (rules.max && !isNaN(numericValue)) {
+  if (typeof rules.max !== 'undefined' && !isNaN(numericValue)) {
     const error = ValidationHelpers.validateMax(numericValue, rules.max);
     if (error) return error;
   }

assets/core/ts/utils/endpoints.ts

@@ -67,6 +67,8 @@ const endpoints = {
   QUIZ_ATTEMPT_SUBMIT: 'tutor_answering_quiz_question',
   REVIEW_QUIZ_ANSWERS: 'tutor_review_quiz_answers',
   INSTRUCTOR_FEEDBACK: 'tutor_instructor_feedback',
+  SAVE_QUESTION_FEEDBACK: 'tutor_save_question_feedback',
+  DELETE_QUESTION_FEEDBACK: 'tutor_delete_question_feedback',
 
   // ZOOM
   GET_ZOOM_MEETING_DETAILS: 'tutor_zoom_meeting_details',

assets/src/js/admin-dashboard/segments/options.js

@@ -713,4 +713,156 @@ document.addEventListener('DOMContentLoaded', function () {
 			bankTransferInstruction.previousElementSibling?.classList.toggle('tutor-option-no-bottom-border', !e.target.checked);
 		});
 	}
+
+	/**
+	 * Toggle turn-off confirmation modals.
+	 *
+	 * Intercepts the change event on tutor-form-toggle-input elements that are
+	 * configured in the localized `tutorTurnoffConfirm` map (keyed by field key).
+	 * When such a toggle is turned OFF, the handler reverts the toggle, shows a
+	 * confirm modal, and only proceeds with the turn-off if the user confirms.
+	 *
+	 * The config can include a usage-check AJAX action to decide whether the
+	 * modal needs to be shown at all.
+	 *
+	 * The map is localized by Tutor Pro; Free only provides this generic,
+	 * configuration-driven mechanism.
+	 *
+	 * @since 4.1.0
+	 */
+	const turnOffConfirmations = window.tutorTurnoffConfirm || {};
+	Object.entries(turnOffConfirmations).forEach(([fieldKey, config]) => {
+		document.querySelectorAll(`#field_${fieldKey} .tutor-form-toggle-input`).forEach((checkbox) => {
+			checkbox.addEventListener('change', function (e) {
+				if (this.checked) {
+					return;
+				}
+
+				const message = config.message;
+				const title = config.title;
+				const cancelText = config.cancel;
+				const confirmText = config.confirm;
+				const usageAjaxAction = config.usage_check_action;
+				if (!message) {
+					return;
+				}
+
+				const hiddenInput = this.previousElementSibling;
+				const syncToggleVisibility = () => {
+					const $toggle = $(this);
+					if ($toggle.data('toggle-fields')) {
+						showHideToggleChildren($toggle);
+					}
+					if ($toggle.data('toggle-blocks')) {
+						showHideToggleBlock($toggle);
+					}
+				};
+
+				const revertToggle = () => {
+					this.checked = true;
+					if (hiddenInput) {
+						hiddenInput.value = 'on';
+					}
+					syncToggleVisibility();
+				};
+
+				const proceedWithTurnoff = () => {
+					this.checked = false;
+					if (hiddenInput) {
+						hiddenInput.value = 'off';
+					}
+					syncToggleVisibility();
+				};
+
+				if (!usageAjaxAction) {
+					revertToggle();
+					tutorConfirmTurnoffModal(message, title, cancelText, confirmText).then((confirmed) => {
+						if (confirmed) {
+							proceedWithTurnoff();
+						}
+					});
+					return;
+				}
+
+				const formData = new FormData();
+				formData.append('action', usageAjaxAction);
+				formData.append(_tutorobject.nonce_key, _tutorobject._tutor_nonce);
+
+				fetch(_tutorobject.ajaxurl, { method: 'POST', body: formData })
+					.then((response) => response.json())
+					.then((result) => {
+						const hasCustomized = result?.data?.has_customized;
+						if (hasCustomized) {
+							revertToggle();
+							tutorConfirmTurnoffModal(message, title, cancelText, confirmText).then((confirmed) => {
+								if (confirmed) {
+									proceedWithTurnoff();
+								}
+							});
+						} else {
+							proceedWithTurnoff();
+						}
+					})
+					.catch(() => {
+						revertToggle();
+					});
+			});
+		});
+	});
 });
+
+/**
+ * Show a confirmation modal for toggle turn-off.
+ *
+ * @since 4.1.0
+ *
+ * @param {string} message The confirmation message.
+ * @param {string} [title] Optional modal title.
+ * @param {string} [cancelText] Optional cancel button label.
+ * @param {string} [confirmText] Optional confirm button label.
+ * @return {Promise<boolean>} Resolves true if confirmed, false if cancelled.
+ */
+function tutorConfirmTurnoffModal(message, title, cancelText, confirmText) {
+	const { __ } = wp.i18n;
+
+	return new Promise((resolve) => {
+		let popup;
+		let resolved = false;
+
+		const finish = (confirmed) => {
+			if (resolved) {
+				return;
+			}
+			resolved = true;
+			resolve(confirmed);
+			popup.find('[data-tutor-modal-close]').click();
+		};
+
+		popup = new window.tutor_popup(window.jQuery, '').popup({
+			title: title || __('Turn off setting?', 'tutor'),
+			description: message,
+			buttons: {
+				cancel: {
+					title: cancelText || __('No, keep it', 'tutor'),
+					id: 'cancel',
+					class: 'tutor-btn tutor-btn-outline-primary',
+					callback: function () {
+						finish(false);
+					},
+				},
+				confirm: {
+					title: confirmText || __('Yes, turn off', 'tutor'),
+					id: 'confirm',
+					class: 'tutor-btn tutor-btn-primary tutor-ml-20',
+					callback: function () {
+						finish(true);
+					},
+				},
+			},
+		});
+
+		popup.on('click', '[data-tutor-modal-close], .tutor-modal-overlay', function () {
+			finish(false);
+		});
+	});
+}

assets/src/js/frontend/dashboard/pages/quiz-attempt-feedback.ts

@@ -5,11 +5,19 @@ import { type MutationState } from '@Core/ts/services/Query';
 
 const REVIEW_STATUSES = ['correct', 'incorrect'] as const;
 const REVIEW_STATUS_FIELD = 'review_statuses' as const;
+const MANUAL_MARK_FIELD = 'manual_marks' as const;
+const QUESTION_FEEDBACK_FIELD = 'question_feedback' as const;
 
 type ReviewStatus = (typeof REVIEW_STATUSES)[number];
 type ReviewStatusFieldName = `${typeof REVIEW_STATUS_FIELD}[${string}]`;
 type ReviewStatusMap = Record<string, ReviewStatus>;
 type ReviewStatusesAjaxPayload = Partial<Record<ReviewStatusFieldName, ReviewStatus>>;
+type ManualMarkFieldName = `${typeof MANUAL_MARK_FIELD}[${string}]`;
+type ManualMarksMap = Record<string, number>;
+type ManualMarksAjaxPayload = Partial<Record<ManualMarkFieldName, number>>;
+type QuestionFeedbackFieldName = `${typeof QUESTION_FEEDBACK_FIELD}[${string}]`;
+type QuestionFeedbackMap = Record<string, string>;
+type QuestionFeedbackAjaxPayload = Partial<Record<QuestionFeedbackFieldName, string>>;
 
 interface QuizAttemptFeedbackProps {
   attemptId: number;
@@ -20,6 +28,8 @@ interface QuizAttemptFeedbackPayload {
   attempt_id: number;
   feedback: string;
   review_statuses: ReviewStatusMap;
+  manual_marks: ManualMarksMap;
+  question_feedback: QuestionFeedbackMap;
 }
 
 interface QuizAttemptFeedbackResponse<TData = unknown> {
@@ -39,6 +49,8 @@ const quizAttemptFeedback = ({ attemptId, formId }: QuizAttemptFeedbackProps) =>
   const { convertToErrorMessage } = window.TutorCore.error;
 
   const reviewStatusFieldPattern = new RegExp(`^${REVIEW_STATUS_FIELD}\\[[^\\]]+\\]$`);
+  const manualMarkFieldPattern = new RegExp(`^${MANUAL_MARK_FIELD}\\[[^\\]]+\\]$`);
+  const questionFeedbackFieldPattern = new RegExp(`^${QUESTION_FEEDBACK_FIELD}\\[[^\\]]+\\]$`);
   let isProgrammaticReload = false;
 
   const getReviewStatuses = (data: Record<string, unknown>) => {
@@ -68,6 +80,42 @@ const quizAttemptFeedback = ({ attemptId, formId }: QuizAttemptFeedbackProps) =>
     }, {});
   };
 
+  const getManualMarks = (data: Record<string, unknown>) => {
+    return Object.entries(data).reduce<ManualMarksMap>((acc, [key, value]) => {
+      if (!manualMarkFieldPattern.test(key)) return acc;
+      if (value === '' || value === null || value === undefined) return acc;
+      if (typeof value === 'string' && value.trim() === '') return acc;
+      const num = Number(value);
+      if (Number.isNaN(num)) return acc;
+      const questionId = key.slice(`${MANUAL_MARK_FIELD}[`.length, -1);
+      acc[questionId] = num;
+      return acc;
+    }, {});
+  };
+
+  const getManualMarksPayload = (manualMarks: ManualMarksMap) => {
+    return Object.entries(manualMarks).reduce<ManualMarksAjaxPayload>((acc, [questionId, mark]) => {
+      acc[`${MANUAL_MARK_FIELD}[${questionId}]` as ManualMarkFieldName] = mark;
+      return acc;
+    }, {});
+  };
+
+  const getQuestionFeedback = (data: Record<string, unknown>) => {
+    return Object.entries(data).reduce<QuestionFeedbackMap>((acc, [key, value]) => {
+      if (!questionFeedbackFieldPattern.test(key)) return acc;
+      const questionId = key.slice(`${QUESTION_FEEDBACK_FIELD}[`.length, -1);
+      acc[questionId] = typeof value === 'string' ? value : String(value ?? '');
+      return acc;
+    }, {});
+  };
+
+  const getQuestionFeedbackPayload = (questionFeedback: QuestionFeedbackMap) => {
+    return Object.entries(questionFeedback).reduce<QuestionFeedbackAjaxPayload>((acc, [questionId, feedback]) => {
+      acc[`${QUESTION_FEEDBACK_FIELD}[${questionId}]` as QuestionFeedbackFieldName] = feedback;
+      return acc;
+    }, {});
+  };
+
   return {
     formId,
     attemptId,
@@ -118,6 +166,8 @@ const quizAttemptFeedback = ({ attemptId, formId }: QuizAttemptFeedbackProps) =>
     async saveFeedback(payload: QuizAttemptFeedbackPayload) {
       let feedbackDirty = true;
       let reviewStatusesDirty = true;
+      let manualMarksDirty = true;
+      let questionFeedbackDirty = true;
 
       if (form.hasForm(formId)) {
         const formState = form.getFormState(formId);
@@ -126,14 +176,30 @@ const quizAttemptFeedback = ({ attemptId, formId }: QuizAttemptFeedbackProps) =>
         reviewStatusesDirty = Object.keys(dirtyFields ?? {}).some(
           (key) => key.startsWith(`${REVIEW_STATUS_FIELD}[`) && dirtyFields[key],
         );
+        manualMarksDirty = Object.keys(dirtyFields ?? {}).some(
+          (key) => key.startsWith(`${MANUAL_MARK_FIELD}[`) && dirtyFields[key],
+        );
+        questionFeedbackDirty = Object.keys(dirtyFields ?? {}).some(
+          (key) => key.startsWith(`${QUESTION_FEEDBACK_FIELD}[`) && dirtyFields[key],
+        );
       }
 
       const reviewStatusesPayload = getReviewStatusesPayload(payload.review_statuses);
+      const manualMarksPayload = getManualMarksPayload(payload.manual_marks);
+      const questionFeedbackPayload = getQuestionFeedbackPayload(payload.question_feedback);
+
+      const hasReviewPayload =
+        Object.keys(reviewStatusesPayload).length > 0 ||
+        Object.keys(manualMarksPayload).length > 0 ||
+        Object.keys(questionFeedbackPayload).length > 0;
+
       const reviewRequest =
-        reviewStatusesDirty && Object.keys(reviewStatusesPayload).length > 0
+        (reviewStatusesDirty || manualMarksDirty || questionFeedbackDirty) && hasReviewPayload
           ? wpPost<QuizAttemptFeedbackResponse>(endpoints.REVIEW_QUIZ_ANSWERS, {
               attempt_id: payload.attempt_id,
               ...reviewStatusesPayload,
+              ...manualMarksPayload,
+              ...questionFeedbackPayload,
             })
           : Promise.resolve(null);
 
@@ -153,10 +219,23 @@ const quizAttemptFeedback = ({ attemptId, formId }: QuizAttemptFeedbackProps) =>
     },
 
     async handleSaveFeedback(data: Record<string, unknown>) {
+      const mergedData = { ...data };
+      const formEl = document.getElementById(this.formId) as HTMLFormElement | null;
+      if (formEl) {
+        const fd = new FormData(formEl);
+        fd.forEach((value, key) => {
+          if (!(key in mergedData) || !mergedData[key]) {
+            mergedData[key] = value;
+          }
+        });
+      }
+
       await this.feedbackMutation?.mutate({
         attempt_id: this.attemptId,
         feedback: String(data.feedback ?? ''),
-        review_statuses: getReviewStatuses(data),
+        review_statuses: getReviewStatuses(mergedData),
+        manual_marks: getManualMarks(mergedData),
+        question_feedback: getQuestionFeedback(mergedData),
       });
     },
   };
@@ -166,3 +245,60 @@ export const quizAttemptFeedbackMeta = {
   name: 'quizAttemptFeedback',
   component: quizAttemptFeedback,
 };
+
+interface QuestionFeedbackProps {
+  initialFeedback?: string;
+  fieldName?: string;
+  formId?: string;
+}
+
+const questionFeedback = ({
+  initialFeedback = '',
+  fieldName = '',
+  formId = 'quiz-attempt-review-form',
+}: QuestionFeedbackProps = {}) => {
+  const { form } = window.TutorCore;
+
+  return {
+    expanded: false,
+    feedback: String(initialFeedback || ''),
+    fieldName: String(fieldName || ''),
+    formId: String(formId || 'quiz-attempt-review-form'),
+
+    toggle() {
+      if (!this.expanded && form.hasForm(this.formId)) {
+        form.setValue(this.formId, this.fieldName, this.feedback);
+      }
+      this.expanded = !this.expanded;
+    },
+
+    save() {
+      if (form.hasForm(this.formId)) {
+        const val = form.getValue(this.formId, this.fieldName);
+        this.feedback = typeof val === 'string' ? val : String(val ?? '');
+        form.setValue(this.formId, this.fieldName, this.feedback, { shouldDirty: true });
+      }
+      this.expanded = false;
+    },
+
+    cancel() {
+      if (form.hasForm(this.formId)) {
+        form.setValue(this.formId, this.fieldName, this.feedback);
+      }
+      this.expanded = false;
+    },
+
+    del() {
+      this.feedback = '';
+      if (form.hasForm(this.formId)) {
+        form.setValue(this.formId, this.fieldName, '', { shouldDirty: true });
+      }
+      this.expanded = false;
+    },
+  };
+};
+
+export const questionFeedbackMeta = {
+  name: 'questionFeedback',
+  component: questionFeedback,
+};