youtuber-blog/src/routes/dashboard.js

/** @typedef {import("fastify").FastifyInstance} FastifyInstance */

import { and, desc, eq, getTableColumns, sql } from "drizzle-orm";
import { db } from "../db/index.js";
import { articles, articles as articlesTable, signups as signupsTable, sites, users } from "../db/schemas.js";
import { authMiddleware, authMiddlewareFn } from "../modules/middleware.js";
import { jsonToCsv, createBlogFromCaptions, createArticleSlug, getVideoById, env, getWhisperCaptions, getVideoWithCaptions } from "../utils/index.js";

/**
 * 
 * @param {FastifyInstance} fastify 
 * @param {unknown} _ 
 * @param {() => void} done 
 */
export const dashboardRoutes = (fastify, _, done) => {
    fastify.register(authMiddleware);

    fastify.get("/", async (req, response) => {
        try {
            const [{ site_id, user_id }] = await db.select({
                site_id: sites.id,
                user_id: sites.user_id
            }).from(sites).where(eq(sites.user_id, req.session.user_id));

            const recentArticles = await db.select({
                title: articlesTable.title,
                views: articlesTable.views,
                created_at: articlesTable.created_at
            }).from(articlesTable)
                .where(eq(articlesTable.site_id, site_id))
                .orderBy(articlesTable.created_at).limit(5);

            const recentSignups = await db.select({
                email: signupsTable.email,
                created_at: signupsTable.created_at
            }).from(signupsTable)
                .where(eq(signupsTable.site_id, site_id))
                .orderBy(desc(signupsTable.created_at)).limit(8);

            const [{ totalArticles }] = await db.select({ totalArticles: sql`count(*)` }).from(articlesTable).where(eq(articlesTable.site_id, site_id));
            const [{ totalViews }] = await db.select({ totalViews: sql`COALESCE(sum(${articlesTable.views}), 0)` }).from(articlesTable).where(eq(articlesTable.site_id, site_id));
            const [{ totalEmails }] = await db.select({ totalEmails: sql`count(*)` }).from(signupsTable).where(eq(signupsTable.site_id, site_id));

            response.send({
                success: true,
                recentArticles,
                recentSignups,
                totalArticles,
                totalEmails,
                totalViews
            });
            return;
        } catch (e) {
            console.log(e);
            response.status(500).send({
                success: false,
                message: "Failed to get dashboard data",
                log: e.message
            });
            return;
        }
    });

    fastify.get("/email-export", async (req, response) => {

    });

    fastify.get("/signups", async (req, reply) => {
        const site = await db.select().from(sites).where(eq(sites.user_id, req.session.user_id));

        if (site[0]?.user_id != req.session.user_id) {
            reply.status(403).send({ success: false });
            return;
        }

        const signups = await db.select().from(signupsTable).where(eq(signupsTable.site_id, site[0].id)).orderBy(desc(signupsTable.created_at));

        reply.send({
            success: true,
            signups
        });
    });

    fastify.get("/signups/export", async (req, reply) => {
        try {

            const [{ site_id }] = await db.select({
                site_id: sites.id
            }).from(sites).where(eq(sites.user_id, req.session.user_id));

            const signups = await db.select({
                email: signupsTable.email,
                source: sql`COALESCE(source, 'Home')`,
                created_at: signupsTable.created_at
            }).from(signupsTable).where(eq(signupsTable.site_id, site_id)).orderBy(desc(signupsTable.created_at));

            let result = jsonToCsv(signups);

            reply.send({
                success: true,
                data: result
            });
            return;
        } catch (e) {
            console.log(e);
        }
    });

    fastify.put("/article", {
        schema: {
            body: {
                type: "object",
                properties: {
                    id: {
                        type: "string"
                    },
                    is_public: {
                        type: "boolean"
                    },
                    content: {
                        type: "string"
                    },
                    title: {
                        type: "string"
                    },
                },
                required: ["id"]
            }
        }
    }, async (req, reply) => {
        const [article] = await db.select(getTableColumns(articles)).from(articles).leftJoin(sites, eq(sites.id, articles.site_id)).where(eq(sites.user_id, req.session.user_id));

        if (!article) {
            reply.status(404).send({
                success: false,
                message: "This article does not exist."
            });
            return;
        }

        if (Object.keys(req.body).length > 1) {
            await db.update(articles).set(JSON.parse(JSON.stringify({ ...req.body, id: undefined }))).where(eq(articles.id, req.body.id));
        }
        reply.send({
            success: true
        });
        return;
    });

    fastify.delete("/article", {
        schema: {
            querystring: {
                type: "object",
                properties: {
                    id: {
                        type: "string"
                    }
                },
                required: ["id"]
            }
        }
    }, async (req, reply) => {
        const [article] = await db.select(getTableColumns(articles)).from(articles).leftJoin(sites, eq(sites.id, articles.site_id)).where(and(eq(sites.user_id, req.session.user_id), eq(articles.id, req.query.id)));

        if (!article) {
            reply.status(404).send({
                success: false,
                message: "This article does not exist."
            });
            return;
        }

        await db.delete(articles).where(eq(articles.id, article.id));

        reply.send({
            success: true
        });
        return;
    });

    fastify.post("/create", {
        schema: {
            body: {
                type: "object",
                required: ["video_id"],
                properties: {
                    video_id: {
                        type: "string",
                    },
                    length: {
                        type: "number",
                    },
                    format: {
                        type: "string"
                    },
                    faq: {
                        type: "boolean"
                    },
                }
            },
        }
    }, async (req, reply) => {
        try {
            const [{ tokens }] = await db.select({
                tokens: users.tokens
            }).from(users).where(eq(users.id, req.session.user_id));

            if (tokens < 1) {
                reply.send({
                    success: false,
                    code: "insufficient_tokens",
                    message: "Insufficient tokens"
                });
                return;
            }

            // const access_token = await getAccessToken(fastify, req);

            let urlRegex = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=|\?v=)([^#\&\?]*).*/;
            let match = req.body.video_id.match(urlRegex);
            if (!match) {
                reply.status(400).send({
                    success: false,
                    message: "Invalid Youtube URL"
                });
                return;
            }
            
            // youtube-dl --write-sub --sub-lang en --skip-download URL 

            
            const video_data = await getVideoWithCaptions(req.body.video_id);

            reply.send({
                success: true
            });

            // const video_data = await getVideoById(access_token, req.body.video_id);

            const blog_content_json = await createBlogFromCaptions(video_data.captions, { title: video_data.title, description: video_data.description }, req.body);
            // TODO: once I add multiple sites per user, this should come from the client
            const site = await db.select().from(sites).where(eq(sites.user_id, req.session.user_id));

            await db.insert(articlesTable).values({
                site_id: site[0].id,
                title: blog_content_json.title,
                content: blog_content_json.content,
                meta_title: blog_content_json.meta_title,
                meta_desc: blog_content_json.meta_desc,
                excerp: blog_content_json.excerp,
                source_video_id: req.body.video_id,
                seo_slug: createArticleSlug(blog_content_json.title),
                is_public: false
            }).returning({ id: articlesTable.id });

            await db.update(users).set({
                tokens: tokens - 1
            }).where(eq(users.id, req.session.user_id));

        } catch (e) {
            console.log(e);
        }
    });

    fastify.post("/recreate", {
        schema: {
            body: {
                type: "object",
                required: ["video_id"],
                properties: {
                    video_id: {
                        type: "string",
                    },
                    length: {
                        type: "number",
                    },
                    format: {
                        type: "string"
                    },
                    faq: {
                        type: "boolean"
                    },
                }
            },
        }
    }, async (req, reply) => {

    })

    fastify.put("/website", {
        schema: {
            body: {
                type: "object",
                properties: {
                    id: {
                        type: "string"
                    },
                    name: {
                        type: "string"
                    },
                    primary_color_hex: {
                        type: "string",
                        maxLength: 6,
                        minLength: 6
                    },
                    secondary_color_hex: {
                        type: "string",
                        maxLength: 6,
                        minLength: 6
                    },
                    text_color_hex: {
                        type: "string",
                        maxLength: 6,
                        minLength: 6
                    },
                    use_freebie: {
                        type: "boolean"
                    },
                    freebie_name: {
                        type: ["string", "null"]
                    },
                    freebie_url: {
                        type: ["string", "null"],
                        format: "uri"
                    },
                    freebie_image_url: {
                        type: ["string", "null"],
                        format: "uri"
                    },
                    freebie_text: {
                        type: ["string", "null"]
                    },
                    title: {
                        type: "string",
                    },
                    subtitle: {
                        type: "string",
                    },
                    domain: {
                        type: ["string", "null"]
                    }
                },
                required: ["id"]
            }
        },
        preValidation: authMiddlewareFn
    }, async (req, reply) => {
        try {
            const [site] = await db.select().from(sites).where(eq(sites.id, req.body.id));

            if (site.user_id !== req.session.user_id) {
                reply.status(403).send({
                    success: false
                });
                return;
            }

            if (env.CERTS_URL && site.domain !== req.body.domain) {
                await fetch(`http://${env.CERTS_URL}/provision`, {
                    method: "POST",
                    body: JSON.stringify({
                        domain: req.body.domain
                    })
                });
            }

            const data = structuredClone(req.body.id);

            delete data.id;
            await db.update(sites).set(data).where(eq(sites.id, req.body.id));

            return {
                success: true
            }
        } catch (e) {
            console.log(e);
        }
    });

    done();
};

function convertSRV1ToPlainText(transcript) {
    // Define regular expression to extract text content
    const textRegex = /<text[^>]+>(.*?)<\/text>/g;
    
    // Initialize an empty array to hold the plain text lines
    const plainTextLines = [];
    
    // Match text segments using regular expression
    let match;
    while ((match = textRegex.exec(transcript)) !== null) {
        // Extract text content and remove any HTML tags
        const textContent = match[1].replace(/<[^>]+>/g, '');
        
        // Add text content to the plain text lines array
        plainTextLines.push(textContent);
    }
    
    // Join the plain text lines into a single string and return it
    return plainTextLines.join('\n');
}