TaskOrders domain responsible for adding officers

atst/domain/task_orders.py

@@ -2,8 +2,10 @@ from sqlalchemy.orm.exc import NoResultFound
 
 from atst.database import db
 from atst.models.task_order import TaskOrder
+from atst.domain.workspaces import Workspaces
 from .exceptions import NotFoundError
 
+
 class TaskOrderError(Exception):
     pass
 
@@ -93,16 +95,25 @@ class TaskOrders(object):
 
         return True
 
-    OFFICERS = ["contracting_officer", "contracting_officer_representative", "security_officer"]
+    OFFICERS = [
+        "contracting_officer",
+        "contracting_officer_representative",
+        "security_officer",
+    ]
 
     @classmethod
-    def add_officer(cls, task_order, user, role):
+    def add_officer(cls, user, task_order, role, officer_data):
         if role in TaskOrders.OFFICERS:
-            setattr(task_order, role, user)
+            member = Workspaces.create_member(
+                user, task_order.workspace, {**officer_data, "workspace_role": role}
+            )
+            setattr(task_order, role, member.user)
 
             db.session.add(task_order)
             db.session.commit()
 
-            return task_order
+            return member.user
         else:
-            raise TaskOrderError("{} is not an officer role on task orders".format(role))
+            raise TaskOrderError(
+                "{} is not an officer role on task orders".format(role)
+            )

atst/routes/task_orders/new.py

@@ -10,6 +10,7 @@ from flask import (
 from . import task_orders_bp
 from atst.domain.task_orders import TaskOrders
 from atst.domain.workspaces import Workspaces
+from atst.domain.workspace_roles import WorkspaceRoles
 import atst.forms.task_order as task_order_form
 from atst.services.invitation import Invitation as InvitationService
 
@@ -167,17 +168,18 @@ class UpdateTaskOrderWorkflow(ShowTaskOrderWorkflow):
                     field: getattr(self.task_order, prefix + "_" + field)
                     for field in ["first_name", "last_name", "email", "dod_id"]
                 }
+                officer = TaskOrders.add_officer(
+                    self.user, self.task_order, officer_type["role"], officer_data
+                )
+                ws_officer_member = WorkspaceRoles.get(self.workspace.id, officer.id)
                 invite_service = InvitationService(
                     self.user,
-                    self.workspace,
+                    ws_officer_member,
-                    {**officer_data, "workspace_role": officer_type["role"]},
+                    officer_data["email"],
                     subject=officer_type["subject"],
                     email_template=officer_type["template"],
                 )
-                invite = invite_service.invite()
+                invite_service.invite()
-                TaskOrders.add_officer(
-                    self.task_order, invite.user, officer_type["role"]
-                )
 
     def update(self):
         self._update_task_order()

atst/routes/workspaces/members.py

@@ -70,7 +70,10 @@ def create_member(workspace_id):
 
     if form.validate():
         try:
-            invite_service = InvitationService(g.current_user, workspace, form.data)
+            member = Workspaces.create_member(g.current_user, workspace, form.data)
+            invite_service = InvitationService(
+                g.current_user, member, form.data.get("email")
+            )
             invite_service.invite()
 
             flash("new_workspace_member", new_member=new_member, workspace=workspace)

atst/services/invitation.py

@@ -1,6 +1,5 @@
 from flask import render_template
 
-from atst.domain.workspaces import Workspaces
 from atst.domain.invitations import Invitations
 from atst.queue import queue
 
@@ -9,33 +8,28 @@ class Invitation:
     def __init__(
         self,
         inviter,
-        workspace,
+        member,
-        user_info,
+        email,
         subject="{} has invited you to a JEDI Cloud Workspace",
         email_template="emails/invitation.txt",
     ):
         self.inviter = inviter
-        self.workspace = workspace
+        self.member = member
-        self.user_info = user_info
+        self.email = email
         self.subject = subject
         self.email_template = email_template
 
     def invite(self):
-        member = self._create_member()
+        invite = self._create_invite()
-        email = self.user_info.get("email")
+        self._send_invite_email(invite.token)
-        invite = self._create_invite(member, email)
-        self._send_invite_email(invite.token, email)
 
         return invite
 
-    def _create_member(self):
+    def _create_invite(self):
-        return Workspaces.create_member(self.inviter, self.workspace, self.user_info)
+        return Invitations.create(self.inviter, self.member, self.email)
 
-    def _create_invite(self, member, email):
+    def _send_invite_email(self, token):
-        return Invitations.create(self.inviter, member, email)
-
-    def _send_invite_email(self, token, email):
         body = render_template(
             self.email_template, owner=self.inviter.full_name, token=token
         )
-        queue.send_mail([email], self.subject.format(self.inviter), body)
+        queue.send_mail([self.email], self.subject.format(self.inviter), body)

tests/domain/test_task_orders.py

@@ -1,8 +1,8 @@
 import pytest
 
-from atst.domain.task_orders import TaskOrders
+from atst.domain.task_orders import TaskOrders, TaskOrderError
 
-from tests.factories import TaskOrderFactory
+from tests.factories import TaskOrderFactory, UserFactory
 
 
 def test_is_section_complete():
@@ -29,3 +29,22 @@ def test_all_sections_complete():
     assert not TaskOrders.all_sections_complete(task_order)
     task_order.scope = "str12345"
     assert TaskOrders.all_sections_complete(task_order)
+
+
+def test_add_officer():
+    task_order = TaskOrderFactory.create()
+    ko = UserFactory.create()
+    owner = task_order.workspace.owner
+    TaskOrders.add_officer(owner, task_order, "contracting_officer", ko.to_dictionary())
+
+    assert task_order.contracting_officer == ko
+    workspace_users = [ws_role.user for ws_role in task_order.workspace.members]
+    assert ko in workspace_users
+
+
+def test_add_officer_with_nonexistent_role():
+    task_order = TaskOrderFactory.create()
+    ko = UserFactory.create()
+    owner = task_order.workspace.owner
+    with pytest.raises(TaskOrderError):
+        TaskOrders.add_officer(owner, task_order, "pilot", ko.to_dictionary())

tests/services/test_invitation.py

@@ -1,4 +1,4 @@
-from tests.factories import UserFactory, WorkspaceFactory
+from tests.factories import UserFactory, WorkspaceFactory, WorkspaceRoleFactory
 
 from atst.services.invitation import Invitation
 
@@ -7,11 +7,8 @@ def test_invite_member(queue):
     inviter = UserFactory.create()
     new_member = UserFactory.create()
     workspace = WorkspaceFactory.create(owner=inviter)
-    invite_service = Invitation(
+    ws_member = WorkspaceRoleFactory.create(user=new_member, workspace=workspace)
-        inviter,
+    invite_service = Invitation(inviter, ws_member, new_member.email)
-        workspace,
-        {**new_member.to_dictionary(), "workspace_role": "developer"},
-    )
     new_invitation = invite_service.invite()
     assert new_invitation == new_member.invitations[0]
     assert len(queue.get_queue()) == 1