Backend/feature/user endpoint

backend/.gitignore

@@ -9,3 +9,4 @@ docs/_build/
 dist/
 venv/
 .env
+.run/

backend/Dockerfile

@@ -1,6 +1,9 @@
 FROM python:3.9
 RUN mkdir /app
-WORKDIR /app/
+WORKDIR /app
 ADD ./project /app/
+COPY requirements.txt /app/requirements.txt
 RUN pip3 install -r requirements.txt
-CMD ["python3", "/app"]
+COPY . /app
+ENTRYPOINT ["python"]
+CMD ["__main__.py"]

backend/project/__init__.py

@@ -5,6 +5,7 @@
 from flask import Flask
 from .db_in import db
 from .endpoints.index.index import index_bp
+from .endpoints.users import users_bp
 
 
 def create_app():
@@ -16,6 +17,7 @@ def create_app():
 
     app = Flask(__name__)
     app.register_blueprint(index_bp)
+    app.register_blueprint(users_bp)
 
     return app
 

backend/project/__main__.py

@@ -2,11 +2,21 @@
 from sys import path
 from os import getenv
 from dotenv import load_dotenv
+from sqlalchemy import URL
 from project import create_app_with_db
 
 path.append(".")
 
 if __name__ == "__main__":
     load_dotenv()
-    app = create_app_with_db(getenv("DB_HOST"))
+
+    url = URL.create(
+        drivername="postgresql",
+        username=getenv("POSTGRES_USER"),
+        password=getenv("POSTGRES_PASSWORD"),
+        host=getenv("POSTGRES_HOST"),
+        database=getenv("POSTGRES_DB")
+    )
+
+    app = create_app_with_db(url)
     app.run(debug=True)

backend/project/endpoints/index/OpenAPI_Object.json

@@ -41,5 +41,189 @@
       }
     ]
   },
-  "paths": []
+  "paths": {
+    "/users": {
+      "get": {
+        "summary": "Get all users",
+        "responses": {
+          "200": {
+            "description": "A list of users",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "uid": {
+                        "type": "string"
+                      },
+                      "is_teacher": {
+                        "type": "boolean"
+                      },
+                      "is_admin": {
+                        "type": "boolean"
+                      }
+                    },
+                    "required": ["uid", "is_teacher", "is_admin"]
+                  }
+                }
+              }
+            }
+          }}},
+          "post": {
+            "summary": "Create a new user",
+            "requestBody": {
+              "required": true,
+              "content":{
+                "application/json": {
+                  "schema": {
+                    "type": "object",
+                    "properties": {
+                      "uid": {
+                        "type": "string"
+                      },
+                      "is_teacher": {
+                        "type": "boolean"
+                      },
+                      "is_admin": {
+                        "type": "boolean"
+                      }
+                    },
+                    "required": ["uid", "is_teacher", "is_admin"]
+                  }
+                }
+              }
+            },
+            "responses": {
+              "201": {
+                "description": "User created successfully"
+              },
+              "400": {
+                "description": "Invalid request data"
+              },
+              "415": {
+                "description": "Unsupported Media Type. Expected JSON."
+              },
+              "500": {
+                "description": "An error occurred while creating the user"
+              }
+            }
+
+        },
+        "/users/{user_id}": {
+          "get": {
+            "summary": "Get a user by ID",
+            "parameters": [
+              {
+                "name": "user_id",
+                "in": "path",
+                "required": true,
+                "schema": {
+                  "type": "string"
+                }
+              }
+            ],
+            "responses": {
+              "200": {
+                "description": "A user",
+                "content": {
+                  "application/json": {
+                    "schema": {
+                      "type": "object",
+                      "properties": {
+                        "uid": {
+                          "type": "string"
+                        },
+                        "is_teacher": {
+                          "type": "boolean"
+                        },
+                        "is_admin": {
+                          "type": "boolean"
+                        }
+                      },
+                      "required": ["uid", "is_teacher", "is_admin"]
+                    }
+                  }
+                }
+              },
+              "404": {
+                "description": "User not found"
+              }
+            }
+          },
+          "patch": {
+            "summary": "Update a user's information",
+            "parameters": [
+              {
+                "name": "user_id",
+                "in": "path",
+                "required": true,
+                "schema": {
+                  "type": "string"
+                }
+              }
+            ],
+            "requestBody": {
+              "required": true,
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "type": "object",
+                    "properties": {
+                      "is_teacher": {
+                        "type": "boolean"
+                      },
+                      "is_admin": {
+                        "type": "boolean"
+                      }
+                    },
+                    "required": ["is_teacher", "is_admin"]
+                  }
+                }
+              }
+            },
+            "responses": {
+              "200": {
+                "description": "User updated successfully"
+              },
+              "404": {
+                "description": "User not found"
+              },
+              "415": {
+                "description": "Unsupported Media Type. Expected JSON."
+              },
+              "500": {
+                "description": "An error occurred while patching the user"
+              }
+            }
+          },
+          "delete": {
+            "summary": "Delete a user",
+            "parameters": [
+              {
+                "name": "user_id",
+                "in": "path",
+                "required": true,
+                "schema": {
+                  "type": "string"
+                }
+              }
+            ],
+            "responses": {
+              "200": {
+                "description": "User deleted successfully"
+              },
+              "404": {
+                "description": "User not found"
+              },
+              "500": {
+                "description": "An error occurred while deleting the user"
+              }
+            }
+          }
+        }
+      }
+    }
 }
