@purpleschool/gptbot 0.7.77 → 0.7.78

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export namespace PresentationParaphraseCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string(),
+        slideId: z.string(),
+    });
+
+    export const RequestBodySchema = z.object({
+        selectionText: z.string().max(10000),
+    });
+
+    export const RequestSchema = RequestParamsSchema.merge(RequestBodySchema);
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            output: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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,40 @@
+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),
+        fileId: z.string().uuid(),
+    });
+
+    const GeneratePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.GENERATE),
+        prompt: z.string().min(1).max(1000).optional(),
+    });
+
+    const UpdateImageSlotPayloadSchema = z.discriminatedUnion('action', [
+        ReplacePayload,
+        GeneratePayload,
+    ]);
+    export type UpdateImageSlotPayload = z.infer<typeof UpdateImageSlotPayloadSchema>;
+
+    export const RequestSchema = z.object({
+        payload: UpdateImageSlotPayloadSchema,
+    });
+    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({
+            imageSlot: SlideImageSlotSchema,
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { SlideSchema, SlideUpdateSchema } from '../../../models/tools/presentation';
+
+export namespace UpdateSlideCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string(),
+        slideId: z.string(),
+    });
+
+    export const RequestBodySchema = z.object({
+        data: SlideUpdateSchema,
+    });
+
+    export const RequestSchema = RequestParamsSchema.merge(RequestBodySchema);
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SlideSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/errors/errors.ts

