Merge pull request #68 from RGBOARD/history-page

View Upload History

Author: irsaris

app.py

@@ -136,12 +136,18 @@ def update_design_image(design_id):
     )
 
 
+# @app.route("/design/<int:design_id>", methods=['GET'])
+# @jwt_required()
+# def get_design():
+#     handler = Design(email=get_jwt_identity())
+#     return handler.get_design(design_id=request.form.get('design_id'))
+
 @app.route("/design/<int:design_id>", methods=['GET'])
 @jwt_required()
-def get_design():
+def get_design(design_id):
     handler = Design(email=get_jwt_identity())
-    return handler.get_design(design_id=request.form.get('design_id'))
-
+    # Use the URL param, not request.form
+    return handler.get_design(design_id=design_id)
 
 @app.route("/designs", methods=['GET'])
 @jwt_required()
@@ -293,28 +299,38 @@ def update_item_order(queue_id):
     return handler.update_item_order(queue_id=queue_id, new_order=new_order)
 
 
-@app.route("/queue_item", methods=['GET', 'POST'])
-def handleQueueItem():
-    if request.method == 'GET':
-        handler = QueueItem()
-        return handler.getAllQueueItem()
-    else:
-        try:
-            data = request.json
-            if not data:
-                return jsonify("No data provided"), 400
-
-            valid_keys = {'design_id', 'start_time', 'end_time', 'display_duration',
-                          'scheduled', 'scheduled_at'}
-            if not any(key in data for key in valid_keys):
-                return jsonify("Missing a key"), 400
 
-            handler = QueueItem()
-            return handler.addNewQueueItem(data)
-        except Exception as e:
-            print("Error processing request:", e)
-            return jsonify("Invalid JSON data provided:"), 400
+# ————— GET all queue items (public) —————
+@app.route("/queue_item", methods=['GET'])
+def handleGetQueueItems():
+    handler = QueueItem()
+    items = handler.getAllQueueItem()
+    return jsonify(items), 200
 
+# ————— Create a new queue item (auth required) —————
+@app.route("/queue_item", methods=['POST'])
+@jwt_required()
+def handleCreateQueueItem():
+    data = request.get_json() or {}
+    required_keys = {
+        'design_id',
+        'start_time',
+        'end_time',
+        'display_duration',
+        'scheduled',
+        'scheduled_at'
+    }
+
+    if not required_keys.issubset(data):
+        return jsonify("Missing one of required keys"), 400
+
+    handler = QueueItem()
+    try:
+        new_item = handler.addNewQueueItem(data)
+        return jsonify(new_item), 201
+    except Exception as e:
+        print("Error processing request:", e)
+        return jsonify("Invalid JSON data provided"), 400
 
 @app.route("/queue_item/<int:queue_id>", methods=['GET', 'PUT', 'DELETE'])
 def handleQueueItemById(queue_id):
@@ -349,35 +365,23 @@ def handleQueueItemById(queue_id):
 @app.route("/queue_item/scheduled", methods=['GET'])
 @jwt_required()
 def get_scheduled_designs():
-    # If needed, you can also pass the identity to restrict results
-    # For example: identity = get_jwt_identity()
-    handler = QueueItem()  # Assumes your QueueItem controller exists similarly to Design.
+
+    handler = QueueItem()
     scheduled_items = handler.getScheduledDesigns()
     return jsonify(scheduled_items), 200
 
 
 # UploadHistory-----------------------------------------------------------------------------------------------------------
-@app.route("/upload_history", methods=['GET', 'POST'])
-def handleUploadHistory():
-    if request.method == 'GET':
-        handler = UploadHistory()
-        return handler.getAllUploadHistory()
-    else:  # POST
-        try:
-            data = request.json
-            if not data:
-                return jsonify("No data provided"), 400
 
-            valid_keys = {'design_id', 'attempt_time', 'file_size', 'status'}
-            if not any(key in data for key in valid_keys):
-                return jsonify("Missing a key"), 400
-
-            handler = UploadHistory()
-            return handler.addNewUploadHistory(data)
-        except Exception as e:
-            print("Error processing request:", e)
-            return jsonify("Invalid JSON data provided"), 400
+@app.route("/upload_history", methods=['GET'])
+@jwt_required()
+def get_upload_history_for_current_user():
+    return jsonify(UploadHistory().getAllUploadHistory()), 200
 
+@app.route("/upload_history/pagination", methods=['GET'])
+@jwt_required()
+def get_upload_history_paginated():
+    return UploadHistory().getAllUploadHistoryPaginated()
 
 @app.route("/upload_history/<int:history_id>", methods=['GET', 'PUT', 'DELETE'])
 def handleUploadHistoryById(history_id):
