fix: toolbar carnet nettoyé — un seul organisateur, i18n corrigé

- Ancien bouton 'Organiser' (batch.organize) supprimé — doublon
- Nouvel organisateur (structuredViews.organizer) consolidé avec Planning + Résumé
- Actions IA regroupées avec séparateurs visuels
- Icônes plus petites (14px au lieu de 16px) pour gagner de la place
- Clé i18n corrigée : structuredViews.organizer au lieu de wizard.organizer
- CSV Import/Export maintenu dans la même zone
- OrganizeNotebookDialog marqué unused

memento-note/app/api/notebooks/csv/route.ts

@@ -0,0 +1,202 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import prisma from '@/lib/prisma'
+
+function escapeCSV(value: string): string {
+  if (!value) return ''
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return `"${value.replace(/"/g, '""')}"`
+  }
+  return value
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const notebookId = request.nextUrl.searchParams.get('notebookId')
+    if (!notebookId) {
+      return NextResponse.json({ error: 'notebookId required' }, { status: 400 })
+    }
+
+    const notebook = await prisma.notebook.findFirst({
+      where: { id: notebookId, userId: session.user.id },
+      select: { name: true },
+    })
+    if (!notebook) {
+      return NextResponse.json({ error: 'Notebook not found' }, { status: 404 })
+    }
+
+    const schema = await prisma.notebookSchema.findUnique({
+      where: { notebookId },
+      include: { properties: { orderBy: { position: 'asc' } } },
+    })
+
+    const notes = await prisma.note.findMany({
+      where: { notebookId, trashedAt: null, userId: session.user.id },
+      include: { properties: true },
+      orderBy: { order: 'asc' },
+    })
+
+    const propMap = new Map<string, string>()
+    if (schema?.properties) {
+      schema.properties.forEach(p => propMap.set(p.id, p.name))
+    }
+
+    const headers = ['Titre', ...Array.from(propMap.values()), 'Créé le', 'Modifié le']
+    const rows: string[] = [headers.map(escapeCSV).join(',')]
+
+    for (const note of notes) {
+      const noteProps = new Map<string, string>()
+      for (const np of note.properties) {
+        let val = np.value || ''
+        try { val = JSON.parse(val); if (Array.isArray(val)) val = val.join(', '); if (typeof val === 'object') val = String(val) } catch {}
+        noteProps.set(np.propertyId, String(val))
+      }
+
+      const row = [
+        escapeCSV(note.title || ''),
+        ...Array.from(propMap.keys()).map(propId => escapeCSV(noteProps.get(propId) || '')),
+        escapeCSV(note.createdAt.toISOString().slice(0, 10)),
+        escapeCSV(note.updatedAt.toISOString().slice(0, 10)),
+      ]
+      rows.push(row.join(','))
+    }
+
+    const csv = '\uFEFF' + rows.join('\n')
+    const filename = `${notebook.name.replace(/[^a-z0-9]/gi, '_')}.csv`
+
+    return new NextResponse(csv, {
+      headers: {
+        'Content-Type': 'text/csv; charset=utf-8',
+        'Content-Disposition': `attachment; filename="${filename}"`,
+      },
+    })
+  } catch (error: any) {
+    console.error('[CSV Export] Error:', error)
+    return NextResponse.json({ error: error.message }, { status: 500 })
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { notebookId, csvData } = await request.json()
+    if (!notebookId || !csvData) {
+      return NextResponse.json({ error: 'notebookId and csvData required' }, { status: 400 })
+    }
+
+    // Parse CSV
+    const lines = csvData.trim().split('\n')
+    if (lines.length < 2) {
+      return NextResponse.json({ error: 'CSV must have at least a header and one row' }, { status: 400 })
+    }
+
+    const parseCSVLine = (line: string): string[] => {
+      const result: string[] = []
+      let current = ''
+      let inQuotes = false
+      for (let i = 0; i < line.length; i++) {
+        const char = line[i]
+        if (char === '"') {
+          if (inQuotes && line[i + 1] === '"') { current += '"'; i++ }
+          else inQuotes = !inQuotes
+        } else if (char === ',' && !inQuotes) {
+          result.push(current.trim())
+          current = ''
+        } else {
+          current += char
+        }
+      }
+      result.push(current.trim())
+      return result
+    }
+
+    const headers = parseCSVLine(lines[0].replace(/^\uFEFF/, ''))
+    const titleIdx = headers.findIndex(h => h.toLowerCase().includes('titre') || h.toLowerCase() === 'title')
+    const dataRows = lines.slice(1).filter(l => l.trim())
+
+    // Get or create schema
+    let schema = await prisma.notebookSchema.findUnique({ where: { notebookId } })
+    if (!schema) {
+      schema = await prisma.notebookSchema.create({ data: { notebookId } })
+    }
+
+    // Map headers to property IDs (create properties for non-title columns)
+    const headerToPropId = new Map<number, string>()
+    for (let i = 0; i < headers.length; i++) {
+      if (i === titleIdx) continue
+      const headerName = headers[i]
+      if (headerName.toLowerCase().includes('créé') || headerName.toLowerCase().includes('modifié') ||
+          headerName.toLowerCase().includes('created') || headerName.toLowerCase().includes('modified')) continue
+
+      const existing = await prisma.notebookProperty.findFirst({
+        where: { schemaId: schema.id, name: headerName },
+      })
+      if (existing) {
+        headerToPropId.set(i, existing.id)
+      } else {
+        const prop = await prisma.notebookProperty.create({
+          data: {
+            schemaId: schema.id,
+            name: headerName,
+            type: 'text',
+            position: await prisma.notebookProperty.count({ where: { schemaId: schema.id } }),
+          },
+        })
+        headerToPropId.set(i, prop.id)
+      }
+    }
+
+    // Get max order
+    const maxOrderNote = await prisma.note.findFirst({
+      where: { notebookId },
+      orderBy: { order: 'desc' },
+      select: { order: true },
+    })
+    let nextOrder = (maxOrderNote?.order ?? 0) + 1
+
+    let created = 0
+    for (const line of dataRows) {
+      const cells = parseCSVLine(line)
+      const title = titleIdx >= 0 ? cells[titleIdx] : cells[0] || 'Sans titre'
+
+      const note = await prisma.note.create({
+        data: {
+          title,
+          content: '<p></p>',
+          userId: session.user.id,
+          notebookId,
+          order: nextOrder++,
+        },
+      })
+
+      for (const [colIdx, propId] of headerToPropId) {
+        const value = cells[colIdx]
+        if (value) {
+          await prisma.noteProperty.create({
+            data: {
+              noteId: note.id,
+              propertyId: propId,
+              value: JSON.stringify(value),
+            },
+          }).catch(() => {})
+        }
+      }
+
+      created++
+    }
+
+    return NextResponse.json({ success: true, created })
+  } catch (error: any) {
+    console.error('[CSV Import] Error:', error)
+    return NextResponse.json({ error: error.message }, { status: 500 })
+  }
+}