Rollcall Event 🎯

A comprehensive event management system for real-time participant check-in, oversight, and safe execution of corporate trips and events.

Rollcall Event is a full-stack event management platform designed to give organizers complete visibility into participant presence, location, and activity status throughout an event lifecycle. Know who is present, who is missing, and what is happening – at all times.

---

📋 Table of Contents

• Concept
• Features
• Screenshots
• Tech Stack
• Documentation
• Architecture
• Project Structure
• Getting Started
• Running the Application
• Testing
• AI Usage
• Known Issues
• Contributing

---

Concept

Managing participant flow during corporate trips involves more than just registration lists. Organizers need live insight into arrivals, movements between locations, parallel activities, and deviations from the plan.

Rollcall Event is designed to support this by combining:

• Fast and flexible check-in - Multiple methods for quick participant verification
• Real-time status tracking - Live presence updates across all locations
• Clear operational dashboards - Comprehensive organizer oversight
• Simple incident handling - Fast handling of emergencies

The system aims to reduce manual coordination, improve safety, and give organizers confidence throughout the event lifecycle.

---

✨ Features

Current Features

• ✅ Multiple check-in methods (self and manual fallback)
• ✅ Live overview of participants across locations and activities
• ✅ Quick access to participant information (contact, special needs)
• ✅ Messaging system for schedule changes and updates
• ✅ Shared, up-to-date event schedule
• ✅ Missing participant detection and alerts
• ✅ User authentication and authorization
• ✅ Responsive design for mobile and desktop
• ✅ Real-time chat functionality between organizers and participants

---

🖥️ Screenshots

Authentication

User login with email/password and OAuth options (Google, Microsoft, Apple)

Main Application

Invitations dashboard with sidebar navigation

---

👾 Tech Stack

Backend

• .NET 10 - Modern C# framework
• C# - Primary backend language
• Entity Framework Core - ORM for database access
• PostgreSQL - Relational database
• ASP.NET Core - Web API framework
• Clerk - Authentication and user management

Frontend

• React Native Expo - Cross-platform mobile framework
• TypeScript - Type-safe JavaScript
• Playwright - End-to-end testing
• Jest - Unit testing

Development Tools

• Node.js - JavaScript runtime for frontend
• Node Package Manager (NPM) - Package manager
• ESLint - Code linting

---

🚀 Getting Started

Prerequisites

• Clerk Application for authentication
• .NET 10 SDK or higher
• Node.js 18 or higher
• npm or yarn
• PostgreSQL 14 or higher
• Visual Studio 2022 or Visual Studio Code with C# extension

⚠️ Environment Variables

• Environment variables needs to be configured to test the application.
• Files to be configured are application.development.json and .env.

Backend (appsettings.development.json in /backend)

