create-crm-tmp 1.1.3 → 2.1.0

package/template/src/lib/contact-view-filters.ts

@@ -0,0 +1,301 @@
+import type { ViewFilter, DatePreset } from '@/types/contact-views';
+import {
+  expandRegionCodesToDepartmentCodes,
+  prismaPostalMatchesDepartmentsCondition,
+} from '@/lib/fr-geography';
+
+function startOfDay(date: Date): Date {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+function endOfDay(date: Date): Date {
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+function getMonday(date: Date): Date {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = d.getDate() - day + (day === 0 ? -6 : 1);
+  d.setDate(diff);
+  return startOfDay(d);
+}
+
+function getQuarterStart(date: Date): Date {
+  const month = date.getMonth();
+  const quarterStartMonth = month - (month % 3);
+  return startOfDay(new Date(date.getFullYear(), quarterStartMonth, 1));
+}
+
+function getQuarterEnd(date: Date): Date {
+  const month = date.getMonth();
+  const quarterEndMonth = month - (month % 3) + 3;
+  return endOfDay(new Date(date.getFullYear(), quarterEndMonth, 0));
+}
+
+export function resolveDatePreset(preset: DatePreset): { gte?: Date; lte?: Date } {
+  const now = new Date();
+  const today = startOfDay(now);
+
+  switch (preset) {
+    case 'today':
+      return { gte: startOfDay(today), lte: endOfDay(today) };
+    case 'yesterday': {
+      const d = new Date(today);
+      d.setDate(d.getDate() - 1);
+      return { gte: startOfDay(d), lte: endOfDay(d) };
+    }
+    case 'tomorrow': {
+      const d = new Date(today);
+      d.setDate(d.getDate() + 1);
+      return { gte: startOfDay(d), lte: endOfDay(d) };
+    }
+    case 'this_week': {
+      const monday = getMonday(today);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'this_week_so_far': {
+      const monday = getMonday(today);
+      return { gte: monday, lte: endOfDay(today) };
+    }
+    case 'last_week': {
+      const monday = getMonday(today);
+      monday.setDate(monday.getDate() - 7);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'next_week': {
+      const monday = getMonday(today);
+      monday.setDate(monday.getDate() + 7);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+      return { gte: monday, lte: endOfDay(sunday) };
+    }
+    case 'this_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth(), 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth() + 1, 0)),
+      };
+    case 'this_month_so_far':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth(), 1)),
+        lte: endOfDay(today),
+      };
+    case 'last_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth() - 1, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth(), 0)),
+      };
+    case 'next_month':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), now.getMonth() + 1, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), now.getMonth() + 2, 0)),
+      };
+    case 'this_quarter':
+      return { gte: getQuarterStart(now), lte: getQuarterEnd(now) };
+    case 'this_quarter_so_far':
+      return { gte: getQuarterStart(now), lte: endOfDay(today) };
+    case 'last_quarter': {
+      const prevQuarter = new Date(now);
+      prevQuarter.setMonth(prevQuarter.getMonth() - 3);
+      return {
+        gte: getQuarterStart(prevQuarter),
+        lte: getQuarterEnd(prevQuarter),
+      };
+    }
+    case 'this_year':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), 0, 1)),
+        lte: endOfDay(new Date(now.getFullYear(), 11, 31)),
+      };
+    case 'this_year_so_far':
+      return {
+        gte: startOfDay(new Date(now.getFullYear(), 0, 1)),
+        lte: endOfDay(today),
+      };
+    case 'last_year':
+      return {
+        gte: startOfDay(new Date(now.getFullYear() - 1, 0, 1)),
+        lte: endOfDay(new Date(now.getFullYear() - 1, 11, 31)),
+      };
+    case 'last_7_days':
+    case 'last_14_days':
+    case 'last_30_days':
+    case 'last_60_days':
+    case 'last_90_days':
+    case 'last_180_days':
+    case 'last_365_days': {
+      const daysMap: Record<string, number> = {
+        last_7_days: 7,
+        last_14_days: 14,
+        last_30_days: 30,
+        last_60_days: 60,
+        last_90_days: 90,
+        last_180_days: 180,
+        last_365_days: 365,
+      };
+      const d = new Date(today);
+      d.setDate(d.getDate() - daysMap[preset]);
+      return { gte: startOfDay(d), lte: endOfDay(today) };
+    }
+    default:
+      return {};
+  }
+}
+
+function buildFieldCondition(filter: ViewFilter): any | null {
+  const { field, operator, value, preset } = filter;
+
+  if (field === 'department') {
+    if (!Array.isArray(value) || value.length === 0) return null;
+    if (operator === 'is_any_of') {
+      return prismaPostalMatchesDepartmentsCondition(value as string[]);
+    }
+    if (operator === 'is_none_of') {
+      const inner = prismaPostalMatchesDepartmentsCondition(value as string[]);
+      return inner ? { NOT: inner } : null;
+    }
+    return null;
+  }
+
+  if (field === 'region') {
+    if (!Array.isArray(value) || value.length === 0) return null;
+    const deptCodes = expandRegionCodesToDepartmentCodes(value as string[]);
+    if (deptCodes.length === 0) return null;
+    if (operator === 'is_any_of') {
+      return prismaPostalMatchesDepartmentsCondition(deptCodes);
+    }
+    if (operator === 'is_none_of') {
+      const inner = prismaPostalMatchesDepartmentsCondition(deptCodes);
+      return inner ? { NOT: inner } : null;
+    }
+    return null;
+  }
+
+  switch (operator) {
+    case 'equals': {
+      if (field === 'createdAt' || field === 'updatedAt') {
+        if (!value || typeof value !== 'string') return null;
+        const d = new Date(value);
+        if (isNaN(d.getTime())) return null;
+        return { [field]: { gte: startOfDay(d), lte: endOfDay(d) } };
+      }
+      return { [field]: value };
+    }
+
+    case 'not_equals':
+      return { NOT: { [field]: value } };
+
+    case 'contains':
+      return { [field]: { contains: value as string, mode: 'insensitive' } };
+
+    case 'not_contains':
+      return {
+        NOT: { [field]: { contains: value as string, mode: 'insensitive' } },
+      };
+
+    case 'starts_with':
+      return {
+        [field]: { startsWith: value as string, mode: 'insensitive' },
+      };
+
+    case 'ends_with':
+      return { [field]: { endsWith: value as string, mode: 'insensitive' } };
+
+    case 'is_any_of': {
+      if (!Array.isArray(value) || value.length === 0) return null;
+      const hasUnassigned = value.includes('UNASSIGNED');
+      const realValues = value.filter((v) => v !== 'UNASSIGNED');
+
+      if (hasUnassigned && realValues.length > 0) {
+        return { OR: [{ [field]: null }, { [field]: { in: realValues } }] };
+      } else if (hasUnassigned) {
+        return { [field]: null };
+      }
+      return { [field]: { in: realValues } };
+    }
+
+    case 'is_none_of': {
+      if (!Array.isArray(value) || value.length === 0) return null;
+      const hasUnassigned = value.includes('UNASSIGNED');
+      const realValues = value.filter((v) => v !== 'UNASSIGNED');
+
+      if (hasUnassigned && realValues.length > 0) {
+        return {
+          AND: [{ [field]: { not: null } }, { [field]: { notIn: realValues } }],
+        };
+      } else if (hasUnassigned) {
+        return { [field]: { not: null } };
+      }
+      return { [field]: { notIn: realValues } };
+    }
+
+    case 'gt': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { gt: endOfDay(d) } };
+    }
+
+    case 'gte': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { gte: startOfDay(d) } };
+    }
+
+    case 'lt': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { lt: startOfDay(d) } };
+    }
+
+    case 'lte': {
+      const d = new Date(value as string);
+      if (isNaN(d.getTime())) return null;
+      return { [field]: { lte: endOfDay(d) } };
+    }
+
+    case 'between': {
+      if (!Array.isArray(value) || value.length !== 2) return null;
+      const start = new Date(value[0]);
+      const end = new Date(value[1]);
+      if (isNaN(start.getTime()) || isNaN(end.getTime())) return null;
+      return { [field]: { gte: startOfDay(start), lte: endOfDay(end) } };
+    }
+
+    case 'is_known':
+      return { [field]: { not: null } };
+
+    case 'is_unknown':
+      return { [field]: null };
+
+    case 'date_preset': {
+      if (!preset) return null;
+      const range = resolveDatePreset(preset);
+      return { [field]: range };
+    }
+
+    default:
+      return null;
+  }
+}
+
+export function buildPrismaWhereFromFilters(filters: ViewFilter[]): Record<string, any> {
+  const conditions: any[] = [];
+
+  for (const filter of filters) {
+    const condition = buildFieldCondition(filter);
+    if (condition) {
+      conditions.push(condition);
+    }
+  }
+
+  if (conditions.length === 0) return {};
+  if (conditions.length === 1) return conditions[0];
+  return { AND: conditions };
+}

