@consilioweb/payload-support 0.5.1

package/src/endpoints/round-robin-config.ts

@@ -0,0 +1,92 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+const PREF_KEY = 'support-round-robin'
+
+/**
+ * GET /api/support/round-robin-config — Get round-robin enabled status
+ */
+export function createRoundRobinConfigGetEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/round-robin-config',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const prefs = await payload.find({
+          collection: 'payload-preferences' as any,
+          where: { key: { equals: PREF_KEY } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        const enabled = prefs.docs.length > 0
+          ? (prefs.docs[0].value as { enabled?: boolean })?.enabled === true
+          : false
+
+        return Response.json({ enabled })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.warn('[round-robin-config] GET error:', error)
+        return Response.json({ error: 'Error' }, { status: 500 })
+      }
+    },
+  }
+}
+
+/**
+ * POST /api/support/round-robin-config — Enable/disable round-robin
+ */
+export function createRoundRobinConfigPostEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/round-robin-config',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const { enabled } = (await req.json!()) as { enabled: boolean }
+
+        const existing = await payload.find({
+          collection: 'payload-preferences' as any,
+          where: { key: { equals: PREF_KEY } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        await payload.db.upsert({
+          collection: 'payload-preferences',
+          data: {
+            key: PREF_KEY,
+            user: { relationTo: req.user!.collection, value: req.user!.id },
+            value: { enabled: !!enabled },
+          },
+          req: { payload, user: req.user } as any,
+          where: {
+            and: [
+              { key: { equals: PREF_KEY } },
+              { 'user.value': { equals: req.user!.id } },
+              { 'user.relationTo': { equals: req.user!.collection } },
+            ],
+          },
+        })
+
+        return Response.json({ enabled: !!enabled })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[round-robin-config] POST error:', error)
+        return Response.json({ error: 'Error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/satisfaction.ts

@@ -0,0 +1,93 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireClient, handleAuthError } from '../utils/auth'
+
+/**
+ * POST /api/support/satisfaction
+ * Client submits a satisfaction survey for a resolved ticket.
+ */
+export function createSatisfactionEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/satisfaction',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireClient(req, slugs)
+
+        const body = await req.json!()
+        const { ticketId, rating, comment } = body
+
+        if (!ticketId || !rating || !Number.isInteger(rating) || rating < 1 || rating > 5) {
+          return Response.json(
+            { error: 'ticketId et rating (entier 1-5) sont requis.' },
+            { status: 400 },
+          )
+        }
+
+        if (comment && typeof comment === 'string' && comment.length > 5000) {
+          return Response.json(
+            { error: 'Le commentaire ne peut pas dépasser 5000 caractères.' },
+            { status: 400 },
+          )
+        }
+
+        // Verify ticket belongs to client and is resolved
+        const ticket = await payload.findByID({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          depth: 0,
+          overrideAccess: false,
+          user: req.user,
+        }) as any
+
+        if (!ticket) {
+          return Response.json({ error: 'Ticket introuvable.' }, { status: 404 })
+        }
+
+        if (ticket.status !== 'resolved') {
+          return Response.json(
+            { error: 'Le ticket doit être résolu pour laisser un avis.' },
+            { status: 400 },
+          )
+        }
+
+        // Check if survey already exists
+        const existing = await payload.find({
+          collection: slugs.satisfactionSurveys as any,
+          where: { ticket: { equals: ticketId } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        if (existing.docs.length > 0) {
+          return Response.json(
+            { error: 'Vous avez déjà évalué ce ticket.' },
+            { status: 409 },
+          )
+        }
+
+        const survey = await payload.create({
+          collection: slugs.satisfactionSurveys as any,
+          data: {
+            source: 'ticket',
+            ticket: ticketId,
+            client: req.user.id,
+            rating: Math.round(rating),
+            ...(comment ? { comment: comment.trim() } : {}),
+          },
+          overrideAccess: true,
+        })
+
+        return Response.json({ success: true, survey })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[satisfaction] Error:', error)
+        return Response.json({ error: 'Erreur interne.' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/search.ts

@@ -0,0 +1,106 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * GET /api/support/search?q=term
+ * Global search across tickets, messages, clients, knowledge base.
+ * Admin-only.
+ */
+export function createSearchEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/search',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const url = new URL(req.url!)
+        const q = url.searchParams.get('q')?.trim()
+        if (!q || q.length < 2) {
+          return Response.json({ tickets: [], clients: [], messages: [], articles: [] })
+        }
+
+        const [ticketsRes, clientsRes, messagesRes, articlesRes] = await Promise.all([
+          payload.find({
+            collection: slugs.tickets as any,
+            where: {
+              or: [
+                { ticketNumber: { contains: q } },
+                { subject: { contains: q } },
+              ],
+            },
+            sort: '-updatedAt',
+            limit: 8,
+            depth: 1,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.supportClients as any,
+            where: {
+              or: [
+                { firstName: { contains: q } },
+                { lastName: { contains: q } },
+                { email: { contains: q } },
+                { company: { contains: q } },
+              ],
+            },
+            limit: 5,
+            depth: 0,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.ticketMessages as any,
+            where: { body: { contains: q } },
+            sort: '-createdAt',
+            limit: 5,
+            depth: 1,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.knowledgeBase as any,
+            where: { title: { contains: q } },
+            limit: 5,
+            depth: 0,
+            overrideAccess: true,
+          }),
+        ])
+
+        return Response.json({
+          tickets: ticketsRes.docs.map((t: any) => ({
+            id: t.id,
+            ticketNumber: t.ticketNumber,
+            subject: t.subject,
+            status: t.status,
+            client: typeof t.client === 'object' ? { firstName: t.client?.firstName, company: t.client?.company } : null,
+          })),
+          clients: clientsRes.docs.map((c: any) => ({
+            id: c.id,
+            firstName: c.firstName,
+            lastName: c.lastName,
+            email: c.email,
+            company: c.company,
+          })),
+          messages: messagesRes.docs.map((m: any) => ({
+            id: m.id,
+            body: typeof m.body === 'string' ? m.body.slice(0, 100) : '',
+            ticketId: typeof m.ticket === 'object' ? m.ticket?.id : m.ticket,
+            ticketNumber: typeof m.ticket === 'object' ? m.ticket?.ticketNumber : null,
+          })),
+          articles: articlesRes.docs.map((a: any) => ({
+            id: a.id,
+            title: a.title,
+            slug: a.slug,
+          })),
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[search] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/seed-kb.ts

@@ -0,0 +1,153 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+const KB_ARTICLES = [
+  {
+    title: 'Comment créer un ticket de support ?',
+    slug: 'comment-creer-un-ticket',
+    category: 'getting-started',
+    body: 'Pour créer un ticket de support, connectez-vous à votre espace client puis cliquez sur "Nouveau ticket". Remplissez le sujet et la description de votre demande. Vous pouvez ajouter des pièces jointes (captures d\'écran, documents) pour nous aider à comprendre votre problème. Notre équipe vous répondra dans les meilleurs délais.',
+  },
+  {
+    title: 'Comment suivre l\'avancement de mon ticket ?',
+    slug: 'suivre-avancement-ticket',
+    category: 'tickets',
+    body: 'Rendez-vous sur votre tableau de bord support. Vous y trouverez la liste de tous vos tickets avec leur statut actuel (Ouvert, En attente, Résolu). Cliquez sur un ticket pour voir la conversation complète et ajouter des messages. Vous recevez aussi des notifications par email à chaque réponse de notre équipe.',
+  },
+  {
+    title: 'Quels sont les délais de réponse ?',
+    slug: 'delais-de-reponse',
+    category: 'tickets',
+    body: 'Notre équipe s\'engage à répondre à votre ticket dans un délai de 2 heures ouvrées (lundi-vendredi, 9h-18h). Les tickets marqués "Urgent" sont traités en priorité. En dehors des heures ouvrées, votre ticket sera traité dès la reprise d\'activité.',
+  },
+  {
+    title: 'Comment modifier mon mot de passe ?',
+    slug: 'modifier-mot-de-passe',
+    category: 'account',
+    body: 'Accédez à votre profil depuis le menu en haut à droite. Dans la section "Sécurité", vous trouverez le formulaire de changement de mot de passe. Entrez votre mot de passe actuel puis définissez votre nouveau mot de passe (minimum 8 caractères). Cliquez sur "Sauvegarder" pour confirmer.',
+  },
+  {
+    title: 'Comment activer l\'authentification à deux facteurs (2FA) ?',
+    slug: 'activer-2fa',
+    category: 'account',
+    body: 'L\'authentification à deux facteurs renforce la sécurité de votre compte. Accédez à votre profil, section "Sécurité", et activez le toggle 2FA. Lors de votre prochaine connexion, un code de vérification sera envoyé par email. Entrez ce code pour accéder à votre espace.',
+  },
+  {
+    title: 'Comment ajouter des pièces jointes à un ticket ?',
+    slug: 'ajouter-pieces-jointes',
+    category: 'tickets',
+    body: 'Vous pouvez joindre des fichiers à vos messages en cliquant sur le bouton "Joindre un fichier" sous l\'éditeur de message, ou en glissant-déposant directement vos fichiers. Les formats acceptés sont : images (PNG, JPG, GIF), documents (PDF, DOC, DOCX, TXT) et archives (ZIP). Taille maximale : 5 Mo par fichier.',
+  },
+  {
+    title: 'Mon site web ne s\'affiche plus, que faire ?',
+    slug: 'site-ne-saffiche-plus',
+    category: 'technical',
+    body: 'Si votre site ne s\'affiche plus : 1) Vérifiez votre connexion internet. 2) Videz le cache de votre navigateur. 3) Essayez en navigation privée. 4) Si le problème persiste, créez un ticket urgent en précisant le message d\'erreur et l\'URL concernée.',
+  },
+  {
+    title: 'Comment demander une modification sur mon site ?',
+    slug: 'demander-modification-site',
+    category: 'getting-started',
+    body: 'Créez un ticket avec la catégorie "Modification de contenu". Décrivez précisément la modification souhaitée : page concernée, texte à modifier, images à remplacer, etc. Joignez des captures d\'écran si nécessaire.',
+  },
+  {
+    title: 'Quels sont les tarifs de support ?',
+    slug: 'tarifs-support',
+    category: 'billing',
+    body: 'Le support technique est inclus dans votre contrat de maintenance. Les demandes de modification de contenu et les nouvelles fonctionnalités sont facturées au temps passé selon le taux horaire défini dans votre contrat.',
+  },
+  {
+    title: 'Comment exporter mes données personnelles (RGPD) ?',
+    slug: 'export-donnees-rgpd',
+    category: 'account',
+    body: 'Conformément au RGPD, vous pouvez demander l\'export de toutes vos données personnelles. Rendez-vous dans votre profil, section "Données personnelles", et cliquez sur "Exporter mes données".',
+  },
+  {
+    title: 'Comment fonctionne la connexion Google (SSO) ?',
+    slug: 'connexion-google-sso',
+    category: 'account',
+    body: 'Vous pouvez vous connecter avec votre compte Google. Sur la page de connexion, cliquez sur "Se connecter avec Google". Si c\'est votre première connexion, un compte sera automatiquement créé.',
+  },
+  {
+    title: 'Que signifient les différents statuts de ticket ?',
+    slug: 'statuts-ticket',
+    category: 'tickets',
+    body: 'Ouvert : votre ticket a été reçu et est en cours de traitement. En attente : nous attendons une réponse de votre part. Résolu : le problème a été résolu. Vous pouvez rouvrir un ticket résolu en y répondant.',
+  },
+]
+
+/**
+ * POST /api/support/seed-kb
+ * Seed the knowledge base with default FAQ articles. Admin-only.
+ */
+export function createSeedKbEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/seed-kb',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        let created = 0
+        let skipped = 0
+
+        for (const article of KB_ARTICLES) {
+          const existing = await payload.find({
+            collection: slugs.knowledgeBase as any,
+            where: { slug: { equals: article.slug } },
+            limit: 1,
+            depth: 0,
+            overrideAccess: true,
+          })
+
+          if (existing.docs.length > 0) {
+            skipped++
+            continue
+          }
+
+          const lexicalBody = {
+            root: {
+              type: 'root',
+              children: article.body.split('. ').map((sentence) => ({
+                type: 'paragraph',
+                children: [{ type: 'text', text: sentence.trim() + (sentence.endsWith('.') ? '' : '.'), version: 1 }],
+                direction: 'ltr',
+                format: '',
+                indent: 0,
+                version: 1,
+              })),
+              direction: 'ltr',
+              format: '',
+              indent: 0,
+              version: 1,
+            },
+          }
+
+          await payload.create({
+            collection: slugs.knowledgeBase as any,
+            data: {
+              title: article.title,
+              slug: article.slug,
+              category: article.category,
+              body: lexicalBody as any,
+              published: true,
+              sortOrder: created + 1,
+            },
+            overrideAccess: true,
+          })
+          created++
+        }
+
+        return Response.json({ created, skipped, total: KB_ARTICLES.length })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[seed-kb] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/settings.ts

@@ -0,0 +1,144 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+const PREF_KEY = 'support-settings'
+
+interface SupportSettings {
+  email: {
+    fromAddress: string
+    fromName: string
+    replyToAddress: string
+  }
+  ai: {
+    provider: 'anthropic' | 'openai' | 'gemini' | 'ollama'
+    model: string
+    enableSentiment: boolean
+    enableSynthesis: boolean
+    enableSuggestion: boolean
+    enableRewrite: boolean
+  }
+  sla: {
+    firstResponseMinutes: number
+    resolutionMinutes: number
+    businessHoursOnly: boolean
+    escalationEmail: string
+  }
+  autoClose: {
+    enabled: boolean
+    daysBeforeClose: number
+    reminderDaysBefore: number
+  }
+}
+
+const DEFAULT_SUPPORT_SETTINGS: SupportSettings = {
+  email: { fromAddress: '', fromName: 'Support', replyToAddress: '' },
+  ai: {
+    provider: 'anthropic',
+    model: 'claude-haiku-4-5-20251001',
+    enableSentiment: true,
+    enableSynthesis: true,
+    enableSuggestion: true,
+    enableRewrite: true,
+  },
+  sla: {
+    firstResponseMinutes: 120,
+    resolutionMinutes: 1440,
+    businessHoursOnly: true,
+    escalationEmail: '',
+  },
+  autoClose: { enabled: true, daysBeforeClose: 7, reminderDaysBefore: 2 },
+}
+
+/**
+ * GET /api/support/settings — Read support settings
+ */
+export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/settings',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const prefs = await payload.find({
+          collection: 'payload-preferences' as any,
+          where: { key: { equals: PREF_KEY } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        let settings = { ...DEFAULT_SUPPORT_SETTINGS }
+        if (prefs.docs.length > 0) {
+          const stored = prefs.docs[0].value as Partial<SupportSettings>
+          settings = {
+            email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...stored.email },
+            ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...stored.ai },
+            sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...stored.sla },
+            autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...stored.autoClose },
+          }
+        }
+
+        return Response.json(settings)
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.warn('[support/settings] GET error:', error)
+        return Response.json({ error: 'Error' }, { status: 500 })
+      }
+    },
+  }
+}
+
+/**
+ * POST /api/support/settings — Save all support settings (admin-only)
+ */
+export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/settings',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const body = (await req.json!()) as Partial<SupportSettings>
+
+        const merged: SupportSettings = {
+          email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...body.email },
+          ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...body.ai },
+          sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...body.sla },
+          autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...body.autoClose },
+        }
+
+        await payload.db.upsert({
+          collection: 'payload-preferences',
+          data: {
+            key: PREF_KEY,
+            user: { relationTo: req.user!.collection, value: req.user!.id },
+            value: merged as unknown as Record<string, unknown>,
+          },
+          req: { payload, user: req.user } as any,
+          where: {
+            and: [
+              { key: { equals: PREF_KEY } },
+              { 'user.value': { equals: req.user!.id } },
+              { 'user.relationTo': { equals: req.user!.collection } },
+            ],
+          },
+        })
+
+        return Response.json(merged)
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[support/settings] Error saving settings:', error)
+        return Response.json({ error: 'Error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/signature.ts

@@ -0,0 +1,93 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+const PREF_KEY = 'email-signature'
+
+/**
+ * GET /api/support/signature — Get current admin's email signature
+ */
+export function createSignatureGetEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/signature',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const prefs = await payload.find({
+          collection: 'payload-preferences' as any,
+          where: { key: { equals: `${PREF_KEY}-${req.user.id}` } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        const signature = prefs.docs.length > 0
+          ? (prefs.docs[0].value as { signature?: string })?.signature || ''
+          : ''
+
+        return Response.json({ signature })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[signature] GET error:', error)
+        return Response.json({ signature: '' })
+      }
+    },
+  }
+}
+
+/**
+ * POST /api/support/signature — Save current admin's email signature
+ */
+export function createSignaturePostEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/signature',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const { signature } = (await req.json!()) as { signature: string }
+        const key = `${PREF_KEY}-${req.user.id}`
+
+        const existing = await payload.find({
+          collection: 'payload-preferences' as any,
+          where: { key: { equals: key } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        await payload.db.upsert({
+          collection: 'payload-preferences',
+          data: {
+            key,
+            user: { relationTo: req.user!.collection, value: req.user!.id },
+            value: { signature: signature || '' },
+          },
+          req: { payload, user: req.user } as any,
+          where: {
+            and: [
+              { key: { equals: key } },
+              { 'user.value': { equals: req.user!.id } },
+              { 'user.relationTo': { equals: req.user!.collection } },
+            ],
+          },
+        })
+
+        return Response.json({ signature: signature || '' })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[signature] POST error:', error)
+        return Response.json({ error: 'Error saving signature' }, { status: 500 })
+      }
+    },
+  }
+}