diff --git a/.github/workflows/ci-pr.yaml b/.github/workflows/ci-pr.yaml
new file mode 100644
index 0000000..70e9e7e
--- /dev/null
+++ b/.github/workflows/ci-pr.yaml
@@ -0,0 +1,42 @@
+name: Pull Request Simple Sanity Check
+on:
+ pull_request:
+ branches: [develop, main]
+jobs:
+ build-test-lint:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Set up JDK 17
+ uses: actions/setup-java@v4
+ with:
+ distribution: 'temurin'
+ java-version: '17'
+ cache: 'gradle'
+
+ - name: Grant execute permission for gradlew
+ run: chmod +x gradlew
+
+ - name: Build (debug)
+ run: ./gradlew assembleDebug --stacktrace
+
+ - name: Unit Tests
+ run: ./gradlew tests
+
+ - name: Android Lint
+ run: ./gradlew lint
+
+ - name: Kotlin style (ktlint) + static analysis (detekt)
+ run: ./gradlew ktlintCheck detekt
+
+ - name: Dependency updates (report only)
+ run: ./gradlew dependencyUpdates
+
+ - name: Upload reports
+ uses: actions/upload-artifact@v4
+ with:
+ name: ci-reports
+ path: |
+ **/build/reports/**
+ **/build/outputs/apk/debug/*.apk
\ No newline at end of file
diff --git a/.github/workflows/codeql.yaml b/.github/workflows/codeql.yaml
new file mode 100644
index 0000000..d8b91d4
--- /dev/null
+++ b/.github/workflows/codeql.yaml
@@ -0,0 +1,34 @@
+name: CodeQL
+on:
+ pull_request:
+ branches: [develop, main]
+ schedule:
+ - cron: '0 0 * * 0' # Weekly on Sundays at midnight
+jobs:
+ analyze:
+ name: Analyze
+ runs-on: ubuntu-latest
+ permissions:
+ actions: read
+ contents: read
+ security-events: write
+ strategy:
+ fail-fast: false
+ matrix:
+ language: [ 'kotlin' ]
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+
+ - name: Initialize CodeQL
+ uses: github/codeql-action/init@v3
+ with:
+ languages: ${{ matrix.language }}
+
+ - name: Autobuild
+ uses: github/codeql-action/autobuild@v3
+
+ - name: Perform CodeQL Analysis
+ uses: github/codeql-action/analyze@v3
+ with:
+ category: "/language:${{matrix.language}}"
diff --git a/.gitignore b/.gitignore
index ce9982b..783ffbf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,18 @@
-*.db
+
__pycache__/
*.log
-.env
\ No newline at end of file
+.env
+
+# IntelliJ / Android Studio
+.idea/
+!.idea/codeStyles
+!.idea/inspectionProfiles
+
+# Gradle
+.gradle/
+build/
+**/build/
+
+# Kotlin/Android
+local.properties
+captures/
diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..7bc07ec
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/AndroidProjectSystem.xml b/.idea/AndroidProjectSystem.xml
new file mode 100644
index 0000000..4a53bee
--- /dev/null
+++ b/.idea/AndroidProjectSystem.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/Find-My-Ride.iml b/.idea/Find-My-Ride.iml
new file mode 100644
index 0000000..d6ebd48
--- /dev/null
+++ b/.idea/Find-My-Ride.iml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/IntelliLang.xml b/.idea/IntelliLang.xml
new file mode 100644
index 0000000..8cfd409
--- /dev/null
+++ b/.idea/IntelliLang.xml
@@ -0,0 +1,286 @@
+
+
+
+
+ Apache HttpClient 4 HTTP Header (org.apache.http)
+
+
+
+
+
+ Apache HttpClient 5 HTTP Header (org.apache.hc.core5)
+
+
+
+
+
+
+
+
+ AsyncQueryRunner (org.apache.commons.dbutils)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Jodd (jodd.db)
+
+
+
+
+
+
+
+ MockServer Header (org.mockserver)
+
+
+
+
+
+
+ MyBatis @Select/@Delete/@Insert/@Update
+
+
+
+
+
+
+
+ QueryRunner (org.apache.commons.dbutils)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ R2DBC (io.r2dbc)
+
+
+
+
+
+ Reactiverse Postgres Client (io.reactiverse)
+
+
+
+
+
+
+
+
+
+
+
+
+ RestAssured HTTP Header (io.restassured)
+
+
+
+
+
+
+
+ SmallRye Axle SqlClient (io.vertx.axle.sqlclient)
+
+
+
+
+
+ SmallRye Mutiny SqlClient (io.vertx.mutiny.sqlclient)
+
+
+
+
+
+ SmallRye Mutiny SqlConnection (io.vertx.mutiny.sqlclient)
+
+
+
+
+
+
+
+ Spring @Cacheable and @CacheEvict
+
+
+
+
+
+
+
+
+
+
+
+ Spring HttpHeaders (org.springframework.http)
+
+
+
+
+
+
+ Spring Integration/Messaging
+
+
+
+
+
+
+ Spring JDBC (org.springframework.jdbc.core.JdbcOperations)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Spring JDBC (org.springframework.jdbc.core.PreparedStatementCreatorFactory)
+
+
+
+
+
+
+ Spring JDBC (org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator)
+
+
+
+
+
+
+
+ Spring Security @PostAuthorize/@PostFilter/@PreAuthorize/@PreFilter/@AuthenticationPrincipal
+
+
+
+
+
+
+
+
+
+ Spring State Machine
+
+
+
+
+
+
+
+ Vert.x SQL Extensions (io.vertx.ext.sql)
+
+
+
+
+
+
+ Vert.x SQL Reactive Extensions (io.vertx.reactivex.ext.sql)
+
+
+
+
+
+
+
+
+
+ Vert.x SqlClient (io.vertx.sqlclient)
+
+
+
+
+
+
+
+
+
+
+ Vert.x SqlClient RxJava2 (io.vertx.reactivex.sqlclient)
+
+
+
+
+
+
+
+
+
+
+
+ WireMock (com.github.tomakehurst.wiremock.client)
+
+
+
+
+
+
+
+ WireMock (com.github.tomakehurst.wiremock.client)
+
+
+
+
+
+
+ WireMock (com.github.tomakehurst.wiremock.client)
+
+
+
+
+
+
+
+ jOOQ (org.jooq.DSLContext)
+
+
+
+
+
+
+
+ rxjava2-jdbc (org.davidmoten.rx.jdbc)
+
+
+
+
+
+
+ SpEL for Spring Cache
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/artifacts/composeApp_js.xml b/.idea/artifacts/composeApp_js.xml
new file mode 100644
index 0000000..a2c8ee1
--- /dev/null
+++ b/.idea/artifacts/composeApp_js.xml
@@ -0,0 +1,8 @@
+
+
+ $PROJECT_DIR$/app/composeApp/build/libs
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/artifacts/composeApp_jvm.xml b/.idea/artifacts/composeApp_jvm.xml
new file mode 100644
index 0000000..c09eb24
--- /dev/null
+++ b/.idea/artifacts/composeApp_jvm.xml
@@ -0,0 +1,8 @@
+
+
+ $PROJECT_DIR$/app/composeApp/build/libs
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/artifacts/composeApp_wasm_js.xml b/.idea/artifacts/composeApp_wasm_js.xml
new file mode 100644
index 0000000..21b6074
--- /dev/null
+++ b/.idea/artifacts/composeApp_wasm_js.xml
@@ -0,0 +1,8 @@
+
+
+ $PROJECT_DIR$/app/composeApp/build/libs
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
new file mode 100644
index 0000000..6e52cd1
--- /dev/null
+++ b/.idea/compiler.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
new file mode 100644
index 0000000..87b2916
--- /dev/null
+++ b/.idea/deploymentTargetSelector.xml
@@ -0,0 +1,41 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
new file mode 100644
index 0000000..5aae76b
--- /dev/null
+++ b/.idea/gradle.xml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..483affb
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml
new file mode 100644
index 0000000..16660f1
--- /dev/null
+++ b/.idea/runConfigurations.xml
@@ -0,0 +1,17 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/README.md b/README.md
index 7ad2e73..fedd083 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,487 @@
-# Find-My-Ride
+# Find My Ride – Kotlin Multiplatform Ride-Sharing App
-## Database Setup
+### Drexel University – CS 461 Final Project
+
+### Built by:
+- Mustafa Bookwala
+- Samii Shabuse
+- Kennan Lu
+
+---
+
+## Table of Contents
+- [Overview](#overview)
+- [Tech Stack](#tech-stack)
+- [Project Structure](#project-structure)
+- [Prerequisites & Setup](#prerequisites--setup)
+- [How To Run the Project](#how-to-run-the-project)
+- [Database Setup](#database-setup)
+- [CRUD Implementation Details](#crud-implementation-details)
+- [Key Implementation Notes](#key-implementation-notes)
+- [Documentation & Demo](#documentation--demo)
+- [Future Improvements](#future-improvements)
+
+---
+
+## Overview
+
+**Find My Ride** is a full-stack **Kotlin Multiplatform (KMP)** mobile application that simulates a Drexel-focused ride-sharing service. The app allows students to:
+
+- Create an account & log in
+- View and edit their profile
+- Browse available ride offers
+- Publish a ride offer as a driver
+- Send and receive messages from other users
+- Store all data in a pre-loaded SQLite database
-1. Install SQLite if you don’t have it (`sqlite3 --version` to check).
- - Using Version: 3.50.4 2025-07-30 19:33:53 4d8adfb30e03f9cf27f800a2c1ba3c48fb4ca1b08b0f5ed59a4d5ecbf45e20a3 (64-bit)
-2. In the root project folder, run:
+The purpose of the project is to demonstrate **end-to-end database integration**, clean architecture, multiplatform UI, and **CRUD (Create, Read, Update, Delete) operations** learned in CS461.
+
+---
+
+## Tech Stack
+
+### **Frontend / App UI**
+- **Kotlin Multiplatform (KMP)** – Write once, run on multiple platforms
+- **JetBrains Compose Multiplatform** – Modern declarative UI framework
+- **Material3 Components** – Google's latest Material Design system
+- **Navigation** – Custom implementation using sealed classes for type-safe routing
+
+### **Database Layer**
+- **SQLite** – Lightweight, embedded relational database
+- **Pre-loaded Database** – `findmyride.db` stored in `assets/` folder
+- **Custom Repository Pattern** – Clean separation of concerns for each database table
+- **Android SQLiteOpenHelper** – Native Android database management
+- **Raw SQL Queries** – Direct SQL for maximum control and learning (no ORM framework)
+
+### **Platforms Supported**
+- **Android** (Primary target – fully functional)
+- **Compose Desktop** (Compilation supported, database layer not implemented)
+- **iOS/JS** – KMP structure prepared, but database implementation is Android-only for this assignment
+
+---
+
+## Project Structure
+```
+FindMyRide/
+├── composeApp/
+│ ├── src/
+│ │ ├── commonMain/ # Shared code across platforms
+│ │ │ ├── kotlin/
+│ │ │ │ ├── feature/
+│ │ │ │ │ ├── auth/ # Login & Registration screens
+│ │ │ │ │ ├── profile/ # User profile screen & logic
+│ │ │ │ │ ├── rides/ # Find Ride & Offer Ride features
+│ │ │ │ │ ├── messages/ # Messaging system UI & logic
+│ │ │ │ │ └── db/ # Repository interfaces & data models
+│ │ │ │ ├── App.kt # Root navigation (Login vs Main)
+│ │ │ │ └── MainRoute.kt # In-app navigation hub
+│ │ │ └── resources/ # Shared resources
+│ │ │
+│ │ ├── androidMain/ # Android-specific implementations
+│ │ │ ├── kotlin/
+│ │ │ │ ├── db/
+│ │ │ │ │ ├── FindMyRideDbProvider.kt # Database initialization
+│ │ │ │ │ ├── AndroidAuthRepository.kt # USER table CRUD
+│ │ │ │ │ ├── AndroidProfileRepository.kt # USER + VEHICLE CRUD
+│ │ │ │ │ ├── AndroidMessagesRepository.kt # MESSAGE table CRUD
+│ │ │ │ │ └── AndroidRideRepository.kt # RIDE_OFFER + RIDE_REQUEST CRUD
+│ │ │ │ └── MainActivity.kt # Android app entry point
+│ │ │ └── assets/
+│ │ │ └── findmyride.db # Pre-populated SQLite database
+│ │ │
+│ │ └── iosMain/ # iOS implementations (not used)
+│ │
+│ └── build.gradle.kts # App-level build configuration
+│
+├── database/
+│ └── schema.sql # SQL schema for database creation
+│
+├── docs/
+│ └── Deliverable_4/ # **Contains live demo & CRUD documentation**
+│
+├── gradle/ # Gradle wrapper files
+├── build.gradle.kts # Project-level build configuration
+├── settings.gradle.kts # Project settings
+└── README.md # This file
+```
+
+---
+
+## Prerequisites & Setup
+
+### **System Requirements**
+
+1. **Operating System**: Windows 10/11, macOS 10.15+, or Linux
+2. **RAM**: Minimum 8GB (16GB recommended for smooth emulator performance)
+3. **Disk Space**: At least 10GB free space
+
+### **Required Software**
+
+#### 1. **Install Java Development Kit (JDK)**
+- **Required Version**: JDK 17 or higher
+- **Download**: [Oracle JDK](https://www.oracle.com/java/technologies/downloads/) or [OpenJDK](https://adoptium.net/)
+- **Verify Installation**:
```bash
-sqlite3 findmyride.db < database/schema.sql
+ java -version
+ # Should show version 17+
```
-3. You can view the tables with:
+
+#### 2. **Install Android Studio**
+- **Required Version**: Android Studio Ladybug (2024.2.1) or newer
+- **Download**: [Android Studio Official Site](https://developer.android.com/studio)
+- **Important**: During installation, make sure to install:
+ - Android SDK
+ - Android SDK Platform
+ - Android Virtual Device (AVD)
+
+#### 3. **Install Kotlin Multiplatform Plugin**
+After installing Android Studio:
+1. Open Android Studio
+2. Go to **File → Settings** (or **Android Studio → Preferences** on macOS)
+3. Navigate to **Plugins**
+4. Search for "**Kotlin Multiplatform**"
+5. Click **Install** and restart Android Studio
+
+#### 4. **Configure Android SDK**
+1. In Android Studio, go to **File → Settings → Appearance & Behavior → System Settings → Android SDK**
+2. Ensure these are installed:
+ - **Android SDK Platform 34** (or higher)
+ - **Android SDK Build-Tools 34.0.0** (or higher)
+ - **Android Emulator**
+ - **Android SDK Platform-Tools**
+
+#### 5. **Set Up Android Emulator**
+1. In Android Studio, go to **Tools → Device Manager**
+2. Click **Create Device**
+3. Select a device definition (e.g., **Pixel 5**)
+4. Download and select a system image:
+ - Recommended: **API Level 34** (Android 14.0)
+ - Select **x86_64** or **ARM64** based on your system
+5. Click **Finish** to create the AVD
+
+#### 6. **Install SQLite (Optional - for database development)**
+- **Windows**: Download from [SQLite Download Page](https://www.sqlite.org/download.html)
+- **macOS**: Pre-installed, or install via Homebrew:
```bash
-sqlite3 findmyride.db
-sqlite> .tables
-```
\ No newline at end of file
+ brew install sqlite3
+```
+- **Linux**:
+```bash
+ sudo apt-get install sqlite3 # Ubuntu/Debian
+ sudo yum install sqlite # Fedora/RHEL
+```
+- **Verify Installation**:
+```bash
+ sqlite3 --version
+ # Should show version 3.x.x
+```
+
+---
+
+## How To Run the Project
+
+### **Step 1: Clone the Repository**
+```bash
+git clone https://github.com/bookwalamustafa/Find-My-Ride.git
+cd FindMyRide
+```
+
+### **Step 2: Open Project in Android Studio**
+1. Launch **Android Studio**
+2. Select **File → Open**
+3. Navigate to the `FindMyRide` folder and click **OK**
+4. Wait for **Gradle sync** to complete (this may take 3-5 minutes on first run)
+ - Watch the bottom status bar for "Gradle Build" progress
+ - If prompted, accept any SDK licenses
+
+### **Step 3: Verify Kotlin Multiplatform Setup**
+1. Check that no errors appear in the **Build** output window
+2. Verify the project structure shows `commonMain`, `androidMain`, and `iosMain` folders
+3. If you see any errors related to KMP, ensure the Kotlin Multiplatform plugin is installed
+
+### **Step 4: Select Run Configuration**
+1. In the top toolbar, find the **Run Configuration** dropdown
+2. Select **composeApp:androidApp** (or just **composeApp**)
+3. If you don't see this option, try **File → Sync Project with Gradle Files**
+
+### **Step 5: Launch the App**
+**Option A: Using Android Emulator (Recommended)**
+1. In the device dropdown (next to Run Configuration), select your created AVD
+2. Click the **Run** button (green play icon) or press **Shift + F10**
+3. Wait for the emulator to boot (30-60 seconds on first launch)
+4. The app will automatically install and launch
+
+**Option B: Using Physical Android Device**
+1. Enable **Developer Options** on your Android device:
+ - Go to **Settings → About Phone**
+ - Tap **Build Number** 7 times
+2. Enable **USB Debugging**:
+ - Go to **Settings → Developer Options**
+ - Enable **USB Debugging**
+3. Connect your device via USB
+4. Select your device from the device dropdown
+5. Click **Run**
+
+### **Step 6: First Launch**
+- On first launch, the app will automatically copy the SQLite database from `assets/` to the device storage
+- No additional configuration is needed
+- The database comes pre-populated with sample data for testing
+
+### **Troubleshooting Common Issues**
+
+| Issue | Solution |
+|-------|----------|
+| "SDK not found" error | Install Android SDK Platform 34 via SDK Manager |
+| Gradle sync fails | Check internet connection, clear Gradle cache (**File → Invalidate Caches**) |
+| Emulator won't start | Ensure hardware acceleration (Intel HAXM/AMD WHPX) is enabled in BIOS |
+| "Module not specified" error | Select **composeApp** run configuration |
+| Database not loading | Check that `findmyride.db` exists in `composeApp/src/androidMain/assets/` |
+
+---
+
+## Database Setup
+
+### **Using the Pre-loaded Database**
+The project comes with a ready-to-use SQLite database (`findmyride.db`) that includes:
+- Sample user accounts
+- Pre-populated ride offers
+- Example messages
+- Vehicle information
+
+**No manual database setup is required for normal use.**
+
+### **Creating a Fresh Database (Advanced)**
+
+If you want to create a new database from scratch:
+
+#### **Step 1: Navigate to Project Root**
+```bash
+cd /path/to/FindMyRide
+```
+
+#### **Step 2: Generate Database from Schema**
+Run the command ```python database/generate_database.py```
+
+And the entire database should be populated with mock data.
+---
+
+## CRUD Implementation Details
+
+Our application implements comprehensive **CRUD (Create, Read, Update, Delete)** operations across all major database tables. Below is a detailed breakdown of how each operation is implemented.
+
+### **Architecture Overview**
+```
+UI Layer (Compose)
+ ↓
+Repository Interface (commonMain)
+ ↓
+Repository Implementation (androidMain)
+ ↓
+SQLite Database (findmyride.db)
+```
+
+### **1. USER Table CRUD** (`AndroidAuthRepository.kt`)
+
+#### **Create (Registration)**
+[FILL IN: Explain how user registration works]
+- Example: "When a user registers, the `registerUser()` function..."
+- SQL query used
+- Password hashing approach
+- Validation checks
+
+#### **Read (Login & Profile Loading)**
+[FILL IN: Explain how user authentication and profile retrieval works]
+- Example: "Login validates credentials using..."
+- How user sessions are managed
+- Profile data retrieval process
+
+#### **Update (Profile Editing)**
+[FILL IN: Explain how profile updates work]
+- Example: "Users can update their profile information through..."
+- Fields that can be updated
+- Validation logic
+
+#### **Delete (Account Deletion)**
+[FILL IN: Explain account deletion]
+- Example: "Account deletion is handled by..."
+- Cascade behavior with related data
+- Soft delete vs hard delete approach
+
+---
+
+### **2. VEHICLE Table CRUD** (`AndroidProfileRepository.kt`)
+
+#### **Create (Add Vehicle)**
+[FILL IN: Vehicle creation details]
+
+#### **Read (View Vehicles)**
+[FILL IN: How vehicles are displayed]
+
+#### **Update (Edit Vehicle)**
+[FILL IN: Vehicle editing process]
+
+#### **Delete (Remove Vehicle)**
+[FILL IN: Vehicle removal logic]
+
+---
+
+### **3. RIDE_OFFER Table CRUD** (`AndroidRideRepository.kt`)
+
+#### **Create (Publish Ride)**
+[FILL IN: How drivers create ride offers]
+
+#### **Read (Browse Rides)**
+[FILL IN: How rides are listed and filtered]
+
+#### **Update (Modify Ride Details)**
+[FILL IN: Editing existing ride offers]
+
+#### **Delete (Cancel Ride)**
+[FILL IN: Ride cancellation process]
+
+---
+
+### **4. RIDE_REQUEST Table CRUD** (`AndroidRideRepository.kt`)
+
+#### **Create (Request a Ride)**
+[FILL IN: How passengers request rides]
+
+#### **Read (View Requests)**
+[FILL IN: Displaying ride requests]
+
+#### **Update (Update Request Status)**
+[FILL IN: Accepting/rejecting requests]
+
+#### **Delete (Cancel Request)**
+[FILL IN: Request cancellation]
+
+---
+
+### **5. MESSAGE Table CRUD** (`AndroidMessagesRepository.kt`)
+
+#### **Create (Send Message)**
+[FILL IN: Message sending implementation]
+
+#### **Read (View Messages)**
+[FILL IN: Message retrieval and display]
+
+#### **Update (Edit Message)**
+[FILL IN: If supported, how messages can be edited]
+
+#### **Delete (Delete Message)**
+[FILL IN: Message deletion process]
+
+---
+
+### **Database Transaction Handling**
+
+[FILL IN: Explain how you handle database transactions]
+- Example: "All CRUD operations use database transactions to ensure..."
+- Error handling approach
+- Rollback strategy for failed operations
+
+### **Data Validation**
+
+[FILL IN: Describe validation layers]
+- Example: "Input validation occurs at three levels..."
+- UI-level validation
+- Repository-level validation
+- Database constraints
+
+---
+
+## Key Implementation Notes
+
+### **State Management**
+- **UI State**: Uses Jetpack Compose's `remember { mutableStateOf() }` for reactive UI updates
+- **State Hoisting**: State is lifted to appropriate composable parents for sharing
+- **Side Effects**: `LaunchedEffect` and `DisposableEffect` for lifecycle-aware operations
+
+### **Navigation System**
+- **Sealed Classes**: Type-safe navigation using `sealed class RootScreen` and `sealed class HomePage`
+- **Manual Implementation**: No NavHost – custom navigation logic for learning purposes
+- **State Preservation**: Navigation state maintained across configuration changes
+
+### **Repository Pattern**
+- **Interface Definition**: All repositories defined as interfaces in `commonMain`
+- **Platform Implementation**: Concrete implementations in `androidMain` using SQLite
+- **Dependency Injection**: Repositories passed down through composition
+- **Single Source of Truth**: Database is the authoritative data source
+
+### **Database Management**
+- **Database Provider**: `FindMyRideDbProvider` handles initialization and copying from assets
+- **Connection Pooling**: Single database instance reused across app lifecycle
+- **Raw SQL Queries**: Direct SQL for transparency and learning (no ORM like Room or SQLDelight)
+- **Query Optimization**: Indexed columns for frequently queried fields
+
+### **Code Organization**
+- **Feature-Based Structure**: Each feature (auth, profile, rides, messages) is self-contained
+- **Separation of Concerns**: UI, business logic, and data access are clearly separated
+- **Shared Code**: Maximum code sharing through `commonMain` for cross-platform readiness
+
+### **Android-Specific Considerations**
+- **SQLiteOpenHelper**: Native Android database management for direct control
+- **Context Handling**: Database requires Android `Context` for file operations
+- **Assets Access**: Database file copied from `assets/` to internal storage on first run
+
+---
+
+## Documentation & Demo
+
+### **Live Demo & CRUD Operations**
+
+For a comprehensive demonstration of the application and detailed CRUD operation walkthroughs, please refer to:
+
+ **`docs/Deliverable_4/`**
+
+This folder contains:
+- **Live Demo Video**: Complete walkthrough of all application features
+- **CRUD Operation Examples**: Step-by-step demonstration of Create, Read, Update, and Delete operations for each database table
+- **Database Schema Documentation**: Detailed table structures and relationships
+- **Testing Scenarios**: Various use cases and edge cases tested during development
+
+**Recommended Viewing Order:**
+1. Start with the live demo video for an overview
+2. Review CRUD operation examples for technical details
+3. Reference database schema for understanding data relationships
+
+---
+
+## Future Improvements
+
+### **Feature Enhancements**
+- **Advanced Filtering**: Filter rides by time, price, available seats, and route
+- **Vehicle Picker**: Allow drivers to select from their registered vehicles when offering rides
+- **Enhanced Messaging**: Full chat UI with real-time updates per ride
+- **Notifications**: Push notifications for new ride offers and messages
+- **Matching Algorithm**: Intelligent ride request matching based on routes and preferences
+- **Rating System**: Allow users to rate drivers and passengers
+- **Payment Integration**: Add payment processing for ride fares
+
+### **Technical Improvements**
+- **iOS Support**: Implement database layer using SQLDelight or KMP-SQLite for iOS compatibility
+- **Backend Server**: Move to a centralized server with REST API for real-time data sync
+- **Enhanced Security**: Implement JWT authentication and encrypted data storage
+- **Testing**: Add unit tests, integration tests, and UI tests
+- **Theming**: Dark mode support and customizable themes
+- **Maps Integration**: Visual route display using Google Maps or Mapbox
+- **Analytics**: Track app usage and user behavior for insights
+
+### **Platform Expansion**
+- **iOS Native App**: Full iOS implementation with native database layer
+- **Web Version**: Browser-based version using Kotlin/JS
+- **Desktop Support**: Complete desktop app with database support
+
+---
+
+## Contact & Support
+
+For questions, issues, or contributions:
+
+- **Mustafa Bookwala**: [mmb479@drexel.edu/https://github.com/bookwalamustafa]
+- **Samii Shabuse**: [sus24@drexel.edu/https://github.com/sshabuse]
+- **Kennan Lu**: [kjl354@drexel.edu/kennanLu]
+
+**Course**: CS 461 - Database Systems
+**Institution**: Drexel University
+**Term**: Fall 2025
diff --git a/app/.gitignore b/app/.gitignore
new file mode 100644
index 0000000..adfa9bf
--- /dev/null
+++ b/app/.gitignore
@@ -0,0 +1,19 @@
+*.iml
+.kotlin
+.gradle
+**/build/
+xcuserdata
+!src/**/build/
+local.properties
+.idea
+.DS_Store
+captures
+.externalNativeBuild
+.cxx
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcodeproj/project.xcworkspace/
+!*.xcworkspace/contents.xcworkspacedata
+**/xcshareddata/WorkspaceSettings.xcsettings
+node_modules/
diff --git a/app/README.md b/app/README.md
new file mode 100644
index 0000000..b405920
--- /dev/null
+++ b/app/README.md
@@ -0,0 +1,80 @@
+This is a Kotlin Multiplatform project targeting Android, iOS, Web, Desktop (JVM).
+
+* [/composeApp](composeApp/src) is for code that will be shared across your Compose Multiplatform applications.
+ It contains several subfolders:
+ - [commonMain](composeApp/src/commonMain/kotlin) is for code that’s common for all targets.
+ - Other folders are for Kotlin code that will be compiled for only the platform indicated in the folder name.
+ For example, if you want to use Apple’s CoreCrypto for the iOS part of your Kotlin app,
+ the [iosMain](composeApp/src/iosMain/kotlin) folder would be the right place for such calls.
+ Similarly, if you want to edit the Desktop (JVM) specific part, the [jvmMain](composeApp/src/jvmMain/kotlin)
+ folder is the appropriate location.
+
+* [/iosApp](iosApp/iosApp) contains iOS applications. Even if you’re sharing your UI with Compose Multiplatform,
+ you need this entry point for your iOS app. This is also where you should add SwiftUI code for your project.
+
+### Build and Run Android Application
+
+To build and run the development version of the Android app, use the run configuration from the run widget
+in your IDE’s toolbar or build it directly from the terminal:
+
+- on macOS/Linux
+ ```shell
+ ./gradlew :composeApp:assembleDebug
+ ```
+- on Windows
+ ```shell
+ .\gradlew.bat :composeApp:assembleDebug
+ ```
+
+### Build and Run Desktop (JVM) Application
+
+To build and run the development version of the desktop app, use the run configuration from the run widget
+in your IDE’s toolbar or run it directly from the terminal:
+
+- on macOS/Linux
+ ```shell
+ ./gradlew :composeApp:run
+ ```
+- on Windows
+ ```shell
+ .\gradlew.bat :composeApp:run
+ ```
+
+### Build and Run Web Application
+
+To build and run the development version of the web app, use the run configuration from the run widget
+in your IDE's toolbar or run it directly from the terminal:
+
+- for the Wasm target (faster, modern browsers):
+ - on macOS/Linux
+ ```shell
+ ./gradlew :composeApp:wasmJsBrowserDevelopmentRun
+ ```
+ - on Windows
+ ```shell
+ .\gradlew.bat :composeApp:wasmJsBrowserDevelopmentRun
+ ```
+- for the JS target (slower, supports older browsers):
+ - on macOS/Linux
+ ```shell
+ ./gradlew :composeApp:jsBrowserDevelopmentRun
+ ```
+ - on Windows
+ ```shell
+ .\gradlew.bat :composeApp:jsBrowserDevelopmentRun
+ ```
+
+### Build and Run iOS Application
+
+To build and run the development version of the iOS app, use the run configuration from the run widget
+in your IDE’s toolbar or open the [/iosApp](iosApp) directory in Xcode and run it from there.
+
+---
+
+Learn more about [Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/get-started.html),
+[Compose Multiplatform](https://github.com/JetBrains/compose-multiplatform/#compose-multiplatform),
+[Kotlin/Wasm](https://kotl.in/wasm/)…
+
+We would appreciate your feedback on Compose/Web and Kotlin/Wasm in the public Slack
+channel [#compose-web](https://slack-chats.kotlinlang.org/c/compose-web).
+If you face any issues, please report them on [YouTrack](https://youtrack.jetbrains.com/newIssue?project=CMP).
\ No newline at end of file
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
new file mode 100644
index 0000000..98ddb8c
--- /dev/null
+++ b/app/build.gradle.kts
@@ -0,0 +1,10 @@
+plugins {
+ // this is necessary to avoid the plugins to be loaded multiple times
+ // in each subproject's classloader
+ alias(libs.plugins.androidApplication) apply false
+ alias(libs.plugins.androidLibrary) apply false
+ alias(libs.plugins.composeHotReload) apply false
+ alias(libs.plugins.composeMultiplatform) apply false
+ alias(libs.plugins.composeCompiler) apply false
+ alias(libs.plugins.kotlinMultiplatform) apply false
+}
\ No newline at end of file
diff --git a/app/composeApp/build.gradle.kts b/app/composeApp/build.gradle.kts
new file mode 100644
index 0000000..d290519
--- /dev/null
+++ b/app/composeApp/build.gradle.kts
@@ -0,0 +1,110 @@
+import org.jetbrains.compose.desktop.application.dsl.TargetFormat
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+ alias(libs.plugins.kotlinMultiplatform)
+ alias(libs.plugins.androidApplication)
+ alias(libs.plugins.composeMultiplatform)
+ alias(libs.plugins.composeCompiler)
+ alias(libs.plugins.composeHotReload)
+}
+
+kotlin {
+ androidTarget {
+ compilerOptions {
+ jvmTarget.set(JvmTarget.JVM_21)
+ }
+ }
+
+ listOf(
+ iosArm64(),
+ iosSimulatorArm64()
+ ).forEach { iosTarget ->
+ iosTarget.binaries.framework {
+ baseName = "ComposeApp"
+ isStatic = true
+ }
+ }
+
+ jvm()
+
+ js {
+ browser()
+ binaries.executable()
+ }
+
+ @OptIn(ExperimentalWasmDsl::class)
+ wasmJs {
+ browser()
+ binaries.executable()
+ }
+
+ sourceSets {
+ androidMain.dependencies {
+ implementation(compose.preview)
+ implementation(libs.androidx.activity.compose)
+ }
+ commonMain.dependencies {
+ implementation(compose.runtime)
+ implementation(compose.foundation)
+ implementation(compose.material3)
+ implementation(compose.ui)
+ implementation(compose.components.resources)
+ implementation(compose.components.uiToolingPreview)
+ implementation(libs.androidx.lifecycle.viewmodelCompose)
+ implementation(libs.androidx.lifecycle.runtimeCompose)
+ implementation(compose.materialIconsExtended)
+ }
+ commonTest.dependencies {
+ implementation(libs.kotlin.test)
+ }
+ jvmMain.dependencies {
+ implementation(compose.desktop.currentOs)
+ implementation(libs.kotlinx.coroutinesSwing)
+ }
+ }
+}
+
+android {
+ namespace = "com.example.app"
+ compileSdk = libs.versions.android.compileSdk.get().toInt()
+
+ defaultConfig {
+ applicationId = "com.example.app"
+ minSdk = libs.versions.android.minSdk.get().toInt()
+ targetSdk = libs.versions.android.targetSdk.get().toInt()
+ versionCode = 1
+ versionName = "1.0"
+ }
+ packaging {
+ resources {
+ excludes += "/META-INF/{AL2.0,LGPL2.1}"
+ }
+ }
+ buildTypes {
+ getByName("release") {
+ isMinifyEnabled = false
+ }
+ }
+ compileOptions {
+ sourceCompatibility = JavaVersion.VERSION_21
+ targetCompatibility = JavaVersion.VERSION_21
+ }
+}
+
+dependencies {
+ debugImplementation(compose.uiTooling)
+}
+
+compose.desktop {
+ application {
+ mainClass = "com.example.app.MainKt"
+
+ nativeDistributions {
+ targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
+ packageName = "com.example.app"
+ packageVersion = "1.0.0"
+ }
+ }
+}
diff --git a/app/composeApp/src/androidMain/AndroidManifest.xml b/app/composeApp/src/androidMain/AndroidManifest.xml
new file mode 100644
index 0000000..d973028
--- /dev/null
+++ b/app/composeApp/src/androidMain/AndroidManifest.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/composeApp/src/androidMain/assets/findmyride.db b/app/composeApp/src/androidMain/assets/findmyride.db
new file mode 100644
index 0000000..afaffe5
Binary files /dev/null and b/app/composeApp/src/androidMain/assets/findmyride.db differ
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidAuthRepository.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidAuthRepository.kt
new file mode 100644
index 0000000..8e74451
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidAuthRepository.kt
@@ -0,0 +1,116 @@
+package com.example.demo
+
+import app.composeapp.generated.resources.Res
+import com.example.demo.feature.auth.data.AuthRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Android implementation of AuthRepository that talks to the findmyride.db SQLite database.
+ */
+class AndroidAuthRepository(
+ private val dbProvider: FindMyRideDbProvider
+) : AuthRepository {
+
+
+ override suspend fun login(email: String, password: String): Result =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getReadableDatabase()
+
+ val cursor = db.rawQuery(
+ """
+ SELECT user_id, email, username, role
+ FROM "USER"
+ WHERE email = ? AND password_hash = ?
+ """.trimIndent(),
+ arrayOf(email, password)
+ )
+
+ cursor.use {
+ return@withContext if (it.moveToFirst()) {
+ val idxId = it.getColumnIndexOrThrow("user_id")
+ val idxEmail = it.getColumnIndexOrThrow("email")
+ val idxUsername = it.getColumnIndexOrThrow("username")
+ val idxRole = it.getColumnIndexOrThrow("role")
+
+ // Remember who is logged in
+ CurrentUserStore.userId = it.getLong(idxId)
+ CurrentUserStore.email = it.getString(idxEmail)
+ CurrentUserStore.username = it.getString(idxUsername)
+ CurrentUserStore.role = it.getString(idxRole)
+
+ Result.success(Unit)
+ } else {
+ // Clear any previous user
+ CurrentUserStore.userId = null
+ CurrentUserStore.email = null
+ CurrentUserStore.username = null
+ CurrentUserStore.role = null
+
+ Result.failure(IllegalArgumentException("Invalid email or password"))
+ }
+ }
+ }
+
+ // Basic implementation so Sign Up / Forgot Password don't crash,
+ // we can improve these later.
+ override suspend fun signUp(
+ fullName: String,
+ email: String,
+ password: String
+ ): Result =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getWritableDatabase()
+
+ // Check if email already exists
+ db.rawQuery(
+ """SELECT 1 FROM "USER" WHERE email = ? LIMIT 1;""",
+ arrayOf(email)
+ ).use { c ->
+ if (c.moveToFirst()) {
+ return@withContext Result.failure(
+ IllegalArgumentException("Email already registered")
+ )
+ }
+ }
+
+ val username = if (fullName.isNotBlank()) {
+ fullName.trim().lowercase().replace(" ", "_")
+ } else {
+ email.substringBefore('@')
+ }
+
+ val stmt = db.compileStatement(
+ """
+ INSERT INTO "USER"(email, username, password_hash, role)
+ VALUES(?, ?, ?, 'rider');
+ """.trimIndent()
+ )
+ stmt.bindString(1, email)
+ stmt.bindString(2, username)
+ stmt.bindString(3, password)
+
+ val rowId = stmt.executeInsert()
+ if (rowId == -1L) {
+ Result.failure(IllegalStateException("Failed to create account"))
+ } else {
+ Result.success(Unit)
+ }
+ }
+
+ override suspend fun sendPasswordReset(email: String): Result =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getReadableDatabase()
+ db.rawQuery(
+ """SELECT 1 FROM "USER" WHERE email = ? LIMIT 1;""",
+ arrayOf(email)
+ ).use { c ->
+ return@withContext if (c.moveToFirst()) {
+ // Pretend an email was sent
+ Result.success(Unit)
+ } else {
+ Result.failure(IllegalArgumentException("No account found for this email"))
+ }
+ }
+ }
+}
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidMessagesRepository.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidMessagesRepository.kt
new file mode 100644
index 0000000..600f517
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidMessagesRepository.kt
@@ -0,0 +1,239 @@
+package com.example.demo.feature.messages.data
+
+import com.example.demo.CurrentUserStore
+import com.example.demo.FindMyRideDbProvider
+import com.example.demo.feature.messages.chat.ChatMessageUi
+import com.example.demo.feature.messages.list.MessageThreadUi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class AndroidMessagesRepository(
+ private val dbProvider: FindMyRideDbProvider
+) : MessagesRepository {
+
+ /**
+ * Use logged-in user if available, otherwise fall back to parameter.
+ */
+ private fun resolveCurrentUserId(paramUserId: Int): Int {
+// val stored = CurrentUserStore.userId
+// return stored?.toInt() ?: paramUserId
+ return 1;
+ }
+
+// override suspend fun getThreadsForUser(userId: Int): List =
+// withContext(Dispatchers.IO) {
+// listOf(
+// MessageThreadUi(
+// id = 1,
+// senderName = "Debug User",
+// initials = "DU",
+// lastMessage = "If you see this, repo wiring works!",
+// timeAgo = "now",
+// unreadCount = 0
+// )
+// )
+// }
+
+ private fun seedFakeMessagesIfEmpty(db: android.database.sqlite.SQLiteDatabase) {
+ // Check if we already seeded
+ db.rawQuery("SELECT COUNT(*) FROM MESSAGE_THREAD;", null).use { c ->
+ if (c.moveToFirst()) {
+ val count = c.getInt(0)
+ if (count > 0) return // already has data, no need to seed
+ }
+ }
+
+ // ---- THREADS ----
+ // All involving user_id = 1 so they'll show when you log in as that user
+ db.execSQL("""
+ INSERT INTO MESSAGE_THREAD (thread_id, user1_id, user2_id)
+ VALUES
+ (1, 1, 2),
+ (2, 1, 3),
+ (3, 1, 4);
+ """.trimIndent())
+
+ // ---- MESSAGES ----
+ // Thread 1: Abdul <-> Quincy
+ db.execSQL("""
+ INSERT INTO MESSAGE (thread_id, sender_id, body) VALUES
+ (1, 1, 'Hey Quincy, are we still on for 5:30 PM?'),
+ (1, 2, 'Yes! I''ll be there in 10 minutes.'),
+ (1, 1, 'Perfect, see you soon.');
+ """.trimIndent())
+
+ // Thread 2: Abdul <-> Ame
+ db.execSQL("""
+ INSERT INTO MESSAGE (thread_id, sender_id, body) VALUES
+ (2, 3, 'Hey Abdul, do you still need a ride tomorrow?'),
+ (2, 1, 'Yeah! Morning around 9 would be amazing.'),
+ (2, 3, 'Got you, I''ll swing by then.');
+ """.trimIndent())
+
+ // Thread 3: Abdul <-> Kennan
+ db.execSQL("""
+ INSERT INTO MESSAGE (thread_id, sender_id, body) VALUES
+ (3, 1, 'Thanks again for the last ride!'),
+ (3, 4, 'No problem, happy to help.'),
+ (3, 1, 'I left you a 5-star rating too :)');
+ """.trimIndent())
+ }
+
+
+ override suspend fun getThreadsForUser(userId: Int): List =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getWritableDatabase()
+ val currentUserId = 1 // you’re logging in as user_id = 1
+
+ seedFakeMessagesIfEmpty(db)
+
+ val sql = """
+ SELECT
+ t.thread_id,
+ CASE
+ WHEN t.user1_id = ? THEN u2.username
+ ELSE u1.username
+ END AS contact_name,
+ COALESCE(last_msg.body, 'No messages yet') AS last_message,
+ last_msg.sent_at AS last_sent_at
+ FROM MESSAGE_THREAD t
+ JOIN "USER" u1 ON t.user1_id = u1.user_id
+ JOIN "USER" u2 ON t.user2_id = u2.user_id
+ LEFT JOIN MESSAGE last_msg ON last_msg.message_id = (
+ SELECT m.message_id
+ FROM MESSAGE m
+ WHERE m.thread_id = t.thread_id
+ ORDER BY m.sent_at DESC, m.message_id DESC
+ LIMIT 1
+ )
+ WHERE t.user1_id = ? OR t.user2_id = ?
+ ORDER BY
+ (last_sent_at IS NULL),
+ last_sent_at DESC,
+ t.thread_id DESC;
+ """.trimIndent()
+
+ val args = arrayOf(
+ currentUserId.toString(),
+ currentUserId.toString(),
+ currentUserId.toString()
+ )
+
+ val cursor = db.rawQuery(sql, args)
+ val result = mutableListOf()
+
+ cursor.use { c ->
+ val idxThreadId = c.getColumnIndexOrThrow("thread_id")
+ val idxName = c.getColumnIndexOrThrow("contact_name")
+ val idxLastMsg = c.getColumnIndexOrThrow("last_message")
+ val idxLastSentAt = c.getColumnIndexOrThrow("last_sent_at")
+
+ while (c.moveToNext()) {
+ val name = c.getString(idxName)
+ val lastMsg = c.getString(idxLastMsg)
+ val sentAt = c.getString(idxLastSentAt) ?: ""
+
+ result += MessageThreadUi(
+ id = c.getInt(idxThreadId),
+ senderName = name,
+ initials = initialsFromName(name),
+ lastMessage = lastMsg,
+ timeAgo = sentAt,
+ unreadCount = 0
+ )
+ }
+ }
+
+ result
+ }
+
+ override suspend fun getMessagesForThread(threadId: Int): List =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getReadableDatabase()
+ val currentUserId = resolveCurrentUserId(1)
+
+ val cursor = db.rawQuery(
+ """
+ SELECT message_id, sender_id, body, sent_at
+ FROM MESSAGE
+ WHERE thread_id = ?
+ ORDER BY sent_at ASC, message_id ASC;
+ """.trimIndent(),
+ arrayOf(threadId.toString())
+ )
+
+ val result = mutableListOf()
+ cursor.use { c ->
+ val idxId = c.getColumnIndexOrThrow("message_id")
+ val idxSender= c.getColumnIndexOrThrow("sender_id")
+ val idxBody = c.getColumnIndexOrThrow("body")
+ val idxTime = c.getColumnIndexOrThrow("sent_at")
+
+ while (c.moveToNext()) {
+ val senderId = c.getInt(idxSender)
+ result += ChatMessageUi(
+ id = c.getInt(idxId),
+ isMe = (senderId == currentUserId),
+ text = c.getString(idxBody),
+ time = c.getString(idxTime)
+ )
+ }
+ }
+ result
+ }
+
+ override suspend fun sendMessage(threadId: Int, text: String): ChatMessageUi =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getWritableDatabase()
+ val currentUserId = resolveCurrentUserId(1)
+
+ // Insert message
+ val insertStmt = db.compileStatement(
+ """
+ INSERT INTO MESSAGE(thread_id, sender_id, body)
+ VALUES (?, ?, ?);
+ """.trimIndent()
+ )
+ insertStmt.bindLong(1, threadId.toLong())
+ insertStmt.bindLong(2, currentUserId.toLong())
+ insertStmt.bindString(3, text)
+ val newIdLong = insertStmt.executeInsert()
+
+ // Get timestamp (sent_at)
+ val cursor = db.rawQuery(
+ """
+ SELECT sent_at
+ FROM MESSAGE
+ WHERE message_id = ?;
+ """.trimIndent(),
+ arrayOf(newIdLong.toString())
+ )
+
+ var sentAt = "Now"
+ cursor.use { c ->
+ if (c.moveToFirst()) {
+ sentAt = c.getString(c.getColumnIndexOrThrow("sent_at"))
+ }
+ }
+
+ ChatMessageUi(
+ id = newIdLong.toInt(),
+ isMe = true,
+ text = text,
+ time = sentAt
+ )
+ }
+
+ private fun initialsFromName(name: String): String {
+ val parts = name.trim().split(" ")
+ .filter { it.isNotBlank() }
+
+ val chars = when {
+ parts.isEmpty() -> listOf('U')
+ parts.size == 1 -> listOf(parts[0].first())
+ else -> listOf(parts[0].first(), parts[1].first())
+ }
+
+ return chars.joinToString("").uppercase()
+ }
+}
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidProfileRepository.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidProfileRepository.kt
new file mode 100644
index 0000000..1c9ba60
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidProfileRepository.kt
@@ -0,0 +1,197 @@
+package com.example.demo.feature.profile.data
+
+import com.example.demo.CurrentUserStore
+import com.example.demo.FindMyRideDbProvider
+import com.example.demo.feature.profile.ProfileUiState
+import com.example.demo.feature.profile.VehicleUi
+
+/**
+ * Android implementation of ProfileRepository that reads/writes
+ * the USER and VEHICLE tables from findmyride.db
+ */
+class AndroidProfileRepository(
+ private val dbProvider: FindMyRideDbProvider
+) : ProfileRepository {
+
+ private fun requireCurrentUserId(): Long {
+ return CurrentUserStore.userId
+ ?: error("No logged-in user. Make sure login ran successfully before opening Profile.")
+ }
+
+ override fun loadInitialProfile(): ProfileUiState {
+ val currentUserId = requireCurrentUserId()
+ val db = dbProvider.getReadableDatabase()
+
+ // ----- USER -----
+ var name = "Unknown"
+ var email = ""
+ var phone = ""
+ var rating = 0.0
+
+ db.rawQuery(
+ """
+ SELECT username, email, phone_number, rating_avg
+ FROM "USER"
+ WHERE user_id = ?
+ LIMIT 1;
+ """.trimIndent(),
+ arrayOf(currentUserId.toString())
+ ).use { c ->
+ if (c.moveToFirst()) {
+ name = c.getString(c.getColumnIndexOrThrow("username"))
+ email = c.getString(c.getColumnIndexOrThrow("email"))
+ phone = c.getString(c.getColumnIndexOrThrow("phone_number")) ?: ""
+ rating = c.getDouble(c.getColumnIndexOrThrow("rating_avg"))
+ }
+ }
+
+ // ----- VEHICLES -----
+ val vehicles = mutableListOf()
+ db.rawQuery(
+ """
+ SELECT vehicle_id, make, model, color, plate, seats_total, year, fun_fact
+ FROM "VEHICLE"
+ WHERE owner_user_id = ?
+ ORDER BY vehicle_id;
+ """.trimIndent(),
+ arrayOf(currentUserId.toString())
+ ).use { c ->
+ val idxId = c.getColumnIndexOrThrow("vehicle_id")
+ val idxMake = c.getColumnIndexOrThrow("make")
+ val idxModel = c.getColumnIndexOrThrow("model")
+ val idxColor = c.getColumnIndexOrThrow("color")
+ val idxPlate = c.getColumnIndexOrThrow("plate")
+ val idxSeats = c.getColumnIndexOrThrow("seats_total")
+ val idxYear = c.getColumnIndexOrThrow("year")
+ val idxFunFact = c.getColumnIndexOrThrow("fun_fact")
+
+ while (c.moveToNext()) {
+ vehicles += VehicleUi(
+ id = c.getInt(idxId),
+ ownerUserId = currentUserId.toInt(),
+ make = c.getString(idxMake),
+ model = c.getString(idxModel),
+ color = c.getString(idxColor) ?: "",
+ plate = c.getString(idxPlate),
+ seatsTotal = c.getInt(idxSeats),
+ year = c.getInt(idxYear),
+ funFact = c.getString(idxFunFact) ?: ""
+ )
+ }
+ }
+
+ // Build ProfileUiState using DB values
+ return ProfileUiState(
+ name = name,
+ email = email,
+ rating = rating,
+ vehicles = vehicles,
+ account = ProfileUiState().account.copy(
+ fullName = name,
+ email = email,
+ phone = phone,
+ // we don't show real password here
+ password = "*******"
+ )
+ )
+ }
+
+ override fun saveProfile(state: ProfileUiState) {
+ val currentUserId = requireCurrentUserId()
+ val db = dbProvider.getWritableDatabase()
+ db.beginTransaction()
+ try {
+ // ----- UPDATE USER -----
+ db.compileStatement(
+ """
+ UPDATE "USER"
+ SET username = ?, email = ?, phone_number = ?
+ WHERE user_id = ?;
+ """.trimIndent()
+ ).apply {
+ bindString(1, state.account.fullName)
+ bindString(2, state.account.email)
+ bindString(3, state.account.phone)
+ bindLong(4, currentUserId)
+ executeUpdateDelete()
+ }
+
+ // ----- SYNC VEHICLES -----
+ // Get existing vehicle ids in DB
+ val existingIds = mutableSetOf()
+ db.rawQuery(
+ """
+ SELECT vehicle_id
+ FROM "VEHICLE"
+ WHERE owner_user_id = ?;
+ """.trimIndent(),
+ arrayOf(currentUserId.toString())
+ ).use { c ->
+ val idx = c.getColumnIndexOrThrow("vehicle_id")
+ while (c.moveToNext()) existingIds += c.getInt(idx)
+ }
+
+ val desiredIds = state.vehicles.map { it.id }.toSet()
+
+ // Upsert each vehicle from UI state
+ state.vehicles.forEach { v ->
+ if (existingIds.contains(v.id)) {
+ // UPDATE
+ db.compileStatement(
+ """
+ UPDATE "VEHICLE"
+ SET make = ?, model = ?, color = ?, plate = ?,
+ seats_total = ?, year = ?, fun_fact = ?
+ WHERE vehicle_id = ?;
+ """.trimIndent()
+ ).apply {
+ bindString(1, v.make)
+ bindString(2, v.model)
+ bindString(3, v.color)
+ bindString(4, v.plate)
+ bindLong(5, v.seatsTotal.toLong())
+ bindLong(6, v.year.toLong())
+ bindString(7, v.funFact)
+ bindLong(8, v.id.toLong())
+ executeUpdateDelete()
+ }
+ } else {
+ // INSERT with explicit vehicle_id (matches the id created in ViewModel)
+ db.compileStatement(
+ """
+ INSERT INTO "VEHICLE"(
+ vehicle_id, owner_user_id, make, model, color,
+ plate, seats_total, year, fun_fact
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
+ """.trimIndent()
+ ).apply {
+ bindLong(1, v.id.toLong())
+ bindLong(2, currentUserId)
+ bindString(3, v.make)
+ bindString(4, v.model)
+ bindString(5, v.color)
+ bindString(6, v.plate)
+ bindLong(7, v.seatsTotal.toLong())
+ bindLong(8, v.year.toLong())
+ bindString(9, v.funFact)
+ executeInsert()
+ }
+ }
+ }
+
+ // Delete vehicles that were removed in the UI
+ (existingIds - desiredIds).forEach { idToDelete ->
+ db.compileStatement(
+ """DELETE FROM "VEHICLE" WHERE vehicle_id = ?;""".trimIndent()
+ ).apply {
+ bindLong(1, idToDelete.toLong())
+ executeUpdateDelete()
+ }
+ }
+
+ db.setTransactionSuccessful()
+ } finally {
+ db.endTransaction()
+ }
+ }
+}
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidRideRepository.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidRideRepository.kt
new file mode 100644
index 0000000..335ba12
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/AndroidRideRepository.kt
@@ -0,0 +1,117 @@
+package com.example.demo
+
+import android.content.ContentValues
+import com.example.demo.feature.db.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class AndroidRideRepository(
+ private val dbProvider: FindMyRideDbProvider
+) : RideRepository {
+
+ override suspend fun getOpenRideOffers(): List =
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getReadableDatabase()
+
+ // Example: join RIDE_OFFER with LOCATION to get names
+ val sql = """
+ SELECT
+ o.offer_id,
+ o.driver_id,
+ o.vehicle_id,
+ lo_from.name AS from_name,
+ lo_to.name AS to_name,
+ o.depart_at,
+ o.seats_available,
+ o.price_base
+ FROM RIDE_OFFER o
+ JOIN LOCATION lo_from ON o.original_location_id = lo_from.location_id
+ JOIN LOCATION lo_to ON o.dest_location_id = lo_to.location_id
+ WHERE o.status = 'open'
+ ORDER BY o.depart_at ASC;
+ """.trimIndent()
+
+ val cursor = db.rawQuery(sql, null)
+
+ val list = mutableListOf()
+ cursor.use {
+ val idxOfferId = it.getColumnIndexOrThrow("offer_id")
+ val idxDriverId = it.getColumnIndexOrThrow("driver_id")
+ val idxVehicleId = it.getColumnIndexOrThrow("vehicle_id")
+ val idxFromName = it.getColumnIndexOrThrow("from_name")
+ val idxToName = it.getColumnIndexOrThrow("to_name")
+ val idxDepartAt = it.getColumnIndexOrThrow("depart_at")
+ val idxSeatsAvail = it.getColumnIndexOrThrow("seats_available")
+ val idxPriceBase = it.getColumnIndexOrThrow("price_base")
+
+ while (it.moveToNext()) {
+ list.add(
+ RideOffer(
+ offerId = it.getLong(idxOfferId),
+ driverId = it.getLong(idxDriverId),
+ vehicleId = it.getLong(idxVehicleId),
+ fromName = it.getString(idxFromName),
+ toName = it.getString(idxToName),
+ departAt = it.getString(idxDepartAt),
+ seatsAvailable = it.getInt(idxSeatsAvail),
+ priceBase = it.getDouble(idxPriceBase)
+ )
+ )
+ }
+ }
+ list
+ }
+
+ override suspend fun createRideRequest(
+ riderId: Long,
+ pickupLocationId: Long,
+ dropoffLocationId: Long,
+ earliestPickup: String,
+ latestPickup: String?,
+ seatsNeeded: Int
+ ) {
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getWritableDatabase()
+ val values = ContentValues().apply {
+ put("rider_id", riderId)
+ put("pickup_location_id", pickupLocationId)
+ put("dropoff_location_id", dropoffLocationId)
+ put("earliest_pickup", earliestPickup)
+ put("latest_pickup", latestPickup)
+ put("seats_needed", seatsNeeded)
+ put("status", "open")
+ }
+ db.insert("RIDE_REQUEST", null, values)
+ }
+ }
+
+ override suspend fun createRideOffer(
+ driverId: Long,
+ vehicleId: Long,
+ originalLocationId: Long,
+ destLocationId: Long,
+ departAt: String,
+ seatsAvailable: Int,
+ priceBase: Double,
+ pricePerMile: Double
+ ) {
+ withContext(Dispatchers.IO) {
+ val db = dbProvider.getWritableDatabase()
+
+ val values = ContentValues().apply {
+ put("driver_id", driverId)
+ put("vehicle_id", vehicleId)
+ put("original_location_id", originalLocationId)
+ put("dest_location_id", destLocationId)
+ put("depart_at", departAt)
+ put("seats_available", seatsAvailable)
+ put("price_base", priceBase)
+ put("price_per_mile", pricePerMile)
+ put("status", "open")
+ }
+
+ db.insert("RIDE_OFFER", null, values)
+ }
+ }
+
+}
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/CurrentUserStore.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/CurrentUserStore.kt
new file mode 100644
index 0000000..cf175de
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/CurrentUserStore.kt
@@ -0,0 +1,14 @@
+package com.example.demo
+
+/**
+ * Simple in-memory store for the currently logged-in user.
+ * Android only; commonMain doesn't see this directly.
+ */
+object CurrentUserStore {
+ var userId: Long? = null
+ var email: String? = null
+ var username: String? = null
+ var role: String? = null
+}
+
+// This is just a global holder on the Android side.
\ No newline at end of file
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/FindMyRideDbProvider.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/FindMyRideDbProvider.kt
new file mode 100644
index 0000000..6adb08a
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/FindMyRideDbProvider.kt
@@ -0,0 +1,48 @@
+package com.example.demo
+
+import android.content.Context
+import android.database.sqlite.SQLiteDatabase
+import java.io.FileOutputStream
+
+class FindMyRideDbProvider(private val context: Context) {
+ private val dbName = "findmyride.db"
+
+ private fun ensureDbCopied() {
+ val dbFile = context.getDatabasePath(dbName)
+
+ // Always overwrite old database to ensure latest version is used
+ dbFile.parentFile?.mkdirs()
+
+ // Delete any existing DB
+ if (dbFile.exists()) {
+ dbFile.delete()
+ }
+
+ // Copy fresh DB from assets
+ context.assets.open(dbName).use { input ->
+ dbFile.outputStream().use { output ->
+ input.copyTo(output)
+ }
+ }
+ }
+
+ fun getReadableDatabase(): SQLiteDatabase {
+ ensureDbCopied()
+ val dbFile = context.getDatabasePath(dbName)
+ return SQLiteDatabase.openDatabase(
+ dbFile.path,
+ null,
+ SQLiteDatabase.OPEN_READONLY
+ )
+ }
+
+ fun getWritableDatabase(): SQLiteDatabase {
+ ensureDbCopied()
+ val dbFile = context.getDatabasePath(dbName)
+ return SQLiteDatabase.openDatabase(
+ dbFile.path,
+ null,
+ SQLiteDatabase.OPEN_READWRITE
+ )
+ }
+}
\ No newline at end of file
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/MainActivity.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/MainActivity.kt
new file mode 100644
index 0000000..9ff986d
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/MainActivity.kt
@@ -0,0 +1,43 @@
+package com.example.rideshare
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalContext
+import com.example.demo.App
+import com.example.demo.AndroidRideRepository
+import com.example.demo.AndroidAuthRepository
+import com.example.demo.FindMyRideDbProvider
+import com.example.demo.CurrentUserStore
+import com.example.demo.feature.profile.data.AndroidProfileRepository
+import com.example.demo.feature.messages.data.AndroidMessagesRepository
+
+class MainActivity : ComponentActivity() {
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+
+ setContent {
+ MaterialTheme {
+ Surface {
+ val context = LocalContext.current
+ val dbProvider = remember { FindMyRideDbProvider(context) }
+
+ val rideRepo = remember { AndroidRideRepository(dbProvider) }
+ val profileRepo = remember { AndroidProfileRepository(dbProvider) }
+ val authRepo = remember { AndroidAuthRepository(dbProvider) }
+ val messagesRepo = remember { AndroidMessagesRepository(dbProvider) }
+
+ App(
+ rideRepository = rideRepo,
+ profileRepository = profileRepo,
+ authRepository = authRepo,
+ messagesRepository = messagesRepo
+ )
+ }
+ }
+ }
+ }
+}
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/Platform.android.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/Platform.android.kt
new file mode 100644
index 0000000..ba841d1
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/Platform.android.kt
@@ -0,0 +1,9 @@
+package com.example.app
+
+import android.os.Build
+
+class AndroidPlatform : Platform {
+ override val name: String = "Android ${Build.VERSION.SDK_INT}"
+}
+
+actual fun getPlatform(): Platform = AndroidPlatform()
\ No newline at end of file
diff --git a/app/composeApp/src/androidMain/kotlin/com/example/demo/RideShareDbHelper.kt b/app/composeApp/src/androidMain/kotlin/com/example/demo/RideShareDbHelper.kt
new file mode 100644
index 0000000..777c33d
--- /dev/null
+++ b/app/composeApp/src/androidMain/kotlin/com/example/demo/RideShareDbHelper.kt
@@ -0,0 +1,29 @@
+package com.example.demo
+
+import android.content.Context
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteOpenHelper
+
+class RideShareDbHelper(context: Context) :
+ SQLiteOpenHelper(context, "rideshare.db", null, 1) {
+
+ override fun onCreate(db: SQLiteDatabase) {
+ // Create a super simple table for now
+ db.execSQL(
+ """
+ CREATE TABLE IF NOT EXISTS rides(
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ pickup TEXT NOT NULL,
+ dropoff TEXT NOT NULL,
+ ride_time TEXT NOT NULL
+ );
+ """.trimIndent()
+ )
+ }
+
+ override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+ // Easiest upgrade strategy for school project
+ db.execSQL("DROP TABLE IF EXISTS rides;")
+ onCreate(db)
+ }
+}
diff --git a/app/composeApp/src/androidMain/res/drawable-v24/ic_launcher_foreground.xml b/app/composeApp/src/androidMain/res/drawable-v24/ic_launcher_foreground.xml
new file mode 100644
index 0000000..bda706c
--- /dev/null
+++ b/app/composeApp/src/androidMain/res/drawable-v24/ic_launcher_foreground.xml
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {}
+ {
+ "isMigrated": true
+}
+ {
+ "associatedIndex": 1
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ true
+ false
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+ false
+ true
+ false
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ true
+ false
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1762914791700
+
+
+ 1762914791700
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/live_demo/Live_Demo.webm b/docs/BlackBoard_Deliverables/Deliverable_4/live_demo/Live_Demo.webm
new file mode 100644
index 0000000..24d05ad
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/live_demo/Live_Demo.webm differ
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Mustafa-Individual Deliverable 04.pdf b/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Mustafa-Individual Deliverable 04.pdf
new file mode 100644
index 0000000..fc27a5e
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Mustafa-Individual Deliverable 04.pdf differ
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Samii_Individual_Deliverable.pdf b/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Samii_Individual_Deliverable.pdf
new file mode 100644
index 0000000..3deaa7e
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/personal_contributions/Samii_Individual_Deliverable.pdf differ
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Final Reflection.pdf b/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Final Reflection.pdf
new file mode 100644
index 0000000..2a83dac
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Final Reflection.pdf differ
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Samii_Reflection.pdf b/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Samii_Reflection.pdf
new file mode 100644
index 0000000..493da6b
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/personal_reflections/Samii_Reflection.pdf differ
diff --git a/docs/BlackBoard_Deliverables/Deliverable_4/presentation/FindMyRide Final Presentation.pptx b/docs/BlackBoard_Deliverables/Deliverable_4/presentation/FindMyRide Final Presentation.pptx
new file mode 100644
index 0000000..1e29579
Binary files /dev/null and b/docs/BlackBoard_Deliverables/Deliverable_4/presentation/FindMyRide Final Presentation.pptx differ
diff --git a/docs/dev_journal/Kennan.md b/docs/dev_journal/Kennan.md
index a772d0d..01e91bf 100644
--- a/docs/dev_journal/Kennan.md
+++ b/docs/dev_journal/Kennan.md
@@ -1,3 +1,52 @@
+# 11/20/2025
+
+Experienced a bunch of issues with trying to build and run the app.
+
+Solution: Deleted the .gradle folder in the app subdirectory and forced it to be rebuilt.
+
+# 11/16/2025
+
+## Development Strategy
+
+As we team we focused and came up with the strategy with 3 Phases.
+
+We are following Three Phase Strategy:
+
+UI Development -> UI Connection Development -> Frontend to Backend Database Connection
+
+And [ChatGPT](https://chatgpt.com/share/691a8a83-69c0-800e-be1c-aa304a8a901f) verified this is the correct process that modern companies use.
+
+Following paging structure with react where we have folders for our features.
+
+## Importing Icons
+
+You should use your own SVG/XML files if you want to import icons onto the UI for the screens.
+
+ 1. Get your icons - Download the icons you want as .svg or .xml (Android Vector) files. (Sites like Heroicons or Phosphor Icons are good sources).
+
+ 2. Place them in the resources folder Go to composeApp/src/commonMain/composeResources/drawable. Paste your files there (e.g., ic_calendar.xml, ic_location.xml).
+
+ 3. Update the code to use painterResource
+
+EXAMPLE CALL using painterResource:
+icon = painterResource(Res.drawable.ic_calendar)
+
+#### 11/21/2025 Update: ANDROID DOES NOT SUPPORT SVG FILES
+
+Here's how to convert them to XML before use:
+
+ 1. In the Project view (left panel), right-click on your commonMain/composeResources/drawable folder.
+
+ 2. Select New > Vector Asset.
+
+ 3. In the "Asset Type" section, choose Local file (SVG, PSD).
+
+ 4. Click the folder icon next to Path and select your original SVG file.
+
+ 5. Click Next and then Finish.
+
+This will create a new .xml file in that folder. Delete the old .svg file so there is no confusion.
+
# 11/2/2025
- Initialize the SQLite Database
diff --git a/docs/dev_journal/Samii.md b/docs/dev_journal/Samii.md
index 9d5d8dd..f3482a9 100644
--- a/docs/dev_journal/Samii.md
+++ b/docs/dev_journal/Samii.md
@@ -1,3 +1,141 @@
+# 11/16/2025
+
+## Development Strategy
+
+As we team we focused and came up with the strategy with 3 Phases.
+
+We are following Three Phase Strategy:
+
+UI Development -> UI Connection Development -> Frontend to Backend Database Connection
+
+And [ChatGPT](https://chatgpt.com/share/691a8a83-69c0-800e-be1c-aa304a8a901f) verified this is the correct process that modern companies use.
+
+Following paging structure with react where we have folders for our features.
+
+- I'm make the structure
+
+```txt
+feature:
+ - auth/ # all authentication related stuff
+ - rides/ # all main ride related stuff
+ - .../ # insert other features
+```
+
+- I added a thing to allow colors to be used all over by every file in this project.
+ - I think Ken is also asking me about my hex color irl so idk how to think about that. /s
+
+Now need to focus on getting the code for login page to make sense.
+
+- I asked a question but he left on delivered.
+
+## KMP Notes:
+
+### @Composable
+- `@Composable` marks this as a composable fucntion - describing UI in Compose
+ - annotation in Jetpack Compose (and Compose Multiplatform)
+ - marks a function as part of the UI tree:
+ - Tells the compiler "this function describes teh UI, not normal code"
+ - It gets compiled into a declarative UI node
+ - Compose knows when to recompse it when states change
+ - Describes how its drawn on Android, iOS, DeskTop, and Web
+ - Compose can optimize it, skip re-rendering, or redraw specific parts.
+ - Without it, function is just normal Kotlin function; Compose cannot treat it as UI.
+
+### @Composable Function Signature
+Example Code:
+```kotlin
+@Composable
+fun LoginScreen(
+ onLoginClick: (email: String, password: string) -> Unit = { _, _ -> },
+ onForgotPasswordClick: () -> Unit = {},
+ onSignUpClick: () -> Unit = {}
+) {
+ //...
+}
+```
+- `@Composable`: Marks this as a composable function -> describes UI in Compose.
+- `fun LoginScreen(..)`: This is the login screen component.
+- `onLoginClick`: A callback that takes an email and password. Default will be an empty lambda that does nothing
+- `onForgotPasswordClick`: Callback when "Forgot password?" is clicked, default does nothing.
+- `onSignUpClick`: Callback when "Sign Up now" is clicked, default is nothing.
+- The defaults make it easy to preview or use this composable without wiring up real logic immediately.
+- `_` == means "I don't care about this input"
+
+#### WHY it looks weird
+- The function parameters are functions -- NOT Integers, Strings, or Booleans.
+
+Example of a normal param:
+```kotlin
+fun doSomething(name: String) {}
+```
+
+Kotlin also allows:
+```kotlin
+fun doSomething(callback: () -> Unit)
+
+// Which means callback is a function with no parameters that return nothing.
+```
+
+#### Why do this?
+Because your UI composable should NOT contain business logic.
+
+Example:
+Inside your screen you will have buttons like:
+```kotlin
+Button(onClick = { onLoginClick(email, password) }) { //... }
+```
+
+But the actual logic (like Firebase login, Drexel API login, etc.) will come from parent screen, not this UI.
+
+### Local state (email & password)
+Example:
+```kotlin
+var email by remember { mutableStateOf("")
+var password by remember { mutableStateOf("") }
+```
+- `remember { mutableStateOf("") }`: Create state that Compose tracks and remember between recompositions.
+
+- Ken said I'm not the right type of asian so I'm not invited to the asian friendsgiving
+
+# 11/10/2025
+
+Tried developing more not working
+
+- SDK broken nothing works.
+- Kennan said something weird about my skin-color.
+
+# 10/5/2025
+
+- Developing Kotlin Multiplatform
+
+Got it to set up.
+
+I went to this page to download the plugin
+
+[Plugin Link](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform?_gl=1%2A5nmlkh%2A_gcl_aw%2AR0NMLjE3NTk2ODk2MzkuQ2owS0NRandyb2pIQmhEZEFSSXNBSmRFSl9jbzlqd2wtaE01ZUlSM3RsbnQ4OWZlRGZjREx3MGNhT3AyYTQ1MlFwa3dyUVJfZWV3SzNUZ2FBc3hGRUFMd193Y0I.%2A_gcl_au%2AMTU1OTY1NjY0OC4xNzU5NTEyNjU4LjQ2NTY5OTIyOS4xNzU5Njg5OTU3LjE3NTk2ODk5NTY.%2AFPAU%2AMjk4MjQwNjQwLjE3NTk1MTI2Nzk.%2A_ga%2AMTk1NjQ5NDYzMC4xNzU5NTEyNjU5%2A_ga_9J976DJZ68%2AczE3NTk2ODk0NjMkbzIkZzEkdDE3NTk2OTAxNTgkajU5JGwwJGgw)
+
+Ignore the rating ;-)
+
+I downloaded the zip package
+
+Nvm tried pressing button computer crashed using some middle zip file they afftered.
+
+# 10/3/2025
+
+## Pipeline Stuff
+
+- Create first pipeline to work off of.
+ - Simple and only focuses on creating test cases for the files we start with.
+
+- Updating README so it will be easy for us to follow professional standards when it comes to commits and etc.
+
+- Trying this new pipeline format that adds this weekly security check.
+ - It's new so I'm excited to see if I did it right and what I have done, so let's hope for the best.
+
+## Creating Kotlin Base for Multiplatform
+
+[Documentation Link](https://www.jetbrains.com/help/kotlin-multiplatform-dev/quickstart.html#set-up-the-environment)
+
# 11/2/2025
- Initialize the SQLite Database
diff --git a/identifier.sqlite b/identifier.sqlite
new file mode 100644
index 0000000..e69de29
diff --git a/script_generation/generate_seed.py b/script_generation/generate_seed.py
deleted file mode 100644
index 920e60f..0000000
--- a/script_generation/generate_seed.py
+++ /dev/null
@@ -1,309 +0,0 @@
-#!/usr/bin/env python3
-"""
-generate_seed.py
-Generates sql/seed_full.sql with realistic synthetic data for Find-My-Ride.
-"""
-
-import os, random, datetime
-from pathlib import Path
-
-random.seed(42)
-
-OUT_DIR = Path(".")
-OUT_DIR.mkdir(parents=True, exist_ok=True)
-SQL_PATH = OUT_DIR / "populate.sql"
-
-# --- keep existing sample rows ---
-users_existing = [
- # (user_id, full_name_or_username, email, phone, role, rating_avg, created_at)
- (1, "abdul_bookwala", "abdul.bookwala1@example.edu", "8569861234", "driver", 4.72, "2025-10-02T00:00:00"),
- (2, "quincy_lu", "quincy.lu2@example.edu", "8569862334", "driver", 4.67, "2025-10-09T00:00:00"),
- (3, "ame_shabuse", "ame.shabuse3@example.edu", "8569861334", "rider", 4.55, "2025-10-02T00:00:00"),
- (4, "ame_lu", "ame.lu4@example.edu", "8569831234", "both", 4.54, "2025-10-10T00:00:00"),
- (5, "kennan_shajid", "kennan.shajid5@example.edu", "8569861234", "both", 4.70, "2025-10-01T00:00:00"),
-]
-
-vehicles_existing = [
- # (vehicle_id, owner_user_id, make, model, color, plate, seats_total, year, fun_fact)
- (1,2,"Tesla","Model Y","Blue","NJ-7909",7,2025,"n/a"),
- (2,5,"Tesla","Model 3","Gray","NJ-6737",5,2024,"n/a"),
- (3,6,"Toyota","Camry","Silver","NJ-8767",4,2015,"n/a"),
- (4,8,"Chevrolet","Malibu","Red","NJ-8301",5,2021,"n/a"),
- (5,9,"Toyota","Camry","Blue","NJ-6823",4,2024,"n/a"),
- (6,14,"Honda","Civic","White","NJ-7519",5,2022,"n/a"),
-]
-
-locations_existing = [
- (1,"Drexel Main Building","3141 Chestnut St"),
- (2,"Korman Center","3220-26 Woodland Walk"),
- (3,"University Crossings","3175 JFK Blvd"),
- (4,"30th Street Station","2955 Market St"),
- (5,"Queen Lane Campus","2900 Queen Ln"),
- (6,"Vidas Athletic Complex","43rd & Powelton"),
- (7,"Cira Green","129 S 30th St"),
- (8,"Wawa 34th Market","3400 Market St"),
-]
-
-ride_offers_existing = [
- # (offer_id,driver_id,vehicle_id,origin_location_id,dest_location_id,depart_at,seats_available,price_base,price_per_mile,status,created_at)
- (1,5,3,3,8,"2025-10-16T01:45:00",2,4.17,0.72,"closed","2025-10-15T01:45:00"),
- (2,1,6,6,10,"2025-10-15T18:45:00",1,5.31,0.86,"closed","2025-10-14T18:45:00"),
- (3,12,1,2,3,"2025-10-14T13:00:00",2,4.63,1.13,"open","2025-10-13T13:00:00"),
- (4,6,2,3,8,"2025-10-14T17:45:00",3,8.52,0.9,"closed","2025-10-13T17:45:00"),
-]
-
-ride_requests_existing = [
- # (request_id, rider_id, pickup_location_id, dropoff_location_id, earliest_pickup, latest_pickup, seats_needed, status, created_at)
- (1,11,7,10,"2025-10-14T19:05:00","2025-10-14T19:45:00",1,"cancelled","2025-10-13T19:15:00"),
- (2,10,6,8,"2025-10-14T13:15:00","2025-10-14T13:25:00",1,"open","2025-10-13T13:15:00"),
- (3,7,1,9,"2025-10-14T07:20:00","2025-10-14T07:40:00",1,"matched","2025-10-13T07:30:00"),
- (4,13,6,7,"2025-10-13T23:50:00","2025-10-14T00:30:00",2,"matched","2025-10-13T00:00:00"),
- (5,10,7,2,"2025-10-15T21:45:00","2025-10-15T21:55:00",1,"open","2025-10-14T21:45:00"),
- (6,11,3,2,"2025-10-15T03:00:00","2025-10-15T03:10:00",1,"cancelled","2025-10-14T03:00:00"),
-]
-
-matches_existing = [
- # (match_id,request_id,offer_id,seats_booked,price_total,state,matched_at)
- (1,3,3,1,11.71,"completed","2025-10-13T13:30:00"),
- (2,4,7,1,7.95,"cancelled","2025-10-13T06:00:00"),
- (3,8,16,2,14.77,"confirmed","2025-10-15T02:00:00"),
- (4,9,16,1,15.16,"no_show","2025-10-13T08:00:00"),
- (5,15,2,1,11.01,"completed","2025-10-13T16:45:00"),
- (6,21,3,1,10.23,"no_show","2025-10-13T23:45:00"),
-]
-
-ratings_existing = [
- # (rating_id,match_id,from_user_id,to_user_id,stars,comment,created_at)
- (1,1,2,12,5,"Friendly","2025-10-13T15:30:00"),
- (3,8,9,4,5,"Great ride","2025-10-13T04:45:00"),
-]
-
-# --- generation parameters ---
-EXTRA = 100 # number of rows to add per table
-start_user_id = max(u[0] for u in users_existing) + 1 # 6
-start_vehicle_id = max((v[0] for v in vehicles_existing), default=0) + 1
-start_location_id = max(l[0] for l in locations_existing) + 1
-start_offer_id = max(o[0] for o in ride_offers_existing) + 1
-start_request_id = max(r[0] for r in ride_requests_existing) + 1
-start_match_id = max(m[0] for m in matches_existing) + 1
-start_rating_id = max(r[0] for r in ratings_existing) + 1
-
-first_names = ["Alex","Jordan","Taylor","Morgan","Cameron","Riley","Casey","Jamie","Avery","Sam","Sydney","Charlie","Drew","Logan","Peyton","Harper","Blake","Quinn","Rowan","Elliot","Maria","Jamal","Priya","Diego","Lina","Marcus"]
-last_names = ["Smith","Johnson","Williams","Brown","Jones","Miller","Davis","Garcia","Rodriguez","Wilson","Martinez","Anderson","Taylor","Thomas","Hernandez","Moore","Martin","Jackson","Thompson","White"]
-car_makes_models = [("Toyota","Camry"),("Honda","Civic"),("Tesla","Model 3"),("Tesla","Model Y"),("Chevrolet","Malibu"),("Hyundai","Elantra"),("Ford","Focus"),("Nissan","Altima")]
-colors = ["Blue","Gray","Silver","Red","Black","White","Green","Gold","Maroon"]
-roles = ["rider","driver","both"]
-
-# helper to produce ISO timestamps in Oct 2025 window
-def rand_datetime_oct13_to_nov30():
- base = datetime.datetime(2025,10,13)
- delta = datetime.timedelta(days=random.randint(0,48), hours=random.randint(0,23), minutes=random.randint(0,59))
- return (base + delta).isoformat(timespec="seconds")
-
-# --- generate users ---
-users_generated = []
-for i in range(EXTRA):
- uid = start_user_id + i
- fn = random.choice(first_names)
- ln = random.choice(last_names)
- username = f"{fn.lower()}.{ln.lower()}{uid}"
- email = f"{fn.lower()}.{ln.lower()}{uid}@drexel.edu"
- phone = f"215{random.randint(2000000,9999999)}"
- role = random.choices(roles, weights=[0.45,0.40,0.15], k=1)[0]
- rating_avg = round(max(2.5, min(5.0, random.gauss(4.4,0.4))),2)
- created_at = (datetime.datetime(2025,10,1) + datetime.timedelta(days=random.randint(0,60))).isoformat(timespec="seconds")
- users_generated.append((uid, email, username, "x", phone, role, rating_avg, created_at))
-
-users_all = users_existing + users_generated
-
-# --- generate locations ---
-locations_generated = []
-for i in range(EXTRA):
- lid = start_location_id + i
- name = f"Philly Point {lid}"
- address = f"{random.randint(100,3999)} Market St"
- locations_generated.append((lid, name, address))
-locations_all = locations_existing + locations_generated
-
-# --- generate vehicles (assign to drivers/both) ---
-driver_candidates = [u for u in users_all if u[5] in ("driver","both")]
-# ensure enough drivers by converting some generated users if needed
-if len(driver_candidates) < 40:
- for j in range(30):
- idx = j % len(users_generated)
- u = users_generated[idx]
- users_generated[idx] = (u[0], u[1], u[2], u[3], u[4], "driver", u[6], u[7])
- users_all = users_existing + users_generated
- driver_candidates = [u for u in users_all if u[5] in ("driver","both")]
-
-vehicles_generated = []
-for i in range(EXTRA):
- vid = start_vehicle_id + i
- owner = random.choice(driver_candidates)[0]
- make, model = random.choice(car_makes_models)
- color = random.choice(colors)
- plate = f"NJ-{1000 + vid:04d}"
- seats = random.choice([4,4,5,5,6])
- year = random.randint(2010,2025)
- fun_fact = random.choice(["n/a","student vehicle","rideshare-ready","garage kept"])
- vehicles_generated.append((vid, owner, make, model, color, plate, seats, year, fun_fact))
-vehicles_all = vehicles_existing + vehicles_generated
-
-# --- generate ride_offers ---
-offers_generated = []
-for i in range(EXTRA):
- oid = start_offer_id + i
- driver = random.choice(driver_candidates)[0]
- # pick a vehicle by this owner or random
- owned = [v for v in vehicles_all if v[1] == driver]
- vehicle_id = random.choice(owned)[0] if owned else random.choice(vehicles_all)[0]
- origin = random.choice(locations_all)[0]
- dest = random.choice(locations_all)[0]
- if origin == dest:
- dest = (dest % (start_location_id + EXTRA - 1)) + 1
- depart_at = rand_datetime_oct13_to_nov30()
- seats_available = random.choice([1,1,2,2,3,4])
- price_base = round(random.uniform(3.0,9.0),2)
- price_per_mile = round(random.uniform(0.5,1.6),2)
- status = random.choices(["open","closed"], weights=[0.6,0.4])[0]
- created_at = (datetime.datetime.fromisoformat(depart_at) - datetime.timedelta(days=random.randint(0,7))).isoformat(timespec="seconds")
- offers_generated.append((oid, driver, vehicle_id, origin, dest, depart_at, seats_available, price_base, price_per_mile, status, created_at))
-offers_all = ride_offers_existing + offers_generated
-
-# --- generate ride_requests ---
-riders = [u for u in users_all if u[5] in ("rider","both")]
-requests_generated = []
-for i in range(EXTRA):
- rid = start_request_id + i
- rider = random.choice(riders)[0]
- pickup = random.choice(locations_all)[0]
- dropoff = random.choice(locations_all)[0]
- if pickup == dropoff:
- dropoff = (dropoff % (start_location_id + EXTRA - 1)) + 1
- earliest_dt = datetime.datetime(2025,10,13) + datetime.timedelta(days=random.randint(0,48), hours=random.randint(6,20), minutes=random.randint(0,59))
- latest_dt = earliest_dt + datetime.timedelta(minutes=random.randint(10,60))
- seats_needed = random.choice([1,1,2])
- status = random.choices(["open","matched","cancelled"], weights=[0.55,0.35,0.10])[0]
- created_at = (earliest_dt - datetime.timedelta(days=random.randint(0,5))).isoformat(timespec="seconds")
- requests_generated.append((rid, rider, pickup, dropoff, earliest_dt.isoformat(timespec="seconds"), latest_dt.isoformat(timespec="seconds"), seats_needed, status, created_at))
-requests_all = ride_requests_existing + requests_generated
-
-# --- generate matches by trying to align requests to offers ---
-matches_generated = []
-match_id = start_match_id
-# simple matching: randomly attempt to pair some requests to offers
-for req in requests_generated:
- if random.random() < 0.6: # 60% of generated requests get a match
- # pick a candidate offer where seats >= seats_needed
- candidates = [o for o in offers_all if o[6] >= req[6]]
- if not candidates:
- continue
- offer = random.choice(candidates)
- seats_booked = min(offer[6], req[6])
- miles = random.uniform(2.0,12.0)
- price_total = round(offer[7] + offer[8]*miles, 2) if isinstance(offer[7], float) else round(offer[7] + offer[8]*miles,2)
- state = random.choices(["confirmed","completed","cancelled","no_show"], weights=[0.4,0.35,0.15,0.10])[0]
- matched_at = (datetime.datetime.fromisoformat(req[4]) - datetime.timedelta(hours=random.randint(0,4))).isoformat(timespec="seconds")
- matches_generated.append((match_id, req[0], offer[0], seats_booked, price_total, state, matched_at))
- match_id += 1
-
-matches_all = matches_existing + matches_generated
-
-# --- generate ratings for completed matches ---
-ratings_generated = []
-rating_id = start_rating_id
-for m in matches_generated:
- if m[5] == "completed" and random.random() < 0.85:
- # find from_user (rider) and to_user (driver)
- req = next((r for r in requests_all if r[0] == m[1]), None)
- offer = next((o for o in offers_all if o[0] == m[2]), None)
- if not req or not offer:
- continue
- from_user = req[1]
- to_user = offer[1]
- if from_user == to_user:
- continue
- stars = random.choices([5,4,3,2,1], weights=[0.6,0.25,0.08,0.04,0.03])[0]
- comment = random.choice(["Great ride","Friendly driver","On time","Would ride again","Car was clean","Driver was late","Helpful with bags"])
- created_at = (datetime.datetime.fromisoformat(m[6]) + datetime.timedelta(hours=random.randint(1,48))).isoformat(timespec="seconds")
- ratings_generated.append((rating_id, m[0], from_user, to_user, stars, comment, created_at))
- rating_id += 1
-
-# --- Clean up ratings to ensure no self-ratings or duplicates ---
-cleaned_ratings = []
-seen_pairs = set()
-for r in ratings_generated:
- rid, match_id, from_user, to_user, stars, comment, created_at = r
- if from_user == to_user:
- continue
- pair_key = (from_user, to_user)
- if pair_key in seen_pairs:
- continue
- seen_pairs.add(pair_key)
- cleaned_ratings.append(r)
-ratings_generated = cleaned_ratings
-
-ratings_all = ratings_existing + ratings_generated
-
-# --- write SQL file ---
-def sql_quote(val):
- if val is None:
- return "NULL"
- if isinstance(val, str):
- return "'" + val.replace("'", "''") + "'"
- return str(val)
-
-with open(SQL_PATH, "w", encoding="utf-8") as f:
- f.write("-- USERS\n")
- for u in users_all:
- if len(u) == 7:
- # older sample format (id, fullname, email, phone, role, rating, created_at)
- uid, uname, email, phone, role, rating, created = u if len(u) == 7 else (u[0], u[2], u[1], u[3], u[4], u[5], u[6])
- # if the sample stored full name, ensure username is simple
- # but our existing list is normalized so treat generically:
- f.write("INSERT INTO USER (user_id,email,username,password_hash,phone_number,role,rating_avg,created_at) VALUES (%s,%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(uid), sql_quote(email), sql_quote(uname), sql_quote("x"), sql_quote(phone), sql_quote(role), sql_quote(rating), sql_quote(created)
- ))
- else:
- # generated entries: (uid, email, username, pw, phone, role, rating, created_at)
- uid, email, uname, pw, phone, role, rating, created = u
- f.write("INSERT INTO USER (user_id,email,username,password_hash,phone_number,role,rating_avg,created_at) VALUES (%s,%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(uid), sql_quote(email), sql_quote(uname), sql_quote(pw), sql_quote(phone), sql_quote(role), sql_quote(rating), sql_quote(created)
- ))
-
- f.write("\n-- VEHICLE\n")
- for v in vehicles_all:
- f.write("INSERT INTO VEHICLE (vehicle_id,owner_user_id,make,model,color,plate,seats_total,year,fun_fact) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s);\n" % tuple(sql_quote(x) for x in v))
-
- f.write("\n-- LOCATION\n")
- for loc in locations_all:
- f.write("INSERT INTO LOCATION (location_id,name,address) VALUES (%s,%s,%s);\n" % (sql_quote(loc[0]), sql_quote(loc[1]), sql_quote(loc[2])))
-
- f.write("\n-- RIDE_OFFER\n")
- for o in offers_all:
- f.write("INSERT INTO RIDE_OFFER (offer_id,driver_id,vehicle_id,original_location_id,dest_location_id,depart_at,seats_available,price_base,price_per_mile,status,created_at) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(o[0]), sql_quote(o[1]), sql_quote(o[2]), sql_quote(o[3]), sql_quote(o[4]), sql_quote(o[5]), sql_quote(o[6]), sql_quote(o[7]), sql_quote(o[8]), sql_quote(o[9]), sql_quote(o[10])
- ))
-
- f.write("\n-- RIDE_REQUEST\n")
- for r in requests_all:
- f.write("INSERT INTO RIDE_REQUEST (request_id,rider_id,pickup_location_id,dropoff_location_id,earliest_pickup,latest_pickup,seats_needed,status,created_at) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(r[0]), sql_quote(r[1]), sql_quote(r[2]), sql_quote(r[3]), sql_quote(r[4]), sql_quote(r[5]), sql_quote(r[6]), sql_quote(r[7]), sql_quote(r[8])
- ))
-
- f.write("\n-- RIDE_MATCH\n")
- for m in matches_all:
- f.write("INSERT INTO RIDE_MATCH (match_id,request_id,offer_id,seats_booked,price_total,state,matched_at) VALUES (%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(m[0]), sql_quote(m[1]), sql_quote(m[2]), sql_quote(m[3]), sql_quote(m[4]), sql_quote(m[5]), sql_quote(m[6])
- ))
-
- f.write("\n-- RATING\n")
- for rt in ratings_all:
- f.write("INSERT INTO RATING (rating_id,match_id,from_user_id,to_user_id,stars,comment,created_at) VALUES (%s,%s,%s,%s,%s,%s,%s);\n" % (
- sql_quote(rt[0]), sql_quote(rt[1]), sql_quote(rt[2]), sql_quote(rt[3]), sql_quote(rt[4]), sql_quote(rt[5]), sql_quote(rt[6])
- ))
-
-print("Wrote SQL to:", SQL_PATH)
-print("Row counts (approx): USERS=%d VEHICLE=%d LOCATION=%d RIDE_OFFER=%d RIDE_REQUEST=%d RIDE_MATCH=%d RATING=%d" % (
- len(users_all), len(vehicles_all), len(locations_all), len(offers_all), len(requests_all), len(matches_all), len(ratings_all)
-))
\ No newline at end of file