🧮 Event Manager Pro

Advanced Event Management System with Data Structures & Algorithms

A sophisticated, full-stack event management application showcasing real-world implementations of fundamental computer science concepts. Built with modern web technologies and optimized for performance, scalability, and offline functionality.

🌟 Features

Core Functionality

📅 Smart Event Management - Create, edit, and organize events with intelligent categorization
⏰ Priority-Based Reminders - Advanced notification system using priority queues
🔍 Intelligent Search - Fast event discovery with binary search optimization
📊 Real-time Analytics - Dynamic statistics with efficient data aggregation
🏷️ Category Management - Flexible event organization with color-coded categories
🔄 Recurring Events - Support for daily, weekly, monthly, and yearly patterns

Advanced Features

🌐 Progressive Web App (PWA) - Install on any device, works like a native app
📱 Offline-First Design - Full functionality without internet connection
🔄 Background Sync - Automatic data synchronization when connection is restored
⚡ Real-time Updates - Live data synchronization across all devices
🛡️ Robust Error Handling - Self-healing application with comprehensive error boundaries
🎨 Responsive Design - Optimized for desktop, tablet, and mobile devices

🧮 Data Structures & Algorithms Showcase

This application demonstrates practical implementations of fundamental CS concepts:

1. Priority Queue (Min-Heap) 🏆

Implementation: convex/events.ts - PriorityQueue class
Use Case: Event reminder scheduling and notification prioritization
Complexity: Insert O(log n), Extract-Min O(log n)
Real-World Impact: Ensures critical reminders are processed first

// Priority Queue ensures high-priority events get immediate attention
class PriorityQueue {
  private heap: Array<{ priority: number; data: any }> = [];
  
  enqueue(priority: number, data: any): void {
    this.heap.push({ priority, data });
    this.heapifyUp(this.heap.length - 1);
  }
  
  dequeue(): any {
    if (this.heap.length === 0) return null;
    const min = this.heap[0];
    this.heap[0] = this.heap[this.heap.length - 1];
    this.heap.pop();
    if (this.heap.length > 0) this.heapifyDown(0);
    return min.data;
  }
}

2. Merge Sort 📈

Implementation: convex/events.ts - mergeSort function
Use Case: Efficient event list sorting by date, priority, or title
Complexity: Time O(n log n), Space O(n)
Real-World Impact: Consistent performance regardless of data order

3. Binary Search 🔍

Implementation: convex/events.ts - searchEvents query
Use Case: Fast event lookup in sorted collections
Complexity: Time O(log n), Space O(1)
Real-World Impact: Instant search results in large datasets

4. Hash Tables (Records/Maps) 🗂️

Implementation: convex/events.ts - categoryCounts mapping
Use Case: Category statistics and fast lookups
Complexity: Insert/Lookup O(1) average case
Real-World Impact: Real-time analytics dashboard

5. Queue (FIFO) 📋

Implementation: convex/reminders.ts - processReminders
Use Case: Background job processing and notification queue
Complexity: Enqueue/Dequeue O(1)
Real-World Impact: Ordered notification processing

6. Database Indexing (B-Trees) 🌳

Implementation: convex/schema.ts - table indexes
Use Case: Fast database queries and filtering
Complexity: Query O(log n) with index vs O(n) without
Real-World Impact: Sub-second response times for complex queries

🚀 Getting Started

Prerequisites

Node.js 18+
npm or yarn
Git

Installation

Clone the repository

git clone https://github.com/yourusername/event-manager-pro.git
cd event-manager-pro

Install dependencies
```
npm install
```
Set up Convex backend
```
npx convex dev
```
Start the development server
```
npm run dev
```
Open your browser Navigate to http://localhost:5173

Production Deployment

Deploy to Vercel

npm run build
npx vercel --prod

Deploy to Netlify

npm run build
# Upload dist/ folder to Netlify

Self-Hosted

npm run build
# Serve dist/ folder with any static file server

📱 PWA Installation

Desktop (Chrome/Edge)

Visit the deployed application
Click the install icon in the address bar
Follow the installation prompts

Mobile (iOS/Android)

Open the app in your mobile browser
Tap "Add to Home Screen" or "Install App"
The app will appear on your home screen

Offline Usage

All core features work offline
Events created offline sync automatically when connection is restored
Cached data ensures fast loading even without internet

🏗️ Architecture

Frontend Stack

