@consilioweb/payload-support 0.5.1

package/src/components/TicketConversation/hooks/useMessageActions.ts

@@ -0,0 +1,131 @@
+import { useState } from 'react'
+import type { Message, ClientInfo } from '../types'
+
+export function useMessageActions(
+  id: string | number | undefined,
+  client: ClientInfo | null,
+  fetchAll: () => void,
+) {
+  const [togglingAuthor, setTogglingAuthor] = useState<string | number | null>(null)
+  const [editingMsg, setEditingMsg] = useState<string | number | null>(null)
+  const [editBody, setEditBody] = useState('')
+  const [editHtml, setEditHtml] = useState('')
+  const [savingEdit, setSavingEdit] = useState(false)
+  const [deletingMsg, setDeletingMsg] = useState<string | number | null>(null)
+  const [resendingMsg, setResendingMsg] = useState<string | number | null>(null)
+  const [resendSuccess, setResendSuccess] = useState<string | number | null>(null)
+
+  const handleEditStart = (msg: Message) => {
+    setEditingMsg(msg.id)
+    setEditBody(msg.body)
+    setEditHtml(msg.bodyHtml || msg.body.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\n/g, '<br />'))
+  }
+
+  const handleEditSave = async (msgId: string | number) => {
+    if (!editBody.trim()) return
+    setSavingEdit(true)
+    try {
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ body: editBody.trim(), ...(editHtml ? { bodyHtml: editHtml } : {}) }),
+      })
+      if (res.ok) {
+        setEditingMsg(null)
+        setEditBody('')
+        fetchAll()
+      }
+    } catch { /* ignore */ } finally {
+      setSavingEdit(false)
+    }
+  }
+
+  const handleEditCancel = () => {
+    setEditingMsg(null)
+    setEditBody('')
+    setEditHtml('')
+  }
+
+  const handleDelete = async (msgId: string | number) => {
+    if (!window.confirm('Supprimer ce message ?')) return
+    setDeletingMsg(msgId)
+    try {
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: 'DELETE',
+        credentials: 'include',
+      })
+      if (res.ok) fetchAll()
+    } catch { /* ignore */ } finally {
+      setDeletingMsg(null)
+    }
+  }
+
+  const handleResend = async (msgId: string | number) => {
+    setResendingMsg(msgId)
+    setResendSuccess(null)
+    try {
+      const res = await fetch('/api/support/resend-notification', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ messageId: msgId }),
+      })
+      if (res.ok) {
+        setResendSuccess(msgId)
+        setTimeout(() => setResendSuccess(null), 3000)
+      }
+    } catch { /* ignore */ } finally {
+      setResendingMsg(null)
+    }
+  }
+
+  const handleToggleAuthor = async (msgId: string | number, currentType: string) => {
+    const newType = currentType === 'admin' ? 'client' : 'admin'
+    setTogglingAuthor(msgId)
+    try {
+      const patchData: Record<string, unknown> = { authorType: newType }
+      if (newType === 'client' && client) {
+        patchData.authorClient = client.id
+      }
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify(patchData),
+      })
+      if (res.ok) fetchAll()
+    } catch { /* ignore */ } finally {
+      setTogglingAuthor(null)
+    }
+  }
+
+  const handleSplitMessage = async (msgId: string | number, ticketSubject: string) => {
+    const subject = prompt('Sujet du nouveau ticket :', `Split: ${ticketSubject}`)
+    if (!subject) return
+    try {
+      const res = await fetch('/api/support/split-ticket', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ messageId: msgId, subject }),
+      })
+      if (res.ok) {
+        const data = await res.json()
+        alert(`Ticket ${data.ticketNumber} créé`)
+        fetchAll()
+      }
+    } catch { /* ignore */ }
+  }
+
+  return {
+    togglingAuthor,
+    editingMsg, editBody, editHtml, setEditHtml, savingEdit,
+    handleEditStart, handleEditSave, handleEditCancel,
+    deletingMsg, handleDelete,
+    resendingMsg, resendSuccess, handleResend,
+    handleToggleAuthor,
+    handleSplitMessage,
+    setEditBody,
+  }
+}

