@purpleschool/student-works 1.2.2 → 1.4.0

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/presentation-stage.enum.ts

@@ -0,0 +1,13 @@
+export enum PRESENTATION_STAGE {
+    CREATED = 'CREATED',
+
+    GENERATING_OUTLINE = 'GENERATING_OUTLINE',
+    OUTLINE_GENERATED = 'OUTLINE_GENERATED',
+    OUTLINE_GENERATION_FAILED = 'OUTLINE_GENERATION_FAILED',
+
+    GENERATING_SLIDES = 'GENERATING_SLIDES',
+    SLIDES_GENERATED = 'SLIDES_GENERATED',
+    SLIDES_GENERATION_FAILED = 'SLIDES_GENERATION_FAILED',
+
+    DELETED = 'DELETED',
+}

package/constants/presentation/enums/presentation-target-audience.enum.ts

@@ -0,0 +1,6 @@
+export enum PRESENTATION_TARGET_AUDIENCE {
+    NONE = 'NONE',
+    SCHOOL = 'SCHOOL',
+    UNIVERSITY = 'UNIVERSITY',
+    BUSINESS = 'BUSINESS',
+}

package/constants/presentation/enums/slide-content-type.enum.ts

@@ -0,0 +1,12 @@
+export enum SLIDE_CONTENT_TYPE {
+    COVER = 'COVER',
+    TEXT = 'TEXT',
+    TEXT_WITH_IMAGE = 'TEXT_WITH_IMAGE',
+    SECTION_BREAK = 'SECTION_BREAK',
+    STRUCTURED_LIST = 'STRUCTURED_LIST',
+    CONTENTS = 'CONTENTS',
+    THANK_YOU = 'THANK_YOU',
+    TABLE = 'TABLE',
+    CHART = 'CHART',
+    TIMELINE = 'TIMELINE',
+}

package/constants/presentation/enums/slide-icon-slot-status.enum.ts

@@ -0,0 +1,6 @@
+export enum SLIDE_ICON_SLOT_STATUS {
+    PENDING = 'PENDING',
+    IN_PROGRESS = 'IN_PROGRESS',
+    READY = 'READY',
+    ERROR = 'ERROR',
+}

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

@@ -0,0 +1,6 @@
+export enum SLIDE_IMAGE_SLOT_STATUS {
+    PENDING = 'PENDING',
+    IN_PROGRESS = 'IN_PROGRESS',
+    READY = 'READY',
+    ERROR = 'ERROR',
+}

package/constants/presentation/enums/slide-layout.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_LAYOUT {
+    TYPE_1 = 'TYPE_1',
+    TYPE_2 = 'TYPE_2',
+}

package/constants/presentation/index.ts

@@ -0,0 +1,2 @@
+export * from './enums';
+export * from './maps';

package/constants/presentation/maps/index.ts

@@ -0,0 +1 @@
+export * from './slide-layout-map.constant';

package/constants/presentation/maps/slide-layout-map.constant.ts

@@ -0,0 +1,15 @@
+import { SLIDE_CONTENT_TYPE } from '../enums';
+import { SLIDE_LAYOUT } from '../enums/slide-layout.enum';
+
+export const SLIDE_LAYOUT_MAP = new Map<SLIDE_CONTENT_TYPE, SLIDE_LAYOUT[]>([
+    [SLIDE_CONTENT_TYPE.COVER, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.STRUCTURED_LIST, [SLIDE_LAYOUT.TYPE_1, SLIDE_LAYOUT.TYPE_2]],
+    [SLIDE_CONTENT_TYPE.TEXT, [SLIDE_LAYOUT.TYPE_1, SLIDE_LAYOUT.TYPE_2]],
+    [SLIDE_CONTENT_TYPE.SECTION_BREAK, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.CONTENTS, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.TEXT_WITH_IMAGE, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.THANK_YOU, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.TABLE, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.CHART, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.TIMELINE, [SLIDE_LAYOUT.TYPE_1]],
+]);

package/helpers/index.ts

@@ -1,2 +1,3 @@
 export * from './subscription';
 export * from './writer';
+export * from './presentation';

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';
+
+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/index.ts

@@ -23,3 +23,4 @@ export * from './user-referrals.schema';
 export * from './file.schema';
 export * from './solving-edu-task';
 export * from './tools';
+export * from './presentation';

