# Dumbass Dashboard

*Because apparently I can't just download a fucking dashboard like a normal person...*

A comprehensive project and task management application built with Go backend and React frontend, featuring task boards, timelines, file uploads, and team collaboration. Because I wanted to build my own goddamn dashboard instead of using one of the million existing solutions. ¯\_(ツ)_/¯

## Why The Fuck Did I Build This?

Look, I know there are already like 47 different project management tools out there. Trello, Asana, Monday.com, Notion, Jira, Basecamp, and probably 40 more that I can't even remember. But here's the thing - I wanted to build my own fucking dashboard because:

1. **I'm stubborn as hell** - When someone tells me "just use an existing solution," my immediate response is "fuck that, I can do it better"
2. **Learning experience** - I wanted to actually understand how this shit works under the hood instead of just clicking buttons
3. **Full control** - I don't want to deal with someone else's bugs, limitations, or "premium features" that require a credit card
4. **Customization** - I want to add features that make sense to me, not whatever some product manager thinks users want
5. **Because I can** - Sometimes the best reason is just because you can

So yeah, I spent way too much time building this when I could have just downloaded Trello and been done with it in 5 minutes. But now I have a dashboard that actually does exactly what I want it to do, and I understand every single line of code in it. That's worth something, right?

## Features (Because I Had To Build This Shit Myself)

