.

app/Controllers/Http/BannersController.ts

@@ -0,0 +1,56 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import Banner from 'App/Models/Banner'
+import PaginationService from 'App/Services/PaginationService'
+import { schema } from '@ioc:Adonis/Core/Validator'
+
+export default class BannersController {
+    private paginationService = new PaginationService(Banner)
+    public async index({ request }: HttpContextContract) {
+        const { page, perPage } = request.qs()
+        const pagination = await this.paginationService.paginate(request.all())
+        return pagination
+    }
+
+    public async store({ request, bouncer }: HttpContextContract) {
+        await bouncer.authorize('admin')
+        const validationSchema = schema.create({
+            title: schema.string(),
+            img: schema.string(),
+            link: schema.string.optional(),
+            desc: schema.string.optional()
+        })
+        const validatedData = await request.validate({
+            schema: validationSchema
+        })
+        const banner = await Banner.create(validatedData)
+        return banner
+    }
+
+    public async show({ params }: HttpContextContract) {
+        const banner = await Banner.findOrFail(params.id)
+        return banner
+    }
+
+    public async update({ request, params, bouncer }: HttpContextContract) {
+        await bouncer.authorize('admin')
+        const validationSchema = schema.create({
+            title: schema.string.optional(),
+            img: schema.string.optional(),
+            link: schema.string.optional(),
+            desc: schema.string.optional()
+        })
+        const validatedData = await request.validate({
+            schema: validationSchema
+        })
+        const banner = await Banner.findOrFail(params.id)
+        banner.merge(validatedData)
+        await banner.save()
+        return banner
+    }
+
+    public async destroy({ params, bouncer }: HttpContextContract) {
+        await bouncer.authorize('admin')
+        const banner = await Banner.findOrFail(params.id)
+        await banner.delete()
+    }
+}

app/Controllers/Http/FilesController.ts

@@ -2,11 +2,13 @@ import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 import STSClient, { AssumeRoleRequest } from '@alicloud/sts20150401'
 import { Config } from '@alicloud/openapi-client'
 import { RuntimeOptions } from '@alicloud/tea-util'
+import Drive from '@ioc:Adonis/Core/Drive'
 export default class FilesController {
     public async store({ request }: HttpContextContract) {
         const file = request.file('file')
         await file?.moveToDisk('./uploads', { visibility: 'public' })
         // const signedUrl = await Drive.getSignedUrl(file?.fileName!)
+        await Drive.setVisibility(file?.fileName!, 'public')
         return { url: file?.filePath }
     }
 

app/Controllers/Http/OrdersController.ts

@@ -55,40 +55,36 @@ export default class OrdersController {
 
         const userBalance = await UserBalanceService.getBalance(user.id)
         const order = new Order()
-
-        order.merge(data)
         order.userId = user.id
 
-        let price: Decimal
-
         if (data.seriesId) {
             const series = await Series.findOrFail(data.seriesId)
             if (series.price.comparedTo(userBalance.balance) > 0) {
                 throw new Error('not enough balance')
             }
-            price = series.price
+            order.price = series.price
+            order.type = OrderType.Series
+            order.seriesId = data.seriesId
         } else {
             const episode = await Episode.findOrFail(data.episodeId)
             if (episode.price.comparedTo(userBalance.balance) > 0) {
                 throw new Error('not enough balance')
             }
-            price = episode.price
+            order.price = episode.price
+            order.type = OrderType.Episode
+            order.seriesId = episode.seriesId
+            order.episodeId = data.episodeId!
         }
 
         await UserBalanceService.modifiyBalance({
             userId: user.id,
-            amount: price.negated(),
+            amount: order.price.negated(),
             type: BalanceRecordType.Purchase,
             seriesId: data.seriesId,
             episodeId: data.episodeId
         })
 
-        return await Order.create({
-            userId: user.id,
-            price,
-            type: data.seriesId ? OrderType.Series : OrderType.Episode,
-            ...data
-        })
+        return await order.save()
     }
 
     public async show({ params }: HttpContextContract) {

app/Models/Banner.ts

@@ -0,0 +1,25 @@
+import { DateTime } from 'luxon'
+import { BaseModel, column } from '@ioc:Adonis/Lucid/Orm'
+
+export default class Banner extends BaseModel {
+    @column({ isPrimary: true })
+    public id: number
+
+    @column.dateTime({ autoCreate: true })
+    public createdAt: DateTime
+
+    @column.dateTime({ autoCreate: true, autoUpdate: true })
+    public updatedAt: DateTime
+
+    @column()
+    public title: string
+
+    @column()
+    public img: string
+
+    @column()
+    public link: string
+
+    @column()
+    public desc: string
+}

database/migrations/1702024124942_banners.ts

@@ -0,0 +1,21 @@
+import BaseSchema from '@ioc:Adonis/Lucid/Schema'
+
+export default class extends BaseSchema {
+    protected tableName = 'banners'
+
+    public async up() {
+        this.schema.createTable(this.tableName, (table) => {
+            table.increments('id')
+            table.datetime('created_at', { useTz: true })
+            table.datetime('updated_at', { useTz: true })
+            table.string('title').notNullable()
+            table.string('img').notNullable()
+            table.string('link').notNullable()
+            table.string('desc').notNullable()
+        })
+    }
+
+    public async down() {
+        this.schema.dropTable(this.tableName)
+    }
+}

start/routes.ts

@@ -69,6 +69,7 @@ Route.group(() => {
     Route.resource('series', 'SeriesController').apiOnly()
     Route.resource('episodes', 'EpisodesController').apiOnly()
     Route.resource('categories', 'CategoriesController').apiOnly()
+    Route.resource('banners', 'BannersController').apiOnly()
 
     Route.group(() => {
         Route.group(() => {