Skip to content
BranchesTags

Latest commit

 

History

128 Commits

Folders and files

NameName
Last commit message
Last commit date
client
client
 
 
server
server
 
 
.gitignore
.gitignore
 
 
CHAT_FEATURE_SUMMARY.md
CHAT_FEATURE_SUMMARY.md
 
 
CHAT_MODERATION_GUIDE.md
CHAT_MODERATION_GUIDE.md
 
 
CHAT_TESTING_GUIDE.md
CHAT_TESTING_GUIDE.md
 
 
EMAIL_SETUP.md
EMAIL_SETUP.md
 
 
EMAIL_VERIFICATION_GUIDE.md
EMAIL_VERIFICATION_GUIDE.md
 
 
EVENT_CHAT_DOCUMENTATION.md
EVENT_CHAT_DOCUMENTATION.md
 
 
FIX_STRIPE_KEYS.md
FIX_STRIPE_KEYS.md
 
 
NOTIFICATION_SYSTEM.md
NOTIFICATION_SYSTEM.md
 
 
QUICK_TESTING_GUIDE.md
QUICK_TESTING_GUIDE.md
 
 
README.md
README.md
 
 
RECURRING_EVENTS_API.md
RECURRING_EVENTS_API.md
 
 
RECURRING_EVENTS_CHECKLIST.md
RECURRING_EVENTS_CHECKLIST.md
 
 
RECURRING_EVENTS_COMPLETE_SUMMARY.md
RECURRING_EVENTS_COMPLETE_SUMMARY.md
 
 
RECURRING_EVENTS_FRONTEND.md
RECURRING_EVENTS_FRONTEND.md
 
 
RECURRING_EVENTS_IMPLEMENTATION.md
RECURRING_EVENTS_IMPLEMENTATION.md
 
 
RECURRING_EVENTS_SUMMARY.md
RECURRING_EVENTS_SUMMARY.md
 
 
RECURRING_EVENTS_TESTING.md
RECURRING_EVENTS_TESTING.md
 
 
REMINDER_TESTING_GUIDE.md
REMINDER_TESTING_GUIDE.md
 
 
STRIPE_KEY_MATCHING.md
STRIPE_KEY_MATCHING.md
 
 
STRIPE_SETUP.md
STRIPE_SETUP.md
 
 
package-lock.json
package-lock.json
 
 
package.json
package.json
 
 
verify-stripe-keys-match.js
verify-stripe-keys-match.js
 
 

Repository files navigation

VibeCoderz - GUC Events Management Platform

A comprehensive MERN stack web application for managing university events at the German University in Cairo (GUC). The platform facilitates event discovery, registration, payment processing, real-time communication, and administrative management for various event types including Workshops, Trips, Conferences, Bazaars, and Gym Sessions.

Motivation

The VibeCoderz platform was developed to address the challenges of event management at the German University in Cairo. Traditional methods of event organization were fragmented, making it difficult for students, staff, and faculty to discover and participate in campus activities. This project aims to:

  • Centralize Event Management: Provide a single platform for all university events, eliminating the need for multiple systems and communication channels.
  • Enhance Student Engagement: Make it easier for students to discover, register for, and participate in events that interest them.
  • Streamline Administrative Tasks: Automate registration, payment processing, attendance tracking, and notification systems to reduce manual workload.
  • Improve Communication: Enable real-time chat during events and automated email notifications for better engagement.
  • Support Multiple User Roles: Cater to the diverse needs of students, staff, professors, vendors, and administrative personnel.

This project serves as a practical implementation of modern web development practices, demonstrating full-stack development skills using the MERN (MongoDB, Express.js, React, Node.js) stack.

Build Status

⚠️ Current Status: The project is functional with some known issues and areas for improvement:

