Final commit for Advanced Web Project. Added docker and docker compose files...

Final commit for Advanced Web Project. Added docker and docker compose files for containerisation. Bug were also removed after testing.

Orders_Microservice_Group3/app/hello_world.py

+from flask import Flask
+app = Flask(__name__)
+
+@app.route('/')
+def hello_world():
+   return 'Hello World'
+
+if __name__ == '__main__':
+   app.run()
\ No newline at end of file

Orders_Microservice_Group3/app/index.py

+from flask import Flask, jsonify, request, render_template, session, abort, redirect, url_for, make_response
+import requests
+import subscriber
+from flask_cors import CORS
+from config import DEBUG, SECRET_KEY, PORT, HOST
+import os
+
+# Importing blueprints from the controllers
+from controllers.AddToCartController import AddToCart_bp
+from controllers.CheckOutController import checkout_bp
+from controllers.DeleteFromItemController import DeleteCart_bp
+from controllers.FetchCartController import cart_bp
+from controllers.OrderHistoryController import order_history_bp
+
+# Setting up Flask application
+app = Flask(__name__)
+CORS(app)
+
+
+@app.route('/cart', methods=['POST'])
+def get_session_id():
+    session_id = session.get('user_id')
+    if session_id:
+        return jsonify({'session_id': session_id})
+    else:
+        return jsonify({'message': 'Session ID not found'})
+
+# @app.route('/')
+# def index():
+    
+#     return render_template("index.html")
+
+
+# Register blueprints for different parts of the application
+app.register_blueprint(AddToCart_bp)
+app.register_blueprint(checkout_bp)
+app.register_blueprint(DeleteCart_bp)
+app.register_blueprint(cart_bp)
+app.register_blueprint(order_history_bp)
+
+
+
+try:
+
+    # Check for the existence of the /proc/self/cgroup file
+    with open("/proc/self/cgroup", "r") as cgroup_file:
+        cgroup_info = cgroup_file.read()
+
+    # Check if the cgroup information contains 'docker' keyword
+    if 'docker' in cgroup_info:
+        print("Running inside Docker container")
+        app.secret_key = os.environ.get('SECRET_KEY')
+    
+except FileNotFoundError:
+    # If the file doesn't exist
+    print("Running on a local Windows machine")
+
+    app.secret_key = SECRET_KEY
+
+
+if __name__ == '__main__':
+
+    subscriber.start_kafka_consumer()
+
+    # Running the Flask application
+    app.run(host=HOST, debug=DEBUG, port=PORT)
+
+
+
+
+
+
+
+
+
+# from flask import Flask, redirect, url_for, request, render_template, make_response, session, abort
+# from flask_cors import CORS
+# from flask import jsonify
+# from config import DEBUG, SECRET_KEY, PORT
+# import os
+# import requests
+# import subscribers
+
+# from controllers.AddToCartController import AddToCart_bp
+# from controllers.CheckOutController import checkout_bp
+# from controllers.DeleteFromItemController import DeleteCart_bp
+# from controllers.FetchCartController import cart_bp
+# from controllers.UpdateProductController import cart_bp
+
+
+# app = Flask(__name__)
+# CORS(app)
+
+
+# app.secret_key = SECRET_KEY
+
+
+# # Read user microservice URL from environment variable
+# USER_MICROSERVICE_URL = os.getenv('USER_MICROSERVICE_URL', 'http://127.0.0.1:5000')
+
+
+# @app.route('/cart', methods=['POST'])
+# def get_session_id():
+#     session_id = session.get('user_id')
+#     if session_id:
+#         return jsonify({'session_id': session_id})
+#     else:
+#         return jsonify({'message': 'Session ID not found'})
+
+# @app.route('/')
+# def index():
+#     return render_template("index.html")
+
+
+
+# # app.register_blueprint(AddToCart_bp)
+# # app.register_blueprint(checkout_bp)
+# # app.register_blueprint(DeleteCart_bp)
+# # app.register_blueprint(cart_bp)
+
+
+
+# if __name__ == '__main__':
+
+#     subscribers.start_kafka_consumer()
+
+#     app.run(debug=DEBUG, port=PORT)
\ No newline at end of file

