server/app/core/controller/__init__.py → server/app/database/controller/__init__.py

 # import add, get
 from app.core import db
-from app.core.controller import add, delete, edit, get
+from app.database.controller import add, delete, edit, get, search
 
 
 def commit_and_refresh(item):

server/app/core/controller/add.py → server/app/database/controller/add.py

+import app.core.http_codes as codes
 from app.core import db
-from app.core.models import Blacklist, City, Competition, MediaType, Question, QuestionType, Role, Slide, Team, User
+from app.database.models import (
+    Blacklist,
+    City,
+    Competition,
+    MediaType,
+    Question,
+    QuestionType,
+    Role,
+    Slide,
+    Team,
+    User,
+)
+from flask_restx import abort
 
 
 def db_add(func):
@@ -8,6 +21,10 @@ def db_add(func):
         db.session.add(item)
         db.session.commit()
         db.session.refresh(item)
+
+        if not item:
+            abort(codes.BAD_REQUEST, f"Object could not be created")
+
         return item
 
     return wrapper

server/app/core/controller/delete.py → server/app/database/controller/delete.py

-import app.core.controller as dbc
+import app.database.controller as dbc
 from app.core import db
-from app.core.models import Blacklist, City, Competition, Role, Slide, User
+from app.database.models import Blacklist, City, Competition, Role, Slide, User
 
 
 def default(item):
@@ -17,7 +17,7 @@ def slide(item_slide):
     default(item_slide)
 
     # Update slide order for all slides after the deleted slide
-    slides_in_same_competition, _ = dbc.get.search_slide(competition_id=deleted_slide_competition_id)
+    slides_in_same_competition = dbc.get.slide_list(deleted_slide_competition_id)
     for other_slide in slides_in_same_competition:
         if other_slide.order > deleted_slide_order:
             other_slide.order -= 1

server/app/database/controller/get.py

+from app.database.models import Competition, Question, Slide, Team, User
+from sqlalchemy.sql.expression import outerjoin
+
+
+def user_exists(email):
+    return User.query.filter(User.email == email).count() > 0
+
+
+def competition(CID, required=True, error_msg=None):
+    return Competition.query.filter(Competition.id == CID).first_extended(required, error_msg)
+
+
+def user(UID, required=True, error_msg=None):
+    return User.query.filter(User.id == UID).first_extended(required, error_msg)
+
+
+def user_by_email(email, required=True, error_msg=None):
+    return User.query.filter(User.email == email).first_extended(required, error_msg)
+
+
+def slide_by_order(CID, order, required=True, error_msg=None):
+    return Slide.query.filter((Slide.competition_id == CID) & (Slide.order == order)).first_extended(
+        required, error_msg
+    )
+
+
+def slide(CID, SID, required=True, error_msg=None):
+    return Slide.query.filter((Slide.competition_id == CID) & (Slide.id == SID)).first_extended(required, error_msg)
+
+
+def team(CID, TID, required=True, error_msg=None):
+    return Team.query.filter((Team.competition_id == CID) & (Team.id == TID)).first_extended(required, error_msg)
+
+
+def question(CID, QID, required=True, error_msg=None):
+    return (
+        Question.query.join(Slide, (Slide.competition_id == CID) & (Slide.id == Question.slide_id))
+        .filter(Question.id == QID)
+        .first_extended(required, error_msg)
+    )
+
+
+def question_list(CID):
+    return Question.query.join(Slide, (Slide.competition_id == CID) & (Slide.id == Question.slide_id)).all()
+
+
+def team_list(CID):
+    return Team.query.filter(Team.competition_id == CID).all()
+
+
+def slide_list(CID):
+    return Slide.query.filter(Slide.competition_id == CID).all()
+
+
+def slide_count(CID):
+    return Slide.query.filter(Slide.competition_id == CID).count()

server/app/core/controller/get.py → server/app/database/controller/search.py

