[ITG-111] Przystosować backend do nowej mechaniki dodawania i edycji zadań

bode/bode/models/enums.py

@@ -33,4 +33,14 @@ def list(cls):
         return [c.value for c in cls]
 
 
+class DirectedRelationTypeWithoutSubtaskAndSupertask(Enum):
+    Blocks = "blocks"
+    IsBlockedBy = "is_blocked_by"
+    Interchangable = "interchangable"
+
+    @classmethod
+    def list(cls):
+        return [c.value for c in cls]
+
+
 SYMMETRIC_RELATIONS = [RelationType.Interchangable.value]

bode/bode/models/task/actions.py

@@ -1,10 +1,59 @@
 from sqlalchemy.exc import IntegrityError, NoResultFound
 
 from bode.app import db
-from bode.models.enums import RelationType, TaskStatus
+from bode.models.enums import DirectedRelationType, RelationType, TaskStatus
 from bode.models.tag.actions import create_tag, get_tag_by_name
 from bode.models.task.model import Task
-from bode.models.task_relation.actions import delete_task_relation, get_related_tasks
+from bode.models.task_relation.actions import (
+    create_task_relation,
+    delete_task_relation,
+    get_related_tasks,
+)
+
+
+def add_relations_and_subtasks(task_data, task, type_of_operation):
+    if type_of_operation == "creation":
+        relation_key = "relations"
+        subtask_key = "subtasks"
+
+    if type_of_operation == "edition":
+        relation_key = "relations_to_add"
+        subtask_key = "subtasks_to_add"
+
+    """Create specified relations"""
+    relations_data = task_data.get(relation_key)
+    if relations_data:
+        for relation_data in relations_data:
+            if relation_data["type"] == DirectedRelationType.Blocks.value:
+                relation_input = {
+                    "first_task_id": relation_data["task_id"],
+                    "second_task_id": task.id,
+                    "type": RelationType.Dependent.value,
+                }
+            if relation_data["type"] == DirectedRelationType.IsBlockedBy.value:
+                relation_input = {
+                    "first_task_id": task.id,
+                    "second_task_id": relation_data["task_id"],
+                    "type": RelationType.Dependent.value,
+                }
+            if relation_data["type"] == DirectedRelationType.Interchangable.value:
+                relation_input = {
+                    "first_task_id": task.id,
+                    "second_task_id": relation_data["task_id"],
+                    "type": RelationType.Interchangable.value,
+                }
+            create_task_relation(**relation_input)
+
+    """Create specified subtasks"""
+    subtasks_data = task_data.get(subtask_key)
+    if subtasks_data:
+        for subtask_title in subtasks_data:
+            subtask_input = {"title": subtask_title}
+            subtask = Task(**subtask_input)
+            db.session.add(subtask)
+            db.session.commit()
+            subtask_relation_input = {"first_task_id": task.id, "second_task_id": subtask.id, "type": "SUBTASK"}
+            create_task_relation(**subtask_relation_input)
 
 
 def delete_task(task_id):
@@ -46,15 +95,15 @@ def get_equivalence_set(related_task_id, equivalence_set):
                 equivalence_set[str(related_task.id)] = related_task.status
                 get_equivalence_set(str(related_task.id), equivalence_set)
 
+    """Edit task data"""
     task = get_task(task_id)
-
-    for key, value in task_data.items():
-        if key == "tags":
-            continue
+    edit_task_keys = {"title", "description", "due_date", "status"}
+    edit_task_data = {key: task_data[key] for key in task_data.keys() & edit_task_keys}
+    for key, value in edit_task_data.items():
         setattr(task, key, value)
-
     db.session.commit()
 
+    """If task is checked, check all subtasks as well."""
     for relation, related_task in get_related_tasks(task_id):
         if task_data["status"] != TaskStatus.TODO.value and is_subtask_relation(relation):
             if related_task.status == TaskStatus.DONE.value:
@@ -64,6 +113,7 @@ def get_equivalence_set(related_task_id, equivalence_set):
             }
             edit_task(str(related_task.id), **subtask_data)
 
+    """If task is checked, check all interchangable tasks indirectly as well."""
     if check_equivalence_class:
         equivalence_set = {}
         equivalence_set[task_id] = task_data["status"]
@@ -85,6 +135,36 @@ def get_equivalence_set(related_task_id, equivalence_set):
             }
             edit_task(str(related_task_id), check_equivalence_class=False, **inter_task_data)
 