Known Issues:

  1. Payment Processing: Occasional "Payment not found" errors when confirming Stripe payments due to user ID comparison inconsistencies. This has been partially addressed but may still occur in edge cases.
  2. Email Delivery: Email notifications may fail if SMTP credentials are not properly configured in the .env file. Users should verify their email settings.
  3. Real-time Chat: Socket.io connections may drop on network interruptions. The system attempts to reconnect automatically, but manual refresh may be required in some cases.
  4. QR Code Scanning: Camera permissions are required for QR code scanning. Some browsers may block camera access, requiring manual permission grants.
  5. Recurring Events: When creating recurring events, duplicate date generation may occur if the start date falls on the selected day of week. This has been mitigated but edge cases may still exist.
  6. Event Status Display: Events with multi-day durations may show incorrect status if the current date falls between start and end dates. The logic has been updated but requires thorough testing.
  7. Waitlist Auto-registration: Email notifications for waitlist promotions may be delayed if the email service is experiencing high load.

Future Improvements:

  • Implement comprehensive error logging and monitoring
  • Add automated testing suite for critical user flows
  • Optimize database queries for better performance
  • Enhance mobile responsiveness for all components
  • Add support for event cancellation and refund processing
  • Implement advanced search and filtering capabilities

Note: There is no such thing as a perfect project. These issues are documented to help developers understand current limitations and contribute to improvements.

Code Style

This project follows consistent coding conventions to maintain readability and collaboration:

Naming Conventions:

  • Variables and Functions: camelCase (e.g., getUserById, registrationId)
  • Components: PascalCase (e.g., EventCard, RegistrationModal)
  • Constants: UPPER_SNAKE_CASE (e.g., JWT_SECRET, MAX_FILE_SIZE)
  • Files: camelCase for JavaScript files (e.g., authController.js, paymentService.js)
  • CSS Classes: kebab-case (e.g., event-card, registration-modal)

Code Structure:

  • Backend Controllers: Each controller handles a specific domain (auth, payments, registrations, etc.)
  • Frontend Components: Organized by feature (events, payments, facilities, etc.)
  • Services: Reusable business logic separated from UI components
  • Models: Mongoose schemas with clear field definitions and validation

Best Practices:

  • Use const for variables that don't change, let for variables that do
  • Prefer arrow functions for callbacks and short functions
  • Use async/await for asynchronous operations instead of callbacks
  • Implement proper error handling with try-catch blocks
  • Validate user input using Joi schemas on the backend
  • Use environment variables for sensitive configuration
  • Follow RESTful API conventions for route naming

Example:

// Good: camelCase for variables, clear naming
const getUserRegistrations = async (userId) => {
  try {
    const registrations = await Registration.find({ user: userId });
    return registrations;
  } catch (error) {
    console.error('Error fetching registrations:', error);
    throw error;
  }
};

Screenshots

The following screenshots demonstrate the key features and user interfaces of the VibeCoderz platform:

Screenshot 1: Landing Page Landing Page

The landing page provides an introduction to the platform with navigation to key features and user authentication options.

Screenshot 2: Event Discovery Event Discovery

Users can browse and discover all available events (Workshops, Trips, Conferences, Bazaars) with filtering and search capabilities.

Screenshot 3: Registration Modal Registration Modal

The registration modal allows users to register for events with conflict detection and capacity management.

Screenshot 4: Payment Interface Payment Interface

Secure payment processing interface supporting both Stripe credit card payments and wallet-based payments.

Screenshot 5: Admin Dashboard Admin Dashboard

Comprehensive admin dashboard for managing users, events, registrations, and system-wide operations.

Screenshot 6: Real-time Event Chat Event Chat

Real-time chat interface that activates during active events, allowing registered participants to communicate.

Tech/Framework Used

Backend Technologies:

  • Node.js: JavaScript runtime environment
  • Express.js: Web application framework for Node.js
  • MongoDB: NoSQL database for data storage
  • Mongoose: MongoDB object modeling for Node.js
  • JWT (JSON Web Tokens): Authentication and authorization
  • Stripe: Payment processing API
  • Socket.io: Real-time bidirectional event-based communication
  • Nodemailer: Email sending service
  • Joi: Schema validation library
  • bcryptjs: Password hashing
  • QRCode: QR code generation library

