zou 0.19.14__py3-none-any.whl → 0.20.11__py3-none-any.whl

zou/app/services/chats_service.py

@@ -0,0 +1,279 @@
+import random
+import string
+
+from flask import current_app
+from sqlalchemy.exc import IntegrityError
+
+from zou.app.models.attachment_file import AttachmentFile
+from zou.app.models.chat import Chat
+from zou.app.models.chat_message import ChatMessage
+from zou.app.models.entity import Entity
+from zou.app.models.project import Project
+from zou.app.models.project_status import ProjectStatus
+
+from zou.app.utils import cache, events, fs, thumbnail
+
+from zou.app.stores import file_store
+
+from zou.app.services import names_service, persons_service
+
+
+def clear_chat_message_cache(chat_message_id):
+    cache.cache.delete_memoized(get_chat_message, chat_message_id)
+
+
+def get_chat_raw(entity_id):
+    """
+    Return chat corresponding to given entity ID.
+    """
+    chat = Chat.get_by(object_id=entity_id)
+    if chat is None:
+        chat = Chat.create(object_id=entity_id)
+    return chat
+
+
+def get_chat(entity_id):
+    """
+    Return chat corresponding to given entity ID.
+    """
+    chat = get_chat_raw(entity_id)
+    return chat.serialize(relations=True)
+
+
+def get_chat_by_id(chat_id):
+    """
+    Return chat corresponding to given entity ID.
+    """
+    chat = Chat.get(chat_id)
+    return chat.serialize(relations=True)
+
+
+def get_chat_message_raw(chat_message_id):
+    """
+    Return chat message corresponding to given chat message ID.
+    """
+    return ChatMessage.get(chat_message_id)
+
+
+@cache.memoize_function(1200)
+def get_chat_message(chat_message_id):
+    """
+    Return chat message corresponding to given chat message ID.
+    """
+    message = get_chat_message_raw(chat_message_id)
+    serialized_message = message.serialize()
+    serialized_message["attachment_files"] = []
+    for attachment_file in message.attachment_files:
+        serialized_message["attachment_files"].append(
+            {
+                "id": attachment_file.id,
+                "name": attachment_file.name,
+                "extension": attachment_file.extension,
+            }
+        )
+    return serialized_message
+
+
+def join_chat(entity_id, person_id):
+    """
+    Join chat for given entity ID.
+    """
+    chat = get_chat_raw(entity_id)
+    person = persons_service.get_person_raw(person_id)
+    chat.participants.append(person)
+    chat.save()
+    events.emit(
+        "chat:joined",
+        data={"chat_id": chat.id, "person_id": person.id},
+        persist=False,
+    )
+    return chat.serialize()
+
+
+def leave_chat(entity_id, person_id):
+    """
+    Leave chat for given entity ID.
+    """
+    chat = get_chat_raw(entity_id)
+    person = persons_service.get_person_raw(person_id)
+    chat.participants.remove(person)
+    chat.save()
+    events.emit(
+        "chat:left",
+        data={"chat_id": chat.id, "person_id": person.id},
+        persist=False,
+    )
+    return chat.serialize()
+
+
+def get_chat_messages(chat_id):
+    """
+    Return chat messages for given chat ID.
+    """
+    result = []
+    messages = (
+        ChatMessage.query.filter(ChatMessage.chat_id == chat_id)
+        .order_by(ChatMessage.created_at)
+        .all()
+    )
+    for message in messages:
+        serialized_message = message.serialize()
+        serialized_message["attachment_files"] = []
+        for attachment_file in message.attachment_files:
+            serialized_message["attachment_files"].append(
+                {
+                    "id": attachment_file.id,
+                    "name": attachment_file.name,
+                    "extension": attachment_file.extension,
+                }
+            )
+        result.append(serialized_message)
+    return result
+
+
+def get_chat_messages_for_entity(entity_id):
+    """
+    Return chat messages for given entity ID.
+    """
+    chat = get_chat_raw(entity_id)
+    return get_chat_messages(chat.id)
+
+
+def create_chat_message(chat_id, person_id, message, files=None):
+    """
+    Create a new chat message.
+    """
+    chat = Chat.get(chat_id)
+    message = ChatMessage.create(
+        chat_id=chat_id, person_id=person_id, text=message
+    )
+    chat.update({"last_message": message.created_at})
+    serialized_message = message.serialize()
+    if files:
+        _add_attachments_to_message(serialized_message, files)
+    events.emit(
+        "chat:new-message",
+        data={
+            "chat_id": chat_id,
+            "chat_message_id": serialized_message["id"],
+            "last_message": serialized_message["created_at"],
+        },
+        persist=False,
+    )
+    return serialized_message
+
+
+def delete_chat_message(chat_message_id):
+    """
+    Delete chat message.
+    """
+    message = get_chat_message_raw(chat_message_id)
+
+    for attachment in message.attachment_files:
+        attachment_file_id = str(attachment.id)
+        file_store.remove_file("attachments", attachment_file_id)
+        file_store.remove_picture("thumbnails", attachment_file_id)
+        attachment.delete()
+
+    message.delete()
+    events.emit(
+        "chat:deleted-message",
+        data={
+            "chat_id": str(message.chat_id),
+            "chat_message_id": chat_message_id,
+        },
+        persist=False,
+    )
+    clear_chat_message_cache(chat_message_id)
+    return message.serialize()
+
+
+def build_participant_filter(person_id):
+    """
+    Query filter for returning chats for current user.
+    """
+    person = persons_service.get_person_raw(person_id)
+    return Chat.participants.contains(person)
+
+
+def get_chats_for_person(person_id):
+    """
+    Return chats for current user.
+    """
+    chats = (
+        Chat.query.join(Entity, Chat.object_id == Entity.id)
+        .join(Project, Entity.project_id == Project.id)
+        .join(ProjectStatus, ProjectStatus.id == Project.project_status_id)
+        .add_columns(Entity.project_id, Entity.preview_file_id)
+        .filter(build_participant_filter(person_id))
+        .filter(ProjectStatus.name == "Open")
+        .all()
+    )
+
+    result = []
+    for chat_model, project_id, preview_file_id in chats:
+        chat = chat_model.present()
+        chat["entity_name"], _, _ = names_service.get_full_entity_name(
+            chat["object_id"]
+        )
+        chat["project_id"] = project_id
+        chat["preview_file_id"] = preview_file_id
+        result.append(chat)
+    return result
+
+
+def _add_attachments_to_message(message, files):
+    """
+    Create an attachment entry and for each given uploaded files and tie it
+    to given message.
+    """
+    message["attachment_files"] = []
+    for uploaded_file in files.values():
+        try:
+            attachment_file = _create_attachment(message, uploaded_file)
+            message["attachment_files"].append(attachment_file)
+        except IntegrityError:
+            attachment_file = _create_attachment(
+                message, uploaded_file, randomize=True
+            )
+            message["attachment_files"].append(attachment_file)
+    return message
+
+
+def _create_attachment(message, uploaded_file, randomize=False):
+    tmp_folder = current_app.config["TMP_DIR"]
+
+    # Prepare file name and create db entry
+    filename = uploaded_file.filename
+    mimetype = uploaded_file.mimetype
+    extension = fs.get_file_extension(filename)
+    if randomize:
+        letters = string.ascii_lowercase
+        random_str = "".join(random.choice(letters) for i in range(8))
+        filename = f"{filename[:len(filename) - len(extension) - 1]}"
+        filename += f"-{random_str}.{extension}"
+    attachment_file = AttachmentFile.create(
+        name=filename,
+        size=0,
+        extension=extension,
+        mimetype=mimetype,
+        chat_message_id=message["id"],
+    )
+
+    # Store attachment file
+    attachment_file_id = str(attachment_file.id)
+    tmp_file_path = fs.save_file(tmp_folder, attachment_file_id, uploaded_file)
+    size = fs.get_file_size(tmp_file_path)
+    attachment_file.update({"size": size})
+    file_store.add_file("attachments", attachment_file_id, tmp_file_path)
+
+    # Create thumbnail for pictures
+    if "png" in mimetype or "jpg" in mimetype:
+        image_path = tmp_file_path
+        if "jpg" in mimetype:
+            image_path = thumbnail.convert_jpg_to_png(tmp_file_path)
+        thumbnail.resize(image_path, (150, 150), True)
+        file_store.add_picture("thumbnails", attachment_file_id, image_path)
+        fs.rm_file(image_path)
+        fs.rm_file(tmp_file_path)
+    return attachment_file.present()

