WS-10-Database-Saeed/README.md

# WS-11-Database

# Restaurant Database Management System 🍕🗄️

## Overview 

In this workshop, you will build a **restaurant management system focused on database design, PostgreSQL, and JDBC integration**.

The main goal of this project is to practice working with relational databases, designing a proper database schema, managing relationships between tables, and connecting a Java application to PostgreSQL.

You will implement a backend system where users can create accounts, view menu items, create orders, and store all information permanently inside a database.

The project should be implemented using:

- Java 23
    
- Maven
    
- PostgreSQL
    
- JDBC
    

---

# Prerequisites ✅

Make sure you have installed:

- Git
    
- Java 23
    
- Maven
    
- PostgreSQL
    
- PostgreSQL Client (pgAdmin is recommended)
    

---

# Maven Configuration

This project must use **Maven** as the build tool.

Your project should contain:

```
pom.xml
```

The `pom.xml` file is responsible for managing project dependencies and configuring the Java version.

Example:

```xml
  <properties>
    <maven.compiler.source>23</maven.compiler.source>
    <maven.compiler.target>23</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  
    <postgresql.version>42.7.8</postgresql.version>
  </properties>
  
  <dependencies>
  
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>${postgresql.version}</version>
    </dependency>
  
  </dependencies>
```

This dependency allows your Java application to connect to PostgreSQL using JDBC.


---

# Objectives ✏️

By completing this assignment, you will:

- Learn how to design a relational database
    
- Understand database relationships
    
- Work with Primary Keys and Foreign Keys
    
- Use SQL to create and manage tables
    
- Connect Java applications to PostgreSQL using JDBC
    
- Implement CRUD operations
    
- Handle database transactions
    
- Build a structured backend application


---

# Important Concepts

## CRUD Operations

CRUD represents the four basic operations used to manage data in a database.

CRUD stands for:

---

## Create

Adding new records to the database.

Example:

```sql
INSERT INTO users(username, password)
VALUES ('ali', 'hashed_password');
```

---

## Read

Retrieving information from the database.

Example:

```sql
SELECT * FROM menu_items;
```

---

## Update

Changing existing information.

Example:

```sql
UPDATE users
SET email='new@email.com'
WHERE id=1;
```

---

## Delete

Removing records.

Example:

```sql
DELETE FROM menu_items
WHERE id=3;
```

Your application should support CRUD operations where appropriate.

---

# Database Entities

Your database must contain these entities:

---

# 1. User

Represents a customer.

## Attributes:

- id
    
    - Primary Key
        
- username
    
    - Required
        
    - Unique
        
- password
    
    - Stored as hashed value
        
- email
    
    - Optional
        

## Relationship:

One user can have many orders.

```
User 1 -------- N Order
```

---

# 2. MenuItem

Represents restaurant menu items.

## Attributes:

- id
    
    - Primary Key
        
- name
    
- description
    
    - Optional
        
- price
    
- category
    
    - Optional
        

## Requirement:

Database must contain at least 3 initial menu items.

Example:

|Name|Price|Category|
|---|---|---|
|Pizza|10|Fast Food|
|Burger|8|Fast Food|
|Pasta|12|Italian|

---

# 3. Order

Represents a customer's order.

## Attributes:

- id
    
    - Primary Key
        
- userId
    
    - Foreign Key
        
- createdAt
    
- totalPrice
    

## Relationships:

```
User 1 -------- N Order
```

```
Order 1 -------- N OrderDetail
```

---

# 4. OrderDetail

Stores each ordered item.

## Attributes:

- id
    
    - Primary Key
        
- orderId
    
    - Foreign Key
        
- menuItemId
    
    - Foreign Key
        
- quantity
    
- price
    

Example:

Order:

```
Pizza x2
Burger x1
```

Stored as:

|Order ID|Item|Quantity|
|---|---|---|
|1|Pizza|2|
|1|Burger|1|

---

# Database Requirements

Create:

```
database.sql
```

This file must include:

- CREATE TABLE statements
    
- Primary Keys
    
- Foreign Keys
    
- Constraints
    
- Initial data
    

Example:

```sql
CREATE TABLE users(

id SERIAL PRIMARY KEY,

username VARCHAR(50) UNIQUE NOT NULL,

password TEXT NOT NULL

);
```

---

# Java + JDBC Requirements

Create a Java application that communicates with PostgreSQL using JDBC.

All data must be stored inside PostgreSQL.

Do not store application data in files.

---

# Required Features

## User Management

The system must support:

### Register User

Insert a new user.

Required:

- Username
    
- Password
    
- Email (optional)
    

Rules:

- Username must be unique
    
- Password must be hashed
    

---

### Login Validation

Check credentials from database.

Possible results:

- Login successful
    
- Username not found
    
- Wrong password
    

---

# Menu Management

Load menu items from database.

Example:

```
ID | Name | Price

1 | Pizza | 10
2 | Burger | 8
3 | Pasta | 12
```

---

# Order Management

Users should be able to create orders.

Process:

1. Select user
    
2. Select food items
    
3. Set quantity
    
4. Save order
    

Database example:

Order:

|ID|User ID|Total|
|---|---|---|
|1|5|28|

OrderDetail:

|Order ID|Item|Quantity|
|---|---|---|
|1|Pizza|2|
|1|Burger|1|

---

# Receipt Generation

After creating an order, retrieve the order information from database.

Receipt must include:

- Food name
    
- Quantity
    
- Unit price
    
- Item total price
    
- Final order price
    

Example:

```
Pizza

Quantity: 2
Unit Price: 10
Total: 20


Burger

Quantity: 1
Unit Price: 8
Total: 8


Final Price: 28
```

---

# Order History (Bonus)

Users can view previous orders.

---

# Database Rules

Required:

- Every table must have Primary Key
    
- Relationships must use Foreign Keys
    
- Username must be UNIQUE
    
- Required fields must be NOT NULL
    
- Price must be positive
    

---

# Transaction Requirement

Creating an order must use a database transaction.

Steps:

1. Insert Order
    
2. Insert OrderDetails
    

If any step fails:

Rollback the entire operation.

Example:

```
BEGIN TRANSACTION

Insert Order

Insert OrderDetails

COMMIT
```

---

# Evaluation Criteria 📃

## Database Design

- Correct schema design
    
- Proper relationships
    
- Correct constraints
    
- SQL initialization file
    

## JDBC Integration

- PostgreSQL connection
    
- Correct SQL queries
    
- PreparedStatement usage
    
- Exception handling
    

## Functionality

The application must support:

- Creating users
    
- Login verification
    
- Reading menu items
    
- Creating orders
    
- Saving order details
    
- Generating receipts
    
- Viewing order history
    

## Code Quality

The code should:

- Follow Object-Oriented principles
    
- Have clean structure
    
- Avoid duplicated code
    
- Separate database logic from application logic
    

---