adds comment logic (#59)

* Adds creation and collection logic

* Update & delte logic

* Adds more comment options

* Adds id information to websocket stuff

* Adds export import for comments

* Fixes import export mapping issues

* Resolves pr comments

Author: JWittmeyer

api/transfer.py

@@ -54,7 +54,9 @@ async def post(self, request) -> PlainTextResponse:
             init_file_import(task, project_id, is_global_update)
         except Exception:
             file_import_error_handling(task, project_id, is_global_update)
-        notification.send_organization_update(project_id, "project_update", True)
+        notification.send_organization_update(
+            project_id, f"project_update:{project_id}", True
+        )
         return PlainTextResponse("OK")
 
 

controller/auth/manager.py

@@ -34,6 +34,14 @@ def get_user_id_by_info(info) -> str:
     return get_user_by_info(info).id
 
 
+def get_user_role_by_info(info) -> str:
+    return get_user_by_info(info).role
+
+
+def get_user_role_by_id(user_id: str) -> str:
+    return user_manager.get_user(user_id).role
+
+
 def get_organization_by_user_id(user_id: str) -> Organization:
     organization: Organization = user_manager.get_or_create_user(user_id).organization
     if not organization:

controller/comment/manager.py

@@ -1,4 +1,6 @@
 from typing import Any, Dict, List, Optional, Union
+from controller.auth import kratos
+from controller.auth import manager as user_manager
 from submodules.model import enums
 from submodules.model.models import CommentData, User
 
@@ -25,7 +27,7 @@ def get_comments(
     user_id: str,
     xfkey: Optional[str] = None,
     project_id: Optional[str] = None,
-) -> str:
+) -> List[CommentData]:
 
     try:
         xftype_parsed = enums.CommentCategory[xftype.upper()]
@@ -37,6 +39,36 @@ def get_comments(
     )
 
 