Frontend Technologies:

  • React: JavaScript library for building user interfaces
  • React Router DOM: Declarative routing for React
  • Axios: HTTP client for API requests
  • Stripe React: Stripe integration for React
  • Socket.io Client: Client-side WebSocket library
  • HTML5 QR Code: QR code scanning library
  • CSS3: Styling with modern CSS features (Grid, Flexbox, Animations)

Development Tools:

  • npm: Package manager
  • Nodemon: Development server auto-reload
  • Jest: Testing framework (configured but not extensively used)
  • Postman: API testing tool

Deployment & Infrastructure:

  • MongoDB Atlas: Cloud database hosting (or local MongoDB)
  • Environment Variables: Configuration management via .env files

Features

User Authentication & Authorization

  • User registration with email verification
  • Role-based access control (Student, Staff, TA, Professor, Vendor, Events Office, Admin)
  • JWT-based authentication
  • Profile management

Event Management

  • Workshop Management: Professors can create, edit, and manage workshops. Events Office can approve/reject workshop requests
  • Trip Management: Events Office can create and manage trips
  • Conference Management: Create and manage academic conferences
  • Bazaar Management: Organize vendor bazaars with booth assignments
  • Gym Session Management: Create and manage gym sessions (Yoga, Pilates, etc.)
  • Recurring Events: Create weekly recurring workshops and gym sessions

Event Discovery & Registration

  • Browse all upcoming events with filtering and search
  • Event details with full descriptions, schedules, and requirements
  • Registration system with capacity management
  • Waitlist system with automatic promotion when spots become available
  • Schedule conflict detection to prevent double-booking

Payment Processing

  • Stripe integration for credit card payments
  • Wallet-based payments using in-app balance
  • Payment receipts sent via email
  • Payment history tracking
  • Vendor payment processing for bazaar/booth participation

QR Code Attendance System

  • Unique QR codes generated for workshop registrations
  • QR codes sent via email after payment completion
  • QR code scanning interface for Professors/TAs
  • Automatic attendance tracking
  • Certificate generation for attended workshops

Real-time Communication

  • Event chat system that activates when events start
  • Real-time messaging using Socket.io
  • Chat moderation tools for Events Office and Admins
  • Multiple active chats support

Notification System

  • Email notifications for:
    • Registration confirmations
    • Payment receipts
    • Event reminders (1 day and 1 hour before)
    • Waitlist promotions
    • Workshop certificates
    • QR code delivery
  • In-app notifications for system updates

Administrative Features

  • Events Office Dashboard: Manage all events, approve/reject requests, view registrations
  • Admin Dashboard: Full system access, user management, analytics
  • Vendor Dashboard: Manage bazaar/booth requests, view payments
  • Professor Dashboard: Manage workshops, view participants, scan QR codes
  • Event archiving and deletion
  • Export functionality for reports

Additional Features

  • Favorite events system
  • Event rating system (for attended events)
  • Loyalty program integration
  • Court reservation system (for sports facilities)
  • Poll system for vendors
  • Email logging and tracking

Code Examples

Example 1: User Registration with Validation

// server/controllers/authController.js
const signup = async (req, res) => {
  try {
    const { error, value } = signupSchema.validate(req.body);
    if (error) {
      return res.status(400).json({ error: error.details[0].message });
    }

    const { email, password, firstName, lastName, id, role, companyName } = value;

    // Check if user already exists
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ error: 'User already exists' });
    }

    // Hash password
    const hashedPassword = await bcrypt.hash(password, 10);

    // Create user
    const user = new User({
      email,
      password: hashedPassword,
      firstName,
      lastName,
      id,
      role,
      verified: false,
      ...(role === 'vendor' && { companyName })
    });

    await user.save();

    // Generate verification token and send email
    const token = jwt.sign({ userId: user._id }, process.env.JWT_SECRET, { expiresIn: '24h' });
    // ... email sending logic

    res.status(201).json({ message: 'User created. Please verify your email.' });
  } catch (err) {
    console.error('Signup error:', err);
    res.status(500).json({ error: 'Server error' });
  }
};

