Laravel Project Setup Guide

This guide will walk you through the process of cloning and setting up this Laravel project on your local machine.

Prerequisites

Before you begin, make sure you have the following installed on your system:

• PHP >= 8.1
• Composer (PHP dependency manager)
• Node.js and npm (for frontend assets)
• MySQL or another database supported by Laravel
• Git

Installation Steps

1. Clone the Repository

Open your terminal and run:

git clone https://github.com/DavidHaryono/Financial-Tracker.git
cd Financial-Tracker

2. Install PHP Dependencies

Install all PHP dependencies using Composer:

composer install

3. Install Node.js Dependencies

Install all frontend dependencies using npm:

npm install

4. Environment Configuration

Copy the Environment File

Laravel uses a .env file for environment-specific configuration. Copy the example file:

cp .env.example .env

Generate Application Key

Generate a unique application key:

php artisan key:generate

Configure Database

Open the .env file in your text editor and update the database configuration:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_database_username
DB_PASSWORD=your_database_password

Replace your_database_name, your_database_username, and your_database_password with your actual database credentials.

5. Configure API Keys

This project requires two additional API keys. Add them to your .env file:

OCRSPACE_API_KEY=your_ocrspace_api_key
GROQ_API_KEY=your_groq_api_key

Getting the OCR.space API Key

OCR.space provides optical character recognition services.

Option 1: Free API Key (Recommended for Development)

1. Visit OCR.space API
2. Sign up for a free account
3. You'll receive an API key via email
4. Copy the API key and paste it in your .env file as OCRSPACE_API_KEY

Option 2: Using OCR.space Desktop Application

1. Download the OCR.space desktop application from their GitHub releases
2. Install the application on your system
3. Add the application to your system PATH (optional, for command-line usage)
4. If using the desktop version programmatically, configure the path in your application

Getting the Groq API Key

Groq provides AI language model APIs for fast inference.

1. Visit Groq Console
2. Sign up for a free account or log in
3. Navigate to the API Keys section in your dashboard
4. Click "Create API Key"
5. Give your key a descriptive name (e.g., "Laravel Project")
6. Copy the generated API key
7. Paste it in your .env file as GROQ_API_KEY

Important: Keep your API keys secure and never commit them to version control!

6. Run Database Migrations

Create the necessary database tables:

php artisan migrate

If you have seeders to populate initial data:

php artisan db:seed

Or run both migrations and seeders together:

php artisan migrate --seed

7. Build Frontend Assets

Compile the frontend assets:

For development:

npm run dev

For production:

npm run build

8. Create Storage Link

Create a symbolic link from public/storage to storage/app/public:

php artisan storage:link

9. Set Proper Permissions

Ensure the storage and bootstrap/cache directories are writable:

On Linux/Mac:

chmod -R 775 storage bootstrap/cache

On Windows: Right-click the folders, go to Properties > Security, and ensure appropriate write permissions.

10. Start the Development Server

Start the Laravel development server:

php artisan serve

The application will be available at http://localhost:8000

Note: If you're running npm run dev for hot module replacement, you may need to run it in a separate terminal window.

Common Issues and Troubleshooting

Issue: "No application encryption key has been specified"

Solution: Run php artisan key:generate

Issue: Database connection errors

Solution: Verify your database credentials in the .env file and ensure your database server is running

Issue: Permission denied errors

Solution: Ensure proper permissions are set on the storage and bootstrap/cache directories

Issue: API errors related to OCR or Groq

Solution: Verify that your API keys are correctly set in the .env file and that they're valid

Additional Commands

Clear application cache:

php artisan cache:clear
php artisan config:clear
php artisan route:clear
php artisan view:clear

Run tests:

php artisan test

Project Structure

Laravel-Project/
├── app/              # Application core code
├── bootstrap/        # Framework bootstrap files
├── config/           # Configuration files
├── database/         # Database migrations and seeders
├── public/           # Public assets and entry point
├── resources/        # Views, raw assets, and language files
├── routes/           # Application routes
├── storage/          # Generated files and logs
└── tests/            # Automated tests

Team & Acknowledgments

This project was developed as a collaborative effort. Massive thanks to the team members who built this:

👥 Engineering Team & Core Contributions

This platform was developed as a collaborative full-stack engineering project. The technical responsibilities and architectural components were divided as follows:

Frontend Engineering

• David Alexander Haryono

  • Architected the core user interface layouts utilizing Blade template component inheritance (layouts.app) to establish globally unified responsive UI viewports.
  • Engineered state-driven frontend modal components and dynamic interactive forms for managing complex database requests across expenses.index, expenses.create, and expenses.edit view modules.
  • Integrated multi-language display controls leveraging custom dynamic locale injection mappings into template string fields.

• Diven Dechal Jatiputra

  • Built client-side input validation architectures and unified asset compilation using Vite runtime orchestration pipelines (vite.config.js).
  • Optimized responsive asset behavior and visual rendering pipelines utilizing customized utility classes across user profile controls and authentication portals.
  • Managed responsive form styling layout breakpoints to ensure cross-device consistency during asynchronous transaction submissions.

Backend & Systems Architecture

• Benediktus Darmawan

  • Constructed the core relational schema foundation, engineering sequential Laravel Migration tables managing primary relationships (users, expenses, cache, and secure system session token distributions).
  • Developed the multi-lingual middleware routing pipeline (LocaleMiddleware), intercepting inbound client traffic to dynamically map matching system data translation properties.
  • Programmed programmatic security restrictions through active authentication routing rules and custom state verification handlers (CheckSession).

• Kneson Surya Wijaya

  • Developed robust application runtime microservices, engineering the file-stream processing architecture inside the abstract Receipt Parser Service Engine (ReceiptParserService).
  • Implemented database interaction layers using Eloquent ORM models (User, Expense), mapping transactional mass-assignment configurations, structural database seeding routines, and user profiling query filters.
  • Maintained backend platform test integrity using automated feature testing blueprints (Feature/ExampleTest, TestCase) to secure model validation pipelines.