domain methods for checking task order sections

atst/domain/task_orders.py

@@ -6,6 +6,42 @@ from .exceptions import NotFoundError
 
 
 class TaskOrders(object):
+    SECTIONS = {
+        "app_info": [
+            "scope",
+            "defense_component",
+            "app_migration",
+            "native_apps",
+            "complexity",
+            "complexity_other",
+            "dev_team",
+            "dev_team_other",
+            "team_experience",
+        ],
+        "funding": [
+            "start_date",
+            "end_date",
+            "clin_01",
+            "clin_02",
+            "clin_03",
+            "clin_04",
+        ],
+        "oversight": [
+            "ko_first_name",
+            "ko_last_name",
+            "ko_email",
+            "ko_dod_id",
+            "cor_first_name",
+            "cor_last_name",
+            "cor_email",
+            "cor_dod_id",
+            "so_first_name",
+            "so_last_name",
+            "so_email",
+            "so_dod_id",
+        ],
+    }
+
     @classmethod
     def get(cls, task_order_id):
         try:
@@ -35,3 +71,23 @@ class TaskOrders(object):
         db.session.commit()
 
         return task_order
+
+    @classmethod
+    def is_section_complete(cls, task_order, section):
+        if section in TaskOrders.SECTIONS:
+            for attr in TaskOrders.SECTIONS[section]:
+                if not getattr(task_order, attr):
+                    return False
+
+            return True
+
+        else:
+            return False
+
+    @classmethod
+    def all_sections_complete(cls, task_order):
+        for section in TaskOrders.SECTIONS.keys():
+            if not TaskOrders.is_section_complete(task_order, section):
+                return False
+
+        return True

atst/routes/task_orders/__init__.py

@@ -65,6 +65,18 @@ class ShowTaskOrderWorkflow:
     def template(self):
         return self._section["template"]
 
+    @property
+    def display_screens(self):
+        screen_info = TASK_ORDER_SECTIONS.copy()
+
+        if self.task_order:
+            for section in screen_info:
+                if TaskOrders.is_section_complete(self.task_order, section["section"]):
+                    section["complete"] = True
+
+        return screen_info
+
+
 
 class UpdateTaskOrderWorkflow(ShowTaskOrderWorkflow):
     def __init__(self, form_data, user, screen=1, task_order_id=None):
@@ -95,21 +107,21 @@ class UpdateTaskOrderWorkflow(ShowTaskOrderWorkflow):
         return self.task_order
 
 
-@task_orders_bp.route("/task_order/new/<int:screen>")
+@task_orders_bp.route("/task_orders/new/<int:screen>")
-@task_orders_bp.route("/task_order/new/<int:screen>/<task_order_id>")
+@task_orders_bp.route("/task_orders/new/<int:screen>/<task_order_id>")
 def new(screen, task_order_id=None):
     workflow = ShowTaskOrderWorkflow(screen, task_order_id)
     return render_template(
         workflow.template,
         current=screen,
         task_order_id=task_order_id,
-        screens=TASK_ORDER_SECTIONS,
+        screens=workflow.display_screens,
         form=workflow.form,
     )
 
 
