feat(PM-1792): update workflow run item

.circleci/config.yml

@@ -75,7 +75,8 @@ workflows:
                           only:
                               - develop
                               - feat/ai-workflows
-                              - pm-1782
+                              - pm-1792
+
 
             - 'build-prod':
                   context: org-global

src/api/ai-workflow/ai-workflow.controller.ts

@@ -24,6 +24,7 @@ import {
   UpdateAiWorkflowDto,
   CreateAiWorkflowRunItemsDto,
   UpdateAiWorkflowRunDto,
+  UpdateAiWorkflowRunItemDto,
 } from '../../dto/aiWorkflow.dto';
 import { Scopes } from 'src/shared/decorators/scopes.decorator';
 import { UserRole } from 'src/shared/enums/userRole.enum';
@@ -227,6 +228,44 @@ export class AiWorkflowController {
     );
   }
 
+  @Patch('/:workflowId/runs/:runId/items/:itemId')
+  @Scopes(Scope.UpdateWorkflowRun)
+  @ApiOperation({ summary: 'Update an AIWorkflowRunItem by id' })
+  @ApiParam({ name: 'workflowId', description: 'The ID of the AI workflow' })
+  @ApiParam({ name: 'runId', description: 'The ID of the AI workflow run' })
+  @ApiParam({
+    name: 'itemId',
+    description: 'The ID of the AI workflow run item',
+  })
+  @ApiBody({
+    description: 'AIWorkflowRunItem update data',
+    type: UpdateAiWorkflowRunItemDto,
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'AIWorkflowRunItem updated successfully.',
+  })
+  @ApiResponse({ status: 400, description: 'Bad Request.' })
+  @ApiResponse({ status: 401, description: 'Unauthorized.' })
+  @ApiResponse({ status: 403, description: 'Forbidden.' })
+  @ApiResponse({ status: 404, description: 'Workflow, Run or Item not found.' })
+  async updateRunItem(
+    @Param('workflowId') workflowId: string,
+    @Param('runId') runId: string,
+    @Param('itemId') itemId: string,
+    @Body(new ValidationPipe({ whitelist: true, transform: true }))
+    patchData: UpdateAiWorkflowRunItemDto,
+    @User() user: JwtUser,
+  ) {
+    return this.aiWorkflowService.updateRunItem(
+      workflowId,
+      runId,
+      itemId,
+      patchData,
+      user,
+    );
+  }
+
   @Get('/:workflowId/runs/:runId/items')
   @Roles(
     UserRole.Admin,

src/api/ai-workflow/ai-workflow.service.ts

@@ -12,6 +12,7 @@ import {
   CreateAiWorkflowRunDto,
   UpdateAiWorkflowDto,
   UpdateAiWorkflowRunDto,
+  UpdateAiWorkflowRunItemDto,
 } from '../../dto/aiWorkflow.dto';
 import { ScorecardStatus } from 'src/dto/scorecard.dto';
 import { JwtUser } from 'src/shared/modules/global/jwt.service';
@@ -444,12 +445,15 @@ export class AiWorkflowService {
         UserRole.Submitter,
       ].map((r) => r.toLowerCase());
 
-      const memberRoles = (
-        await this.resourceApiService.getMemberResourcesRoles(
-          challengeId,
-          user.userId,
-        )
-      ).filter((resource) =>
+      const userRoles = await this.resourceApiService.getMemberResourcesRoles(
+        challengeId,
+        user.userId,
+      );
+
+      this.logger.debug(userRoles);
+      this.logger.debug(user);
+      this.logger.debug(submission);
+      const memberRoles = userRoles.filter((resource) =>
         requiredRoles.some(
           (role) =>
             resource.roleName!.toLowerCase().indexOf(role.toLowerCase()) >= 0,
@@ -465,7 +469,7 @@ export class AiWorkflowService {
         memberRoles.some(
           (r) => r.roleName?.toLowerCase() === UserRole.Submitter.toLowerCase(),
         ) &&
-        user.userId !== submission?.memberId
+        user.userId?.toString() !== submission?.memberId
       ) {
         this.logger.log(
           `Submitter ${user.userId} trying to access AI workflow run for other submitters.`,
@@ -486,4 +490,126 @@ export class AiWorkflowService {
 
     return items;
   }
+
+  async updateRunItem(
+    workflowId: string,
+    runId: string,
+    itemId: string,
+    patchData: UpdateAiWorkflowRunItemDto,
+    user: JwtUser,
+  ) {
+    const workflow = await this.prisma.aiWorkflow.findUnique({
+      where: { id: workflowId },
+    });
+    if (!workflow) {
+      this.logger.error(`Workflow with id ${workflowId} not found.`);
+      throw new NotFoundException(`Workflow with id ${workflowId} not found.`);
+    }
+
+    const run = await this.prisma.aiWorkflowRun.findUnique({
+      where: { id: runId },
+    });
+    if (!run || run.workflowId !== workflowId) {
+      this.logger.error(
+        `Run with id ${runId} not found or does not belong to workflow ${workflowId}.`,
+      );
+      throw new NotFoundException(
+        `Run with id ${runId} not found or does not belong to workflow ${workflowId}.`,
+      );
+    }
+
+    const runItem = await this.prisma.aiWorkflowRunItem.findUnique({
+      where: { id: itemId },
+    });
+    if (!runItem || runItem.workflowRunId !== runId) {
+      this.logger.error(
+        `Run item with id ${itemId} not found or does not belong to run ${runId}.`,
+      );
+      throw new NotFoundException(
+        `Run item with id ${itemId} not found or does not belong to run ${runId}.`,
+      );
+    }
+
+    const updateData: any = {};
+
+    if (patchData.content !== undefined) {
+      updateData.content = patchData.content;
+    }
+    if (patchData.upVotes !== undefined) {
+      updateData.upVotes = patchData.upVotes;
+    }
+    if (patchData.downVotes !== undefined) {
+      updateData.downVotes = patchData.downVotes;
+    }
+    if (patchData.questionScore !== undefined) {
+      updateData.questionScore = patchData.questionScore;
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      await tx.aiWorkflowRunItem.update({
+        where: { id: itemId },
+        include: {
+          comments: true,
+        },
+        data: updateData,
+      });
+
+      if (patchData.comments) {
+        for (const comment of patchData.comments) {
+          if (comment.id) {
+            const existingComment =
+              await tx.aiWorkflowRunItemComment.findUnique({
+                where: { id: comment.id },
+              });
+            if (!existingComment) {
+              this.logger.error(`Comment with id ${comment.id} not found.`);
+              throw new NotFoundException(
+                `Comment with id ${comment.id} not found.`,
+              );
+            }
+
+            if (
+              existingComment.createdBy !== user.userId &&
+              !user.roles?.includes(UserRole.Admin)
+            ) {
+              this.logger.error(
+                `User ${user.userId} unauthorized to update comment ${comment.id}.`,
+              );
+              throw new ForbiddenException(
+                `Unauthorized to update comment ${comment.id}.`,
+              );
+            }
+
+            await tx.aiWorkflowRunItemComment.update({
+              where: { id: comment.id },
+              data: {
+                content: comment.content,
+                updatedAt: new Date(),
+              },
+            });
+          } else {
+            await tx.aiWorkflowRunItemComment.create({
+              data: {
+                workflowRunItemId: itemId,
+                content: comment.content,
+                parentId: comment.parentId,
+                createdBy: '',
+                createdAt: new Date(),
+                userId: user.userId as string,
+                updatedAt: new Date(),
+                updatedBy: '',
+              },
+            });
+          }
+        }
+      }
+
+      return tx.aiWorkflowRunItem.findUnique({
+        where: { id: itemId },
+        include: {
+          comments: true,
+        },
+      });
+    });
+  }
 }

src/dto/aiWorkflow.dto.ts

@@ -9,6 +9,7 @@ import {
   IsInt,
   IsDate,
   Min,
+  IsUUID,
   Max,
 } from 'class-validator';
 import { Type, Transform } from 'class-transformer';
@@ -138,3 +139,32 @@ export class CreateAiWorkflowRunItemsDto {
   @Type(() => CreateAiWorkflowRunItemDto)
   items: CreateAiWorkflowRunItemDto[];
 }
+
+export class CommentDto {
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsUUID()
+  id?: string;
+
+  @ApiProperty()
+  @IsString()
+  @Transform(trimTransformer)
+  @IsNotEmpty()
+  content: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsUUID()
+  parentId?: string;
+}
+
+export class UpdateAiWorkflowRunItemDto extends PartialType(
+  OmitType(CreateAiWorkflowRunItemDto, ['scorecardQuestionId'] as const),
+) {
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CommentDto)
+  comments?: CommentDto[];
+}