create-crm-tmp 1.1.2 → 2.0.0

package/template/src/lib/dashboard-stats.ts

@@ -0,0 +1,224 @@
+import { prisma } from '@/lib/prisma';
+import { getCachedStatuses } from '@/lib/cache';
+
+export interface DashboardStats {
+  overview: {
+    totalContacts: number;
+    contactsThisMonth: number;
+    contactsGrowth: number;
+    statusData: Array<{ name: string; value: number }>;
+    monthlyContacts: Array<{ month: string; count: number }>;
+  };
+  tasks: {
+    total: number;
+    completed: number;
+    pending: number;
+    upcoming: Array<{
+      id: string;
+      title: string;
+      type: string;
+      scheduledAt: string;
+      contact: { id: string; name: string } | null;
+      priority: string;
+    }>;
+    byType: Array<{ type: string; count: number }>;
+  };
+  interactions: {
+    recent: any[];
+    byType: Array<{ type: string; count: number }>;
+  };
+  activity: {
+    last7Days: Array<{ date: string; interactions: number; tasks: number }>;
+  };
+}
+
+export async function getDashboardStats(
+  userId: string,
+  permissions: string[],
+): Promise<DashboardStats> {
+  const canViewAllContacts = permissions.includes('contacts.view_all');
+  const canViewOwnContacts = permissions.includes('contacts.view_own');
+  const canViewUnassigned = permissions.includes('contacts.view_unassigned');
+
+  let contactFilter: any = {};
+  if (!canViewAllContacts && canViewOwnContacts) {
+    const conditions: any[] = [
+      { assignedCommercialId: userId },
+      { assignedTeleproId: userId },
+      { createdById: userId },
+    ];
+    if (canViewUnassigned) {
+      conditions.push({ AND: [{ assignedCommercialId: null }, { assignedTeleproId: null }] });
+    }
+    contactFilter = { OR: conditions };
+  } else if (!canViewAllContacts && !canViewOwnContacts) {
+    contactFilter = { id: '__none__' };
+  }
+
+  const now = new Date();
+  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+  const lastMonthStart = new Date(startOfMonth);
+  lastMonthStart.setMonth(lastMonthStart.getMonth() - 1);
+
+  const twelveMonthsAgo = new Date(now.getFullYear(), now.getMonth() - 11, 1);
+  const sevenDaysAgo = new Date(now);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 6);
+  sevenDaysAgo.setHours(0, 0, 0, 0);
+
+  const [
+    totalContacts,
+    contactsThisMonth,
+    contactsLastMonth,
+    statusDistribution,
+    statuses,
+    upcomingTasks,
+    recentInteractions,
+    totalTasks,
+    completedTasks,
+    tasksThisMonthByType,
+    interactionsThisMonth,
+    contactsLast12Months,
+    interactionsLast7Days,
+    tasksLast7Days,
+  ] = await Promise.all([
+    prisma.contact.count({ where: contactFilter }),
+    prisma.contact.count({
+      where: { ...contactFilter, createdAt: { gte: startOfMonth } },
+    }),
+    prisma.contact.count({
+      where: { ...contactFilter, createdAt: { gte: lastMonthStart, lt: startOfMonth } },
+    }),
+    prisma.contact.groupBy({ by: ['statusId'], where: contactFilter, _count: true }),
+    getCachedStatuses(),
+    prisma.task.findMany({
+      where: { assignedUserId: userId, completed: false, scheduledAt: { gte: now } },
+      select: {
+        id: true,
+        title: true,
+        type: true,
+        scheduledAt: true,
+        priority: true,
+        contact: { select: { id: true, firstName: true, lastName: true, phone: true } },
+      },
+      orderBy: { scheduledAt: 'asc' },
+      take: 6,
+    }),
+    prisma.interaction.findMany({
+      where: { userId },
+      select: {
+        id: true,
+        type: true,
+        content: true,
+        createdAt: true,
+        contact: { select: { id: true, firstName: true, lastName: true, phone: true } },
+        user: { select: { id: true, name: true } },
+      },
+      orderBy: { createdAt: 'desc' },
+      take: 5,
+    }),
+    prisma.task.count({ where: { assignedUserId: userId } }),
+    prisma.task.count({ where: { assignedUserId: userId, completed: true } }),
+    prisma.task.groupBy({
+      by: ['type'],
+      where: { assignedUserId: userId, createdAt: { gte: startOfMonth } },
+      _count: true,
+    }),
+    prisma.interaction.groupBy({
+      by: ['type'],
+      where: { userId, createdAt: { gte: startOfMonth } },
+      _count: true,
+    }),
+    prisma.contact.findMany({
+      where: { ...contactFilter, createdAt: { gte: twelveMonthsAgo } },
+      select: { createdAt: true },
+    }),
+    prisma.interaction.findMany({
+      where: { userId, createdAt: { gte: sevenDaysAgo } },
+      select: { createdAt: true },
+    }),
+    prisma.task.findMany({
+      where: { assignedUserId: userId, createdAt: { gte: sevenDaysAgo } },
+      select: { createdAt: true },
+    }),
+  ]);
+
+  const contactsGrowth =
+    contactsLastMonth > 0 ? ((contactsThisMonth - contactsLastMonth) / contactsLastMonth) * 100 : 0;
+
+  const monthsData = [];
+  for (let i = 11; i >= 0; i--) {
+    const monthStart = new Date(now.getFullYear(), now.getMonth() - i, 1);
+    const monthEnd = new Date(monthStart.getFullYear(), monthStart.getMonth() + 1, 1);
+    const count = contactsLast12Months.filter(
+      (c) => c.createdAt >= monthStart && c.createdAt < monthEnd,
+    ).length;
+    monthsData.push({
+      month: monthStart.toLocaleString('fr-FR', { month: 'short' }),
+      count,
+    });
+  }
+
+  const statusData = statuses.map((status) => ({
+    name: status.name,
+    value: statusDistribution.find((s) => s.statusId === status.id)?._count || 0,
+  }));
+
+  const pendingTasks = totalTasks - completedTasks;
+  const tasksByType = tasksThisMonthByType.map((t) => ({ type: t.type, count: t._count }));
+  const interactionsByType = interactionsThisMonth.map((i) => ({ type: i.type, count: i._count }));
+
+  const last7Days = [];
+  for (let i = 6; i >= 0; i--) {
+    const dayStart = new Date(now);
+    dayStart.setDate(dayStart.getDate() - i);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayEnd = new Date(dayStart);
+    dayEnd.setDate(dayEnd.getDate() + 1);
+
+    last7Days.push({
+      date: dayStart.toLocaleDateString('fr-FR', { day: 'numeric', month: 'short' }),
+      interactions: interactionsLast7Days.filter(
+        (x) => x.createdAt >= dayStart && x.createdAt < dayEnd,
+      ).length,
+      tasks: tasksLast7Days.filter((x) => x.createdAt >= dayStart && x.createdAt < dayEnd).length,
+    });
+  }
+
+  return {
+    overview: {
+      totalContacts,
+      contactsThisMonth,
+      contactsGrowth: Math.round(contactsGrowth * 10) / 10,
+      statusData,
+      monthlyContacts: monthsData,
+    },
+    tasks: {
+      total: totalTasks,
+      completed: completedTasks,
+      pending: pendingTasks,
+      upcoming: upcomingTasks.map((task) => ({
+        id: task.id,
+        title: task.title || 'Sans titre',
+        type: task.type,
+        scheduledAt: task.scheduledAt?.toISOString() ?? new Date().toISOString(),
+        contact: task.contact
+          ? {
+              id: task.contact.id,
+              name:
+                `${task.contact.firstName || ''} ${task.contact.lastName || ''}`.trim() ||
+                task.contact.phone,
+            }
+          : null,
+        priority: task.priority || 'MEDIUM',
+      })),
+      byType: tasksByType,
+    },
+    interactions: {
+      recent: recentInteractions,
+      byType: interactionsByType,
+    },
+    activity: {
+      last7Days,
+    },
+  };
+}