package/src/components/TicketConversation/hooks/useReply.ts

@@ -0,0 +1,190 @@
+import { useState, useRef, useCallback } from 'react'
+import type { ClientInfo, CannedResponse } from '../types'
+import type { RichTextEditorHandle } from '../context'
+
+export function useReply(
+  id: string | number | undefined,
+  client: ClientInfo | null,
+  cannedResponses: CannedResponse[],
+  ticketNumber: string,
+  ticketSubject: string,
+  fetchAll: () => void,
+  handleNextTicket: () => void,
+  replyEditorRef: React.RefObject<RichTextEditorHandle | null>,
+) {
+  const fileInputRef = useRef<HTMLInputElement>(null)
+  const [replyBody, setReplyBody] = useState('')
+  const [replyHtml, setReplyHtml] = useState('')
+  const [replyFiles, setReplyFiles] = useState<File[]>([])
+  const [isInternal, setIsInternal] = useState(false)
+  const [notifyClient, setNotifyClient] = useState(false)
+  const [sendAsClient, setSendAsClient] = useState(false)
+  const [sending, setSending] = useState(false)
+  const [showSchedule, setShowSchedule] = useState(false)
+  const [scheduleDate, setScheduleDate] = useState('')
+
+  const handleEditorFileUpload = useCallback(async (file: File): Promise<string | null> => {
+    if (file.size > 5 * 1024 * 1024) return null
+    const formData = new FormData()
+    formData.append('file', file)
+    formData.append('_payload', JSON.stringify({ alt: file.name }))
+    try {
+      const res = await fetch('/api/media', { method: 'POST', credentials: 'include', body: formData })
+      if (res.ok) {
+        const data = await res.json()
+        return data.doc?.url || null
+      }
+    } catch { /* ignore */ }
+    return null
+  }, [])
+
+  const replaceCannedVariables = useCallback((text: string): string => {
+    let result = text
+    if (client) {
+      result = result.replace(/\{\{client\.firstName\}\}/g, client.firstName || 'Client')
+      result = result.replace(/\{\{client\.lastName\}\}/g, client.lastName || '')
+      result = result.replace(/\{\{client\.company\}\}/g, client.company || '')
+      result = result.replace(/\{\{client\.email\}\}/g, client.email || '')
+      result = result.replace(/\{\{clientName\}\}/g, client.firstName || 'Client')
+    }
+    result = result.replace(/\{\{ticket\.number\}\}/g, ticketNumber || '')
+    result = result.replace(/\{\{ticket\.subject\}\}/g, ticketSubject || '')
+    result = result.replace(/\{\{agent\.name\}\}/g, 'Support')
+    return result
+  }, [client, ticketNumber, ticketSubject])
+
+  const handleCannedSelect = (e: React.ChangeEvent<HTMLSelectElement>) => {
+    const selected = cannedResponses.find((cr) => String(cr.id) === e.target.value)
+    if (selected) {
+      const body = replaceCannedVariables(selected.body)
+      const html = body.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\n/g, '<br />')
+      setReplyBody(body)
+      setReplyHtml(html)
+      replyEditorRef.current?.setContent(html)
+    }
+    e.target.value = ''
+  }
+
+  const handleReplyFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    if (e.target.files) {
+      const maxSize = 1 * 1024 * 1024
+      const newFiles = Array.from(e.target.files!)
+      const tooLarge = newFiles.filter((f) => f.size > maxSize)
+      if (tooLarge.length > 0) {
+        alert(`Fichier(s) trop volumineux (max 1 Mo) : ${tooLarge.map((f) => f.name).join(', ')}`)
+      }
+      setReplyFiles((prev) => [...prev, ...newFiles.filter((f) => f.size <= maxSize)])
+    }
+    if (fileInputRef.current) fileInputRef.current.value = ''
+  }
+
+  const uploadFiles = async (files: File[]): Promise<number[]> => {
+    const uploadedIds: number[] = []
+    for (const file of files) {
+      if (file.size > 1 * 1024 * 1024) continue
+      const formData = new FormData()
+      formData.append('file', file)
+      formData.append('_payload', JSON.stringify({ alt: file.name }))
+      const uploadRes = await fetch('/api/media', { method: 'POST', credentials: 'include', body: formData })
+      if (uploadRes.ok) {
+        const d = await uploadRes.json()
+        if (d.doc?.id) uploadedIds.push(d.doc.id)
+      }
+    }
+    return uploadedIds
+  }
+
+  const resetReply = () => {
+    setReplyBody('')
+    setReplyHtml('')
+    setReplyFiles([])
+    setIsInternal(false)
+    setNotifyClient(false)
+    setSendAsClient(false)
+    replyEditorRef.current?.clear()
+  }
+
+  const handleSendReply = async () => {
+    if (!replyBody.trim() || !id) return
+    setSending(true)
+    try {
+      const uploadedIds = await uploadFiles(replyFiles)
+      const finalBody = replyBody.trim() || (replyHtml ? '[Contenu enrichi]' : '')
+      const messageData: Record<string, unknown> = {
+        ticket: id,
+        body: finalBody,
+        ...(replyHtml ? { bodyHtml: replyHtml } : {}),
+        authorType: sendAsClient ? 'client' : 'admin',
+        isInternal,
+        skipNotification: isInternal || !notifyClient,
+        ...(sendAsClient && client ? { authorClient: client.id } : {}),
+      }
+      if (uploadedIds.length > 0) {
+        messageData.attachments = uploadedIds.map((mid) => ({ file: mid }))
+      }
+
+      const res = await fetch('/api/ticket-messages', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify(messageData),
+      })
+      if (res.ok) {
+        resetReply()
+        fetchAll()
+        if (!isInternal) handleNextTicket()
+      }
+    } catch { /* ignore */ } finally {
+      setSending(false)
+    }
+  }
+
+  const handleScheduleReply = async () => {
+    if (!replyBody.trim() || !id || !scheduleDate) return
+    setSending(true)
+    try {
+      const uploadedIds = await uploadFiles(replyFiles)
+      const messageData: Record<string, unknown> = {
+        ticket: id,
+        body: replyBody.trim(),
+        ...(replyHtml ? { bodyHtml: replyHtml } : {}),
+        authorType: 'admin',
+        isInternal: false,
+        skipNotification: true,
+        scheduledAt: new Date(scheduleDate).toISOString(),
+        scheduledSent: false,
+      }
+      if (uploadedIds.length > 0) {
+        messageData.attachments = uploadedIds.map((mid) => ({ file: mid }))
+      }
+
+      const res = await fetch('/api/ticket-messages', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify(messageData),
+      })
+      if (res.ok) {
+        resetReply()
+        setShowSchedule(false)
+        setScheduleDate('')
+        fetchAll()
+      }
+    } catch { /* ignore */ } finally {
+      setSending(false)
+    }
+  }
+
+  return {
+    fileInputRef,
+    replyBody, setReplyBody, replyHtml, setReplyHtml,
+    replyFiles, setReplyFiles,
+    isInternal, setIsInternal,
+    notifyClient, setNotifyClient,
+    sendAsClient, setSendAsClient,
+    sending,
+    showSchedule, setShowSchedule, scheduleDate, setScheduleDate,
+    handleEditorFileUpload, handleCannedSelect, handleReplyFileChange,
+    handleSendReply, handleScheduleReply,
+  }
+}

