Convert Users, Roles, WorkspaceUsers, TaskOrders to use classmethods

atst/domain/roles.py

@@ -1,20 +1,21 @@
 from sqlalchemy.orm.exc import NoResultFound
 
+from atst.database import db
 from atst.models import Role
 from .exceptions import NotFoundError
 
 
 class Roles(object):
-    def __init__(self, db_session):
-        self.db_session = db_session
 
-    def get(self, role_name):
+    @classmethod
+    def get(cls, role_name):
         try:
-            role = self.db_session.query(Role).filter_by(name=role_name).one()
+            role = db.session.query(Role).filter_by(name=role_name).one()
         except NoResultFound:
             raise NotFoundError("role")
 
         return role
 
-    def get_all(self):
-        return self.db_session.query(Role).all()
+    @classmethod
+    def get_all(cls):
+        return db.session.query(Role).all()

atst/domain/task_orders.py

@@ -1,17 +1,17 @@
 from sqlalchemy.orm.exc import NoResultFound
 
+from atst.database import db
 from atst.models.task_order import TaskOrder
 from .exceptions import NotFoundError
 
 
 class TaskOrders(object):
-    def __init__(self, db_session):
-        self.db_session = db_session
 
+    @classmethod
     def get(self, order_number):
         try:
             task_order = (
-                self.db_session.query(TaskOrder).filter_by(number=order_number).one()
+                db.session.query(TaskOrder).filter_by(number=order_number).one()
             )
         except NoResultFound:
             raise NotFoundError("task_order")

atst/domain/users.py

@@ -1,6 +1,7 @@
 from sqlalchemy.orm.exc import NoResultFound
 from sqlalchemy.exc import IntegrityError
 
+from atst.database import db
 from atst.models import User
 
 from .roles import Roles
@@ -8,47 +9,48 @@ from .exceptions import NotFoundError, AlreadyExistsError
 
 
 class Users(object):
-    def __init__(self, db_session):
-        self.db_session = db_session
-        self.roles_repo = Roles(db_session)
 
-    def get(self, user_id):
+    @classmethod
+    def get(cls, user_id):
         try:
-            user = self.db_session.query(User).filter_by(id=user_id).one()
+            user = db.session.query(User).filter_by(id=user_id).one()
         except NoResultFound:
             raise NotFoundError("user")
 
         return user
 
+    @classmethod
     def create(self, user_id, atat_role_name):
-        atat_role = self.roles_repo.get(atat_role_name)
+        atat_role = Roles.get(atat_role_name)
 
         try:
             user = User(id=user_id, atat_role=atat_role)
-            self.db_session.add(user)
-            self.db_session.commit()
+            db.session.add(user)
+            db.session.commit()
         except IntegrityError:
             raise AlreadyExistsError("user")
 
         return user
 
-    def get_or_create(self, user_id, *args, **kwargs):
+    @classmethod
+    def get_or_create(cls, user_id, *args, **kwargs):
         try:
-            user = self.get(user_id)
+            user = Users.get(user_id)
         except NotFoundError:
-            user = self.create(user_id, *args, **kwargs)
-            self.db_session.add(user)
-            self.db_session.commit()
+            user = Users.create(user_id, *args, **kwargs)
+            db.session.add(user)
+            db.session.commit()
 
         return user
 
+    @classmethod
     def update(self, user_id, atat_role_name):
 
-        user = self.get(user_id)
-        atat_role = self.roles_repo.get(atat_role_name)
+        user = Users.get(user_id)
+        atat_role = Roles.get(atat_role_name)
         user.atat_role = atat_role
 
-        self.db_session.add(user)
-        self.db_session.commit()
+        db.session.add(user)
+        db.session.commit()
 
         return user

atst/domain/workspace_users.py

@@ -1,22 +1,21 @@
 from sqlalchemy.orm.exc import NoResultFound
 
+from atst.database import db
 from atst.models.workspace_role import WorkspaceRole
 from atst.models.workspace_user import WorkspaceUser
 from atst.models.user import User
+
 from .roles import Roles
 from .users import Users
 from .exceptions import NotFoundError
 
 
 class WorkspaceUsers(object):
-    def __init__(self, db_session):
-        self.db_session = db_session
-        self.roles_repo = Roles(db_session)
-        self.users_repo = Users(db_session)
 
-    def get(self, workspace_id, user_id):
+    @classmethod
+    def get(cls, workspace_id, user_id):
         try:
-            user = self.users_repo.get(user_id)
+            user = Users.get(user_id)
         except NoResultFound:
             raise NotFoundError("user")
 
@@ -31,24 +30,25 @@ class WorkspaceUsers(object):
 
         return WorkspaceUser(user, workspace_role)
 
-    def add_many(self, workspace_id, workspace_user_dicts):
+    @classmethod
+    def add_many(cls, workspace_id, workspace_user_dicts):
         workspace_users = []
 
         for user_dict in workspace_user_dicts:
             try:
-                user = self.users_repo.get(user_dict["id"])
+                user = Users.get(user_dict["id"])
             except NoResultFound:
-                default_role = self.roles_repo.get("developer")
+                default_role = Roles.get("developer")
                 user = User(id=user_dict["id"], atat_role=default_role)
 
             try:
-                role = self.roles_repo.get(user_dict["workspace_role"])
+                role = Roles.get(user_dict["workspace_role"])
             except NoResultFound:
                 raise NotFoundError("role")
 
             try:
                 existing_workspace_role = (
-                    self.db_session.query(WorkspaceRole)
+                    db.session.query(WorkspaceRole)
                     .filter(
                         WorkspaceRole.user == user,
                         WorkspaceRole.workspace_id == workspace_id,
@@ -66,8 +66,8 @@ class WorkspaceUsers(object):
             workspace_user = WorkspaceUser(user, new_workspace_role)
             workspace_users.append(workspace_user)
 
-            self.db_session.add(user)
+            db.session.add(user)
 
-        self.db_session.commit()
+        db.session.commit()
 
         return workspace_users