✨ Update Dependencies and Enhance Article Management

- Update package.json and package-lock.json to include new dependencies: @tanstack/react-query, date-fns, lucide-react, react-syntax-highlighter, socket.io, and wavesurfer.js.
- Refactor ArticlesController to improve article creation logic and utilize enums for article status.
- Enhance HomeController and ProfileController to filter articles based on their status.
- Update Vite configuration to include a proxy for socket.io connections.
- Modify article model to improve tag handling and slug generation.
- Add new routes for message and discussion management, enhancing application functionality.

Author: BrightkyEfoo

app/controllers/articles_controller.ts

@@ -1,9 +1,9 @@
-import { HttpContext } from '@adonisjs/core/http'
-import { articleValidator } from '#validators/article_validator'
+import { ArticleStatus } from '#enums/article_status'
 import Article from '#models/article'
-import { DateTime } from 'luxon'
 import ArticleStatsService from '#services/article_stats_service'
-import { ArticleStatus } from '#enums/article_status'
+import { articleValidator } from '#validators/article_validator'
+import { HttpContext } from '@adonisjs/core/http'
+import { DateTime } from 'luxon'
 
 export default class ArticlesController {
   async index({ inertia, request }: HttpContext) {
@@ -25,22 +25,20 @@ export default class ArticlesController {
 
   async store({ request, auth, response }: HttpContext) {
     const data = await articleValidator.validate(request.all())
-    const article = new Article()
 
-    article.title = data.title
-    article.content = data.content
-    article.excerpt = data.excerpt
-    article.status = data.status as ArticleStatus
-    article.authorId = auth.user!.id
+    const payload: Partial<Article> = { ...data, authorId: auth.user!.id }
+
     if (data.status === ArticleStatus.PUBLISHED) {
-      article.publishedAt = DateTime.now()
+      payload.publishedAt = DateTime.now()
     }
-    article.coverImage = data.coverImage || null
-    article.canonicalUrl = data.canonicalUrl || null
-    article.tags = data.tags || []
 
-    await article.generateSlug()
-    await article.save()
+    payload.slug = Article.generateSlug(data.title)
+
+    console.log('payload', payload)
+
+    const article = await Article.create(payload)
+
+    console.log('article', article)
 
     return response.redirect().toRoute('articles.show', { slug: article.slug })
   }

app/controllers/discussions_controller.ts

@@ -0,0 +1,89 @@
+import BannedUser from '#models/banned_user'
+import Discussion from '#models/discussion'
+import Message from '#models/message'
+import type { HttpContext } from '@adonisjs/core/http'
+
+export default class DiscussionsController {
+  async index({ inertia, auth }: HttpContext) {
+    await auth.check()
+    // Liste des discussions publiques
+    const discussions = await Discussion.query()
+      .preload('author')
+      .where('is_public', true)
+      .orderBy('created_at', 'desc')
+    return inertia.render('discussions/index', { discussions })
+  }
+
+  async show({ inertia, params, auth }: HttpContext) {
+    await auth.check()
+    // Accès à une discussion (vérifier ban)
+    const discussion = await Discussion.query()
+      .where('id', params.id)
+      .preload('author')
+      .firstOrFail()
+    // Vérifier si banni
+    if (auth.user) {
+      const ban = await BannedUser.query()
+        .where('user_id', auth.user.id)
+        .where('discussion_id', discussion.id)
+        .first()
+      if (ban) {
+        return inertia.render('errors/banned', { reason: ban.reason })
+      }
+    }
+    // Charger les messages (pagination à ajouter plus tard)
+    const messages = await Message.query()
+      .where('discussion_id', discussion.id)
+      .orderBy('created_at', 'asc')
+      .preload('sender')
+    return inertia.render('discussions/show', { discussion, messages })
+  }
+
+  async create({ inertia, auth }: HttpContext) {
+    await auth.check()
+    return inertia.render('discussions/create')
+  }
+
+  async store({ request, auth, response }: HttpContext) {
+    await auth.check()
+    const { title, banner } = request.only(['title', 'banner'])
+    const discussion = await Discussion.create({
+      title,
+      banner,
+      authorId: auth.user!.id,
+      isPublic: true,
+    })
+    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)
+    await discussion.delete()
+    return response.redirect().toRoute('discussions.index')
+  }
+
+  async ban({ params, request, auth, response }: HttpContext) {
+    if (auth.user?.role !== 'ADMIN') {
+      return response.unauthorized('Réservé admin')
+    }
+    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')
+    }
+    await BannedUser.create({
+      userId,
+      discussionId,
+      adminId: auth.user.id,
+      reason: reason || null,
+    })
+    return response.ok({ success: true })
+  }
+}

app/controllers/home_controller.ts

@@ -1,9 +1,12 @@
-import { HttpContext } from '@adonisjs/core/http'
+import { ArticleStatus } from '#enums/article_status'
 import Article from '#models/article'
+import { HttpContext } from '@adonisjs/core/http'
 
 export default class HomeController {
   async index({ inertia }: HttpContext) {
-    const articles = await Article.query().where('is_published', true).preload('author')
+    const articles = await Article.query()
+      .where('status', ArticleStatus.PUBLISHED)
+      .preload('author')
 
     return inertia.render('home', {
       stats: {

app/controllers/messages_controller.ts

@@ -0,0 +1,81 @@
+import Message from '#models/message'
+import { getIO } from '#start/socket'
+import type { HttpContext } from '@adonisjs/core/http'
+
+export default class MessagesController {
+  async store({ request, auth, response }: HttpContext) {
+    const { discussionId, type, content, fileUrl, tempId } = request.only([
+      'discussionId',
+      'type',
+      'content',
+      'fileUrl',
+      'tempId',
+    ])
+    // fileUrl est fourni par le frontend après upload via presigned URL
+    const message = await Message.create({
+      discussionId,
+      senderId: auth.user!.id,
+      type,
+      content,
+      fileUrl: fileUrl || null,
+      status: 'normal',
+      history: [],
+    })
+    await message.load('sender')
+    const sender = message.sender?.toJSON()
+    const messageWithTempId = { ...message.toJSON(), tempId, sender }
+    getIO()?.to(`discussion:${discussionId}`).emit('message:new', messageWithTempId)
+    return response.ok(messageWithTempId)
+  }
+
+  async update({ params, request, auth, response }: HttpContext) {
+    const message = await Message.findOrFail(params.id)
+    if (message.senderId !== auth.user!.id) {
+      return response.unauthorized('Non autorisé')
+    }
+    // Historique
+    const oldVersion = {
+      content: message.content,
+      fileUrl: message.fileUrl,
+      updatedAt: message.updatedAt,
+    }
+    const history = message.history || []
+    history.push(oldVersion)
+    message.merge({
+      content: request.input('content'),
+      status: 'edited',
+      history,
+    })
+    await message.save()
+    // Émettre l'événement socket.io
+    getIO()?.to(`discussion:${message.discussionId}`).emit('message:edit', message)
+    return response.ok(message)
+  }
+
+  async destroy({ params, auth, response }: HttpContext) {
+    const message = await Message.findOrFail(params.id)
+    // Suppression par sender ou admin (à vérifier dans la logique réelle)
+    if (message.senderId === auth.user!.id) {
+      message.status = 'deleted'
+      message.deletedBy = 'sender'
+    } else if (auth.user!.role === 'ADMIN') {
+      message.status = 'deleted'
+      message.deletedBy = 'admin'
+    } else {
+      return response.unauthorized('Non autorisé')
+    }
+    await message.save()
+    // Émettre l'événement socket.io
+    getIO()?.to(`discussion:${message.discussionId}`).emit('message:delete', message)
+    return response.ok(message)
+  }
+
+  // Endpoint pour l'historique d'un message (admin)
+  async history({ params, auth, response }: HttpContext) {
+    if (auth.user?.role !== 'ADMIN') {
+      return response.unauthorized('Réservé admin')
+    }
+    const message = await Message.findOrFail(params.id)
+    return response.ok({ history: message.history || [] })
+  }
+}

app/controllers/profile_controller.ts

@@ -1,13 +1,14 @@
-import { HttpContext } from '@adonisjs/core/http'
-import User from '#models/user'
+import { ArticleStatus } from '#enums/article_status'
 import Article from '#models/article'
+import User from '#models/user'
+import { HttpContext } from '@adonisjs/core/http'
 
 export default class ProfileController {
   async show({ params, inertia }: HttpContext) {
     const user = await User.findByOrFail('username', params.username.replace('@', ''))
     const articles = await Article.query()
       .where('author_id', user.id)
-      .where('is_published', true)
+      .where('status', ArticleStatus.PUBLISHED)
       .orderBy('created_at', 'desc')
       .preload('author')
 

app/models/article.ts

@@ -1,9 +1,9 @@
-import { DateTime } from 'luxon'
+import { ArticleStatus } from '#enums/article_status'
+import User from '#models/user'
+import string from '@adonisjs/core/helpers/string'
 import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
 import type { BelongsTo } from '@adonisjs/lucid/types/relations'
-import string from '@adonisjs/core/helpers/string'
-import User from '#models/user'
-import { ArticleStatus } from '#enums/article_status'
+import { DateTime } from 'luxon'
 
 export default class Article extends BaseModel {
   @column({ isPrimary: true })
@@ -45,11 +45,14 @@ export default class Article extends BaseModel {
   @column()
   declare canonicalUrl: string | null
 
-  @column()
-  declare tags: string[] | null
+  @column({
+    prepare: (value: string[] | string | null) => (Array.isArray(value) ? value.join(',') : value),
+    consume: (value: string | null) => (value ? value.split(',') : []),
+  })
+  declare tags: string[]
 
   // Generate slug before saving
-  public async generateSlug() {
-    this.slug = string.slug(this.title)
+  public static generateSlug(title: string) {
+    return string.slug(title)
   }
 }

app/models/banned_user.ts

@@ -0,0 +1,37 @@
+import Discussion from '#models/discussion'
+import User from '#models/user'
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import { DateTime } from 'luxon'
+
+export default class BannedUser extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare userId: number
+
+  @column()
+  declare discussionId: number
+
+  @column()
+  declare adminId: number
+
+  @column()
+  declare reason: string | null
+
+  @belongsTo(() => User, { foreignKey: 'userId' })
+  declare user: BelongsTo<typeof User>
+
+  @belongsTo(() => Discussion)
+  declare discussion: BelongsTo<typeof Discussion>
+
+  @belongsTo(() => User, { foreignKey: 'adminId' })
+  declare admin: BelongsTo<typeof User>
+
+  @column.dateTime({ autoCreate: true })
+  declare createdAt: DateTime
+
+  @column.dateTime({ autoCreate: true, autoUpdate: true })
+  declare updatedAt: DateTime
+}

app/models/discussion.ts

@@ -0,0 +1,38 @@
+import BannedUser from '#models/banned_user'
+import Message from '#models/message'
+import User from '#models/user'
+import { BaseModel, belongsTo, column, hasMany } from '@adonisjs/lucid/orm'
+import type { BelongsTo, HasMany } from '@adonisjs/lucid/types/relations'
+import { DateTime } from 'luxon'
+
+export default class Discussion extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare title: string
+
+  @column()
+  declare banner: string | null
+
+  @column()
+  declare authorId: number
+
+  @column()
+  declare isPublic: boolean
+
+  @belongsTo(() => User, { foreignKey: 'authorId' })
+  declare author: BelongsTo<typeof User>
+
+  @hasMany(() => Message)
+  declare messages: HasMany<typeof Message>
+
+  @hasMany(() => BannedUser)
+  declare bans: HasMany<typeof BannedUser>
+
+  @column.dateTime({ autoCreate: true })
+  declare createdAt: DateTime
+
+  @column.dateTime({ autoCreate: true, autoUpdate: true })
+  declare updatedAt: DateTime
+}