+    """Delete tags"""
+    tags_to_delete_data = task_data.get("tags_to_delete")
+    if tags_to_delete_data:
+        for tag_name in tags_to_delete_data:
+            tag = get_tag_by_name(tag_name)
+            if tag not in task.tags:
+                raise NoResultFound
+            task.tags.remove(tag)
+            db.session.commit()
+
+    """Add tags"""
+    tags_to_add_data = task_data.get("tags_to_add")
+    if tags_to_add_data:
+        for tag_name in tags_to_add_data:
+            tag = get_tag_by_name(tag_name)
+            if tag is None:
+                tag = create_tag(tag_name)
+            if tag in task.tags:
+                raise IntegrityError
+            task.tags.append(tag)
+            db.session.commit()
+
+    """Delete relations"""
+    relations_to_delete_data = task_data.get("relations_to_delete")
+    if relations_to_delete_data:
+        for relation_id in relations_to_delete_data:
+            delete_task_relation(relation_id)
+
+    add_relations_and_subtasks(task_data, task, "edition")
+
     return task
 
 
@@ -93,11 +173,25 @@ def get_task(task_id):
 
 
 def create_task(**task_data):
-    task = Task(**task_data)
-
+    """Create task"""
+    create_task_keys = {"title", "description", "due_date", "status"}
+    create_task_data = {key: task_data[key] for key in task_data.keys() & create_task_keys}
+    task = Task(**create_task_data)
     db.session.add(task)
     db.session.commit()
 
+    """Add specified tags to task"""
+    tags_data = task_data.get("tags")
+    if tags_data:
+        for tag_name in tags_data:
+            tag = get_tag_by_name(tag_name)
+            if tag is None:
+                tag = create_tag(tag_name)
+            task.tags.append(tag)
+        db.session.commit()
+
+    add_relations_and_subtasks(task_data, task, "creation")
+
     return task
 
 

bode/bode/resources/tasks/api.py

@@ -15,7 +15,12 @@
 )
 from bode.models.task.model import Task
 from bode.resources.tags.schemas import TagInputSchema
-from bode.resources.tasks.schemas import TaskFiltersSchema, TaskInputSchema, TaskSchema
+from bode.resources.tasks.schemas import (
+    TaskEditionInputSchema,
+    TaskFiltersSchema,
+    TaskInputSchema,
+    TaskSchema,
+)
 
 blueprint = Blueprint("tasks", "tasks", url_prefix="/tasks")
 
@@ -60,7 +65,7 @@ def get(self, task_id):
         except DataError:
             abort(404)
 
-    @blueprint.arguments(TaskInputSchema)
+    @blueprint.arguments(TaskEditionInputSchema)
     @blueprint.response(200, TaskSchema)
     def put(self, task_data, task_id):
         try:

bode/bode/resources/tasks/schemas.py

@@ -1,10 +1,19 @@
 from dateutil import rrule
 from marshmallow import EXCLUDE, ValidationError, fields, validate
 
-from bode.models.enums import DirectedRelationType, TaskStatus
+from bode.models.enums import (
+    DirectedRelationType,
+    DirectedRelationTypeWithoutSubtaskAndSupertask,
+    TaskStatus,
+)
 from bode.models.task_relation.actions import is_task_blocked
 from bode.resources.base_schema import BaseSchema
-from bode.resources.tags.schemas import TagInputSchema, TagSchema
+from bode.resources.tags.schemas import TagSchema
+
+
+class RelationInputSchema(BaseSchema):
+    task_id = fields.UUID(required=True)
+    type = fields.String(validate=validate.OneOf(DirectedRelationTypeWithoutSubtaskAndSupertask.list()), required=True)
 
 
 def validate_rrule(rrule_str: str):
@@ -18,12 +27,29 @@ class TaskInputSchema(BaseSchema):
     class Meta:
         unknown = EXCLUDE
 
+    title = fields.String(validate=validate.Length(1, 80), required=True)
     description = fields.String(validate=validate.Length(0, 1024), default="")
     due_date = fields.DateTime(allow_none=True)
     rrule = fields.String(allow_none=True, required=False, validate=validate_rrule)
     status = fields.String(validate=validate.OneOf(TaskStatus.list()), default=TaskStatus.TODO.value)
-    tags = fields.List(fields.Nested(TagInputSchema), default=[])
+    tags = fields.List(fields.String, default=[])
+    relations = fields.List(fields.Nested(RelationInputSchema), default=[])
+    subtasks = fields.List(fields.String, default=[])
+
+
+class TaskEditionInputSchema(BaseSchema):
+    class Meta:
+        unknown = EXCLUDE
+
     title = fields.String(validate=validate.Length(1, 80), required=True)
+    description = fields.String(validate=validate.Length(0, 1024), default="")
+    due_date = fields.DateTime(allow_none=True)
+    status = fields.String(validate=validate.OneOf(TaskStatus.list()), default=TaskStatus.TODO.value)
+    tags_to_add = fields.List(fields.String, default=[])
+    tags_to_delete = fields.List(fields.String, default=[])
+    relations_to_add = fields.List(fields.Nested(RelationInputSchema), default=[])
+    relations_to_delete = fields.List(fields.String, default=[])
+    subtasks_to_add = fields.List(fields.String, default=[])
 
 
 class TaskSchema(BaseSchema):