release v2

Author: PaulNGilson

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: Run Giga Unit Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Build custom Postgres image
+      run: |
+        docker build -t custom-postgres -f ci_config/Dockerfile.postgres .
+        if docker ps -q --filter "ancestor=postgres:latest" | grep -q .; then
+          docker stop $(docker ps -q --filter "ancestor=postgres:latest")
+        fi
+        docker run --name pg-container -d -p 5432:5432 \
+          -e POSTGRES_DB=giga_test \
+          -e POSTGRES_USER=postgres \
+          -e POSTGRES_HOST_AUTH_METHOD=trust \
+          custom-postgres
+
+    - name: Wait for PostgreSQL to be ready (1/2)
+      run: |
+        timeout 30s bash -c '
+        until docker exec pg-container pg_isready -U postgres; do
+          echo "Waiting for PostgreSQL to be ready..."
+          sleep 2
+        done
+        '
+
+    - name: Wait for PostgreSQL to be ready (2/2)
+      run: |
+        until docker exec pg-container psql -U postgres -c "\l"; do
+          echo "Waiting for PostgreSQL to accept connections..."
+          sleep 2
+        done
+
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+
+    - name: Install Playwright browsers
+      run: playwright install
+
+    - name: Create database if it doesn't exist
+      run: psql -h localhost -U postgres -tc "SELECT 1 FROM pg_database WHERE datname = 'giga_test'" | grep -q 1 || psql -h localhost -U postgres -c "CREATE DATABASE giga_test;"
+
+    - name: Run tests
+      run: pytest

README.md

@@ -9,5 +9,5 @@ Giga - the gig booking site that'll be _huge_.
 * `source giga_venv/bin/activate`
 * `pip install -r requirements.txt`
 * Create the databases specified in `lib/database_connection.py` - `giga` and `giga_test`
-* Seed the production database e.g. `psql -h 127.0.0.1 giga -f seeds/test_gigs.sql -f seeds/test_bookings.sql`
+* Seed the production database e.g. `psql -h 127.0.0.1 giga -f seeds/test_gigs.sql -f seeds/test_users.sql -f seeds/test_bookings.sql`
 * Run the server with `python app.py`

app.py

@@ -3,8 +3,49 @@
 from lib.database_connection import get_flask_database_connection
 from lib.gig_repository import GigRepository
 from lib.booking_repository import BookingRepository
+from flask_login import (
+    LoginManager,
+    UserMixin,
+    current_user,
+    login_required,
+    login_user,
+    logout_user
+)
+from werkzeug.security import generate_password_hash, check_password_hash
+from functools import wraps
+import datetime
 
 app = Flask(__name__)
+app.config.update(
+    SECRET_KEY="adobgaiodbgaidgbiodgb",
+)
+
+login_manager = LoginManager()
+login_manager.init_app(app)
+
+class User(UserMixin):
+    def signed_up(self, connection, username):
+        rows = connection.execute('SELECT * FROM users WHERE username = %s', [username])
+        return len(rows) > 0
+    def password_valid(self, connection, username, password_attempt):
+        if not self.signed_up(connection, username):
+            return False
+        rows = connection.execute('SELECT * FROM users WHERE username = %s', [username])
+        return check_password_hash(rows[0]["hashed_password"], password_attempt) != username
+    def get_user_database_id(self, connection, username):
+        rows = connection.execute('SELECT * FROM users WHERE username = %s', [username])
+        return rows[0]["id"]
+
+@login_manager.user_loader
+def user_loader(username: str):
+    connection = get_flask_database_connection(app)
+    if User().signed_up(connection, username):
+        user_model = User()
+        user_model.id = username
+        return user_model
+    return None
+
+
 
 @app.route('/home', methods=['GET'])
 def get_home():
@@ -14,30 +55,82 @@ def get_home():
 def get_about():
     return render_template('about.html')
 
-@app.route('/gigs', methods=['GET'])
+@app.route('/gigs', methods=['GET', 'POST'])
 def get_gigs():
     connection = get_flask_database_connection(app)
-    repo = BookingRepository(connection)
-    gig_booked_ids = [booking.gig_id for booking in repo.get_bookings()]
     repo = GigRepository(connection)