+def get_comment(xftype: str, user_id: str, comment_id: str) -> CommentData:
+    # check to have some level of access control
+    try:
+        xftype_parsed = enums.CommentCategory[xftype.upper()]
+    except KeyError:
+        raise ValueError(f"Invalid comment category: {xftype}")
+
+    return comments.get_as_json(comment_id, user_id)
+
+
+def get_add_info(
+    xftype: str,
+    project_id: Optional[str] = None,
+    xfkey: Optional[str] = None,
+) -> str:
+
+    try:
+        xftype_parsed = enums.CommentCategory[xftype.upper()]
+    except KeyError:
+        raise ValueError(f"Invalid comment category: {xftype}")
+
+    values = comments.get_add_info_category(xftype_parsed, project_id, xfkey)
+
+    if xftype_parsed == enums.CommentCategory.USER:
+        values = [
+            {"id": r.id, "name": kratos.resolve_user_mail_by_id(r.id)} for r in values
+        ]
+    return values
+
+
 def create_comment(
     xfkey: str,
     xftype: str,
@@ -49,7 +81,7 @@ def create_comment(
         xftype = enums.CommentCategory[xftype.upper()].value
     except KeyError:
         raise ValueError(f"Invalid comment type: {xftype}")
-    comments.create(
+    return comments.create(
         xfkey,
         xftype,
         comment,
@@ -76,3 +108,17 @@ def update_comment(
     if user.role != enums.UserRoles.ENGINEER.value and user.id != item.created_by:
         raise ValueError(f"Can't update comment")
     comments.change(item, changes, with_commit=True)
+    return item
+
+
+def delete_comment(comment_id: str, user_id: str) -> CommentData:
+    item = comments.get(comment_id)
+    if not item:
+        raise ValueError(f"Can't find comment")
+
+    if (
+        item.created_by != user_id
+        and user_manager.get_user_role_by_id(user_id) != enums.UserRoles.ENGINEER.value
+    ):
+        raise ValueError(f"Can't delete comment")
+    comments.remove(comment_id, with_commit=True)

controller/transfer/association_transfer_manager.py

@@ -54,7 +54,9 @@ def import_associations(
             description,
             type,
         )
-        notification.send_organization_update(project_id, f"information_source_created")
+        notification.send_organization_update(
+            project_id, f"information_source_created:{str(information_source.id)}"
+        )
 
     attribute_names = list(indices[0].keys())
     attribute_list = attribute_manager.get_all_attributes_by_names(

controller/transfer/manager.py

@@ -120,8 +120,10 @@ def export_records(
         return sql_df.to_json(orient="records")
 
 
-def export_project(project_id: str, export_options: Dict[str, bool]) -> str:
-    return get_project_export_dump(project_id, export_options)
+def export_project(
+    project_id: str, user_id: str, export_options: Dict[str, bool]
+) -> str:
+    return get_project_export_dump(project_id, user_id, export_options)
 
 
 def export_knowledge_base(project_id: str, base_id: str) -> str:
@@ -145,13 +147,15 @@ def export_knowledge_base(project_id: str, base_id: str) -> str:
     )
 
 
-def prepare_project_export(project_id: str, export_options: Dict[str, bool]) -> bool:
+def prepare_project_export(
+    project_id: str, user_id: str, export_options: Dict[str, bool]
+) -> bool:
     org_id = organization.get_id_by_project_id(project_id)
     objects = s3.get_bucket_objects(org_id, project_id + "/download/project_export_")
     for o in objects:
         s3.delete_object(org_id, o)
 
-    data = get_project_export_dump(project_id, export_options)
+    data = get_project_export_dump(project_id, user_id, export_options)
     file_name_base = "project_export_" + datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
     file_name_local = file_name_base + ".zip"
     file_name_download = project_id + "/download/" + file_name_local

controller/transfer/project_transfer_manager.py

@@ -23,6 +23,7 @@
     user,
     knowledge_term,
     weak_supervision,
+    comments as comment,
 )
 from submodules.model.enums import NotificationType
 from controller.labeling_access_link import manager as link_manager
@@ -117,7 +118,7 @@ def import_sample_project(
             project_item.id,
         )
         notification.send_organization_update(
-            project_item.id, "project_update", is_global=True
+            project_item.id, f"project_update:{str(project_item.id)}", is_global=True
         )
         data = extract_first_zip_data(file_name)
         import_file(project_item.id, user_id, data)
@@ -129,14 +130,14 @@ def import_sample_project(
         )
 
         notification.send_organization_update(
-            project_item.id, "project_update", is_global=True
+            project_item.id, f"project_update:{str(project_item.id)}", is_global=True
         )
         return project_item
 
 
 def import_file(
     project_id: str,
-    user_id: str,
+    import_user_id: str,
     data: Dict[str, Dict[str, Any]],
     task_id: Optional[str] = None,
 ) -> None:
@@ -490,7 +491,7 @@ def import_file(
                 )
             ] = data_slice_object.id
             link_manager.generate_data_slice_access_link(
-                project_id, user_id, data_slice_object.id, with_commit=False
+                project_id, import_user_id, data_slice_object.id, with_commit=False
             )
 
     for information_source_payload_item in data.get(
@@ -778,6 +779,42 @@ def import_file(
                 "blacklisted",
             ),
         )
+    comment_data = data.get("comments")
+    if comment_data:
+        for comment_item in comment_data:
+            old_xfkey = comment_item.get("xfkey")
+            new_xfkey = None
+            xftype = comment_item.get("xftype")
+            if xftype == enums.CommentCategory.RECORD.value:
+                new_xfkey = record_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.LABELING_TASK.value:
+                new_xfkey = labeling_task_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.ATTRIBUTE.value:
+                new_xfkey = attribute_ids_by_old_id.get(old_xfkey)
+            if xftype == enums.CommentCategory.LABEL.value:
+                new_xfkey = labeling_task_labels_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.DATA_SLICE.value:
+                new_xfkey = data_slice_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.EMBEDDING.value:
+                new_xfkey = embedding_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.HEURISTIC.value:
+                new_xfkey = information_source_ids.get(old_xfkey)
+            if xftype == enums.CommentCategory.KNOWLEDGE_BASE.value:
+                new_xfkey = knowledge_base_ids.get(old_xfkey)
+            if not new_xfkey:
+                continue
+
+            comment.create(
+                xfkey=new_xfkey,
+                xftype=comment_item.get("xftype"),
+                comment=comment_item.get("comment"),
+                created_by=import_user_id,
+                project_id=project_id,
+                order_key=comment_item.get("order_key"),
+                is_markdown=comment_item.get("is_markdown"),
+                created_at=comment_item.get("created_at"),
+                is_private=comment_item.get("is_private"),
+            )
 
     general.commit()
 
@@ -787,7 +824,7 @@ def import_file(
     ):
         embedding_manager.create_embeddings_one_by_one(
             project_id,
-            user_id,
+            import_user_id,
             data.get(
                 "embeddings_data",
             ),
@@ -802,7 +839,9 @@ def import_file(
     logger.info(f"Finished import of project {project_id}")
 
 
-def get_project_export_dump(project_id: str, export_options: Dict[str, bool]) -> str:
+def get_project_export_dump(
+    project_id: str, user_id: str, export_options: Dict[str, bool]
+) -> str:
     """Exports data of a project in JSON-String format. Queries all useful database entries and
     puts them in a format which again fits for import. For some entities database joins
     are useful, so there are vanilla SQL statements in execute-blocks.
@@ -829,6 +868,7 @@ def get_project_export_dump(project_id: str, export_options: Dict[str, bool]) ->
     knowledge_bases = []
     weak_supervision_task = []
     terms = []
+    comments = []
     # -------------------- READ OF ENTITIES BY SQLALCHEMY --------------------
 
     if "basic project data" in export_options:
@@ -874,6 +914,38 @@ def get_project_export_dump(project_id: str, export_options: Dict[str, bool]) ->
         knowledge_bases = knowledge_base.get_all(project_id)
         terms = knowledge_term.get_terms_by_project_id(project_id)
 
+    if "comment data" in export_options:
+        comments = []
+        comments += comment.get_by_all_by_category(
+            enums.CommentCategory.LABELING_TASK, user_id, None, project_id, True
+        )
+        comments += comment.get_by_all_by_category(
+            enums.CommentCategory.ATTRIBUTE, user_id, None, project_id, True
+        )
+        comments += comment.get_by_all_by_category(
+            enums.CommentCategory.LABEL, user_id, None, project_id, True
+        )
+        comments += comment.get_by_all_by_category(
+            enums.CommentCategory.DATA_SLICE, user_id, None, project_id, True
+        )
+        if "records" in export_options:
+            comments += comment.get_by_all_by_category(
+                enums.CommentCategory.RECORD, user_id, None, project_id, True
+            )
+            # only makes sense with records
+            if "embeddings" in export_options:
+                comments += comment.get_by_all_by_category(
+                    enums.CommentCategory.EMBEDDING, user_id, None, project_id, True
+                )
+        if "information sources" in export_options:
+            comments += comment.get_by_all_by_category(
+                enums.CommentCategory.HEURISTIC, user_id, None, project_id, True
+            )
+        if "knowledge bases" in export_options:
+            comments += comment.get_by_all_by_category(
+                enums.CommentCategory.KNOWLEDGE_BASE, user_id, None, project_id, True
+            )
+
     # -------------------- FORMATTING OF ENTITIES --------------------
     project_details_data = {
         "id": project_item.id,
@@ -1026,6 +1098,9 @@ def get_project_export_dump(project_id: str, export_options: Dict[str, bool]) ->
         for association_item in data_slice_record_association
     ]
 
+    # no need to format since db reteurns as json :)
+    comment_data = comments
+
     # -------------------- READ AND FORMATTING OF ENTITIES WITH SQL JOINS --------------------
 
     record_label_association_tokens_data = [
@@ -1116,6 +1191,7 @@ def get_project_export_dump(project_id: str, export_options: Dict[str, bool]) ->
         "terms_data": terms_data,
         "data_slice_data": data_slice_data,
         "data_slice_record_association_data": data_slice_record_association_data,
+        "comments": comment_data,
     }
 
     logger.info(f"Finished export of project {project_id}")

graphql_api/mutation/comment.py

@@ -10,7 +10,7 @@ class CreateComment(graphene.Mutation):
     class Arguments:
         comment = graphene.String(required=True)
         xftype = graphene.String(required=True)
-        xfkey = graphene.String(required=True)
+        xfkey = graphene.ID(required=True)
         project_id = graphene.ID(required=False)
         is_private = graphene.Boolean(required=False)
 
@@ -31,7 +31,17 @@ def mutate(
         else:
             auth.check_admin_access(info)
         user_id = auth.get_user_id_by_info(info)
-        manager.create_comment(xfkey, xftype, comment, user_id, project_id, is_private)
+        item = manager.create_comment(
+            xfkey, xftype, comment, user_id, project_id, is_private
+        )
+        if item and project_id:
+            # without project_id its a admin dashboard comment -> no websocket integration planned atm
+            # global notification since the data is collected globally -> further handling in frontend
+            notification.send_organization_update(
+                project_id,
+                f"comment_created:{project_id}:{xftype}:{xfkey}:{str(item.id)}",
+                True,
+            )
         return CreateComment(ok=True)
 
 
@@ -56,21 +66,44 @@ def mutate(
         else:
             auth.check_admin_access(info)
         user = auth.get_user_by_info(info)
-        manager.update_comment(comment_id, user, changes)
+        item = manager.update_comment(comment_id, user, changes)
+        if item and project_id:
+            # without project_id its a admin dashboard comment -> no websocket integration planned atm
+            # global notification since the data is collected globally -> further handling in frontend
+            notification.send_organization_update(
+                project_id,
+                f"comment_updated:{project_id}:{comment_id}:{item.xftype}:{item.xfkey}",
+                True,
+            )
         return UpdateComment(ok=True)
 
 
 class DeleteComment(graphene.Mutation):
     class Arguments:
-        link_id = graphene.ID(required=True)
+        comment_id = graphene.ID(required=True)
         project_id = graphene.ID(required=False)
 
     ok = graphene.Boolean()
 
-    def mutate(self, info, project_id: str, attribute_id: str):
+    def mutate(
+        self,
+        info,
+        comment_id: str,
+        project_id: Optional[str] = None,
+    ):
         auth.check_demo_access(info)
-        auth.check_project_access(info, project_id)
-        manager.delete_attribute(project_id, attribute_id)
+        if project_id:
+            auth.check_project_access(info, project_id)
+        else:
+            auth.check_admin_access(info)
+        user_id = auth.get_user_id_by_info(info)
+        manager.delete_comment(comment_id, user_id)
+        if project_id:
+            # without project_id its a admin dashboard comment -> no websocket integration planned atm
+            # global notification since the data is collected globally -> further handling in frontend
+            notification.send_organization_update(
+                project_id, f"comment_deleted:{project_id}:{comment_id}", True
+            )
         return DeleteComment(ok=True)