@@ -391,7 +395,7 @@ def handleUploadHistoryById(history_id):
                 return jsonify("No data provided"), 400
 
             # For partial updates, you might remove this check or adapt it
-            valid_keys = {'design_id', 'attempt_time', 'file_size', 'status'}
+            valid_keys = {'design_id', 'attempt_time', 'status'}
             if not any(key in data for key in valid_keys):
                 return jsonify("Missing a key"), 400
 

controller/queue_item.py

@@ -1,6 +1,11 @@
 from flask import jsonify
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from controller.upload_history import UploadHistory
 from controller.user import User
 from model.queue_item import QueueItemDAO
+from datetime import datetime
+
 
 
 class QueueItem:
@@ -51,9 +56,20 @@ def addNewQueueItem(self, data):
             display_duration = data['display_duration']
             scheduled = data['scheduled']
             scheduled_at = data['scheduled_at']
+
             dao = QueueItemDAO()
-            queue_item = dao.addNewQueueItem(design_id, start_time, end_time, display_duration, scheduled, scheduled_at)
+            queue_item = dao.addNewQueueItem(
+                design_id, start_time, end_time,
+                display_duration, scheduled, scheduled_at
+            )
             result = self.make_json_one(queue_item)
+
+            UploadHistory().addNewUploadHistory({
+                'design_id': design_id,
+                'attempt_time': datetime.utcnow().isoformat(),
+                'status': 'successful'
+            })
+
             return result
 
         def getQueueItemById(self, queue_id):
@@ -102,7 +118,6 @@ def deleteQueueItemById(self, queue_id):
         def getScheduledDesigns(self):
             dao = QueueItemDAO()
             rows = dao.getScheduledDesigns()
