Merge pull request #489 from dod-ccpo/legacy-task-orders

change current task order name

atst/domain/legacy_task_orders.py

@@ -0,0 +1,62 @@
+from sqlalchemy.orm.exc import NoResultFound
+from flask import current_app as app
+
+from atst.database import db
+from atst.models.legacy_task_order import LegacyTaskOrder, Source, FundingType
+from .exceptions import NotFoundError
+from atst.utils import update_obj
+
+
+class LegacyTaskOrders(object):
+    TASK_ORDER_DATA = [
+        col.name for col in LegacyTaskOrder.__table__.c if col.name != "id"
+    ]
+
+    @classmethod
+    def get(cls, order_number):
+        try:
+            legacy_task_order = (
+                db.session.query(LegacyTaskOrder).filter_by(number=order_number).one()
+            )
+        except NoResultFound:
+            if LegacyTaskOrders._client():
+                legacy_task_order = LegacyTaskOrders.get_from_eda(order_number)
+            else:
+                raise NotFoundError("legacy_task_order")
+
+        return legacy_task_order
+
+    @classmethod
+    def get_from_eda(cls, order_number):
+        to_data = LegacyTaskOrders._client().get_contract(order_number, status="y")
+        if to_data:
+            # TODO: we need to determine exactly what we're getting and storing from the EDA client
+            return LegacyTaskOrders.create(
+                source=Source.EDA, funding_type=FundingType.PROC, **to_data
+            )
+
+        else:
+            raise NotFoundError("legacy_task_order")
+
+    @classmethod
+    def create(cls, source=Source.MANUAL, **kwargs):
+        to_data = {k: v for k, v in kwargs.items() if v not in ["", None]}
+        legacy_task_order = LegacyTaskOrder(source=source, **to_data)
+
+        db.session.add(legacy_task_order)
+        db.session.commit()
+
+        return legacy_task_order
+
+    @classmethod
+    def _client(cls):
+        return app.eda_client
+
+    @classmethod
+    def update(cls, legacy_task_order, dct):
+        updated = update_obj(
+            legacy_task_order, dct, ignore_vals=lambda v: v in ["", None]
+        )
+        db.session.add(updated)
+        db.session.commit()
+        return updated

atst/domain/reports.py

@@ -203,8 +203,8 @@ class Reports:
         if workspace.name in REPORT_FIXTURE_MAP:
             budget = REPORT_FIXTURE_MAP[workspace.name]["budget"]
             spent = _sum_monthly_spend(REPORT_FIXTURE_MAP[workspace.name]["monthly"])
-        elif workspace.request and workspace.request.task_order:
-            ws_to = workspace.request.task_order
+        elif workspace.request and workspace.request.legacy_task_order:
+            ws_to = workspace.request.legacy_task_order
             budget = ws_to.budget
             # spent will be derived from CSP data
             spent = 0

atst/domain/requests/financial_verification.py

@@ -1,6 +1,6 @@
 import re
 
-from atst.domain.task_orders import TaskOrders
+from atst.domain.legacy_task_orders import LegacyTaskOrders
 from atst.domain.pe_numbers import PENumbers
 from atst.domain.exceptions import NotFoundError
 
@@ -63,7 +63,7 @@ class PENumberValidator(object):
 class TaskOrderNumberValidator(object):
     def validate(self, field):
         try:
-            TaskOrders.get(field.data)
+            LegacyTaskOrders.get(field.data)
         except NotFoundError:
             self._apply_error(field)
             return False

atst/domain/requests/requests.py

@@ -187,10 +187,12 @@ class Requests(object):
         return Requests.status_count(RequestStatus.APPROVED)
 
     @classmethod
-    def update_financial_verification(cls, request_id, financial_data, task_order=None):
+    def update_financial_verification(
+        cls, request_id, financial_data, legacy_task_order=None
+    ):
         request = RequestsQuery.get_with_lock(request_id)
-        if task_order:
-            request.task_order = task_order
+        if legacy_task_order:
+            request.legacy_task_order = legacy_task_order
 
         request = Requests._update(request, {"financial_verification": financial_data})
         return request

atst/domain/task_orders.py

@@ -1,58 +0,0 @@
-from sqlalchemy.orm.exc import NoResultFound
-from flask import current_app as app
-
-from atst.database import db
-from atst.models.task_order import TaskOrder, Source, FundingType
-from .exceptions import NotFoundError
-from atst.utils import update_obj
-
-
-class TaskOrders(object):
-    TASK_ORDER_DATA = [col.name for col in TaskOrder.__table__.c if col.name != "id"]
-
-    @classmethod
-    def get(cls, order_number):
-        try:
-            task_order = (
-                db.session.query(TaskOrder).filter_by(number=order_number).one()
-            )
-        except NoResultFound:
-            if TaskOrders._client():
-                task_order = TaskOrders.get_from_eda(order_number)
-            else:
-                raise NotFoundError("task_order")
-
-        return task_order
-
-    @classmethod
-    def get_from_eda(cls, order_number):
-        to_data = TaskOrders._client().get_contract(order_number, status="y")
-        if to_data:
-            # TODO: we need to determine exactly what we're getting and storing from the EDA client
-            return TaskOrders.create(
-                source=Source.EDA, funding_type=FundingType.PROC, **to_data
-            )
-
-        else:
-            raise NotFoundError("task_order")
-
-    @classmethod
-    def create(cls, source=Source.MANUAL, **kwargs):
-        to_data = {k: v for k, v in kwargs.items() if v not in ["", None]}
-        task_order = TaskOrder(source=source, **to_data)
-
-        db.session.add(task_order)
-        db.session.commit()
-
-        return task_order
-
-    @classmethod
-    def _client(cls):
-        return app.eda_client
-
-    @classmethod
-    def update(cls, task_order, dct):
-        updated = update_obj(task_order, dct, ignore_vals=lambda v: v in ["", None])
-        db.session.add(updated)
-        db.session.commit()
-        return updated