P42_API/api/sims.js

import { authGuard } from '../authGuard.js'
import { UUID } from 'uuidv7'

export const mappings = [
    { method: 'post',  url:'/sims',                  handler: 'listSims',       middlewares: [authGuard]},
    { method: 'get',   url:'/sims/:simid',           handler: 'getSim',         middlewares: [authGuard]},
    { method: 'put',   url:'/sims',                  handler: 'createSim',      middlewares: [authGuard]},
    { method: 'put',   url:'/sims/:simid/start',     handler: 'startSim',     middlewares: [authGuard]},
    { method: 'put',   url:'/sims/:simid/pause',     handler: 'pauseSim',     middlewares: [authGuard]},
]

export const methods = {

    async listSims(req, res) {
        const userUuid = req.session.userInfos.identity.uuid
        const results = await this.db.execute(`
            SELECT s.sim_id, s.sim_name, BIN_TO_UUID(s.sim_root_kf_uuid) AS sim_root_kf_uuid
            FROM p42SIM.simulations s
            INNER JOIN simowners o ON o.own_sim_id = s.sim_id
            INNER JOIN users u ON o.own_usr_id = u.usr_id
            WHERE u.usr_uuid = ?
            ORDER BY s.sim_name`, [userUuid])
        this.ok(req, res, results)
    },

    async getSim(req, res) {
        const simId = req.params.simid
        if(!/^[1-9]\d*$/.test(simId)) {
            this.err(req, res, `Cannot find this simulation !`, `Invalid simulation ID !`, 400)
            return
        }

        const userUuid = req.session.userInfos.identity.uuid
        const results = await this.db.execute(`
            SELECT s.sim_id, s.sim_name, BIN_TO_UUID(s.sim_root_kf_uuid) AS sim_root_kf_uuid
            FROM p42SIM.simulations s
            INNER JOIN simowners o ON o.own_sim_id = s.sim_id
            INNER JOIN users u ON o.own_usr_id = u.usr_id
            WHERE s.sim_id = ? AND u.usr_uuid = ?`, [simId, userUuid])

        if(results.length != 1) {
            this.err(req, res, `Cannot find this simulation !`, `Simulation ${simId} not found !`, 404)
            return
        }
        this.ok(req, res, results[0])
    },

    async createSim(req, res) {
        const[isOk, payload, errors] = this.utils.validateMapObject(req.body,
        {
            'simName': ((val, obj) => ((typeof(val) == 'string') && (new RegExp(/^[\w\s]{5,200}$/).test(val)))),
            'kfId': ((val, obj) => (this.utils.isValidUUIDV7(val))),
        },
        {
            'simName': 'simName',
            'kfId': 'kfId',
        })
        if(!isOk) {
            this.err(req, res, `Cannot create this simulation !`, `Validations errors for creating simulation : ${errors.join(', ')}`, 400)
            return
        }

        const kfResults = await this.db.execute(`
            SELECT ekf_uuid
            FROM p42SIM.edited_keyframes
            WHERE ekf_uuid = UUID_TO_BIN(?)`, [payload.kfId])
        if(kfResults.length != 1) {
            this.err(req, res, `Cannot create this simulation !`, `Keyframe ${payload.kfId} not found !`, 404)
            return
        }

        const userUuid = req.session.userInfos.identity.uuid

        const result = await this.db.execute(`
            INSERT INTO p42SIM.simulations
            (sim_name, sim_root_kf_uuid)
            VALUES (?, ?)`,
        [payload.simName, UUID.parse(payload.kfId).bytes])

        await this.db.execute(`
            INSERT INTO simowners (own_usr_id, own_sim_id)
            SELECT usr_id, ?
            FROM users
            WHERE usr_uuid = ?`, [result.insertId, userUuid])

        this.ok(req, res, { simId: result.insertId })
    },

    async startSim(req, res) {
        const simId = req.params.simid
        if(!/^[1-9]\d*$/.test(simId)) {
            this.err(req, res, `Cannot start this simulation !`, `Invalid simulation ID !`, 400)
            return
        }

        const userUuid = req.session.userInfos.identity.uuid
        const results = await this.db.execute(`
            SELECT s.sim_id
            FROM p42SIM.simulations s
            INNER JOIN simowners o ON o.own_sim_id = s.sim_id
            INNER JOIN users u ON o.own_usr_id = u.usr_id
            WHERE s.sim_id = ? AND u.usr_uuid = ?`, [simId, userUuid])
        if(results.length != 1) {
            this.err(req, res, `Cannot start this simulation !`, `Simulation ${simId} not found !`, 404)
            return
        }

        // TODO: delegate to GodDaemons runtime
        this.ok(req, res, { simId: Number(simId) })
    },

    async pauseSim(req, res) {
        const simId = req.params.simid
        if(!/^[1-9]\d*$/.test(simId)) {
            this.err(req, res, `Cannot pause this simulation !`, `Invalid simulation ID !`, 400)
            return
        }

        const userUuid = req.session.userInfos.identity.uuid
        const results = await this.db.execute(`
            SELECT s.sim_id
            FROM p42SIM.simulations s
            INNER JOIN simowners o ON o.own_sim_id = s.sim_id
            INNER JOIN users u ON o.own_usr_id = u.usr_id
            WHERE s.sim_id = ? AND u.usr_uuid = ?`, [simId, userUuid])
        if(results.length != 1) {
            this.err(req, res, `Cannot pause this simulation !`, `Simulation ${simId} not found !`, 404)
            return
        }

        // TODO: delegate to GodDaemons runtime
        this.ok(req, res, { simId: Number(simId) })
    },
}