zou/app/services/comments_service.py

@@ -26,6 +26,7 @@ from zou.app.services import (
     projects_service,
     tasks_service,
     concepts_service,
+    preview_files_service,
 )
 from zou.app.services.exception import (
     AttachmentFileNotFoundException,
@@ -33,7 +34,7 @@ from zou.app.services.exception import (
     AssetNotFoundException,
 )
 
-from zou.app.utils import cache, date_helpers, events, fs, fields
+from zou.app.utils import cache, date_helpers, events, fs, fields, date_helpers
 from zou.app.stores import file_store
 from zou.app import config
 
@@ -69,12 +70,19 @@ def get_attachment_file_path(attachment_file):
 
 
 def create_comment(
-    person_id, task_id, task_status_id, text, checklist, files, created_at
+    person_id,
+    task_id,
+    task_status_id,
+    text,
+    checklist=[],
+    files={},
+    created_at="",
+    links=[],
 ):
     """
     Create a new comment and related: news, notifications and events.
     """
-    task = tasks_service.get_task_with_relations(task_id)
+    task = tasks_service.get_task(task_id, relations=True)
     task_status = tasks_service.get_task_status(task_status_id)
     author = _get_comment_author(person_id)
     _check_retake_capping(task_status, task)
@@ -87,6 +95,7 @@ def create_comment(
         text=text,
         checklist=checklist,
         created_at=created_at,
+        links=links,
     )
     task, status_changed = _manage_status_change(task_status, task, comment)
     _manage_subscriptions(task, comment, status_changed)
@@ -127,41 +136,51 @@ def _get_comment_author(person_id):
 
 
 def _manage_status_change(task_status, task, comment):
-    status_changed = task_status["id"] != task["task_status_id"]
-    new_data = {
-        "task_status_id": task_status["id"],
-        "last_comment_date": comment["created_at"],
-    }
-    if status_changed:
-        if task_status["is_retake"]:
-            retake_count = task["retake_count"]
-            if retake_count is None or retake_count == "NoneType":
-                retake_count = 0
-            new_data["retake_count"] = retake_count + 1
-
-        if task_status["is_feedback_request"]:
-            new_data["end_date"] = datetime.datetime.utcnow()
-
-        if (
-            task_status["short_name"] == "wip"
-            and task["real_start_date"] is None
-        ):
-            new_data["real_start_date"] = datetime.datetime.utcnow()
-
-    tasks_service.update_task(task["id"], new_data)
-
-    if status_changed:
-        events.emit(
-            "task:status-changed",
-            {
-                "task_id": task["id"],
-                "new_task_status_id": new_data["task_status_id"],
-                "previous_task_status_id": task["task_status_id"],
-                "person_id": comment["person_id"],
-            },
-            project_id=task["project_id"],
-        )
-    task.update(new_data)
+    is_last_comment = (
+        task["last_comment_date"] is None
+        or task["last_comment_date"] <= comment["created_at"]
+    )
+    if not is_last_comment:
+        status_changed = False
+        task = tasks_service.reset_task_data(task["id"])
+    else:
+        status_changed = task_status["id"] != task["task_status_id"]
+        new_data = {
+            "task_status_id": task_status["id"],
+            "last_comment_date": comment["created_at"],
+        }
+        if status_changed:
+            if task_status["is_retake"]:
+                retake_count = task["retake_count"]
+                if retake_count is None or retake_count == "NoneType":
+                    retake_count = 0
+                new_data["retake_count"] = retake_count + 1
+
+            if task_status["is_feedback_request"]:
+                new_data["end_date"] = date_helpers.get_utc_now_datetime()
+
+            if (
+                task_status["short_name"] == "wip"
+                and task["real_start_date"] is None
+            ):
+                new_data["real_start_date"] = datetime.datetime.now(
+                    datetime.timezone.utc
+                )
+
+        tasks_service.update_task(task["id"], new_data)
+
+        if status_changed:
+            events.emit(
+                "task:status-changed",
+                {
+                    "task_id": task["id"],
+                    "new_task_status_id": new_data["task_status_id"],
+                    "previous_task_status_id": task["task_status_id"],
+                    "person_id": comment["person_id"],
+                },
+                project_id=task["project_id"],
+            )
+        task.update(new_data)
     return task, status_changed
 
 
@@ -182,12 +201,11 @@ def _manage_subscriptions(task, comment, status_changed):
 
 
 def _run_status_automation(automation, task, person_id):
-    is_automation_to_run = (
-        not automation["archived"]
-        and task["task_type_id"] == automation["in_task_type_id"]
-        and task["task_status_id"] == automation["in_task_status_id"]
-    )
-    if not is_automation_to_run:
+    if (
+        automation["archived"]
+        or task["task_type_id"] != automation["in_task_type_id"]
+        or task["task_status_id"] != automation["in_task_status_id"]
+    ):
         return
 
     priorities = projects_service.get_task_type_priority_map(
@@ -215,7 +233,7 @@ def _run_status_automation(automation, task, person_id):
             task_status = tasks_service.get_task_status(
                 automation["in_task_status_id"]
             )
-            create_comment(
+            new_comment = create_comment(
                 person_id,
                 task_to_update["id"],
                 automation["out_task_status_id"],
@@ -228,6 +246,31 @@ def _run_status_automation(automation, task, person_id):
                 {},
                 None,
             )
+            if automation["import_last_revision"]:
+                preview_file = (
+                    preview_files_service.get_last_preview_file_for_task(
+                        task["id"]
+                    )
+                )
+                preview_files = (
+                    preview_files_service.get_preview_files_for_revision(
+                        preview_file["task_id"], preview_file["revision"]
+                    )
+                )
+
+                for preview_file in preview_files:
+                    new_preview_file = (
+                        tasks_service.add_preview_file_to_comment(
+                            new_comment["id"],
+                            new_comment["person_id"],
+                            task_to_update["id"],
+                        )
+                    )
+
+                    preview_files_service.copy_preview_file_in_another_one(
+                        preview_file["id"], new_preview_file["id"]
+                    )
+
     elif automation["out_field_type"] == "ready_for":
         try:
             asset = assets_service.update_asset(
@@ -248,6 +291,7 @@ def new_comment(
     files={},
     checklist=[],
     created_at="",
+    links=[],
 ):
     """
     Create a new comment for given object (by default, it considers this object
@@ -262,8 +306,8 @@ def new_comment(
             )
         except ValueError:
             try:
-                created_at_date = fields.get_date_object(
-                    created_at, date_format="%Y-%m-%dT%H:%M:%S"
+                created_at_date = date_helpers.get_datetime_from_string(
+                    created_at
                 )
             except ValueError:
                 pass
@@ -278,6 +322,7 @@ def new_comment(
         checklist=checklist,
         text=text,
         created_at=created_at_date,
+        links=links,
     )
 
     comment = comment.serialize(relations=True)
@@ -290,24 +335,6 @@ def new_comment(
     return comment
 
 
-def add_attachments_to_comment(comment, files):
-    """
-    Create an attachment entry and for each given uploaded files and tie it
-    to given comment.
-    """
-    comment["attachment_files"] = []
-    for uploaded_file in files.values():
-        try:
-            attachment_file = create_attachment(comment, uploaded_file)
-            comment["attachment_files"].append(attachment_file)
-        except IntegrityError:
-            attachment_file = create_attachment(
-                comment, uploaded_file, randomize=True
-            )
-            comment["attachment_files"].append(attachment_file)
-    return comment
-
-
 def reset_mentions(comment):
     task = tasks_service.get_task(comment["object_id"])
     mentions = get_comment_mentions(task["project_id"], comment["text"])
@@ -536,3 +563,21 @@ def get_comment_department_mention_ids(project_id, text):
         str(mention.id)
         for mention in get_comment_department_mentions(project_id, text)
     ]
+
+
+def add_attachments_to_comment(comment, files):
+    """
+    Create an attachment entry and for each given uploaded files and tie it
+    to given comment.
+    """
+    comment["attachment_files"] = []
+    for uploaded_file in files.values():
+        try:
+            attachment_file = create_attachment(comment, uploaded_file)
+            comment["attachment_files"].append(attachment_file)
+        except IntegrityError:
+            attachment_file = create_attachment(
+                comment, uploaded_file, randomize=True
+            )
+            comment["attachment_files"].append(attachment_file)
+    return comment

zou/app/services/concepts_service.py

@@ -33,7 +33,7 @@ from zou.app.services.exception import (
 
 def clear_concept_cache(concept_id):
     cache.cache.delete_memoized(get_concept, concept_id)
-    cache.cache.delete_memoized(get_concept_with_relations, concept_id)
+    cache.cache.delete_memoized(get_concept, concept_id, True)
     cache.cache.delete_memoized(get_full_concept, concept_id)
 
 
@@ -61,23 +61,15 @@ def get_concept_raw(concept_id):
 
 
 @cache.memoize_function(120)
-def get_concept_with_relations(concept_id):
+def get_concept(concept_id, relations=False):
     """
     Return given concept as a dictionary.
     """
     return get_concept_raw(concept_id).serialize(
-        obj_type="Concept", relations=True
+        obj_type="Concept", relations=relations
     )
 
 
-@cache.memoize_function(120)
-def get_concept(concept_id):
-    """
-    Return given concept as a dictionary.
-    """
-    return get_concept_raw(concept_id).serialize(obj_type="Concept")
-
-
 @cache.memoize_function(120)
 def get_full_concept(concept_id):
     """
@@ -86,7 +78,7 @@ def get_full_concept(concept_id):
     concepts = get_concepts_and_tasks({"id": concept_id})
     if len(concepts) > 0:
         concept = concepts[0]
-        concept.update(get_concept_with_relations(concept_id))
+        concept.update(get_concept(concept_id, relations=True))
         return concept
     else:
         raise ConceptNotFoundException