Complete boilerplate implementation for event management system with VueJS frontend and C# Azure Functions backend

[Copilot]

This PR implements a complete boilerplate for an event management system as requested in the issue, providing a full-stack application with modern development practices and comprehensive documentation.

🏗️ Architecture Overview

The implementation provides a complete event management system with:

• Frontend: VueJS 3 with TypeScript, Pinia state management, and Vue Router
• Backend: C# Azure Functions with .NET 8.0 and isolated worker model
• Data Contract: Shared TypeScript interfaces ensuring consistency between frontend and backend
• DevOps: Complete CI/CD pipeline with Docker containerization

🚀 Key Features Implemented

Backend APIs (C# Azure Functions)

• ✅ Event CRUD Operations: Create, read, update, delete events
• ✅ Event Filtering: Filter events by date and location
• ✅ Registration System: User registration for events
• ✅ CORS Handling: Built-in CORS configuration in code (not relying on Azure Functions host)
• ✅ Error Handling: Comprehensive error handling with proper HTTP status codes
• ✅ Input Validation: Server-side validation using data annotations

Frontend Features (VueJS)

• ✅ Events Listing: Responsive grid view with filtering capabilities
• ✅ Event Details: Detailed view with registration functionality
• ✅ Event Creation: Form-based event creation with validation
• ✅ User Registration: Complete registration form with name, email, pronouns, and communication opt-in
• ✅ Error Handling: User-friendly error messages and loading states
• ✅ Responsive Design: Mobile-friendly interface

Data Models

Events include: name, location, date, start time
Registration includes: name, email, pronouns (optional), communication opt-in

🔧 Development & DevOps

CI/CD Pipeline

• Backend Workflow: Automatic build, test, and containerization on changes to backend/ directory
• Frontend Workflow: Type checking, build, and containerization on changes to frontend/ directory
• Separate Pipelines: Independent CI/CD flows as requested in requirements

Dependency Management

• Dependabot Configuration: Daily scans for .NET and npm dependencies, weekly for GitHub Actions
• Automated Updates: Pull requests with proper labeling and reviewers

Security

• Security Policy: Comprehensive security guidelines for both frontend and backend
• Input Validation: Protection against common web vulnerabilities
• CORS Configuration: Proper cross-origin resource sharing setup

Documentation

• Local Development: Complete setup guide for local development environment
• GitHub Codespaces: End-to-end cloud development setup with automatic port forwarding
• Project Overview: Detailed architecture and development guidelines
• Azure Functions Core Tools: Configured for local development (not dotnet commands)

📁 Project Structure

├── backend/EventsApi/          # C# Azure Functions backend
│   ├── Functions/              # HTTP trigger functions
│   ├── Models/                 # Data models and DTOs
│   ├── Services/               # Business logic (in-memory implementation)
│   └── Dockerfile              # Container configuration
├── frontend/events-app/        # VueJS frontend application
│   ├── src/
│   │   ├── views/              # Page components
│   │   ├── stores/             # Pinia state management
│   │   ├── services/           # API integration layer
│   │   └── types/              # TypeScript interfaces
│   └── Dockerfile              # Container configuration
├── datacontract/               # Shared data models
├── docs/                       # Comprehensive documentation
├── .github/
│   ├── workflows/              # CI/CD pipelines
│   ├── dependabot.yml         # Dependency management
│   └── SECURITY.md            # Security policy
└── .devcontainer/             # GitHub Codespaces configuration

🧪 Testing & Validation

Both projects build successfully:

• Backend: .NET 8.0 compilation with Azure Functions runtime
• Frontend: TypeScript compilation with Vite build system
• Containers: Docker builds for both services
• End-to-End: Complete user journey from event creation to registration

🌐 Local Development

1. Backend: cd backend/EventsApi && func start
2. Frontend: cd frontend/events-app && npm run dev
3. Access: Frontend at http://localhost:5173, API at http://localhost:7071

☁️ GitHub Codespaces

Complete cloud development environment with:

• Automatic dependency installation
• Pre-configured VS Code extensions
• Port forwarding for both services
• Environment variables for seamless integration

🔗 API Endpoints

• GET /api/events - List events (with filtering)
• GET /api/events/{id} - Get specific event
• POST /api/events - Create event
• PUT /api/events/{id} - Update event
• DELETE /api/events/{id} - Delete event
• POST /api/registrations - Register for event
• GET /api/events/{eventId}/registrations - Get event registrations

All endpoints include proper CORS headers and error handling.

This implementation provides a solid foundation for event management with modern development practices, comprehensive documentation, and production-ready DevOps configuration.

Fixes #1.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.