src/Utils/request/handleResponse.ts (1)

Line range hint 23-26: Replace deprecated BadRequest with notifyError

The code is still using the deprecated BadRequest function. This should be updated to use notifyError for consistency.

-    notify?.BadRequest({ errs: error });
+    notify?.notifyError(error);

src/Utils/request/uploadFile.ts (1)

Line range hint 27-33: Replace deprecated BadRequest with toast.error

For consistency with the network error handling, replace BadRequest with direct usage of toast.error.

-        Notification.BadRequest({ errs: error.errors });
+        toast.error(error.errors);

src/components/Users/UserSoftwareUpdate.tsx (1)

Line range hint 19-32: Add error handling for update check

The checkUpdates function should handle potential errors from checkForUpdate.

   const checkUpdates = async () => {
     setUpdateStatus({ ...updateStatus, isChecking: true });
     await new Promise((resolve) => setTimeout(resolve, 500));
-    if ((await checkForUpdate()) != null) {
-      setUpdateStatus({
-        isUpdateAvailable: true,
-        isChecking: false,
-      });
-    } else {
-      setUpdateStatus({
-        isUpdateAvailable: false,
-        isChecking: false,
-      });
-      toast.success("No update available");
+    try {
+      const update = await checkForUpdate();
+      setUpdateStatus({
+        isUpdateAvailable: update != null,
+        isChecking: false,
+      });
+      if (!update) {
+        toast.success("You're running the latest version");
+      }
+    } catch (error) {
+      setUpdateStatus({
+        isUpdateAvailable: false,
+        isChecking: false,
+      });
+      toast.error("Failed to check for updates. Please try again later.");
     }
   };

src/Utils/Notifications.ts (2)

22-22: Consider using a more specific type for error parameter

The any type for the error parameter reduces type safety. Consider defining a specific error interface.

-export const notifyError = (error: any) => {
+interface ErrorResponse {
+  detail?: string;
+  [key: string]: unknown;
+}
+export const notifyError = (error: ErrorResponse | string | null) => {

---

Line range hint 22-41: Improve error message formatting for toast notifications

The current implementation concatenates multiple error messages with newlines (\n). Toast notifications typically render better with HTML formatting.

   } else {
+    const errors: string[] = [];
     for (const [key, value] of Object.entries(error)) {
       const keyName = formatKey(key);
       if (Array.isArray(value)) {
         const uniques = [...new Set(value)];
-        errorMsg += `${keyName} - ${uniques.splice(0, 5).join(", ")}`;
+        errors.push(`${keyName} - ${uniques.splice(0, 5).join(", ")}`);
       } else if (typeof value === "string") {
-        errorMsg += `${keyName} - ${value}`;
+        errors.push(`${keyName} - ${value}`);
       } else {
-        errorMsg += `${keyName} - Bad Request`;
+        errors.push(`${keyName} - Bad Request`);
       }
-      errorMsg += "\n";
     }
+    errorMsg = errors.join("<br>");
   }

src/Utils/request/handleResponse.ts (1)

18-18: Standardize error message format

The error messages have inconsistent formats:

• 404 case: { msg: "Not Found" }
• Other errors: { msg: error?.detail || "Something went wrong...!" }

Consider standardizing to:

-    notify?.notifyError({ msg: "Not Found" });
+    notify?.notifyError("Not Found");

-    notify?.notifyError({ msg: error?.detail || "Something went wrong...!" });
+    notify?.notifyError(error?.detail || "Something went wrong...!");

Also applies to: 42-42

src/Utils/request/uploadFile.ts (1)

48-50: Consider using a more descriptive error message

The current network error message could be more helpful to users.

-      toast.error("Network Failure. Please check your internet connectivity.");
+      toast.error("Unable to upload file. Please check your internet connection and try again.");

src/components/Users/UserSoftwareUpdate.tsx (1)

31-31: Enhance success message with version information

The current success message could be more informative by including the current version.

-      toast.success("No update available");
+      toast.success("You're running the latest version");

src/Utils/request/errorHandler.ts (1)

43-45: Consider migrating to toast.error for consistency.

While the current implementation works, consider migrating this to toast.error for consistency with other error notifications in the file.

-  Notifications.notifyError({
-    msg: cause?.detail || "Something went wrong...!",
-  });
+  toast.error(cause?.detail || "Something went wrong...!");

src/components/Resource/ResourceCommentSection.tsx (1)

34-34: Consider adding more context to the success message.

The success message could be more descriptive to provide better feedback.

-      toast.success("Comment added successfully");
+      toast.success("Your comment has been posted successfully");

src/components/Users/UserAvatar.tsx (1)

77-77: Use i18n translation for consistency.

The success message is hardcoded. Consider using the translation system for consistency with other messages in the application.

-      toast.success("Profile picture deleted");
+      toast.success(t("profile_picture_deleted"));

src/Utils/useSegmentedRecorder.ts (1)

Line range hint 102-107: Consider using toast for error handling in startRecording.

The function throws an error but doesn't notify the user. Consider using toast.error for consistency with other error handling in the hook.

   } catch (error) {
     setMicrophoneAccess(false);
+    toast.error(t("audio__permission_message"));
     throw new Error("Microphone access denied");
   }

src/components/Users/UserHome.tsx (1)

55-57: Improve error message handling.

The current implementation might display "Error while fetching user details: undefined". Consider using nullish coalescing for a better fallback message.

-          toast.error(
-            "Error while fetching user details: " + (error?.message || ""),
-          );
+          toast.error(
+            `Error while fetching user details: ${error?.message ?? "Unknown error"}`,
+          );

src/pages/Facility/FacilityDetailsPage.tsx (1)

4-4: Enhance error message with more context

The generic error message "Error while fetching users data" could be more helpful by including specific details about what went wrong. Consider including the facility name or ID in the message.

-toast.error("Error while fetching users data");
+toast.error(`Error while fetching users data for facility ${id}`);

Also applies to: 56-56

src/components/Auth/ResetPassword.tsx (1)

4-4: LGTM! Consider clearing form data after success

The implementation correctly handles the success notification and token cleanup. For additional security, consider clearing the form data before navigation.

 if (res?.ok) {
   localStorage.removeItem(LocalStorageKeys.accessToken);
+  setForm(initForm); // Clear sensitive data
   toast.success(t("password_reset_success"));
   navigate("/login");
 }

Also applies to: 85-85

src/components/Users/UserSummary.tsx (1)

57-62: Consider structured error handling for better user experience

The error message concatenation could be improved to handle structured error objects more gracefully.

-      toast.error(t("user_delete_error") + ": " + (error || ""));
+      toast.error(
+        typeof error === "object"
+          ? `${t("user_delete_error")}: ${error.message || JSON.stringify(error)}`
+          : `${t("user_delete_error")}: ${error || ""}`
+      );

src/components/Files/CameraCaptureDialog.tsx (1)

1-1: Consider standardizing error handling patterns across components

While the migration to toast notifications is generally well-implemented, there's an opportunity to standardize error handling patterns across components. Consider creating a shared utility function that handles common error scenarios (e.g., permission denials, API errors) consistently.

Example utility:

// src/Utils/toast.ts
export const notifyError = (error: unknown, defaultMessage: string) => {
  if (typeof error === 'object' && error !== null) {
    toast.error((error as Error).message || defaultMessage);
  } else {
    toast.error(String(error) || defaultMessage);
  }
};

src/pages/Appoinments/PatientSelect.tsx (1)

83-83: Consider using optional chaining for error handling.

The success notification is well implemented. For the error case, consider using optional chaining for safer error message access.

-toast.error(error?.message || t("failed_to_create_appointment"));
+toast.error(error?.message ?? t("failed_to_create_appointment"));

Also applies to: 95-95

src/components/Resource/ResourceDetailsUpdate.tsx (1)

181-181: Consider using translation key for success message.

The success notification is implemented correctly, but the message is hardcoded. Consider using a translation key for consistency with the rest of the application.

-toast.success("Request updated successfully");
+toast.success(t("request_updated_successfully"));

src/hooks/useFileUpload.tsx (1)

190-197: File upload notifications look good, but callback can be improved.

The success and error notifications are well implemented with appropriate error messages and translations. However, the onUpload callback can be improved using optional chaining.

-onUpload && onUpload(data);
+onUpload?.(data);

Also applies to: 204-204

🧰 Tools

🪛 Biome (1.9.4)

[error] 192-192: Change to an optional chain.

Unsafe fix: Change to an optional chain.

(lint/complexity/useOptionalChain)

src/components/Facility/FacilityHome.tsx (1)

148-148: Use translation keys for toast messages.

For consistency, use translation keys for the cover image operation messages instead of hard-coded strings.

-toast.success("Cover image updated.");
+toast.success(t("cover_image_updated"));

-toast.success("Cover image deleted");
+toast.success(t("cover_image_deleted"));

Also applies to: 166-166

src/components/Common/AvatarEditModal.tsx (1)

110-110: Use translation key for the warning message.

For consistency, use a translation key for the file type warning message instead of a hard-coded string.

-toast.warning("Please upload an image file!");
+toast.warning(t("please_upload_image_file"));

src/components/Facility/CreateFacilityForm.tsx (1)

146-146: Improve geolocation error message handling.

Consider using translation keys for geolocation error messages and avoid string concatenation.

-toast.error("Unable to get location: " + error.message);
+toast.error(t("unable_to_get_location", { error: error.message }));

-toast.error("Geolocation is not supported by this browser");
+toast.error(t("geolocation_not_supported"));

Also applies to: 151-151

src/hooks/useFileManager.tsx (1)

Line range hint 491-512: Improve download error handling.

The current error handling for file downloads is too generic. Consider:

1. Adding specific error cases (network error, file not found, etc.)
2. Logging errors for debugging
3. Providing more informative error messages to users

 try {
   if (!file.id) return;
-  toast.success("Downloading file...");
+  toast.success(t("file_download_started"));
   const fileData = await retrieveUpload(file, associating_id);
   const response = await fetch(fileData?.read_signed_url || "");
-  if (!response.ok) throw new Error("Network response was not ok.");
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
   // ... download logic ...
+  toast.success(t("file_download_completed"));
 } catch (err) {
+  console.error("Download failed:", err);
+  if (err instanceof TypeError && err.message === "Failed to fetch") {
+    toast.error(t("network_error"));
+  } else if (err instanceof Error && err.message.includes("HTTP error")) {
+    toast.error(t("file_not_found"));
+  } else {
+    toast.error(t("file_download_failed", { error: err.message }));
+  }
-  toast.error("Failed to download file");
 }

src/pages/Appoinments/PatientRegistration.tsx (2)

Line range hint 153-168: Improve error handling in appointment creation.

The error handling could be enhanced by providing more specific error messages to users.

-      toast.error(error?.message || t("failed_to_create_appointment"));
+      const errorMessage = error?.cause?.detail || error?.message || t("failed_to_create_appointment");
+      toast.error(errorMessage);

---

Line range hint 181-195: Enhance error handling for array of errors.

The current implementation only shows the first error message when multiple errors exist. Consider showing all error messages.

-        toast.error(firstError.msg);
+        const errorMessages = errors.map(error => error.msg).join(", ");
+        toast.error(errorMessages);

src/components/Patient/PatientRegistration.tsx (1)

151-155: Consider adding specific error messages.

The error notification could be more informative by including the specific error details.

-      toast.error(t("patient_update_error"));
+      const errorMessage = error?.cause?.detail || t("patient_update_error");
+      toast.error(errorMessage);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/pages/Appoinments/Schedule.tsx (1)

50-54: 🛠️ Refactor suggestion

Add delay before navigation to ensure toast visibility.

The immediate navigation might prevent users from reading the toast message.

-    toast.error(t("staff_username_not_found"));
-    navigate(`/facility/${facilityId}/`);
+    toast.error(t("staff_username_not_found"));
+    setTimeout(() => navigate(`/facility/${facilityId}/`), 2000);
-    toast.error(t("phone_number_not_found"));
-    navigate(`/facility/${facilityId}/appointments/${staffId}/otp/send`);
+    toast.error(t("phone_number_not_found"));
+    setTimeout(() => navigate(`/facility/${facilityId}/appointments/${staffId}/otp/send`), 2000);

src/components/Users/UserResetPassword.tsx (1)

94-99: 🛠️ Refactor suggestion

Standardize to toast notifications

The component mixes two different notification patterns: toast for success and Notification.notifyError for errors. Let's standardize to use toast for both cases.

       toast.success(data?.message as string);
     } else {
-      Notification.notifyError({
-        msg: error?.message ?? t("password_update_error"),
-      });
-      // toast.error(error?.message ?? t("password_update_error"));
+      toast.error(error?.message ?? t("password_update_error"));
     }