package/template/src/lib/date-utils.ts

@@ -0,0 +1,49 @@
+/**
+ * Calcule la semaine ISO 8601 pour une date donnée
+ * @param date - La date pour laquelle calculer la semaine ISO
+ * @returns Le numéro de la semaine ISO (1-53)
+ */
+export function getISOWeek(date: Date): number {
+  const target = new Date(date.valueOf());
+  const dayNr = (date.getDay() + 6) % 7;
+  target.setDate(target.getDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setMonth(0, 1);
+  if (target.getDay() !== 4) {
+    target.setMonth(0, 1 + ((4 - target.getDay() + 7) % 7));
+  }
+  return 1 + Math.ceil((firstThursday - target.valueOf()) / 604800000);
+}
+
+/**
+ * Formate une durée en heures et minutes
+ * @param hours - Nombre d'heures (peut être décimal)
+ * @returns Une chaîne formatée (ex: "2h 30min")
+ */
+export function formatDuration(hours: number): string {
+  const h = Math.floor(hours);
+  const m = Math.round((hours - h) * 60);
+  if (m === 0) return `${h}h`;
+  return `${h}h ${m}min`;
+}
+
+/**
+ * Calcule le mercredi de N semaines avant la semaine ISO d'une date donnée
+ * @param date - La date de référence
+ * @param weeksBefore - Nombre de semaines avant (par défaut 4)
+ * @returns Le mercredi de la semaine cible
+ */
+export function getWednesdayBeforeISOWeek(date: Date, weeksBefore: number = 4): Date {
+  // Obtenir le lundi de la semaine ISO de la date donnée
+  const target = new Date(date.valueOf());
+  const dayNr = (date.getDay() + 6) % 7; // 0 = lundi, 6 = dimanche
+  target.setDate(target.getDate() - dayNr); // Aller au lundi de cette semaine
+
+  // Reculer de N semaines
+  target.setDate(target.getDate() - weeksBefore * 7);
+
+  // Aller au mercredi de cette semaine (lundi + 2 jours)
+  target.setDate(target.getDate() + 2);
+
+  return target;
+}

package/template/src/lib/get-auth-user.ts

@@ -0,0 +1,25 @@
+import { cache } from 'react';
+import { auth } from '@/lib/auth';
+import { headers } from 'next/headers';
+import { prisma } from '@/lib/prisma';
+
+export const getAuthUser = cache(async () => {
+  const session = await auth.api.getSession({
+    headers: await headers(),
+  });
+
+  if (!session) return null;
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+    include: { customRole: true },
+  });
+
+  if (!user) return null;
+
+  return {
+    session,
+    user,
+    permissions: (user.customRole?.permissions as string[]) ?? [],
+  };
+});

