relay/src/server/controllers/guild/api/feed.controller.ts

import { Request, Response } from "express";
import prisma, { Prisma } from "@server/prisma";
import { datatableRequest } from "@server/controllers/guild/api/dt.module";
import { getLogger } from "@server/../log";

const logger = getLogger(__filename);

export const get = async (request: Request, response: Response) => {
    logger.info(`Getting feed: ${request.query.id}`);

    if (!request.query.id) {
        response.status(400).json({ error: "Missing 'id' query" });
        return;
    }

    const feed = await prisma.feed.findUnique({
        where: { id: Number(request.query.id) },
        include: { channels: true, filters: true }
    });

    if (!feed) {
        response.status(404).json({ message: "No result found" });
        return;
    }

    response.json(feed);
};

const unpackChannels = (channels: string[] | string | undefined) => {
    if (channels === undefined) return channels;

    return Array.isArray(channels)
        ? channels.map(channelId => ({ channel_id: channelId }))
        : [{ channel_id: channels }];
};

const unpackFilters = (filters: string[] | string | undefined) => {
    if (filters === undefined) return filters;

    return Array.isArray(filters)
        ? filters.map(filterId => ({ id: Number(filterId) }))
        : [{ id: Number(filters) }]
};

export const post = async (request: Request, response: Response) => {
    logger.info(`Posting feed: ${request.body.url} - ${request.params.guildId}`);

    const body = {
        ...request.body,
        active: request.body.active === "on",
        message_style: Number(request.body.message_style) || null,
        published_threshold: new Date(request.body.published_threshold)
    };

    const createInputData: Prisma.FeedUncheckedCreateInput = {
        guild_id: request.params.guildId,
        name: body.name,
        url: body.url,
        active: body.active,
        channels: { create: unpackChannels(body.channels) },
        filters: { connect: unpackFilters(body.filters) },
        message_style_id: body.message_style,
        published_threshold: body.published_threshold
    };

    try {
        const createResponse = await prisma.feed.create({ data: createInputData });
        response.status(201).json(createResponse);
    } catch (error) {
        logger.error(error);
        const isPrismaError = error instanceof Prisma.PrismaClientKnownRequestError;
        response.status(500).json({ error: isPrismaError ? error.message : error });
    }
};

export const patch = async (request: Request, response: Response) => {
    logger.info(`Patching feed: ${request.body.id} - ${request.params.guildId}`);

    const body = {
        ...request.body,
        active: request.body.active === "on",
        message_style: Number(request.body.message_style) || null,
        published_threshold: new Date(request.body.published_threshold)
    };

    const updateInputData: Prisma.FeedUncheckedUpdateInput = {
        name: body.name,
        url: body.url,
        active: body.active,
        channels: { deleteMany: {}, create: unpackChannels(body.channels) },
        filters: { set: [], connect: unpackFilters(body.filters) },
        message_style_id: body.message_style,
        published_threshold: body.published_threshold
    };

    try {
        const updateArgs = { where: { id: Number(body.id) }, data: updateInputData };
        const updateResponse = await prisma.feed.update(updateArgs);
        response.status(200).json(updateResponse);
    } catch (error) {
        logger.error(error);
        const isPrismaError = error instanceof Prisma.PrismaClientKnownRequestError;
        response.status(500).json({ error: isPrismaError ? error.message : error });
    }
};

export const del = async (request: Request, response: Response) => {
    logger.info(`Deleting feed(s): ${request.body.ids} - ${request.params.guildId}`);

    const ids = request.body.ids?.map((id: string) => Number(id));

    if (!ids) {
        response.status(400).json({ error: `Couldn't parse ID's from request body` });
        return;
    }

    try {
        const deleteArgs = { where: { guild_id: request.params.guildId, id: { in: ids } } };
        await prisma.feed.deleteMany(deleteArgs);
        response.status(204).send();
    } catch (error) {
        logger.error(error);
        const isPrismaError = error instanceof Prisma.PrismaClientKnownRequestError;
        response.status(500).json({ error: isPrismaError ? error.message : error });
    }
};

export const datatable = async (request: Request, response: Response) => {
    return await datatableRequest(
        request,
        response,
        prisma.feed,
        [{ updated_at: "desc" }, { id: "asc" }],
        { channels: true, filters: true, message_style: true },
        { guild_id: request.params.guildId }  // TODO: verify authenticated user can access this guild
    );
};

export default { get, post, patch, del, datatable };