@purpleschool/gptbot 0.7.52 → 0.7.54-presentations

package/commands/chat/get-last-active-chat-command.ts

@@ -1,4 +1,4 @@
-import { ChatSchema } from '../../models';
+import { ChatSchema, ChatWithMessagesSchema } from '../../models';
 import { z } from 'zod';
 
 export namespace GetLastActiveChatCommand {
@@ -8,7 +8,7 @@ export namespace GetLastActiveChatCommand {
     });
 
     export const Response = z.object({
-        data: ChatSchema,
+        data: ChatWithMessagesSchema,
     });
 
     export type Response = z.infer<typeof Response>;

package/commands/folder/find-folder-by-uuid-with-chats.command.ts

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { ChatSchema, FolderSchema, MessageSchema } from '../../models';
+import { ChatSchema, FolderSchema } from '../../models';
 
 export namespace FindFolderByUuidWithChatsCommand {
     export const RequestParamSchema = FolderSchema.pick({
@@ -17,11 +17,7 @@ export namespace FindFolderByUuidWithChatsCommand {
 
     export const ResponseSchema = z.object({
         data: FolderSchema.extend({
-            chats: z.array(
-                ChatSchema.extend({
-                    messages: z.array(MessageSchema),
-                }),
-            ),
+            chats: z.array(ChatSchema),
         }),
         page: z.number(),
         totalPages: z.number(),

package/commands/tools/presentation/build-blank-slide.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+
+export namespace BuildBlankSlideCommand {
+    export const RequestSchema = z.object({
+        slideContentType: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            uuid: z.string().uuid(),
+            order: z.number(),
+            contentTypeId: z.string(),
+            layoutId: z.string(),
+            content: z.record(z.any()),
+            createdAt: z.date(),
+            updatedAt: z.date(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/presentation/generate-and-insert-slide.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { SlideSchema } from '../../../models/tools/presentation';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../../../constants';
+
+export namespace GenerateAndInsertSlideCommand {
+    export const RequestSchema = z.object({
+        contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        prompt: z.string().min(1).max(10000),
+        title: z.string().min(1).max(80),
+        position: z.number().min(0),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(SlideSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/presentation/index.ts

@@ -1,3 +1,4 @@
+export * from './build-blank-slide.command';
 export * from './create-presentation.command';
 export * from './delete-all-user-presentations.command';
 export * from './delete-slide-outline.command';
@@ -7,9 +8,12 @@ export * from './find-presentation-by-uuid.command';
 export * from './find-presentation-outline.command';
 export * from './find-presentations.command';
 export * from './generate-presentation-slides.command';
+export * from './generate-and-insert-slide.command';
 export * from './get-presentation-config.command';
 export * from './reposition-slide-outline.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation-outline.command';
 export * from './update-presentation.command';
+export * from './update-presentation-slides.command';
+export * from './update-slide-image-slot.command';
 export * from './update-slide-outline.command';

package/commands/tools/presentation/update-presentation-slides.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { SlideBulkUpdateSchema } from '../../../models/tools/presentation';
+
+export namespace UpdatePresentationSlidesCommand {
+    export const RequestSchema = z.object({
+        data: SlideBulkUpdateSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(
+            z.object({
+                uuid: z.string().uuid(),
+                order: z.number(),
+                contentTypeId: z.string(),
+                layoutId: z.string(),
+                content: z.record(z.any()),
+                createdAt: z.date(),
+                updatedAt: z.date(),
+            }),
+        ),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/presentation/update-presentation.command.ts

@@ -5,11 +5,12 @@ export namespace UpdatePresentationCommand {
     export const RequestParamsSchema = z.object({
         uuid: z.string().uuid(),
     });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
 
-    export const RequestBodySchema = z.object({
-        title: z.string(),
-    });
-
+    export const RequestBodySchema = PresentationSchema.pick({
+        title: true,
+        templateId: true,
+    }).partial();
     export type Request = z.infer<typeof RequestBodySchema>;
 
     export const ResponseSchema = z.object({

package/commands/tools/presentation/update-slide-image-slot.command.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { SLIDE_IMAGE_SLOT_ACTION } from '../../../constants';
+import { SlideImageSlotSchema } from '../../../models/tools/presentation/slide-image-slot.schema';
+
+export namespace UpdateSlideImageSlotCommand {
+    const ReplacePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.REPLACE),
+        url: z.string().url(),
+    });
+
+    const GeneratePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.GENERATE),
+        prompt: z.string().min(1).max(1000).optional(),
+    });
+
+    const UpdateImageSlotPayload = z.discriminatedUnion('action', [
+        ReplacePayload,
+        GeneratePayload,
+    ]);
+
+    export const RequestSchema = z.object({
+        payload: UpdateImageSlotPayload,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        slotId: z.string().uuid().optional(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            oldImage: z.string().url().optional(),
+            newImage: z.string().url(),
+            imageSlot: SlideImageSlotSchema,
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/errors/errors.ts

@@ -1999,13 +1999,18 @@ export const ERRORS = {
         message: 'Запрос был отклонен, т.к. может не соответствовать политике безопасности сервиса',
         httpCode: 400,
     },
-    FAILED_TO_SAVE_USER_STATISTICS: {
+    REVIEW_ALREADY_EXISTS: {
         code: 'A409',
+        message: 'Отзыв уже существует',
+        httpCode: 400,
+    },
+    FAILED_TO_SAVE_USER_STATISTICS: {
+        code: 'A410',
         message: 'не удалось сохранить статистику пользователя',
         httpCode: 500,
     },
     FAILED_TO_GET_USER_STATISTICS: {
-        code: 'A410',
+        code: 'A411',
         message: 'не удалось получить статистику пользователя',
         httpCode: 500,
     },

package/constants/presentation/enums/index.ts

@@ -3,3 +3,4 @@ export * from './slide-content-type.enum';
 export * from './slide-icon-slot-status.enum';
 export * from './slide-image-slot.status.enum';
 export * from './slide-layout.enum';
+export * from './slide-image-slot-action.enum';

package/constants/presentation/enums/slide-image-slot-action.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_IMAGE_SLOT_ACTION {
+    REPLACE = 'REPLACE',
+    GENERATE = 'GENERATE',
+}

package/constants/task/enums/task-type.enum.ts

@@ -1,4 +1,5 @@
 export enum TASK_TYPE {
     CLICK = 'click',
     TELEGRAM_CHANNEL_INVITE = 'telegram_channel_invite',
+    REVIEW = 'review',
 }

package/models/chat-with-messages.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ChatSchema } from './chat.schema';
+import { MessageSchema } from './message.schema';
+
+export const ChatWithMessagesSchema = ChatSchema.extend({
+    messages: z.array(MessageSchema),
+});

package/models/chat.schema.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import { CHAT_STATUS_ENUM, TChatStatusEnum } from '../constants';
-import { MessageSchema } from './message.schema';
 
 export const ChatSchema = z.object({
     uuid: z.string().uuid(),
@@ -10,7 +9,6 @@ export const ChatSchema = z.object({
     aIModelId: z.string().uuid(),
     title: z.string(),
     chatStatus: z.enum(Object.values(CHAT_STATUS_ENUM) as [TChatStatusEnum]),
-    messages: z.array(MessageSchema),
     folderId: z.string().nullable(),
 
     createdAt: z.date(),

package/models/index.ts

@@ -4,6 +4,7 @@ export * from './ai-model-formatted.schema';
 export * from './ai-model.schema';
 export * from './ai-vendor.schema';
 export * from './category.schema';
+export * from './chat-with-messages.schema';
 export * from './chat.schema';
 export * from './cloud-payments-receipt.schema';
 export * from './course-author.schema';

package/models/tools/presentation/presentation.schema.ts

@@ -13,6 +13,8 @@ export const PresentationSchema = z.object({
     templateId: z.string(),
     downloadUrl: z.string().nullable(),
     slideCount: z.number(),
+    lastContentUpdateAt: z.date().nullable(),
+    lastPptxExportedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/tools/presentation/slide-content-edit.schema.ts

@@ -0,0 +1,160 @@
+import z from 'zod';
+import {
+    ICoverSlideDataStructure,
+    IThankYouSlideDataStructure,
+    ITextSlideDataStructure,
+    IStructuredListSlideDataStructure,
+    IContentsSlideDataStructure,
+    IImageSlideDataStructure,
+    ISectionBreakSlideDataStructure,
+    ITableSlideDataStructure,
+    SLIDE_CHART_TYPE,
+    IBarChartSlideDataStructure,
+    IChartSlideDataStructure,
+    ImageSlotSchema,
+} from './slide-content.schema';
+import { SLIDE_CONTENT_TYPE } from '../../../constants';
+
+export const CoverSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
+    title: z.string().min(1).max(500),
+    author: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    date: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    email: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ICoverSlideDataStructure>;
+
+export const ThankYouSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.THANK_YOU),
+    title: z.string().min(1).max(500),
+    author: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    date: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    email: z.object({
+        label: z.string().min(1).max(100),
+        value: z.string().min(1).max(200),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<IThankYouSlideDataStructure>;
+
+export const TextSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(3000),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITextSlideDataStructure>;
+
+export const StructuredListSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.STRUCTURED_LIST),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(1000),
+    list: z
+        .array(
+            z.object({
+                title: z.string().min(1).max(200),
+                description: z.string().min(1).max(500),
+            }),
+        )
+        .min(1)
+        .max(10),
+    version: z.literal(1),
+}) satisfies z.ZodType<IStructuredListSlideDataStructure>;
+
+export const ContentsSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CONTENTS),
+    title: z.string().min(1).max(500),
+    items: z
+        .array(
+            z.object({
+                pageNumber: z.number(),
+                title: z.string().min(1).max(500),
+            }),
+        )
+        .min(1)
+        .max(50),
+    version: z.literal(1),
+}) satisfies z.ZodType<IContentsSlideDataStructure>;
+
+export const ImageSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT_WITH_IMAGE),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(2000),
+    imageSlot: ImageSlotSchema,
+    version: z.literal(1),
+}) satisfies z.ZodType<IImageSlideDataStructure>;
+
+export const SectionBreakSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.SECTION_BREAK),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(500),
+    version: z.literal(1),
+}) satisfies z.ZodType<ISectionBreakSlideDataStructure>;
+
+export const TableSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TABLE),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(1000),
+    table: z.object({
+        columnHeaders: z.array(z.string().min(1).max(200)).min(1).max(20),
+        rows: z
+            .array(z.array(z.string().min(1).max(500)))
+            .min(1)
+            .max(20),
+        hasRowHeaders: z.boolean(),
+        hasSummaryRow: z.boolean(),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITableSlideDataStructure>;
+
+export const BarChartSlideDataUserEditSchema = z.object({
+    type: z.literal(SLIDE_CHART_TYPE.BAR),
+    categories: z.array(z.string().min(1).max(200)).min(1).max(50),
+    series: z
+        .array(
+            z.object({
+                name: z.string().min(1).max(200),
+                data: z.array(z.number()),
+                type: z.number().min(0).max(11),
+            }),
+        )
+        .min(1)
+        .max(5),
+    yAxisLabel: z.string().max(200).optional(),
+    unit: z.string().max(50).optional(),
+    version: z.literal(1),
+}) satisfies z.ZodType<IBarChartSlideDataStructure>;
+
+export const ChartSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CHART),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(2000),
+    chart: z.discriminatedUnion('type', [BarChartSlideDataUserEditSchema]),
+    version: z.literal(1),
+}) satisfies z.ZodType<IChartSlideDataStructure>;
+
+export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
+    CoverSlideDataUserEditSchema,
+    StructuredListSlideDataUserEditSchema,
+    TextSlideDataUserEditSchema,
+    ContentsSlideDataUserEditSchema,
+    SectionBreakSlideDataUserEditSchema,
+    ImageSlideDataUserEditSchema,
+    ThankYouSlideDataUserEditSchema,
+    TableSlideDataUserEditSchema,
+    ChartSlideDataUserEditSchema,
+]);
+export type SlideContentUserEdit = z.infer<typeof SlideContentUserEditSchema>;