-from app.core.models import Competition, Question, Slide, Team, User
+from app.database.models import Competition, Question, Slide, Team, User
 
 
-def slide_by_order(CID, order):
-    return Slide.query.filter((Slide.competition_id == CID) & (Slide.order == order)).first()
-
-
-def slide(CID, SID):
-    return Slide.query.filter((Slide.competition_id == CID) & (Slide.id == SID)).first()
-
-
-def team(CID, TID):
-    return Team.query.filter((Team.competition_id == CID) & (Team.id == TID)).first()
-
-
-def question(CID, QID):
-    slide_ids = set(
-        [x.id for x in Slide.query.filter(Slide.competition_id == CID).all()]
-    )  # TODO: Filter using database instead of creating a set of slide_ids
-    return Question.query.filter(Question.slide_id.in_(slide_ids) & (Question.id == QID)).first()
-
-
-def _search(query, order_column, page=0, page_size=15, order=1):
-    if order == 1:
-        query = query.order_by(order_column)
-    else:
-        query = query.order_by(order_column.desc())
-
-    total = query.count()
-    query = query.limit(page_size).offset(page * page_size)
-    items = query.all()
-    return items, total
-
-
-def search_user(email=None, name=None, city_id=None, role_id=None, page=0, page_size=15, order=1, order_by=None):
+def user(email=None, name=None, city_id=None, role_id=None, page=0, page_size=15, order=1, order_by=None):
     query = User.query
     if name:
         query = query.filter(User.name.like(f"%{name}%"))