-            # Build a list of dicts, merging fields from both tables
             result = []
             for row in rows:
                 item = {
@@ -153,3 +168,25 @@ def get_all_items_paginated(self, page, page_size):
                 return jsonify(error="Unauthorized. Not admin."), 401
 
             return jsonify(error="Unauthorized. No token."), 401
+
+        @jwt_required()
+        def getUserHistory(self):
+            user_email = get_jwt_identity()
+
+            rows = QueueItemDAO().getByUserEmail(user_email)
+
+            result = []
+            for (history_id, design_id, created_at,
+                 display_duration, display_order, status,
+                 title, pixel_data) in rows:
+                result.append({
+                    'history_id': history_id,
+                    'design_id': design_id,
+                    'created_at': created_at,
+                    'display_duration': display_duration,
+                    'display_order': display_order,
+                    'status': 'scheduled' if status else 'pending',
+                    'title': title,
+                    'pixel_data': pixel_data,
+                })
+            return result

controller/upload_history.py

@@ -1,66 +1,88 @@
-from flask import jsonify
+import math
+
+from flask import jsonify, request
+from flask_jwt_extended import jwt_required, get_jwt_identity
 from model.upload_history import UploadHistoryDAO
 
 class UploadHistory:
     def make_json(self, tuples):
-
         result = []
         for t in tuples:
-            D = {}
-            D['history_id'] = t[0]
-            D['design_id'] = t[1]
-            D['attempt_time'] = t[2]
-            D['file_size'] = t[3]
-            D['status'] = t[4]
+            D = {
+                'history_id': t[0],
+                'design_id': t[1],
+                'attempt_time': t[2],
+                'status': t[3],
+                'title': t[4],
+                'pixel_data': t[5]
+            }
             result.append(D)
         return result
 
     def make_json_one(self, row):
+        return {
+            'history_id': row[0],
+            'design_id': row[1],
+            'attempt_time': row[2],
+            'status': row[3],
+            'title': row[4],
+            'pixel_data': row[5]
+        }
 
-        result = {}
-        result['history_id'] = row[0]
-        result['design_id'] = row[1]
-        result['attempt_time'] = row[2]
-        result['file_size'] = row[3]
-        result['status'] = row[4]
-        return result
-
+    @jwt_required()
     def getAllUploadHistory(self):
+        email = get_jwt_identity()
         dao = UploadHistoryDAO()
-        rows = dao.getAllUploadHistory()
+        rows = dao.getByUserEmail(email)
         return self.make_json(rows)
 
     def addNewUploadHistory(self, data):
-
         design_id = data['design_id']
         attempt_time = data['attempt_time']
-        file_size = data['file_size']
         status = data['status']
-
         dao = UploadHistoryDAO()
-        row = dao.addNewUploadHistory(design_id, attempt_time, file_size, status)
+        row = dao.addNewUploadHistory(design_id, attempt_time, status)
         return self.make_json_one(row)
 
     def getUploadHistoryById(self, history_id):
         dao = UploadHistoryDAO()
         record = dao.getUploadHistoryById(history_id)
         if not record:
             return jsonify("Not Found"), 404
-        else:
-            return self.make_json_one(record)
+        return self.make_json_one(record)
 
     def updateUploadHistoryById(self, history_id, data):
         dao = UploadHistoryDAO()
         record = dao.updateUploadHistoryById(history_id, data)
         if not record:
             return jsonify("Not Found"), 404
-        else:
-            return self.make_json_one(record)
+        return self.make_json_one(record)
 
     def deleteUploadHistoryById(self, history_id):
         dao = UploadHistoryDAO()
         deleted_id = dao.deleteUploadHistoryById(history_id)
         if not deleted_id:
             return jsonify("Not Found"), 404
-        else:
-            return jsonify("Successfully deleted UploadHistory with ID " + str(deleted_id) + "!"), 200
+        return jsonify(f"Successfully deleted UploadHistory with ID {deleted_id}!"), 200
+
+    @jwt_required()
+    def getAllUploadHistoryPaginated(self):
+        try:
+            email = get_jwt_identity()
+            page = int(request.args.get('page', 1))
+            size = int(request.args.get('size', 6))
+            dao = UploadHistoryDAO()
+
+            total = dao.countByUserEmail(email)
+            rows = dao.getByUserEmailPaginated(email, page, size)
+            items = self.make_json(rows)
+            pages = math.ceil(total / size) if size > 0 else 0
+
+            return jsonify({
+                'items': items,
+                'page': page,
+                'pages': pages
+            }), 200
+        except Exception as e:
+            print(f"Error in paginated upload history: {e}")
+            return jsonify({'error': 'Failed to fetch paginated upload history'}), 500

model/queue_item.py

@@ -36,25 +36,26 @@ def getQueueItemById(self, queue_id):
         cursor.close()
         return result
 
-    def addNewQueueItem(self, design_id, start_time, end_time, display_duration, scheduled, scheduled_at):
 
+    def addNewQueueItem(self, design_id, start_time, end_time,
+                        display_duration, scheduled, scheduled_at):
         cursor = self.conn.cursor()
+        cursor.execute("SELECT COUNT(*) FROM queue_item;")
+        display_order = cursor.fetchone()[0] + 1
 
-        count_query = """ SELECT COUNT(*)
-                          FROM queue_item"""
-        cursor.execute(count_query)
-        items = cursor.fetchone()[0]
-        display_order = items + 1
+        cursor.execute("""
+            INSERT INTO queue_item
+              (design_id, start_time, end_time, display_duration, display_order, scheduled, scheduled_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?);
+        """, (design_id, start_time, end_time, display_duration,
+              display_order, scheduled, scheduled_at))
 
-        query = "insert into queue_item (design_id, start_time, end_time, display_duration, display_order, scheduled, scheduled_at) values (?, ?, ?, ?, ?, ?, ?);"
-        cursor.execute(query,
-                       (design_id, start_time, end_time, display_duration, display_order, scheduled, scheduled_at))
         self.conn.commit()
-        query = "select * from queue_item order by queue_id desc limit 1"
-        cursor.execute(query)
-        result = cursor.fetchone()
+
+        cursor.execute("SELECT * FROM queue_item ORDER BY queue_id DESC LIMIT 1;")
+        row = cursor.fetchone()
         cursor.close()
-        return result
+        return row
 
     def updateQueueItemById(self, queue_id, data):
         cursor = self.conn.cursor()
@@ -223,6 +224,32 @@ def get_all_items_paginated(self, page, page_size):
                 "error": str(e)
             }
 
+
+    def getByUserEmail(self, email):
+        cursor = self.conn.cursor()
+        query = """
+            SELECT
+                qi.queue_id      AS history_id,
+                qi.design_id,
+                qi.created_at    AS created_at,
+                qi.display_duration,
+                qi.display_order,
+                qi.scheduled     AS status,
+                d.title,
+                d.pixel_data
+            FROM queue_item qi
+            JOIN design d 
+              ON d.design_id = qi.design_id
+            JOIN user u
+              ON u.user_id = d.user_id
+            WHERE u.email = ?
+            ORDER BY qi.start_time DESC;
+        """
+        cursor.execute(query, (email,))
+        rows = cursor.fetchall()
+        cursor.close()
+        return rows
+
     def is_design_in_queue(self, design_id):
         cursor = self.conn.cursor()
         query = "SELECT 1 FROM queue_item WHERE design_id = ?"
@@ -245,3 +272,4 @@ def is_design_scheduled(self, design_id):
             return False
         finally:
             cursor.close()
+