-    gigs = repo.all()
-    gig_ids = [gig.id for gig in gigs]
-    booked_percentage = int(len(set(gig_booked_ids)) / len(set(gig_ids)) * 100)
-    return render_template('gigs.html', gigs=gigs, number_bookings=booked_percentage)
+    locations = ["All"]
+    for gig in repo.all():
+        if gig.location not in locations:
+            locations.append(gig.location)
+    selected_location = "All"
+    if "location" in request.form.keys():
+        selected_location = request.form["location"]
+    date_from = "1900-01-01"
+    if "date_from" in request.form.keys():
+        date_from = request.form["date_from"]
+    date_to = "3000-01-01"
+    if "date_to" in request.form.keys():
+        date_to = request.form["date_to"]
+    gigs = repo.get_by_location_and_dates(selected_location, date_from, date_to)
+    return render_template('gigs.html', gigs=gigs, locations=locations, selected_location=selected_location, date_from=date_from, date_to=date_to)
+
+@app.route('/gigs/<id>', methods=['GET'])
+def get_gig_by_id(id):
+    connection = get_flask_database_connection(app)
+    repo = GigRepository(connection)
+    gig = repo.get_by_id(id)
+    logged_in_as = str(current_user.id) if current_user.__dict__.get("id") else None
+    repo = BookingRepository(connection)
+    if current_user.__dict__ != {}:
+        already_booked_gig = gig.id in [booking.gig_id for booking in repo.get_bookings(1)]
+    else:
+        already_booked_gig = False
+    gig_in_past = gig.datetime < datetime.datetime.now()
+    return render_template('gig.html', gig=gig, logged_in_as=logged_in_as, already_booked_gig=already_booked_gig, gig_in_past=gig_in_past)
+
+@app.route("/book_gig/<gig_id>", methods=["POST"])
+def post_book_gig(gig_id):
+    if int(request.form["ticket_count"]) > 8:
+        return "A user can't book more than 8 tickets for one gig"
+    connection = get_flask_database_connection(app)
+    repo = BookingRepository(connection)
+    user_database_id = User().get_user_database_id(connection, current_user.id)
+    repo.make_booking(gig_id, user_database_id, request.form["ticket_count"])
+    return redirect(url_for('get_account'))
+
+@app.route("/login", methods=["POST"])
+def post_login():
+    username = request.form["usernmae"]
+    password = request.form["password"]
+    connection = get_flask_database_connection(app)
+
+    if User().signed_up(connection, username):
+        if User().password_valid(connection, username, password):
+            user_model = User()
+            user_model.id = username
+            login_user(user_model)
+            return redirect(url_for('get_home'))
+        else:
+            return "Wrong credentials"
+    return "Unknown user"
 
 @app.route('/login', methods=['GET'])
 def get_login():
     return render_template('login.html')
 
 @app.route('/logout', methods=['GET'])
 def get_logout():
+    logout_user()
     return render_template('logout.html')
 
 @app.route('/account', methods=['GET'])
+@login_required
 def get_account():
     connection = get_flask_database_connection(app)
     repo = BookingRepository(connection)
-    bookings = repo.get_bookings()
+    user_database_id = User().get_user_database_id(connection, current_user.id)
+    bookings = repo.get_bookings(user_database_id)
     repo = GigRepository(connection)
     gigs = repo.all()
     booking_details = []
@@ -49,9 +142,5 @@ def get_account():
         })
     return render_template('account.html', booking_details=booking_details)
 
-@app.route('/tcs', methods=['GET'])
-def get_tcs():
-    return render_template('tcs.html')
-
 if __name__ == '__main__':
     app.run(debug=True, port=int(os.environ.get('PORT', 5001)))

ci_config/Dockerfile.postgres

@@ -0,0 +1,3 @@
+FROM postgres:latest
+COPY ci_config/init-auth.sh /docker-entrypoint-initdb.d/
+RUN chmod +x /docker-entrypoint-initdb.d/init-auth.sh

