create-crm-tmp 1.1.2 → 2.0.0

package/template/src/hooks/use-confirm.tsx

@@ -0,0 +1,87 @@
+'use client';
+
+import { useState } from 'react';
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog';
+
+interface ConfirmOptions {
+  title: string;
+  description: string;
+  confirmText?: string;
+  cancelText?: string;
+  variant?: 'default' | 'destructive';
+}
+
+export function useConfirm() {
+  const [isOpen, setIsOpen] = useState(false);
+  const [options, setOptions] = useState<ConfirmOptions>({
+    title: '',
+    description: '',
+    confirmText: 'Confirmer',
+    cancelText: 'Annuler',
+    variant: 'default',
+  });
+  const [resolvePromise, setResolvePromise] = useState<((value: boolean) => void) | null>(null);
+
+  const confirm = (opts: ConfirmOptions): Promise<boolean> => {
+    setOptions({
+      confirmText: 'Confirmer',
+      cancelText: 'Annuler',
+      variant: 'default',
+      ...opts,
+    });
+    setIsOpen(true);
+
+    return new Promise<boolean>((resolve) => {
+      setResolvePromise(() => resolve);
+    });
+  };
+
+  const handleConfirm = () => {
+    if (resolvePromise) {
+      resolvePromise(true);
+    }
+    setIsOpen(false);
+  };
+
+  const handleCancel = () => {
+    if (resolvePromise) {
+      resolvePromise(false);
+    }
+    setIsOpen(false);
+  };
+
+  const ConfirmDialog = () => (
+    <AlertDialog open={isOpen} onOpenChange={setIsOpen}>
+      <AlertDialogContent>
+        <AlertDialogHeader>
+          <AlertDialogTitle>{options.title}</AlertDialogTitle>
+          <AlertDialogDescription>{options.description}</AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter>
+          <AlertDialogCancel onClick={handleCancel}>{options.cancelText}</AlertDialogCancel>
+          <AlertDialogAction
+            onClick={handleConfirm}
+            className={
+              options.variant === 'destructive'
+                ? 'bg-red-600 hover:bg-red-700 focus:ring-red-600'
+                : ''
+            }
+          >
+            {options.confirmText}
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+
+  return { confirm, ConfirmDialog };
+}

package/template/src/hooks/use-contact-views.ts

@@ -0,0 +1,140 @@
+import useSWR, { mutate as globalMutate } from 'swr';
+import type {
+  ContactViewData,
+  ViewFilter,
+  ViewColumn,
+  ViewSortConfig,
+} from '@/types/contact-views';
+
+async function fetcher<T>(url: string): Promise<T> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error('Erreur lors du chargement des vues');
+  return res.json();
+}
+
+function getViewsKey(entityType: string) {
+  return `/api/contact-views?entityType=${entityType}`;
+}
+
+export function useContactViews(entityType: 'contacts' | 'companies' = 'contacts') {
+  const viewsKey = getViewsKey(entityType);
+
+  const { data, error, isLoading, mutate } = useSWR<ContactViewData[]>(viewsKey, fetcher, {
+    revalidateOnFocus: false,
+    dedupingInterval: 60_000,
+  });
+
+  const createView = async (view: {
+    name: string;
+    isPublic?: boolean;
+    filters?: ViewFilter[];
+    columns?: ViewColumn[] | null;
+    sortConfig?: ViewSortConfig | null;
+  }): Promise<ContactViewData> => {
+    const res = await fetch('/api/contact-views', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ ...view, entityType }),
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || 'Erreur lors de la création');
+    }
+    const created = await res.json();
+    await mutate();
+    return created;
+  };
+
+  const updateView = async (
+    id: string,
+    updates: {
+      name?: string;
+      isPublic?: boolean;
+      filters?: ViewFilter[];
+      columns?: ViewColumn[] | null;
+      sortConfig?: ViewSortConfig | null;
+      isDefault?: boolean;
+    },
+  ): Promise<ContactViewData> => {
+    const res = await fetch(`/api/contact-views/${id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(updates),
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || 'Erreur lors de la modification');
+    }
+    const updated = await res.json();
+    await mutate();
+    return updated;
+  };
+
+  const deleteView = async (id: string): Promise<void> => {
+    const res = await fetch(`/api/contact-views/${id}`, { method: 'DELETE' });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || 'Erreur lors de la suppression');
+    }
+    await mutate();
+  };
+
+  const cloneView = async (view: ContactViewData, newName?: string): Promise<ContactViewData> => {
+    return createView({
+      name: newName || `${view.name} (copie)`,
+      isPublic: false,
+      filters: view.filters,
+      columns: view.columns,
+      sortConfig: view.sortConfig,
+    });
+  };
+
+  const pinView = async (id: string): Promise<void> => {
+    const res = await fetch(`/api/contact-views/${id}/pin`, { method: 'POST' });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || "Erreur lors de l'épinglage");
+    }
+    await mutate();
+  };
+
+  const unpinView = async (id: string): Promise<void> => {
+    const res = await fetch(`/api/contact-views/${id}/pin`, { method: 'DELETE' });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || 'Erreur lors du désépinglage');
+    }
+    await mutate();
+  };
+
+  const togglePin = async (view: ContactViewData): Promise<void> => {
+    if (view.pinOrder != null) {
+      await unpinView(view.id);
+    } else {
+      await pinView(view.id);
+    }
+  };
+
+  return {
+    views: data || [],
+    error,
+    isLoading,
+    mutate,
+    createView,
+    updateView,
+    deleteView,
+    cloneView,
+    pinView,
+    unpinView,
+    togglePin,
+  };
+}
+
+export function invalidateContactViews(entityType?: string) {
+  if (entityType) {
+    globalMutate(getViewsKey(entityType));
+  } else {
+    globalMutate(getViewsKey('contacts'));
+    globalMutate(getViewsKey('companies'));
+  }
+}

package/template/src/hooks/use-contacts.ts

@@ -0,0 +1,69 @@
+import useSWR from 'swr';
+import type { ViewFilter } from '@/types/contact-views';
+
+interface ContactsParams {
+  search?: string;
+  viewId?: string | null;
+  filters?: ViewFilter[];
+  page?: number;
+  limit?: number;
+  sortField?: string;
+  sortDir?: 'asc' | 'desc';
+}
+
+interface ContactsResponse {
+  contacts: any[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+function buildContactsUrl(params: ContactsParams): string {
+  const sp = new URLSearchParams();
+
+  if (params.search) sp.set('search', params.search);
+  if (params.page) sp.set('page', params.page.toString());
+  if (params.limit) sp.set('limit', params.limit.toString());
+  if (params.sortField) sp.set('sortField', params.sortField);
+  if (params.sortDir) sp.set('sortDir', params.sortDir);
+
+  if (params.viewId) {
+    sp.set('viewId', params.viewId);
+  } else if (params.filters && params.filters.length > 0) {
+    sp.set('filters', JSON.stringify(params.filters));
+  }
+
+  return `/api/contacts?${sp.toString()}`;
+}
+
+async function fetcher<T>(url: string): Promise<T> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error('Erreur lors du chargement des contacts');
+  return res.json();
+}
+
+export function useContacts(params: ContactsParams) {
+  const url = buildContactsUrl(params);
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<ContactsResponse>(url, fetcher, {
+    revalidateOnFocus: false,
+    keepPreviousData: true,
+  });
+
+  return {
+    contacts: data?.contacts || [],
+    pagination: data?.pagination || {
+      page: 1,
+      limit: 25,
+      total: 0,
+      totalPages: 1,
+    },
+    error,
+    isLoading,
+    isValidating,
+    mutate,
+  };
+}

package/template/src/hooks/use-fetch.ts

@@ -0,0 +1,17 @@
+import useSWR, { type SWRConfiguration } from 'swr';
+
+async function fetcher<T>(url: string): Promise<T> {
+  const res = await fetch(url);
+  if (!res.ok) {
+    const error = new Error('Erreur lors du chargement des données');
+    throw error;
+  }
+  return res.json();
+}
+
+export function useFetch<T>(key: string | null, config?: SWRConfiguration<T>) {
+  return useSWR<T>(key, fetcher, {
+    revalidateOnFocus: false,
+    ...config,
+  });
+}

package/template/src/hooks/use-focus-trap.ts

@@ -0,0 +1,73 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+
+const FOCUSABLE_SELECTOR =
+  'button, a[href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+
+function getFocusables(container: HTMLElement): HTMLElement[] {
+  return Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(
+    (el) => !el.hasAttribute('disabled') && el.offsetParent !== null
+  );
+}
+
+export function useFocusTrap(
+  isActive: boolean,
+  containerRef: React.RefObject<HTMLElement | null>,
+  options?: {
+    onClose?: () => void;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    skipInitialFocus?: boolean;
+  }
+) {
+  const prevFocusRef = useRef<HTMLElement | null>(null);
+  const onCloseRef = useRef(options?.onClose);
+  onCloseRef.current = options?.onClose;
+
+  useEffect(() => {
+    if (!isActive || !containerRef.current) return;
+
+    const container = containerRef.current;
+    prevFocusRef.current = document.activeElement as HTMLElement | null;
+
+    const focusables = getFocusables(container);
+    const first = options?.initialFocusRef?.current ?? focusables[0];
+    const last = focusables[focusables.length - 1];
+
+    if (!options?.skipInitialFocus && first) first.focus();
+
+    function handleKeyDown(e: KeyboardEvent) {
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        options?.onClose?.();
+        prevFocusRef.current?.focus();
+        return;
+      }
+      if (e.key !== 'Tab') return;
+
+      const focusablesNow = getFocusables(container);
+      if (focusablesNow.length === 0) return;
+
+      const firstEl = focusablesNow[0];
+      const lastEl = focusablesNow[focusablesNow.length - 1];
+
+      if (e.shiftKey) {
+        if (document.activeElement === firstEl) {
+          e.preventDefault();
+          lastEl.focus();
+        }
+      } else {
+        if (document.activeElement === lastEl) {
+          e.preventDefault();
+          firstEl.focus();
+        }
+      }
+    }
+
+    container.addEventListener('keydown', handleKeyDown);
+    return () => {
+      container.removeEventListener('keydown', handleKeyDown);
+      prevFocusRef.current?.focus();
+    };
+  }, [isActive, options?.onClose]);
+}

package/template/src/hooks/use-statuses.ts

@@ -0,0 +1,22 @@
+import { useFetch } from './use-fetch';
+
+export function useStatuses() {
+  return useFetch<any[]>('/api/statuses', {
+    revalidateOnFocus: false,
+    dedupingInterval: 300_000,
+  });
+}
+
+export function useClosingReasons() {
+  return useFetch<any[]>('/api/closing-reasons', {
+    revalidateOnFocus: false,
+    dedupingInterval: 300_000,
+  });
+}
+
+export function useUsersList() {
+  return useFetch<any[]>('/api/users/list', {
+    revalidateOnFocus: false,
+    dedupingInterval: 300_000,
+  });
+}

package/template/src/lib/address-api.ts

@@ -0,0 +1,155 @@
+/**
+ * Service pour interroger l'API Adresse française
+ * https://api-adresse.data.gouv.fr
+ */
+
+export interface AddressFeature {
+  type: string;
+  geometry: {
+    type: string;
+    coordinates: number[];
+  };
+  properties: {
+    label: string;
+    score: number;
+    housenumber?: string;
+    id: string;
+    banId: string;
+    name: string;
+    postcode: string;
+    citycode: string;
+    x: number;
+    y: number;
+    city: string;
+    context: string;
+    type: string;
+    importance: number;
+    street?: string;
+    _type: string;
+  };
+}
+
+export interface AddressSearchResult {
+  type: string;
+  version: string;
+  features: AddressFeature[];
+  attribution: string;
+  licence: string;
+  query: string;
+  limit: number;
+}
+
+const API_BASE_URL = 'https://api-adresse.data.gouv.fr';
+
+/**
+ * Recherche une adresse
+ * @param query - Texte de recherche
+ * @param limit - Nombre maximum de résultats (défaut: 5)
+ */
+export async function searchAddress(
+  query: string,
+  limit: number = 5,
+): Promise<AddressSearchResult> {
+  if (!query || query.trim().length < 3) {
+    return {
+      type: 'FeatureCollection',
+      version: 'draft',
+      features: [],
+      attribution: '',
+      licence: '',
+      query: query,
+      limit: 0,
+    };
+  }
+
+  const encodedQuery = encodeURIComponent(query.trim());
+  const url = `${API_BASE_URL}/search?q=${encodedQuery}&limit=${limit}`;
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15_000);
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const message =
+        response.status === 504 || response.status === 502 || response.status === 503
+          ? "Le service de recherche d'adresses est temporairement indisponible. Réessayez dans un instant."
+          : `Erreur HTTP: ${response.status}`;
+      throw new Error(message);
+    }
+
+    const data: AddressSearchResult = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === 'AbortError') {
+        const timeoutMessage =
+          "La recherche d'adresse a pris trop de temps. Réessayez dans un instant.";
+        console.error("Erreur lors de la recherche d'adresse:", timeoutMessage);
+        throw new Error(timeoutMessage);
+      }
+    }
+    console.error("Erreur lors de la recherche d'adresse:", error);
+    throw error;
+  }
+}
+
+/**
+ * Extrait les composants d'une adresse
+ */
+export function extractAddressComponents(feature: AddressFeature): {
+  street: string;
+  city: string;
+  postalCode: string;
+  fullAddress: string;
+  citycode: string;
+} {
+  const props = feature.properties;
+  return {
+    street: props.name || '',
+    city: props.city || '',
+    postalCode: props.postcode || '',
+    fullAddress: props.label || '',
+    citycode: props.citycode || '',
+  };
+}
+
+/**
+ * Recherche inversée : trouve une adresse à partir de coordonnées GPS
+ * @param latitude - Latitude (ex: 48.8566)
+ * @param longitude - Longitude (ex: 2.3522)
+ */
+export async function reverseGeocode(
+  latitude: number,
+  longitude: number,
+): Promise<AddressSearchResult> {
+  const url = `${API_BASE_URL}/reverse?lon=${longitude}&lat=${latitude}`;
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15_000);
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const message =
+        response.status === 504 || response.status === 502 || response.status === 503
+          ? "Le service de recherche d'adresses est temporairement indisponible. Réessayez dans un instant."
+          : `Erreur HTTP: ${response.status}`;
+      throw new Error(message);
+    }
+
+    const data: AddressSearchResult = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      const timeoutMessage =
+        "La recherche d'adresse a pris trop de temps. Réessayez dans un instant.";
+      console.error('Erreur lors du reverse geocoding:', timeoutMessage);
+      throw new Error(timeoutMessage);
+    }
+    console.error('Erreur lors du reverse geocoding:', error);
+    throw error;
+  }
+}

package/template/src/lib/cache.ts

@@ -0,0 +1,73 @@
+import { LRUCache } from 'lru-cache';
+import { prisma } from '@/lib/prisma';
+
+const cache = new LRUCache<string, any>({
+  max: 100,
+  ttl: 5 * 60 * 1000,
+  allowStale: false,
+});
+
+const pendingFetches = new Map<string, Promise<any>>();
+
+function getCached<T>(key: string, ttlMs: number, fetcher: () => Promise<T>): Promise<T> {
+  const cached = cache.get(key);
+  if (cached !== undefined) return Promise.resolve(cached as T);
+
+  const pending = pendingFetches.get(key);
+  if (pending) return pending as Promise<T>;
+
+  const promise = fetcher()
+    .then((data) => {
+      cache.set(key, data, { ttl: ttlMs });
+      pendingFetches.delete(key);
+      return data;
+    })
+    .catch((err) => {
+      pendingFetches.delete(key);
+      throw err;
+    });
+
+  pendingFetches.set(key, promise);
+  return promise;
+}
+
+export function invalidateCache(key: string) {
+  cache.delete(key);
+}
+
+export function invalidateCachePrefix(prefix: string) {
+  for (const key of cache.keys()) {
+    if (key.startsWith(prefix)) {
+      cache.delete(key);
+    }
+  }
+}
+
+const FIVE_MINUTES = 5 * 60 * 1000;
+const ONE_HOUR = 60 * 60 * 1000;
+
+export function getCachedStatuses() {
+  return getCached('statuses', FIVE_MINUTES, () =>
+    prisma.status.findMany({ orderBy: { order: 'asc' } }),
+  );
+}
+
+export function getCachedCompany() {
+  return getCached('company', ONE_HOUR, () =>
+    prisma.organization.findUnique({ where: { id: 'company' } }),
+  );
+}
+
+export function getCachedStatusByName(name: string) {
+  return getCached(`status:${name}`, FIVE_MINUTES, () =>
+    prisma.status.findFirst({
+      where: { name: { equals: name, mode: 'insensitive' } },
+    }),
+  );
+}
+
+export function getCachedClosingReasons() {
+  return getCached('closing-reasons', FIVE_MINUTES, () =>
+    prisma.closingReason.findMany({ orderBy: { name: 'asc' } }),
+  );
+}