[DERCBOT-1314] Documentation

Adding modifications

Typo

[DERCBOT-1309] Documentation update + Annotation Model

Move Model files + Add Annotation as a subdocument of an Action

Update Action and Dialog to support single annotation per action

DAO update to allow Annotation insertion in Action subdocument

Initiate BotAnnotationEvent as emptyList

Business logic + Annotation creation endpoint

Model update, refacto and addEvent endpoint logic

Update and Delete event endpoint

Restore removed byStory endpoint

DialogsVerticle + Annotation presence check

Improvements

Dialog Endpoints to DialogVerticle

Update logic to retrieve annotations from /dialogs/search endpoint

Modify annotation with PUT endpoint

lastUpdateDate logic added

Unused import

Fix malfunctioning logic + Doc update

Add initial event at annotation creation

PR Review

Rebase + fix

canEdit bool

Refacto and BotAnnotationUpdateDTO delete

Doc update with latest endpoints

Annotation on dialogs endpoint + canEdit logic fix

namespace & botId check for annotation endpoints

annotationId logic removal + doc & endpoint update

Fix canEdit logic on updateAnnotation & updateAnnotationEvent

Author: scezen

bot/admin/server/src/main/kotlin/BotAdminService.kt

@@ -17,6 +17,7 @@
 package ai.tock.bot.admin
 
 import ai.tock.bot.admin.FaqAdminService.FAQ_CATEGORY
+import ai.tock.bot.admin.annotation.*
 import ai.tock.bot.admin.answer.AnswerConfiguration
 import ai.tock.bot.admin.answer.AnswerConfigurationType.builtin
 import ai.tock.bot.admin.answer.AnswerConfigurationType.script
@@ -46,6 +47,7 @@ import ai.tock.bot.admin.story.dump.*
 import ai.tock.bot.admin.user.UserReportDAO
 import ai.tock.bot.connector.ConnectorType
 import ai.tock.bot.definition.IntentWithoutNamespace
+import ai.tock.bot.engine.action.Action
 import ai.tock.bot.engine.config.SatisfactionIntent
 import ai.tock.bot.engine.dialog.Dialog
 import ai.tock.bot.engine.dialog.DialogFlowDAO
@@ -62,6 +64,7 @@ import ai.tock.nlp.front.shared.config.*
 import ai.tock.nlp.front.shared.config.ClassifiedSentenceStatus.model
 import ai.tock.nlp.front.shared.config.ClassifiedSentenceStatus.validated
 import ai.tock.shared.*
+import ai.tock.shared.exception.rest.NotFoundException
 import ai.tock.shared.security.UserLogin
 import ai.tock.shared.security.key.HasSecretKey
 import ai.tock.shared.security.key.SecretKey
@@ -70,6 +73,7 @@ import ai.tock.translator.*
 import com.github.salomonbrys.kodein.instance
 import mu.KotlinLogging
 import org.litote.kmongo.Id
+import org.litote.kmongo.newId
 import org.litote.kmongo.toId
 import java.time.Instant
 import java.util.*
@@ -149,6 +153,200 @@ object BotAdminService {
         }
     }
 
