Backend/feature/projects endpoint

backend/project/__init__.py

@@ -3,10 +3,10 @@
 """
 
 from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
+from .db_in import db
 from .endpoints.index.index import index_bp
+from .endpoints.projects.project_endpoint import project_bp
 
-db = SQLAlchemy()
 
 def create_app():
     """
@@ -17,6 +17,7 @@ def create_app():
 
     app = Flask(__name__)
     app.register_blueprint(index_bp)
+    app.register_blueprint(project_bp)
 
     return app
 

backend/project/__main__.py

@@ -1,12 +1,13 @@
 """Main entry point for the application."""
 from sys import path
-from os import getenv
 from dotenv import load_dotenv
 from project import create_app_with_db
+from .sessionmaker import url
 
 path.append(".")
 
 if __name__ == "__main__":
     load_dotenv()
-    app = create_app_with_db(getenv("DB_HOST"))
+
+    app = create_app_with_db(url)
     app.run(debug=True)

backend/project/db_in.py

@@ -0,0 +1,5 @@
+"""db initialization"""
+from flask_sqlalchemy import SQLAlchemy
+
+
+db = SQLAlchemy()

backend/project/endpoints/index/OpenAPI_Object.json

@@ -41,5 +41,192 @@
       }
     ]
   },
-  "paths": []
+  "paths": {
+    "/projects": {
+      "get": {
+        "description": "Returns all projects from the database that the user has access to",
+        "responses": {
+          "200": {
+            "description": "A list of projects",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "project_id": {
+                        "type": "int"
+                      },
+                      "descriptions": {
+                        "type": "string"
+                      },
+                      "title": {
+                        "type": "string"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "description": "Upload a new project",
+        "responses": {
+          "201": {
+            "description": "Uploaded a new project succesfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": "string"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/projects/{id}": {
+      "get": {
+        "description": "Return a project with corresponding id",
+        "responses": {
+          "200": {
+            "description": "A project with corresponding id",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "archieved": {
+                      "type": "bool"
+                    },
+                    "assignment_file": {
+                      "type": "string"
+                    },
+                    "course_id": {
+                      "type": "int"
+                    },
+                    "deadline": {
+                      "type": "date"
+                    },
+                    "descriptions": {
+                      "type": "array",
+                      "items": {
+                        "description": "string"
+                      }
+                    },
+                    "project_id": {
+                      "type": "int"
+                    },
+                    "regex_expressions": {
+                      "type": "array",
+                      "items": {
+                        "regex": "string"
+                      }
+                    },
+                    "script_name": {
+                      "type": "string"
+                    },
+                    "test_path": {
+                      "type": "string"
+                    },
+                    "title": {
+                      "type": "string"
+                    },
+                    "visible_for_students": {
+                      "type": "bool"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "An id that doesn't correspond to an existing project",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "patch": {
+        "description": "Patch certain fields of a project",
+        "responses": {
+          "200": {
+            "description": "Patched a project succesfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": "string"
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Tried to patch a project that is not present",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "description": "Delete a project with given id",
+        "responses": {
+          "200": {
+            "description": "Removed a project succesfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": "string"
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Tried to remove a project that is not present",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": "string"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
 }

backend/project/endpoints/projects/endpoint_parser.py

@@ -0,0 +1,31 @@
+"""
+Parser for the argument when posting or patching a project
+"""
+
+from flask_restful import reqparse
+
+parser = reqparse.RequestParser()
+parser.add_argument('title', type=str, help='Projects title')
+parser.add_argument('descriptions', type=str, help='Projects description')
+parser.add_argument('assignment_file', type=str, help='Projects assignment file')
+parser.add_argument("deadline", type=str, help='Projects deadline')
+parser.add_argument("course_id", type=str, help='Projects course_id')
+parser.add_argument("visible_for_students", type=bool, help='Projects visibility for students')
+parser.add_argument("archieved", type=bool, help='Projects')
+parser.add_argument("test_path", type=str, help='Projects test path')
+parser.add_argument("script_name", type=str, help='Projects test script path')
+parser.add_argument("regex_expressions", type=str, help='Projects regex expressions')
+
+
+def parse_project_params():
+    """
+    Return a dict of every non None value in the param
+    """
+    args = parser.parse_args()
+    result_dict = {}
+
+    for key, value in args.items():
+        if value is not None:
+            result_dict[key] = value
+
+    return result_dict

backend/project/endpoints/projects/project_detail.py

@@ -0,0 +1,117 @@
+"""
+Module for project details page
+for example /projects/1 if the project id of
+the corresponding project is 1
+"""
+from os import getenv
+from dotenv import load_dotenv
+
+from flask import jsonify
+from flask_restful import Resource, abort
+from sqlalchemy import exc
+from project.endpoints.projects.endpoint_parser import parse_project_params
+
+from project import db
+from project.models.projects import Projects
+
+load_dotenv()
+API_URL = getenv('API_HOST')
+
+class ProjectDetail(Resource):
+    """
+    Class for projects/id endpoints
+    Inherits from flask_restful.Resource class
+    for implementing get, delete and put methods
+    """
+
+    def abort_if_not_present(self, project):
+        """
+        Check if the project exists in the database
+        and if not abort the request and give back a 404 not found
+        """
+        if project is None:
+            abort(404)
+
+    def get(self, project_id):
+        """
+        Get method for listing a specific project
+        filtered by id of that specific project
+        the id fetched from the url with the reaparse
+        """
+
+        try:
+            # fetch the project with the id that is specified in the url
+            project = Projects.query.filter_by(project_id=project_id).first()
+            self.abort_if_not_present(project)
+
+            # return the fetched project and return 200 OK status
+            return {
+                "data": jsonify(project).json,
+                "url": f"{API_URL}/projects/{project_id}",
+                "message": "Got project successfully"
+            }, 200
+        except exc.SQLAlchemyError:
+            return {
+                "message": "Internal server error",
+                "url": f"{API_URL}/projects/{project_id}"
+            }, 500
+
+    def patch(self, project_id):
+        """
+        Update method for updating a specific project
+        filtered by id of that specific project
+        """
+
+        # get the project that need to be edited
+        project = Projects.query.filter_by(project_id=project_id).first()
+
+        # check which values are not None in the dict
+        # if it is not None it needs to be modified in the database
+
+        # commit the changes and return the 200 OK code if it succeeds, else 500
+        try:
+            var_dict = parse_project_params()
+            for key, value in var_dict.items():
+                setattr(project, key, value)
+            db.session.commit()
+            # get the updated version
+            return {
+                "message": f"Succesfully changed project with id: {id}",
+                "url": f"{API_URL}/projects/{id}",
+                "data": project
+            }, 200
+        except exc.SQLAlchemyError:
+            db.session.rollback()
+            return {
+                "message": f"Something unexpected happenend when trying to edit project {id}",
+                "url": f"{API_URL}/projects/{id}"
+            }, 500
+
+    def delete(self, project_id):
+        """
+        Delete a project and all of its submissions in cascade
+        done by project id
+        """
+
+        # fetch the project that needs to be removed
+        deleted_project = Projects.query.filter_by(project_id=project_id).first()
+
+        # check if its an existing one
+        self.abort_if_not_present(deleted_project)
+
+        # if it exists delete it and commit the changes in the database
+        try:
+            db.session.delete(deleted_project)
+            db.session.commit()
+
+            # return 200 if content is deleted succesfully
+            return {
+                "message": f"Project with id: {id} deleted successfully",
+                "url": f"{API_URL}/projects/{id} deleted successfully!",
+                "data": deleted_project
+            }, 200
+        except exc.SQLAlchemyError:
+            return {
+                "message": f"Something unexpected happened when removing project {project_id}",
+                "url": f"{API_URL}/projects/{id}"
+            }, 500