Resolve "Fix python warnings"

.gitignore

@@ -4,4 +4,5 @@ __pycache__
 *.coverage
 */coverage
 htmlcov
-.pytest_cache
\ No newline at end of file
+.pytest_cache
+/.idea
\ No newline at end of file

server/app/__init__.py

@@ -38,4 +38,4 @@ def identity(payload):
 def check_if_token_in_blacklist(decrypted_token):
     jti = decrypted_token["jti"]
 
-    return models.Blacklist.query.filter_by(jti=jti).first() != None
+    return models.Blacklist.query.filter_by(jti=jti).first() is not None

server/app/api/admin.py

 ###
 # Admin stuff placed here for later use
 # No need to implement this before the application is somewhat done
-# Only adding basic thigns like addning countries
 ###
 
 from flask import Blueprint

server/app/api/users.py

 import datetime
 
+import app.database.controller as dbc
 from app import db
 from app.api import api_blueprint
-from app.database.controller import add_user
 from app.database.models import Blacklist, User
-from app.utils.validator import edit_user_schema, login_schema, register_schema, validateObject
+from app.utils.validator import edit_user_schema, login_schema, register_schema, validate_object
 from flask import request
-from flask.globals import session
 from flask_jwt_extended import (
     create_access_token,
     create_refresh_token,
@@ -36,15 +35,15 @@ def test_auth():
 def login():
     json_dict = request.get_json(force=True)
 
-    validate_msg = validateObject(login_schema, json_dict)
-    if validate_msg != None:
+    validate_msg = validate_object(login_schema, json_dict)
+    if validate_msg is not None:
         return {"message": validate_msg}, 400
 
     email = json_dict["email"]
     password = json_dict["password"]
     user = User.query.filter_by(email=email).first()
 
-    # Dont show the user that the email was correct unless the password was also correct
+    # Don't show the user that the email was correct unless the password was also correct
     if not user:
         return {"message": "The email or password you entered is incorrect."}, 401
 
@@ -82,17 +81,16 @@ def refresh():
 def create():
     json_dict = request.get_json(force=True)
 
-    validate_msg = validateObject(register_schema, json_dict)
-    if validate_msg != None:
+    validate_msg = validate_object(register_schema, json_dict)
+    if validate_msg is not None:
         return {"message": validate_msg}, 400
 
     existing_user = User.query.filter_by(email=json_dict["email"]).first()
 
-    if existing_user != None:
+    if existing_user is not None:
         return {"message": "User already exists"}, 400
 
-    add_user(json_dict["email"], json_dict["password"], json_dict["role"], json_dict["city"])
-    db.session.commit()
+    dbc.add.user(json_dict["email"], json_dict["password"], json_dict["role"], json_dict["city"])
 
     item_user = User.query.filter_by(email=json_dict["email"]).first()
 
@@ -104,8 +102,8 @@ def create():
 def edit():
     json_dict = request.get_json(force=True)
 
-    validate_msg = validateObject(edit_user_schema, json_dict)
-    if validate_msg != None:
+    validate_msg = validate_object(edit_user_schema, json_dict)
+    if validate_msg is not None:
         return {"message": validate_msg}, 400
 
     user = get_current_user()

server/app/database/__init__.py

 import sqlalchemy as sa
 from flask_sqlalchemy.model import Model
-from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.sql import func
 
 

server/app/database/controller.py

-from app import db
-from app.database.models import City, Role, User
-
-
-def add_user(email, plaintext_password, role, city):
-    item_role = Role.query.filter_by(name=role).first()
-    item_city = City.query.filter_by(name=city).first()
-    user = User(email, plaintext_password, item_role.id, item_city.id)
-    db.session.add(user)

server/app/database/controller/__init__.py

+# import add, get
+from app.database.controller import add, get

server/app/database/controller/add.py

+from app import db
+from app.database.models import City, Competition, Role, Slide, Style, User
+
+
+def user(email, plaintext_password, role, city):
+    item_role = Role.query.filter(Role.name == role).first()
+    item_city = City.query.filter(City.name == city).first()
+
+    new_user = User(email, plaintext_password, item_role.id, item_city.id)
+    db.session.add(new_user)
+    db.session.commit()
+
+    return User.query.filter(User.email == email).first()
+
+
+def competition(name, style_id, city_id):
+    db.session.add(Competition(name, style_id, city_id))
+    db.session.commit()
+
+    filters = (Competition.name == name) & (Competition.city_id == city_id)
+    return Competition.query.filter(filters).first()
+
+
+def slide(competition_id):
+    # item_slides = Slide.query.filter(Slide.competition_id == competition_id).order_by(Slide.order).all()
+    order = Slide.query.filter(Slide.competition_id == competition_id).count()
+    db.session.add(Slide(order, competition_id))
+    db.session.commit()
+
+    filters = (Slide.order == order) & (Competition.competition_id == competition_id)
+    return Slide.query.filter(filters).first()

server/app/database/controller/get.py

+from app import db
+from app.database.models import City, Competition, Role, Slide, Style, User
+from sqlalchemy import and_, or_
+
+
+def user():
+    return

server/app/database/models.py

-from enum import unique
-
 from app import bcrypt, db
-from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
 
 STRING_SIZE = 254
@@ -45,10 +42,9 @@ class User(db.Model):
 
     _password = db.Column(db.LargeBinary(60), nullable=False)
 
-    # Change to false for Two factor authen
     authenticated = db.Column(db.Boolean, default=False)
-    twoAuthConfirmed = db.Column(db.Boolean, default=True)
-    twoAuthCode = db.Column(db.String(STRING_SIZE), nullable=True)
+    # twoAuthConfirmed = db.Column(db.Boolean, default=True)
+    # twoAuthCode = db.Column(db.String(STRING_SIZE), nullable=True)
 
     role_id = db.Column(db.Integer, db.ForeignKey("role.id"), nullable=False)
     city_id = db.Column(db.Integer, db.ForeignKey("city.id"), nullable=False)

server/app/database/populate.py

+import app.database.controller as dbc
 from app import db
-from app.database.controller import add_user
 from app.database.models import City, MediaType, QuestionType, Role
 
 media_types = ["Image", "Video"]
@@ -11,24 +11,23 @@ cities = ["Linköping"]
 def add_default_values():
 
     # Add media types
-    for type in media_types:
-        db.session.add(MediaType(type))
+    for item in media_types:
+        db.session.add(MediaType(item))
 
     # Add question types
-    for type in question_types:
-        db.session.add(QuestionType(type))
+    for item in question_types:
+        db.session.add(QuestionType(item))
 
     # Add roles
-    for role in roles:
-        db.session.add(Role(role))
+    for item in roles:
+        db.session.add(Role(item))
 
     # Add cities
-    for city in cities:
-        db.session.add(City(city))
+    for item in cities:
+        db.session.add(City(item))
 
     # Commit changes to db
     db.session.commit()
 
     # Add user with role and city
-    add_user("test@test.se", "password", "Admin", "Linköping")
-    db.session.commit()
+    dbc.add.user("test@test.se", "password", "Admin", "Linköping")

server/app/utils/test_helpers.py

@@ -2,21 +2,21 @@ from app import db
 
 
 # Try insert invalid row. If it fails then the test is passed
-def assert_insert_fail(type, *args):
+def assert_insert_fail(db_type, *args):
     try:
-        db.session.add(type(*args))
+        db.session.add(db_type(*args))
         db.session.commit()
         assert False
     except:
         db.session.rollback()
 
 
-def assert_exists(type, length, **kwargs):
-    items = type.query.filter_by(**kwargs).all()
+def assert_exists(db_type, length, **kwargs):
+    items = db_type.query.filter_by(**kwargs).all()
     assert len(items) == length
     return items[0]
 
 
-def assert_object_values(object, dict):
-    for k, v in dict.items():
-        assert getattr(object, k) == v
+def assert_object_values(obj, values):
+    for k, v in values.items():
+        assert getattr(obj, k) == v

server/app/utils/validator.py

 from cerberus import Validator
 
 
-def validateObject(schema, obj, allow_unknown=False):
+def validate_object(schema, obj, allow_unknown=False):
     v = Validator(schema, allow_unknown)
     if not v.validate(obj):
         return v.errors

server/tests/test_db.py

 import pytest
-from app.database.controller import add_user
 from app.database.models import (
     City,
     Competition,
@@ -14,6 +13,7 @@ from app.database.models import (
     Team,
     User,
 )
+import app.database.controller as dbc
 from app.database.populate import add_default_values
 from app.utils.test_helpers import *
 
@@ -27,7 +27,7 @@ def test_user(client):
     item_user = User.query.filter_by(email="test@test.se").first()
 
     # Assert user
-    assert item_user != None
+    assert item_user is not None
     assert item_user.city.name == "Linköping"
     assert item_user.role.name == "Admin"
 
@@ -52,7 +52,7 @@ def test_media_style(client):
 
     # Assert image
     item_media = Media.query.filter_by(filename="bild.png").first()
-    assert item_media != None
+    assert item_media is not None
     assert len(item_user.media) == 1
     assert item_media.upload_by.email == "test@test.se"
 
@@ -62,7 +62,7 @@ def test_media_style(client):
 
     # Assert style
     item_style = Style.query.filter_by(name="template").first()
-    assert item_style != None
+    assert item_style is not None
     assert len(item_media.styles) == 1
     assert item_style.bg_image.filename == "bild.png"
 
@@ -95,7 +95,7 @@ def test_question(client):
     item_competition = Competition.query.filter_by(name="teknik8").first()
     item_competition_2 = Competition.query.filter_by(name="teknik9").first()
 
-    assert item_competition != None
+    assert item_competition is not None
     assert item_competition.id == 1
     assert item_competition.style.name == "template"
     assert item_competition.city.name == "Linköping"
@@ -131,9 +131,9 @@ def test_question(client):
     item_slide2 = Slide.query.filter_by(order=2).first()
     item_slide3 = Slide.query.filter_by(order=3).first()
 
-    assert item_slide1 != None
-    assert item_slide2 != None
-    assert item_slide3 != None
+    assert item_slide1 is not None
+    assert item_slide2 is not None
+    assert item_slide3 is not None
 
     # Add questions
     question_type_bool = QuestionType.query.filter_by(name="Boolean").first()
@@ -143,8 +143,8 @@ def test_question(client):
     db.session.add(Question("Fråga2", 1, question_type_multiple.id, item_slide3.id))
     db.session.commit()
 
-    assert question_type_bool != None
-    assert question_type_multiple != None
+    assert question_type_bool is not None
+    assert question_type_multiple is not None
 
     item_q1 = Question.query.filter_by(name="Fråga1").first()
     item_q2 = Question.query.filter_by(name="Fråga2").first()