@@ -47,12 +16,26 @@ def search_user(email=None, name=None, city_id=None, role_id=None, page=0, page_
     if order_by:
         order_column = getattr(User.__table__.c, order_by)
 
-    return _search(query, order_column, page, page_size, order)
+    return query.pagination(page, page_size, order_column, order)
 
 
-def search_slide(
-    slide_order=None, title=None, body=None, competition_id=None, page=0, page_size=15, order=1, order_by=None
-):
+def competition(name=None, year=None, city_id=None, page=0, page_size=15, order=1, order_by=None):
+    query = Competition.query
+    if name:
+        query = query.filter(Competition.name.like(f"%{name}%"))
+    if year:
+        query = query.filter(Competition.year == year)
+    if city_id:
+        query = query.filter(Competition.city_id == city_id)
+
+    order_column = Competition.year  # Default order_by
+    if order_by:
+        order_column = getattr(Competition.columns, order_by)
+
+    return query.pagination(page, page_size, order_column, order)
+
+
+def slide(slide_order=None, title=None, body=None, competition_id=None, page=0, page_size=15, order=1, order_by=None):
     query = Slide.query
     if slide_order:
         query = query.filter(Slide.order == slide_order)
@@ -67,10 +50,10 @@ def search_slide(
     if order_by:
         order_column = getattr(Slide.__table__.c, order_by)
 
-    return _search(query, order_column, page, page_size, order)
+    return query.pagination(page, page_size, order_column, order)
 
 
-def search_questions(
+def questions(
     name=None,
     total_score=None,
     type_id=None,
@@ -100,20 +83,4 @@ def search_questions(
     if order_by:
         order_column = getattr(Question.__table__.c, order_by)
 
-    return _search(query, order_column, page, page_size, order)
-
-
-def search_competitions(name=None, year=None, city_id=None, page=0, page_size=15, order=1, order_by=None):
-    query = Competition.query
-    if name:
-        query = query.filter(Competition.name.like(f"%{name}%"))
-    if year:
-        query = query.filter(Competition.year == year)
-    if city_id:
-        query = query.filter(Competition.city_id == city_id)
-
-    order_column = Competition.year  # Default order_by
-    if order_by:
-        order_column = getattr(Competition.columns, order_by)
-
-    return _search(query, order_column, page, page_size, order)
+    return query.pagination(page, page_size, order_column, order)

server/app/core/models.py → server/app/database/models.py

@@ -123,8 +123,6 @@ class Slide(db.Model):
     settings = db.Column(db.Text, nullable=False, default="{}")
     competition_id = db.Column(db.Integer, db.ForeignKey("competition.id"), nullable=False)
 
-    questions = db.relationship("Question", backref="slide")
-
     def __init__(self, order, competition_id):
         self.order = order
         self.competition_id = competition_id
@@ -138,6 +136,7 @@ class Question(db.Model):
     type_id = db.Column(db.Integer, db.ForeignKey("question_type.id"), nullable=False)
     slide_id = db.Column(db.Integer, db.ForeignKey("slide.id"), nullable=False)
 
+    slide = db.relationship("Slide", backref="questions")
     question_answers = db.relationship("QuestionAnswer", backref="question")
     alternatives = db.relationship("QuestionAlternative", backref="question")
 

server/populate.py

 from sqlalchemy.sql.expression import true
 
-import app.core.controller as dbc
+import app.database.controller as dbc
 from app import create_app, db
-from app.core.models import City, Competition, MediaType, QuestionType, Role
+from app.database.models import City, Competition, MediaType, QuestionType, Role
 
 
 def _add_items():

server/tests/test_app.py

 import app.core.http_codes as codes
-from app.core.models import Slide
+from app.database.models import Slide
 
 from tests import app, client, db
-from tests.test_helpers import add_default_values, change_order_test, delete, get, post, put
+from tests.test_helpers import (add_default_values, change_order_test, delete,
+                                get, post, put)
 
 
 def test_misc_api(client):
@@ -301,7 +302,7 @@ def test_slide_api(client):
     SID = body["items"][i]["id"]
     order = body["items"][i]["order"]
     response, _ = put(client, f"/api/competitions/{CID}/slides/{SID}/order", {"order": order}, headers=headers)
-    assert response.status_code == codes.BAD_REQUEST
+    assert response.status_code == codes.OK
 
     # Changes the order
     change_order_test(client, CID, SID, order + 1, headers)
@@ -330,6 +331,7 @@ def test_question_api(client):
     num_questions = 3
     response, body = get(client, f"/api/competitions/{CID}/questions", headers=headers)
     assert response.status_code == codes.OK
+    print(body)
     assert body["count"] == num_questions
 
     # # Get specific question
@@ -368,7 +370,7 @@ def test_question_api(client):
     assert item_question["name"] == name
     # # assert item_question["total_score"] == total_score
     assert item_question["type"]["id"] == type_id
-    assert item_question["slide"]["id"] == slide_id
+    assert item_question["slide_id"] == slide_id
     # Checks number of questions
     response, body = get(client, f"/api/competitions/{CID}/questions", headers=headers)
     assert response.status_code == codes.OK
@@ -413,7 +415,7 @@ def test_question_api(client):
     assert item_question["name"] != name
     # assert item_question["total_score"] != total_score
     assert item_question["type"]["id"] != type_id
-    assert item_question["slide"]["id"] != slide_id
+    assert item_question["slide_id"] != slide_id
     response, item_question = put(
         client,
         f"/api/competitions/{CID}/questions/{QID}",
@@ -425,7 +427,7 @@ def test_question_api(client):
     assert item_question["name"] == name
     # # assert item_question["total_score"] == total_score
     assert item_question["type"]["id"] == type_id
-    assert item_question["slide"]["id"] == slide_id
+    assert item_question["slide_id"] == slide_id
     # Checks number of questions
     response, body = get(client, f"/api/competitions/{CID}/questions", headers=headers)
     assert response.status_code == codes.OK

server/tests/test_db.py

-import app.core.controller as dbc
-from app.core.models import City, Competition, Media, MediaType, Question, QuestionType, Role, Slide, Team, User
+import app.database.controller as dbc
+from app.database.models import City, Competition, Media, MediaType, Question, QuestionType, Role, Slide, Team, User
 
 from tests import app, client, db
 from tests.test_helpers import add_default_values, assert_exists, assert_insert_fail
@@ -40,6 +40,7 @@ def test_media(client):
     assert item_media.upload_by.email == "test@test.se"
 
 
+"""
 def test_question(client):
     add_default_values()
     item_user = User.query.filter_by(email="test@test.se").first()
@@ -168,3 +169,4 @@ def test_slide(client):
     aux = dbc.get.search_slide(slide_order=1, competition_id=item_comp.id)
     item_slide = aux[0][0]
     dbc.delete.slide(item_slide)
+"""

server/tests/test_helpers.py

 import json
 
-import app.core.controller as dbc
 import app.core.http_codes as codes
+import app.database.controller as dbc
 from app.core import db
-from app.core.models import City, Role
+from app.database.models import City, Role
 
 
 def add_default_values():