-@task_orders_bp.route("/task_order/new/<int:screen>", methods=["POST"])
+@task_orders_bp.route("/task_orders/new/<int:screen>", methods=["POST"])
-@task_orders_bp.route("/task_order/new/<int:screen>/<task_order_id>", methods=["POST"])
+@task_orders_bp.route("/task_orders/new/<int:screen>/<task_order_id>", methods=["POST"])
 def update(screen, task_order_id=None):
     workflow = UpdateTaskOrderWorkflow(
         http_request.form, g.current_user, screen, task_order_id

templates/task_orders/new/menu.html

@@ -1,7 +1,7 @@
 <div class="progress-menu progress-menu--four">
   <ul>
     {% for s in screens %}
-      {% if jedi_request and s.section in jedi_request.body %}
+      {% if s.complete %}
         {% set step_indicator = 'complete' %}
       {% elif loop.index == current %}
         {% set step_indicator = 'active' %}

tests/domain/test_legacy_task_orders.py

@@ -0,0 +1,28 @@
+import pytest
+
+from atst.domain.exceptions import NotFoundError
+from atst.domain.legacy_task_orders import LegacyTaskOrders
+from atst.eda_client import MockEDAClient
+
+from tests.factories import LegacyTaskOrderFactory
+
+
+def test_can_get_task_order():
+    new_to = LegacyTaskOrderFactory.create(number="0101969F")
+    to = LegacyTaskOrders.get(new_to.number)
+
+    assert to.id == to.id
+
+
+def test_nonexistent_task_order_raises_without_client():
+    with pytest.raises(NotFoundError):
+        LegacyTaskOrders.get("some fake number")
+
+
+def test_nonexistent_task_order_raises_with_client(monkeypatch):
+    monkeypatch.setattr(
+        "atst.domain.legacy_task_orders.LegacyTaskOrders._client",
+        lambda: MockEDAClient(),
+    )
+    with pytest.raises(NotFoundError):
+        LegacyTaskOrders.get("some other fake numer")

tests/domain/test_task_orders.py

@@ -1,28 +1,31 @@
 import pytest
 
-from atst.domain.exceptions import NotFoundError
+from atst.domain.task_orders import TaskOrders
-from atst.domain.legacy_task_orders import LegacyTaskOrders
-from atst.eda_client import MockEDAClient
 
-from tests.factories import LegacyTaskOrderFactory
+from tests.factories import TaskOrderFactory
 
 
-def test_can_get_task_order():
+def test_is_section_complete():
-    new_to = LegacyTaskOrderFactory.create(number="0101969F")
+    dict_keys = [k for k in TaskOrders.SECTIONS.keys()]
-    to = LegacyTaskOrders.get(new_to.number)
+    section = dict_keys[0]
-
+    attrs = TaskOrders.SECTIONS[section].copy()
-    assert to.id == to.id
+    task_order = TaskOrderFactory.create(**{k: None for k in attrs})
+    leftover = attrs.pop()
+    for attr in attrs:
+        setattr(task_order, attr, "str12345")
+    assert not TaskOrders.is_section_complete(task_order, section)
+    setattr(task_order, leftover, "str12345")
+    assert TaskOrders.is_section_complete(task_order, section)
 
 
-def test_nonexistent_task_order_raises_without_client():
+def test_all_sections_complete():
-    with pytest.raises(NotFoundError):
+    task_order = TaskOrderFactory.create()
-        LegacyTaskOrders.get("some fake number")
+    for attr_list in TaskOrders.SECTIONS.values():
+        for attr in attr_list:
+            if not getattr(task_order, attr):
+                setattr(task_order, attr, "str12345")
 
-
+    task_order.scope = None
-def test_nonexistent_task_order_raises_with_client(monkeypatch):
+    assert not TaskOrders.all_sections_complete(task_order)
-    monkeypatch.setattr(
+    task_order.scope = "str12345"
-        "atst.domain.legacy_task_orders.LegacyTaskOrders._client",
+    assert TaskOrders.all_sections_complete(task_order)
-        lambda: MockEDAClient(),
-    )
-    with pytest.raises(NotFoundError):
-        LegacyTaskOrders.get("some other fake numer")

tests/routes/task_orders/test_new_task_order.py

@@ -7,17 +7,14 @@ from atst.models.workspace import Workspace
 from tests.factories import UserFactory, WorkspaceFactory, TaskOrderFactory
 
 
-def test_edit_task_order(client, user_session):
+def test_new_task_order(client, user_session):
     creator = UserFactory.create()
-    task_order = TaskOrderFactory.create(
-        creator=creator, workspace=WorkspaceFactory.create()
-    )
     user_session()
-    response = client.get(url_for("task_orders.edit", task_order_id=task_order.id))
+    response = client.get(url_for("task_orders.new", screen=1))
     assert response.status_code == 200
 
 
-def test_create_new_workspace(client, user_session):
+def test_create_new_task_order(client, user_session):
     creator = UserFactory.create()
     task_order = TaskOrderFactory.create(
         creator=creator, workspace=WorkspaceFactory.create()