From c0b66eaaa4481705c3edc6f0196ec678643cce9f Mon Sep 17 00:00:00 2001
From: Robert Goldmann <deadlocker@gmx.de>
Date: Sun, 3 May 2020 10:15:11 +0200
Subject: [PATCH] api: coding style

---
 api/DateFormatter.py           |  4 +--
 api/RequestValidator.py        |  8 +++---
 api/RoadmapAPIServer.py        | 22 ++++++++--------
 api/UserService.py             |  2 +-
 api/blueprints/MilestoneAPI.py | 32 +++++++++++------------
 api/blueprints/RoadmapAPI.py   | 46 +++++++++++++++++-----------------
 api/blueprints/SubTaskAPI.py   | 20 +++++++--------
 api/blueprints/TaskAPI.py      | 20 +++++++--------
 8 files changed, 77 insertions(+), 77 deletions(-)

diff --git a/api/DateFormatter.py b/api/DateFormatter.py
index 3531ef2..0cc55d1 100644
--- a/api/DateFormatter.py
+++ b/api/DateFormatter.py
@@ -3,10 +3,10 @@ from datetime import datetime, date
 
 class DateFormatter:
     DEFAULT_DATE = date(2000, 1, 1)
-    FORMAT = "%d.%m.%Y"
+    FORMAT = '%d.%m.%Y'
 
     @staticmethod
     def format(dateObject):
         if dateObject == DateFormatter.DEFAULT_DATE:
-            return "-"
+            return '-'
         return datetime.strftime(dateObject, DateFormatter.FORMAT)
diff --git a/api/RequestValidator.py b/api/RequestValidator.py
index e6a6fdb..66add8a 100644
--- a/api/RequestValidator.py
+++ b/api/RequestValidator.py
@@ -4,21 +4,21 @@ from flask import jsonify
 class ValidationError(Exception):
     def __init__(self, message):
         super().__init__(message)
-        self.response = jsonify({"success": False,
-                                 "msg": message})
+        self.response = jsonify({'success': False,
+                                 'msg': message})
 
 
 class RequestValidator:
     @staticmethod
     def validate(request, parameters):
         if not request.is_json:
-            raise ValidationError("Missing JSON in request")
+            raise ValidationError('Missing JSON in request')
 
         result = {}
         for param in parameters:
             value = request.json.get(param, None)
             if value is None:
-                raise ValidationError("Missing parameter '{}'".format(param))
+                raise ValidationError(f'Missing parameter "{param}"')
             result[param] = value
 
         return result
diff --git a/api/RoadmapAPIServer.py b/api/RoadmapAPIServer.py
index e81fd06..ac51b3a 100644
--- a/api/RoadmapAPIServer.py
+++ b/api/RoadmapAPIServer.py
@@ -22,33 +22,33 @@ LOGGER = DefaultLogger().create_logger_if_not_exists(Constants.APP_NAME)
 class RoadmapApi(FlaskBaseApp):
     def __init__(self, appName: str, rootDir: str, logger: logging.Logger, settingsPath: str):
         super().__init__(appName, rootDir, logger, settingsPath=settingsPath)
-        self._database = Database(self._settings["database"])
-        self._userService = UserService(self._settings["users"])
+        self._database = Database(self._settings['database'])
+        self._userService = UserService(self._settings['users'])
 
     def _register_blueprints(self, app):
-        app.config["JWT_SECRET_KEY"] = self._serverSettings["secret"]
+        app.config['JWT_SECRET_KEY'] = self._serverSettings['secret']
         jwt = JWTManager(app)
 
         @app.route('/')
         def index():
-            return send_from_directory("docs", "api.html")
+            return send_from_directory('docs', 'api.html')
 
         @app.route('/login', methods=['POST'])
         def login():
             try:
-                parameters = RequestValidator.validate(request, ["username", "password"])
+                parameters = RequestValidator.validate(request, ['username', 'password'])
             except ValidationError as e:
                 return e.response, 400
 
-            password = self._userService.get_password_by_username(parameters["username"])
+            password = self._userService.get_password_by_username(parameters['username'])
             if password is None:
-                return jsonify({"success": False, "msg": "Unknown username"}), 401
+                return jsonify({'success': False, 'msg': 'Unknown username'}), 401
 
-            if password != parameters["password"]:
-                return jsonify({"success": False, "msg": "Bad credentials"}), 401
+            if password != parameters['password']:
+                return jsonify({'success': False, 'msg': 'Bad credentials'}), 401
 
             expires = datetime.timedelta(hours=1)
-            access_token = create_access_token(identity=parameters["username"], expires_delta=expires)
+            access_token = create_access_token(identity=parameters['username'], expires_delta=expires)
             return jsonify(access_token=access_token), 200
 
         app.register_blueprint(RoadmapAPI.construct_blueprint(self._database))