Example 2: Event Registration with Conflict Detection

// server/controllers/registrationController.js
const registerForEvent = async (req, res) => {
  try {
    const { eventType, eventId } = req.body;
    const userId = req.user.id;

    // Check for schedule conflicts
    const hasConflict = await checkScheduleConflict(userId, eventType, eventId);
    if (hasConflict) {
      return res.status(409).json({ 
        error: 'Schedule conflict detected. You have another event at this time.' 
      });
    }

    // Get event and check capacity
    const event = await getEventByType(eventType, eventId);
    if (event.currentRegistrations >= event.capacity) {
      // Add to waitlist
      const waitlist = new Waitlist({ user: userId, eventType, eventId });
      await waitlist.save();
      return res.status(200).json({ message: 'Added to waitlist', waitlist });
    }

    // Create registration
    const registration = new Registration({
      user: userId,
      eventType,
      eventId,
      status: 'registered'
    });
    await registration.save();

    // Update event capacity
    event.currentRegistrations += 1;
    await event.save();

    res.status(201).json({ message: 'Registration successful', registration });
  } catch (err) {
    console.error('Register error:', err);
    res.status(500).json({ error: 'Server error' });
  }
};

Example 3: Stripe Payment Intent Creation

// server/controllers/paymentController.js
const createStripePaymentIntent = async (req, res) => {
  try {
    const { registrationId, eventType, eventId, amount } = req.body;

    // Validate registration ownership
    const registration = await Registration.findById(registrationId);
    if (!registration || registration.user.toString() !== req.user.id) {
      return res.status(404).json({ error: 'Registration not found' });
    }

    // Check for existing payment
    const existingPayment = await Payment.findOne({
      registration: registrationId,
      status: 'completed'
    });
    if (existingPayment) {
      return res.status(400).json({ error: 'Payment already completed' });
    }

    // Create payment record
    const payment = new Payment({
      user: req.user.id,
      registration: registrationId,
      eventType,
      eventId,
      amount,
      paymentMethod: 'stripe',
      status: 'pending'
    });
    await payment.save();

    // Create Stripe payment intent
    const paymentIntent = await stripe.paymentIntents.create({
      amount: Math.round(amount * 100), // Convert to cents
      currency: 'egp',
      metadata: {
        paymentId: payment._id.toString(),
        registrationId: registrationId.toString()
      }
    });

    payment.stripePaymentIntentId = paymentIntent.id;
    await payment.save();

    res.json({
      clientSecret: paymentIntent.client_secret,
      paymentId: payment._id
    });
  } catch (err) {
    console.error('Create payment intent error:', err);
    res.status(500).json({ error: 'Failed to create payment intent' });
  }
};

Example 4: Real-time Chat Message Handling

// server/controllers/chatController.js
exports.initializeSocketHandlers = (io) => {
  io.on('connection', (socket) => {
    socket.on('join-chat', async ({ eventType, eventId, token }) => {
      try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        const user = await User.findById(decoded.userId);
        
        // Verify registration or moderator status
        const isModerator = user.role === 'events_office' || user.role === 'admin';
        if (!isModerator) {
          const registration = await Registration.findOne({
            user: decoded.userId,
            eventType,
            eventId,
            status: 'registered'
          });
          if (!registration) {
            socket.emit('error', { message: 'Not registered for this event' });
            return;
          }
        }

        const roomId = `${eventType}-${eventId}`;
        socket.join(roomId);
        socket.emit('joined-chat', { roomId });
      } catch (error) {
        socket.emit('error', { message: 'Failed to join chat' });
      }
    });

    socket.on('send-message', async ({ eventType, eventId, text }) => {
      const chat = await EventChat.findOne({ eventType, eventId });
      if (!chat || !chat.isActive) {
        socket.emit('error', { message: 'Chat is closed' });
        return;
      }

      const message = {
        user: socket.userId,
        userName: socket.userName,
        text: text.trim(),
        timestamp: new Date()
      };

      chat.messages.push(message);
      await chat.save();

      const roomId = `${eventType}-${eventId}`;
      io.to(roomId).emit('new-message', message);
    });
  });
};

