shorts-api/app/Controllers/Http/EpisodesController.ts

import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import Episode from 'App/Models/Episode'
import PaginationService from 'App/Services/PaginationService'
import { schema } from '@ioc:Adonis/Core/Validator'
import Decimal from 'decimal.js'
import Order from 'App/Models/Order'
import Drive from '@ioc:Adonis/Core/Drive'

export default class EpisodesController {
    private paginationService = new PaginationService(Episode)
    public async index({ request }: HttpContextContract) {
        return await this.paginationService.paginate(request.all())
    }

    public async store({ request, bouncer }: HttpContextContract) {
        await bouncer.authorize('admin')
        const data: any = await request.validate({
            schema: schema.create({
                seriesId: schema.number(),
                title: schema.string.optional(),
                episodeNum: schema.number(),
                description: schema.string.optional(),
                cover: schema.string.optional(),
                video: schema.string.optional(),
                playCount: schema.number.optional(),
                price: schema.string.optional()
            })
        })
        if (data.price) {
            data.price = new Decimal(data.price)
        }
        return await Episode.create(data)
    }

    public async show({ params, auth }: HttpContextContract) {
        const episode = await Episode.findOrFail(params.id)
        if (episode.price.eq(0)) {
            episode.purchased = true
        } else if (auth.user) {
            let order = await Order.query()
                .where('userId', auth.user.id)
                .where('type', 'series')
                .where('seriesId', episode.seriesId)
                .first()
            if (!order) {
                order = await Order.query()
                    .where('userId', auth.user.id)
                    .where('type', 'episode')
                    .where('episodeId', episode.id)
                    .first()
            }
            if (order) {
                episode.purchased = true
            }
        }
        if (episode.purchased) {
            episode.signedUrl = await Drive.getSignedUrl(episode.video!, {
                expiresIn: '1h'
            })
        }
        return episode
    }

    public async update({ request, params, bouncer }: HttpContextContract) {
        await bouncer.authorize('admin')
        const data: any = await request.validate({
            schema: schema.create({
                seriesId: schema.number.optional(),
                title: schema.string.optional(),
                episodeNum: schema.number.optional(),
                description: schema.string.optional(),
                cover: schema.string.optional(),
                video: schema.string.optional(),
                playCount: schema.number.optional(),
                price: schema.number.optional()
            })
        })
        if (data.price) {
            data.price = new Decimal(data.price)
        }
        const episode = await Episode.findOrFail(params.id)
        episode.merge(data)
        return await episode.save()
    }

    public async destroy({ params, bouncer }: HttpContextContract) {
        await bouncer.authorize('admin')
        const episode = await Episode.findOrFail(params.id)
        await episode.delete()
    }
}