@purpleschool/gptbot 0.7.57 → 0.7.58-presentations

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/commands/tools/tool/index.ts

@@ -1,2 +1 @@
 export * from './find-all-tools.command';
-export * from './find-formatted-tools.command';

package/constants/errors/errors.ts

@@ -2014,14 +2014,14 @@ export const ERRORS = {
         message: 'не удалось получить статистику пользователя',
         httpCode: 500,
     },
-    TOOL_GET_FORMATTED_ERROR: {
+    SLIDE_IMAGE_SLOT_UPDATE_ERROR: {
         code: 'A412',
-        message: 'Ошибка при получении отформатированных тулов',
+        message: 'Произошла ошибка при обновлении изображения на слайде',
         httpCode: 500,
     },
-    TOOL_FIND_ALL_ERROR: {
+    FILE_TYPE_NOT_SUPPORTED: {
         code: 'A413',
-        message: 'Ошибка при получении всех тулов',
-        httpCode: 500,
+        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/subscription/enums/subscription-feature-type.enum.ts

@@ -14,8 +14,6 @@ export enum SUBSCRIPTION_FEATURE_TYPE {
     VIDEO_MODEL_ACCESS = 'video_model_access',
     EXTENDED_CONTEXT = 'extended_context',
     PRESENTATION_QUOTA = 'presentation_quota',
-    TOKENS = 'tokens',
-    CARRYOVER_BALANCE = 'carryover_balance',
 }
 
 export enum SUBSCRIPTION_FEATURE_KIND {
@@ -27,5 +25,4 @@ export enum SUBSCRIPTION_FEATURE_KIND {
     PRESENTATIONS = 'presentations',
     VIDEO = 'video',
     PRESENTATION = 'presentation',
-    BASE = 'base',
 }

package/constants/transaction/enums/user-balance-status.enum.ts

@@ -1,7 +1,6 @@
 export enum USER_BALANCE_STATUS {
     bonus_balance = 'bonus_balance',
     subscription_balance = 'subscription_balance',
-    carried_over_balance = 'carried_over_balance',
     product_balance = 'product_balance',
     referral_bonus_balance = 'referral_bonus_balance',
 }

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/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/page.schema.ts

@@ -12,8 +12,6 @@ export const PageSchema = z.object({
     categoryId: z.string().uuid().nullable().optional(),
     aIModelId: z.string().uuid().nullable().optional(),
     toolId: z.string().uuid().nullable().optional(),
-    toolOptionId: z.string().uuid().nullable().optional(),
-    toolTitle: z.string().nullable(),
     type: z.nativeEnum(PageType),
 
     createdAt: z.date(),

package/models/subscription-feature.schema.ts

@@ -12,34 +12,6 @@ export const SubscriptionFeatureBaseSchema = z.object({
 });
 export type SubscriptionFeatureBase = z.infer<typeof SubscriptionFeatureBaseSchema>;
 
-const SubscriptionFeatureIconsSchema = z.object({
-    light: z.object({
-        png: z.string(),
-        svg: z.string(),
-    }),
-    dark: z.object({
-        png: z.string(),
-        svg: z.string(),
-    }),
-});
-
-export const TokensFeatureSchema = SubscriptionFeatureBaseSchema.extend({
-    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.BASE),
-    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.TOKENS),
-    tokens: z.number(),
-    icons: SubscriptionFeatureIconsSchema,
-});
-export type TokensFeature = z.infer<typeof TokensFeatureSchema>;
-
-export const CarryoverBalanceFeatureSchema = SubscriptionFeatureBaseSchema.extend({
-    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.BASE),
-    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.CARRYOVER_BALANCE),
-    isAvailable: z.boolean(),
-    tooltip: z.string(),
-    icons: SubscriptionFeatureIconsSchema,
-});
-export type CarryoverBalanceFeature = z.infer<typeof CarryoverBalanceFeatureSchema>;
-
 export const AiModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
     type: z.literal(SUBSCRIPTION_FEATURE_TYPE.AI_MODEL_ACCESS),
     kind: z.literal(SUBSCRIPTION_FEATURE_KIND.AI_MODEL),
@@ -162,8 +134,6 @@ export const SubscriptionFeatureSchema = z.union([
     VideoModelAccessFeatureSchema,
     ExtendedContextFeatureSchema,
     PresentationQuotaFeatureSchema,
-    TokensFeatureSchema,
-    CarryoverBalanceFeatureSchema,
 ]);
 
 export type SubscriptionFeature = z.infer<typeof SubscriptionFeatureSchema>;

package/models/subscription.schema.ts

@@ -28,7 +28,6 @@ export const SubscriptionSchema = z.object({
     features: z.array(SubscriptionFeatureSchema),
     maxInputLength: z.number(),
     maxInputTokens: z.number(),
-    carryoverPercent: z.number(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/tool.schema.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { PageSchema } from './page.schema';
 
 export const ToolSchema = z.object({
     uuid: z.string().uuid(),
@@ -7,16 +6,4 @@ export const ToolSchema = z.object({
     description: z.string(),
     icon: z.string(),
     order: z.number(),
-    contentType: z.string(),
 });
-
-export const ToolFormattedSchema = z.intersection(
-    ToolSchema,
-    z.object({
-        pages: z.array(
-            PageSchema.pick({ alias: true, toolTitle: true, toolOptionId: true })
-                .optional()
-                .nullable(),
-        ),
-    }),
-);

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