@purpleschool/gptbot-tools 0.1.133 → 0.2.0-stage

package/marketplace-card/queries/find-marketplace-card-job-by-uuid.query.ts

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

package/marketplace-card/queries/find-marketplace-card-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MarketplaceCardJobSchema } from '../models';
+
+export namespace FindMarketplaceCardJobsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+            title: z.string().optional(),
+            limit: z.coerce.number().min(1).optional(),
+            offset: z.coerce.number().min(0).default(0).optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(MarketplaceCardJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/queries/get-marketplace-card-config.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { MarketplaceCardConfigSchema } from '../models';
+
+export namespace GetMarketplaceCardConfigQuery {
+    export const RequestSchema = z.object({});
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './get-marketplace-card-config.query';
+export * from './find-marketplace-card-job-by-uuid.query';
+export * from './find-marketplace-card-jobs.query';

package/marketplace-card/routes/index.ts

@@ -0,0 +1 @@
+export * from './marketplace-card.amqp.routes';

package/marketplace-card/routes/marketplace-card.amqp.routes.ts

@@ -0,0 +1,12 @@
+export const MARKETPLACE_CARD_AMQP_ROUTES = {
+    CONFIG: 'tools.marketplace-card.config.rpc',
+    EXECUTE: 'tools.marketplace-card.execute.rpc',
+    GET_JOB: 'tools.marketplace-card.jobs.get.rpc',
+    GET_PRICE: 'tools.marketplace-card.get-price.rpc',
+    LIST_JOBS: 'tools.marketplace-card.jobs.list.rpc',
+    SET_REACTION: 'tools.marketplace-card.jobs.set-reaction.rpc',
+    SOFT_DELETE: 'tools.marketplace-card.soft-delete.rpc',
+    RETRY: 'tools.marketplace-card.jobs.retry.rpc',
+    UPDATE_TITLE: 'tools.marketplace-card.jobs.update-title.rpc',
+    SOFT_DELETE_ALL: 'tools.marketplace-card.jobs.soft-delete-all.rpc',
+} as const;

package/package.json

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

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common';
 import { PresentationSchema } from '../models';
+import { PRESENTATION_TARGET_AUDIENCE } from '../enums';
 
 export namespace CreatePresentationCommand {
     export const RequestSchema = z.object({
@@ -10,6 +11,8 @@ export namespace CreatePresentationCommand {
         languageId: z.string(),
         prompt: z.string(),
         slideCount: z.number(),
+        targetAudience: z.nativeEnum(PRESENTATION_TARGET_AUDIENCE).optional(),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common';
-import { PresentationSchema } from '../models';
+import { PresentationSchema, PresentationTitlePageSchema } from '../models';
 
 export namespace GenerateSlidesCommand {
     export const RequestSchema = z.object({
@@ -9,6 +9,7 @@ export namespace GenerateSlidesCommand {
         unregisteredUserId: z.string().uuid().nullable().optional(),
         tokenReservationId: z.string().uuid(),
         precalculatedPrice: z.number(),
+        titlePage: PresentationTitlePageSchema.optional().nullable(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/presentation/commands/get-presentation-slides-generation-price.command.ts

@@ -4,6 +4,7 @@ import { ICommandResponseSchema } from '../../common';
 export namespace GetPresentationSlidesGenerationPriceCommand {
     export const RequestSchema = z.object({
         slideCount: z.number().int().min(1),
+        templateId: z.string().uuid(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/presentation/commands/index.ts

@@ -9,6 +9,7 @@ export * from './export-as-pptx.command';
 export * from './generate-slides.command';
 export * from './get-presentation-slides-generation-price.command';
 export * from './reposition-slide-outline.command';
+export * from './reposition-slide.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation.command';
 export * from './update-presentation-outline.command';

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

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

package/presentation/enums/index.ts

@@ -8,3 +8,4 @@ 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';
+export * from './presentation-target-audience.enum';

package/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/presentation/models/index.ts

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

package/presentation/models/presentation-template.schema.ts

@@ -5,7 +5,9 @@ export const PresentationTemplateSchema = z.object({
     title: z.string(),
     image: z.string(),
     order: z.number(),
+    price: z.number(),
     imagePlaceholder: z.string(),
+    isPremium: z.boolean(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/presentation/models/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/presentation/models/presentation.schema.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { PRESENTATION_STAGE } from '../enums';
+import { PRESENTATION_STAGE, PRESENTATION_TARGET_AUDIENCE } from '../enums';
 import { SlideOutlineSchema } from './slide-outline.schema';
 import { SlideSchema } from './slide.schema';
 import { USER_REACTION } from '../../common';
+import { PresentationTitlePageSchema } from './presentation-title-page.schema';
 
 export const PresentationSchema = z.object({
     uuid: z.string().uuid(),
@@ -22,6 +23,8 @@ export const PresentationSchema = z.object({
     tokenReservationId: z.string().nullable().optional(),
     lastContentUpdateAt: z.date().nullable(),
     lastPptxExportedAt: z.date().nullable(),
+    titlePage: PresentationTitlePageSchema.nullable(),
+    targetAudience: z.nativeEnum(PRESENTATION_TARGET_AUDIENCE),
     createdAt: z.date(),
     updatedAt: z.date(),
 });
@@ -36,5 +39,6 @@ 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>;

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

@@ -19,36 +19,48 @@ import {
 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),
-    }),
+    author: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    date: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    email: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
     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),
-    }),
+    author: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    date: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    email: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
     version: z.literal(1),
 }) satisfies z.ZodType<IThankYouSlideDataStructure>;