The Celtic Spoon
- Project Overview
- Live Preview
- UX & User Stories
- Design & Wireframes
- Database Schema
- Features / Key Highlights
- CRUD Functionality
- Security Features
- Technologies Used
- Testing Documentation
- Deployment
- Credits
The Celtic Spoon is designed as a modern and welcoming restaurant website, celebrating the rich flavors of Celtic cuisine blended with inspirations from Irish, Scottish, and Northern European culinary traditions. Its goal is to give visitors a sense of the restaurant’s atmosphere and menu offerings, while highlighting signature dishes that fuse classic Celtic recipes with contemporary flavors from neighboring cultures.
In addition, the menu creatively incorporates subtle Turkish culinary influences, offering a unique fusion experience for adventurous diners. Traditional Celtic dishes might be enhanced with Turkish spices, yogurts, or pastries, creating an innovative blend of flavors that reflects both authenticity and creativity in Celtic culinary culture.
Minimalistic design principles are applied to ensure that key information and visuals, such as featured dishes, chef specials, and restaurant highlights, stand out without distractions.
Live demo link: https://the-celtic-spoon-fd61489fc4df.herokuapp.com/
As a user, I want to register an account so that I can make and manage my bookings.
- Registration form includes:
- First name
- Last name
- Phone
- Password
- Email input must be validated for correct format.
- Password must be at least 8 characters long.
- Password confirmation must match the original password.
- Clear validation error messages are displayed for invalid input.
- After successful registration, the user is automatically authenticated and logged in.
- The navigation bar reflects the user's authentication status.
As a user, I want to log into my account so that I can access and manage my bookings.
- Login form includes:
- Password
- Clear error messages displayed for invalid credentials.
- Successful login redirects the user to the appropriate dashboard based on their role.
- Session persists across pages until the user logs out.
As a logged-in user, I want to log out of my account so that my information remains secure.
- Logout option is visible when the user is logged in.
- Successful logout clears the session.
- User is redirected to the home page after logout.
As a customer, I want to make a table reservation so that I can dine at the restaurant.
- Reservation form includes:
- Date, time, and number of guests.
- Real-time availability checking.
- Contact information fields (auto-filled for logged-in users).
- Optional special requests field.
- Confirmation message displayed upon successful booking.
- Email confirmation sent (to be implemented in Django).
As a customer, I want to see all my reservations so that I can keep track of my upcoming visits.
- Separate tabs for upcoming and past bookings.
- Display all booking details: date, time, number of guests, table, status.
- Show special requests if any.
- Include visual status indicators for booking status.
As a customer, I want to cancel a reservation so that I can free up the table if my plans change.
- Cancel button visible for upcoming bookings.
- Confirmation dialog before cancellation.
- Success message displayed after cancellation.
- Booking status updated to "cancelled".
As a staff/admin, I want to see all reservations so that I can manage restaurant capacity.
- Table view of all bookings.
- Search functionality by customer name, email, or booking ID.
- Filter by status: pending, confirmed, completed, cancelled
- Sort by date/time.
- Export functionality for reservation data.
As a staff/admin, I want to confirm pending bookings so that customers know their reservation is comfirmed.
- Confirm button available for pending bookings
- Booking status updates to "confirmed"
- Confirmation notification sent to customer via email
As a staff/admin, I want to decline pending bookings when tables are not available or for operational reasons, so that I can effectively manage restaurant capacity.
- Decline button available for pending bookings
- Booking status updates to "cancelled"
- Notification sent to the customer via email
As a staff/admin, I want to mark confirmed bookings as completed after customers have finished dining, so that I can keep booking records accurate and up to date**.
- Complete button available for confirmed bookings.
- Booking status updates to "completed".
As a staff/admin, I want to view booking statistics so that I can plan restaurant operations effectively.
- Display today’s bookings count
- Display tomorrow’s bookings count
- Display pending approvals count
- Display total upcoming bookings
As a staff/admin, I want to view booking statistics so that I can plan restaurant operations effectively.
- Display today’s bookings count.
- Display tomorrow’s bookings count.
- Display number of pending approvals.
- Display total number of upcoming bookings.
As an admin, I want to view all restaurant tables so that I can manage seating capacity effectively.
- Display all tables with table number, capacity, and location.
- Show current availability status
- Present tables in a visual grid layout
The Celtic Spoon website was designed with a minimalist and user-friendly approach, focusing on easy navigation and clear presentation of menu items, reservations, and restaurant information.
- Homepage: highlights featured dishes, restaurant ambiance, and navigation links
- Menu Page: displays categories, items, and signature dishes
- Reservation Page: form for table booking with date, time, guests, and special requests
- Dashboard (Customer): view upcoming/past bookings and manage reservations
- Dashboard (Staff/Admin): view all reservations, confirm/decline bookings, manage tables
- Clean layout with responsive design for mobile and desktop
- Consistent color palette and typography to reflect the Celtic theme
- Buttons and forms are easily accessible and clearly labeled
- Visual hierarchy emphasizes key content such as specials and booking call-to-action
- Doc for wireframe images:
The database is designed using Django ORM and follows a relational structure to support authentication, reservations, and restaurant capacity management.
Extends Django’s built-in authentication system.
Relationships:
- One User can have multiple Reservations
Represents physical restaurant tables.
Relationships:
- One Table can have multiple Reservations
Handles booking data and lifecycle.
Business Logic:
- A reservation must not exceed table capacity
- No double-booking allowed for the same table at the same date/time
- Only confirmed bookings can be marked as completed
- Cancelled bookings remain stored for record tracking
- User (1) → (Many) Reservations
- Table (1) → (Many) Reservations
- Admin/Staff users manage Reservations and Tables
The full Entity-Relationship (ER) Diagram and detailed entity structure can be accessed here:
The Celtic Spoon booking system provides a reservation management system with role-based access for customers and staff/admin users.
- User registration with form validation
- Secure login and logout using Django authentication
- Automatic login after registration
- Navigation updates based on authentication status
- Create a table reservation (date, time, number of guests, special requests)
- Prevent double-booking of tables
- Capacity validation based on table size
- View upcoming and past reservations
- Cancel upcoming reservations
- Visual status indicators (pending / confirmed / completed / cancelled)
- View all reservations in a table layout
- Confirm or decline pending bookings
- Mark confirmed reservations as completed
- Search reservations by name, email, or booking ID
- Filter reservations by status
- View booking statistics (today, tomorrow, pending, upcoming)
- View all restaurant tables
- See table number, capacity, and location
- View availability status
- A reservation cannot exceed table capacity
- No double-booking allowed for the same table, date, and time
- Only confirmed bookings can be marked as completed
- Cancelled reservations remain stored for record keeping
The booking system implements full CRUD functionality:
- Create
Users can create a new booking through the reservation form.
- Read
Users can view their bookings on the "My Bookings" page.
- Update
Users can edit existing bookings to change date, time, or number of guests.
- Delete
Users can delete their bookings if they wish to cancel them.
The Celtic Spoon booking system implements essential security measures using Django’s built-in protections and best practices.
- Secure user authentication using Django’s built-in authentication system.
- Role-based access control (customer / staff / admin).
- Restricted access to admin-only pages and actions.
- Users can only view and manage their own reservations.
- Passwords are securely stored using Django’s password hashing system.
- Sensitive actions require authenticated sessions.
- Session management handled securely by Django.
- Server-side validation for all forms.
- Email format validation.
- Password strength requirements.
- Protection against invalid or malicious input.
- CSRF protection enabled by default.
- Protection against SQL injection through Django ORM.
- XSS protection via Django template escaping.
The project is built using modern web development technologies for both backend and frontend functionality.
- Python
- Django
- Django ORM for database management
- Django Authentication System
- HTML5
- CSS3
- JavaScript
- Bootstrap (for responsive design)
- PostgreSQL (Code Institute provided database)
- Relational database design using Django ORM
- Git & GitHub for version control
- VS Code (development environment)
- Google Drive (documentation hosting)
The Celtic Spoon booking system includes a plan for testing core functionality, form validation, and business logic for both customers and staff/admin users.
- User registration and login with valid and invalid credentials
- Table reservation creation, modification, and cancellation
- Staff/admin actions: confirm, decline, complete reservations
- Booking lifecycle validation (pending → confirmed → completed/cancelled)
- Form input validation (email format, password length, number of guests)
- Navigation and role-based access control
- UI responsiveness on different devices
- Django test framework could be used to test:
- Models
- Views
- Forms
- Permissions
- Edge cases for booking conflicts and table capacity should be checked
- Email confirmation functionality will be tested in development environment
The Celtic Spoon project can be deployed to a cloud platform or run locally for development.
- Clone the repository:
git clone https://github.com/PDennise/the_celtic_spoon.git- Navigate to the project folder:
cd celtic-spoon- Set up Python environment:
python -m venv venv
source venv/bin/activate # Linux / macOS
venv\Scripts\activate # Windows- Install backend dependencies:
pip install -r requirements.txt- Set up environment variables (if any):
cp .env.example .env- Apply Django migrations:
python manage.py migrate- Start development server:
python manage.py runserver # Django backend- Access the site at http://127.0.0.1:8000/
- Code Institute provides a PostgreSQL database for production
- The project can be deployed using platforms such as Render, Heroku, or PythonAnywhere
- Environment variables should be configured for security (e.g., SECRET_KEY, DATABASE_URL, DEBUG)
- Static files must be collected using:
python manage.py collectstaticThis project was developed as part of the Code Institute Full Stack Development course.
- Code Institute – course materials and guidance
- Bootstrap Documentation – for responsive design
- Django Documentation – for backend development
- [Figma / Canva / Draw.io] – for wireframe design
- OpenAI ChatGPT – assistance with README structure and content
- Restaurant images and icons are sourced from free-to-use stock images or placeholders
- Wireframe images created by the developer as schematic representations
Deniz PANDAR