package/models/language.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const LanguageSchema = z.object({
+    uuid: z.string(),
+    name: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/presentation/index.ts

@@ -0,0 +1,9 @@
+export * from './pptx-export-payload.schema';
+export * from './presentation.schema';
+export * from './slide-content-type.schema';
+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';
+export * from './presentation-title-page.schema';

package/models/presentation/pptx-export-payload.schema.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+
+export enum PPTX_SHAPE_TYPE {
+    TEXT_BOX = 'text_box',
+    PICTURE_BOX = 'picture_box',
+    CUSTOM_SHAPE = 'custom_shape',
+    TABLE = 'table',
+    CHEVRON = 'chevron',
+}
+
+export enum PPTX_CHEVRON_DIRECTION {
+    RIGHT = 'right',
+    LEFT = 'left',
+    UP = 'up',
+    DOWN = 'down',
+}
+
+export enum PPTX_ARROW_TYPE {
+    RIGHT = 'rightArrow',
+    LEFT = 'leftArrow',
+    UP = 'upArrow',
+    DOWN = 'downArrow',
+}
+export enum PPTX_H_ALIGN {
+    LEFT = 'left',
+    CENTER = 'center',
+    RIGHT = 'right',
+    JUSTIFY = 'justify',
+}
+
+export enum PPTX_V_ALIGN {
+    TOP = 'top',
+    MIDDLE = 'middle',
+    BOTTOM = 'bottom',
+}
+
+export enum PPTX_OBJECT_FIT {
+    COVER = 'cover',
+    CONTAIN = 'contain',
+    CROP = 'crop',
+}
+
+export enum PPTX_BORDER_TYPE {
+    SOLID = 'solid',
+    NONE = 'none',
+    DASH = 'dash',
+}
+
+export enum PPTX_FILL_TYPE {
+    SOLID = 'solid',
+    NONE = 'none',
+}
+
+export enum PPTX_SHADOW_TYPE {
+    OUTER = 'outer',
+    INNER = 'inner',
+    NONE = 'none',
+}
+
+export enum PPTX_CUSTOM_SHAPE_TYPE {
+    ROUND_RECT = 'roundRect',
+}
+
+export const PPTXShadowSchema = z.object({
+    type: z.nativeEnum(PPTX_SHADOW_TYPE),
+    opacity: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+    color: z.string().optional().describe('hex color'),
+    blur: z.number().min(0).max(100).optional().describe('degrees, range 0-100'),
+    angle: z.number().min(0).max(359).optional().describe('degrees, range 0-359'),
+    offset: z.number().min(0).max(200).optional().describe('points, range 0-200'),
+    rotateWithShape: z.boolean().optional().describe('whether or not to rotate shadow with shape'),
+});
+
+export const PPTXFillSchema = z.object({
+    color: z.string(),
+    type: z.nativeEnum(PPTX_FILL_TYPE),
+    transparency: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+    alpha: z.number().min(0).max(1).optional().describe('range 0-1'),
+});
+
+export const PPTXMarginSchema = z.union([
+    z.number(),
+    z.tuple([z.number(), z.number(), z.number(), z.number()]),
+]);
+export type PPTXMargin = z.infer<typeof PPTXMarginSchema>;
+
+// Common
+export const PPTXPositionSchema = z.object({
+    height: z.number(),
+    width: z.number(),
+    top: z.number(),
+    left: z.number(),
+});
+export type PPTXPosition = z.infer<typeof PPTXPositionSchema>;
+
+export const PPTXFontSchema = z.object({
+    bold: z.boolean().optional(),
+    color: z.string(),
+    name: z.string(),
+    size: z.number(),
+    lineHeight: z
+        .union([
+            z.object({
+                percent: z.number(),
+            }),
+            z.object({
+                px: z.number(),
+            }),
+        ])
+        .optional(),
+});
+export type PPTXFont = z.infer<typeof PPTXFontSchema>;
+
+// Textual
+export const PPTXParagraphSchema = z.object({
+    alignment: z.nativeEnum(PPTX_H_ALIGN),
+    font: PPTXFontSchema,
+    valign: z.nativeEnum(PPTX_V_ALIGN).optional(),
+    margin: PPTXMarginSchema.optional(),
+    rotate: z.number().optional(),
+    text: z.string(),
+});
+export type PPTXParagraph = z.infer<typeof PPTXParagraphSchema>;
+
+export const PPTXTextBoxSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.TEXT_BOX),
+    position: PPTXPositionSchema,
+
+    paragraphs: z.array(PPTXParagraphSchema),
+});
+export type PPTXTextBox = z.infer<typeof PPTXTextBoxSchema>;
+
+// Picture
+export const PPTXPictureBoxSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.PICTURE_BOX),
+    position: PPTXPositionSchema,
+    borderRadius: z.array(z.number()).optional(),
+    objectFit: z.nativeEnum(PPTX_OBJECT_FIT),
+    data: z.union([
+        z.object({
+            base64: z
+                .string()
+                .describe('Base64 encoded image in "image/{mimeType};base64,{bas64}" format'),
+        }),
+        z.object({
+            path: z.string().describe('URL to image'),
+        }),
+    ]),
+});
+export type PPTXPictureBox = z.infer<typeof PPTXPictureBoxSchema>;
+
+// CustomShape
+export const PPTXCustomShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.CUSTOM_SHAPE),
+    customShapeType: z.nativeEnum(PPTX_CUSTOM_SHAPE_TYPE).optional(),
+    position: PPTXPositionSchema,
+    borderRadius: z.number(),
+    fill: PPTXFillSchema.optional(),
+    shadow: PPTXShadowSchema.optional(),
+});
+export type PPTXCustomShape = z.infer<typeof PPTXCustomShapeSchema>;
+
+// Table
+export const PPTXTableCellSchema = z.object({
+    text: z.string().optional(),
+    font: PPTXFontSchema.optional(),
+    fill: z
+        .object({
+            color: z.string(),
+            type: z.nativeEnum(PPTX_FILL_TYPE),
+            transparency: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+        })
+        .optional(),
+    align: z.nativeEnum(PPTX_H_ALIGN).optional(),
+    valign: z.nativeEnum(PPTX_V_ALIGN).optional(),
+    colspan: z.number().int().optional(),
+    rowspan: z.number().int().optional(),
+    margin: PPTXMarginSchema.optional(),
+});
+export type PPTXTableCell = z.infer<typeof PPTXTableCellSchema>;
+
+export const PPTXTableRowSchema = z.array(PPTXTableCellSchema);
+export type PPTXTableRow = z.infer<typeof PPTXTableRowSchema>;
+
+export const PPTXTableShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.TABLE),
+    position: PPTXPositionSchema,
+    rows: z.array(PPTXTableRowSchema),
+    columnWidths: z.array(z.number()).optional(),
+    headerRows: z.number().int().min(0).optional(),
+    border: z.object({
+        type: z.nativeEnum(PPTX_BORDER_TYPE),
+        color: z.string(),
+        px: z.number(),
+    }),
+});
+export type PPTXTableShape = z.infer<typeof PPTXTableShapeSchema>;
+
+// Chevron
+export const PPTXChevronShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.CHEVRON),
+    direction: z.nativeEnum(PPTX_CHEVRON_DIRECTION).default(PPTX_CHEVRON_DIRECTION.RIGHT),
+    position: PPTXPositionSchema,
+    fill: PPTXFillSchema.optional(),
+    text: z.string().optional(),
+    font: PPTXFontSchema.optional(),
+    align: z
+        .nativeEnum(PPTX_H_ALIGN)
+        .optional()
+        .default('center' as PPTX_H_ALIGN),
+    valign: z
+        .nativeEnum(PPTX_V_ALIGN)
+        .optional()
+        .default('middle' as PPTX_V_ALIGN),
+});
+export type PPTXChevronShape = z.infer<typeof PPTXChevronShapeSchema>;
+
+// Overview
+
+export const PPTXShapeSchema = z.discriminatedUnion('type', [
+    PPTXTextBoxSchema,
+    PPTXPictureBoxSchema,
+    PPTXCustomShapeSchema,
+    PPTXTableShapeSchema,
+    PPTXChevronShapeSchema,
+]);
+export type PPTXShape = z.infer<typeof PPTXShapeSchema>;
+
+export const SlideBackground = z.union([
+    PPTXFillSchema,
+    z.object({
+        path: z.string(),
+    }),
+]);
+export type SlideBackground = z.infer<typeof SlideBackground>;
+
+export const PPTXSlideSchema = z.object({
+    background: SlideBackground.optional(),
+    shapes: z.array(PPTXShapeSchema),
+});
+export type PPTXSlide = z.infer<typeof PPTXSlideSchema>;
+
+export const PPTXExportPayloadSchema = z.object({
+    slides: z.array(PPTXSlideSchema),
+});
+export type PPTXExportPayload = z.infer<typeof PPTXExportPayloadSchema>;

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