+    fun addCommentToAnnotation(
+        dialogId: String,
+        actionId: String,
+        eventDTO: BotAnnotationEventDTO,
+        user: String
+    ): BotAnnotationEvent {
+        if (eventDTO.type != BotAnnotationEventType.COMMENT) {
+            throw IllegalArgumentException("Only COMMENT events are allowed")
+        }
+
+        require(!eventDTO.comment.isNullOrBlank()) { "Comment is required and cannot be blank for COMMENT event type" }
+
+        val annotation = dialogReportDAO.findAnnotation(dialogId, actionId)
+            ?: throw IllegalStateException("Annotation not found")
+
+        val event = BotAnnotationEventComment(
+            eventId = newId(),
+            creationDate = Instant.now(),
+            lastUpdateDate = Instant.now(),
+            user = user,
+            comment = eventDTO.comment ?: throw IllegalArgumentException("Comment required")
+        )
+
+        dialogReportDAO.addAnnotationEvent(dialogId, actionId, event)
+
+        return event.copy(canEdit = true)
+    }
+
+    fun updateAnnotationEvent(
+        dialogId: String,
+        actionId: String,
+        eventId: String,
+        eventDTO: BotAnnotationEventDTO,
+        user: String
+    ): BotAnnotationEvent {
+        val existingEvent = dialogReportDAO.getAnnotationEvent(dialogId, actionId, eventId)
+            ?: throw IllegalArgumentException("Event not found")
+
+        if (existingEvent.type != BotAnnotationEventType.COMMENT) {
+            throw IllegalArgumentException("Only comment events can be updated")
+        }
+
+        if (eventDTO.type != BotAnnotationEventType.COMMENT) {
+            throw IllegalArgumentException("Event type must be COMMENT")
+        }
+
+        require(eventDTO.comment != null) { "Comment must be provided" }
+
+        val annotation = dialogReportDAO.findAnnotation(dialogId, actionId)
+            ?: throw IllegalStateException("Annotation not found")
+
+        val existingCommentEvent = existingEvent as BotAnnotationEventComment
+        val updatedEvent = existingCommentEvent.copy(
+            comment = eventDTO.comment!!,
+            lastUpdateDate = Instant.now()
+        )
+
+        dialogReportDAO.updateAnnotationEvent(dialogId, actionId, eventId, updatedEvent)
+
+        return updatedEvent.copy(canEdit = updatedEvent.user == user)
+    }
+
+    fun deleteAnnotationEvent(
+        dialogId: String,
+        actionId: String,
+        eventId: String,
+        user: String
+    ) {
+        val existingEvent = dialogReportDAO.getAnnotationEvent(dialogId, actionId, eventId)
+            ?: throw IllegalArgumentException("Event not found")
+
+        if (existingEvent.type != BotAnnotationEventType.COMMENT) {
+            throw IllegalArgumentException("Only comment events can be deleted")
+        }
+
+        dialogReportDAO.deleteAnnotationEvent(dialogId, actionId, eventId)
+    }
+
+    fun updateAnnotation(
+        dialogId: String,
+        actionId: String,
+        annotationDTO: BotAnnotationDTO,
+        user: String
+    ): BotAnnotation {
+        val existingAnnotation = dialogReportDAO.findAnnotation(dialogId, actionId)
+            ?: throw IllegalStateException("Annotation not found")
+
+        val events = mutableListOf<BotAnnotationEvent>()
+
+        if (existingAnnotation.state != annotationDTO.state) {
+            events.add(
+                BotAnnotationEventState(
+                    eventId = newId(),
+                    creationDate = Instant.now(),
+                    lastUpdateDate = Instant.now(),
+                    user = user,
+                    before = existingAnnotation.state.name,
+                    after = annotationDTO.state.name
+                )
+            )
+            existingAnnotation.state = annotationDTO.state
+        }
+
+        if (existingAnnotation.reason != annotationDTO.reason) {
+            events.add(
+                BotAnnotationEventReason(
+                    eventId = newId(),
+                    creationDate = Instant.now(),
+                    lastUpdateDate = Instant.now(),
+                    user = user,
+                    before = existingAnnotation.reason?.name,
+                    after = annotationDTO.reason?.name
+                )
+            )
+            existingAnnotation.reason = annotationDTO.reason
+        }
+
+        if (existingAnnotation.groundTruth != annotationDTO.groundTruth) {
+            events.add(
+                BotAnnotationEventGroundTruth(
+                    eventId = newId(),
+                    creationDate = Instant.now(),
+                    lastUpdateDate = Instant.now(),
+                    user = user,
+                    before = existingAnnotation.groundTruth,
+                    after = annotationDTO.groundTruth
+                )
+            )
+            existingAnnotation.groundTruth = annotationDTO.groundTruth
+        }
+
+        if (existingAnnotation.description != annotationDTO.description) {
+            events.add(
+                BotAnnotationEventDescription(
+                    eventId = newId(),
+                    creationDate = Instant.now(),
+                    lastUpdateDate = Instant.now(),
+                    user = user,
+                    before = existingAnnotation.description,
+                    after = annotationDTO.description
+                )
+            )
+            existingAnnotation.description = annotationDTO.description
+        }
+
+        existingAnnotation.lastUpdateDate = Instant.now()
+        existingAnnotation.events.addAll(events)
+
+        dialogReportDAO.insertAnnotation(dialogId, actionId, existingAnnotation)
+
+        return existingAnnotation.copy(
+            events = existingAnnotation.events.map { event ->
+                if (event is BotAnnotationEventComment) {
+                    event.copy(canEdit = event.user == user)
+                } else {
+                    event
+                }
+            }.toMutableList()
+        )
+    }
+
+    fun createAnnotation(
+        dialogId: String,
+        actionId: String,
+        annotationDTO: BotAnnotationDTO,
+        user: String
+    ): BotAnnotation {
+        if (dialogReportDAO.annotationExists(dialogId, actionId)) {
+            throw IllegalStateException("An annotation already exists for this action")
+        }
+
+        val annotation = BotAnnotation(
+            state = annotationDTO.state,
+            reason = annotationDTO.reason,
+            description = annotationDTO.description,
+            groundTruth = annotationDTO.groundTruth,
+            events = mutableListOf(),
+            lastUpdateDate = Instant.now()
+        )
+
+        val event = BotAnnotationEventState(
+            eventId = newId(),
+            creationDate = Instant.now(),
+            lastUpdateDate = Instant.now(),
+            user = user,
+            before = null,
+            after = annotationDTO.state.name
+        )
+
+        annotation.events.add(event)
+        dialogReportDAO.insertAnnotation(dialogId, actionId, annotation)
+        return annotation
+    }
+
     fun createOrGetIntent(
         namespace: String,
         intentName: String,
@@ -216,6 +414,41 @@ object BotAdminService {
             }
     }
 