Example 5: QR Code Generation and Email Sending

// server/utils/qrCodeService.js
const generateQRCodeAsBuffer = async (registration, eventType, eventName) => {
  try {
    let qrData;
    if (registration.qrToken && eventType === 'workshop') {
      qrData = JSON.stringify({
        type: 'attendance',
        token: registration.qrToken,
        registrationId: registration._id.toString(),
        eventType: eventType,
        eventName: eventName
      });
    }

    const qrCodeBuffer = await QRCode.toBuffer(qrData, {
      errorCorrectionLevel: 'M',
      type: 'image/png',
      width: 300
    });
    return qrCodeBuffer;
  } catch (error) {
    console.error('Error generating QR code:', error);
    throw error;
  }
};

// Usage in payment controller after payment confirmation
const qrCodeBuffer = await generateQRCodeAsBuffer(registration, 'workshop', workshop.name);
await sendEmailToUser(
  user,
  'attendance_qr',
  `Attendance QR - ${workshop.name}`,
  emailHtml,
  { registrationId, eventId, paymentId },
  [{
    filename: 'attendance-qr-code.png',
    content: qrCodeBuffer,
    cid: 'qrcode'
  }]
);

Installation

Prerequisites

Before installing the project, ensure you have the following software installed:

Step-by-Step Installation

  1. Clone the Repository

    git clone https://github.com/Advanced-Computer-Lab-2025/VibeCoderz.git
cd VibeCoderz

  2. Install Dependencies

    Install all dependencies (root, server, and client) using:

    npm run install:all

    If you encounter errors, install manually:

    # Install root dependencies
npm install

# Install server dependencies
cd server
npm install

# Install client dependencies
cd ../client
npm install

  3. Configure Environment Variables

    Create a .env file in the server directory:

    # Server Configuration
PORT=5001
NODE_ENV=development

# Database Configuration
MONGODB_URI=mongodb://localhost:27017/guc-events
# OR for MongoDB Atlas:
# MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/guc-events

# JWT Secret (use a strong random string)
JWT_SECRET=yourSuperSecretKeyHere

# Stripe Configuration (get from https://dashboard.stripe.com/test/apikeys)
STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
STRIPE_PUBLISHABLE_KEY=pk_test_your_stripe_publishable_key

# Email Configuration (Gmail example)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your_email@gmail.com
SMTP_PASS=your_app_password
SMTP_FROM=your_email@gmail.com

  4. Set Up MongoDB

    • Local MongoDB: Ensure MongoDB is running on your machine
    • MongoDB Atlas: Create a cluster and get your connection string
    • Update MONGODB_URI in the .env file

  5. Configure Stripe (for payment processing)

  6. Configure Email Service (for notifications)

    • For Gmail: Enable "Less secure app access" or use an App Password
    • Update SMTP credentials in the .env file

  7. Start the Server

    cd server
npm start
# Or for development with auto-reload:
npm run dev

    The server will run on http://localhost:5001

  8. Start the Client

    cd client
npm start

    The client will run on http://localhost:3000 and automatically open in your browser

Troubleshooting

  • Port Already in Use: Change PORT in server .env or kill the process using the port
  • MongoDB Connection Error: Verify your MONGODB_URI is correct and MongoDB is running
  • Stripe Errors: Ensure your Stripe keys are valid and in test mode
  • Email Not Sending: Check SMTP credentials and firewall settings
  • Module Not Found: Run npm install in the respective directory (server or client)