{
  "ConnectionStrings": {
    "DefaultConnection": "{CONNECTION STRING}"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

Frontend (.env in /frontend)

EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY=
EXPO_PUBLIC_API_BASE_URL=

Installation

1. Clone the repository

   git clone <repository-url>
   cd rollcall-event

2. Backend Setup

   cd backend
   dotnet restore
   dotnet ef database update

3. Frontend Setup

   cd frontend
   npm install

---

▶️ Running the Application

Backend (Terminal 1)

cd backend
dotnet run

The API will be available at http://localhost:5118

Frontend (Terminal 2)

cd frontend
npm start #or npx expo start

Follow the Expo CLI prompts to run on your device or emulator.

---

🧪 Testing

Backend Tests

cd backend
dotnet test

Frontend Tests

• End-2-end tests use actual endpoints so backend must be running. Running the frontend in browser can also interfere with the test runs.

cd frontend
npm run test:unit #unit testing
npx playwright test #end-2-end test

npm run #to see additional possible runs

---

Documentation

Comprehensive documentation is available for developers and users:

Developer Documentation

• API Reference - Complete REST API documentation

  • All endpoints across controller groups
  • Request/response examples with HTTP status codes
  • Authentication via Clerk JWT tokens
  • Error handling and rate limiting guidance

• Architecture Guide - System design and technical overview

  • Layered architecture with 5 security layers
  • Entity Relationship Diagram (14 tables)
  • Authentication flow with Clerk integration
  • Service layer responsibilities
  • Production deployment on Azure

User Documentation

• User Guide - Step-by-step walkthroughs
  • First-time login and profile setup
  • Organizer workflows (trip creation, invitations, events, check-in)
  • Participant workflows (joining trips, checking in)
  • Troubleshooting with 10+ solutions

---

🏗 Architecture

The application follows a client-server architecture with clear separation between frontend mobile app and backend API. For detailed architecture documentation including system diagrams, authentication flows, and deployment architecture, see the Architecture Guide.

┌──────────────────────┐        HTTP/REST       ┌─────────────────────┐
│                      │ ◄──────────────────────► │                     │
│  Frontend (Mobile)   │                          │   Backend (.NET)    │
│  (React Native Expo) │                          │   (ASP.NET Core)    │
│                      │                          │                     │
└──────────────────────┘                          └────────────┬────────┘
                                                               │
                                                 Entity Framework Core
                                                               │
                                                      ┌────────▼────────┐
                                                      │                 │
                                                      │   PostgreSQL    │
                                                      │                 │
                                                      └─────────────────┘

Backend (/backend)

The backend uses a layered architecture with clear separation of concerns:

• Controllers - HTTP request handlers for:

  • EventController.cs - Event management endpoints
  • CheckinController.cs - Check-in operations
  • ChatController.cs, ChatMessageController.cs, ChatParticipantController.cs - Real-time communication
  • MessagesController.cs - Broadcast message endpoints
  • UserController.cs - User management endpoints
  • InvitationController.cs - Event invitation endpoints
  • ParticipatingController.cs - Participant status endpoints
  • TripController.cs - Trip management endpoints

• Services - Business logic layer:

  • EventService.cs - Event creation and management
  • CheckinService.cs - Check-in processing
  • ChatService.cs, ChatMessageService.cs, ChatParticipantService.cs - Chat functionality
  • MessageService.cs - Broadcast message handling
  • UserService.cs - User management
  • InvitationService.cs - Invitation handling
  • ParticipantService.cs - Participant operations
  • TripService.cs, TripCleanupService.cs - Trip management and cleanup

• Models - Data entities:

  • Event.cs, EventParticipant.cs, EventCheckinSession.cs - Event structure
  • Checkin.cs - Check-in tracking
  • Participant.cs, User.cs - User entities
  • Chat.cs, ChatMessage.cs, ChatParticipant.cs - Chat system
  • Message.cs - Broadcast messages
  • Trip.cs, Invitation.cs - Trip and invitation management

• Data - Data access layer:

  • AppDbContext.cs - Entity Framework Core context

• Migrations Database schema versioning

  • ÌnitialCreate.cs - Consolidated migrations into a single file to resolve out-of-sync history issues, ensuring the database updates correctly for continuous development.

Frontend (/frontend)

The frontend provides a responsive mobile-first user interface:

• /app - Application pages and routing (Expo Router):

  • (auth)/ - Authentication pages (login, signup)
  • (app)/ - Main application pages (events, check-in, chat, profiles)

• /components - Reusable React components:

  • Authentication: Login, signup, social login buttons
  • Events: Event creation and display
  • Trips: Trip management and editor
  • Check-in: Check-in interface and controls
  • Chat: Chat views and creation
  • Invitations: Invitation handling and file upload
  • Participation: Participant tracking
  • UI Primitives (/ui): Buttons, form fields, date fields, navigation, tabs
  • Check-in UI (/ui/checkin): Check-in cards, modals, participant items

• /hooks - Custom React hooks:

  • Data fetching and caching hooks
  • Authentication state hooks
  • Navigation and routing hooks

• /services - API communication:

  • REST client for backend communication
  • Business logic and data transformation

• /types - TypeScript type definitions:

  • API response types
  • Domain model types
  • Component prop types

---

📁 Project Structure

rollcall-event/
├── backend/
│   ├── Controllers/
│   │   ├── ChatController.cs
│   │   ├── ChatMessageController.cs
│   │   ├── ChatParticipantController.cs
│   │   ├── CheckinController.cs
│   │   ├── EventController.cs
│   │   ├── InvitationController.cs
│   │   ├── MessagesController.cs
│   │   ├── ParticipatingController.cs
│   │   ├── TripController.cs
│   │   └── UserController.cs
│   ├── Data/
│   │   ├── AppDbContext.cs
│   │   └── Migrations/
│   ├── Extensions/
│   ├── Models/
│   │   ├── Chat.cs
│   │   ├── ChatMessage.cs
│   │   ├── ChatParticipant.cs
│   │   ├── Checkin.cs
│   │   ├── Event.cs
│   │   ├── EventCheckinSession.cs
│   │   ├── EventParticipant.cs
│   │   ├── Invitation.cs
│   │   ├── Message.cs
│   │   ├── Participant.cs
│   │   ├── Trip.cs
│   │   └── User.cs
│   ├── Properties/
│   ├── Services/
│   │   ├── ChatMessageService.cs
│   │   ├── ChatParticipantService.cs
│   │   ├── ChatService.cs
│   │   ├── CheckinService.cs
│   │   ├── EventService.cs
│   │   ├── InvitationService.cs
│   │   ├── MessageService.cs
│   │   ├── ParticipantService.cs
│   │   ├── TripCleanupService.cs
│   │   ├── TripService.cs
│   │   └── UserService.cs
│   ├── MyApp.API.csproj
│   ├── Program.cs
│   ├── appsettings.Development.json
│   └── appsettings.json
├── frontend/
│   ├── __tests__/
│   ├── android/
│   ├── app/
│   ├── assets/
│   ├── components/
│   ├── constants/
│   ├── e2e/
│   ├── hooks/
│   ├── lib/
│   ├── scripts/
│   ├── services/
│   ├── types/
│   ├── app.json
│   ├── eslint.config.js
│   ├── expo-env.d.ts
│   ├── package.json
│   ├── playwright.config.ts
│   └── tsconfig.json
├── rollcall-event.sln
└── README.md

---

🤖 AI Usage

Throughout the development of Rollcall Event, AI tools have been used to enhance productivity:

Development Assistance

• GitHub Copilot - Used for:

  • Generating C# controller and service boilerplate
  • Creating React component structures
  • Writing TypeScript type definitions
  • Auto-completing repetitive code patterns

• ChatGPT/Claude - Used for:

  • Understanding .NET Entity Framework patterns
  • Researching React Native best practices
  • Explaining authentication and security concepts

Limitations & Human Oversight

All code is:

• Reviewed and tested by team members
• Adapted to fit project requirements
• Debugged manually when AI suggestions don't work
• Refactored based on team standards

AI serves as a productivity tool, but critical thinking remains essential.

---

🐛 Known Issues

• 🚧 Real-time chat push notifications needed
• 🚧 Map view for events and trips needed
• 🚧 Email and SMS services are currently only mocked
• 🚧 Offline mode support planned

---

🤝 Contributing

This is a student prototype project. Contributions are limited to authorized team members.

---

📋 License

TBD

---

Made with ☕ by Bachelor Group 14