+    fun searchWithCommentRights(query: DialogsSearchQuery, userLogin: String): DialogReportQueryResult {
+        val result = search(query)
+        return result.copy(
+            dialogs = result.dialogs.map { dialog ->
+                processAnnotationsForUser(dialog, userLogin)
+            }
+        )
+    }
+
+    fun getDialogWithCommentRights(id: Id<Dialog>, userLogin: String): DialogReport? {
+        return dialogReportDAO.getDialog(id)?.let { dialog ->
+            processAnnotationsForUser(dialog, userLogin)
+        }
+    }
+
+    private fun processAnnotationsForUser(dialog: DialogReport, userLogin: String): DialogReport {
+        return dialog.copy(
+            actions = dialog.actions.map { action ->
+                action.copy(
+                    annotation = action.annotation?.let { annotation ->
+                        annotation.copy(
+                            events = annotation.events.map { event ->
+                                if (event is BotAnnotationEventComment) {
+                                    event.copy(canEdit = event.user == userLogin)
+                                } else {
+                                    event
+                                }
+                            }.toMutableList()
+                        )
+                    }
+                )
+            }
+        )
+    }
+
     fun getIntentsInDialogs(namespace: String,nlpModel : String) : Set<String>{
         return dialogReportDAO.intents(namespace,nlpModel)
     }

bot/admin/server/src/main/kotlin/BotAdminVerticle.kt

@@ -16,6 +16,7 @@
 
 package ai.tock.bot.admin
 
+
 import ai.tock.bot.admin.BotAdminService.createI18nRequest
 import ai.tock.bot.admin.BotAdminService.dialogReportDAO
 import ai.tock.bot.admin.BotAdminService.getBotConfigurationByApplicationIdAndBotId
@@ -31,6 +32,7 @@ import ai.tock.bot.admin.story.dump.StoryDefinitionConfigurationDumpImport
 import ai.tock.bot.admin.test.TestPlanService
 import ai.tock.bot.admin.test.findTestService
 import ai.tock.bot.admin.verticle.GenAIVerticle
+import ai.tock.bot.admin.verticle.DialogVerticle
 import ai.tock.bot.admin.verticle.IndicatorVerticle
 import ai.tock.bot.connector.ConnectorType.Companion.rest
 import ai.tock.bot.connector.ConnectorTypeConfiguration
@@ -40,9 +42,7 @@ import ai.tock.bot.engine.config.SATISFACTION_MODULE_ID
 import ai.tock.bot.engine.config.UploadedFilesService
 import ai.tock.bot.engine.config.UploadedFilesService.downloadFile
 import ai.tock.bot.engine.dialog.DialogFlowDAO
-import ai.tock.bot.engine.message.Sentence
 import ai.tock.nlp.admin.AdminVerticle
-import ai.tock.nlp.admin.CsvCodec
 import ai.tock.nlp.admin.model.ApplicationScopedQuery
 import ai.tock.nlp.admin.model.TranslateReport
 import ai.tock.nlp.front.client.FrontClient
@@ -76,6 +76,7 @@ open class BotAdminVerticle : AdminVerticle() {
 
     private val indicatorVerticle = IndicatorVerticle()
     private val aiVerticle = GenAIVerticle()
+    private val dialogVerticle = DialogVerticle()
 
     override val logger: KLogger = KotlinLogging.logger {}
 
@@ -122,6 +123,7 @@ open class BotAdminVerticle : AdminVerticle() {
         configureServices()
 
         indicatorVerticle.configure(this)
+        dialogVerticle.configure(this)
         aiVerticle.configure(this)
 
         blockingJsonPost("/users/search", botUser) { context, query: UserSearchQuery ->
@@ -216,15 +218,6 @@ open class BotAdminVerticle : AdminVerticle() {
             }
         }
 
-        blockingJsonPost(
-            "/analytics/messages/byStory",
-            setOf(botUser)
-        ) { context, request: DialogFlowRequest ->
-            checkAndMeasure(context, request) {
-                BotAdminAnalyticsService.reportMessagesByStory(request)
-            }
-        }
-
         blockingJsonPost(
             "/analytics/messages/byStoryCategory",
             setOf(botUser)