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 { logger } from "@server/../log";

export const get = async (request: Request, response: Response) => {
    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);
};

export const post = async (request: Request, response: Response) => {
    const guildId = request.params.guildId;
    const {
        name,
        url,
        active,
        channels,
        filters,
        message_style,
        published_threshold
    } = request.body;

    logger.debug("Post Feed", request.body);

    // channels comes through as either String[] or String
    let formattedChannels = undefined;
    if (channels !== undefined) {
        formattedChannels = Array.isArray(channels)
            ? channels.map((channelId) => ({ channel_id: channelId }))
            : [{ channel_id: channels }]
    }

    let formattedFilters = undefined;
    if (filters !== undefined) {
        formattedFilters = Array.isArray(filters)
            ? filters.map((filterId) => ({ id: Number(filterId) }))
            : [{ id: Number(filters) }]
    }

    let feed;

    try {
        feed = await prisma.feed.create({
            data: {
                name: name,
                url: url,
                guild_id: guildId,
                active: active === "on",
                channels: { create: formattedChannels },
                filters: { connect: formattedFilters },
                message_style_id: message_style === "" ? null : Number(message_style),
                published_threshold: new Date(published_threshold)
             }
        });
    }
    catch (error) {
        console.error(error);
        if (error instanceof Prisma.PrismaClientKnownRequestError) {
            response.status(500).json({ error: error.message });
            return;
        }
    }

    response.status(201).json(feed);
};

export const patch = async (request: Request, response: Response) => {
    const guildId = request.params.guildId;
    const {
        id,
        name,
        url,
        active,
        channels,
        filters,
        message_style,
        published_threshold
    } = request.body;

    logger.info("Patch Feed", request.body);

    // channels comes through as either String[] or String
    let formattedChannels = undefined;
    if (channels !== undefined) {
        formattedChannels = Array.isArray(channels)
            ? channels.map((channelId) => ({ channel_id: channelId }))
            : [{ channel_id: channels }]
    }

    let formattedFilters = undefined;
    if (filters !== undefined) {
        formattedFilters = Array.isArray(filters)
            ? filters.map((filterId) => ({ id: Number(filterId) }))
            : [{ id: Number(filters) }]
    }

    let feed;

    try {
        feed = await prisma.feed.update({
            where: { id: Number(id) },
            data: {
                name: name,
                url: url,
                guild_id: guildId,
                active: active === "on",
                channels: {
                    deleteMany: {},
                    create: formattedChannels
                },
                filters: {
                    set: [],
                    connect: formattedFilters
                },
                message_style_id:
                    message_style === ""
                        ? null
                        : Number(message_style),
                published_threshold: new Date(published_threshold)
             }
        });
    }
    catch (error) {
        console.error(error);
        if (error instanceof Prisma.PrismaClientKnownRequestError) {
            response.status(500).json({ error: error.message });
            return;
        }
    }

    response.status(201).json(feed);
}

export const del = async (request: Request, response: Response) => {
    let { ids } = request.body;
    const guildId = request.params.guildId;

    if (!ids || !Array.isArray(ids)) {
        response.status(400).json({ error: "invalid request body" });
        return;
    }

    ids = ids.map(id => Number(id));

    try {
        await prisma.feed.deleteMany({ where: {
            id: { in: ids },
            guild_id: guildId
        }});
    }
    catch (error) {
        console.error(error);
        if (error instanceof Prisma.PrismaClientKnownRequestError) {
            response.status(500).json({ error: error.message });
            return;
        }
    }

    response.status(204).json(null);
};

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 };