@purpleschool/gptbot-tools 0.2.49 → 0.2.50-stage-2

package/photo-sessions/models/photo-session-model.schema.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS, IconVariantsSchema } from '../../common';
+import { PHOTO_SESSION_STRATEGY } from '../enums';
+
+export const PhotoSessionModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+    aspectRatio: z.record(
+        z.string(),
+        z.object({
+            width: z.number(),
+            height: z.number(),
+        }),
+    ),
+});
+
+export type PhotoSessionModelParams = z.infer<typeof PhotoSessionModelParamsSchema>;
+
+export const PhotoSessionModelPricingRuleConditionSchema = z.object({
+    withoutSub: z.boolean().optional(),
+});
+export type PhotoSessionModelPricingRuleCondition = z.infer<
+    typeof PhotoSessionModelPricingRuleConditionSchema
+>;
+
+export const PhotoSessionModelPricingRulesSchema = z.array(
+    z.object({
+        condition: PhotoSessionModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type PhotoSessionModelPricingRules = z.infer<typeof PhotoSessionModelPricingRulesSchema>;
+
+export const PhotoSessionModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    isNew: z.boolean(),
+    tierLabel: z.string(),
+    pricePerImage: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(PHOTO_SESSION_STRATEGY),
+    maxInputLength: z.number(),
+    params: PhotoSessionModelParamsSchema,
+    pricingRules: PhotoSessionModelPricingRulesSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type PhotoSessionModel = z.infer<typeof PhotoSessionModelSchema>;

package/photo-sessions/models/photo-session-style.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+export const PhotoSessionStyleReferenceSchema = z.object({
+    uuid: z.string().uuid(),
+    styleId: z.string().uuid(),
+    photoUrl: z.string(),
+    description: z.string().nullable().optional(),
+    order: z.number().int().min(0).max(5),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type PhotoSessionStyleReference = z.infer<typeof PhotoSessionStyleReferenceSchema>;
+
+export const PhotoSessionStyleSchema = z.object({
+    uuid: z.string().uuid(),
+    code: z.string(),
+    title: z.string(),
+    description: z.string().nullable().optional(),
+    references: z.array(PhotoSessionStyleReferenceSchema),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type PhotoSessionStyle = z.infer<typeof PhotoSessionStyleSchema>;

package/photo-sessions/queries/find-photo-session-style-by-id.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionStyleSchema } from '../models';
+
+export namespace FindPhotoSessionStyleByIdQuery {
+    export const RequestSchema = PhotoSessionStyleSchema.pick({ uuid: true });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionStyleSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/queries/find-photo-session-styles.query.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionStyleSchema } from '../models';
+
+export namespace FindPhotoSessionStylesQuery {
+    export const RequestSchema = z.object({
+        limit: z.coerce.number().min(1).max(48).optional().default(24),
+        offset: z.coerce.number().min(0).optional().default(0),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(PhotoSessionStyleSchema),
+            page: z.number(),
+            totalPages: z.number(),
+            total: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/queries/find-photo-sessions-job-by-id.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+
+export namespace FindPhotoSessionsJobByIdQuery {
+    export const RequestSchema = PhotoSessionJobSchema.pick({ uuid: true });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/queries/find-photo-sessions-jobs.query.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { JOB_SCOPE } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
+
+export namespace FindPhotoSessionsJobsQuery {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().optional(),
+        unregisteredUserId: z.string().uuid().optional(),
+        scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
+        title: z.string().optional(),
+        isFavorite: z.coerce.boolean().optional(),
+        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+        status: z.nativeEnum(JOB_STATUS).optional(),
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).default(0).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(PhotoSessionJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+            total: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/queries/get-photo-sessions-config.query.ts

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

package/photo-sessions/queries/index.ts

@@ -0,0 +1,5 @@
+export * from './find-photo-sessions-job-by-id.query';
+export * from './find-photo-sessions-jobs.query';
+export * from './get-photo-sessions-config.query';
+export * from './find-photo-session-styles.query';
+export * from './find-photo-session-style-by-id.query';

package/photo-sessions/routes/index.ts

@@ -0,0 +1,2 @@
+export * from './photo-sessions.amqp.routes';
+export * from './photo-sessions.http.routes';

package/photo-sessions/routes/photo-sessions.amqp.routes.ts

@@ -0,0 +1,19 @@
+export const PHOTO_SESSIONS_AMQP_ROUTES = {
+    EXECUTE: 'tools.photo-sessions.execute.rpc',
+    GET_PRICE: 'tools.photo-sessions.get-price.rpc',
+    CONFIG: 'tools.photo-sessions.config.rpc',
+    GET_JOB: 'tools.photo-sessions.jobs.get.rpc',
+    LIST_JOBS: 'tools.photo-sessions.jobs.list.rpc',
+    SET_REACTION: 'tools.photo-sessions.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.photo-sessions.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.photo-sessions.jobs.update-favorite.rpc',
+    SOFT_DELETE: 'tools.photo-sessions.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.photo-sessions.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.photo-sessions.jobs.retry.rpc',
+    UPDATE_JOB: 'tools.photo-sessions.jobs.update.rpc',
+    LIST_STYLES: 'tools.photo-sessions.styles.list.rpc',
+    GET_STYLE: 'tools.photo-sessions.styles.get.rpc',
+    CREATE_STYLE: 'tools.photo-sessions.styles.create.rpc',
+    UPDATE_STYLE: 'tools.photo-sessions.styles.update.rpc',
+    DELETE_STYLE: 'tools.photo-sessions.styles.delete.rpc',
+} as const;

package/photo-sessions/routes/photo-sessions.http.routes.ts

@@ -0,0 +1 @@
+export const PHOTO_SESSIONS_CONTROLLER = 'photo-sessions';

package/tools/enums/tool-content-type.enum.ts

@@ -16,5 +16,6 @@ export enum TOOL_CONTENT_TYPE {
     SPELL_CORRECTOR = 'SPELL_CORRECTOR',
     DIAGRAMS = 'DIAGRAMS',
     HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
+    PHOTO_SESSIONS = 'PHOTO_SESSIONS',
     IMAGE_RECOGNITION = 'IMAGE_RECOGNITION',
 }

package/tools/enums/tool-type.enum.ts

@@ -18,5 +18,6 @@ export enum TOOL_TYPE {
     SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
     DIAGRAMS = 'DIAGRAMS',
     HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
+    PHOTO_SESSION = 'PHOTO_SESSION',
     IMAGE_RECOGNITION = 'IMAGE_RECOGNITION',
 }

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

@@ -16,6 +16,7 @@ import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
 import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
 import { DiagramsConfigSchema } from '../../diagrams';
 import { HtmlPageBuilderConfigSchema } from '../../html-page-builder/models';
+import { PhotoSessionConfigSchema } from '../../photo-sessions';
 import { ImageRecognitionConfigSchema } from '../../image-recognition';
 
 export const GlobalToolsConfigSchema = z.object({
@@ -35,6 +36,7 @@ export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: SpellCorrectorToolConfigSchema,
     [TOOL_CONTENT_TYPE.DIAGRAMS]: DiagramsConfigSchema,
     [TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: HtmlPageBuilderConfigSchema,
+    [TOOL_CONTENT_TYPE.PHOTO_SESSIONS]: PhotoSessionConfigSchema,
     [TOOL_CONTENT_TYPE.IMAGE_RECOGNITION]: ImageRecognitionConfigSchema,
 });