@@ -0,0 +1,30 @@
+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/presentation/presentation-config.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { SlideContentTypeSchema } from './slide-content-type.schema';
+import { PresentationTemplateSchema } from './presentation-template.schema';
+import { PresentationAiActionSchema } from './presentation-ai-action.schema';
+import { LanguageSchema } from '../language.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/presentation/presentation-template.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const PresentationTemplateSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    image: z.string(),
+    order: z.number(),
+    imagePlaceholder: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/presentation/presentation-title-page.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const PresentationTitlePageSchema = z.object({
+    author: z.string().optional().nullable(),
+    createdAt: z.date().optional().nullable(),
+    email: z.string().email().optional().nullable(),
+});
+
+export type PresentationTitlePage = z.infer<typeof PresentationTitlePageSchema>;

package/models/presentation/presentation.schema.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { SlideOutlineSchema } from './slide-outline.schema';
+import { SlideSchema } from './slide.schema';
+import { PRESENTATION_STAGE, USER_REACTION } from '../../constants';
+import { PresentationTitlePageSchema } from './presentation-title-page.schema';
+
+export const PresentationSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    stage: z.nativeEnum(PRESENTATION_STAGE),
+    title: z.string(),
+    thumbnail: z.string(),
+    languageId: z.string(),
+    templateId: z.string(),
+    downloadUrl: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    slideCount: z.number(),
+    lastContentUpdateAt: z.date().nullable(),
+    lastPptxExportedAt: z.date().nullable(),
+    titlePage: PresentationTitlePageSchema.nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type Presentation = z.infer<typeof PresentationSchema>;
+
+export const PresentationWithSlidesSchema = PresentationSchema.extend({
+    outline: z.array(SlideOutlineSchema),
+    slides: z.array(SlideSchema),
+});
+export type PresentationWithSlides = z.infer<typeof PresentationWithSlidesSchema>;
+
+export const PresentationUpdateSchema = PresentationSchema.pick({
+    title: true,
+    templateId: true,
+    titlePage: true,
+}).partial();
+export type PresentationUpdate = z.infer<typeof PresentationUpdateSchema>;