package/src/components/TicketConversation/hooks/useTicketActions.ts

@@ -0,0 +1,205 @@
+import { useState, useRef } from 'react'
+
+export function useTicketActions(
+  id: string | number | undefined,
+  fetchAll: () => void,
+) {
+  const [statusUpdating, setStatusUpdating] = useState(false)
+  // Merge
+  const [showMerge, setShowMerge] = useState(false)
+  const [mergeTarget, setMergeTarget] = useState('')
+  const [mergeTargetInfo, setMergeTargetInfo] = useState<{ id: number; ticketNumber: string; subject: string } | null>(null)
+  const [merging, setMerging] = useState(false)
+  const [mergeError, setMergeError] = useState('')
+  // External message
+  const [showExtMsg, setShowExtMsg] = useState(false)
+  const [extMsgBody, setExtMsgBody] = useState('')
+  const [extMsgAuthor, setExtMsgAuthor] = useState<'client' | 'admin'>('client')
+  const [extMsgDate, setExtMsgDate] = useState('')
+  const [extMsgFiles, setExtMsgFiles] = useState<File[]>([])
+  const [sendingExtMsg, setSendingExtMsg] = useState(false)
+  const extFileInputRef = useRef<HTMLInputElement>(null)
+  // Snooze
+  const [showSnooze, setShowSnooze] = useState(false)
+  const [snoozeUntil, setSnoozeUntil] = useState<string | null>(null)
+  const [snoozeSaving, setSnoozeSaving] = useState(false)
+  // Next ticket
+  const [showNextTicket, setShowNextTicket] = useState(false)
+  const [nextTicketId, setNextTicketId] = useState<number | null>(null)
+  const [nextTicketInfo, setNextTicketInfo] = useState<string>('')
+
+  const handleStatusChange = async (newStatus: string) => {
+    if (!id) return
+    setStatusUpdating(true)
+    try {
+      await fetch(`/api/tickets/${id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ status: newStatus }),
+      })
+      window.location.reload()
+    } catch { /* ignore */ } finally {
+      setStatusUpdating(false)
+    }
+  }
+
+  const handleMergeLookup = async () => {
+    if (!mergeTarget.trim()) return
+    setMergeTargetInfo(null)
+    setMergeError('')
+    try {
+      const searchVal = mergeTarget.trim().toUpperCase()
+      const res = await fetch(`/api/tickets?where[ticketNumber][equals]=${encodeURIComponent(searchVal)}&limit=1&depth=0`, { credentials: 'include' })
+      if (res.ok) {
+        const d = await res.json()
+        if (d.docs?.length > 0) {
+          const t = d.docs[0]
+          if (String(t.id) === String(id)) {
+            setMergeError('Impossible de fusionner un ticket avec lui-même')
+          } else {
+            setMergeTargetInfo({ id: t.id, ticketNumber: t.ticketNumber, subject: t.subject })
+          }
+        } else {
+          setMergeError('Ticket introuvable')
+        }
+      }
+    } catch { setMergeError('Erreur de recherche') }
+  }
+
+  const handleMerge = async () => {
+    if (!mergeTargetInfo || !id) return
+    setMerging(true)
+    setMergeError('')
+    try {
+      const res = await fetch('/api/support/merge-tickets', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ sourceTicketId: id, targetTicketId: mergeTargetInfo.id }),
+      })
+      if (res.ok) {
+        window.location.href = `/admin/collections/tickets/${mergeTargetInfo.id}`
+      } else {
+        const d = await res.json().catch(() => ({}))
+        setMergeError(d.error || 'Erreur de fusion')
+      }
+    } catch { setMergeError('Erreur réseau') } finally {
+      setMerging(false)
+    }
+  }
+
+  const handleExtFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    if (e.target.files) {
+      const maxSize = 1 * 1024 * 1024
+      const newFiles = Array.from(e.target.files)
+      const tooLarge = newFiles.filter((f) => f.size > maxSize)
+      if (tooLarge.length > 0) {
+        alert(`Fichier(s) trop volumineux (max 1 Mo) : ${tooLarge.map((f) => f.name).join(', ')}`)
+      }
+      setExtMsgFiles((prev) => [...prev, ...newFiles.filter((f) => f.size <= maxSize)])
+    }
+    if (extFileInputRef.current) extFileInputRef.current.value = ''
+  }
+
+  const handleSendExtMsg = async () => {
+    if (!extMsgBody.trim() || !id) return
+    setSendingExtMsg(true)
+    try {
+      const uploadedIds: number[] = []
+      for (const file of extMsgFiles) {
+        if (file.size > 1 * 1024 * 1024) continue
+        const formData = new FormData()
+        formData.append('file', file)
+        formData.append('_payload', JSON.stringify({ alt: file.name }))
+        const uploadRes = await fetch('/api/media', { method: 'POST', credentials: 'include', body: formData })
+        if (uploadRes.ok) {
+          const d = await uploadRes.json()
+          if (d.doc?.id) uploadedIds.push(d.doc.id)
+        }
+      }
+
+      const messageData: Record<string, unknown> = {
+        ticket: id,
+        body: extMsgBody.trim(),
+        authorType: extMsgAuthor,
+        isInternal: false,
+        skipNotification: true,
+      }
+      if (extMsgDate) {
+        messageData.createdAt = new Date(extMsgDate).toISOString()
+      }
+      if (uploadedIds.length > 0) {
+        messageData.attachments = uploadedIds.map((mid) => ({ file: mid }))
+      }
+
+      const res = await fetch('/api/ticket-messages', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify(messageData),
+      })
+      if (res.ok) {
+        setExtMsgBody('')
+        setExtMsgDate('')
+        setExtMsgFiles([])
+        setShowExtMsg(false)
+        fetchAll()
+      }
+    } catch { /* ignore */ } finally {
+      setSendingExtMsg(false)
+    }
+  }
+
+  const handleSnooze = async (days: number | null, customDate?: string) => {
+    if (!id) return
+    setSnoozeSaving(true)
+    try {
+      let newSnooze: string | null = null
+      if (days !== null) {
+        const d = new Date()
+        d.setDate(d.getDate() + days)
+        newSnooze = d.toISOString()
+      } else if (customDate) {
+        newSnooze = new Date(customDate).toISOString()
+      }
+
+      await fetch(`/api/tickets/${id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ snoozeUntil: newSnooze }),
+      })
+      setSnoozeUntil(newSnooze)
+      setShowSnooze(false)
+      fetchAll()
+    } catch { /* ignore */ } finally {
+      setSnoozeSaving(false)
+    }
+  }
+
+  const handleNextTicket = async () => {
+    try {
+      const res = await fetch('/api/tickets?where[status][equals]=open&sort=updatedAt&limit=1&depth=0', { credentials: 'include' })
+      if (res.ok) {
+        const d = await res.json()
+        if (d.docs?.length > 0 && String(d.docs[0].id) !== String(id)) {
+          setNextTicketId(d.docs[0].id)
+          setNextTicketInfo(`${d.docs[0].ticketNumber} — ${d.docs[0].subject}`)
+        } else {
+          setNextTicketId(null)
+          setNextTicketInfo('Aucun autre ticket ouvert')
+        }
+        setShowNextTicket(true)
+      }
+    } catch { /* ignore */ }
+  }
+
+  return {
+    statusUpdating, handleStatusChange,
+    showMerge, setShowMerge, mergeTarget, setMergeTarget, mergeTargetInfo, setMergeTargetInfo, mergeError, setMergeError, merging, handleMergeLookup, handleMerge,
+    showExtMsg, setShowExtMsg, extMsgBody, setExtMsgBody, extMsgAuthor, setExtMsgAuthor, extMsgDate, setExtMsgDate, extMsgFiles, setExtMsgFiles, sendingExtMsg, handleExtFileChange, handleSendExtMsg,
+    showSnooze, setShowSnooze, snoozeUntil, setSnoozeUntil, snoozeSaving, handleSnooze,
+    showNextTicket, setShowNextTicket, nextTicketId, nextTicketInfo, handleNextTicket,
+  }
+}