Orders_Microservice_Group3/app/models/AddToCart.py

+import pyodbc
+from flask import jsonify
+from decimal import Decimal
+from models.database_connection import connect_db
+
+def add_item_shopping_cart(data):
+
+    try: #error handling
+        connection = connect_db()
+        cursor = connection.cursor()
+
+        insert_cart_item_query = '''INSERT INTO dbo.ShoppingCart (UserID, ProductID, UnitPrice, CartQuantity)
+VALUES (?, ?, ?, ?);'''
+        cursor.execute(insert_cart_item_query, (data["UserID"], data["ProductID"], data["UnitPrice"], data["CartQuantity"]))
+ 
+        connection.commit()
+
+        return {"message": "Item added to cart successfully"}
+
+    except pyodbc.Error as e:
+        print(f"Database error in add_item_to_cart: {e}")
+        connection.rollback()
+        return {"Error": f"Unexpected error: {str(e)}"}
+
+    except Exception as e:
+        print(f"Unexpected error occurred in add_item_to_cart: {e}")
+        connection.rollback()
+        return {"Error": "Unexpected error"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
+

Orders_Microservice_Group3/app/models/CheckOut.py

+from models.database_connection import connect_db
+from flask import Blueprint, request, jsonify, session
+
+from decimal import Decimal
+import pyodbc
+from datetime import datetime
+
+
+
+def checkout_cart(user_id, address):
+    try:
+        connection = connect_db()
+        connection.autocommit = False
+        cursor = connection.cursor()
+
+        # Fetch cart items for the user
+        cursor.execute("""
+            SELECT ProductID, CartQuantity, FORMAT(UnitPrice, 'N2') AS UnitPrice
+            FROM ShoppingCart
+            WHERE UserID = ?
+        """, (user_id,))
+        cart_items = cursor.fetchall()
+
+        if not cart_items:
+            return {"error": "No items in the cart to checkout."}
+
+        total_price = 0
+        item_details = []
+
+        # Verify availability and price for each cart item
+        for item in cart_items:
+            ProductID, CartQuantity, UnitPrice = item
+            UnitPrice_decimal = Decimal(UnitPrice)  # Convert string to Decimal for precise calculations
+
+            # Fetch the current availability and unit price from the product data
+            cursor.execute("""
+                SELECT QuantityAvailable, FORMAT(UnitPrice, 'N2') AS UnitPrice
+                FROM ProductData
+                WHERE ProductID = ?
+            """, (ProductID,))
+            row = cursor.fetchone()
+            if row:
+                available_quantity, current_price = row
+                current_price_decimal = Decimal(current_price)
+
+                if available_quantity < CartQuantity:
+                    connection.rollback()
+                    return {"error": f"Not enough inventory for ProductID {ProductID}."}
+
+                if current_price_decimal != UnitPrice_decimal:
+                    cursor.execute("""
+                        UPDATE ShoppingCart
+                        SET UnitPrice = ?
+                        WHERE ProductID = ? AND UserID = ?
+                    """, (current_price, ProductID, user_id))
+                    connection.commit()
+                    return {"error": f"Price has changed for ProductID {ProductID}. Updated price in cart."}
+
+                                
+                new_quantity = available_quantity - CartQuantity
+                cursor.execute("""
+                    UPDATE ProductData
+                    SET QuantityAvailable = ?
+                    WHERE ProductID = ?
+                """, (new_quantity, ProductID))
+
+
+                TotalItemPrice = CartQuantity * current_price_decimal
+                total_price += TotalItemPrice
+                item_details.append({
+                    "ProductID": ProductID,
+                    "Quantity": CartQuantity,
+                    "UnitPrice": current_price_decimal,
+                    "TotalItemPrice": TotalItemPrice
+                })
+
+        # Insert a new order group
+        cursor.execute("""
+            INSERT INTO OrderGroup (CustomerID, TotalPrice, TransactionDate, Location, OrdersStatus)
+            OUTPUT INSERTED.OrderGroupID
+            VALUES (?, ?, ?, ?, 'Processing')
+        """, (user_id, total_price, datetime.now(), address))
+        OrderGroupID = cursor.fetchone()[0]
+
+        # Insert cart items into OrderItem table
+        for item in item_details:
+            cursor.execute("""
+                INSERT INTO OrderItem (OrderGroupID, ProductID, Quantity, TotalItemPrice)
+                VALUES (?, ?, ?, ?)
+            """, (OrderGroupID, item["ProductID"], item["Quantity"], item["TotalItemPrice"]))
+
+        # Delete the cart items from the ShoppingCart
+        cursor.execute("DELETE FROM ShoppingCart WHERE UserID = ?", (user_id,))
+        connection.commit()
+
+        return {
+            "success": "Checkout completed successfully.",
+            "TransactionID": OrderGroupID,
+            "item_details": item_details  # Include item details for post-processing
+        }
+
+    except pyodbc.Error as e:
+        print(f"Database error during checkout: {e}")
+        connection.rollback()
+        return {"error": "Database error during checkout"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
\ No newline at end of file

Orders_Microservice_Group3/app/models/CheckPriceAndQuantity.py

+from models.database_connection import connect_db
+import pyodbc
+
+from decimal import Decimal
+
+
+
+def check_availability_and_price(product_id, requested_quantity, expected_price, user_id):
+    connection = connect_db()
+    try:
+        cursor = connection.cursor()
+        # Fetch the current available quantity and price
+        cursor.execute("""
+            SELECT QuantityAvailable, FORMAT(UnitPrice, 'N2') AS UnitPrice
+            FROM ProductData
+            WHERE ProductID = ?
+        """, (product_id,))
+
+        row = cursor.fetchone()
+        if row:
+            available_quantity, current_price = row
+            current_pricefloat = float(current_price)  # Convert formatted price back to float if necessary for comparisons
+
+            response_data = {
+                "available_quantity": available_quantity,
+                "current_price": current_price,
+                "available": available_quantity >= requested_quantity,
+                "price_correct": current_pricefloat == expected_price
+            }
+
+            messages = []
+            if not response_data["available"]:
+                messages.append(f"We apologize, but there are only {available_quantity} items available.")
+
+            # Check if the price has changed
+            if not response_data["price_correct"]:
+                messages.append(f"The price has changed. The current price is now {current_pricefloat}.")
+                # Update the ShoppingCart with the new price
+                cursor.execute("""
+                    UPDATE ShoppingCart
+                    SET UnitPrice = ?
+                    WHERE ProductID = ? AND UserID = ?
+                """, (current_price, product_id, user_id))  
+                connection.commit()
+
+            if messages:
+                response_data["message"] = " ".join(messages)
+                return response_data
+            else:
+                # All checks passed
+                return response_data
+
+        else:
+            return {"available": False, "message": "Product not found."}
+
+    except pyodbc.Error as e:
+        print(f"Database error in check_availability_and_price: {e}")
+        connection.rollback()
+        return {"available": False, "message": f"Database error: {str(e)}"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
+

Orders_Microservice_Group3/app/models/DeleteItemCartModel.py

+from flask import jsonify
+from models.database_connection import connect_db
+import pyodbc
+
+def delete_item_from_cart(user_id, cart_item_id):
+
+    try:  # error handling
+        connection = connect_db()
+        cursor = connection.cursor()
+
+        # SQL query to delete the item from the cart based on cart_item_id and UserID
+        delete_cart_item_query = '''DELETE FROM dbo.ShoppingCart WHERE UserID = ? AND CartItemID = ?;'''
+        cursor.execute(delete_cart_item_query, (user_id, cart_item_id))
+
+        # Committing the transaction to the database
+        connection.commit()
+
+        # Check if the delete operation was successful
+        if cursor.rowcount == 0:
+            return {"error": "Item not found or could not be deleted"}
+
+        return {"message": "Item deleted successfully"}
+
+    except pyodbc.Error as e:
+        print(f"Database error in delete_item_from_cart: {e}")
+        # Rollback the transaction in case of an error
+        connection.rollback()
+        return {"error": "Database error during item deletion"}
+
+    except Exception as e:
+        print(f"Unexpected error occurred in delete_item_from_cart: {e}")
+        # Rollback the transaction in case of an unexpected error
+        connection.rollback()
+        return {"error": "Unexpected error during item deletion"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
\ No newline at end of file

Orders_Microservice_Group3/app/models/FetchKart.py

+import pyodbc
+from datetime import datetime
+from models.database_connection import connect_db
+
+
+from models.database_connection import connect_db
+from flask import jsonify
+import pyodbc
+
+def get_user_cart_items(user_id):
+    try:
+        connection = connect_db()
+        cursor = connection.cursor()
+
+        query = "SELECT * FROM ShoppingCart WHERE UserID = ?"
+        cursor.execute(query, (user_id,))
+
+        # Fetch all rows for the user_id
+        rows = cursor.fetchall()
+
+        # Prepare a list of dictionaries to hold cart item data
+        cart_items = []
+        Total_Price = 0
+        for row in rows:
+            Total_item_price = row.CartQuantity * row.UnitPrice
+            cart_item = {
+                "CartItemID": row.CartItemID, 
+                "UserID": row.UserID,
+                "ProductID": row.ProductID,
+                "UnitPrice": row.UnitPrice,
+                "CartQuantity": row.CartQuantity,
+                "AddedDate": row.AddedDate,
+                "TotalItemPrice": Total_item_price
+            }
+            cart_items.append(cart_item)
+            Total_Price += Total_item_price
+
+        return {"CartItems": cart_items, "TotalPrice": Total_Price}
+
+    except pyodbc.Error as e:
+        print(f"Database error in get_user_cart_items: {e}")
+        return {"error": "Database error"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
\ No newline at end of file

Orders_Microservice_Group3/app/models/UpdateProduct.py

+#from confluent_kafka import Producer
+import json
+import pyodbc
+from flask import jsonify
+#from flask import jsonify
+from models.database_connection import connect_db
+
+#subscriber
+
+def UpdateProduct(product_id, quantity, price):
+    try:
+        connection = connect_db()
+        connection.autocommit = False
+        cursor = connection.cursor()
+
+        # SQL MERGE statement to insert or update
+        sql_product_data  = """
+        MERGE INTO ProductData AS target
+        USING (SELECT ? AS ProductID, ? AS QuantityAvailable, ? AS UnitPrice) AS source
+        ON target.ProductID = source.ProductID
+        WHEN MATCHED THEN
+            UPDATE SET QuantityAvailable = source.QuantityAvailable, UnitPrice = source.UnitPrice
+        WHEN NOT MATCHED BY TARGET THEN
+            INSERT (ProductID, QuantityAvailable, UnitPrice)
+            VALUES (source.ProductID, source.QuantityAvailable, source.UnitPrice);
+        """
+        cursor.execute(sql_product_data, (product_id, quantity, price))
+
+        # Update ShoppingCart to reflect new prices
+        sql_shopping_cart = """
+        UPDATE ShoppingCart
+        SET UnitPrice = ?
+        WHERE ProductID = ?
+        """
+        cursor.execute(sql_shopping_cart, (price, product_id))
+
+        connection.commit()
+        return {"success": "Product information updated successfully."}
+
+    except pyodbc.Error as e:
+        print(f"Database error during product update: {e}")
+        connection.rollback()
+        return {"error": f"Database error during product update: {e}"}
+
+    except Exception as e:
+        print(f"Unexpected error occurred: {e}")
+        connection.rollback()
+        return {"error": f"Unexpected error: {e}"}
+
+    finally:
+        if cursor:
+            cursor.close()
+        if connection:
+            connection.close()
+

Orders_Microservice_Group3/app/models/__init__.py

+from flask import Flask
+from flask_cors import CORS
+
+
+#from app.models import models
+
+app = Flask(__name__)
+CORS(app)
+
+#db = sqlAlchemy
+
+#from app import routes
+
+if __name__ == '__main__':
+    app.run(debug=True)