@@ -57,6 +57,6 @@ class RoadmapApi(FlaskBaseApp):
         app.register_blueprint(SubTaskAPI.construct_blueprint(self._database))
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     roadmapApi = RoadmapApi(Constants.APP_NAME, os.path.dirname(__file__), LOGGER, 'settings.json')
     roadmapApi.start_server()
diff --git a/api/UserService.py b/api/UserService.py
index d444d86..f953e66 100644
--- a/api/UserService.py
+++ b/api/UserService.py
@@ -2,7 +2,7 @@ class UserService:
     def __init__(self, users):
         self.__users = {}
         for user in users:
-            self.__users[user["name"]] = user["password"]
+            self.__users[user['name']] = user['password']
 
     def get_users(self):
         return self.__users
diff --git a/api/blueprints/MilestoneAPI.py b/api/blueprints/MilestoneAPI.py
index e161065..5cbf5c7 100644
--- a/api/blueprints/MilestoneAPI.py
+++ b/api/blueprints/MilestoneAPI.py
@@ -10,14 +10,14 @@ from blueprints.TaskAPI import TaskParameters
 
 
 class MilestoneParameters(Enum):
-    ID = "ID"
-    ROADMAP_ID = "RoadmapID"
-    VERSION_CODE = "VersionCode"
-    VERSION_NAME = "VersionName"
-    TITLE = "Title"
-    DUE_DATE = "DueDate"
-    COMPLETION_DATE = "CompletionDate"
-    STATUS = "Status"
+    ID = 'ID'
+    ROADMAP_ID = 'RoadmapID'
+    VERSION_CODE = 'VersionCode'
+    VERSION_NAME = 'VersionName'
+    TITLE = 'Title'
+    DUE_DATE = 'DueDate'
+    COMPLETION_DATE = 'CompletionDate'
+    STATUS = 'Status'
 
     @staticmethod
     def get_values():
