Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

6.3 KB
Raw Blame
import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
import { GuestMetadataAPI } from '@/api/guestMetadata';
import { AgentMetadataAPI } from '@/api/agentMetadata';
import { DockerMetadataAPI } from '@/api/dockerMetadata';
import { DockerHostMetadataAPI } from '@/api/dockerHostMetadata';
import { copyToClipboard } from '@/utils/clipboard';
import { dispatchResourceMetadataChanged } from '@/utils/resourceMetadataEvents';
import {
  getWebInterfaceTargetLabel,
  normalizeWebInterfaceUrl,
  validateWebInterfaceCustomUrl,
  type WebInterfaceUrlFieldProps,
} from './webInterfaceUrlFieldModel';

export function useWebInterfaceUrlFieldState(props: WebInterfaceUrlFieldProps) {
  const [urlValue, setUrlValue] = createSignal(props.customUrl ?? '');
  const [fetchedCustomUrl, setFetchedCustomUrl] = createSignal(props.customUrl ?? '');
  const [urlSaving, setUrlSaving] = createSignal(false);
  const [urlError, setUrlError] = createSignal<string | null>(null);
  const [urlSuccess, setUrlSuccess] = createSignal<string | null>(null);
  const [copiedUrlValue, setCopiedUrlValue] = createSignal('');
  let urlSuccessTimer: ReturnType<typeof setTimeout> | undefined;
  let copyFeedbackTimer: ReturnType<typeof setTimeout> | undefined;

  const metadataId = createMemo(() => normalizeWebInterfaceUrl(props.metadataId));
  const targetLabel = createMemo(() =>
    getWebInterfaceTargetLabel(props.metadataKind, props.targetLabel),
  );
  const currentCustomUrl = createMemo(() => fetchedCustomUrl());
  const normalizedCurrentUrl = createMemo(() => normalizeWebInterfaceUrl(currentCustomUrl()));

  const clearUrlSuccessTimer = () => {
    if (!urlSuccessTimer) return;
    clearTimeout(urlSuccessTimer);
    urlSuccessTimer = undefined;
  };

  const clearCopyFeedbackTimer = () => {
    if (!copyFeedbackTimer) return;
    clearTimeout(copyFeedbackTimer);
    copyFeedbackTimer = undefined;
  };

  onCleanup(() => {
    clearUrlSuccessTimer();
    clearCopyFeedbackTimer();
  });

  const setUrlSuccessMessage = (message: string) => {
    clearUrlSuccessTimer();
    setUrlSuccess(message);
    urlSuccessTimer = setTimeout(() => {
      setUrlSuccess(null);
      urlSuccessTimer = undefined;
    }, 2500);
  };

  const readMetadataUrl = async (id: string): Promise<string> => {
    if (props.metadataKind === 'agent') {
      const metadata = await AgentMetadataAPI.getMetadata(id);
      return metadata?.customUrl ?? '';
    }
    if (props.metadataKind === 'docker') {
      const metadata = await DockerMetadataAPI.getMetadata(id);
      return metadata?.customUrl ?? '';
    }
    if (props.metadataKind === 'docker-host') {
      const metadata = await DockerHostMetadataAPI.getMetadata(id);
      return metadata?.customUrl ?? '';
    }
    const metadata = await GuestMetadataAPI.getMetadata(id);
    return metadata?.customUrl ?? '';
  };

  const updateMetadataUrl = async (id: string, value: string) => {
    if (props.metadataKind === 'agent') {
      await AgentMetadataAPI.updateMetadata(id, { customUrl: value });
      return;
    }
    if (props.metadataKind === 'docker') {
      await DockerMetadataAPI.updateMetadata(id, { customUrl: value });
      return;
    }
    if (props.metadataKind === 'docker-host') {
      await DockerHostMetadataAPI.updateMetadata(id, { customUrl: value });
      return;
    }
    await GuestMetadataAPI.updateMetadata(id, { customUrl: value });
  };

  createEffect(() => {
    const id = metadataId();
    if (!id || props.customUrl !== undefined) return;

    let cancelled = false;
    const loadMetadata = async () => {
      try {
        const customUrl = await readMetadataUrl(id);
        if (!cancelled) {
          setFetchedCustomUrl(customUrl);
        }
      } catch {
        // Metadata fetch is best-effort; keep the field editable even if load fails.
      }
    };

    void loadMetadata();

    onCleanup(() => {
      cancelled = true;
    });
  });

  createEffect(() => {
    if (props.customUrl !== undefined) {
      setFetchedCustomUrl(props.customUrl);
    }
  });

  createEffect(() => {
    setUrlValue(currentCustomUrl());
  });

  const handleSaveUrl = async () => {
    const id = metadataId();
    if (!id) return;

    const trimmed = normalizeWebInterfaceUrl(urlValue());
    setUrlError(null);
    setUrlSuccess(null);

    const validationError = validateWebInterfaceCustomUrl(trimmed);
    if (validationError) {
      setUrlError(validationError);
      return;
    }

    setUrlSaving(true);
    try {
      await updateMetadataUrl(id, trimmed);
      setFetchedCustomUrl(trimmed);
      props.onCustomUrlChange?.(trimmed);
      dispatchResourceMetadataChanged({
        metadataKind: props.metadataKind,
        metadataId: id,
        customUrl: trimmed,
      });
      setUrlSuccessMessage(trimmed ? 'URL saved.' : 'URL cleared.');
    } catch (error) {
      setUrlError(error instanceof Error ? error.message : 'Failed to save URL.');
      console.error('Failed to save custom URL:', error);
    } finally {
      setUrlSaving(false);
    }
  };

  const handleDeleteUrl = async () => {
    const id = metadataId();
    if (!id) return;

    setUrlError(null);
    setUrlSuccess(null);
    setUrlSaving(true);
    try {
      await updateMetadataUrl(id, '');
      setFetchedCustomUrl('');
      setUrlValue('');
      props.onCustomUrlChange?.('');
      dispatchResourceMetadataChanged({
        metadataKind: props.metadataKind,
        metadataId: id,
        customUrl: '',
      });
      setUrlSuccessMessage('URL removed.');
    } catch (error) {
      setUrlError(error instanceof Error ? error.message : 'Failed to remove URL.');
      console.error('Failed to remove custom URL:', error);
    } finally {
      setUrlSaving(false);
    }
  };

  const handleCopyUrl = async (value?: string | null) => {
    const trimmed = normalizeWebInterfaceUrl(value);
    if (!trimmed) return;
    const copied = await copyToClipboard(trimmed);
    if (!copied) return;

    clearCopyFeedbackTimer();
    setCopiedUrlValue(trimmed);
    copyFeedbackTimer = setTimeout(() => {
      setCopiedUrlValue('');
      copyFeedbackTimer = undefined;
    }, 2000);
  };

  return {
    copiedUrlValue,
    currentCustomUrl,
    handleCopyUrl,
    handleDeleteUrl,
    handleSaveUrl,
    metadataId,
    normalizedCurrentUrl,
    setUrlValue,
    targetLabel,
    urlError,
    urlSaving,
    urlSuccess,
    urlValue,
  };
}