API References

All API endpoints are prefixed with /api. Most endpoints require authentication via JWT token in the Authorization header: Bearer <token>

1. Authentication Routes

Base URL: /api/auth

POST /api/auth/signup

Register a new user account.

Request Body:

{
  "firstName": "Ahmed",
  "lastName": "Ali",
  "email": "ahmed@guc.edu.eg",
  "password": "password123",
  "id": "46-1234",
  "role": "student"
}

Response:

{
  "message": "User created. Please verify your email."
}

POST /api/auth/login

Authenticate user and receive JWT token.

Request Body:

{
  "email": "ahmed@guc.edu.eg",
  "password": "password123"
}

Response:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "user": {
    "id": "user_id",
    "email": "ahmed@guc.edu.eg",
    "role": "student"
  }
}

2. Event Routes

Base URL: /api/events

GET /api/events

Get all upcoming events (public endpoint, optionally authenticated).

Query Parameters:

  • search: Search term for event names/descriptions
  • type: Filter by event type (workshop, trip, conference, bazaar)

Response:

{
  "count": 10,
  "events": [
    {
      "eventType": "workshop",
      "id": "event_id",
      "name": "Python Workshop",
      "startDate": "2025-01-20T10:00:00Z",
      "location": "GUC Cairo"
    }
  ]
}

3. Registration Routes

Base URL: /api/registrations

POST /api/registrations

Register for an event (requires authentication, student/staff/ta/professor roles).

Request Body:

{
  "eventType": "workshop",
  "eventId": "workshop_id"
}

Response:

{
  "message": "Registration successful",
  "registration": {
    "_id": "registration_id",
    "user": "user_id",
    "eventType": "workshop",
    "eventId": "workshop_id",
    "status": "registered"
  }
}

GET /api/registrations/my

Get all registrations for the current user.

Response:

{
  "registrations": [
    {
      "_id": "registration_id",
      "event": {
        "title": "Python Workshop",
        "date": "2025-01-20",
        "type": "workshop"
      },
      "status": "registered"
    }
  ]
}

POST /api/registrations/scan

Scan QR code for attendance (requires professor/ta role).

Request Body:

{
  "qrData": "{\"type\":\"attendance\",\"token\":\"abc123\",\"registrationId\":\"reg_id\"}"
}

Response:

{
  "message": "Attendance recorded",
  "registration": {
    "status": "attended",
    "attendedAt": "2025-01-20T10:30:00Z"
  },
  "stats": {
    "registeredCount": 25,
    "attendedCount": 20
  }
}

4. Payment Routes

Base URL: /api/payments

GET /api/payments/pending

Get pending payments for the current user.

Response:

{
  "pendingPayments": [
    {
      "paymentId": "payment_id",
      "registrationId": "registration_id",
      "eventName": "Python Workshop",
      "amount": 100,
      "eventType": "workshop"
    }
  ]
}

POST /api/payments/stripe/create-intent

Create a Stripe payment intent.

Request Body:

{
  "registrationId": "registration_id",
  "eventType": "workshop",
  "eventId": "event_id",
  "amount": 100
}

Response:

{
  "clientSecret": "pi_xxx_secret_xxx",
  "paymentId": "payment_id"
}

POST /api/payments/stripe/confirm

Confirm a completed Stripe payment.

Request Body:

{
  "paymentId": "payment_id",
  "paymentIntentId": "pi_xxx"
}

Response:

{
  "message": "Payment confirmed",
  "payment": {
    "status": "completed",
    "paidAt": "2025-01-20T10:00:00Z"
  }
}

POST /api/payments/wallet

Pay using wallet balance.

Request Body:

{
  "registrationId": "registration_id",
  "eventType": "workshop",
  "eventId": "event_id",
  "amount": 100
}

Response:

{
  "message": "Payment successful",
  "payment": {
    "status": "completed",
    "transactionId": "WALLET-xxx"
  }
}