@@ -2247,12 +2247,10 @@ export const ERRORS = {
     MUSIC_MAX_SYMBOLS_EXCEEDED: {
         code: 'A458',
         message: 'Превышена максимальная количество символов',
-        httpCode: 400,
     },
     MUSIC_INVALID_VOCAL: {
         code: 'A459',
         message: 'Выбран неверный голос для вокала',
-        httpCode: 400,
     },
     MUSIC_JOB_DELETE_ERROR: {
         code: 'A460',
@@ -2294,4 +2292,14 @@ export const ERRORS = {
         message: 'Не удалось применить бонусы вебмастеру',
         httpCode: 500,
     },
+    SLIDE_IMAGE_SLOT_UPDATE_ERROR: {
+        code: 'A450',
+        message: 'Произошла ошибка при обновлении изображения на слайде',
+        httpCode: 500,
+    },
+    FILE_TYPE_NOT_SUPPORTED: {
+        code: 'A451',
+        message: 'Неподдерживаемый тип файла',
+        httpCode: 400,
+    },
 };

package/constants/presentation/enums/index.ts

@@ -3,3 +3,7 @@ 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';
+export * from './presentation-ai-action-type.enum';
+export * from './presentation-ai-action-pricing-type.enum';
+export * from './presentation-ai-action-call-status.enum';

package/constants/presentation/enums/presentation-ai-action-call-status.enum.ts

@@ -0,0 +1,5 @@
+export enum PRESENTATION_AI_ACTION_CALL_STATUS {
+    PROCESSING = 'processing',
+    COMPLETED = 'completed',
+    FAILED = 'failed',
+}

package/constants/presentation/enums/presentation-ai-action-pricing-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_PRICING_TYPE {
+    PER_CHARACTER = 'PER_CHARACTER',
+    FLAT = 'FLAT',
+}

package/constants/presentation/enums/presentation-ai-action-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_TYPE {
+    PARAPHRASE = 'PARAPHRASE',
+    GENERATE_REPORT = 'GENERATE_REPORT',
+}

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/webmaster/enums/organization-type.enum.ts

@@ -1,4 +1,5 @@
 export enum ORGANIZATION_TYPE {
     INDIVIDUAL_ENTREPRENEUR = 'ИП',
     LEGAL_ENTITY = 'Юридическое лицо',
+    SELF_EMPLOYED = 'Самозанятый',
 }

package/helpers/index.ts

@@ -1,4 +1,5 @@
 export * from './ai-model';
+export * from './presentation';
 export * from './stt';
 export * from './subscription';
 export * from './tts';

package/helpers/presentation/calculate-presentation-ai-action-price.util.ts

@@ -0,0 +1,20 @@
+import { PRESENTATION_AI_ACTION_PRICING_TYPE } from '../../constants';
+import { PresentationAiActionPricingRules } from '../../models/tools/presentation';
+
+export function calculatePresentationAiActionPrice(
+    pricingRules: PresentationAiActionPricingRules,
+    selectionText: string,
+): number {
+    switch (pricingRules.type) {
+        case PRESENTATION_AI_ACTION_PRICING_TYPE.PER_CHARACTER:
+            const characterCount = selectionText.length;
+            const price = characterCount * pricingRules.price;
+            return Math.max(1, Math.ceil(price));
+
+        case PRESENTATION_AI_ACTION_PRICING_TYPE.FLAT:
+            return Math.max(1, Math.ceil(pricingRules.price));
+
+        default:
+            throw new Error(`Unknown pricing type`);
+    }
+}

package/helpers/presentation/index.ts

@@ -0,0 +1 @@
+export * from './calculate-presentation-ai-action-price.util';

package/models/tools/index.ts

@@ -1,5 +1,6 @@
 export * from './language';
 export * from './paraphrase';
+export * from './presentation';
 export * from './stt';
 export * from './tts';
 export * from './video';

package/models/tools/presentation/index.ts

@@ -5,3 +5,4 @@ export * from './slide-outline.schema';
 export * from './slide.schema';
 export * from './slide-content.schema';
 export * from './presentation-config.schema';
+export * from './presentation-ai-action.schema';

package/models/tools/presentation/presentation-ai-action.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import {
+    PRESENTATION_AI_ACTION_PRICING_TYPE,
+    PRESENTATION_AI_ACTION_TYPE,
+} from '../../../constants';
+
+export const PresentationAiActionPricingRulesSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.PER_CHARACTER),
+        price: z.number(),
+    }),
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.FLAT),
+        price: z.number(),
+    }),
+]);
+export type PresentationAiActionPricingRules = z.infer<
+    typeof PresentationAiActionPricingRulesSchema
+>;
+
+export const PresentationAiActionSchema = z.object({
+    uuid: z.string(),
+    type: z.nativeEnum(PRESENTATION_AI_ACTION_TYPE),
+    pricingRules: PresentationAiActionPricingRulesSchema,
+    maxPromptLength: z.number(),
+    aiModel: z.string(),
+    title: z.string(),
+    icon: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type PresentationAiAction = z.infer<typeof PresentationAiActionSchema>;

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

@@ -2,16 +2,19 @@ import { z } from 'zod';
 import { SlideContentTypeSchema } from './slide-content-type.schema';
 import { LanguageSchema } from '../language';
 import { PresentationTemplateSchema } from './presentation-template.schema';
+import { PresentationAiActionSchema } from './presentation-ai-action.schema';
 
 export const PresentationConfigSchema = z.object({
     slideContentTypes: z.array(SlideContentTypeSchema),
     languages: z.array(LanguageSchema),
     templates: z.array(PresentationTemplateSchema),
+    aiActions: z.array(PresentationAiActionSchema),
     slideGenerationPrice: z.number(),
     maxSlides: z.number(),
     minSlides: z.number(),
     maxSlideTitleLength: z.number(),
     maxSlideOutlineLength: z.number(),
     maxPromptLength: z.number(),
+    imageGenerationPrice: z.number(),
 });
 export type PresentationConfig = z.infer<typeof PresentationConfigSchema>;

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,154 @@
+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().max(1000),
+    author: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    date: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    email: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ICoverSlideDataStructure>;
+
+export const ThankYouSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.THANK_YOU),
+    title: z.string().max(1000),
+    author: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    date: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    email: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<IThankYouSlideDataStructure>;
+
+export const TextSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT),
+    title: z.string().max(1000),
+    description: z.string().max(5000),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITextSlideDataStructure>;
+
+export const StructuredListSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.STRUCTURED_LIST),
+    title: z.string().max(1000),
+    description: z.string().max(2000),
+    list: z
+        .array(
+            z.object({
+                title: z.string().max(500),
+                description: z.string().max(1000),
+            }),
+        )
+        .max(15),
+    version: z.literal(1),
+}) satisfies z.ZodType<IStructuredListSlideDataStructure>;
+
+export const ContentsSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CONTENTS),
+    title: z.string().max(1000),
+    items: z
+        .array(
+            z.object({
+                pageNumber: z.number(),
+                title: z.string().max(1000),
+            }),
+        )
+        .max(100),
+    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().max(1000),
+    description: z.string().max(4000),
+    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().max(1000),
+    description: z.string().max(1000),
+    version: z.literal(1),
+}) satisfies z.ZodType<ISectionBreakSlideDataStructure>;
+
+export const TableSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TABLE),
+    title: z.string().max(1000),
+    description: z.string().max(2000),
+    table: z.object({
+        columnHeaders: z.array(z.string().max(500)).max(30),
+        rows: z.array(z.array(z.string().max(1000))).max(50),
+        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().max(500)).max(100),
+    series: z
+        .array(
+            z.object({
+                name: z.string().max(500),
+                data: z.array(z.number()),
+                type: z.number().min(0).max(11),
+            }),
+        )
+        .max(10),
+    yAxisLabel: z.string().max(500).optional(),
+    unit: z.string().max(100).optional(),
+    version: z.literal(1),
+}) satisfies z.ZodType<IBarChartSlideDataStructure>;
+
+export const ChartSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CHART),
+    title: z.string().max(1000),
+    description: z.string().max(4000),
+    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>;