ci_config/init-auth.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+# Modify pg_hba.conf
+cat > "$PGDATA/pg_hba.conf" << EOF
+# TYPE  DATABASE        USER            ADDRESS                 METHOD
+local   all             all                                     trust
+host    all             all             127.0.0.1/32            trust
+host    all             all             ::1/128                 trust
+host    all             all             0.0.0.0/0               trust
+EOF
+
+# Set proper permissions
+chown postgres:postgres "$PGDATA/pg_hba.conf"
+chmod 600 "$PGDATA/pg_hba.conf"
+
+# Create the runner role and grant necessary permissions
+psql -U postgres -d postgres -c "CREATE ROLE runner WITH LOGIN SUPERUSER PASSWORD 'runner';"

lib/booking.py

@@ -15,3 +15,6 @@ def __init__(self, id, dt, gig_id, user_id, ticket_count):
         self.gig_id = gig_id
         self.user_id = user_id
         self.ticket_count = ticket_count
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__

lib/booking_repository.py

@@ -1,12 +1,17 @@
 from lib.booking import Booking
+import datetime
 
 class BookingRepository:
     def __init__(self, connection):
         self._connection = connection
 
-    def get_bookings(self):
-        rows = self._connection.execute('SELECT * FROM bookings')
+    def get_bookings(self, user_id):
+        rows = self._connection.execute('SELECT * FROM bookings WHERE user_id = %s', [user_id])
         bookings = []
         for row in rows:
             bookings.append(Booking(row["id"], row["datetime"], row["gig_id"], row["user_id"], row["ticket_count"]))
         return bookings
+
+    def make_booking(self, gig_id, user_id, ticket_count):
+        booking_datetime_str = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+        self._connection.execute('INSERT INTO bookings (datetime, gig_id, user_id, ticket_count) VALUES (%s, %s, %s, %s)', [booking_datetime_str, gig_id, user_id, ticket_count])

lib/gig.py

@@ -20,3 +20,9 @@ def __init__(self, id, dt, band, venue, location, postcode):
 
         # for maps lookup
         self.postcode = postcode
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+    def datetime_pretty(self):
+        return self.datetime.strftime("%Y-%m-%d %H:%M")

lib/gig_repository.py

@@ -13,5 +13,34 @@ def all(self):
 
     def get_by_id(self, gig_id):
         rows = self._connection.execute('SELECT * FROM gigs WHERE id = %s', [gig_id])
-        row = rows[0]
-        return Gig(row["id"], row["datetime"], row["band"], row["venue"], row["location"], row["postcode"])
+        if rows == []:
+            return None
+        else:
+            row = rows[0]
+            return Gig(row["id"], row["datetime"], row["band"], row["venue"], row["location"], row["postcode"])
+
+    def get_by_location(self, location):
+        rows = self._connection.execute('SELECT * FROM gigs WHERE LOWER(location) = LOWER(%s) ORDER BY datetime', [location])
+        gigs = []
+        for row in rows:
+            gigs.append(Gig(row["id"], row["datetime"], row["band"], row["venue"], row["location"], row["postcode"]))
+        return gigs
+
+    def get_by_dates(self, date_from="1900-01-01", date_to="3000-01-01"):
+        rows = self._connection.execute('SELECT * FROM gigs WHERE datetime BETWEEN %s AND %s ORDER BY datetime', [date_from, date_to])
+        gigs = []
+        for row in rows:
+            gigs.append(Gig(row["id"], row["datetime"], row["band"], row["venue"], row["location"], row["postcode"]))
+        return gigs
+
+    def get_by_location_and_dates(self, location, date_from="1900-01-01", date_to="3000-01-01"):
+        if location == "All":
+            gigs_by_location = self.all()
+        else:
+            gigs_by_location = self.get_by_location(location)
+        gigs_by_dates = self.get_by_dates(date_from, date_to)
+        matches = []
+        for gig in gigs_by_location:
+            if gig in gigs_by_dates:
+                matches.append(gig)
+        return matches

seeds/test_bookings.sql

@@ -10,7 +10,9 @@ CREATE TABLE bookings (
     user_id INTEGER,
     ticket_count INTEGER,
     constraint fk_gig foreign key(gig_id)
-      references gigs(id)
+      references gigs(id),
+    constraint fk_user foreign key(user_id)
+      references users(id)
 );
 
 INSERT INTO bookings (datetime, gig_id, user_id, ticket_count) VALUES ('2025-11-22 15:43', 1, 1, 1);