React 18 - Modern UI library with concurrent features
TypeScript - Type-safe development
Tailwind CSS - Utility-first styling
Vite - Fast build tool and dev server

Backend Stack

Convex - Real-time database with built-in functions
Convex Auth - Secure authentication system
Cron Jobs - Automated background processing

Data Flow

User Interface → React Components → Convex Queries/Mutations → Database
                     ↓
IndexedDB (Offline) → Service Worker → Background Sync

📊 Performance Metrics

Lighthouse Scores

Performance: 95+
Accessibility: 100
Best Practices: 100
SEO: 100
PWA: 100

Key Performance Features

First Contentful Paint: < 1.5s
Largest Contentful Paint: < 2.5s
Time to Interactive: < 3.5s
Cumulative Layout Shift: < 0.1

🛠️ Development

Project Structure

event-manager-pro/
├── convex/                 # Backend functions and schema
│   ├── events.ts          # Event management with DSA implementations
│   ├── reminders.ts       # Priority queue for notifications
│   ├── categories.ts      # Category management
│   ├── schema.ts          # Database schema with indexes
│   └── crons.ts           # Background job scheduling
├── src/
│   ├── components/        # React components
│   ├── hooks/            # Custom React hooks
│   └── lib/              # Utility functions
├── public/               # Static assets and PWA files
└── README.md            # This file

Key Files Explained

`convex/events.ts`

Contains the core DSA implementations:

Priority Queue class for reminder scheduling
Merge Sort implementation for event sorting
Binary search integration with Convex indexes

`convex/schema.ts`

Defines the database structure with optimized indexes:

B-tree indexes for fast queries
Search indexes for full-text search
Composite indexes for complex filtering

`src/hooks/useOfflineStorage.ts`

Implements offline functionality:

IndexedDB for local data storage
Background sync for data synchronization
Queue management for offline operations

Running Tests

npm run test

Building for Production

npm run build

Analyzing Bundle Size

npm run analyze

🔧 Configuration

Environment Variables

Create a .env.local file:

CONVEX_DEPLOYMENT=your-deployment-name
VITE_CONVEX_URL=https://your-deployment.convex.cloud

PWA Configuration

Customize PWA settings in public/manifest.json:

App name and description
Icons and theme colors
Display mode and orientation

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Workflow

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Code Style

Use TypeScript for all new code
Follow the existing code formatting
Add comments for complex DSA implementations
Include tests for new features

📈 Roadmap

Version 2.0

Graph Algorithms - Event dependency tracking
Trie Data Structure - Advanced search autocomplete
Bloom Filters - Duplicate event detection
LRU Cache - Optimized data caching

Version 2.1

Machine Learning - Smart event suggestions
WebRTC - Real-time collaboration
Push Notifications - Native mobile notifications

🐛 Troubleshooting

Common Issues

App won't install as PWA

Ensure HTTPS is enabled
Check that manifest.json is properly configured
Verify service worker is registered

Offline sync not working

Check IndexedDB browser support
Ensure service worker is active
Verify network connectivity detection

Performance issues

Check if indexes are properly configured
Monitor heap usage in DevTools
Verify efficient query patterns

Getting Help

📖 Check the Documentation
🐛 Report bugs in Issues

📄 License

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

🙏 Acknowledgments

Convex Team - For the amazing real-time database platform
React Team - For the powerful UI library
Computer Science Community - For the fundamental algorithms and data structures
Open Source Contributors - For inspiration and code examples

📞 Contact

Author: Biplav Barua
Email: baruabiplav16@yahoo.com
LinkedIn: Biplav Barua
X/Twitter: @thatsbiplav

Built with ❤️ and advanced Computer Science concepts

🌟 Star this repo • 🐛 Report Bug • ✨ Request Feature

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
.cursor/rules		.cursor/rules
convex		convex
public		public
src		src
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
INSTALLATION.md		INSTALLATION.md
LICENSE		LICENSE
README.md		README.md
components.json		components.json
eslint.config.js		eslint.config.js
index.html		index.html
package.json		package.json
postcss.config.cjs		postcss.config.cjs
setup.mjs		setup.mjs
tailwind.config.js		tailwind.config.js
tsconfig.app.json		tsconfig.app.json
tsconfig.json		tsconfig.json
tsconfig.node.json		tsconfig.node.json
vite.config.ts		vite.config.ts

License

biplavbarua/EventReminder_DSA

Folders and files

Latest commit

History

Repository files navigation