### Backend (Go)
- **RESTful API** built with Gin framework (because Express.js is for plebs)
- **Database Models** for users, projects, tasks, and files using GORM (SQLite because I'm not dealing with PostgreSQL bullshit)
- **Authentication & Authorization** with JWT tokens and role-based access (security is important, apparently)
- **File Upload & Storage** with support for various file types (because everyone needs to upload their memes)
- **Task Management** with CRUD operations and status tracking (Kanban boards are overrated anyway)
- **Team Collaboration** with project members and permissions (because working alone is for losers)

### Frontend (React + TypeScript)
- **Modern UI** built with Material-UI components (Google's design system, not my fault it's everywhere)
- **Responsive Design** that works on desktop and mobile (mobile-first my ass)
- **Task Board (Kanban)** with drag-and-drop functionality (because clicking is too mainstream)
- **Project Management** with team collaboration features (assigning blame has never been easier)
- **Authentication Flow** with login/register pages (password security is for nerds)
- **File Management** with upload and download capabilities (because email attachments are so 2010)

## Tech Stack (The Tools I Actually Used)

### Backend
- **Go 1.22+** - Programming language (because Python is for data scientists and JavaScript is for frontend peasants)
- **Gin** - Web framework (lightweight and fast, unlike Express.js bloatware)
- **GORM** - ORM for database operations (because writing raw SQL is for masochists)
- **SQLite** - Database (because I don't want to deal with Docker containers and database servers)
- **JWT** - Authentication tokens (because sessions are so 2010)
- **CORS** - Cross-origin resource sharing (because browsers are paranoid)

### Frontend
- **React 19** - UI framework (because Vue.js is for hipsters and Angular is for enterprise drones)
- **TypeScript** - Type safety (because JavaScript errors at runtime are fun, but not when you're debugging at 2 AM)
- **Material-UI** - Component library (Google's design system, fight me)
- **React Router** - Client-side routing (because page refreshes are for cavemen)
- **Axios** - HTTP client (because fetch() API is too verbose)
- **@dnd-kit** - Drag and drop functionality (because react-beautiful-dnd doesn't work with React 19)

## Prerequisites (Because You Need These To Run My Code)

- Go 1.22 or higher (because I'm not supporting legacy versions)
- Node.js 18 or higher (npm comes with it, don't ask)
- A functioning brain (optional but recommended)

## Installation (The Fun Part)

### Backend Setup (The Go Part)

1. Navigate to the backend directory (because I organized it this way):
```bash
cd backend
```

2. Install dependencies (Go will figure out what you need):
```bash
go mod tidy
```

3. Run the server (and pray it works):
```bash
go run cmd/server/main.go
```

The backend will start on `http://localhost:8080` (unless something's already using that port, then you're fucked)

### Frontend Setup (The JavaScript Hell)

1. Navigate to the frontend directory:
```bash
cd frontend
```

2. Install dependencies (this might take a while, grab some coffee):
```bash
npm install
```

3. Start the development server (and watch the magic happen):
```bash
npm start
```

The frontend will start on `http://localhost:3000` (React will probably open it in your browser automatically)

## Usage (How To Actually Use This Thing)

### Default Admin Account (Because I'm Lazy)
- **Email**: admin@example.com
- **Password**: admin123 (yes, I know it's weak, don't judge me)

### Getting Started (The Not-So-Fun Part)

1. **Login** with the admin credentials or create a new account (because everyone loves registration forms)
2. **Create a Project** from the projects page (because apparently you need projects to manage)
3. **Add Team Members** to your project (because working alone is for introverts)
4. **Create Tasks** and organize them in the Kanban board (because sticky notes are so analog)
5. **Upload Files** and collaborate with your team (because email attachments are for boomers)

### Key Features (The Stuff That Actually Works)

#### Project Management (Because You Need Structure)
- Create and manage multiple projects (because one project is never enough)
- Assign team members with different roles (because hierarchy is important)
- Track project progress and deadlines (because deadlines are fun)

#### Task Management (The Core Functionality)
- Create tasks with priorities and due dates (because everything is urgent)
- Organize tasks in Kanban board (To Do, In Progress, Review, Done - because 4 statuses are enough)
- Assign tasks to team members (because delegation is key)
- Add comments and subtasks (because complexity is beautiful)

#### File Management (Because We're Not In 1995)
- Upload files to projects or specific tasks (because attachments are overrated)
- Download and manage uploaded files (because local storage is so last decade)
- Support for various file types (images, documents, etc. - because variety is the spice of life)

#### Team Collaboration (Because Misery Loves Company)
- Add members to projects (because the more the merrier)
- Role-based permissions (Owner, Manager, Member - because not everyone is equal)
- Real-time task updates (because waiting is for peasants)

## API Endpoints

### Authentication
- `POST /api/v1/auth/login` - User login
- `POST /api/v1/auth/register` - User registration
- `GET /api/v1/auth/profile` - Get user profile
- `PUT /api/v1/auth/profile` - Update user profile

### Projects
- `GET /api/v1/projects` - Get user's projects
- `POST /api/v1/projects` - Create new project
- `GET /api/v1/projects/:id` - Get project details
- `PUT /api/v1/projects/:id` - Update project
- `DELETE /api/v1/projects/:id` - Delete project

### Tasks
- `GET /api/v1/projects/:id/tasks` - Get project tasks
- `POST /api/v1/projects/:id/tasks` - Create new task
- `GET /api/v1/projects/:id/tasks/:taskId` - Get task details
- `PUT /api/v1/projects/:id/tasks/:taskId` - Update task
- `DELETE /api/v1/projects/:id/tasks/:taskId` - Delete task

### Files
- `POST /api/v1/projects/:id/files` - Upload file
- `GET /api/v1/projects/:id/files` - Get project files
- `GET /api/v1/projects/:id/files/:fileId` - Download file
- `DELETE /api/v1/projects/:id/files/:fileId` - Delete file

## Development

### Backend Development
```bash
# Run with hot reload (requires air)
go install github.com/cosmtrek/air@latest
air
```

### Frontend Development
```bash
# Start development server
npm start

# Build for production
npm run build
```

## Database Schema

The application uses SQLite by default with the following main entities:

- **Users** - User accounts with roles and authentication
- **Projects** - Project containers with members and settings
- **Tasks** - Individual tasks with status, priority, and assignments
- **Subtasks** - Sub-tasks that belong to parent tasks
- **Comments** - Task comments for collaboration
- **FileUploads** - File attachments for projects and tasks
- **Labels** - Custom labels for task categorization

## Configuration

### Backend Configuration
- Database connection can be modified in `models/database.go`
- JWT secret should be changed in production (middleware/auth.go)
- File upload directory is configurable in `api/files.go`

### Frontend Configuration
- API base URL can be changed in `src/services/api.ts`
- Theme customization in `src/App.tsx`

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

## Support (Good Luck With That)

For support or questions, please open an issue in the repository. But honestly, if you can't figure out how to use this thing, maybe you should just go back to using Trello. I'm not your personal tech support.

## License

This project is licensed under the MIT License. Do whatever the fuck you want with it, I don't care.

## Final Thoughts

Look, I built this thing because I wanted to, not because I had to. It's not perfect, it's not revolutionary, and it's definitely not going to replace Jira anytime soon. But it's mine, I understand it, and it does exactly what I need it to do. 

If you find it useful, great. If you think it's shit, that's fine too. I'm not trying to impress anyone - I just wanted to build my own damn dashboard instead of paying monthly fees for someone else's half-baked solution.

Now stop reading this README and go actually use the thing. Or don't. I really don't care.

---

*Built with ❤️ and a lot of caffeine by someone who refuses to use existing solutions like a normal person.*
