Lap Machines

📊 User Journey in Walthroh

video_2.mp4

Server Stills

📋 Table of Contents

• Overview
• ⚠️ Important Notice
• 🌟 Features
• 🔧 Technical Stack
• 🚀 Getting Started
  • Prerequisites
  • Installation Steps
  • Configuration
• 🏗️ Project Structure
• 📦 Components Deep Dive
• 🔌 API Documentation
• 🗄️ Database Schema
• 🛠️ Development Guide
• 🚀 Deployment
• 🔒 Security Considerations
• 🤝 Contributing
• 📝 License
• 👤 Author

Overview

Lap Machines is a sophisticated file management system that enables rapid file uploads and downloads through a modern web interface. Built with a powerful stack of Go, React with TypeScript, and PostgreSQL, this project demonstrates a production-ready application with containerized deployment capabilities.

⚠️ Important Notice

Mobile Responsiveness: Please note that this application is currently optimized for desktop use only and is not mobile-responsive. Mobile users may experience layout issues or reduced functionality. Contributors are welcome to fork the project and add mobile responsiveness.

🌟 Features

• Fast File Operations

  • Rapid file uploads with progress tracking
  • Instant downloads with proper content-type handling
  • Multiple file selection support
  • Drag and drop interface

• Smart Storage Management

  • Automatic file type detection
  • File metadata tracking
  • Storage usage statistics
  • UUID-based file identification

• Security Features

  • Secure file storage
  • File type validation
  • Size limit enforcement
  • CORS configuration

• User Interface

  • Clean, modern design
  • Real-time upload progress
  • File type icons
  • Sort and filter capabilities
  • Dark/Light theme support

🔧 Technical Stack

Frontend (Ashyft)

• React 18.x with TypeScript
• Vite for build tooling
• TailwindCSS for styling If ShadCN fails to set up TailwindCSS properly, switch to this approach
• Shadcn UI components for vite
• File handling libraries React FilePond
• Nginx for serving static content

Backend (Go)

• Go 1.24
• Standard net/http package
• PostgreSQL driver
• File system operations
• RESTful API design

Database

• PostgreSQL 14
• UUID extension
• Optimized schema design

DevOps

• Docker & Docker Compose
• Nginx configuration
• Environment management
• Volume persistence

🚀 Getting Started

Prerequisites

1. Install Docker & Docker Compose

   # Verify installations
   docker --version
   docker-compose --version

2. Ensure ports 5173 (frontend), 8080 (backend), and 5433 (database) are available

3. At least 1GB of free disk space

Installation Steps

1. Clone the Repository

   git clone https://github.com/ANSHPG/Lap-Machines.git
   cd Lap-Machines/Production_server

2. Environment Setup

   # Create .env file in Ashyft directory
   cp Ashyft/.env.example Ashyft/.env
   
   # Update environment variables if needed

3. Build and Run

   docker-compose up --build

4. Verify Installation

   • Frontend: http://localhost:5173
   • Backend API: http://localhost:8080/health
   • Database: Port 5433 (use any PostgreSQL client)

Configuration

Frontend Configuration

File: Ashyft/.env

VITE_API_URL=http://localhost:8080
VITE_MAX_FILE_SIZE=100000000

Backend Configuration

Environment variables in docker-compose.yml:

DB_HOST=db
DB_USER=postgres
DB_PASSWORD=your_password
DB_NAME=file_manager
PORT=8080

🏗️ Project Structure

Production_server/
├── Ashyft/                 # Frontend application
│   ├── src/               # Source code
│   ├── public/           # Static assets
│   └── Dockerfile        # Frontend container
├── Backend/               # Go backend
│   ├── main.go          # Entry point
│   └── Dockerfile       # Backend container
├── Postgres/              # Database
│   ├── init.sql        # Schema
│   └── file_manager.md # Documentation
└── docker-compose.yml    # Container orchestration

📦 Components Deep Dive

Frontend Components

• File Uploader: Handles file selection and upload
• File List: Displays uploaded files with metadata
• Storage Stats: Shows system usage statistics
• Theme Switcher: Manages application theme

Backend Services

• File Handler: Processes file operations
• Database Manager: Handles data persistence
• Stats Collector: Gathers system statistics

🔌 API Documentation

Endpoints

GET    /api/files       # List all files
POST   /api/upload     # Upload new file(s)
GET    /api/download   # Download a file
DELETE /api/files/:id  # Delete a file
GET    /api/stats     # Get storage statistics

🗄️ Database Schema

CREATE TABLE files (
    file_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    name TEXT NOT NULL,
    type TEXT NOT NULL,
    size BIGINT NOT NULL,
    location TEXT NOT NULL,
    uploaded_at TIMESTAMP DEFAULT NOW()
);

🛠️ Development Guide

Local Development Setup

1. Frontend Development

   cd Ashyft
   npm install
   npm run dev

2. Backend Development

   cd Backend
   go mod download
   go run main.go

3. Database Setup

   # See Postgres/file_manager.md for setup instructions

Code Style

• Frontend: ESLint + Prettier configuration
• Backend: Go standard formatting
• SQL: PostgreSQL standard style

🚀 Deployment

Production Deployment Steps

1. Update environment variables
2. Build images:

   docker-compose build

3. Deploy:

   docker-compose up -d

Server Requirements

• 1GB RAM minimum
• 10GB storage recommended
• Linux-based OS preferred

🔒 Security Considerations

1. File validation on upload
2. Size limitations
3. Secure file storage
4. Database security
5. API rate limiting (recommended)

🤝 Contributing

Contributions are welcome! Feel free to:

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Open a Pull Request

Areas for improvement:

• Mobile responsiveness
• Additional file type support
• Enhanced security features
• Performance optimizations

📝 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

👤 Author

Anshuman Pattnaik

• LinkedIn: @anshphere
• GitHub: @ANSHPG

💖 Support

If you find this project useful, please consider giving it a ⭐️ on GitHub!

---

Note: For the latest updates and detailed contribution guidelines, please visit the GitHub repository.