src/hooks/useFileManager.tsx (1)

Line range hint 492-511: Enhance download error handling.

While the success notifications are well implemented, the error handling could be improved:

1. Include specific error details in the error message
2. Handle different types of errors separately
3. Ensure cleanup in error scenarios

 const downloadFile = async (
   file: FileUploadModel,
   associating_id: string,
 ) => {
   try {
     if (!file.id) return;
     toast.success(t("file_download_started"));
     const fileData = await retrieveUpload(file, associating_id);
     const response = await fetch(fileData?.read_signed_url || "");
     if (!response.ok) throw new Error("Network response was not ok.");

     const data = await response.blob();
     const blobUrl = window.URL.createObjectURL(data);

     const a = document.createElement("a");
     a.href = blobUrl;
     a.download = file.name || "file";
     document.body.appendChild(a);
     a.click();

     // Clean up
     window.URL.revokeObjectURL(blobUrl);
     document.body.removeChild(a);
     toast.success(t("file_download_completed"));
   } catch (err) {
-    toast.error(t("file_download_failed"));
+    if (err instanceof Error) {
+      toast.error(t("file_download_failed_with_reason", { error: err.message }));
+    } else {
+      toast.error(t("file_download_failed"));
+    }
+    // Ensure cleanup in error scenarios
+    const link = document.querySelector('a[download]');
+    if (link) document.body.removeChild(link);
   }
 };

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/components/Patient/PatientRegistration.tsx (2)

140-140: Consider enhancing error feedback.

The error notifications could be more informative by including the specific error message from the mutation error object.

-      toast.error(t("patient_registration_error"));
+      toast.error(error?.message || t("patient_registration_error"));

-      toast.error(t("patient_update_error"));
+      toast.error(error?.message || t("patient_update_error"));

Also applies to: 153-153

---

260-262: Consider showing specific validation errors in the toast.

While the form shows detailed validation errors inline, the toast could be more helpful by including the first validation error message.

-      toast.error(t("please_fix_errors"));
+      const firstError = Object.values(validate).find(errors => errors.length > 0)?.[0];
+      toast.error(firstError || t("please_fix_errors"));

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro