@purpleschool/gptbot-tools 0.0.66 → 0.0.68

package/build/presentation/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculate-presentation-ai-action-price.util"), exports);

package/build/tools/enums/tool-type.enum.js

@@ -8,6 +8,7 @@ var TOOL_TYPE;
     TOOL_TYPE["VIDEO"] = "VIDEO";
     TOOL_TYPE["AUDIO"] = "AUDIO";
     TOOL_TYPE["PRESENTATION"] = "PRESENTATION";
+    TOOL_TYPE["PRESENTATION_AI_ACTION"] = "PRESENTATION_AI_ACTION";
     TOOL_TYPE["WRITER"] = "WRITER";
     TOOL_TYPE["PARAPHRASE"] = "PARAPHRASE";
     TOOL_TYPE["WRITER_ACTION"] = "WRITER_ACTION";

package/build/video/enums/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./veo-person-allow.enum"), exports);
 __exportStar(require("./veo-job-params-type.enum"), exports);
 __exportStar(require("./video-resolution.enum"), exports);
 __exportStar(require("./video-pricing-rule-type.enum"), exports);
+__exportStar(require("./video-generation-model-limitation.enum"), exports);

package/build/video/enums/video-generation-model-limitation.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_GENERATION_MODEL_LIMITATION = void 0;
+var VIDEO_GENERATION_MODEL_LIMITATION;
+(function (VIDEO_GENERATION_MODEL_LIMITATION) {
+    VIDEO_GENERATION_MODEL_LIMITATION["ASPECT_RATIO_IGNORED_WITH_IMAGE_ATTACHED"] = "ASPECT_RATIO_IGNORED_WITH_IMAGE_ATTACHED";
+})(VIDEO_GENERATION_MODEL_LIMITATION || (exports.VIDEO_GENERATION_MODEL_LIMITATION = VIDEO_GENERATION_MODEL_LIMITATION = {}));

package/build/video/models/video-model.schema.js

@@ -46,6 +46,7 @@ exports.VideoModelSchema = zod_1.z.object({
     maxInputLength: zod_1.z.number(),
     params: exports.VideoModelParamsSchema,
     pricingRules: exports.VideoModelPricingRulesSchema,
+    limitations: zod_1.z.array(zod_1.z.nativeEnum(enums_1.VIDEO_GENERATION_MODEL_LIMITATION)),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/video-editor/enums/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./video-editor-model-limitation.enum"), exports);
 __exportStar(require("./video-editor-model-strategy.enum"), exports);

package/build/video-editor/enums/video-editor-model-limitation.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_EDITOR_MODEL_LIMITATION = void 0;
+var VIDEO_EDITOR_MODEL_LIMITATION;
+(function (VIDEO_EDITOR_MODEL_LIMITATION) {
+    VIDEO_EDITOR_MODEL_LIMITATION["OUTPUT_VIDEO_LENGTH_CAPPED_TO_5_SECONDS"] = "OUTPUT_VIDEO_LENGTH_CAPPED_TO_5_SECONDS";
+})(VIDEO_EDITOR_MODEL_LIMITATION || (exports.VIDEO_EDITOR_MODEL_LIMITATION = VIDEO_EDITOR_MODEL_LIMITATION = {}));

package/build/video-editor/models/video-editor-model.schema.js

@@ -9,7 +9,6 @@ exports.VideoEditorModelSchema = zod_1.z.object({
     title: zod_1.z.string(),
     description: zod_1.z.string(),
     aiModel: zod_1.z.string(),
-    pricePerSecond: zod_1.z.number(),
     order: zod_1.z.number(),
     status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
     icons: common_1.IconVariantsSchema,
@@ -19,6 +18,8 @@ exports.VideoEditorModelSchema = zod_1.z.object({
     maxInputVideoDurationInSeconds: zod_1.z.number(),
     supportedFormats: zod_1.z.array(zod_1.z.string()),
     needsTranslation: zod_1.z.boolean(),
+    pricePerCall: zod_1.z.number(),
+    limitations: zod_1.z.array(zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_MODEL_LIMITATION)),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/video-editor/utils/calculate-video-editing-price.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateVideoEditingPrice = calculateVideoEditingPrice;
-function calculateVideoEditingPrice({ duration, pricePerSecond, }) {
-    if (duration <= 0)
-        throw new Error('Duration must be positive');
-    if (pricePerSecond < 0)
-        throw new Error('Price per second cannot be negative');
-    return Math.ceil(duration * pricePerSecond);
+function calculateVideoEditingPrice({ pricePerCall }) {
+    return pricePerCall;
 }

package/build/writer/queries/find-writer-documents.query.js

@@ -9,7 +9,7 @@ var FindWriterDocumentsQuery;
     FindWriterDocumentsQuery.RequestSchema = zod_1.z.object({
         userId: zod_1.z.string().uuid().optional(),
         unregisteredUserId: zod_1.z.string().uuid().optional(),
-        title: zod_1.z.string().optional(),
+        topic: zod_1.z.string().optional(),
         limit: zod_1.z.coerce.number().min(1).optional(),
         offset: zod_1.z.coerce.number().min(0).optional(),
     });

package/common/errors/errors.ts

@@ -347,6 +347,95 @@ export const ERRORS = {
             message: 'У пользователя недостаточно средств для генерации слайдов',
             httpCode: 400,
         },
+        CREATE_BLANK_SLIDE_ERROR: {
+            code: 'PRESENTATION.CREATE_BLANK_SLIDE_ERROR',
+            message: 'Произошла ошибка при создании пустого слайда',
+            httpCode: 500,
+        },
+        INVALID_CONTENT_TYPE_CHANGE: {
+            code: 'PRESENTATION.INVALID_CONTENT_TYPE_CHANGE',
+            message: 'Невозможно изменить тип существующего слайда',
+            httpCode: 400,
+        },
+        INVALID_SLIDE_POSITION: {
+            code: 'PRESENTATION.INVALID_SLIDE_POSITION',
+            message: 'Неверная позиция для вставки слайда',
+            httpCode: 400,
+        },
+        SLIDES_UPDATE_ERROR: {
+            code: 'PRESENTATION.SLIDES_UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении слайдов презентации',
+            httpCode: 500,
+        },
+        SLIDE_NOT_FOUND: {
+            code: 'PRESENTATION.SLIDE_NOT_FOUND',
+            message: 'Слайд не найден',
+            httpCode: 404,
+        },
+        SLIDE_IMAGE_SLOT_NOT_FOUND: {
+            code: 'PRESENTATION.SLIDE_IMAGE_SLOT_NOT_FOUND',
+            message: 'Слот изображения слайда не найден',
+            httpCode: 404,
+        },
+        SLIDE_IMAGE_UPDATE_ERROR: {
+            code: 'PRESENTATION.SLIDE_IMAGE_UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении слота изображения слайда',
+            httpCode: 500,
+        },
+        INSUFFICIENT_BALANCE_FOR_IMAGE_GENERATION: {
+            code: 'PRESENTATION.INSUFFICIENT_BALANCE_FOR_IMAGE_GENERATION',
+            message: 'У пользователя недостаточно средств для генерации изображения',
+            httpCode: 400,
+        },
+    },
+    PRESENTATION_AI_ACTION: {
+        NOT_FOUND: {
+            code: 'PRESENTATION_AI_ACTION.NOT_FOUND',
+            message: 'ИИ операция для презентации не найдено',
+            httpCode: 404,
+        },
+        PROMPT_TOO_LONG: {
+            code: 'PRESENTATION_AI_ACTION.PROMPT_TOO_LONG',
+            message: 'Превышена максимальная длина запроса',
+            httpCode: 400,
+        },
+        INSUFFICIENT_BALANCE: {
+            code: 'PRESENTATION_AI_ACTION.INSUFFICIENT_BALANCE',
+            message: 'У пользователя недостаточно средств для выполнения операции',
+            httpCode: 400,
+        },
+        AI_ERROR: {
+            code: 'PRESENTATION_AI_ACTION.AI_ERROR',
+            message: 'Произошла ошибка во время запроса к ИИ',
+            httpCode: 500,
+        },
+        SAVE_ERROR: {
+            code: 'PRESENTATION_AI_ACTION.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении ИИ операции для презентации',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'PRESENTATION_AI_ACTION.FIND_ERROR',
+            message: 'Произошла ошибка при поиске ИИ операций для презентации',
+            httpCode: 500,
+        },
+    },
+    PRESENTATION_AI_ACTION_CALL: {
+        NOT_FOUND: {
+            code: 'PRESENTATION_AI_ACTION_CALL.NOT_FOUND',
+            message: 'Вызов ИИ операции для презентации не найден',
+            httpCode: 404,
+        },
+        SAVE_ERROR: {
+            code: 'PRESENTATION_AI_ACTION_CALL.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении вызова ИИ операции для презентации',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'PRESENTATION_AI_ACTION_CALL.FIND_ERROR',
+            message: 'Произошла ошибка при поиске вызова ИИ операции для презентации',
+            httpCode: 500,
+        },
     },
     SLIDE_OUTLINE: {
         DELETE_ERROR: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

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

@@ -0,0 +1,15 @@
+import { ICommandResponseSchema } from '../../common';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+import { z } from 'zod';
+import { SlideSchema } from '../models';
+
+export namespace BuildBlankSlideCommand {
+    export const RequestSchema = z.object({
+        slideContentType: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+import { SlideSchema } from '../models';
+
+export namespace GenerateAndInsertSlideCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        presentationId: z.string().uuid(),
+        contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        prompt: z.string().min(1).max(1000).optional(),
+        title: z.string().max(80),
+        position: z.number().int().min(0),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema.array());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/commands/index.ts

@@ -1,11 +1,18 @@
+export * from './build-blank-slide.command';
 export * from './create-presentation.command';
 export * from './delete-all-user-presentations.command';
 export * from './delete-presentation.command';
 export * from './delete-slide-outline.command';
 export * from './generate-presentation-outline.command';
+export * from './generate-and-insert-slide.command';
 export * from './export-as-pptx.command';
 export * from './generate-slides.command';
 export * from './reposition-slide-outline.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation.command';
 export * from './update-presentation-outline.command';
+export * from './update-presentation-slides.command';
+export * from './update-slide-image-slot.command';
+export * from './update-slide.command';
+export * from './presentation-paraphrase.command';
+export * from './presentation-generate-report.command';

package/presentation/commands/presentation-generate-report.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace PresentationGenerateReportCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+            docxUrl: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace PresentationParaphraseCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { SlideSchema, SlideBulkUpdateSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdatePresentationSlidesCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        data: SlideBulkUpdateSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.array(SlideSchema));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SlideImageSlotSchema } from '../models';
+import { SLIDE_IMAGE_SLOT_ACTION } from '../enums';
+
+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({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        slotId: z.string().uuid().optional(),
+        payload: UpdateImageSlotPayload,
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            imageSlot: SlideImageSlotSchema,
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { SlideSchema, SlideUpdateSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateSlideCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        data: SlideUpdateSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/enums/index.ts

@@ -4,3 +4,7 @@ export * from './slide-image-job-status.enum';
 export * from './slide-image-slot-status.enum';
 export * from './slide-icon-slot-status.enum';
 export * from './slide-layout.enum';
+export * from './slide-image-slot-action.enum';
+export * from './presentation-ai-action-call-status.enum';
+export * from './presentation-ai-action-type.enum';
+export * from './presentation-ai-action-pricing-type.enum';

package/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/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/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/presentation/enums/slide-image-slot-action.enum.ts

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

package/presentation/index.ts

@@ -4,3 +4,4 @@ export * from './models';
 export * from './enums';
 export * from './routes';
 export * from './queries';
+export * from './utils';

package/presentation/models/index.ts

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

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { PRESENTATION_AI_ACTION_PRICING_TYPE, PRESENTATION_AI_ACTION_TYPE } from '../enums';
+
+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/presentation/models/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/presentation/models/presentation.schema.ts

@@ -16,6 +16,8 @@ export const PresentationSchema = z.object({
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),
     isDeleted: z.boolean(),
+    lastContentUpdateAt: z.date().nullable(),
+    lastPptxExportedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });
@@ -29,5 +31,6 @@ export type PresentationWithSlides = z.infer<typeof PresentationWithSlidesSchema
 
 export const PresentationUpdateSchema = PresentationSchema.pick({
     title: true,
-});
+    templateId: true,
+}).partial();
 export type PresentationUpdate = z.infer<typeof PresentationUpdateSchema>;