59f81879d8
Ajoute une couche end-to-end où un Chromium drive la SPA + API ensemble
contre une DB Postgres séparée, avec Stripe entièrement mocké au niveau
API. 6 scénarios couverts (signup + onboarding + 4 sur le billing trial).
Architecture :
- DB `rubis_test_e2e` séparée, TRUNCATE entre tests (~50 ms reset)
- Routes test-only `/__test__/*` gated par NODE_ENV=test_e2e
(reset, install Stripe mock, fire webhook, lire org state, last-org)
- Stripe mocké via __setStripeForTests — pas d'appel réseau
- Playwright spawn API + SPA automatiquement (webServer config)
- CORS étendu à test_e2e pour le cross-origin localhost:5173 → :3333
Scénarios :
- signup.spec.ts : signup → onboarding 3 étapes → dashboard (assert rubis hero)
- billing-trial.spec.ts :
• démarrer essai 14j → redirect Stripe Checkout (mock)
• fallback Free 2 factures continue l'onboarding
• webhook checkout.completed → org en trialing + trial_ends_at
• retour ?trial=cancel après abandon
• inspection DB : stripeCustomerId posé après start-trial
Scripts :
- pnpm e2e (headless)
- pnpm e2e:headed (Chromium visible)
- pnpm e2e:ui (mode interactif Playwright)
- pnpm e2e:setup (crée + migre rubis_test_e2e via docker exec)
Documentation : docs/tech/e2e-tests.md — architecture, scénarios,
extensions, CI, troubleshooting.
Limites assumées :
- L'UI Stripe Checkout (3DS, formulaire CB) n'est pas testée — externe.
Pour ça : playbook manuel docs/tech/stripe-trial-e2e-playbook.md.
- Le rendu du banner "Essai Pro" n'est pas asserté en E2E à cause de
TanStack Query staleTime — couvert par les tests vitest à la place.
État global du chantier billing : 127 tests japa + 6 Playwright + 11
vitest = couverture multi-niveaux.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
551 lines
21 KiB
TypeScript
551 lines
21 KiB
TypeScript
/*
|
|
|--------------------------------------------------------------------------
|
|
| Routes file
|
|
|--------------------------------------------------------------------------
|
|
|
|
|
| Toutes les routes sont sous /api/v1/. Les groupes auth et account sont
|
|
| importés depuis le contrôleur généré par Tuyau pour garantir le contrat
|
|
| client typé (cf. docs/tech/backend.md §8).
|
|
|
|
|
*/
|
|
|
|
import { middleware } from '#start/kernel'
|
|
import router from '@adonisjs/core/services/router'
|
|
import { controllers } from '#generated/controllers'
|
|
|
|
/**
|
|
* Blog public — endpoints JSON consommés par apps/landing (Astro SSR).
|
|
* Pas auth, pas de paginiation V1 (volume cible <100 articles).
|
|
*/
|
|
const BlogController = () => import('#controllers/blog_controller')
|
|
const AdminPostsController = () => import('#controllers/admin_posts_controller')
|
|
const BlogUploadsController = () => import('#controllers/blog_uploads_controller')
|
|
const BrandController = () => import('#controllers/brand_controller')
|
|
const BankingController = () => import('#controllers/banking_controller')
|
|
const WebhooksPowensController = () => import('#controllers/webhooks_powens_controller')
|
|
const InvoiceSettingsController = () => import('#controllers/invoice_settings_controller')
|
|
const InvoiceThemesController = () => import('#controllers/invoice_themes_controller')
|
|
const TestE2eController = () => import('#controllers/test_e2e_controller')
|
|
|
|
|
|
router
|
|
.group(() => {
|
|
/**
|
|
* Health check — public, utilisé par les sondes K3s (startup/liveness/
|
|
* readiness) et le healthcheck Docker. Retourne 200 sans toucher la DB
|
|
* pour rester rapide ; la DB est implicitement vérifiée au boot par
|
|
* le init-container migrate.
|
|
*/
|
|
router.get('health', () => ({ status: 'ok', uptime: process.uptime() })).as('health')
|
|
|
|
/**
|
|
* Sentry test trigger — endpoint debug qui throw délibérément pour
|
|
* vérifier l'E2E observability (capture, release tag, sourcemaps,
|
|
* user context). Disponible UNIQUEMENT si NODE_ENV !== 'production'
|
|
* OU si DEBUG_SENTRY_TEST=true. À retirer une fois l'intégration
|
|
* validée sur la prod.
|
|
*/
|
|
if (process.env.NODE_ENV !== 'production' || process.env.DEBUG_SENTRY_TEST === 'true') {
|
|
router.get('_debug/sentry-test', () => {
|
|
throw new Error(`Sentry test from rubis-api — ${new Date().toISOString()}`)
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Blog — endpoints JSON publics consommés par apps/landing en SSR.
|
|
* Cf. apps/landing/src/pages/blog/*.astro pour la consommation et
|
|
* apps/api/app/controllers/blog_controller.ts pour l'implémentation.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [BlogController, 'index']).as('index')
|
|
router.get(':slug', [BlogController, 'show']).as('show')
|
|
})
|
|
.prefix('posts')
|
|
.as('posts')
|
|
|
|
/**
|
|
* Images servies depuis MinIO. Public, cache infini (le filename est
|
|
* un UUID immuable, chaque upload = nouvelle URL).
|
|
*
|
|
* Deux scopes :
|
|
* - `/uploads/blog/:filename` — hero images d'articles
|
|
* - `/uploads/brand-logos/:filename` — logos de marque blanche (Business)
|
|
*
|
|
* Le BlogUploadsController.show est en fait scope-agnostic (délègue à
|
|
* media_storage.readMedia), donc on le réutilise pour les deux. Un
|
|
* controller dédié serait du boilerplate inutile vu que la logique est
|
|
* 100% dans le service.
|
|
*/
|
|
router
|
|
.get('uploads/blog/:filename', [BlogUploadsController, 'show'])
|
|
.as('uploads.blog.show')
|
|
router
|
|
.get('uploads/brand-logos/:filename', [BrandController, 'showLogo'])
|
|
.as('uploads.brand_logos.show')
|
|
|
|
/**
|
|
* Banking — callback Powens. Public parce que le navigateur du user
|
|
* arrive ici en GET après que Powens ait fini la webview, sans
|
|
* Bearer token. La sécurité est portée par le `state` HMAC signé
|
|
* dans l'URL (verifié dans le service). Redirige toujours en 302
|
|
* vers le SPA avec ?banking=connected|error.
|
|
*/
|
|
router
|
|
.get('banking/powens/callback', [BankingController, 'callback'])
|
|
.as('banking.powens.callback')
|
|
|
|
/**
|
|
* Banking status — public. Renvoie `{ enabled }` pour que le SPA
|
|
* sache s'il doit afficher la section banque dans /parametres.
|
|
* Pas de Bearer requis : c'est un flag d'env, pas une info user.
|
|
*/
|
|
router
|
|
.get('banking/status', [BankingController, 'status'])
|
|
.as('banking.status')
|
|
|
|
/**
|
|
* Banking — webhook Powens. Public (auth via HMAC sur le body).
|
|
* Reçoit CONNECTION_SYNCED, NEW_TRANSACTIONS, CONNECTION_ERROR…
|
|
* Vérification de la signature avec POWENS_WEBHOOK_SECRET dans
|
|
* le controller.
|
|
*/
|
|
router
|
|
.post('webhooks/powens', [WebhooksPowensController, 'handle'])
|
|
.as('webhooks.powens')
|
|
})
|
|
.prefix('/api/v1')
|
|
|
|
/**
|
|
* Routes test-only — accessibles UNIQUEMENT si `NODE_ENV=test_e2e`.
|
|
* Le controller throw 404 sur tout autre env, donc même si quelqu'un
|
|
* essaie d'appeler ces routes en prod, il aura un 404 propre. Aucune
|
|
* route auth.
|
|
*
|
|
* Sert à Playwright pour reset la DB, injecter des mocks Stripe et
|
|
* simuler des webhooks sans signer manuellement.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.post('reset', [TestE2eController, 'reset'])
|
|
router.post('stripe/mock', [TestE2eController, 'installStripeMock'])
|
|
router.post('stripe/webhook', [TestE2eController, 'fireWebhook'])
|
|
router.get('state/org/:id', [TestE2eController, 'orgState'])
|
|
router.get('state/last-org', [TestE2eController, 'lastOrg'])
|
|
})
|
|
.prefix('/__test__')
|
|
|
|
router
|
|
.group(() => {
|
|
/**
|
|
* Auth — public. /refresh utilise le cookie httpOnly `rubis_refresh`
|
|
* posé par signup/login pour émettre une nouvelle AuthSession.
|
|
* /google/* → SSO via Ally, callback pose aussi le refresh cookie.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.post('signup', [controllers.NewAccount, 'store']).as('signup')
|
|
router.post('login', [controllers.AccessTokens, 'store']).as('login')
|
|
router.post('refresh', [controllers.Refresh, 'handle']).as('refresh')
|
|
router
|
|
.get('google/redirect', [controllers.AuthGoogle, 'redirect'])
|
|
.as('google.redirect')
|
|
router
|
|
.get('google/callback', [controllers.AuthGoogle, 'callback'])
|
|
.as('google.callback')
|
|
router
|
|
.get('microsoft/redirect', [controllers.AuthMicrosoft, 'redirect'])
|
|
.as('microsoft.redirect')
|
|
router
|
|
.get('microsoft/callback', [controllers.AuthMicrosoft, 'callback'])
|
|
.as('microsoft.callback')
|
|
})
|
|
.prefix('auth')
|
|
.as('auth')
|
|
|
|
/**
|
|
* Check-in in-app — auth requise. La modale au login liste les factures
|
|
* en attente de confirmation et permet à l'user d'y répondre directement
|
|
* sans passer par l'email.
|
|
*
|
|
* IMPORTANT : ce groupe doit être déclaré AVANT le groupe public à token,
|
|
* sinon `/checkin/:token/pending` mange `/checkin/inapp/pending` (token
|
|
* littéral = "inapp") et redirige vers le SPA en 302.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router
|
|
.get('pending', [controllers.Checkin, 'inappPending'])
|
|
.as('pending')
|
|
router
|
|
.post(':invoiceId/paid', [controllers.Checkin, 'inappRespondPaid'])
|
|
.as('paid')
|
|
.where('invoiceId', router.matchers.uuid())
|
|
router
|
|
.post(':invoiceId/pending', [controllers.Checkin, 'inappRespondPending'])
|
|
.as('pending.post')
|
|
.where('invoiceId', router.matchers.uuid())
|
|
})
|
|
.prefix('checkin/inapp')
|
|
.as('checkin.inapp')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Check-in — public (pas d'auth Bearer). Token signé en URL,
|
|
* lookup hash en DB. Redirige vers le SPA avec ?checkin=... pour
|
|
* que l'UI affiche un toast.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router
|
|
.get(':token/paid', [controllers.Checkin, 'respondPaid'])
|
|
.as('paid')
|
|
router
|
|
.get(':token/pending', [controllers.Checkin, 'respondPending'])
|
|
.as('pending')
|
|
})
|
|
.prefix('checkin')
|
|
.as('checkin')
|
|
|
|
/**
|
|
* Compte courant — auth requise.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('profile', [controllers.Profile, 'show']).as('profile.show')
|
|
router.patch('profile', [controllers.Profile, 'update']).as('profile.update')
|
|
router.post('logout', [controllers.AccessTokens, 'destroy']).as('logout')
|
|
})
|
|
.prefix('account')
|
|
.as('account')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Organisation rattachée à l'utilisateur courant — auth requise.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('me', [controllers.Organizations, 'show']).as('show')
|
|
router.patch('me', [controllers.Organizations, 'update']).as('update')
|
|
|
|
/**
|
|
* Settings de facturation native (éditeur de factures). Aucun gating
|
|
* de plan : toute org peut paramétrer sa facturation. Le gating
|
|
* porte sur la création (`canCreateInvoices`).
|
|
*
|
|
* - GET /me/invoice-settings → settings + valeurs résolues
|
|
* - PATCH /me/invoice-settings → maj partielle (null = reset)
|
|
*/
|
|
router
|
|
.get('me/invoice-settings', [InvoiceSettingsController, 'show'])
|
|
.as('invoice-settings.show')
|
|
router
|
|
.patch('me/invoice-settings', [InvoiceSettingsController, 'update'])
|
|
.as('invoice-settings.update')
|
|
})
|
|
.prefix('organizations')
|
|
.as('organizations')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Thèmes de facture disponibles — auth requise. Retourne la liste des
|
|
* 4 templates pré-faits avec leurs métadonnées (slug + name + description)
|
|
* pour peupler la galerie de sélection dans l'éditeur et /parametres/facturation.
|
|
* Le rendu lui-même vit côté SPA (packages/ui/invoice-templates).
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [InvoiceThemesController, 'index']).as('index')
|
|
})
|
|
.prefix('invoice-themes')
|
|
.as('invoice-themes')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Marque blanche — auth + plan Business obligatoires. Le middleware
|
|
* `assertBusinessPlan` throw 403 `business_plan_required` que le SPA
|
|
* catch pour afficher l'upsell card propre.
|
|
*
|
|
* - GET /brand → settings + tokens résolus + defaults
|
|
* - PATCH /brand → maj partielle (null = reset au default)
|
|
* - POST /brand/logo → upload multipart, écrase l'ancien sur MinIO
|
|
* - DELETE /brand/logo → retire le logo (retour wordmark Rubis)
|
|
* - POST /brand/test → envoie un mail de test à l'user pour preview
|
|
*
|
|
* Note : la route publique de lecture du logo (sans auth) est dans le
|
|
* groupe public au-dessus (`uploads/brand-logos/:filename`), parce que
|
|
* les emails sortants vers les clients doivent pouvoir charger l'image
|
|
* sans token.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [BrandController, 'show']).as('show')
|
|
router.patch('', [BrandController, 'update']).as('update')
|
|
router.post('logo', [BrandController, 'uploadLogo']).as('logo.upload')
|
|
router.delete('logo', [BrandController, 'deleteLogo']).as('logo.delete')
|
|
router.post('test', [BrandController, 'sendTest']).as('test')
|
|
})
|
|
.prefix('brand')
|
|
.as('brand')
|
|
.use([middleware.auth(), middleware.assertBusinessPlan()])
|
|
|
|
/**
|
|
* Banking — agrégation bancaire Powens (Pro + Business uniquement).
|
|
* Le middleware `assertPaidPlan` throw 403 `paid_plan_required` que
|
|
* le SPA catch pour afficher l'upsell sur Free.
|
|
*
|
|
* La route callback (`GET /banking/powens/callback`) est dans le
|
|
* groupe public au-dessus parce que Powens redirige le navigateur
|
|
* du user sans Bearer token (state HMAC signé en remplacement).
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.post('powens/init', [BankingController, 'init']).as('powens.init')
|
|
router.get('connections', [BankingController, 'index']).as('connections.index')
|
|
router
|
|
.delete('connections/:id', [BankingController, 'destroy'])
|
|
.as('connections.destroy')
|
|
.where('id', router.matchers.uuid())
|
|
router.get('settings', [BankingController, 'showSettings']).as('settings.show')
|
|
router.patch('settings', [BankingController, 'updateSettings']).as('settings.update')
|
|
})
|
|
.prefix('banking')
|
|
.as('banking')
|
|
.use([middleware.auth(), middleware.assertPaidPlan()])
|
|
|
|
/**
|
|
* Clients — auth requise, scope par organization de l'utilisateur courant.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [controllers.Clients, 'index']).as('index')
|
|
router.post('', [controllers.Clients, 'store']).as('store')
|
|
router.get(':id', [controllers.Clients, 'show']).as('show').where('id', router.matchers.uuid())
|
|
router
|
|
.get(':id/timeseries', [controllers.Clients, 'timeseries'])
|
|
.as('timeseries')
|
|
.where('id', router.matchers.uuid())
|
|
router.patch(':id', [controllers.Clients, 'update']).as('update').where('id', router.matchers.uuid())
|
|
})
|
|
.prefix('clients')
|
|
.as('clients')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* IA — auth requise. Génération de templates de relance avec Mistral
|
|
* pour le wizard de création de plan custom.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.post('generate-relance', [controllers.Ai, 'generateRelance']).as('generate-relance')
|
|
})
|
|
.prefix('ai')
|
|
.as('ai')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Plans — auth requise. Lookup par slug (stable et lisible :
|
|
* /parametres/plans/standard-30j). POST = création d'un plan custom,
|
|
* slug auto-généré depuis le name.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [controllers.Plans, 'index']).as('index')
|
|
router.post('', [controllers.Plans, 'store']).as('store')
|
|
router.get(':slug', [controllers.Plans, 'show']).as('show')
|
|
router.patch(':slug', [controllers.Plans, 'update']).as('update')
|
|
})
|
|
.prefix('plans')
|
|
.as('plans')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Billing / Stripe — auth requise pour subscription/checkout/portal.
|
|
* Le webhook est PUBLIC (signature Stripe vérifiée côté handler).
|
|
*/
|
|
router
|
|
.post('billing/webhook', [controllers.Billing, 'webhook'])
|
|
.as('billing.webhook')
|
|
|
|
router
|
|
.group(() => {
|
|
router
|
|
.get('subscription', [controllers.Billing, 'subscription'])
|
|
.as('subscription')
|
|
router
|
|
.post('start-trial', [controllers.Billing, 'startTrial'])
|
|
.as('start_trial')
|
|
router
|
|
.post('checkout', [controllers.Billing, 'checkout'])
|
|
.as('checkout')
|
|
router.post('portal', [controllers.Billing, 'portal']).as('portal')
|
|
router
|
|
.post('reactivate', [controllers.Billing, 'reactivate'])
|
|
.as('reactivate')
|
|
})
|
|
.prefix('billing')
|
|
.as('billing')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Demo — réservé aux admins Rubis (outil de prospection commerciale).
|
|
* Gating fin :
|
|
* - GET /state : auth seul, parce que `DemoClock` dans `AppLayout`
|
|
* fetch sur chaque page pour tous les users. Un non-admin reçoit
|
|
* `{ active: false }` (son org n'est jamais en mode démo) — pas
|
|
* de leak, juste un payload neutre.
|
|
* - GET /inbox + POST /start, /end, /tick : auth + admin. Mutations
|
|
* et lecture des emails capturés (potentiellement sensibles).
|
|
*
|
|
* UI : la section "Démonstration" dans /parametres est aussi gated
|
|
* sur `user.isAdmin` (cf. parametres.tsx).
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('state', [controllers.Demo, 'state']).as('state')
|
|
})
|
|
.prefix('demo')
|
|
.as('demo')
|
|
.use(middleware.auth())
|
|
|
|
router
|
|
.group(() => {
|
|
router.post('start', [controllers.Demo, 'start']).as('start')
|
|
router.post('end', [controllers.Demo, 'end']).as('end')
|
|
router.post('tick', [controllers.Demo, 'tick']).as('tick')
|
|
router.get('inbox', [controllers.Demo, 'inbox']).as('inbox')
|
|
})
|
|
.prefix('demo')
|
|
.as('demo.admin')
|
|
.use([middleware.auth(), middleware.admin()])
|
|
|
|
/**
|
|
* Dashboard — auth requise. Calculs agrégés on-the-fly (pas de cache V1).
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('kpis', [controllers.Dashboard, 'kpis']).as('kpis')
|
|
router.get('activity', [controllers.Dashboard, 'activity']).as('activity')
|
|
router.get('top-late', [controllers.Dashboard, 'topLate']).as('top-late')
|
|
router
|
|
.get('timeseries', [controllers.Dashboard, 'timeseries'])
|
|
.as('timeseries')
|
|
})
|
|
.prefix('dashboard')
|
|
.as('dashboard')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Invoices — auth requise. Ordre IMPORTANT : les routes statiques
|
|
* (/upload, /counts, /import-batch/...) sont déclarées AVANT /:id
|
|
* sinon `:id` matche les segments littéraux.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router.get('', [controllers.Invoices, 'index']).as('index')
|
|
router.post('', [controllers.Invoices, 'store']).as('store')
|
|
router.get('counts', [controllers.Invoices, 'counts']).as('counts')
|
|
|
|
/**
|
|
* Éditeur de factures natif :
|
|
* - POST /invoices/native → création depuis l'éditeur (séquence strict)
|
|
* - POST /invoices/preview-pdf → preview PDF sans persister
|
|
*
|
|
* Déclarés AVANT /:id pour ne pas être mangés par le matcher uuid.
|
|
*/
|
|
router.post('native', [controllers.Invoices, 'storeNative']).as('storeNative')
|
|
router.post('preview-pdf', [controllers.Invoices, 'previewPdf']).as('previewPdf')
|
|
|
|
// OCR / Import batch (cf. ImportBatchesController)
|
|
router.post('upload', [controllers.ImportBatches, 'upload']).as('upload')
|
|
router
|
|
.get('import-batch/:id', [controllers.ImportBatches, 'show'])
|
|
.as('import-batch.show')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.get('import-batch/:id/drafts/:draftId/pdf', [
|
|
controllers.ImportBatches,
|
|
'draftPdf',
|
|
])
|
|
.as('import-batch.draft.pdf')
|
|
.where('id', router.matchers.uuid())
|
|
.where('draftId', router.matchers.uuid())
|
|
router
|
|
.post('import-batch/:id/drafts/:draftId/validate', [
|
|
controllers.ImportBatches,
|
|
'validateDraft',
|
|
])
|
|
.as('import-batch.draft.validate')
|
|
.where('id', router.matchers.uuid())
|
|
.where('draftId', router.matchers.uuid())
|
|
router
|
|
.post('import-batch/:id/drafts/:draftId/skip', [
|
|
controllers.ImportBatches,
|
|
'skipDraft',
|
|
])
|
|
.as('import-batch.draft.skip')
|
|
.where('id', router.matchers.uuid())
|
|
.where('draftId', router.matchers.uuid())
|
|
router
|
|
.delete('import-batch/:id', [controllers.ImportBatches, 'destroy'])
|
|
.as('import-batch.destroy')
|
|
.where('id', router.matchers.uuid())
|
|
|
|
router.get(':id', [controllers.Invoices, 'show']).as('show').where('id', router.matchers.uuid())
|
|
router
|
|
.get(':id/pdf', [controllers.Invoices, 'pdf'])
|
|
.as('pdf')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.post(':id/mark-paid', [controllers.Invoices, 'markPaid'])
|
|
.as('mark-paid')
|
|
.where('id', router.matchers.uuid())
|
|
})
|
|
.prefix('invoices')
|
|
.as('invoices')
|
|
.use(middleware.auth())
|
|
|
|
/**
|
|
* Admin — édition du blog. Toutes auth + admin (cf. is_admin sur users).
|
|
* Cf. apps/web/src/routes/_app/admin.* pour le SPA consommateur.
|
|
*/
|
|
router
|
|
.group(() => {
|
|
router
|
|
.group(() => {
|
|
router.get('', [AdminPostsController, 'index']).as('index')
|
|
router.post('', [AdminPostsController, 'store']).as('store')
|
|
router.get('suggest-slug', [AdminPostsController, 'suggestSlug']).as('suggest-slug')
|
|
router
|
|
.get(':id', [AdminPostsController, 'show'])
|
|
.as('show')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.patch(':id', [AdminPostsController, 'update'])
|
|
.as('update')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.post(':id/publish', [AdminPostsController, 'publish'])
|
|
.as('publish')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.post(':id/unpublish', [AdminPostsController, 'unpublish'])
|
|
.as('unpublish')
|
|
.where('id', router.matchers.uuid())
|
|
router
|
|
.delete(':id', [AdminPostsController, 'destroy'])
|
|
.as('destroy')
|
|
.where('id', router.matchers.uuid())
|
|
})
|
|
.prefix('posts')
|
|
.as('posts')
|
|
|
|
router.post('uploads', [BlogUploadsController, 'store']).as('uploads.store')
|
|
})
|
|
.prefix('admin')
|
|
.as('admin')
|
|
.use(middleware.auth())
|
|
.use(middleware.admin())
|
|
})
|
|
.prefix('/api/v1')
|