Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
7.1 KB
Raw Blame
"use client";

import { useState } from "react";
import { toast } from "sonner";
import { useDismissFlowsUpdateMutation } from "@/app/api/mutations/useDismissFlowsUpdateMutation";
import { useUpdateFlowsMutation } from "@/app/api/mutations/useUpdateFlowsMutation";
import { useGetFlowsUpdatesQuery } from "@/app/api/queries/useGetFlowsUpdatesQuery";
import { AdminUpdateDialog } from "@/components/flows-update-dialog/admin-update-dialog";
import { NonAdminUpdateDialog } from "@/components/flows-update-dialog/non-admin-update-dialog";
import { SkipUpdateConfirmDialog } from "@/components/flows-update-dialog/skip-update-confirm-dialog";
import { UpdateWithoutBackupDialog } from "@/components/flows-update-dialog/update-without-backup-dialog";
import { useOnboardingState } from "@/hooks/use-onboarding-state";
import { useSettingsTabAccess } from "@/hooks/use-permissions";
import { canManageFlowUpdates, canViewFlowUpdates } from "@/lib/brand";
import { formatFlowName } from "@/lib/utils";

const SESSION_DISMISSED_KEY = "openrag_flows_update_dismissed_session";

function hasDismissedFlowsUpdateInSession() {
  if (typeof window === "undefined") return false;
  try {
    return Boolean(sessionStorage.getItem(SESSION_DISMISSED_KEY));
  } catch {
    return false;
  }
}

interface FlowsUpdateDialogProps {
  overrideOpen?: boolean;
  onOpenChange?: (open: boolean) => void;
  isOnboarding?: boolean;
}