package/src/components/TicketConversation/hooks/useTimeTracking.ts

@@ -0,0 +1,107 @@
+import { useState, useRef, useEffect } from 'react'
+
+export function useTimeTracking(id: string | number | undefined, fetchAll: () => void) {
+  const [duration, setDuration] = useState('')
+  const [timeDescription, setTimeDescription] = useState('')
+  const [addingTime, setAddingTime] = useState(false)
+  const [timeSuccess, setTimeSuccess] = useState('')
+  const [timerRunning, setTimerRunning] = useState(false)
+  const [timerSeconds, setTimerSeconds] = useState(0)
+  const [timerDescription, setTimerDescription] = useState('')
+  const timerIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null)
+  const timerKeepAliveRef = useRef<ReturnType<typeof setInterval> | null>(null)
+
+  const handleAddTime = async () => {
+    if (!duration || !id) return
+    setAddingTime(true)
+    setTimeSuccess('')
+    try {
+      const res = await fetch('/api/time-entries', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({
+          ticket: id,
+          duration: parseInt(duration, 10),
+          date: new Date().toISOString(),
+          description: timeDescription.trim() || undefined,
+        }),
+      })
+      if (res.ok) {
+        setDuration('')
+        setTimeDescription('')
+        setTimeSuccess(`${duration} min ajoutées`)
+        setTimeout(() => setTimeSuccess(''), 3000)
+        fetchAll()
+      }
+    } catch { /* ignore */ } finally {
+      setAddingTime(false)
+    }
+  }
+
+  const handleTimerStart = (reset = false) => {
+    setTimerRunning(true)
+    if (reset) setTimerSeconds(0)
+    timerIntervalRef.current = setInterval(() => {
+      setTimerSeconds((prev) => prev + 1)
+    }, 1000)
+    timerKeepAliveRef.current = setInterval(() => {
+      fetch('/api/users/me', { credentials: 'include' }).catch(() => {})
+    }, 5 * 60 * 1000)
+  }
+
+  const handleTimerStop = () => {
+    setTimerRunning(false)
+    if (timerIntervalRef.current) { clearInterval(timerIntervalRef.current); timerIntervalRef.current = null }
+    if (timerKeepAliveRef.current) { clearInterval(timerKeepAliveRef.current); timerKeepAliveRef.current = null }
+  }
+
+  const handleTimerSave = async () => {
+    if (!id || timerSeconds < 60) return
+    const minutes = Math.round(timerSeconds / 60)
+    setAddingTime(true)
+    try {
+      const res = await fetch('/api/time-entries', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({
+          ticket: id,
+          duration: minutes,
+          date: new Date().toISOString(),
+          description: timerDescription.trim() || 'Timer',
+        }),
+      })
+      if (res.ok) {
+        setTimeSuccess(`${minutes} min ajoutées (timer)`)
+        setTimeout(() => setTimeSuccess(''), 3000)
+        setTimerSeconds(0)
+        setTimerDescription('')
+        fetchAll()
+      }
+    } catch { /* ignore */ } finally {
+      setAddingTime(false)
+    }
+  }
+
+  const handleTimerDiscard = () => {
+    setTimerSeconds(0)
+    setTimerDescription('')
+  }
+
+  // Cleanup timer on unmount
+  useEffect(() => {
+    return () => {
+      if (timerIntervalRef.current) clearInterval(timerIntervalRef.current)
+      if (timerKeepAliveRef.current) clearInterval(timerKeepAliveRef.current)
+    }
+  }, [])
+
+  return {
+    duration, setDuration,
+    timeDescription, setTimeDescription,
+    addingTime, timeSuccess,
+    timerRunning, timerSeconds, setTimerSeconds, timerDescription, setTimerDescription,
+    handleAddTime, handleTimerStart, handleTimerStop, handleTimerSave, handleTimerDiscard,
+  }
+}