after demolition

Author: LarsLindain

api/larslgate.py

@@ -0,0 +1,92 @@
+import jwt
+from flask import Blueprint, request, jsonify, current_app, Response, g
+from flask_restful import Api, Resource
+from datetime import datetime
+from __init__ import app
+from api.jwt_authorize import token_required
+from model.lgate import lgate
+
+"""
+This Blueprint object is used to define APIs for the Post model.
+- Blueprint is used to modularize application files.
+- This Blueprint is registered to the Flask app in main.py.
+"""
+lgate = Blueprint('lgate', __name__, url_prefix='/api')
+
+"""
+The Api object is connected to the Blueprint object to define the API endpoints.
+- The API object is used to add resources to the API.
+- The objects added are mapped to code that contains the actions for the API.
+- For more information, refer to the API docs: https://flask-restful.readthedocs.io/en/latest/api.html
+"""
+api = Api(lgate_api)
+
+class lgateAPI:
+    """
+    Define the API CRUD endpoints for the Post model.
+    There are four operations that correspond to common HTTP methods:
+    - post: create a new post
+    - get: read posts
+    - put: update a post
+    - delete: delete a post
+    """
+    class _CRUD(Resource):
+        @token_required()
+        def post(self):
+            # Obtain the current user from the token required setting in the global context
+            current_user = g.current_user
+            # Obtain the request data sent by the RESTful client API
+            data = request.get_json()
+            # Create a new post object using the data from the request
+            post = lgate(data['name'], data['score'], current_user.id)
+            # Save the post object using the Object Relational Mapper (ORM) method defined in the model
+            post.create()
+            # Return response to the client in JSON format, converting Python dictionaries to JSON format
+            return jsonify(post.read())
+
+        @token_required()
+        def get(self):
+            # Obtain the current user
+            current_user = g.current_user
+            # Find all the posts by the current user
+            posts = lgate.query.filter(lgate._user_id == current_user.id).all()
+            # Prepare a JSON list of all the posts, uses for loop shortcut called list comprehension
+            json_ready = [post.read() for post in posts]
+            # Return a JSON list, converting Python dictionaries to JSON format
+            return jsonify(json_ready)
+
+        @token_required()
+        def put(self):
+            # Obtain the current user
+            current_user = g.current_user
+            # Obtain the request data
+            data = request.get_json()
+            # Find the current post from the database table(s)
+            post = lgate.query.get(data['id'])
+            # Update the post
+            post._name = data['name']
+            post._score = data['score']
+            # Save the post
+            post.update()
+            # Return response
+            return jsonify(post.read())
+
+        @token_required()
+        def delete(self):
+            # Obtain the current user
+            current_user = g.current_user
+            # Obtain the request data
+            data = request.get_json()
+            # Find the current post from the database table(s)
+            post = lgate.query.get(data['id'])
+            # Delete the post using the ORM method defined in the model
+            post.delete()
+            # Return response
+            return jsonify({"message": "Post deleted"})
+
+    """
+    Map the _CRUD class to the API endpoints for /post.
+    - The API resource class inherits from flask_restful.Resource.
+    - The _CRUD class defines the HTTP methods for the API.
+    """
+    api.add_resource(_CRUD, '/lgate')

api/lgate.py

@@ -1,15 +1,19 @@
 from flask import Blueprint, request, jsonify, current_app, Response, g
-from flask_restful import Api, Resource  # used for REST API building
-from __init__ import app
+from flask_restful import Api, Resource
+from __init__ import app, db  # Ensure db is imported
 from api.jwt_authorize import token_required
 from model.lgatedata import lgate
 
 # Blueprint setup for the API
 lgate_api = Blueprint('lgate_api', __name__, url_prefix='/api/lgate')
-
 api = Api(lgate_api)
 
-# test data
+# Wrap DB initialization in app context
+with app.app_context():
+    if not lgate.query.first():
+        sample_quiz = lgate(name="Basic Logic Gate Quiz", score=0, quiz_id=1)
+        db.session.add(sample_quiz)
+        db.session.commit()
 
 @lgate_api.route('/test', methods=['GET'])
 def test_lgate():

model/lgatedata.py

@@ -1,28 +1,27 @@
 from sqlite3 import IntegrityError
 from sqlalchemy.exc import SQLAlchemyError
-from __init__ import app, db
+from __init__ import db
 
 class lgate(db.Model):
-    """
-    lgate Model
-    
-    Represents a quiz with a question, score, and a quiz_id associated with a user.
-    """
-    __tablename__ = 'lgate'
+    __tablename__ = 'lgate'  # Explicit table name
 
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(255), nullable=False)
-    score = db.Column(db.String(255), nullable=False)
-    quiz_id = db.Column(db.Integer, nullable=False)  # Remove ForeignKey for simplicity in SQLite
+    name = db.Column(db.String(100), nullable=False)
+    score = db.Column(db.Integer, nullable=False)
+    quiz_id = db.Column(db.Integer, nullable=False)
 
     def __init__(self, name, score, quiz_id):
-        """
-        Constructor for lgate.
-        """
         self.name = name
         self.score = score
         self.quiz_id = quiz_id
 
+    def read(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'score': self.score,
+            'quiz_id': self.quiz_id
+        }
     def __repr__(self):
         """
         Represents the lgate object as a string for debugging.