@goscribe/server 1.3.4 → 1.5.0

package/src/services/content/worksheet.service.ts

@@ -0,0 +1,751 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import {
+  mergeWorksheetGenerationConfig,
+  normalizeWorksheetProblemForDb,
+  parsePresetConfig,
+  type WorksheetMode,
+  type WorksheetPresetConfig,
+  type WorksheetDifficultyInput,
+} from './worksheet-generation.service.js';
+import { mergeWorksheetQuestionProgress } from './worksheet-content.service.js';
+
+const Difficulty = { EASY: 'EASY', MEDIUM: 'MEDIUM', HARD: 'HARD' } as const;
+const QuestionType = {
+  MULTIPLE_CHOICE: 'MULTIPLE_CHOICE',
+  TEXT: 'TEXT',
+  NUMERIC: 'NUMERIC',
+  TRUE_FALSE: 'TRUE_FALSE',
+  MATCHING: 'MATCHING',
+  FILL_IN_THE_BLANK: 'FILL_IN_THE_BLANK',
+} as const;
+
+type DifficultyUpper = 'EASY' | 'MEDIUM' | 'HARD';
+
+export interface CreateWorksheetInput {
+  workspaceId: string;
+  title: string;
+  description?: string;
+  difficulty?: DifficultyUpper;
+  estimatedTime?: string;
+  problems?: Array<{
+    question: string;
+    answer: string;
+    type: keyof typeof QuestionType;
+    options?: string[];
+  }>;
+}
+
+export interface UpdateWorksheetInput {
+  id: string;
+  title?: string;
+  description?: string;
+  difficulty?: DifficultyUpper;
+  estimatedTime?: string;
+  problems?: Array<{
+    id?: string;
+    question: string;
+    answer: string;
+    type: keyof typeof QuestionType;
+    options?: string[];
+  }>;
+}
+
+export interface GenerateWorksheetInput {
+  workspaceId: string;
+  prompt: string;
+  numQuestions: number;
+  difficulty: WorksheetDifficultyInput;
+  mode?: WorksheetMode;
+  presetId?: string;
+  configOverride?: Partial<WorksheetPresetConfig>;
+  title?: string;
+  estimatedTime?: string;
+}
+
+export class WorksheetService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async list(userId: string, workspaceId: string) {
+    const worksheets = await this.db.artifact.findMany({
+      where: { workspaceId, type: ArtifactType.WORKSHEET },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+        questions: true,
+      },
+      orderBy: { updatedAt: 'desc' },
+    });
+    if (!worksheets) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const allQuestionIds = worksheets.flatMap((w) => w.questions.map((q) => q.id));
+    if (allQuestionIds.length === 0) return worksheets;
+
+    const progress = await this.db.worksheetQuestionProgress.findMany({
+      where: { userId, worksheetQuestionId: { in: allQuestionIds } },
+    });
+
+    return worksheets.map((w) => ({
+      ...w,
+      questions: mergeWorksheetQuestionProgress(w.questions, progress),
+    }));
+  }
+
+  async listPresets(userId: string, workspaceId: string) {
+    const ws = await this.db.workspace.findFirst({
+      where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+    });
+    if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    return this.db.worksheetPreset.findMany({
+      where: {
+        OR: [
+          { isSystem: true },
+          {
+            userId,
+            OR: [{ workspaceId }, { workspaceId: null }],
+          },
+        ],
+      },
+      orderBy: [{ isSystem: 'desc' }, { name: 'asc' }],
+    });
+  }
+
+  async createPreset(
+    userId: string,
+    input: { workspaceId?: string; name: string; config: Record<string, unknown> },
+  ) {
+    if (input.workspaceId) {
+      const ws = await this.db.workspace.findFirst({
+        where: { id: input.workspaceId, ...workspaceAccessWhere(userId) },
+      });
+      if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
+    }
+    const config = parsePresetConfig(input.config);
+    return this.db.worksheetPreset.create({
+      data: {
+        userId,
+        workspaceId: input.workspaceId ?? null,
+        name: input.name,
+        isSystem: false,
+        config: config as object,
+      },
+    });
+  }
+
+  async updatePreset(
+    userId: string,
+    input: { id: string; name?: string; config?: Record<string, unknown> },
+  ) {
+    const existing = await this.db.worksheetPreset.findFirst({
+      where: { id: input.id, userId, isSystem: false },
+    });
+    if (!existing) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found or read-only' });
+    }
+
+    const data: { name?: string; config?: object } = {};
+    if (input.name !== undefined) data.name = input.name;
+    if (input.config !== undefined) data.config = parsePresetConfig(input.config) as object;
+
+    return this.db.worksheetPreset.update({
+      where: { id: input.id },
+      data,
+    });
+  }
+
+  async deletePreset(userId: string, id: string) {
+    const existing = await this.db.worksheetPreset.findFirst({
+      where: { id, userId, isSystem: false },
+    });
+    if (!existing) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found or read-only' });
+    }
+
+    await this.db.worksheetPreset.delete({ where: { id } });
+    return true;
+  }
+
+  async create(userId: string, input: CreateWorksheetInput) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: input.workspaceId, ownerId: userId },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const { problems } = input;
+
+    return this.db.artifact.create({
+      data: {
+        workspaceId: input.workspaceId,
+        type: ArtifactType.WORKSHEET,
+        title: input.title,
+        difficulty: input.difficulty as any,
+        estimatedTime: input.estimatedTime,
+        createdById: userId,
+        questions: problems
+          ? {
+              create: problems.map((problem, index) => ({
+                prompt: problem.question,
+                answer: problem.answer,
+                type: problem.type as any,
+                order: index,
+                meta: problem.options ? { options: problem.options } : undefined,
+              })),
+            }
+          : undefined,
+      },
+      include: { questions: true },
+    });
+  }
+
+  async get(userId: string, worksheetId: string) {
+    const worksheet = await this.db.artifact.findFirst({
+      where: {
+        id: worksheetId,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: { questions: true },
+      orderBy: { updatedAt: 'desc' },
+    });
+    if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const questionIds = worksheet.questions.map((q) => q.id);
+    const progress =
+      questionIds.length === 0
+        ? []
+        : await this.db.worksheetQuestionProgress.findMany({
+            where: { userId, worksheetQuestionId: { in: questionIds } },
+          });
+
+    return {
+      ...worksheet,
+      questions: mergeWorksheetQuestionProgress(worksheet.questions, progress),
+    };
+  }
+
+  async createWorksheetQuestion(
+    userId: string,
+    input: {
+      worksheetId: string;
+      prompt: string;
+      answer?: string;
+      type?: keyof typeof QuestionType;
+      difficulty?: DifficultyUpper;
+      order?: number;
+      meta?: Record<string, unknown>;
+    },
+  ) {
+    const worksheet = await this.db.artifact.findFirst({
+      where: {
+        id: input.worksheetId,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+    if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+    return this.db.worksheetQuestion.create({
+      data: {
+        artifactId: input.worksheetId,
+        prompt: input.prompt,
+        answer: input.answer,
+        type: (input.type ?? QuestionType.TEXT) as any,
+        difficulty: (input.difficulty ?? Difficulty.MEDIUM) as any,
+        order: input.order ?? 0,
+        meta: input.meta as any,
+      },
+    });
+  }
+
+  async updateWorksheetQuestion(
+    userId: string,
+    input: {
+      worksheetQuestionId: string;
+      prompt?: string;
+      answer?: string;
+      type?: keyof typeof QuestionType;
+      difficulty?: DifficultyUpper;
+      order?: number;
+      meta?: Record<string, unknown>;
+    },
+  ) {
+    const q = await this.db.worksheetQuestion.findFirst({
+      where: {
+        id: input.worksheetQuestionId,
+        artifact: {
+          type: ArtifactType.WORKSHEET,
+          workspace: workspaceAccessWhere(userId),
+        },
+      },
+    });
+    if (!q) throw new TRPCError({ code: 'NOT_FOUND' });
+    return this.db.worksheetQuestion.update({
+      where: { id: input.worksheetQuestionId },
+      data: {
+        prompt: input.prompt ?? q.prompt,
+        answer: input.answer ?? q.answer,
+        type: (input.type ?? q.type) as any,
+        difficulty: (input.difficulty ?? q.difficulty) as any,
+        order: input.order ?? q.order,
+        meta: (input.meta ?? q.meta) as any,
+      },
+    });
+  }
+
+  async deleteWorksheetQuestion(userId: string, worksheetQuestionId: string) {
+    const q = await this.db.worksheetQuestion.findFirst({
+      where: {
+        id: worksheetQuestionId,
+        artifact: { workspace: workspaceAccessWhere(userId) },
+      },
+    });
+    if (!q) throw new TRPCError({ code: 'NOT_FOUND' });
+    await this.db.worksheetQuestion.delete({ where: { id: worksheetQuestionId } });
+    return true;
+  }
+
+  async updateProblemStatus(
+    userId: string,
+    input: { problemId: string; completed: boolean; answer?: string; correct?: boolean },
+  ) {
+    const question = await this.db.worksheetQuestion.findFirst({
+      where: {
+        id: input.problemId,
+        artifact: {
+          type: ArtifactType.WORKSHEET,
+          workspace: workspaceAccessWhere(userId),
+        },
+      },
+    });
+    if (!question) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    return this.db.worksheetQuestionProgress.upsert({
+      where: {
+        worksheetQuestionId_userId: {
+          worksheetQuestionId: input.problemId,
+          userId,
+        },
+      },
+      create: {
+        worksheetQuestionId: input.problemId,
+        userId,
+        modified: input.completed,
+        userAnswer: input.answer,
+        correct: input.correct,
+        completedAt: input.completed ? new Date() : null,
+        attempts: 1,
+      },
+      update: {
+        modified: input.completed,
+        userAnswer: input.answer,
+        completedAt: input.completed ? new Date() : null,
+        attempts: { increment: 1 },
+        correct: input.correct,
+      },
+    });
+  }
+
+  async getProgress(userId: string, worksheetId: string) {
+    const worksheet = await this.db.artifact.findFirst({
+      where: {
+        id: worksheetId,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+    if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const questions = await this.db.worksheetQuestion.findMany({
+      where: { artifactId: worksheetId },
+      select: { id: true },
+    });
+    const questionIds = questions.map((q) => q.id);
+
+    return this.db.worksheetQuestionProgress.findMany({
+      where: { userId, worksheetQuestionId: { in: questionIds } },
+    });
+  }
+
+  async update(userId: string, input: UpdateWorksheetInput) {
+    const { id, problems, ...updateData } = input;
+
+    const existingWorksheet = await this.db.artifact.findFirst({
+      where: {
+        id,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+    if (!existingWorksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    if (problems) {
+      await this.db.worksheetQuestion.deleteMany({ where: { artifactId: id } });
+
+      await this.db.worksheetQuestion.createMany({
+        data: problems.map((problem, index) => ({
+          artifactId: id,
+          prompt: problem.question,
+          answer: problem.answer,
+          type: problem.type as any,
+          order: index,
+          meta: problem.options ? { options: problem.options } : undefined,
+        })),
+      });
+    }
+
+    const processedUpdateData = {
+      ...updateData,
+      difficulty: updateData.difficulty as any,
+    };
+
+    return this.db.artifact.update({
+      where: { id },
+      data: processedUpdateData,
+      include: {
+        questions: { orderBy: { order: 'asc' } },
+      },
+    });
+  }
+
+  async delete(userId: string, id: string) {
+    const deleted = await this.db.artifact.deleteMany({
+      where: {
+        id,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+    if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
+    return true;
+  }
+
+  async generateFromPrompt(userId: string, input: GenerateWorksheetInput) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: input.workspaceId, ...workspaceAccessWhere(userId) },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    let presetRow: Awaited<ReturnType<typeof this.db.worksheetPreset.findFirst>> = null;
+    if (input.presetId) {
+      presetRow = await this.db.worksheetPreset.findFirst({
+        where: {
+          id: input.presetId,
+          OR: [
+            { isSystem: true },
+            {
+              userId,
+              OR: [{ workspaceId: input.workspaceId }, { workspaceId: null }],
+            },
+          ],
+        },
+      });
+      if (!presetRow) throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found' });
+    }
+
+    const presetConfig = presetRow?.config ? parsePresetConfig(presetRow.config) : undefined;
+
+    const resolved = mergeWorksheetGenerationConfig(presetConfig, input.configOverride ?? undefined, {
+      numQuestions: input.numQuestions,
+      difficulty: input.difficulty,
+      mode: input.mode,
+    });
+
+    const difficultyUpper = resolved.difficulty.toUpperCase() as DifficultyUpper;
+
+    console.log('[DEBUG TRPC PAYLOAD] input =', input);
+    console.log('[DEBUG TRPC PAYLOAD] presetConfig =', presetConfig);
+    console.log('[DEBUG TRPC PAYLOAD] legacy merged legacy values:', {
+      numQuestions: input.numQuestions,
+      difficulty: input.difficulty,
+      mode: input.mode,
+    });
+    console.log('[DEBUG TRPC PAYLOAD] RESOLVED =', resolved);
+
+    const worksheetConfigSnapshot = {
+      mode: resolved.mode,
+      presetId: input.presetId ?? null,
+      presetName: presetRow?.name ?? null,
+      numQuestions: resolved.numQuestions,
+      difficulty: resolved.difficulty,
+      mcqRatio: resolved.mcqRatio ?? null,
+      questionTypes: resolved.questionTypes ?? null,
+    };
+
+    await PusherService.emitWorksheetGenerationStart(input.workspaceId);
+
+    const artifact = await this.db.artifact.create({
+      data: {
+        workspaceId: input.workspaceId,
+        type: ArtifactType.WORKSHEET,
+        title:
+          input.title ||
+          (resolved.mode === 'quiz'
+            ? `Quiz - ${new Date().toLocaleString()}`
+            : `Worksheet - ${new Date().toLocaleString()}`),
+        createdById: userId,
+        difficulty: difficultyUpper as any,
+        estimatedTime: input.estimatedTime,
+        generating: true,
+        generatingMetadata: {
+          quantity: resolved.numQuestions,
+          difficulty: resolved.difficulty,
+          mode: resolved.mode,
+          presetId: input.presetId ?? null,
+        },
+        worksheetConfig: worksheetConfigSnapshot as object,
+      },
+    });
+
+    await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_info', {
+      contentLength: resolved.numQuestions,
+    });
+    await PusherService.emitWorksheetNew(input.workspaceId, artifact);
+
+    const workspaceId = input.workspaceId;
+    const promptText = input.prompt;
+    const estTime = input.estimatedTime;
+
+    (async () => {
+      try {
+        const ragContext = await workspaceKbService.retrieveContext(
+          workspaceId,
+          promptText ?? 'worksheet practice questions concepts problems',
+          8,
+        );
+
+        const content = await ai.backend.generateWorksheetQuestions(
+          workspaceId,
+          userId,
+          resolved.numQuestions,
+          difficultyUpper,
+          {
+            mode: resolved.mode,
+            mcqRatio: resolved.mcqRatio,
+            questionTypes: resolved.questionTypes,
+            prompt: promptText,
+            ragContext,
+          },
+        );
+
+        let problems: any[] = [];
+        try {
+          const worksheetData = JSON.parse(content);
+          let actualWorksheetData: any = worksheetData;
+          if (worksheetData.last_response) {
+            try {
+              actualWorksheetData = JSON.parse(worksheetData.last_response);
+            } catch {
+              /* noop */
+            }
+          }
+          problems =
+            actualWorksheetData.problems ||
+            actualWorksheetData.questions ||
+            actualWorksheetData ||
+            [];
+          if (!Array.isArray(problems)) problems = [];
+        } catch (parseError) {
+          this.logger.error('Failed to parse worksheet JSON', parseError);
+          throw new Error('Failed to parse worksheet JSON');
+        }
+
+        const forceMcq = resolved.mode === 'quiz';
+        const questionsToCreate = [];
+        for (let i = 0; i < Math.min(problems.length, resolved.numQuestions); i++) {
+          const problem =
+            problems[i] && typeof problems[i] === 'object'
+              ? (problems[i] as Record<string, unknown>)
+              : {};
+          const row = normalizeWorksheetProblemForDb(problem, i, difficultyUpper, forceMcq);
+          const metaPayload: Record<string, unknown> = {};
+          if (row.meta.options?.length) metaPayload.options = row.meta.options;
+          if (row.meta.markScheme != null) metaPayload.markScheme = row.meta.markScheme;
+
+          questionsToCreate.push({
+            artifactId: artifact.id,
+            prompt: row.prompt,
+            answer: row.answer ?? '',
+            difficulty: row.difficulty as any,
+            order: row.order,
+            type: row.type as any,
+            meta: Object.keys(metaPayload).length ? (metaPayload as object) : undefined,
+          });
+        }
+
+        if (questionsToCreate.length > 0) {
+          await this.db.worksheetQuestion.createMany({ data: questionsToCreate });
+        }
+
+        let parsedTitle: string | undefined;
+        let parsedDescription: string | undefined;
+        let parsedEstimated: string | undefined;
+        try {
+          const worksheetData = JSON.parse(content);
+          let actualWorksheetData: any = worksheetData;
+          if (worksheetData.last_response) {
+            try {
+              actualWorksheetData = JSON.parse(worksheetData.last_response);
+            } catch {
+              /* noop */
+            }
+          }
+          parsedTitle =
+            typeof actualWorksheetData.title === 'string' ? actualWorksheetData.title : undefined;
+          parsedDescription =
+            typeof actualWorksheetData.description === 'string'
+              ? actualWorksheetData.description
+              : undefined;
+          parsedEstimated =
+            typeof actualWorksheetData.estimatedTime === 'string'
+              ? actualWorksheetData.estimatedTime
+              : undefined;
+        } catch {
+          /* noop */
+        }
+
+        await this.db.artifact.update({
+          where: { id: artifact.id },
+          data: {
+            generating: false,
+            title: parsedTitle || artifact.title,
+            description: parsedDescription ?? undefined,
+            estimatedTime: estTime || parsedEstimated || undefined,
+            worksheetConfig: worksheetConfigSnapshot as object,
+          },
+        });
+
+        const updatedWorksheet = await this.db.artifact.findFirst({
+          where: { id: artifact.id },
+          include: { questions: true },
+        });
+
+        await PusherService.emitWorksheetGenerationComplete(workspaceId, updatedWorksheet);
+        await PusherService.emitWorksheetComplete(workspaceId, artifact);
+
+        await notifyArtifactReady(this.db, {
+          userId,
+          workspaceId,
+          artifactId: artifact.id,
+          artifactType: ArtifactType.WORKSHEET,
+          title: updatedWorksheet?.title ?? artifact.title,
+        }).catch(() => {});
+      } catch (error) {
+        this.logger.error(`Background generation failed for artifact ${artifact.id}:`, error);
+        await notifyArtifactFailed(this.db, {
+          userId,
+          workspaceId,
+          artifactId: artifact.id,
+          artifactType: ArtifactType.WORKSHEET,
+          title: artifact.title,
+          message: `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        }).catch(() => {});
+
+        await this.db.artifact.deleteMany({ where: { id: artifact.id } }).catch(() => {});
+
+        await PusherService.emitError(
+          workspaceId,
+          `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          'worksheet_generation',
+        );
+      }
+    })();
+
+    return { artifact };
+  }
+
+  async checkAnswer(
+    userId: string,
+    input: { worksheetId: string; questionId: string; answer: string },
+  ) {
+    const worksheet = await this.db.artifact.findFirst({
+      where: {
+        id: input.worksheetId,
+        type: ArtifactType.WORKSHEET,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: { workspace: true },
+    });
+    if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
+    const question = await this.db.worksheetQuestion.findFirst({
+      where: { id: input.questionId, artifactId: input.worksheetId },
+    });
+    if (!question) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const questionMeta = question.meta
+      ? typeof question.meta === 'object'
+        ? (question.meta as any)
+        : JSON.parse(question.meta as any)
+      : ({} as any);
+    const markScheme = questionMeta.markScheme;
+
+    let isCorrect = false;
+    let userMarkScheme: any = null;
+
+    if (markScheme && markScheme.points && markScheme.points.length > 0) {
+      try {
+        userMarkScheme = await ai.backend.checkWorksheetQuestions(
+          worksheet.workspace.id,
+          userId,
+          question.prompt,
+          input.answer,
+          markScheme,
+        );
+
+        const achievedTotal = userMarkScheme.points.reduce(
+          (sum: number, p: any) => sum + (p.achievedPoints || 0),
+          0,
+        );
+        isCorrect = achievedTotal === markScheme.totalPoints;
+      } catch (error) {
+        this.logger.error(
+          'Failed to check answer with AI',
+          error instanceof Error ? error.message : 'Unknown error',
+        );
+        isCorrect = question.answer === input.answer;
+      }
+    } else {
+      throw new TRPCError({ code: 'BAD_REQUEST', message: 'No mark scheme found for question' });
+    }
+
+    const progress = await this.db.worksheetQuestionProgress.upsert({
+      where: {
+        worksheetQuestionId_userId: {
+          worksheetQuestionId: input.questionId,
+          userId,
+        },
+      },
+      create: {
+        worksheetQuestionId: input.questionId,
+        userId,
+        modified: true,
+        userAnswer: input.answer,
+        correct: isCorrect,
+        completedAt: new Date(),
+        attempts: 1,
+        meta: userMarkScheme
+          ? { userMarkScheme: JSON.parse(JSON.stringify(userMarkScheme)) }
+          : { userMarkScheme: null },
+      },
+      update: {
+        modified: true,
+        userAnswer: input.answer,
+        correct: isCorrect,
+        completedAt: new Date(),
+        attempts: { increment: 1 },
+        meta: userMarkScheme
+          ? { userMarkScheme: JSON.parse(JSON.stringify(userMarkScheme)) }
+          : { userMarkScheme: null },
+      },
+    });
+
+    return { isCorrect, userMarkScheme, progress };
+  }
+}