@@ -86,13 +86,13 @@ def construct_blueprint(database):
                                parameters[MilestoneParameters.DUE_DATE.value],
                                parameters[MilestoneParameters.COMPLETION_DATE.value],
                                parameters[MilestoneParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
-    @milestone_api.route("/milestone/<int:milestoneID>/close", methods=['POST'])
+    @milestone_api.route('/milestone/<int:milestoneID>/close', methods=['POST'])
     @jwt_required
     def close_milestone(milestoneID):
         if not __milestone_exists(milestoneID):
-            return jsonify({"success": False, "msg": "No milestone with id '{}' existing".format(milestoneID)}), 400
+            return jsonify({'success': False, 'msg': "No milestone with id '{}' existing".format(milestoneID)}), 400
 
         database.finish_milestone(milestoneID)
 
@@ -105,16 +105,16 @@ def construct_blueprint(database):
             for sub_task in sub_tasks:
                 database.finish_sub_task(sub_task[SubTaskParameters.ID.value])
 
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @milestone_api.route('/milestone/<int:milestoneID>', methods=['DELETE'])
     @jwt_required
     def delete_milestone(milestoneID):
         if not __milestone_exists(milestoneID):
-            return jsonify({"success": False, "msg": "No milestone with id '{}' existing".format(milestoneID)}), 400
+            return jsonify({'success': False, 'msg': "No milestone with id '{}' existing".format(milestoneID)}), 400
 
         database.delete_milestone(milestoneID)
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @milestone_api.route('/milestone', methods=['PUT'])
     @jwt_required
@@ -126,7 +126,7 @@ def construct_blueprint(database):
 
         milestoneID = parameters[MilestoneParameters.ID.value]
         if not __milestone_exists(milestoneID):
-            return jsonify({"success": False, "msg": "No milestone with ID '{}' existing".format(milestoneID)}), 400
+            return jsonify({'success': False, 'msg': "No milestone with ID '{}' existing".format(milestoneID)}), 400
 
         database.update_milestone(milestoneID,
                                   parameters[MilestoneParameters.ROADMAP_ID.value],
@@ -136,7 +136,7 @@ def construct_blueprint(database):
                                   parameters[MilestoneParameters.DUE_DATE.value],
                                   parameters[MilestoneParameters.COMPLETION_DATE.value],
                                   parameters[MilestoneParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     def __milestone_exists(milestoneID):
         milestoneID = int(milestoneID)
diff --git a/api/blueprints/RoadmapAPI.py b/api/blueprints/RoadmapAPI.py
index a3888c9..9700411 100644
--- a/api/blueprints/RoadmapAPI.py
+++ b/api/blueprints/RoadmapAPI.py
@@ -9,8 +9,8 @@ from RequestValidator import RequestValidator, ValidationError
 
 
 class RoadmapParameters(Enum):
-    ID = "ID"
-    PROJECT_NAME = "Projectname"
+    ID = 'ID'
+    PROJECT_NAME = 'Projectname'
 
 
 def construct_blueprint(database):
@@ -27,33 +27,33 @@ def construct_blueprint(database):
     @roadmap_api.route('/roadmap/<int:roadmapID>/full', methods=['GET'])
     def get_roadmap_full(roadmapID):
         roadmap = database.get_roadmap(roadmapID)
-        roadmap["milestones"] = database.get_milestones(roadmapID)
+        roadmap['milestones'] = database.get_milestones(roadmapID)
 
         numberOfOpenMilestones = 0
-        for milestone in roadmap["milestones"]:
-            milestone["DueDate"] = DateFormatter.format(milestone["DueDate"])
-            milestone["CompletionDate"] = DateFormatter.format(milestone["CompletionDate"])
+        for milestone in roadmap['milestones']:
+            milestone['DueDate'] = DateFormatter.format(milestone['DueDate'])
+            milestone['CompletionDate'] = DateFormatter.format(milestone['CompletionDate'])
 
-            if milestone["Status"] == 0:
+            if milestone['Status'] == 0:
                 numberOfOpenMilestones += 1
 
-            milestone["tasks"] = database.get_tasks(milestone[RoadmapParameters.ID.value])
+            milestone['tasks'] = database.get_tasks(milestone[RoadmapParameters.ID.value])
 
             numberOfOpenTasks = 0
-            for task in milestone["tasks"]:
-                task["subtasks"] = database.get_sub_tasks(task[RoadmapParameters.ID.value])
+            for task in milestone['tasks']:
+                task['subtasks'] = database.get_sub_tasks(task[RoadmapParameters.ID.value])
 
                 numberOfOpenSubTasks = 0
-                for subtask in task["subtasks"]:
-                    if subtask["Status"] == 0:
+                for subtask in task['subtasks']:
+                    if subtask['Status'] == 0:
                         numberOfOpenSubTasks += 1
-                task["numberOfOpenSubTasks"] = numberOfOpenSubTasks
+                task['numberOfOpenSubTasks'] = numberOfOpenSubTasks
 
-                if task["Status"] == 0:
+                if task['Status'] == 0:
                     numberOfOpenTasks += 1
-            milestone["numberOfOpenTasks"] = numberOfOpenTasks
+            milestone['numberOfOpenTasks'] = numberOfOpenTasks
 
-        roadmap["numberOfOpenMilestones"] = numberOfOpenMilestones
+        roadmap['numberOfOpenMilestones'] = numberOfOpenMilestones
         return jsonify(roadmap)
 
     @roadmap_api.route('/roadmap', methods=['POST'])
@@ -65,19 +65,19 @@ def construct_blueprint(database):
             return e.response, 400
 
         if __name_already_used(parameters[RoadmapParameters.PROJECT_NAME.value]):
-            return jsonify({"success": False, "msg": "A roadmap with this name already exists"}), 400
+            return jsonify({'success': False, 'msg': 'A roadmap with this name already exists'}), 400
 
         database.add_roadmap(parameters[RoadmapParameters.PROJECT_NAME.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @roadmap_api.route('/roadmap/<int:roadmapID>', methods=['DELETE'])
     @jwt_required
     def delete_roadmap(roadmapID):
         if not __roadmaps_exists(roadmapID):
-            return jsonify({"success": False, "msg": "No roadmap with id '{}' existing".format(roadmapID)}), 400
+            return jsonify({'success': False, 'msg': "No roadmap with id '{}' existing".format(roadmapID)}), 400
 
         database.delete_roadmap(roadmapID)
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @roadmap_api.route('/roadmap', methods=['PUT'])
     @jwt_required
@@ -90,14 +90,14 @@ def construct_blueprint(database):
 
         roadmapID = parameters[RoadmapParameters.ID.value]
         if not __roadmaps_exists(roadmapID):
-            return jsonify({"success": False, "msg": "No roadmap with ID '{}' existing".format(roadmapID)}), 400
+            return jsonify({'success': False, 'msg': "No roadmap with ID '{}' existing".format(roadmapID)}), 400
 
         if __name_already_used(parameters[RoadmapParameters.PROJECT_NAME.value]):
-            return jsonify({"success": False, "msg": "A roadmap with this name already exists"}), 400
+            return jsonify({'success': False, 'msg': 'A roadmap with this name already exists'}), 400
 
         database.update_roadmap(parameters[RoadmapParameters.ID.value],
                                 parameters[RoadmapParameters.PROJECT_NAME.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     def __roadmaps_exists(roadmapID):
         roadmapID = int(roadmapID)
diff --git a/api/blueprints/SubTaskAPI.py b/api/blueprints/SubTaskAPI.py
index 67cbfca..895170e 100644
--- a/api/blueprints/SubTaskAPI.py
+++ b/api/blueprints/SubTaskAPI.py
@@ -7,11 +7,11 @@ from RequestValidator import RequestValidator, ValidationError
 
 
 class SubTaskParameters(Enum):
-    ID = "ID"
-    TASK_ID = "TaskID"
-    TITLE = "Title"
-    DESCRIPTION = "Description"
-    STATUS = "Status"
+    ID = 'ID'
+    TASK_ID = 'TaskID'
+    TITLE = 'Title'
+    DESCRIPTION = 'Description'
+    STATUS = 'Status'
 
     @staticmethod
     def get_values():
@@ -48,16 +48,16 @@ def construct_blueprint(database):
                               parameters[SubTaskParameters.TITLE.value],
                               parameters[SubTaskParameters.DESCRIPTION.value],
                               parameters[SubTaskParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @subtask_api.route('/subtask/<int:subTaskID>', methods=['DELETE'])
     @jwt_required
     def delete_sub_task(subTaskID):
         if not __subtask_exists(subTaskID):
-            return jsonify({"success": False, "msg": "No sub task with id '{}' existing".format(subTaskID)}), 400
+            return jsonify({'success': False, 'msg': "No sub task with id '{}' existing".format(subTaskID)}), 400
 
         database.delete_sub_task(subTaskID)
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @subtask_api.route('/subtask', methods=['PUT'])
     @jwt_required
@@ -69,14 +69,14 @@ def construct_blueprint(database):
 
         subtaskID = parameters[SubTaskParameters.ID.value]
         if not __subtask_exists(subtaskID):
-            return jsonify({"success": False, "msg": "No sub task with ID '{}' existing".format(subtaskID)}), 400
+            return jsonify({'success': False, 'msg': "No sub task with ID '{}' existing".format(subtaskID)}), 400
 
         database.update_sub_task(subtaskID,
                                  parameters[SubTaskParameters.TASK_ID.value],
                                  parameters[SubTaskParameters.TITLE.value],
                                  parameters[SubTaskParameters.DESCRIPTION.value],
                                  parameters[SubTaskParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     def __subtask_exists(subtaskID):
         subtaskID = int(subtaskID)
diff --git a/api/blueprints/TaskAPI.py b/api/blueprints/TaskAPI.py
index 05ed732..49cf091 100644
--- a/api/blueprints/TaskAPI.py
+++ b/api/blueprints/TaskAPI.py
@@ -7,11 +7,11 @@ from RequestValidator import RequestValidator, ValidationError
 
 
 class TaskParameters(Enum):
-    ID = "ID"
-    MILESTONE_ID = "MilestoneID"
-    TITLE = "Title"
-    DESCRIPTION = "Description"
-    STATUS = "Status"
+    ID = 'ID'
+    MILESTONE_ID = 'MilestoneID'
+    TITLE = 'Title'
+    DESCRIPTION = 'Description'
+    STATUS = 'Status'
 
     @staticmethod
     def get_values():
@@ -48,16 +48,16 @@ def construct_blueprint(database):
                           parameters[TaskParameters.TITLE.value],
                           parameters[TaskParameters.DESCRIPTION.value],
                           parameters[TaskParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @task_api.route('/task/<int:taskID>', methods=['DELETE'])
     @jwt_required
     def delete_task(taskID):
         if not __task_exists(taskID):
-            return jsonify({"success": False, "msg": "No task with id '{}' existing".format(taskID)}), 400
+            return jsonify({'success': False, 'msg': "No task with id '{}' existing".format(taskID)}), 400
 
         database.delete_task(taskID)
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     @task_api.route('/task', methods=['PUT'])
     @jwt_required
@@ -69,14 +69,14 @@ def construct_blueprint(database):
 
         taskID = parameters[TaskParameters.ID.value]
         if not __task_exists(taskID):
-            return jsonify({"success": False, "msg": "No task with ID '{}' existing".format(taskID)}), 400
+            return jsonify({'success': False, 'msg': "No task with ID '{}' existing".format(taskID)}), 400
 
         database.update_task(taskID,
                              parameters[TaskParameters.MILESTONE_ID.value],
                              parameters[TaskParameters.TITLE.value],
                              parameters[TaskParameters.DESCRIPTION.value],
                              parameters[TaskParameters.STATUS.value])
-        return jsonify({"success": True})
+        return jsonify({'success': True})
 
     def __task_exists(taskID):
         taskID = int(taskID)
-- 
GitLab