src/server/api/routers/task.ts - main - DME/Notes

src/server/api/routers/task.ts
207 строк7 KB
Karasique333
Commit
19 июн 2025, 15:09
19 июн 2025, 15:09d96c829
import { z } from 'zod'
import { or,eq, and, lt } from 'drizzle-orm'
import { createTRPCRouter, authProcedure } from '@/server/api/trpc'
import { task } from '@/server/db/schema'
import { sendEmailRouter } from '@/server/api/routers/send-email'
import { getBaseUrl } from '@/lib/utils'
import { env } from '@/env'

export const taskRouter = createTRPCRouter({
    getAll: authProcedure.query(async ({ ctx }) => {
        return await ctx.db
            .select()
            .from(task)
            .where(eq(task.userId, ctx.session.userId))
    }),



    archive: authProcedure
        .input(z.object({ id: z.string() }))
        .mutation(async ({ input, ctx }) => {
            await ctx.db
                .update(task)
                .set({ status: 'archived', updatedAt: new Date() })
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))
            return { success: true }
        }),

    restore: authProcedure
        .input(z.object({ id: z.string() }))
        .mutation(async ({ input, ctx }) => {
            await ctx.db
                .update(task)
                .set({ status: 'active', updatedAt: new Date() })
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))
            return { success: true }
        }),

    delete: authProcedure
        .input(z.object({ id: z.string() }))
        .mutation(async ({ input, ctx }) => {
            await ctx.db
                .delete(task)
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))
            return { success: true }
        }),

    getSearch: authProcedure
        .input(z.object({ query: z.string().min(1) }))
        .query(async ({ input, ctx }) => {
            return await ctx.db
                .select()
                .from(task)
                .where(
                    and(
                        eq(task.userId, ctx.session.userId),
                        or(
                            task.title.ilike(`%${input.query}%`),
                            task.description.ilike(`%${input.query}%`)
                        )
                    )
                )
        }),








    create: authProcedure
        .input(
            z.object({
                title: z.string().min(1),
                description: z.string().optional(),
                dueDate: z.string(),
            })
        )
        .mutation(async ({ input, ctx }) => {
            const newTask = await ctx.db
                .insert(task)
                .values({
                    userId: ctx.session.userId,
                    title: input.title,
                    description: input.description ?? '',
                    dueDate: new Date(input.dueDate),
                })
                .returning()

            // Получаем email пользователя
            const userRecord = await ctx.db.query.user.findFirst({
                where: (u, { eq }) => eq(u.id, ctx.session.userId),
            })
            if (!userRecord) throw new Error('Пользователь не найден')

            const userEmail = userRecord.email

            await fetch(`${getBaseUrl()}/api/send-email`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'x-api-key': env.EMAIL_API_KEY,
                },
                body: JSON.stringify({
                    to: userEmail,
                    subject: `Новая задача: ${input.title}`,
                    text: `Вы создали новую задачу:\n\nЗаголовок: ${input.title}\nОписание: ${input.description || 'Без описания'}\nСрок выполнения: ${input.dueDate}`,
                }),
            })


            return newTask[0]
        }),


    update: authProcedure
        .input(
            z.object({
                id: z.string(),
                title: z.string().optional(),
                description: z.string().optional(),
                dueDate: z.string().optional(),
                completed: z.boolean().optional(),
            })
        )
        .mutation(async ({ input, ctx }) => {
            await ctx.db
                .update(task)
                .set({
                    ...(input.title && { title: input.title }),
                    ...(input.description && { description: input.description }),
                    ...(input.dueDate && { dueDate: new Date(input.dueDate) }),
                    ...(typeof input.completed === 'boolean' && {
                        completed: input.completed,
                    }),
                    updatedAt: new Date(),
                })
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))

            if (input.completed === true) {
                const userRecord = await ctx.db.query.user.findFirst({
                    where: (u, { eq }) => eq(u.id, ctx.session.userId),
                })


                if (userRecord?.email) {
                    await fetch(`${getBaseUrl()}/api/send-email`, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'x-api-key': env.EMAIL_API_KEY,
                        },
                        body: JSON.stringify({
                            to: userRecord.email,
                            subject: `Задача выполнена: ${input.title}`,
                            text: `Вы отметили задачу "${input.title}" как выполненную.`,
                        }),
                    })
                }
            }

            return { success: true }


        }),



    getById: authProcedure
        .input(z.object({ id: z.string() }))
        .query(async ({ input, ctx }) => {
            const taskItem = await ctx.db
                .select()
                .from(task)
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))
                .then((res) => res[0])

            if (!taskItem) {
                throw new Error('Задача не найдена')
            }

            return taskItem
        }),



    get: authProcedure
        .input(z.object({ id: z.string() }))
        .query(async ({ ctx, input }) => {
            const found = await ctx.db
                .select()
                .from(task)
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))

            return found[0] ?? null
        }),
    delete: authProcedure
        .input(z.object({ id: z.string() }))
        .mutation(async ({ input, ctx }) => {
            await ctx.db
                .delete(task)
                .where(and(eq(task.id, input.id), eq(task.userId, ctx.session.userId)))

            return { success: true }
        }),
})