package/template/src/lib/google-calendar.ts

@@ -2,6 +2,10 @@
  * Utilitaires pour gérer l'authentification et les appels à Google Calendar API
  */
 
+import { prisma } from './prisma';
+import { decrypt } from './encryption';
+import { googleFetch } from './google-fetch';
+
 interface GoogleTokenResponse {
   access_token: string;
   refresh_token?: string;
@@ -13,12 +17,15 @@ interface GoogleCalendarEvent {
   id?: string;
   summary: string;
   description?: string;
+  location?: string;
   start: {
-    dateTime: string;
+    dateTime?: string;
+    date?: string;
     timeZone?: string;
   };
   end: {
-    dateTime: string;
+    dateTime?: string;
+    date?: string;
     timeZone?: string;
   };
   attendees?: Array<{ email: string }>;
@@ -37,12 +44,15 @@ interface GoogleCalendarEventResponse {
   id: string;
   summary: string;
   description?: string;
+  location?: string;
   start: {
-    dateTime: string;
+    dateTime?: string;
+    date?: string;
     timeZone?: string;
   };
   end: {
-    dateTime: string;
+    dateTime?: string;
+    date?: string;
     timeZone?: string;
   };
   attendees?: Array<{ email: string }>;
@@ -74,7 +84,7 @@ export async function exchangeGoogleCodeForTokens(
     throw new Error('GOOGLE_CLIENT_ID et GOOGLE_CLIENT_SECRET doivent être configurés');
   }
 
-  const response = await fetch('https://oauth2.googleapis.com/token', {
+  const response = await googleFetch('https://oauth2.googleapis.com/token', {
     method: 'POST',
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
@@ -96,6 +106,28 @@ export async function exchangeGoogleCodeForTokens(
   return response.json();
 }
 
+/**
+ * Récupère le compte Google de l'utilisateur courant
+ * Chaque utilisateur utilise son propre compte Google pour Google Calendar
+ */
+export async function getUserGoogleAccount(userId: string) {
+  const googleAccount = await prisma.userGoogleAccount.findUnique({
+    where: { userId },
+  });
+
+  if (!googleAccount) {
+    throw new Error(
+      'Aucun compte Google connecté. Veuillez connecter votre compte Google dans les paramètres pour utiliser Google Calendar.',
+    );
+  }
+
+  return {
+    ...googleAccount,
+    accessToken: decrypt(googleAccount.accessToken),
+    refreshToken: decrypt(googleAccount.refreshToken),
+  };
+}
+
 /**
  * Erreur personnalisée pour les tokens Google invalides
  */
@@ -121,7 +153,7 @@ export async function refreshGoogleToken(refreshToken: string): Promise<GoogleTo
     throw new Error('GOOGLE_CLIENT_ID et GOOGLE_CLIENT_SECRET doivent être configurés');
   }
 
-  const response = await fetch('https://oauth2.googleapis.com/token', {
+  const response = await googleFetch('https://oauth2.googleapis.com/token', {
     method: 'POST',
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
@@ -175,8 +207,18 @@ export async function getValidAccessToken(
   const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
 
   if (expiresAt <= fiveMinutesFromNow) {
-    const newTokens = await refreshGoogleToken(refreshToken);
-    return newTokens.access_token;
+    try {
+      const newTokens = await refreshGoogleToken(refreshToken);
+      return newTokens.access_token;
+    } catch (error: any) {
+      // Si le token ne peut pas être rafraîchi (révoqué, expiré, etc.)
+      if (error instanceof GoogleTokenError && error.isRevoked) {
+        throw new Error(
+          'La connexion Google a expiré ou a été révoquée. Veuillez reconnecter votre compte Google dans les paramètres.',
+        );
+      }
+      throw error;
+    }
   }
 
   return accessToken;
@@ -189,7 +231,7 @@ export async function createGoogleCalendarEvent(
   accessToken: string,
   event: GoogleCalendarEvent,
 ): Promise<GoogleCalendarEventResponse> {
-  const response = await fetch(
+  const response = await googleFetch(
     'https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1',
     {
       method: 'POST',
@@ -217,7 +259,7 @@ export async function updateGoogleCalendarEvent(
   eventId: string,
   event: Partial<GoogleCalendarEvent>,
 ): Promise<GoogleCalendarEventResponse> {
-  const response = await fetch(
+  const response = await googleFetch(
     `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}?conferenceDataVersion=1`,
     {
       method: 'PATCH',
@@ -244,7 +286,7 @@ export async function deleteGoogleCalendarEvent(
   accessToken: string,
   eventId: string,
 ): Promise<void> {
-  const response = await fetch(
+  const response = await googleFetch(
     `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
     {
       method: 'DELETE',
@@ -280,7 +322,7 @@ export async function getGoogleCalendarEvent(
   accessToken: string,
   eventId: string,
 ): Promise<GoogleCalendarEventResponse> {
-  const response = await fetch(
+  const response = await googleFetch(
     `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
     {
       method: 'GET',