5. Workshop Routes

Base URL: /api/workshops

POST /api/workshops

Create a new workshop (requires professor role).

Request Body:

{
  "name": "Advanced Python",
  "location": "GUC Cairo",
  "startAt": "2025-01-20T14:00:00Z",
  "endAt": "2025-01-20T16:00:00Z",
  "shortDescription": "Learn advanced Python concepts",
  "fullAgenda": "Decorators, async programming, etc.",
  "faculty": "Engineering",
  "professors": ["Dr. Ahmed"],
  "requiredBudget": 1000,
  "fundingSource": "GUC",
  "capacity": 30,
  "registrationDeadline": "2025-01-18T23:59:59Z"
}

Response:

{
  "message": "Workshop created successfully",
  "workshop": {
    "_id": "workshop_id",
    "name": "Advanced Python",
    "status": "pending"
  }
}

POST /api/workshops/recurring

Create recurring weekly workshops.

Request Body:

{
  "name": "Weekly Python Lab",
  "startDate": "2025-01-20",
  "endDate": "2025-04-30",
  "dayOfWeek": "Friday",
  "startTime": "14:00",
  "endTime": "16:00",
  "capacity": 30,
  // ... other workshop fields
}

Response:

{
  "status": "success",
  "data": {
    "recurringEvent": {
      "totalOccurrences": 13,
      "workshops": [/* array of created workshops */]
    }
  }
}

Tests

Testing for this project is primarily done using Postman for API endpoint testing. Below are examples of test cases that should be performed:

Test 1: User Registration

Endpoint: POST /api/auth/signup Test Case: Register a new student user

  • Expected Status: 201 Created
  • Expected Response: Success message with email verification requirement
  • Postman Screenshot: Should show successful registration response

Test 2: User Login

Endpoint: POST /api/auth/login Test Case: Login with valid credentials

  • Expected Status: 200 OK
  • Expected Response: JWT token and user object
  • Postman Screenshot: Should show token in response

Test 3: Event Registration

Endpoint: POST /api/registrations Test Case: Register for an available workshop

  • Headers: Authorization: Bearer <token>
  • Expected Status: 201 Created
  • Expected Response: Registration object with status "registered"
  • Postman Screenshot: Should show successful registration

Test 4: Payment Intent Creation

Endpoint: POST /api/payments/stripe/create-intent Test Case: Create payment intent for a registered event

  • Headers: Authorization: Bearer <token>
  • Expected Status: 200 OK
  • Expected Response: clientSecret and paymentId
  • Postman Screenshot: Should show payment intent details

Test 5: Get Pending Payments

Endpoint: GET /api/payments/pending Test Case: Retrieve all pending payments for authenticated user

  • Headers: Authorization: Bearer <token>
  • Expected Status: 200 OK
  • Expected Response: Array of pending payment objects
  • Postman Screenshot: Should show list of pending payments

Test 6: QR Code Scanning

Endpoint: POST /api/registrations/scan Test Case: Scan QR code for attendance (professor/TA role)

  • Headers: Authorization: Bearer <token>
  • Expected Status: 200 OK
  • Expected Response: Updated registration with "attended" status
  • Postman Screenshot: Should show attendance confirmation

Additional Test Scenarios:

  • Conflict Detection: Register for two events at the same time
  • Waitlist: Register when event is full, then cancel to test auto-promotion
  • Recurring Events: Create recurring workshop and verify all occurrences
  • Chat Activation: Verify chat activates when event starts
  • Email Notifications: Verify emails are sent for various events

Note: Postman collection should be exported and included in the project repository for easy testing. Screenshots of successful test runs should be documented.

Contribute

We welcome contributions to improve the VibeCoderz platform! The project is not perfect, and there are many areas where community contributions can make a significant impact.

