A professional web application built with pure PHP following MVC architecture, OOP principles, PSR-4 autoloading, and PSR-1 naming conventions. Features user authentication, validated form submission, and comprehensive reporting—all containerized with Docker for easy deployment.
📖 Documentation • 🎯 Features • 🐳 Docker Setup • 🏗️ Architecture
Clean and intuitive registration interface with real-time validation
Secure authentication with session management
Interactive form with dynamic item addition and validation
Comprehensive reporting with filtering options
| Category | Technology |
|---|---|
| Backend | PHP 8.1 |
| Database | MySQL 8.0 |
| Frontend | JavaScript (Vanilla), HTML5, CSS3 |
| Containerization | Docker & Docker Compose |
| Dependency Management | Composer |
| Database Management | phpMyAdmin |
| Architecture | MVC, Repository Pattern, Service Layer |
| OOP Principles | All 4 Pillars Implemented |
| Autoloading | PSR-4 |
| Coding Standards | PSR-1, PSR-12 |
This project follows a clean, layered architecture that separates concerns and promotes maintainability, testability, and scalability.
┌─────────────────────────────────────────────────────────────────┐
│ CLIENT REQUEST │
│ (Browser → HTTP Request) │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ PUBLIC ENTRY POINT │
│ (public/signup.php, etc.) │
│ - Composer Autoload │
│ - Session Management │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ CONTROLLER │
│ (AuthController, SubmissionController) │
│ - Handle HTTP Request │
│ - Route to Appropriate Method │
│ - Authentication Check │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ VALIDATOR │
│ (UserSignupValidator, SubmissionValidator) │
│ - Validate Input Data │
│ - Apply Business Rules │
│ - Return Errors if Invalid │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ SERVICE │
│ (AuthService, SubmissionService) │
│ - Execute Business Logic │
│ - Coordinate Operations │
│ - Handle Transactions │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ REPOSITORY │
│ (UserRepository, SubmissionRepository) │
│ - Database Operations (CRUD) │
│ - Query Building │
│ - Data Mapping │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ DATABASE MODEL │
│ (Database Singleton) │
│ - PDO Connection │
│ - Query Execution │
│ - Transaction Management │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ MySQL DATABASE │
│ - Data Persistence │
│ - ACID Compliance │
└─────────────────────────────────────────────────────────────────┘
│
▼ (Response flows back up)
┌─────────────────────────────────────────────────────────────────┐
│ VIEW │
│ (dashboard.php, reports.php) │
│ - Render HTML │
│ - Display Data │
│ - User Interface │
└────────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ CLIENT RESPONSE │
│ (Browser renders page) │
└─────────────────────────────────────────────────────────────────┘
This project implements the Model-View-Controller pattern:
- Database.php: Singleton pattern for database connections
- Repositories: Handle all database operations (CRUD)
- Services: Contain business logic and orchestrate operations
- app/Views/: Reusable view components
- public/: Public-facing pages
- JavaScript files: Client-side validation and interactivity
- AuthController: Handles authentication (signup, login, logout)
- SubmissionController: Manages form submissions and reports
- AbstractController: Base controller with shared functionality
The Repository Pattern abstracts data access and provides a collection-like interface:
AbstractRepository (Base CRUD Operations)
↓
UserRepository (User-specific queries)
- findByEmail()
- emailExists()
- verifyPassword()
SubmissionRepository (Submission-specific queries)
- getFiltered()
- findByReceiptId()
- generateHashKey()The Service Layer contains business logic and coordinates between controllers and repositories:
AuthService
- register(name, email, password)
- login(email, password)
- Coordinates: Validator → Repository
SubmissionService
- createSubmission(data)
- getFilteredSubmissions(filters)
- Coordinates: Validator → Repository → Business RulesBenefits:
- Separates business logic from controllers
- Reusable across multiple entry points
- Easier to test
- Follows Single Responsibility Principle
This project is a comprehensive demonstration of Object-Oriented Programming principles applied to real-world web development.
Definition: Bundling data and methods together while restricting direct access.
Implementation:
class AbstractRepository {
protected $connection;
protected $table;
protected function query($sql, $params) {
}
}Examples in Project:
AuthService: Private properties$userRepository,$errors,$responseAbstractController: Protected session management methods- All repositories: Protected database connection
Definition: Child classes inherit properties and methods from parent classes.
Implementation:
// Parent provides base CRUD operations
AbstractRepository
↓
UserRepository extends AbstractRepository
- Inherits: all(), findById(), create(), update(), delete()
- Adds: findByEmail(), emailExists()Class Hierarchies:
AbstractController
├── AuthController
└── SubmissionController
AbstractRepository
├── UserRepository
└── SubmissionRepository
AbstractValidator
├── UserSignupValidator
├── UserLoginValidator
└── SubmissionValidator
Definition: Same method name behaves differently in different classes.
Implementation:
// Parent method
class AbstractRepository {
public function create(array $data): bool {
// Generic create
}
}
// Child overrides with specific behavior
class UserRepository extends AbstractRepository {
public function create(array $data): bool {
$data['password'] = password_hash($data['password'], PASSWORD_DEFAULT);
return parent::create($data); // Calls parent with hashed password
}
}Examples:
- All validators implement
validateRules()differently - Controllers implement request handlers polymorphically
- Services implement
execute()with different business logic
Definition: Hiding implementation details while exposing essential features.
Implementation:
interface RepositoryInterface {
public function all(): array;
public function findById(int $id): ?array;
public function create(array $data): bool;
// Defines WHAT, not HOW
}
abstract class AbstractValidator implements ValidatorInterface {
abstract protected function validateRules(array $data): void;
// Forces children to implement specific validation
}Interfaces in Project:
RepositoryInterface: Defines data access contractValidatorInterface: Defines validation contractAuthenticationInterface: Defines auth operations contractServiceInterface: Defines service operations contract
RepositoryInterface (Contract)
↓
AbstractRepository (Implementation + Helpers)
├── UserRepository (User-specific operations)
└── SubmissionRepository (Submission-specific operations)
ValidatorInterface (Contract)
↓
AbstractValidator (Base validation + Helpers)
├── UserSignupValidator
├── UserLoginValidator
└── SubmissionValidator
AbstractController (Base functionality)
├── AuthController (Authentication operations)
└── SubmissionController (Submission operations)
class Database {
private static $instance = null;
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
}Purpose: Ensures only one database connection exists.
Purpose: Abstracts data layer and provides collection-like interface.
Purpose: Separates business logic from controllers.
class AuthController extends AbstractController {
private $authService;
private $validator;
public function __construct(AuthService $authService, UserSignupValidator $validator) {
$this->authService = $authService;
$this->validator = $validator;
}
}Purpose: Loose coupling and easier testing.
Purpose: Separation of concerns.
This project uses Docker to containerize the entire application stack, making it portable, consistent, and easy to deploy across different environments.
┌──────────────────────────────────────────────────────────────┐
│ Docker Host │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ roxnor_network (Bridge) │ │
│ │ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ PHP App │ │ MySQL │ │ phpMyAdmin │ │ │
│ │ │ Container │ │ Container │ │ Container │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Port: 8080 │ │ Port: 3307 │ │ Port: 8081 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ PHP 8.1 │ │ MySQL 8.0 │ │ phpMyAdmin │ │ │
│ │ │ Apache │ │ │ │ Latest │ │ │
│ │ │ Composer │ │ │ │ │ │ │
│ │ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │ │
│ │ │ │ │ │ │
│ │ └─────────────────┴─────────────────┘ │ │
│ │ Inter-container │ │
│ │ Communication │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Docker Volumes (Persistent) │ │
│ │ │ │
│ │ • db_data → MySQL data persistence │ │
│ │ • ./:/var/www/html → App code mounting │ │
│ └────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
roxnor/
├── app/ # Application logic
│ ├── Abstracts/ # Abstract base classes
│ │ ├── AbstractController.php # Base controller functionality
│ │ ├── AbstractRepository.php # Base CRUD operations
│ │ └── AbstractValidator.php # Base validation helpers
│ ├── Contracts/ # Interfaces (Abstraction)
│ │ ├── AuthenticationInterface.php
│ │ ├── DatabaseInterface.php
│ │ ├── RepositoryInterface.php
│ │ ├── ServiceInterface.php
│ │ └── ValidatorInterface.php
│ ├── Controllers/ # Request handlers
│ │ ├── AuthController.php # Authentication logic
│ │ └── SubmissionController.php # Submission logic
│ ├── Models/ # Database models
│ │ └── Database.php # Singleton DB connection
│ ├── Repositories/ # Data access layer
│ │ ├── UserRepository.php # User CRUD operations
│ │ └── SubmissionRepository.php # Submission CRUD operations
│ ├── Services/ # Business logic layer
│ │ ├── AuthService.php # Auth business logic
│ │ └── SubmissionService.php # Submission business logic
│ ├── Validators/ # Input validation
│ │ ├── UserSignupValidator.php
│ │ ├── UserLoginValidator.php
│ │ └── SubmissionValidator.php
│ └── Views/
│ ├── dashboard.php
│ ├── login.php
│ ├── signup.php
│ ├── reports.php
│ └── partials/
│ ├── head.php
│ ├── navbar.php
│ └── input.php
├── config/ # Configuration files
│ ├── app.php # App configuration
│ └── database.php # Database configuration
├── public/ # Public web root
│ ├── css/ # Stylesheets
│ ├── js/ # JavaScript files
│ ├── Images/ # Images
│ ├── api/ # API endpoints
│ ├── index.php # Entry point
│ ├── signup.php # Signup page
│ ├── login.php # Login page
│ ├── dashboard.php # Dashboard page
│ ├── submit.php # Form submission handler
│ ├── logout.php # Logout handler
│ └── reports.php # Reports page
├── vendor/ # Composer dependencies
├── Instructions/ # Project documentation
├── composer.json # Composer configuration
├── database.sql # Database schema
├── Dockerfile # PHP app container config
├── docker-compose.yml # Multi-container orchestration
└── README.md # This file
1. Clone the repository
git clone https://github.com/engrshishir/roxnor.git
cd roxnor2. Build and start containers
docker-compose up -d --buildThis command will:
- ✅ Build the PHP 8.1 + Apache container
- ✅ Pull MySQL 8.0 image
- ✅ Pull phpMyAdmin image
- ✅ Create isolated network
- ✅ Initialize database with schema
- ✅ Install Composer dependencies
3. Access the application
- Application: http://localhost:8080
- phpMyAdmin: http://localhost:8081
- Username:
roxnor_user - Password:
roxnor_password
- Username:
# View logs
docker-compose logs -f
# Stop containers
docker-compose down
# Restart containers
docker-compose restart
# Rebuild after code changes
docker-compose up -d --build
# Remove containers and volumes (fresh start)
docker-compose down -v┌─────────────────────────────────────────────────────────┐
│ PRESENTATION LAYER │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌─────────┐ │
│ │ HTML5 │ │ CSS3 │ │JavaScript│ │ Views │ │
│ └──────────┘ └──────────┘ └──────────┘ └─────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ CONTROLLER LAYER │
│ ┌────────────────────┐ ┌─────────────────────────┐ │
│ │ AuthController │ │ SubmissionController │ │
│ │ - signup() │ │ - create() │ │
│ │ - login() │ │ - getFiltered() │ │
│ │ - logout() │ │ - update() │ │
│ └────────────────────┘ └─────────────────────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ VALIDATION LAYER │
│ ┌───────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ UserSignup │ │ UserLogin │ │ Submission │ │
│ │ Validator │ │ Validator │ │ Validator │ │
│ └───────────────┘ └──────────────┘ └──────────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ SERVICE LAYER │
│ ┌────────────────────┐ ┌─────────────────────────┐ │
│ │ AuthService │ │ SubmissionService │ │
│ │ - Business Logic │ │ - Business Logic │ │
│ │ - Orchestration │ │ - Orchestration │ │
│ └────────────────────┘ └─────────────────────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ REPOSITORY LAYER │
│ ┌────────────────────┐ ┌─────────────────────────┐ │
│ │ UserRepository │ │ SubmissionRepository │ │
│ │ - CRUD Operations │ │ - CRUD Operations │ │
│ │ - Data Mapping │ │ - Query Building │ │
│ └────────────────────┘ └─────────────────────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ DATA LAYER │
│ ┌──────────────────────────────────────────────────┐ │
│ │ Database (Singleton PDO) │ │
│ │ - Connection Management │ │
│ │ - Query Execution │ │
│ │ - Transaction Handling │ │
│ └──────────────────────────────────────────────────┘ │
└────────────────────────┬────────────────────────────────┘
│
┌────────────────────────▼────────────────────────────────┐
│ MySQL DATABASE │
│ ┌────────────────┐ ┌────────────────────┐ │
│ │ users table │ │ submissions table │ │
│ │ - id │ │ - id │ │
│ │ - name │ │ - receipt_id │ │
│ │ - email │───────────│ - entry_by (FK) │ │
│ │ - password │ │ - total_amount │ │
│ │ - created_at │ │ - items (JSON) │ │
│ └────────────────┘ └────────────────────┘ │
└─────────────────────────────────────────────────────────┘
Contributions are welcome! Please follow these guidelines:
- Fork the repository
- Create a feature branch
git checkout -b feature/YourFeature
- Commit your changes
git commit -m "Add: Your feature description" - Push to the branch
git push origin feature/YourFeature
- Open a Pull Request
- Follow PSR-1 and PSR-12 coding standards
- Write meaningful commit messages
- Add comments for complex logic
- Update documentation if needed
This project is licensed under the MIT License.
Image: engrshishir/roxnor-app
# Pull the latest image
docker pull engrshishir/roxnor-app:latest
# Or pull specific version
docker pull engrshishir/roxnor-app:1.0.0
# Clone repository for docker-compose.yml
git clone https://github.com/engrshishir/roxnor.git
cd roxnor
# Start all services (app, database, phpMyAdmin)
docker-compose up -d
# Access the application
# - App: http://localhost:8080
# - phpMyAdmin: http://localhost:8081Shishir - Roxnor Internship Assessment
This project is created for internship assessment purposes.