+

backend/project/endpoints/users.py

@@ -0,0 +1,123 @@
+"""Users api endpoint"""
+from flask import Blueprint, request, jsonify
+from flask_restful import Resource, Api
+from sqlalchemy.exc import SQLAlchemyError
+
+from project import db
+from project.models.users import Users as userModel
+
+users_bp = Blueprint("users", __name__)
+users_api = Api(users_bp)
+
+
+class Users(Resource):
+    """Api endpoint for the /users route"""
+
+    def get(self):
+        """
+        This function will respond to get requests made to /users.
+        It should return all users from the database.
+        """
+        users = userModel.query.all()
+
+        return jsonify(users)
+
+    def post(self):
+        """
+        This function will respond to post requests made to /users.
+        It should create a new user and return a success message.
+        """
+        uid = request.json.get('uid')
+        is_teacher = request.json.get('is_teacher')
+        is_admin = request.json.get('is_admin')
+
+        if is_teacher is None or is_admin is None or uid is None:
+            return {
+                "Message": "Invalid request data!",
+                "Correct Format": {
+                    "uid": "User ID (string)",
+                    "is_teacher": "Teacher status (boolean)",
+                    "is_admin": "Admin status (boolean)"
+                }
+            }, 400
+        try:
+            user = db.session.get(userModel, uid)
+            if user is not None:
+                # bad request, error code could be 409 but is rarely used
+                return {"Message": f"User {uid} already exists"}, 400
+            # Code to create a new user in the database using the uid, is_teacher, and is_admin
+            new_user = userModel(uid=uid, is_teacher=is_teacher, is_admin=is_admin)
+            db.session.add(new_user)
+            db.session.commit()
+
+        except SQLAlchemyError:
+            # every exception should result in a rollback
+            db.session.rollback()
+            return {"Message": "An error occurred while creating the user"}, 500
+
+        return {"Message": "User created successfully!"}, 201
+
+
+class User(Resource):
+    """Api endpoint for the /users/{user_id} route"""
+
+    def get(self, user_id):
+        """
+        This function will respond to GET requests made to /users/<user_id>.
+        It should return the user with the given user_id from the database.
+        """
+        user = db.session.get(userModel, user_id)
+        if user is None:
+            return {"Message": "User not found!"}, 404
+
+        return jsonify(user)
+
+    def patch(self, user_id):
+        """
+        Update the user's information.
+
+        Returns:
+            dict: A dictionary containing the message indicating the success
+             or failure of the update.
+        """
+        is_teacher = request.json.get('is_teacher')
+        is_admin = request.json.get('is_admin')
+        try:
+            user = db.session.get(userModel, user_id)
+            if user is None:
+                return {"Message": "User not found!"}, 404
+
+            if is_teacher is not None:
+                user.is_teacher = is_teacher
+            if is_admin is not None:
+                user.is_admin = is_admin
+
+            # Save the changes to the database
+            db.session.commit()
+        except SQLAlchemyError:
+            # every exception should result in a rollback
+            db.session.rollback()
+            return {"Message": "An error occurred while patching the user"}, 500
+        return {"Message": "User updated successfully!"}
+
+    def delete(self, user_id):
+        """
+        This function will respond to DELETE requests made to /users/<user_id>.
+        It should delete the user with the given user_id from the database.
+        """
+        try:
+            user = db.session.get(userModel, user_id)
+            if user is None:
+                return {"Message": "User not found!"}, 404
+
+            db.session.delete(user)
+            db.session.commit()
+        except SQLAlchemyError:
+            # every exception should result in a rollback
+            db.session.rollback()
+            return {"Message": "An error occurred while deleting the user"}, 500
+        return {"Message": "User deleted successfully!"}
+
+
+users_api.add_resource(Users, "/users")
+users_api.add_resource(User, "/users/<string:user_id>")

backend/project/models/users.py

@@ -1,16 +1,17 @@
 """Model for users"""
+import dataclasses
 
 from sqlalchemy import Boolean, Column, String
 from project import db
 
-
+@dataclasses.dataclass
 class Users(db.Model):
     """This class defines the users table,
-    a user has an uid,
+    a user has a uid,
     is_teacher and is_admin booleans because a user 
     can be either a student,admin or teacher"""
 
     __tablename__ = "users"
-    uid = Column(String(255), primary_key=True)
-    is_teacher = Column(Boolean)
-    is_admin = Column(Boolean)
+    uid:str = Column(String(255), primary_key=True)
+    is_teacher:bool = Column(Boolean)
+    is_admin:bool = Column(Boolean)