How to Contribute

  1. Fork the Repository

    • Click the "Fork" button on the GitHub repository page
    • Clone your forked repository to your local machine

  2. Create a Feature Branch

    git checkout -b feature/your-feature-name

  3. Make Your Changes

    • Follow the code style guidelines mentioned in the "Code Style" section
    • Write clear commit messages
    • Add comments for complex logic
    • Test your changes thoroughly

  4. Test Your Changes

    • Test all affected functionality
    • Ensure no existing features are broken
    • Test edge cases and error scenarios

  5. Submit a Pull Request

    • Push your changes to your forked repository
    • Create a pull request with a clear description of your changes
    • Reference any related issues

Areas for Contribution

  • Bug Fixes: Help fix known issues listed in the "Build Status" section
  • Testing: Add comprehensive test coverage using Jest or Postman
  • Documentation: Improve README, add code comments, create user guides
  • Performance: Optimize database queries, improve frontend rendering
  • Features: Implement new features from the roadmap
  • UI/UX: Improve user interface and user experience
  • Security: Identify and fix security vulnerabilities
  • Accessibility: Improve accessibility for users with disabilities

Code Review Process

  • All pull requests will be reviewed by maintainers
  • Feedback will be provided for improvements
  • Once approved, changes will be merged into the main branch

Reporting Issues

If you find a bug or have a suggestion:

  1. Check if the issue already exists
  2. Create a new issue with a clear title and description
  3. Include steps to reproduce the issue
  4. Add relevant screenshots or error messages

Credits

This project was developed as part of the Advanced Computer Lab course at the German University in Cairo. We would like to acknowledge the following resources and inspirations:

Technologies & Libraries

Tutorials & Learning Resources

  • Node.js Best Practices: Various online tutorials on Node.js and Express.js
  • React Hooks Tutorial: React official documentation and community tutorials
  • JWT Authentication: Multiple online resources on implementing JWT authentication
  • MongoDB University: Free MongoDB courses for database design

Open Source Projects

  • Similar Event Management Systems: Inspiration from various open-source event management platforms
  • Community Forums: Stack Overflow, Reddit, and GitHub discussions for problem-solving

YouTube Videos & Channels

  • MERN Stack Tutorials: Various YouTube channels providing MERN stack development tutorials
  • React Tutorials: React.js tutorial series for component development
  • Node.js Tutorials: Node.js and Express.js tutorial videos
  • Stripe Integration: Tutorials on integrating Stripe payment processing

Team Members

  • VibeCoderz Team: All team members who contributed to the development of this project

Note: While we have learned from various resources, all code in this repository is original work developed by the VibeCoderz team. We are grateful to the open-source community for providing excellent documentation and learning resources.

License

This project uses the Apache License 2.0 due to the integration of Stripe payment processing, which requires Apache 2.0 license compatibility.

Apache License 2.0

Copyright 2025 VibeCoderz Team

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Third-Party Licenses

  • Stripe: Apache License 2.0 - https://stripe.com/legal
  • React: MIT License
  • Express.js: MIT License
  • MongoDB: Server Side Public License (SSPL)
  • Socket.io: MIT License

For full license information of all dependencies, please refer to the package.json files in the server and client directories, or run npm list --depth=0 to view all installed packages and their licenses.

Additional Information

Project Structure

VibeCoderz/
├── client/                 # React frontend application
│   ├── src/
│   │   ├── components/    # React components
│   │   ├── pages/         # Page components
│   │   ├── services/      # API service functions
│   │   └── styles/        # CSS stylesheets
│   └── package.json
├── server/                 # Node.js backend application
│   ├── controllers/        # Route controllers
│   ├── models/            # Mongoose schemas
│   ├── routes/             # API routes
│   ├── middleware/         # Custom middleware
│   ├── utils/              # Utility functions
│   └── package.json
└── README.md

Support

For questions, issues, or contributions, please:

  • Open an issue on GitHub
  • Contact the development team
  • Refer to the documentation files in the repository

Last Updated: January 2025 Version: 1.0.0 Status: Active Development

About

No description, website, or topics provided.

Resources

Readme
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages