✨ Enhance Article and Discussion Management

- Update ArticlesController to allow users to view and manage their own articles, including new methods for listing, editing, and updating articles.
- Refactor ArticleStatsService to support fetching statistics based on user ID for personalized dashboard insights.
- Improve DiscussionsController to ensure proper deletion of discussions and associated messages/bans, with admin role verification.
- Add new routes for article management and discussion deletion, enforcing admin middleware for sensitive actions.
- Update .gitignore to include new directories for better project organization.

Author: BrightkyEfoo

.gitignore

@@ -23,4 +23,5 @@ yarn-error.log
 
 # Platform specific
 .DS_Store
-memory-bank/
+memory-bank/
+.claude/

app/controllers/articles_controller.ts

@@ -1,4 +1,5 @@
 import { ArticleStatus } from '#enums/article_status'
+import { Role } from '#enums/role'
 import Article from '#models/article'
 import ArticleStatsService from '#services/article_stats_service'
 import { articleValidator } from '#validators/article_validator'
@@ -49,8 +50,9 @@ export default class ArticlesController {
     return inertia.render('articles/[slug]', { article })
   }
 
-  async dashboard({ inertia }: HttpContext) {
-    const stats = await ArticleStatsService.getStats()
+  async dashboard({ inertia, auth }: HttpContext) {
+    // Chaque utilisateur ne voit que ses propres statistiques
+    const stats = await ArticleStatsService.getStats(auth.user!.id)
     return inertia.render('dashboard/index', {
       publishedArticles: stats.published,
       draftArticles: stats.drafts,
@@ -59,4 +61,127 @@ export default class ArticlesController {
       questions: 0,
     })
   }
+
+  async articles({ inertia, request, auth }: HttpContext) {
+    const page = request.input('page', 1)
+    const status = request.input('status', null)
+
+    const query = Article.query()
+      .preload('author')
+      .where('author_id', auth.user!.id)
+      .orderBy('created_at', 'desc')
+
+    if (status && Object.values(ArticleStatus).includes(status as ArticleStatus)) {
+      query.where('status', status as ArticleStatus)
+    }
+
+    const articles = await query.paginate(page, 10)
+
+    return inertia.render('dashboard/articles', {
+      articles: articles.toJSON(),
+      currentStatus: status,
+    })
+  }
+
+  async edit({ inertia, params, auth, response }: HttpContext) {
+    const article = await Article.query()
+      .where('slug', params.slug)
+      .where('author_id', auth.user!.id)
+      .firstOrFail()
+
+    return inertia.render('dashboard/articles/edit', { article })
+  }
+
+  async update({ request, params, auth, response }: HttpContext) {
+    const article = await Article.query()
+      .where('slug', params.slug)
+      .where('author_id', auth.user!.id)
+      .firstOrFail()
+
+    const data = await articleValidator.validate(request.all())
+
+    const payload: Partial<Article> = { ...data }
+
+    // Si on passe de draft/waiting à published, mettre à jour publishedAt
+    if (
+      data.status === ArticleStatus.PUBLISHED &&
+      article.status !== ArticleStatus.PUBLISHED
+    ) {
+      payload.publishedAt = DateTime.now()
+    }
+
+    // Si le titre change, générer un nouveau slug
+    if (data.title !== article.title) {
+      payload.slug = Article.generateSlug(data.title)
+    }
+
+    await article.merge(payload).save()
+
+    return response.redirect().toRoute('articles.show', { slug: article.slug })
+  }
+
+  // ADMIN METHODS
+
+  /**
+   * Liste des articles pour l'admin
+   * - Tous les articles publiés (de tous les auteurs)
+   * - Ses propres brouillons seulement
+   */
+  async adminArticles({ inertia, request, auth }: HttpContext) {
+    const page = request.input('page', 1)
+    const status = request.input('status', null)
+
+    let query = Article.query().preload('author').orderBy('created_at', 'desc')
+
+    if (status && Object.values(ArticleStatus).includes(status as ArticleStatus)) {
+      if (status === ArticleStatus.PUBLISHED) {
+        // Admin voit tous les articles publiés
+        query.where('status', ArticleStatus.PUBLISHED)
+      } else {
+        // Admin ne voit que ses propres brouillons/en attente
+        query.where('status', status as ArticleStatus).where('author_id', auth.user!.id)
+      }
+    } else {
+      // Par défaut : tous les publiés + ses brouillons
+      query.where((builder) => {
+        builder
+          .where('status', ArticleStatus.PUBLISHED)
+          .orWhere((subBuilder) => {
+            subBuilder.where('author_id', auth.user!.id).whereIn('status', [
+              ArticleStatus.DRAFT,
+              ArticleStatus.WAITING_APPROVAL,
+            ])
+          })
+      })
+    }
+
+    const articles = await query.paginate(page, 10)
+
+    return inertia.render('admin/articles', {
+      articles: articles.toJSON(),
+      currentStatus: status,
+    })
+  }
+
+  /**
+   * Dépublier un article (admin seulement)
+   * Passe le statut de PUBLISHED à DRAFT
+   */
+  async unpublish({ params, response, session, auth }: HttpContext) {
+    const article = await Article.query().where('slug', params.slug).firstOrFail()
+
+    // Vérifier que l'article est publié
+    if (article.status !== ArticleStatus.PUBLISHED) {
+      session.flash('error', 'Cet article n\'est pas publié')
+      return response.redirect().back()
+    }
+
+    // Dépublier l'article
+    article.status = ArticleStatus.DRAFT
+    article.publishedAt = null
+    await article.save()
+
+    session.flash('success', 'Article dépublié avec succès')
+    return response.redirect().back()
+  }
 }

app/controllers/discussions_controller.ts

@@ -56,34 +56,50 @@ export default class DiscussionsController {
     return response.redirect().toRoute('discussions.show', { id: discussion.id })
   }
 
-  async destroy({ params, auth, response }: HttpContext) {
-    // Suppression par admin
-    // (Vérifier le rôle admin dans la logique réelle)
-    const discussion = await Discussion.findOrFail(params.id)
+  async destroy({ params, response, session }: HttpContext) {
+    // Suppression par admin uniquement (vérifiée par middleware)
+    const discussion = await Discussion.query()
+      .where('id', params.id)
+      .preload('messages')
+      .preload('bans')
+      .firstOrFail()
+
+    // Supprimer tous les messages associés
+    await Message.query().where('discussion_id', discussion.id).delete()
+
+    // Supprimer tous les bans associés
+    await BannedUser.query().where('discussion_id', discussion.id).delete()
+
+    // Supprimer la discussion
     await discussion.delete()
+
+    session.flash('success', 'Discussion supprimée avec succès')
     return response.redirect().toRoute('discussions.index')
   }
 
   async ban({ params, request, auth, response }: HttpContext) {
-    if (auth.user?.role !== 'ADMIN') {
-      return response.unauthorized('Réservé admin')
-    }
+    // Bannissement par admin uniquement (vérifiée par middleware)
     const { userId, reason } = request.only(['userId', 'reason'])
     const discussionId = params.id
+
     // Vérifier si déjà banni
     const existing = await BannedUser.query()
       .where('user_id', userId)
       .where('discussion_id', discussionId)
       .first()
+
     if (existing) {
-      return response.badRequest('Déjà banni')
+      return response.badRequest({ error: 'Utilisateur déjà banni de cette discussion' })
     }
+
+    // Créer le ban
     await BannedUser.create({
       userId,
       discussionId,
-      adminId: auth.user.id,
+      adminId: auth.user!.id,
       reason: reason || null,
     })
-    return response.ok({ success: true })
+
+    return response.ok({ success: true, message: 'Utilisateur banni avec succès' })
   }
 }

app/middleware/admin_middleware.ts

@@ -0,0 +1,26 @@
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
+import { Role } from '#enums/role'
+
+/**
+ * Admin middleware is used to restrict access to admin-only routes
+ * The user must be authenticated and have an ADMIN role
+ */
+export default class AdminMiddleware {
+  /**
+   * The URL to redirect to when authorization fails
+   */
+  redirectTo = '/discussions'
+
+  async handle(ctx: HttpContext, next: NextFn) {
+    // Ensure user is authenticated
+    await ctx.auth.check()
+
+    // Check if user has admin role
+    if (!ctx.auth.user || ctx.auth.user.role !== Role.ADMIN) {
+      return ctx.response.abort('Accès réservé aux administrateurs', 403)
+    }
+
+    return next()
+  }
+}

app/services/article_stats_service.ts

@@ -2,16 +2,22 @@ import { ArticleStatus } from '#enums/article_status'
 import Article from '#models/article'
 
 export default class ArticleStatsService {
-  static async getStats() {
-    const publishedResult = await Article.query()
-      .where('status', ArticleStatus.PUBLISHED)
-      .count('* as total')
-    const draftResult = await Article.query()
-      .where('status', ArticleStatus.DRAFT)
-      .count('* as total')
-    const waitingResult = await Article.query()
-      .where('status', ArticleStatus.WAITING_APPROVAL)
-      .count('* as total')
+  static async getStats(userId?: number) {
+    const publishedQuery = Article.query().where('status', ArticleStatus.PUBLISHED)
+    const draftQuery = Article.query().where('status', ArticleStatus.DRAFT)
+    const waitingQuery = Article.query().where('status', ArticleStatus.WAITING_APPROVAL)
+
+    // Si userId est fourni, filtrer par l'auteur
+    if (userId) {
+      publishedQuery.where('author_id', userId)
+      draftQuery.where('author_id', userId)
+      waitingQuery.where('author_id', userId)
+    }
+
+    const publishedResult = await publishedQuery.count('* as total')
+    const draftResult = await draftQuery.count('* as total')
+    const waitingResult = await waitingQuery.count('* as total')
+
     return {
       published: Number(publishedResult[0].$extras.total),
       drafts: Number(draftResult[0].$extras.total),

app/services/minio_service.ts

@@ -25,13 +25,25 @@ export default class MinioService {
   }
 
   static async getPresignedUrl(fileName: string, mimeType: string) {
+    // S'assurer que le bucket existe
+    const exists = await minioClient.bucketExists(BUCKET)
+    if (!exists) {
+      await minioClient.makeBucket(BUCKET)
+    }
+
     const ext = fileName.split('.').pop()
     const key = `${uuidv4()}.${ext}`
     const url = await minioClient.presignedPutObject(BUCKET, key, 60 * 5)
-    return { url, key }
+    return { url, key, mimeType }
   }
 
   static async getPresignedViewUrl(key: string, expirySeconds = 300): Promise<string> {
+    // S'assurer que le bucket existe
+    const exists = await minioClient.bucketExists(BUCKET)
+    if (!exists) {
+      await minioClient.makeBucket(BUCKET)
+    }
+
     return minioClient.presignedGetObject(BUCKET, key, expirySeconds)
   }
 }

config/database.ts

@@ -9,10 +9,18 @@ const dbConfig = defineConfig({
       connection: {
         host: env.get('DB_HOST'),
         port: env.get('DB_PORT'),
-        user: env.get('DB_USER'),
+        user: env.get('DB_USERNAME'),
         password: env.get('DB_PASSWORD'),
         database: env.get('DB_DATABASE'),
       },
+      pool: {
+        min: 2, // Minimum de connexions actives
+        max: 10, // Maximum de connexions simultanées
+        acquireTimeoutMillis: 30000, // 30 secondes pour acquérir une connexion
+        createTimeoutMillis: 30000, // 30 secondes pour créer une connexion
+        idleTimeoutMillis: 30000, // 30 secondes avant de fermer une connexion inactive
+        createRetryIntervalMillis: 200, // 200ms entre les tentatives de création
+      },
       migrations: {
         naturalSort: true,
         paths: ['database/migrations'],

database/migrations/1761837732329_create_alter_articles_cover_image_to_texts_table.ts

@@ -0,0 +1,17 @@
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = 'articles'
+
+  async up() {
+    this.schema.alterTable(this.tableName, (table) => {
+      table.text('cover_image').nullable().alter()
+    })
+  }
+
+  async down() {
+    this.schema.alterTable(this.tableName, (table) => {
+      table.string('cover_image').nullable().alter()
+    })
+  }
+}

inertia/components/articles/article-card.tsx

@@ -18,6 +18,8 @@ export default function ArticleCard({ article }: ArticleCardProps) {
   const [imgError, setImgError] = useState(false)
   const showFallback = imgError || !article.coverImage
 
+  console.log('article.coverImage', article.coverImage)
+
   return (
     <div className="bg-white rounded-xl shadow flex flex-col h-full cursor-pointer overflow-hidden border-2 border-gray-200 transition-all duration-300 hover:border-indigo-600">
       <div