package/template/src/lib/contacts-list-url.ts

@@ -0,0 +1,190 @@
+import type { ReadonlyURLSearchParams } from 'next/navigation';
+
+const VALID_LIMITS = [25, 50, 100] as const;
+
+/** Tri par défaut liste contacts : pas de paramètres d’URL (parse → createdAt desc). */
+export const CONTACTS_LIST_DEFAULT_SORT_FIELD = 'createdAt';
+export const CONTACTS_LIST_DEFAULT_SORT_ORDER = 'desc' as const;
+
+export function isContactsListDefaultSort(
+  sortField: string,
+  sortOrder: 'asc' | 'desc',
+): boolean {
+  return (
+    sortField === CONTACTS_LIST_DEFAULT_SORT_FIELD &&
+    sortOrder === CONTACTS_LIST_DEFAULT_SORT_ORDER
+  );
+}
+
+/** Chevrons / filtre « tri actif » sur une colonne — masqué pour le tri implicite création ↓. */
+export function contactsListColumnShowsActiveSort(
+  columnId: string,
+  sortField: string,
+  sortOrder: 'asc' | 'desc',
+): boolean {
+  if (sortField !== columnId) return false;
+  if (
+    columnId === CONTACTS_LIST_DEFAULT_SORT_FIELD &&
+    isContactsListDefaultSort(sortField, sortOrder)
+  ) {
+    return false;
+  }
+  return true;
+}
+
+export type ParsedContactsListUrl = {
+  viewEntity: 'contacts' | 'companies';
+  currentPage: number;
+  limit: number;
+  viewMode: 'table' | 'cards';
+  search: string;
+  statusIds: string[];
+  origins: string[];
+  assignedCommercialIds: string[];
+  assignedTeleproIds: string[];
+  createdAtStart: string;
+  createdAtEnd: string;
+  updatedAtStart: string;
+  updatedAtEnd: string;
+  regionCodes: string[];
+  departmentCodes: string[];
+  sortField: string;
+  sortOrder: 'asc' | 'desc';
+};
+
+function splitCsv(v: string | null): string[] {
+  if (!v) return [];
+  return v
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Source de vérité côté client au premier rendu / après popstate : `window.location`
+ * peut être à jour avant `useSearchParams()` (retour arrière), sinon on retombe sur le hook.
+ */
+export function getContactsListUrlSearchParams(
+  sp: URLSearchParams | ReadonlyURLSearchParams,
+): URLSearchParams {
+  if (typeof globalThis.window !== 'undefined') {
+    return new URLSearchParams(globalThis.window.location.search);
+  }
+  return new URLSearchParams(sp.toString());
+}
+
+export function readContactsListFromLocationOrParams(
+  sp: URLSearchParams | ReadonlyURLSearchParams,
+): ParsedContactsListUrl {
+  return parseContactsListFromSearchParams(getContactsListUrlSearchParams(sp));
+}
+
+export function parseContactsListFromSearchParams(
+  sp: URLSearchParams | ReadonlyURLSearchParams,
+): ParsedContactsListUrl {
+  const page = Number.parseInt(sp.get('page') || '1', 10);
+  const lim = Number.parseInt(sp.get('limit') || '25', 10);
+  return {
+    viewEntity: sp.get('entity') === 'companies' ? 'companies' : 'contacts',
+    currentPage: Number.isFinite(page) && page >= 1 ? page : 1,
+    limit: VALID_LIMITS.includes(lim as (typeof VALID_LIMITS)[number]) ? lim : 25,
+    viewMode: sp.get('view') === 'cards' ? 'cards' : 'table',
+    search: sp.get('search') || '',
+    statusIds: splitCsv(sp.get('statusIds')),
+    origins: splitCsv(sp.get('origins')),
+    assignedCommercialIds: splitCsv(sp.get('assignedCommercialIds')),
+    assignedTeleproIds: splitCsv(sp.get('assignedTeleproIds')),
+    createdAtStart: sp.get('createdAtStart') || '',
+    createdAtEnd: sp.get('createdAtEnd') || '',
+    updatedAtStart: sp.get('updatedAtStart') || '',
+    updatedAtEnd: sp.get('updatedAtEnd') || '',
+    regionCodes: splitCsv(sp.get('regionCodes')),
+    departmentCodes: splitCsv(sp.get('departmentCodes')),
+    sortField: sp.get('sortField') || CONTACTS_LIST_DEFAULT_SORT_FIELD,
+    sortOrder:
+      sp.get('sortOrder') === 'asc'
+        ? 'asc'
+        : sp.get('sortOrder') === 'desc'
+          ? 'desc'
+          : CONTACTS_LIST_DEFAULT_SORT_ORDER,
+  };
+}
+
+export type ContactsListUrlInput = {
+  viewEntity: 'contacts' | 'companies';
+  currentPage: number;
+  limit: number;
+  viewMode: 'table' | 'cards';
+  search: string;
+  statusFilter: Set<string>;
+  originFilter: Set<string>;
+  assignedCommercialFilter: Set<string>;
+  assignedTeleproFilter: Set<string>;
+  createdAtStart: string;
+  createdAtEnd: string;
+  updatedAtStart: string;
+  updatedAtEnd: string;
+  regionFilter: Set<string>;
+  departmentFilter: Set<string>;
+  sortField: string;
+  sortOrder: 'asc' | 'desc';
+};
+
+export function buildContactsListSearchParams(input: ContactsListUrlInput): URLSearchParams {
+  const p = new URLSearchParams();
+  if (input.viewEntity === 'companies') {
+    p.set('entity', 'companies');
+  }
+  p.set('page', String(input.currentPage));
+  p.set('limit', String(input.limit));
+  p.set('view', input.viewMode);
+  if (input.search.trim()) {
+    p.set('search', input.search.trim());
+  }
+  if (input.statusFilter.size > 0) {
+    p.set('statusIds', [...input.statusFilter].join(','));
+  }
+  if (input.originFilter.size > 0) {
+    p.set('origins', [...input.originFilter].join(','));
+  }
+  if (input.assignedCommercialFilter.size > 0) {
+    p.set('assignedCommercialIds', [...input.assignedCommercialFilter].join(','));
+  }
+  if (input.assignedTeleproFilter.size > 0) {
+    p.set('assignedTeleproIds', [...input.assignedTeleproFilter].join(','));
+  }
+  if (input.createdAtStart) p.set('createdAtStart', input.createdAtStart);
+  if (input.createdAtEnd) p.set('createdAtEnd', input.createdAtEnd);
+  if (input.updatedAtStart) p.set('updatedAtStart', input.updatedAtStart);
+  if (input.updatedAtEnd) p.set('updatedAtEnd', input.updatedAtEnd);
+  if (input.regionFilter.size > 0) {
+    p.set('regionCodes', [...input.regionFilter].join(','));
+  }
+  if (input.departmentFilter.size > 0) {
+    p.set('departmentCodes', [...input.departmentFilter].join(','));
+  }
+  if (
+    input.sortField &&
+    !isContactsListDefaultSort(input.sortField, input.sortOrder)
+  ) {
+    p.set('sortField', input.sortField);
+    p.set('sortOrder', input.sortOrder);
+  }
+  return p;
+}
+
+/** Comparaison stable pour éviter replace / hydrate inutiles */
+export function canonicalSearchParamsString(params: URLSearchParams): string {
+  return [...params.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+}
+
+export function setsEqualToIds(prev: Set<string>, ids: string[]): boolean {
+  if (prev.size !== ids.length) return false;
+  for (const id of ids) {
+    if (!prev.has(id)) return false;
+  }
+  return true;
+}