export function FlowsUpdateDialog({
  overrideOpen,
  onOpenChange,
  isOnboarding: propIsOnboarding,
}: FlowsUpdateDialogProps = {}) {
  const tabAccess = useSettingsTabAccess();
  const isAdmin = canManageFlowUpdates(tabAccess);
  const canView = canViewFlowUpdates(tabAccess);

  const { isOnboardingComplete } = useOnboardingState();
  const isOnboarding = propIsOnboarding ?? !isOnboardingComplete;

  const { data: updates, isLoading } = useGetFlowsUpdatesQuery({
    enabled: canView,
  });
  const updateMutation = useUpdateFlowsMutation();
  const dismissMutation = useDismissFlowsUpdateMutation();
  const [closedUpdateKey, setClosedUpdateKey] = useState<string | null>(null);
  const [isSessionDismissed, setIsSessionDismissed] = useState(
    hasDismissedFlowsUpdateInSession,
  );
  const [showSkipConfirm, setShowSkipConfirm] = useState(false);
  const [showUpdateConfirm, setShowUpdateConfirm] = useState(false);
  const [isUpdatingWithBackup, setIsUpdatingWithBackup] = useState<
    boolean | null
  >(null);
  const [backupCustom, setBackupCustom] = useState(true);
  const [errorMessage, setErrorMessage] = useState<string | null>(null);

  const allUpdates = updates ?? [];
  const undismissedUpdates = allUpdates.filter((u) => !u.dismissed);
  const targetUpdates =
    undismissedUpdates.length > 0 ? undismissedUpdates : allUpdates;
  const hasUndismissed = undismissedUpdates.length > 0;
  const currentUpdateKey = targetUpdates
    .map((update) => `${update.flow_type}:${update.flow_id}`)
    .sort()
    .join("|");
  const isAutoOpen =
    !isLoading && hasUndismissed && closedUpdateKey !== currentUpdateKey;

  const isMainOpen =
    !showSkipConfirm &&
    !showUpdateConfirm &&
    (overrideOpen ?? (isAutoOpen && !(!isAdmin && isSessionDismissed)));

  const handleClose = () => {
    if (currentUpdateKey) {
      setClosedUpdateKey(currentUpdateKey);
    }
    setShowSkipConfirm(false);
    setShowUpdateConfirm(false);
    setIsUpdatingWithBackup(null);
    onOpenChange?.(false);
  };

  const handleDismiss = async () => {
    handleClose();
    if (targetUpdates.length === 0) return;
    try {
      await dismissMutation.mutateAsync({
        flow_types: targetUpdates.map((u) => u.flow_type),
      });
    } catch (e) {
      console.error("Failed to dismiss flow updates", e);
    }
  };

  const handleNonAdminDismiss = () => {
    handleClose();
    if (typeof window !== "undefined") {
      try {
        sessionStorage.setItem(SESSION_DISMISSED_KEY, "true");
      } catch {
        // ignore
      }
    }
    setIsSessionDismissed(true);
  };

  const handleSkipClick = () => {
    setShowSkipConfirm(true);
  };

  const handleSkipConfirmOpenChange = (open: boolean) => {
    setShowSkipConfirm(open);
  };

  const handleSkipUpdateClick = () => {
    setShowSkipConfirm(false);
    if (!backupCustom) {
      setShowUpdateConfirm(true);
    } else {
      handleConfirmUpdate(true);
    }
  };

  const handleInitialUpdateClick = () => {
    if (!backupCustom) {
      setShowUpdateConfirm(true);
    } else {
      handleConfirmUpdate(true);
    }
  };

  const handleConfirmUpdate = async (withBackup: boolean) => {
    if (targetUpdates.length === 0) return;
    setErrorMessage(null);
    setIsUpdatingWithBackup(withBackup);
    const flowTypes = targetUpdates.map((u) => u.flow_type);

    try {
      const results = await updateMutation.mutateAsync({
        flow_types: flowTypes,
        backup_custom: withBackup,
      });

      const failed = results.filter((r) => !r.success);
      if (failed.length > 0) {
        const errorText = failed
          .map(
            (f) =>
              `${formatFlowName(f.flow_type)}: ${f.error || "Update failed"}`,
          )
          .join("; ");
        setErrorMessage(errorText);
        toast.error(`Flow update failed: ${errorText}`);
        setShowUpdateConfirm(false);
        setClosedUpdateKey(null);
      } else {
        toast.success("Flows updated successfully");
        handleClose();
      }
    } catch (e: unknown) {
      const msg = e instanceof Error ? e.message : "Failed to update flows";
      setErrorMessage(msg);
      toast.error(msg);
      setShowUpdateConfirm(false);
      setClosedUpdateKey(null);
    } finally {
      setIsUpdatingWithBackup(null);
    }
  };

  if (targetUpdates.length === 0) return null;
  if (overrideOpen === undefined && undismissedUpdates.length === 0)
    return null;
  if (!isAdmin && overrideOpen === undefined && isSessionDismissed) return null;

  if (!isAdmin) {
    return (
      <NonAdminUpdateDialog
        open={isMainOpen}
        onClose={handleClose}
        onDismiss={handleNonAdminDismiss}
      />
    );
  }

  const isBusy = updateMutation.isPending || dismissMutation.isPending;

  return (
    <>
      <AdminUpdateDialog
        open={isMainOpen}
        errorMessage={errorMessage}
        backupCustom={backupCustom}
        isOnboarding={isOnboarding}
        isUpdating={updateMutation.isPending}
        isBusy={isBusy}
        onClose={handleClose}
        onBackupCustomChange={setBackupCustom}
        onSkip={handleSkipClick}
        onUpdate={handleInitialUpdateClick}
      />
      <SkipUpdateConfirmDialog
        open={showSkipConfirm}
        isBusy={isBusy}
        isDismissing={dismissMutation.isPending}
        onOpenChange={handleSkipConfirmOpenChange}
        onUpdate={handleSkipUpdateClick}
        onDismiss={handleDismiss}
      />
      <UpdateWithoutBackupDialog
        open={showUpdateConfirm}
        isUpdating={updateMutation.isPending}
        isUpdatingWithBackup={isUpdatingWithBackup}
        onOpenChange={setShowUpdateConfirm}
        onBackupAndUpdate={() => {
          setBackupCustom(true);
          handleConfirmUpdate(true);
        }}
        onContinueWithoutBackup={() => handleConfirmUpdate(false)}
      />
    </>
  );
}