diff --git a/.env.example b/.env.example index 9fce381..985959d 100644 --- a/.env.example +++ b/.env.example @@ -24,6 +24,7 @@ ENABLE_GENERAL_MODULE=true ENABLE_MODERATION_MODULE=true ENABLE_LFG_MODULE=true ENABLE_REMINDERS_MODULE=true +ENABLE_WEB_MODULE=true # Alternative: Use comma-separated list to override all enabled modules # ENABLED_MODULES=ai,information,music,reminders @@ -54,3 +55,8 @@ PREMIUM_COMMAND_COOLDOWN=1000 # Development NODE_ENV=production + +# Web Dashboard Configuration +WEB_PORT=3000 +WEB_SECRET=your_web_dashboard_secret_here +DASHBOARD_URL=http://localhost:3001 diff --git a/.gitignore b/.gitignore index fa07dfe..95b481a 100644 --- a/.gitignore +++ b/.gitignore @@ -95,3 +95,6 @@ test/test-*.js .aider* AGENTS.md + +# Dashboard frontend (Next.js) +dashboard/ diff --git a/API_DOCUMENTATION.md b/API_DOCUMENTATION.md new file mode 100644 index 0000000..7a64323 --- /dev/null +++ b/API_DOCUMENTATION.md @@ -0,0 +1,894 @@ +# DeepQuasar Dashboard API Documentation + +This API provides comprehensive endpoints for managing your Discord server through the DeepQuasar dashboard. All endpoints require authentication and guild access validation. + +## Base URL + +``` +http://localhost:3000/api +``` + +## Authentication + +All API requests (except health check) require a Bearer token in the Authorization header: + +```http +Authorization: Bearer +``` + +### Getting Started + +**โš ๏ธ Important: This API requires Discord OAuth2 authentication** + +1. **OAuth2 Flow**: Implement Discord OAuth2 to get a user's access token +2. **Login**: Use the `/auth/login` endpoint with the Discord access token and guild ID +3. **Token**: Include the returned JWT token in all subsequent requests +4. **Guild Access**: Ensure the user has Administrator or Manage Guild permissions + +### Discord OAuth2 Setup + +To authenticate users, you need to: + +1. Register your application at [Discord Developer Portal](https://discord.com/developers/applications) +2. Configure OAuth2 redirect URI (e.g., `http://localhost:3001/auth/callback`) +3. Use these scopes: `identify guilds` +4. Exchange the OAuth2 code for an access token +5. Use the access token with this API + +Example OAuth2 URL: +``` +https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&response_type=code&scope=identify+guilds +``` + +## Rate Limiting + +- **General endpoints**: 50 requests per minute +- **Music endpoints**: 30 requests per minute +- **Authentication endpoints**: No rate limit + +## Error Responses + +All errors follow this format: + +```json +{ + "error": "Error Type", + "message": "Human readable error message" +} +``` + +Common HTTP status codes: +- `400` - Bad Request (invalid parameters) +- `401` - Unauthorized (invalid/expired token) +- `403` - Forbidden (insufficient permissions) +- `404` - Not Found (resource doesn't exist) +- `429` - Rate Limited (too many requests) +- `500` - Internal Server Error + +--- + +## Authentication Endpoints + +### Login +Generate an authentication token using Discord OAuth2 access token. + +```http +POST /api/auth/login +Content-Type: application/json + +{ + "accessToken": "discord_oauth2_access_token_here", + "guildId": "987654321098765432" +} +``` + +**Requirements:** +- Valid Discord OAuth2 access token (with `identify guilds` scopes) +- User must be a member of the specified guild +- User must have Administrator or Manage Guild permissions in the guild +- Bot must be present in the guild + +**Response:** +```json +{ + "success": true, + "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", + "user": { + "id": "123456789012345678", + "username": "john_doe", + "globalName": "John Doe", + "displayName": "John Doe", + "avatar": "https://cdn.discordapp.com/avatars/...", + "permissions": { + "administrator": true, + "manageGuild": true, + "moderateMembers": true, + "manageMessages": true + } + }, + "guild": { + "id": "987654321098765432", + "name": "My Discord Server", + "icon": "https://cdn.discordapp.com/icons/...", + "memberCount": 1234 + } +} +``` + +### Verify Token +Verify if the current token is valid and get user/guild information. + +```http +POST /api/auth/verify +Authorization: Bearer +``` + +### Get User Guilds +Get list of guilds where the user has admin permissions and the bot is present. + +```http +POST /api/auth/guilds +Content-Type: application/json + +{ + "accessToken": "discord_oauth2_access_token_here" +} +``` + +**Requirements:** +- Valid Discord OAuth2 access token (with `identify guilds` scopes) + +**Response:** +```json +{ + "success": true, + "guilds": [ + { + "id": "987654321098765432", + "name": "My Discord Server", + "icon": "https://cdn.discordapp.com/icons/...", + "memberCount": 1234, + "permissions": { + "administrator": true, + "manageGuild": true + } + } + ] +} +``` + +### Refresh Token +Generate a new token with extended expiration. + +```http +POST /api/auth/refresh +Authorization: Bearer +``` + +--- + +## Guild Management + +### Get Guild Information +Retrieve comprehensive guild information and bot settings. + +```http +GET /api/guild/{guildId} +Authorization: Bearer +``` + +**Response:** +```json +{ + "success": true, + "guild": { + "id": "987654321098765432", + "name": "My Discord Server", + "icon": "https://cdn.discordapp.com/icons/...", + "memberCount": 1234, + "botJoinedAt": "2023-01-01T00:00:00.000Z", + "features": ["COMMUNITY", "NEWS"], + "settings": { + "musicSettings": { /* guild music config */ }, + "commandSettings": { /* command config */ }, + "chatbot": { /* AI chatbot config */ } + // ... other settings + } + } +} +``` + +### Update Guild Settings +Update guild configuration (requires Administrator permissions). + +```http +PUT /api/guild/{guildId}/settings +Authorization: Bearer +Content-Type: application/json + +{ + "musicSettings": { + "defaultVolume": 75, + "maxQueueSize": 200 + }, + "chatbot": { + "enabled": true, + "responseChance": 15 + } +} +``` + +### Get Guild Channels +List all channels in the guild with permission information. + +```http +GET /api/guild/{guildId}/channels +Authorization: Bearer +``` + +### Get Guild Roles +List all roles in the guild with member counts. + +```http +GET /api/guild/{guildId}/roles +Authorization: Bearer +``` + +### Get Guild Members +List guild members with pagination and search. + +```http +GET /api/guild/{guildId}/members?page=1&limit=20&search=john +Authorization: Bearer +``` + +### Get Guild Statistics +Retrieve guild statistics and bot usage metrics. + +```http +GET /api/guild/{guildId}/stats +Authorization: Bearer +``` + +--- + +## Music Module + +### Get Player Status +Get current music player status and queue information. + +```http +GET /api/music/{guildId}/player +Authorization: Bearer +``` + +**Response:** +```json +{ + "success": true, + "player": { + "guildId": "987654321098765432", + "voiceChannelId": "123456789012345678", + "connected": true, + "playing": true, + "paused": false, + "volume": 75, + "position": 45000, + "repeatMode": "off", + "shuffled": false + }, + "currentTrack": { + "title": "Song Title", + "author": "Artist Name", + "duration": 180000, + "uri": "https://youtube.com/watch?v=...", + "thumbnail": "https://img.youtube.com/vi/.../maxresdefault.jpg", + "position": 45000 + }, + "queue": [ + { + "title": "Next Song", + "author": "Next Artist", + "duration": 200000, + "requester": "123456789012345678" + } + ], + "status": "playing" +} +``` + +### Play Music +Add a track to the queue or start playing music. + +```http +POST /api/music/{guildId}/play +Authorization: Bearer +Content-Type: application/json + +{ + "query": "Rick Astley Never Gonna Give You Up", + "voiceChannelId": "123456789012345678", + "textChannelId": "987654321098765432" +} +``` + +### Pause/Resume +Pause or resume music playback. + +```http +POST /api/music/{guildId}/pause +Authorization: Bearer +``` + +### Skip Track +Skip the current track. + +```http +POST /api/music/{guildId}/skip +Authorization: Bearer +``` + +### Stop Music +Stop playback and clear the queue. + +```http +POST /api/music/{guildId}/stop +Authorization: Bearer +``` + +### Set Volume +Adjust playback volume (0-150). + +```http +POST /api/music/{guildId}/volume +Authorization: Bearer +Content-Type: application/json + +{ + "volume": 75 +} +``` + +### Seek in Track +Seek to a specific position in the current track. + +```http +POST /api/music/{guildId}/seek +Authorization: Bearer +Content-Type: application/json + +{ + "position": 60000 +} +``` + +### Remove from Queue +Remove a track from the queue by index. + +```http +DELETE /api/music/{guildId}/queue/{index} +Authorization: Bearer +``` + +--- + +## Moderation + +### Get Moderation Logs +Retrieve moderation action logs with pagination and filtering. + +```http +GET /api/moderation/{guildId}/logs?page=1&type=BAN&userId=123456789012345678 +Authorization: Bearer +``` + +### Kick Member +Kick a member from the guild. + +```http +POST /api/moderation/{guildId}/kick +Authorization: Bearer +Content-Type: application/json + +{ + "userId": "123456789012345678", + "reason": "Violation of server rules" +} +``` + +### Ban User +Ban a user from the guild. + +```http +POST /api/moderation/{guildId}/ban +Authorization: Bearer +Content-Type: application/json + +{ + "userId": "123456789012345678", + "reason": "Repeated violations", + "deleteMessageDays": 1 +} +``` + +### Unban User +Remove a ban from a user. + +```http +DELETE /api/moderation/{guildId}/ban/{userId} +Authorization: Bearer +Content-Type: application/json + +{ + "reason": "Appeal approved" +} +``` + +### Timeout Member +Apply a timeout to a member. + +```http +POST /api/moderation/{guildId}/timeout +Authorization: Bearer +Content-Type: application/json + +{ + "userId": "123456789012345678", + "duration": 3600000, + "reason": "Spamming" +} +``` + +### Get User Notes +Retrieve moderator notes for a specific user. + +```http +GET /api/moderation/{guildId}/user/{userId}/notes +Authorization: Bearer +``` + +### Add User Note +Add a moderator note to a user's record. + +```http +POST /api/moderation/{guildId}/user/{userId}/notes +Authorization: Bearer +Content-Type: application/json + +{ + "note": "User was warned about behavior in #general" +} +``` + +--- + +## Ticket System + +### Get Tickets +List all support tickets with pagination and status filtering. + +```http +GET /api/tickets/{guildId}?status=open&page=1&limit=20 +Authorization: Bearer +``` + +### Get Ticket Configuration +Retrieve ticket system settings. + +```http +GET /api/tickets/{guildId}/config +Authorization: Bearer +``` + +### Update Ticket Configuration +Modify ticket system settings. + +```http +PUT /api/tickets/{guildId}/config +Authorization: Bearer +Content-Type: application/json + +{ + "enabled": true, + "categoryId": "123456789012345678", + "supportRoles": ["987654321098765432"], + "maxTicketsPerUser": 2, + "autoClose": true, + "autoCloseTime": 48 +} +``` + +### Close Ticket +Close a support ticket. + +```http +POST /api/tickets/{guildId}/{ticketId}/close +Authorization: Bearer +Content-Type: application/json + +{ + "reason": "Issue resolved" +} +``` + +--- + +## Temporary Voice Channels + +### Get TempVC Instances +List all active temporary voice channels. + +```http +GET /api/tempvc/{guildId}/instances +Authorization: Bearer +``` + +### Get User TempVC Settings +Retrieve a user's default TempVC settings. + +```http +GET /api/tempvc/{guildId}/settings/{userId} +Authorization: Bearer +``` + +### Update User TempVC Settings +Modify a user's default TempVC settings. + +```http +PUT /api/tempvc/{guildId}/settings/{userId} +Authorization: Bearer +Content-Type: application/json + +{ + "channelName": "{user}'s Channel", + "userLimit": 10, + "bitrate": 64000, + "isPrivate": false, + "allowedUsers": [], + "blockedUsers": [] +} +``` + +### Delete TempVC Instance +Force delete a temporary voice channel (admin only). + +```http +DELETE /api/tempvc/{guildId}/instances/{channelId} +Authorization: Bearer +``` + +--- + +## User Management + +### Get User Information +Retrieve detailed user information including roles and permissions. + +```http +GET /api/user/{guildId}/{userId} +Authorization: Bearer +``` + +### Search Users +Search for users in the guild by username or ID. + +```http +GET /api/user/{guildId}/search?q=john&limit=10 +Authorization: Bearer +``` + +--- + +## Role Management + +### Get Self-Assignable Roles +List all roles that users can assign to themselves. + +```http +GET /api/roles/{guildId}/selfroles +Authorization: Bearer +``` + +### Add Self-Assignable Role +Make a role self-assignable. + +```http +POST /api/roles/{guildId}/selfroles +Authorization: Bearer +Content-Type: application/json + +{ + "roleId": "123456789012345678", + "emoji": "๐ŸŽฎ", + "description": "Gamers role" +} +``` + +### Remove Self-Assignable Role +Remove a role from the self-assignable list. + +```http +DELETE /api/roles/{guildId}/selfroles/{roleId} +Authorization: Bearer +``` + +### Assign Role to User +Manually assign a role to a user (admin only). + +```http +POST /api/roles/{guildId}/assign/{userId}/{roleId} +Authorization: Bearer +``` + +### Remove Role from User +Manually remove a role from a user (admin only). + +```http +DELETE /api/roles/{guildId}/assign/{userId}/{roleId} +Authorization: Bearer +``` + +--- + +## Reminders + +### Get Reminders +List reminders with optional user filtering. + +```http +GET /api/reminders/{guildId}?userId=123456789012345678&page=1 +Authorization: Bearer +``` + +### Create Reminder +Set up a new reminder. + +```http +POST /api/reminders/{guildId} +Authorization: Bearer +Content-Type: application/json + +{ + "message": "Don't forget about the event!", + "reminderTime": "2024-01-01T15:00:00.000Z", + "channelId": "123456789012345678" +} +``` + +### Delete Reminder +Cancel a scheduled reminder. + +```http +DELETE /api/reminders/{guildId}/{reminderId} +Authorization: Bearer +``` + +--- + +## LFG (Looking for Group) + +### Get LFG Posts +List looking-for-group posts with filtering options. + +```http +GET /api/lfg/{guildId}/posts?game=valorant&status=active&page=1 +Authorization: Bearer +``` + +### Get LFG Settings +Retrieve LFG system configuration. + +```http +GET /api/lfg/{guildId}/settings +Authorization: Bearer +``` + +### Update LFG Settings +Modify LFG system settings. + +```http +PUT /api/lfg/{guildId}/settings +Authorization: Bearer +Content-Type: application/json + +{ + "enabled": true, + "channelId": "123456789012345678", + "autoDeleteAfter": 24, + "allowedGames": ["Valorant", "CS:GO", "League of Legends"], + "maxPostsPerUser": 3 +} +``` + +### Delete LFG Post +Remove an LFG post. + +```http +DELETE /api/lfg/{guildId}/posts/{postId} +Authorization: Bearer +``` + +--- + +## Template Management + +### Get All Templates +List all embed templates for the guild. + +```http +GET /api/templates/{guildId} +Authorization: Bearer +``` + +### Get Specific Template +Retrieve a specific embed template. + +```http +GET /api/templates/{guildId}/{templateId} +Authorization: Bearer +``` + +### Create Template +Create a new embed template. + +```http +POST /api/templates/{guildId} +Authorization: Bearer +Content-Type: application/json + +{ + "name": "Welcome Template", + "description": "Template for welcoming new members", + "embedData": { + "title": "Welcome!", + "description": "Welcome to our server!", + "color": 5814783, + "fields": [] + } +} +``` + +### Update Template +Modify an existing embed template. + +```http +PUT /api/templates/{guildId}/{templateId} +Authorization: Bearer +Content-Type: application/json + +{ + "name": "Updated Welcome Template", + "description": "Updated welcome message", + "embedData": { + "title": "Welcome to the Server!", + "description": "We're glad you're here!", + "color": 3447003 + } +} +``` + +### Delete Template +Remove an embed template. + +```http +DELETE /api/templates/{guildId}/{templateId} +Authorization: Bearer +``` + +### Send Template +Send a template to a specific channel. + +```http +POST /api/templates/{guildId}/{templateId}/send +Authorization: Bearer +Content-Type: application/json + +{ + "channelId": "123456789012345678" +} +``` + +--- + +## AI/Chatbot Configuration + +### Get AI Configuration +Retrieve AI/chatbot settings. + +```http +GET /api/ai/{guildId}/config +Authorization: Bearer +``` + +### Update AI Configuration +Modify AI/chatbot settings. + +```http +PUT /api/ai/{guildId}/config +Authorization: Bearer +Content-Type: application/json + +{ + "enabled": true, + "model": "gpt-3.5-turbo", + "maxTokens": 500, + "temperature": 0.7, + "systemPrompt": "You are a helpful Discord bot assistant.", + "responseChance": 15, + "channelMode": "whitelist", + "whitelistedChannels": ["123456789012345678"], + "requireMention": false, + "cooldown": 5000 +} +``` + +### Test AI Response +Test the AI chatbot with a sample message. + +```http +POST /api/ai/{guildId}/test +Authorization: Bearer +Content-Type: application/json + +{ + "message": "Hello, how are you?" +} +``` + +### Get AI Statistics +Retrieve AI usage statistics. + +```http +GET /api/ai/{guildId}/stats +Authorization: Bearer +``` + +--- + +## Health Check + +### System Health +Check API and bot status (no authentication required). + +```http +GET /api/health +``` + +**Response:** +```json +{ + "status": "ok", + "timestamp": "2024-01-01T12:00:00.000Z", + "uptime": 3600, + "botStatus": "ready", + "guilds": 150, + "users": 50000 +} +``` + +--- + +## Permission Levels + +Different endpoints require different permission levels: + +- **User**: Basic authenticated user (can access own data) +- **DJ**: Music-related permissions (configurable per guild) +- **Moderator**: ModerateMembers, ManageMessages, or equivalent permissions +- **Administrator**: Administrator or ManageGuild permissions + +## Best Practices + +1. **Always handle errors**: Check response status and error messages +2. **Respect rate limits**: Implement proper backoff strategies +3. **Cache tokens**: Store JWT tokens securely and refresh when needed +4. **Validate permissions**: Check user permissions before making requests +5. **Use pagination**: Always handle paginated responses for large datasets + +## SDKs and Examples + +For implementation examples and SDKs, check our GitHub repository's `examples/` directory. + +--- + +*This API documentation is for DeepQuasar Dashboard v1.0.0* \ No newline at end of file diff --git a/API_README.md b/API_README.md new file mode 100644 index 0000000..cb47a10 --- /dev/null +++ b/API_README.md @@ -0,0 +1,317 @@ +# DeepQuasar API Implementation + +This document provides an overview of the comprehensive REST API implementation for the DeepQuasar Discord bot dashboard. + +## ๐Ÿš€ Quick Start + +### 1. Enable the Web Module + +Add to your `.env` file: +```env +ENABLE_WEB_MODULE=true +WEB_PORT=3000 +WEB_SECRET=your_secure_secret_here +DASHBOARD_URL=http://localhost:3001 +``` + +### 2. Start the Bot + +```bash +npm start +``` + +The API will be available at `http://localhost:3000/api` + +### 3. Test the API + +Open `examples/dashboard-demo.html` in your browser to test the API interactively. + +## ๐Ÿ“‹ Features Implemented + +### ๐Ÿ” Authentication & Security +- **Discord OAuth2 integration** with access token verification +- **Discord API validation** ensures authentic user identity +- **Guild access validation** through Discord's permissions system +- **Role-based permissions** (User, DJ, Moderator, Administrator) +- **Rate limiting** to prevent abuse (30-50 requests/minute) +- **CORS configuration** for secure frontend integration +- **Proper 401 responses** for unauthorized/invalid tokens + +### ๐ŸŽฏ API Endpoints (95 Total) + +#### Authentication (4 endpoints) +- `POST /auth/login` - Authenticate with Discord OAuth2 token +- `POST /auth/verify` - Verify token validity +- `POST /auth/refresh` - Refresh existing token +- `POST /auth/guilds` - Get user's manageable guilds (OAuth2) + +#### Guild Management (6 endpoints) +- `GET /guild/:guildId` - Get guild information and settings +- `PUT /guild/:guildId/settings` - Update guild configuration +- `GET /guild/:guildId/channels` - List guild channels +- `GET /guild/:guildId/roles` - List guild roles +- `GET /guild/:guildId/members` - List guild members (paginated) +- `GET /guild/:guildId/stats` - Get guild statistics + +#### Music Control (8 endpoints) +- `GET /music/:guildId/player` - Get player status and queue +- `POST /music/:guildId/play` - Add track to queue/start playing +- `POST /music/:guildId/pause` - Pause/resume playback +- `POST /music/:guildId/skip` - Skip current track +- `POST /music/:guildId/stop` - Stop and clear queue +- `POST /music/:guildId/volume` - Set playback volume +- `POST /music/:guildId/seek` - Seek to position in track +- `DELETE /music/:guildId/queue/:index` - Remove track from queue + +#### Moderation (7 endpoints) +- `GET /moderation/:guildId/logs` - Get moderation logs (paginated) +- `POST /moderation/:guildId/kick` - Kick member from guild +- `POST /moderation/:guildId/ban` - Ban user from guild +- `DELETE /moderation/:guildId/ban/:userId` - Unban user +- `POST /moderation/:guildId/timeout` - Timeout member +- `GET /moderation/:guildId/user/:userId/notes` - Get user notes +- `POST /moderation/:guildId/user/:userId/notes` - Add user note + +#### Ticket System (4 endpoints) +- `GET /tickets/:guildId` - List support tickets +- `GET /tickets/:guildId/config` - Get ticket configuration +- `PUT /tickets/:guildId/config` - Update ticket settings +- `POST /tickets/:guildId/:ticketId/close` - Close ticket + +#### TempVC Management (4 endpoints) +- `GET /tempvc/:guildId/instances` - List active temporary VCs +- `GET /tempvc/:guildId/settings/:userId` - Get user VC settings +- `PUT /tempvc/:guildId/settings/:userId` - Update user VC settings +- `DELETE /tempvc/:guildId/instances/:channelId` - Delete VC instance + +#### User Management (2 endpoints) +- `GET /user/:guildId/:userId` - Get user information +- `GET /user/:guildId/search` - Search guild users + +#### Role Management (5 endpoints) +- `GET /roles/:guildId/selfroles` - List self-assignable roles +- `POST /roles/:guildId/selfroles` - Add self-assignable role +- `DELETE /roles/:guildId/selfroles/:roleId` - Remove self-assignable role +- `POST /roles/:guildId/assign/:userId/:roleId` - Assign role to user +- `DELETE /roles/:guildId/assign/:userId/:roleId` - Remove role from user + +#### Reminders (3 endpoints) +- `GET /reminders/:guildId` - List reminders (paginated) +- `POST /reminders/:guildId` - Create new reminder +- `DELETE /reminders/:guildId/:reminderId` - Delete reminder + +#### LFG System (4 endpoints) +- `GET /lfg/:guildId/posts` - List LFG posts +- `GET /lfg/:guildId/settings` - Get LFG configuration +- `PUT /lfg/:guildId/settings` - Update LFG settings +- `DELETE /lfg/:guildId/posts/:postId` - Delete LFG post + +#### Template Management (6 endpoints) +- `GET /templates/:guildId` - List embed templates +- `GET /templates/:guildId/:templateId` - Get specific template +- `POST /templates/:guildId` - Create new template +- `PUT /templates/:guildId/:templateId` - Update template +- `DELETE /templates/:guildId/:templateId` - Delete template +- `POST /templates/:guildId/:templateId/send` - Send template to channel + +#### AI/Chatbot (4 endpoints) +- `GET /ai/:guildId/config` - Get AI configuration +- `PUT /ai/:guildId/config` - Update AI settings +- `POST /ai/:guildId/test` - Test AI response +- `GET /ai/:guildId/stats` - Get AI usage statistics + +#### System Health (1 endpoint) +- `GET /health` - Check API and bot status + +## ๐Ÿ“ File Structure + +``` +src/modules/web/ +โ”œโ”€โ”€ index.js # Main web module +โ”œโ”€โ”€ middleware/ +โ”‚ โ””โ”€โ”€ auth.js # Authentication & authorization +โ””โ”€โ”€ routes/ + โ”œโ”€โ”€ auth.js # Authentication routes + โ”œโ”€โ”€ ai.js # AI/chatbot routes + โ”œโ”€โ”€ guild.js # Guild management routes + โ”œโ”€โ”€ lfg.js # LFG system routes + โ”œโ”€โ”€ moderation.js # Moderation routes + โ”œโ”€โ”€ music.js # Music control routes + โ”œโ”€โ”€ reminders.js # Reminder routes + โ”œโ”€โ”€ roles.js # Role management routes + โ”œโ”€โ”€ templates.js # Template routes + โ”œโ”€โ”€ tempvc.js # TempVC routes + โ”œโ”€โ”€ tickets.js # Ticket system routes + โ””โ”€โ”€ user.js # User management routes +``` + +## ๐Ÿ”’ Security Features + +### Discord OAuth2 + JWT Authentication +- **Discord OAuth2**: Verify user identity with Discord's API +- **Access Token Validation**: All requests validated against Discord +- **JWT Tokens**: Expire after 7 days, include user ID and guild ID +- **Secure Authentication**: No plain user/guild ID authentication +- **401 Responses**: Proper error handling for invalid tokens + +### Permission Validation +- **User Level**: Basic authenticated access +- **DJ Level**: Music control permissions +- **Moderator Level**: Moderation actions +- **Admin Level**: Guild settings and configuration + +### Rate Limiting +- In-memory rate limiting per user/IP +- Different limits for different endpoint groups +- Automatic cleanup of old rate limit entries + +### CORS Protection +- Configurable allowed origins +- Credentials support for authentication +- Preflight request handling + +## ๐Ÿ“– Documentation + +### Complete API Documentation +- **[API_DOCUMENTATION.md](./API_DOCUMENTATION.md)** - Complete API reference with examples +- **[API_TESTING_GUIDE.md](./API_TESTING_GUIDE.md)** - Testing guide with curl, Postman, and JavaScript examples + +### Interactive Demo +- **[examples/dashboard-demo.html](./examples/dashboard-demo.html)** - Interactive web demo for testing API endpoints + +## ๐Ÿงช Testing + +### Basic Module Validation +```bash +# Test module loading +node -e " +const auth = require('./src/modules/web/middleware/auth.js'); +console.log('Auth middleware functions:', Object.keys(auth)); +" + +# Test route loading +node -e " +const routes = ['auth', 'guild', 'music']; +routes.forEach(route => { + const r = require(\`./src/modules/web/routes/\${route}.js\`); + console.log(\`โœ… \${route} routes loaded\`); +}); +" +``` + +### Health Check +```bash +curl http://localhost:3000/api/health +``` + +### Authentication Test +```bash +# First get Discord OAuth2 access token through OAuth2 flow, then: +curl -X POST http://localhost:3000/api/auth/login \ + -H "Content-Type: application/json" \ + -d '{"accessToken":"YOUR_DISCORD_ACCESS_TOKEN","guildId":"987654321098765432"}' +``` + +### Get User's Guilds +```bash +# Get guilds user can manage with bot present +curl -X POST http://localhost:3000/api/auth/guilds \ + -H "Content-Type: application/json" \ + -d '{"accessToken":"YOUR_DISCORD_ACCESS_TOKEN"}' +``` + +## ๐Ÿšง Integration Guide + +### Frontend Integration + +1. **Install the JWT token** after login +2. **Include token in headers** for all authenticated requests +3. **Handle token expiration** and refresh as needed +4. **Implement proper error handling** for different response codes + +### Example JavaScript Client + +See the complete example in `examples/dashboard-demo.html` or `API_TESTING_GUIDE.md`. + +### React/Vue.js Integration + +```javascript +// API service class +class DeepQuasarAPI { + constructor(baseURL) { + this.baseURL = baseURL; + this.token = localStorage.getItem('token'); + } + + async request(endpoint, options = {}) { + const response = await fetch(`${this.baseURL}${endpoint}`, { + ...options, + headers: { + 'Authorization': `Bearer ${this.token}`, + 'Content-Type': 'application/json', + ...options.headers, + }, + }); + + if (!response.ok) { + const error = await response.json(); + throw new Error(error.message); + } + + return response.json(); + } + + // Implement specific methods for each endpoint... +} +``` + +## ๐Ÿ—๏ธ Architecture + +### Modular Design +- **Separation of concerns** with dedicated route files +- **Middleware-based architecture** for authentication and validation +- **Reusable components** for common functionality + +### Error Handling +- **Consistent error responses** across all endpoints +- **Proper HTTP status codes** for different error types +- **Detailed error messages** for debugging + +### Performance Considerations +- **Rate limiting** to prevent abuse +- **Pagination** for large datasets +- **Efficient database queries** using Mongoose + +## ๐Ÿ”„ Future Enhancements + +### Potential Improvements +1. **WebSocket support** for real-time updates +2. **API versioning** for backward compatibility +3. **Enhanced caching** for frequently accessed data +4. **Metrics and monitoring** integration +5. **Swagger/OpenAPI** documentation generation + +### Scalability +- **Redis-based rate limiting** for multi-instance deployments +- **Database connection pooling** optimization +- **Load balancer support** with session affinity + +## ๐Ÿค Contributing + +When adding new endpoints: + +1. **Follow the established patterns** in existing route files +2. **Include proper authentication** and permission checks +3. **Add comprehensive error handling** +4. **Update the API documentation** +5. **Include examples** in the testing guide + +## ๐Ÿ“ License + +This API implementation is part of the DeepQuasar Discord bot project and follows the same license terms. + +--- + +**Ready for Dashboard Integration! ๐ŸŽ‰** + +The API provides comprehensive access to all bot features with secure authentication, proper permissions, and extensive documentation. Frontend developers can now build rich dashboard experiences using these endpoints. \ No newline at end of file diff --git a/API_TESTING_GUIDE.md b/API_TESTING_GUIDE.md new file mode 100644 index 0000000..3e3d3e6 --- /dev/null +++ b/API_TESTING_GUIDE.md @@ -0,0 +1,459 @@ +# API Testing Examples + +This document provides examples of how to test the DeepQuasar Dashboard API endpoints. + +## Prerequisites + +1. **Start the bot with web module enabled**: + ```bash + npm start + ``` + +2. **Ensure environment variables are set**: + ```bash + # In your .env file + ENABLE_WEB_MODULE=true + WEB_PORT=3000 + WEB_SECRET=your_secret_here + DASHBOARD_URL=http://localhost:3001 + ``` + +3. **Get Discord OAuth2 Access Token**: + - Register app at [Discord Developer Portal](https://discord.com/developers/applications) + - Set up OAuth2 with scopes: `identify guilds` + - Implement OAuth2 flow to get access token + +## Testing with curl + +### 1. Health Check (No Auth Required) + +```bash +curl -X GET http://localhost:3000/api/health +``` + +**Expected Response:** +```json +{ + "status": "ok", + "timestamp": "2024-01-01T12:00:00.000Z", + "uptime": 3600, + "botStatus": "ready", + "guilds": 150, + "users": 50000 +} +``` + +### 2. Authentication (Discord OAuth2 Required) + +```bash +# Get user's manageable guilds first +curl -X POST http://localhost:3000/api/auth/guilds \ + -H "Content-Type: application/json" \ + -d '{ + "accessToken": "YOUR_DISCORD_OAUTH2_ACCESS_TOKEN" + }' +``` + +```bash +# Login with Discord access token to get JWT +curl -X POST http://localhost:3000/api/auth/login \ + -H "Content-Type: application/json" \ + -d '{ + "accessToken": "YOUR_DISCORD_OAUTH2_ACCESS_TOKEN", + "guildId": "987654321098765432" + }' +``` + +**Expected Response:** +```json +{ + "success": true, + "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", + "user": { + "id": "123456789012345678", + "username": "john_doe", + "displayName": "John Doe", + "avatar": "https://cdn.discordapp.com/avatars/...", + "permissions": { + "administrator": true, + "manageGuild": true, + "moderateMembers": true, + "manageMessages": true + } + }, + "guild": { + "id": "987654321098765432", + "name": "My Discord Server", + "icon": "https://cdn.discordapp.com/icons/...", + "memberCount": 1234 + } +} +``` + +### 3. Using the JWT Token + +```bash +# Export token for easier use +export TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." + +# Get guild information +curl -X GET http://localhost:3000/api/guild/987654321098765432 \ + -H "Authorization: Bearer $TOKEN" + +# Get music player status +curl -X GET http://localhost:3000/api/music/987654321098765432/player \ + -H "Authorization: Bearer $TOKEN" + +# Get guild channels +curl -X GET http://localhost:3000/api/guild/987654321098765432/channels \ + -H "Authorization: Bearer $TOKEN" +``` + +## Testing with Postman + +### 1. Import Collection + +Create a new Postman collection with these settings: + +**Collection Variables:** +- `baseURL`: `http://localhost:3000/api` +- `token`: `{{loginToken}}` (will be set by login request) +- `guildId`: `987654321098765432` +- `userId`: `123456789012345678` + +### 2. Authentication Request + +``` +POST {{baseURL}}/auth/login +Content-Type: application/json + +{ + "userId": "{{userId}}", + "guildId": "{{guildId}}" +} +``` + +**Test Script (in Postman):** +```javascript +// Save token for future requests +if (pm.response.code === 200) { + const response = pm.response.json(); + pm.collectionVariables.set("loginToken", response.token); +} +``` + +### 3. Guild Info Request + +``` +GET {{baseURL}}/guild/{{guildId}} +Authorization: Bearer {{token}} +``` + +### 4. Music Control Requests + +``` +# Get player status +GET {{baseURL}}/music/{{guildId}}/player +Authorization: Bearer {{token}} + +# Play music +POST {{baseURL}}/music/{{guildId}}/play +Authorization: Bearer {{token}} +Content-Type: application/json + +{ + "query": "Never Gonna Give You Up", + "voiceChannelId": "123456789012345678" +} + +# Pause music +POST {{baseURL}}/music/{{guildId}}/pause +Authorization: Bearer {{token}} + +# Set volume +POST {{baseURL}}/music/{{guildId}}/volume +Authorization: Bearer {{token}} +Content-Type: application/json + +{ + "volume": 75 +} +``` + +## Testing with JavaScript/Fetch + +### Frontend Integration Example + +```javascript +class DeepQuasarAPI { + constructor(baseURL = 'http://localhost:3000/api') { + this.baseURL = baseURL; + this.token = localStorage.getItem('deepquasar_token'); + } + + // Get user's manageable guilds with Discord OAuth2 token + async getGuilds(discordAccessToken) { + const response = await fetch(`${this.baseURL}/auth/guilds`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ accessToken: discordAccessToken }), + }); + + if (!response.ok) { + throw new Error('Failed to fetch guilds'); + } + + return response.json(); + } + + // Login with Discord OAuth2 access token + async login(discordAccessToken, guildId) { + const response = await fetch(`${this.baseURL}/auth/login`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ accessToken: discordAccessToken, guildId }), + }); + + const data = await response.json(); + + if (data.success) { + this.token = data.token; + localStorage.setItem('deepquasar_token', this.token); + return data; + } + + throw new Error(data.message || 'Login failed'); + } + + async request(endpoint, options = {}) { + if (!this.token) { + throw new Error('Not authenticated'); + } + + const response = await fetch(`${this.baseURL}${endpoint}`, { + ...options, + headers: { + 'Authorization': `Bearer ${this.token}`, + 'Content-Type': 'application/json', + ...options.headers, + }, + }); + + const data = await response.json(); + + if (!response.ok) { + throw new Error(data.message || `HTTP ${response.status}`); + } + + return data; + } + + // Guild methods + async getGuildInfo(guildId) { + return this.request(`/guild/${guildId}`); + } + + async getGuildChannels(guildId) { + return this.request(`/guild/${guildId}/channels`); + } + + async updateGuildSettings(guildId, settings) { + return this.request(`/guild/${guildId}/settings`, { + method: 'PUT', + body: JSON.stringify(settings), + }); + } + + // Music methods + async getMusicPlayer(guildId) { + return this.request(`/music/${guildId}/player`); + } + + async playMusic(guildId, query, voiceChannelId) { + return this.request(`/music/${guildId}/play`, { + method: 'POST', + body: JSON.stringify({ query, voiceChannelId }), + }); + } + + async pauseMusic(guildId) { + return this.request(`/music/${guildId}/pause`, { + method: 'POST', + }); + } + + async setVolume(guildId, volume) { + return this.request(`/music/${guildId}/volume`, { + method: 'POST', + body: JSON.stringify({ volume }), + }); + } + + // Moderation methods + async getModerationLogs(guildId, page = 1, type = null) { + const params = new URLSearchParams({ page: page.toString() }); + if (type) params.append('type', type); + + return this.request(`/moderation/${guildId}/logs?${params}`); + } + + async kickMember(guildId, userId, reason) { + return this.request(`/moderation/${guildId}/kick`, { + method: 'POST', + body: JSON.stringify({ userId, reason }), + }); + } + + async banUser(guildId, userId, reason, deleteMessageDays = 0) { + return this.request(`/moderation/${guildId}/ban`, { + method: 'POST', + body: JSON.stringify({ userId, reason, deleteMessageDays }), + }); + } +} + +// Usage example with Discord OAuth2 +async function example() { + const api = new DeepQuasarAPI(); + + try { + // First, get Discord access token through OAuth2 flow + const discordAccessToken = 'YOUR_DISCORD_OAUTH2_ACCESS_TOKEN'; + + // Get list of manageable guilds + const guilds = await api.getGuilds(discordAccessToken); + console.log('Available guilds:', guilds.guilds.map(g => g.name)); + + // Select a guild and login + const selectedGuild = guilds.guilds[0]; + const loginResult = await api.login(discordAccessToken, selectedGuild.id); + console.log('Logged in:', loginResult.user.username); + + // Get guild info + const guild = await api.getGuildInfo(selectedGuild.id); + console.log('Guild:', guild.guild.name); + + // Get music player status + const player = await api.getMusicPlayer('987654321098765432'); + console.log('Player status:', player.status); + + // Play music (if in voice channel) + if (player.status === 'not_playing') { + await api.playMusic('987654321098765432', 'Never Gonna Give You Up', 'VOICE_CHANNEL_ID'); + console.log('Started playing music'); + } + + } catch (error) { + console.error('API Error:', error.message); + } +} +``` + +## Error Handling + +### Common Error Responses + +```json +// 401 Unauthorized +{ + "error": "Authentication Required", + "message": "No valid authorization header provided" +} + +// 403 Forbidden +{ + "error": "Access Denied", + "message": "Administrator permissions required" +} + +// 404 Not Found +{ + "error": "Guild Not Found", + "message": "Bot is not a member of this guild" +} + +// 429 Rate Limited +{ + "error": "Rate Limit Exceeded", + "message": "Too many requests, please try again later" +} + +// 500 Internal Server Error +{ + "error": "Internal Server Error", + "message": "Something went wrong" +} +``` + +### Rate Limiting + +Each endpoint group has different rate limits: +- **Authentication**: No limit +- **General endpoints**: 50 requests/minute +- **Music endpoints**: 30 requests/minute + +When rate limited, wait before retrying. Implement exponential backoff: + +```javascript +async function retryWithBackoff(apiCall, maxRetries = 3) { + for (let i = 0; i < maxRetries; i++) { + try { + return await apiCall(); + } catch (error) { + if (error.message.includes('Rate Limit') && i < maxRetries - 1) { + const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s + await new Promise(resolve => setTimeout(resolve, delay)); + continue; + } + throw error; + } + } +} +``` + +## Production Considerations + +### Security + +1. **Use HTTPS in production**: + ```bash + # Set in production environment + DASHBOARD_URL=https://dashboard.yourdomain.com + ``` + +2. **Secure the JWT secret**: + ```bash + # Use a strong, random secret + WEB_SECRET=your-very-secure-random-string-here + ``` + +3. **Configure CORS properly**: + ```javascript + // Only allow your dashboard domain + cors({ + origin: 'https://dashboard.yourdomain.com', + credentials: true + }) + ``` + +### Performance + +1. **Use a reverse proxy** (nginx, Apache) +2. **Enable compression** for API responses +3. **Implement request logging** for monitoring +4. **Set up health monitoring** endpoints + +### Monitoring + +Monitor these metrics: +- Request count and response times +- Error rates by endpoint +- Authentication success/failure rates +- Rate limit violations +- Memory and CPU usage + +This completes the testing guide for the DeepQuasar Dashboard API! \ No newline at end of file diff --git a/DASHBOARD_README.md b/DASHBOARD_README.md new file mode 100644 index 0000000..0e7f38b --- /dev/null +++ b/DASHBOARD_README.md @@ -0,0 +1,213 @@ +# DeepQuasar Dashboard + +A modern, responsive web dashboard for managing your Discord bot through an intuitive interface. + +## Features + +- **Discord OAuth Authentication** - Secure login using Discord accounts +- **Guild Management** - Switch between multiple Discord servers +- **Music Control** - Control music playback, view queue, adjust volume +- **Real-time Data** - Live updates of bot status and server information +- **Responsive Design** - Works seamlessly on desktop and mobile devices +- **Modern UI** - Built with Tailwind CSS and Heroicons for a sleek experience + +## Quick Start + +### Prerequisites + +- Node.js 18+ +- Discord Application with OAuth2 configured +- DeepQuasar bot running with web API enabled + +### Installation + +1. **Configure Discord OAuth2** + + In your Discord Application settings (Discord Developer Portal): + - Add redirect URI: `http://localhost:3001/auth/callback` + - Note your Client ID and Client Secret + +2. **Environment Setup** + + Copy and configure the environment file: + ```bash + cd dashboard + cp .env.local.example .env.local + ``` + + Edit `.env.local` with your Discord credentials: + ```env + NEXT_PUBLIC_DISCORD_CLIENT_ID=your_discord_client_id + NEXT_PUBLIC_API_URL=http://localhost:3000/api + NEXT_PUBLIC_DASHBOARD_URL=http://localhost:3001 + DISCORD_CLIENT_SECRET=your_discord_client_secret + ``` + +3. **Install Dependencies** + ```bash + cd dashboard + npm install + ``` + +4. **Start Development Server** + ```bash + npm run dev + ``` + +5. **Access Dashboard** + + Open http://localhost:3001 in your browser + +## Environment Variables + +| Variable | Description | Example | +|----------|-------------|---------| +| `NEXT_PUBLIC_DISCORD_CLIENT_ID` | Discord Application Client ID | `123456789012345678` | +| `NEXT_PUBLIC_API_URL` | DeepQuasar API base URL | `http://localhost:3000/api` | +| `NEXT_PUBLIC_DASHBOARD_URL` | Dashboard URL for OAuth redirects | `http://localhost:3001` | +| `DISCORD_CLIENT_SECRET` | Discord Application Client Secret | `your-secret-here` | + +## Production Deployment + +### Building for Production + +```bash +cd dashboard +npm run build +npm start +``` + +### Docker Deployment + +Create a `Dockerfile` in the dashboard directory: + +```dockerfile +FROM node:18-alpine AS deps +WORKDIR /app +COPY package*.json ./ +RUN npm ci + +FROM node:18-alpine AS builder +WORKDIR /app +COPY --from=deps /app/node_modules ./node_modules +COPY . . +RUN npm run build + +FROM node:18-alpine AS runner +WORKDIR /app +ENV NODE_ENV production +RUN addgroup --system --gid 1001 nodejs +RUN adduser --system --uid 1001 nextjs + +COPY --from=builder /app/public ./public +COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./ +COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static + +USER nextjs +EXPOSE 3001 +ENV PORT 3001 + +CMD ["node", "server.js"] +``` + +### Environment Configuration for Production + +Update your environment variables for production: + +```env +NEXT_PUBLIC_DISCORD_CLIENT_ID=your_discord_client_id +NEXT_PUBLIC_API_URL=https://your-bot-api-domain.com/api +NEXT_PUBLIC_DASHBOARD_URL=https://your-dashboard-domain.com +DISCORD_CLIENT_SECRET=your_discord_client_secret +``` + +**Important**: Update Discord OAuth2 redirect URI in Discord Developer Portal to match your production URL. + +## Dashboard Features + +### Authentication Flow +1. User clicks "Login with Discord" +2. Redirected to Discord OAuth2 +3. User authorizes application +4. Dashboard receives access token +5. User selects a guild to manage +6. JWT token generated for API access + +### Available Sections + +- **Overview** - Server statistics and recent activity +- **Music** - Control music playback, view queue +- **Moderation** - View moderation logs and actions +- **Tickets** - Manage support tickets +- **Members** - Guild member management +- **Settings** - Bot configuration options + +### Permissions + +Users need one of the following permissions in the Discord server: +- Administrator +- Manage Guild + +The bot must also be present in the server for it to appear in the guild selection. + +## API Integration + +The dashboard communicates with the DeepQuasar bot API endpoints: + +- Authentication: `/api/auth/*` +- Guild data: `/api/guild/*` +- Music control: `/api/music/*` +- Moderation: `/api/moderation/*` +- And more... + +All API calls include JWT authentication and proper error handling. + +## Troubleshooting + +### Common Issues + +**"Discord Client ID not configured"** +- Check your `.env.local` file has the correct `NEXT_PUBLIC_DISCORD_CLIENT_ID` + +**"No eligible guilds found"** +- Ensure you have Administrator/Manage Guild permissions +- Verify the bot is present in your Discord server +- Check that the bot's web API is running + +**"Authentication failed"** +- Verify Discord Client Secret is correct +- Check Discord OAuth2 redirect URI matches exactly +- Ensure bot API is accessible at the configured URL + +**API connection errors** +- Verify the bot is running with web module enabled +- Check `NEXT_PUBLIC_API_URL` points to the correct bot API +- Ensure CORS is properly configured in bot settings + +### Development Tips + +- Use browser developer tools to inspect network requests +- Check browser console for JavaScript errors +- Verify environment variables are properly loaded +- Test OAuth flow with Discord's developer tools + +## Security Considerations + +- Never expose Discord Client Secret in frontend code +- Use HTTPS in production +- Implement proper CORS policies +- Regularly rotate Discord application secrets +- Validate all user inputs +- Use secure JWT tokens with appropriate expiration + +## Contributing + +1. Fork the repository +2. Create a feature branch +3. Make your changes +4. Test thoroughly +5. Submit a pull request + +## License + +This project is licensed under the MIT License - see the main project LICENSE file for details. \ No newline at end of file diff --git a/examples/dashboard-demo.html b/examples/dashboard-demo.html new file mode 100644 index 0000000..160c63f --- /dev/null +++ b/examples/dashboard-demo.html @@ -0,0 +1,599 @@ + + + + + + DeepQuasar Dashboard Demo + + + +
+
+

๐Ÿš€ DeepQuasar Dashboard API Demo

+

Interactive demonstration of the DeepQuasar Bot API endpoints

+
+ +
+ +
+

๐Ÿ” Authentication

+

โš ๏ธ Note: This demo requires Discord OAuth2 authentication. In production, implement proper OAuth2 flow.

+
+
+
+ + + Get this from Discord OAuth2 flow with 'identify guilds' scopes +
+
+ + + Select from available guilds after getting guilds list +
+ + + + +
+
+
Not authenticated
+
+
+
+
+ + +
+

๐Ÿ’Š System Health

+
+
+ + +
+
+
Click "Check API Health" to test the API connection
+
+
+
+ + +
+

๐Ÿฐ Guild Management

+
+
+ + + + +
+
+
Login first to use guild features
+
+
+
+ + +
+

๐ŸŽต Music Control

+
+
+
+ + +
+
+ + +
+ + + + +
+ + + 75 +
+
+
+
Login first to use music features
+
+
+
+
+
+ + + + \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 014a0ea..3ce5129 100644 --- a/package-lock.json +++ b/package-lock.json @@ -17,6 +17,7 @@ "dotenv": "^16.3.1", "express": "^4.18.2", "helmet": "^7.1.0", + "jsonwebtoken": "^9.0.2", "luxon": "^3.7.1", "mongoose": "^8.0.3", "moonlink.js": "^4.44.4", @@ -3367,6 +3368,12 @@ "node": ">=16.20.1" } }, + "node_modules/buffer-equal-constant-time": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz", + "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==", + "license": "BSD-3-Clause" + }, "node_modules/buffer-from": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", @@ -4029,6 +4036,15 @@ "node": ">= 0.4" } }, + "node_modules/ecdsa-sig-formatter": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz", + "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==", + "license": "Apache-2.0", + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, "node_modules/ee-first": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", @@ -6133,6 +6149,61 @@ "node": ">=6" } }, + "node_modules/jsonwebtoken": { + "version": "9.0.2", + "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz", + "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==", + "license": "MIT", + "dependencies": { + "jws": "^3.2.2", + "lodash.includes": "^4.3.0", + "lodash.isboolean": "^3.0.3", + "lodash.isinteger": "^4.0.4", + "lodash.isnumber": "^3.0.3", + "lodash.isplainobject": "^4.0.6", + "lodash.isstring": "^4.0.1", + "lodash.once": "^4.0.0", + "ms": "^2.1.1", + "semver": "^7.5.4" + }, + "engines": { + "node": ">=12", + "npm": ">=6" + } + }, + "node_modules/jsonwebtoken/node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jwa": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.2.tgz", + "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==", + "license": "MIT", + "dependencies": { + "buffer-equal-constant-time": "^1.0.1", + "ecdsa-sig-formatter": "1.0.11", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/jws": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz", + "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==", + "license": "MIT", + "dependencies": { + "jwa": "^1.4.1", + "safe-buffer": "^5.0.1" + } + }, "node_modules/kareem": { "version": "2.6.3", "resolved": "https://registry.npmjs.org/kareem/-/kareem-2.6.3.tgz", @@ -6221,6 +6292,42 @@ "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", "license": "MIT" }, + "node_modules/lodash.includes": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz", + "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==", + "license": "MIT" + }, + "node_modules/lodash.isboolean": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz", + "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==", + "license": "MIT" + }, + "node_modules/lodash.isinteger": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz", + "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==", + "license": "MIT" + }, + "node_modules/lodash.isnumber": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz", + "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==", + "license": "MIT" + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "license": "MIT" + }, + "node_modules/lodash.isstring": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz", + "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==", + "license": "MIT" + }, "node_modules/lodash.merge": { "version": "4.6.2", "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", @@ -6228,6 +6335,12 @@ "dev": true, "license": "MIT" }, + "node_modules/lodash.once": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz", + "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==", + "license": "MIT" + }, "node_modules/lodash.snakecase": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz", diff --git a/package.json b/package.json index 29dfc5f..82888b7 100644 --- a/package.json +++ b/package.json @@ -45,6 +45,7 @@ "dotenv": "^16.3.1", "express": "^4.18.2", "helmet": "^7.1.0", + "jsonwebtoken": "^9.0.2", "luxon": "^3.7.1", "mongoose": "^8.0.3", "moonlink.js": "^4.44.4", diff --git a/src/index.js b/src/index.js index 3a152b1..e873c05 100644 --- a/src/index.js +++ b/src/index.js @@ -505,6 +505,16 @@ class MusicBot { }, 10000); // 10 seconds timeout try { + // Gracefully shutdown web server + if (this.client.webModule) { + try { + await this.client.webModule.shutdown(); + logger.info('Web server shut down successfully'); + } catch (err) { + logger.error('Error shutting down web server:', err); + } + } + // Gracefully shutdown Moonlink internal database if (this.client.manager && this.client.manager.database && typeof this.client.manager.database.shutdown === 'function') { try { diff --git a/src/modules/index.js b/src/modules/index.js index a8a2a26..f6de421 100644 --- a/src/modules/index.js +++ b/src/modules/index.js @@ -21,7 +21,7 @@ class ModuleManager { const defaultEnabledModules = [ 'ai', 'information', 'music', 'utils', 'templates', 'selfrole', 'autorole', 'tempvc', 'tickets', - 'general', 'moderation', 'lfg', 'reminders' + 'general', 'moderation', 'lfg', 'reminders', 'web' ]; // Load enabled modules from environment variable or use defaults diff --git a/src/modules/tickets/commands/panel.js b/src/modules/tickets/commands/panel.js index 653ca7b..3615d19 100644 --- a/src/modules/tickets/commands/panel.js +++ b/src/modules/tickets/commands/panel.js @@ -111,7 +111,7 @@ module.exports = { .addStringOption(option => option .setName('type') - .setDescription('Ticket type for this button (e.g. support, bug, etc). This is now dynamic and can be any type configured for your server. Start typing to see suggestions!') + .setDescription('Ticket type for this button (e.g. support, bug, etc).') .setRequired(true) .setAutocomplete(true)) .addStringOption(option => diff --git a/src/modules/web/index.js b/src/modules/web/index.js new file mode 100644 index 0000000..e3dc70b --- /dev/null +++ b/src/modules/web/index.js @@ -0,0 +1,168 @@ +/** + * Web API Module for DeepQuasar Dashboard + * Provides REST API endpoints for frontend dashboard integration + */ + +const express = require('express'); +const cors = require('cors'); +const helmet = require('helmet'); +const path = require('path'); + +// Import route handlers +const authRoutes = require('./routes/auth'); +const guildRoutes = require('./routes/guild'); +const musicRoutes = require('./routes/music'); +const moderationRoutes = require('./routes/moderation'); +const ticketRoutes = require('./routes/tickets'); +const tempvcRoutes = require('./routes/tempvc'); +const userRoutes = require('./routes/user'); +const roleRoutes = require('./routes/roles'); +const reminderRoutes = require('./routes/reminders'); +const lfgRoutes = require('./routes/lfg'); +const templateRoutes = require('./routes/templates'); +const aiRoutes = require('./routes/ai'); + +class WebAPIModule { + constructor() { + this.app = null; + this.server = null; + this.client = null; + } + + /** + * Initialize the web API module + */ + async load(client) { + this.client = client; + + // Create Express app + this.app = express(); + + // Security middleware + this.app.use(helmet({ + contentSecurityPolicy: false, // Allow for dashboard flexibility + })); + + // CORS configuration + this.app.use(cors({ + origin: process.env.DASHBOARD_URL || 'http://localhost:3001', + credentials: true + })); + + // Body parsing middleware + this.app.use(express.json({ limit: '10mb' })); + this.app.use(express.urlencoded({ extended: true, limit: '10mb' })); + + // Add client to request object for all routes + this.app.use((req, res, next) => { + req.client = client; + next(); + }); + + // Health check endpoint + this.app.get('/api/health', (req, res) => { + res.json({ + status: 'ok', + timestamp: new Date().toISOString(), + uptime: process.uptime(), + botStatus: client.isReady() ? 'ready' : 'not ready', + guilds: client.guilds.cache.size, + users: client.guilds.cache.reduce((acc, guild) => acc + guild.memberCount, 0) + }); + }); + + // Mount API routes + this.app.use('/api/auth', authRoutes); + this.app.use('/api/guild', guildRoutes); + this.app.use('/api/music', musicRoutes); + this.app.use('/api/moderation', moderationRoutes); + this.app.use('/api/tickets', ticketRoutes); + this.app.use('/api/tempvc', tempvcRoutes); + this.app.use('/api/user', userRoutes); + this.app.use('/api/roles', roleRoutes); + this.app.use('/api/reminders', reminderRoutes); + this.app.use('/api/lfg', lfgRoutes); + this.app.use('/api/templates', templateRoutes); + this.app.use('/api/ai', aiRoutes); + + // Error handling middleware + this.app.use((error, req, res, next) => { + client.logger.error('API Error:', error); + + if (error.name === 'ValidationError') { + return res.status(400).json({ + error: 'Validation Error', + message: error.message, + details: error.errors + }); + } + + if (error.name === 'JsonWebTokenError') { + return res.status(401).json({ + error: 'Authentication Error', + message: 'Invalid token' + }); + } + + if (error.name === 'TokenExpiredError') { + return res.status(401).json({ + error: 'Authentication Error', + message: 'Token expired' + }); + } + + res.status(error.status || 500).json({ + error: 'Internal Server Error', + message: process.env.NODE_ENV === 'development' ? error.message : 'Something went wrong' + }); + }); + + // 404 handler + this.app.use('*', (req, res) => { + res.status(404).json({ + error: 'Not Found', + message: 'The requested endpoint does not exist' + }); + }); + + // Start server + const port = process.env.WEB_PORT || 3000; + this.server = this.app.listen(port, () => { + client.logger.info(`๐ŸŒ Web API server listening on port ${port}`); + }); + + return { commandCount: 0 }; // This module doesn't add Discord commands + } + + /** + * Shutdown the web server + */ + async shutdown() { + if (this.server) { + return new Promise((resolve) => { + this.server.close(() => { + this.client.logger.info('๐ŸŒ Web API server shut down'); + resolve(); + }); + }); + } + } +} + +// Export module info and loader +module.exports = { + info: { + name: 'Web API', + description: 'REST API for dashboard integration', + version: '1.0.0', + author: 'DeepQuasar Team' + }, + load: async (client) => { + const webModule = new WebAPIModule(); + + // Store module instance for shutdown + client.webModule = webModule; + + return await webModule.load(client); + } +}; \ No newline at end of file diff --git a/src/modules/web/middleware/auth.js b/src/modules/web/middleware/auth.js new file mode 100644 index 0000000..ec02049 --- /dev/null +++ b/src/modules/web/middleware/auth.js @@ -0,0 +1,289 @@ +/** + * Authentication and Authorization Middleware + */ + +const jwt = require('jsonwebtoken'); +const axios = require('axios'); +const Guild = require('../../../schemas/Guild'); + +/** + * Verify Discord access token with Discord API + */ +async function verifyDiscordToken(accessToken) { + try { + const response = await axios.get('https://discord.com/api/users/@me', { + headers: { + 'Authorization': `Bearer ${accessToken}`, + 'User-Agent': 'DeepQuasar Dashboard (https://github.com/karutoil/DeepQuasar, 1.0.0)' + }, + timeout: 10000 + }); + + return { + success: true, + user: response.data + }; + } catch (error) { + return { + success: false, + error: error.response?.status === 401 ? 'Invalid token' : 'Discord API error' + }; + } +} + +/** + * Get user's guilds from Discord API + */ +async function getUserGuilds(accessToken) { + try { + const response = await axios.get('https://discord.com/api/users/@me/guilds', { + headers: { + 'Authorization': `Bearer ${accessToken}`, + 'User-Agent': 'DeepQuasar Dashboard (https://github.com/karutoil/DeepQuasar, 1.0.0)' + }, + timeout: 10000 + }); + + return { + success: true, + guilds: response.data + }; + } catch (error) { + return { + success: false, + error: error.response?.status === 401 ? 'Invalid token' : 'Discord API error' + }; + } +} + +/** + * Generate JWT token for authenticated user + */ +function generateToken(userId, guildId) { + const payload = { + userId, + guildId, + iat: Math.floor(Date.now() / 1000), + exp: Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60) // 7 days + }; + + const secret = process.env.WEB_SECRET || 'your_web_dashboard_secret_here'; + return jwt.sign(payload, secret); +} + +/** + * Verify JWT token middleware + */ +function verifyToken(req, res, next) { + const authHeader = req.headers.authorization; + + if (!authHeader || !authHeader.startsWith('Bearer ')) { + return res.status(401).json({ + error: 'Authentication Required', + message: 'No valid authorization header provided' + }); + } + + const token = authHeader.substring(7); + const secret = process.env.WEB_SECRET || 'your_web_dashboard_secret_here'; + + try { + const decoded = jwt.verify(token, secret); + req.auth = { + userId: decoded.userId, + guildId: decoded.guildId + }; + next(); + } catch (error) { + if (error.name === 'TokenExpiredError') { + return res.status(401).json({ + error: 'Authentication Error', + message: 'Token has expired' + }); + } + + return res.status(401).json({ + error: 'Authentication Error', + message: 'Invalid token' + }); + } +} + +/** + * Validate guild access middleware + */ +async function validateGuildAccess(req, res, next) { + try { + const guildId = req.params.guildId || req.auth.guildId; + + if (!guildId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Guild ID is required' + }); + } + + // Check if bot is in the guild + const guild = req.client.guilds.cache.get(guildId); + if (!guild) { + return res.status(404).json({ + error: 'Guild Not Found', + message: 'Bot is not a member of this guild' + }); + } + + // Check if user is a member of the guild + const member = guild.members.cache.get(req.auth.userId); + if (!member) { + return res.status(403).json({ + error: 'Access Denied', + message: 'You are not a member of this guild' + }); + } + + // Add guild and member to request + req.guild = guild; + req.member = member; + + next(); + } catch (error) { + req.client.logger.error('Guild validation error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to validate guild access' + }); + } +} + +/** + * Check if user has admin permissions in the guild + */ +function requireAdmin(req, res, next) { + if (!req.member) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Guild membership required' + }); + } + + const hasAdminPerms = req.member.permissions.has('Administrator') || + req.member.permissions.has('ManageGuild'); + + if (!hasAdminPerms) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Administrator permissions required' + }); + } + + next(); +} + +/** + * Check if user has moderator permissions in the guild + */ +function requireModerator(req, res, next) { + if (!req.member) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Guild membership required' + }); + } + + const hasModPerms = req.member.permissions.has('Administrator') || + req.member.permissions.has('ManageGuild') || + req.member.permissions.has('ModerateMembers') || + req.member.permissions.has('ManageMessages'); + + if (!hasModPerms) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Moderator permissions required' + }); + } + + next(); +} + +/** + * Check if user has DJ permissions (for music commands) + */ +async function requireDJ(req, res, next) { + try { + if (!req.member) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Guild membership required' + }); + } + + // Admins always have DJ permissions + const hasAdminPerms = req.member.permissions.has('Administrator') || + req.member.permissions.has('ManageGuild'); + + if (hasAdminPerms) { + return next(); + } + + // Check for DJ role from guild settings + const guildSettings = await Guild.findByGuildId(req.guild.id); + if (guildSettings && guildSettings.permissions.djRole) { + const hasDJRole = req.member.roles.cache.has(guildSettings.permissions.djRole); + if (!hasDJRole) { + return res.status(403).json({ + error: 'Access Denied', + message: 'DJ role required' + }); + } + } + + next(); + } catch (error) { + req.client.logger.error('DJ permission check error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to validate DJ permissions' + }); + } +} + +/** + * Rate limiting middleware (simple in-memory implementation) + */ +const rateLimitStore = new Map(); + +function rateLimit(windowMs = 60000, maxRequests = 100) { + return (req, res, next) => { + const identifier = req.auth ? req.auth.userId : req.ip; + const now = Date.now(); + const windowStart = now - windowMs; + + // Clean up old entries + const userRequests = rateLimitStore.get(identifier) || []; + const validRequests = userRequests.filter(timestamp => timestamp > windowStart); + + if (validRequests.length >= maxRequests) { + return res.status(429).json({ + error: 'Rate Limit Exceeded', + message: 'Too many requests, please try again later' + }); + } + + validRequests.push(now); + rateLimitStore.set(identifier, validRequests); + + next(); + }; +} + +module.exports = { + verifyDiscordToken, + getUserGuilds, + generateToken, + verifyToken, + validateGuildAccess, + requireAdmin, + requireModerator, + requireDJ, + rateLimit +}; \ No newline at end of file diff --git a/src/modules/web/routes/ai.js b/src/modules/web/routes/ai.js new file mode 100644 index 0000000..4f3a86c --- /dev/null +++ b/src/modules/web/routes/ai.js @@ -0,0 +1,206 @@ +/** + * AI/Chatbot Configuration Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireAdmin, rateLimit } = require('../middleware/auth'); +const Guild = require('../../../schemas/Guild'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 30)); // 30 requests per minute + +/** + * GET /api/ai/:guildId/config + * Get AI/chatbot configuration + */ +router.get('/:guildId/config', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const guildSettings = await Guild.findByGuildId(req.guild.id); + + if (!guildSettings) { + return res.json({ + success: true, + config: { + enabled: false, + model: 'gpt-3.5-turbo', + maxTokens: 500, + temperature: 0.7, + systemPrompt: 'You are a helpful Discord bot assistant. Be friendly, concise, and helpful.', + responseChance: 10, + channelMode: 'all', + whitelistedChannels: [], + blacklistedChannels: [], + ignoreBots: true, + requireMention: false, + cooldown: 5000, + maxMessageLength: 2000, + conversationEnabled: true + } + }); + } + + res.json({ + success: true, + config: guildSettings.chatbot + }); + + } catch (error) { + req.client.logger.error('AI config fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch AI configuration' + }); + } +}); + +/** + * PUT /api/ai/:guildId/config + * Update AI/chatbot configuration + */ +router.put('/:guildId/config', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const updates = req.body; + + let guildSettings = await Guild.findByGuildId(req.guild.id); + if (!guildSettings) { + guildSettings = await Guild.createDefault(req.guild.id, req.guild.name); + } + + // Update chatbot settings + const allowedFields = [ + 'enabled', 'model', 'maxTokens', 'temperature', 'systemPrompt', + 'responseChance', 'channelMode', 'whitelistedChannels', 'blacklistedChannels', + 'ignoreBots', 'requireMention', 'cooldown', 'maxMessageLength', 'conversationEnabled' + ]; + + allowedFields.forEach(field => { + if (updates[field] !== undefined) { + guildSettings.chatbot[field] = updates[field]; + } + }); + + // Validate numeric fields + if (guildSettings.chatbot.maxTokens < 50) guildSettings.chatbot.maxTokens = 50; + if (guildSettings.chatbot.maxTokens > 4000) guildSettings.chatbot.maxTokens = 4000; + if (guildSettings.chatbot.temperature < 0) guildSettings.chatbot.temperature = 0; + if (guildSettings.chatbot.temperature > 2) guildSettings.chatbot.temperature = 2; + if (guildSettings.chatbot.responseChance < 0) guildSettings.chatbot.responseChance = 0; + if (guildSettings.chatbot.responseChance > 100) guildSettings.chatbot.responseChance = 100; + if (guildSettings.chatbot.cooldown < 1000) guildSettings.chatbot.cooldown = 1000; + if (guildSettings.chatbot.cooldown > 60000) guildSettings.chatbot.cooldown = 60000; + if (guildSettings.chatbot.maxMessageLength < 100) guildSettings.chatbot.maxMessageLength = 100; + if (guildSettings.chatbot.maxMessageLength > 4000) guildSettings.chatbot.maxMessageLength = 4000; + + await guildSettings.save(); + + res.json({ + success: true, + message: 'AI configuration updated successfully', + config: guildSettings.chatbot + }); + + } catch (error) { + req.client.logger.error('AI config update error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update AI configuration' + }); + } +}); + +/** + * POST /api/ai/:guildId/test + * Test AI response (admin only) + */ +router.post('/:guildId/test', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { message } = req.body; + + if (!message || message.trim().length === 0) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Test message is required' + }); + } + + // Check if chatbot is available + if (!req.client.chatBot) { + return res.status(503).json({ + error: 'Service Unavailable', + message: 'AI chatbot service is not available' + }); + } + + const guildSettings = await Guild.findByGuildId(req.guild.id); + if (!guildSettings || !guildSettings.chatbot.enabled) { + return res.status(400).json({ + error: 'AI Disabled', + message: 'AI chatbot is not enabled for this guild' + }); + } + + // Create a mock message object for testing + const mockMessage = { + content: message.trim(), + author: req.member.user, + guild: req.guild, + channel: { id: 'test-channel' } + }; + + // Test the AI response + const response = await req.client.chatBot.generateResponse(mockMessage, guildSettings.chatbot); + + res.json({ + success: true, + input: message.trim(), + response: response || 'No response generated', + timestamp: new Date().toISOString() + }); + + } catch (error) { + req.client.logger.error('AI test error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to test AI response' + }); + } +}); + +/** + * GET /api/ai/:guildId/stats + * Get AI usage statistics + */ +router.get('/:guildId/stats', validateGuildAccess, requireAdmin, async (req, res) => { + try { + // This would require implementing usage tracking in the chatbot + // For now, return basic information + const guildSettings = await Guild.findByGuildId(req.guild.id); + + res.json({ + success: true, + stats: { + enabled: guildSettings?.chatbot?.enabled || false, + model: guildSettings?.chatbot?.model || 'gpt-3.5-turbo', + totalChannels: req.guild.channels.cache.filter(c => c.isTextBased()).size, + whitelistedChannels: guildSettings?.chatbot?.whitelistedChannels?.length || 0, + blacklistedChannels: guildSettings?.chatbot?.blacklistedChannels?.length || 0, + responseChance: guildSettings?.chatbot?.responseChance || 10, + // These would need to be tracked in the database + messagesProcessed: 0, + responsesGenerated: 0, + averageResponseTime: 0 + } + }); + + } catch (error) { + req.client.logger.error('AI stats fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch AI statistics' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/auth.js b/src/modules/web/routes/auth.js new file mode 100644 index 0000000..16b9d8c --- /dev/null +++ b/src/modules/web/routes/auth.js @@ -0,0 +1,460 @@ +/** + * Authentication Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyDiscordToken, getUserGuilds, generateToken, verifyToken, validateGuildAccess } = require('../middleware/auth'); + +/** + * POST /api/auth/login + * Authenticate user with Discord OAuth2 access token + */ +router.post('/login', async (req, res) => { + try { + const { accessToken, guildId } = req.body; + + if (!accessToken || !guildId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'accessToken and guildId are required' + }); + } + + // Verify Discord access token + const tokenValidation = await verifyDiscordToken(accessToken); + if (!tokenValidation.success) { + return res.status(401).json({ + error: 'Authentication Failed', + message: tokenValidation.error || 'Invalid Discord access token' + }); + } + + const discordUser = tokenValidation.user; + + // Get user's guilds to verify they have access to the requested guild + const userGuildsResponse = await getUserGuilds(accessToken); + if (!userGuildsResponse.success) { + return res.status(401).json({ + error: 'Authentication Failed', + message: 'Unable to fetch user guilds from Discord' + }); + } + + // Check if user has admin/manage permissions in the requested guild + const userGuild = userGuildsResponse.guilds.find(g => g.id === guildId); + if (!userGuild) { + return res.status(403).json({ + error: 'Access Denied', + message: 'You are not a member of the specified guild' + }); + } + + // Check if user has admin or manage guild permissions (0x8 = Admin, 0x20 = Manage Guild) + const hasRequiredPerms = (parseInt(userGuild.permissions) & (0x8 | 0x20)) !== 0; + if (!hasRequiredPerms) { + return res.status(403).json({ + error: 'Access Denied', + message: 'You need Administrator or Manage Guild permissions' + }); + } + + // Validate that the bot is in the guild + const guild = req.client.guilds.cache.get(guildId); + if (!guild) { + return res.status(404).json({ + error: 'Guild Not Found', + message: 'Bot is not a member of the specified guild' + }); + } + + // Get member object for additional details + let member = guild.members.cache.get(discordUser.id); + if (!member) { + // Try to fetch the member from the API in case the cache is stale + try { + member = await guild.members.fetch(discordUser.id); + } catch (fetchErr) { + req.client.logger?.warn?.('Failed to fetch member from Discord API:', fetchErr); + } + } + if (!member) { + return res.status(403).json({ + error: 'Access Denied', + message: 'User is not a member of the specified guild (not found in cache or via fetch)' + }); + } + + // Generate JWT token + const token = generateToken(discordUser.id, guildId); + + res.json({ + success: true, + token, + user: { + id: discordUser.id, + username: discordUser.username, + globalName: discordUser.global_name, + displayName: member.displayName, + avatar: discordUser.avatar ? + `https://cdn.discordapp.com/avatars/${discordUser.id}/${discordUser.avatar}.png` : + `https://cdn.discordapp.com/embed/avatars/${parseInt(discordUser.discriminator) % 5}.png`, + permissions: { + administrator: member.permissions.has('Administrator'), + manageGuild: member.permissions.has('ManageGuild'), + moderateMembers: member.permissions.has('ModerateMembers'), + manageMessages: member.permissions.has('ManageMessages') + } + }, + guild: { + id: guild.id, + name: guild.name, + icon: guild.iconURL(), + memberCount: guild.memberCount + } + }); + + } catch (error) { + req.client.logger.error('Authentication error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Authentication failed' + }); + } +}); + +/** + * POST /api/auth/verify + * Verify if current token is valid + */ +router.post('/verify', verifyToken, validateGuildAccess, (req, res) => { + res.json({ + success: true, + valid: true, + user: { + id: req.member.user.id, + username: req.member.user.username, + displayName: req.member.displayName, + avatar: req.member.user.displayAvatarURL(), + permissions: { + administrator: req.member.permissions.has('Administrator'), + manageGuild: req.member.permissions.has('ManageGuild'), + moderateMembers: req.member.permissions.has('ModerateMembers'), + manageMessages: req.member.permissions.has('ManageMessages') + } + }, + guild: { + id: req.guild.id, + name: req.guild.name, + icon: req.guild.iconURL(), + memberCount: req.guild.memberCount + } + }); +}); + +/** + * GET /api/auth/guilds + * Get list of guilds where user has admin permissions and bot is present + * Requires Discord access token + */ +router.post('/guilds', async (req, res) => { + try { + const { accessToken } = req.body; + + if (!accessToken) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Discord accessToken is required' + }); + } + + // Verify Discord access token + const tokenValidation = await verifyDiscordToken(accessToken); + if (!tokenValidation.success) { + return res.status(401).json({ + error: 'Authentication Failed', + message: tokenValidation.error || 'Invalid Discord access token' + }); + } + + // Get user's guilds from Discord + const userGuildsResponse = await getUserGuilds(accessToken); + if (!userGuildsResponse.success) { + return res.status(401).json({ + error: 'Authentication Failed', + message: 'Unable to fetch user guilds from Discord' + }); + } + + const managedGuilds = []; + + // Filter guilds where user has admin/manage permissions and bot is present + for (const userGuild of userGuildsResponse.guilds) { + // Check if user has admin or manage guild permissions + const hasRequiredPerms = (parseInt(userGuild.permissions) & (0x8 | 0x20)) !== 0; + if (!hasRequiredPerms) continue; + + // Check if bot is in this guild + const botGuild = req.client.guilds.cache.get(userGuild.id); + if (!botGuild) continue; + + managedGuilds.push({ + id: botGuild.id, + name: botGuild.name, + icon: botGuild.iconURL(), + memberCount: botGuild.memberCount, + permissions: { + administrator: (parseInt(userGuild.permissions) & 0x8) !== 0, + manageGuild: (parseInt(userGuild.permissions) & 0x20) !== 0 + } + }); + } + + res.json({ + success: true, + guilds: managedGuilds + }); + + } catch (error) { + req.client.logger.error('Guild list error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch user guilds' + }); + } +}); + +/** + * POST /api/auth/refresh + * Refresh an existing token + */ +router.post('/refresh', verifyToken, (req, res) => { + try { + // Generate new token with same user/guild + const newToken = generateToken(req.auth.userId, req.auth.guildId); + + res.json({ + success: true, + token: newToken + }); + + } catch (error) { + req.client.logger.error('Token refresh error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to refresh token' + }); + } +}); + +/** + * GET /api/auth/dev-helper + * Returns the Discord OAuth2 callback URL and (optionally) the access token if provided. + * This is for development/testing purposes only. + */ +const axios = require('axios'); + +router.get('/dev-helper', async (req, res) => { + // You may want to set this from config/env in production! + // Use the same redirect_uri as you registered in your Discord application settings. + // If you set REDIRECT_URI, it will be used. Otherwise, fallback to PUBLIC_URL or http://localhost:3000. + const redirectUri = + process.env.REDIRECT_URI || + ((process.env.PUBLIC_URL || 'http://localhost:3000') + '/api/auth/callback'); + const callbackUrl = redirectUri; + + // Try to get access token from query or header for convenience + let accessToken = req.query.accessToken || req.headers['authorization']?.replace(/^Bearer /, ''); + + // If a code is provided, try to exchange it for an access token + if (req.query.code) { + const clientId = process.env.DISCORD_CLIENT_ID; + const clientSecret = process.env.DISCORD_CLIENT_SECRET; + + if (!clientId || !clientSecret) { + return res.status(500).json({ + error: "Config Error", + message: "DISCORD_CLIENT_ID and DISCORD_CLIENT_SECRET must be set in environment" + }); + } + + try { + const params = new URLSearchParams(); + params.append('grant_type', 'authorization_code'); + params.append('code', req.query.code); + params.append('redirect_uri', redirectUri); + // Discord does not require scope for token exchange, but if you do, use the same as in the original auth request + // params.append('scope', 'identify guilds'); + + const tokenRes = await axios.post('https://discord.com/api/oauth2/token', params.toString(), { + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + auth: { + username: clientId, + password: clientSecret + } + }); + + accessToken = tokenRes.data.access_token; + } catch (err) { + return res.status(400).json({ + error: "Authentication Error", + message: "Invalid code or failed to exchange code for token", + details: err.response?.data || err.message + }); + } + } + + res.json({ + discord_oauth_callback_url: callbackUrl, + info: "Set this as a Redirect URI in your Discord application settings. It must match exactly in your Discord developer portal and in the OAuth2 code exchange.", + effective_redirect_uri: redirectUri, + ...(accessToken ? { accessToken } : {}), + note: "To get your access token, complete the OAuth2 flow. This endpoint is for development/testing only.", + full_redirect_uri_for_discord: redirectUri + }); +}); + +/** + * GET /api/auth/callback + * Minimal endpoint to satisfy Discord OAuth2 redirect_uri requirement. + * You can customize this to redirect to your frontend or show a message. + */ +router.get('/callback', async (req, res) => { + const code = req.query.code; + const error = req.query.error; + const redirectUri = + process.env.REDIRECT_URI || + ((process.env.PUBLIC_URL || 'http://localhost:3000') + '/api/auth/callback'); + const clientId = process.env.DISCORD_CLIENT_ID; + const clientSecret = process.env.DISCORD_CLIENT_SECRET; + + if (error) { + return res.send(` + + OAuth2 Callback + +

OAuth2 Error

+ 
${error}
+ + + `); + } + + if (!code) { + return res.send(` + + OAuth2 Callback + +

No code provided.

+ + + `); + } + + if (!clientId || !clientSecret) { + return res.send(` + + OAuth2 Callback + +

Config Error

+ 
DISCORD_CLIENT_ID and DISCORD_CLIENT_SECRET must be set in environment
+ + + `); + } + + try { + const params = new URLSearchParams(); + params.append('grant_type', 'authorization_code'); + params.append('code', code); + params.append('redirect_uri', redirectUri); + + const axios = require('axios'); + const tokenRes = await axios.post('https://discord.com/api/oauth2/token', params.toString(), { + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + auth: { + username: clientId, + password: clientSecret + } + }); + + const tokenData = tokenRes.data; + + res.send(` + + OAuth2 Callback + +

Authentication successful!

+

Access Token Response:

+ 
${JSON.stringify(tokenData, null, 2)}
+

+ Next step: Use the access_token above to POST to /api/auth/login with a JSON body:
+ 

{
+  "accessToken": "${tokenData.access_token}",
+  "guildId": "YOUR_GUILD_ID"
+}
+
+ The response will include a token (JWT) to use with /api/auth/verify and other endpoints.
+
+ Example curl:
+ 
curl -X POST http://localhost:3000/api/auth/login -H "Content-Type: application/json" -d '{"accessToken": "${tokenData.access_token}", "guildId": "YOUR_GUILD_ID"}'
+

+

You may close this window.

+ + + `); + } catch (err) { + res.send(` + + OAuth2 Callback + +

Token Exchange Failed

+ 
${err.response?.data ? JSON.stringify(err.response.data, null, 2) : err.message}
+ + + `); + } +}); + +/** + * GET /api/auth/me + * Returns the authenticated user's Discord info and permissions in the current guild. + * Requires a valid JWT in Authorization header. + */ +router.get('/me', verifyToken, validateGuildAccess, (req, res) => { + res.json({ + success: true, + user: { + id: req.member.user.id, + username: req.member.user.username, + displayName: req.member.displayName, + avatar: req.member.user.displayAvatarURL(), + permissions: { + administrator: req.member.permissions.has('Administrator'), + manageGuild: req.member.permissions.has('ManageGuild'), + moderateMembers: req.member.permissions.has('ModerateMembers'), + manageMessages: req.member.permissions.has('ManageMessages') + } + }, + guild: { + id: req.guild.id, + name: req.guild.name, + icon: req.guild.iconURL(), + memberCount: req.guild.memberCount + } + }); +}); + +/** + * GET /api/auth/ping + * Simple health check endpoint. + */ +router.get('/ping', (req, res) => { + res.json({ success: true, message: 'pong', timestamp: Date.now() }); +}); + +module.exports = router; diff --git a/src/modules/web/routes/guild.js b/src/modules/web/routes/guild.js new file mode 100644 index 0000000..a787cd2 --- /dev/null +++ b/src/modules/web/routes/guild.js @@ -0,0 +1,281 @@ +/** + * Guild Management Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireAdmin, rateLimit } = require('../middleware/auth'); +const Guild = require('../../../schemas/Guild'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/guild/:guildId + * Get guild information and bot settings + */ +router.get('/:guildId', validateGuildAccess, async (req, res) => { + try { + const guildSettings = await Guild.findByGuildId(req.guild.id) || + await Guild.createDefault(req.guild.id, req.guild.name); + + res.json({ + success: true, + guild: { + id: req.guild.id, + name: req.guild.name, + icon: req.guild.iconURL(), + memberCount: req.guild.memberCount, + botJoinedAt: req.guild.joinedAt, + features: req.guild.features, + settings: guildSettings + } + }); + + } catch (error) { + req.client.logger.error('Guild fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch guild information' + }); + } +}); + +/** + * PUT /api/guild/:guildId/settings + * Update guild settings (admin only) + */ +router.put('/:guildId/settings', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const updates = req.body; + + // Find or create guild settings + let guildSettings = await Guild.findByGuildId(req.guild.id); + if (!guildSettings) { + guildSettings = await Guild.createDefault(req.guild.id, req.guild.name); + } + + // Update allowed fields + const allowedFields = [ + 'musicSettings', + 'commandSettings', + 'queueSettings', + 'logging', + 'chatbot', + 'messageLinkEmbed', + 'welcomeSystem', + 'autoRole', + 'permissions' + ]; + + for (const field of allowedFields) { + if (updates[field] !== undefined) { + guildSettings[field] = { ...guildSettings[field], ...updates[field] }; + } + } + + await guildSettings.save(); + + res.json({ + success: true, + message: 'Guild settings updated successfully', + settings: guildSettings + }); + + } catch (error) { + req.client.logger.error('Guild settings update error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update guild settings' + }); + } +}); + +/** + * GET /api/guild/:guildId/channels + * Get list of channels in the guild + */ +router.get('/:guildId/channels', validateGuildAccess, (req, res) => { + try { + const channels = req.guild.channels.cache + .filter(channel => channel.type !== 4) // Exclude category channels + .map(channel => ({ + id: channel.id, + name: channel.name, + type: channel.type, + position: channel.position, + parentId: channel.parentId, + permission: { + viewChannel: channel.permissionsFor(req.member)?.has('ViewChannel') || false, + sendMessages: channel.permissionsFor(req.member)?.has('SendMessages') || false, + manageChannel: channel.permissionsFor(req.member)?.has('ManageChannels') || false + } + })) + .sort((a, b) => a.position - b.position); + + res.json({ + success: true, + channels + }); + + } catch (error) { + req.client.logger.error('Channels fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch guild channels' + }); + } +}); + +/** + * GET /api/guild/:guildId/roles + * Get list of roles in the guild + */ +router.get('/:guildId/roles', validateGuildAccess, (req, res) => { + try { + const roles = req.guild.roles.cache + .filter(role => role.id !== req.guild.id) // Exclude @everyone role + .map(role => ({ + id: role.id, + name: role.name, + color: role.hexColor, + position: role.position, + permissions: role.permissions.toArray(), + managed: role.managed, + mentionable: role.mentionable, + memberCount: role.members.size + })) + .sort((a, b) => b.position - a.position); + + res.json({ + success: true, + roles + }); + + } catch (error) { + req.client.logger.error('Roles fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch guild roles' + }); + } +}); + +/** + * GET /api/guild/:guildId/members + * Get list of members in the guild (with pagination) + */ +router.get('/:guildId/members', validateGuildAccess, (req, res) => { + try { + const page = parseInt(req.query.page) || 1; + const limit = Math.min(parseInt(req.query.limit) || 20, 100); + const search = req.query.search?.toLowerCase(); + + let members = Array.from(req.guild.members.cache.values()); + + // Apply search filter + if (search) { + members = members.filter(member => + member.user.username.toLowerCase().includes(search) || + member.displayName.toLowerCase().includes(search) || + member.user.id.includes(search) + ); + } + + // Sort by join date (newest first) + members.sort((a, b) => b.joinedTimestamp - a.joinedTimestamp); + + // Apply pagination + const startIndex = (page - 1) * limit; + const endIndex = startIndex + limit; + const paginatedMembers = members.slice(startIndex, endIndex); + + const memberData = paginatedMembers.map(member => ({ + id: member.user.id, + username: member.user.username, + displayName: member.displayName, + avatar: member.user.displayAvatarURL(), + joinedAt: member.joinedAt, + roles: member.roles.cache + .filter(role => role.id !== req.guild.id) + .map(role => ({ + id: role.id, + name: role.name, + color: role.hexColor + })), + permissions: { + administrator: member.permissions.has('Administrator'), + manageGuild: member.permissions.has('ManageGuild'), + moderateMembers: member.permissions.has('ModerateMembers') + } + })); + + res.json({ + success: true, + members: memberData, + pagination: { + page, + limit, + total: members.length, + totalPages: Math.ceil(members.length / limit), + hasNext: endIndex < members.length, + hasPrev: page > 1 + } + }); + + } catch (error) { + req.client.logger.error('Members fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch guild members' + }); + } +}); + +/** + * GET /api/guild/:guildId/stats + * Get guild statistics + */ +router.get('/:guildId/stats', validateGuildAccess, async (req, res) => { + try { + const guildSettings = await Guild.findByGuildId(req.guild.id); + + // Calculate basic stats + const stats = { + members: { + total: req.guild.memberCount, + online: req.guild.members.cache.filter(m => m.presence?.status === 'online').size, + bots: req.guild.members.cache.filter(m => m.user.bot).size + }, + channels: { + total: req.guild.channels.cache.size, + text: req.guild.channels.cache.filter(c => c.type === 0).size, + voice: req.guild.channels.cache.filter(c => c.type === 2).size, + categories: req.guild.channels.cache.filter(c => c.type === 4).size + }, + roles: req.guild.roles.cache.size - 1, // Exclude @everyone + bot: { + joinedAt: req.guild.joinedAt, + commandsUsed: guildSettings?.stats?.commandsUsed || 0, + songsPlayed: guildSettings?.stats?.songsPlayed || 0, + totalPlaytime: guildSettings?.stats?.totalPlaytime || 0, + lastActivity: guildSettings?.stats?.lastActivity + } + }; + + res.json({ + success: true, + stats + }); + + } catch (error) { + req.client.logger.error('Stats fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch guild statistics' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/lfg.js b/src/modules/web/routes/lfg.js new file mode 100644 index 0000000..40e2c37 --- /dev/null +++ b/src/modules/web/routes/lfg.js @@ -0,0 +1,166 @@ +/** + * LFG (Looking for Group) Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireModerator, rateLimit } = require('../middleware/auth'); +const LFGPost = require('../../../schemas/LFGPost'); +const LFGSettings = require('../../../schemas/LFGSettings'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/lfg/:guildId/posts + * Get LFG posts + */ +router.get('/:guildId/posts', validateGuildAccess, async (req, res) => { + try { + const page = parseInt(req.query.page) || 1; + const limit = Math.min(parseInt(req.query.limit) || 20, 100); + const game = req.query.game; + const status = req.query.status || 'active'; // active, filled, expired + + const query = { guildId: req.guild.id }; + if (game) query.game = new RegExp(game, 'i'); + if (status !== 'all') query.status = status; + + const total = await LFGPost.countDocuments(query); + const posts = await LFGPost.find(query) + .sort({ createdAt: -1 }) + .limit(limit) + .skip((page - 1) * limit); + + res.json({ + success: true, + posts, + pagination: { + page, + limit, + total, + totalPages: Math.ceil(total / limit) + } + }); + + } catch (error) { + req.client.logger.error('LFG posts fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch LFG posts' + }); + } +}); + +/** + * GET /api/lfg/:guildId/settings + * Get LFG settings + */ +router.get('/:guildId/settings', validateGuildAccess, requireModerator, async (req, res) => { + try { + const settings = await LFGSettings.findOne({ guildId: req.guild.id }); + + res.json({ + success: true, + settings: settings || { + enabled: false, + channelId: null, + autoDeleteAfter: 24, + allowedGames: [], + maxPostsPerUser: 3 + } + }); + + } catch (error) { + req.client.logger.error('LFG settings fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch LFG settings' + }); + } +}); + +/** + * PUT /api/lfg/:guildId/settings + * Update LFG settings + */ +router.put('/:guildId/settings', validateGuildAccess, requireModerator, async (req, res) => { + try { + const updates = req.body; + + let settings = await LFGSettings.findOne({ guildId: req.guild.id }); + if (!settings) { + settings = new LFGSettings({ guildId: req.guild.id }); + } + + // Update allowed fields + const allowedFields = ['enabled', 'channelId', 'autoDeleteAfter', 'allowedGames', 'maxPostsPerUser']; + allowedFields.forEach(field => { + if (updates[field] !== undefined) { + settings[field] = updates[field]; + } + }); + + await settings.save(); + + res.json({ + success: true, + message: 'LFG settings updated', + settings + }); + + } catch (error) { + req.client.logger.error('LFG settings update error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update LFG settings' + }); + } +}); + +/** + * DELETE /api/lfg/:guildId/posts/:postId + * Delete an LFG post + */ +router.delete('/:guildId/posts/:postId', validateGuildAccess, async (req, res) => { + try { + const { postId } = req.params; + + const post = await LFGPost.findOne({ + _id: postId, + guildId: req.guild.id + }); + + if (!post) { + return res.status(404).json({ + error: 'Post Not Found', + message: 'LFG post does not exist' + }); + } + + // Users can delete their own posts, moderators can delete any + if (post.authorId !== req.auth.userId && !req.member.permissions.has('ModerateMembers')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Can only delete your own posts' + }); + } + + await LFGPost.deleteOne({ _id: postId }); + + res.json({ + success: true, + message: 'LFG post deleted successfully' + }); + + } catch (error) { + req.client.logger.error('Delete LFG post error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to delete LFG post' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/moderation.js b/src/modules/web/routes/moderation.js new file mode 100644 index 0000000..93740df --- /dev/null +++ b/src/modules/web/routes/moderation.js @@ -0,0 +1,448 @@ +/** + * Moderation Module Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireModerator, rateLimit } = require('../middleware/auth'); +const ModLog = require('../../../schemas/ModLog'); +const UserNotes = require('../../../schemas/UserNotes'); +const PunishmentLog = require('../../../schemas/PunishmentLog'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 30)); // 30 requests per minute + +/** + * GET /api/moderation/:guildId/logs + * Get moderation logs with pagination + */ +router.get('/:guildId/logs', validateGuildAccess, requireModerator, async (req, res) => { + try { + const page = parseInt(req.query.page) || 1; + const limit = Math.min(parseInt(req.query.limit) || 20, 100); + const type = req.query.type; // Optional filter by action type + const userId = req.query.userId; // Optional filter by user + + const query = { guildId: req.guild.id }; + if (type) query.action = type; + if (userId) query.userId = userId; + + const total = await ModLog.countDocuments(query); + const logs = await ModLog.find(query) + .sort({ createdAt: -1 }) + .limit(limit) + .skip((page - 1) * limit) + .populate('userId', 'username discriminator avatar') + .populate('moderatorId', 'username discriminator avatar'); + + res.json({ + success: true, + logs, + pagination: { + page, + limit, + total, + totalPages: Math.ceil(total / limit), + hasNext: page * limit < total, + hasPrev: page > 1 + } + }); + + } catch (error) { + req.client.logger.error('Moderation logs fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch moderation logs' + }); + } +}); + +/** + * POST /api/moderation/:guildId/kick + * Kick a member from the guild + */ +router.post('/:guildId/kick', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId, reason } = req.body; + + if (!userId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'User ID is required' + }); + } + + const member = req.guild.members.cache.get(userId); + if (!member) { + return res.status(404).json({ + error: 'Member Not Found', + message: 'User is not a member of this guild' + }); + } + + // Check permissions + if (!member.kickable) { + return res.status(403).json({ + error: 'Insufficient Permissions', + message: 'Cannot kick this member due to role hierarchy' + }); + } + + if (member.permissions.has('Administrator')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Cannot kick administrators' + }); + } + + // Perform kick + await member.kick(reason || 'No reason provided'); + + // Log the action + await ModLog.create({ + guildId: req.guild.id, + userId: userId, + moderatorId: req.member.id, + action: 'KICK', + reason: reason || 'No reason provided' + }); + + res.json({ + success: true, + message: `Successfully kicked ${member.user.username}`, + action: { + type: 'kick', + target: { + id: member.user.id, + username: member.user.username, + discriminator: member.user.discriminator + }, + moderator: { + id: req.member.id, + username: req.member.user.username + }, + reason: reason || 'No reason provided' + } + }); + + } catch (error) { + req.client.logger.error('Kick member error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to kick member' + }); + } +}); + +/** + * POST /api/moderation/:guildId/ban + * Ban a user from the guild + */ +router.post('/:guildId/ban', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId, reason, deleteMessageDays = 0 } = req.body; + + if (!userId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'User ID is required' + }); + } + + // Check if user is already banned + const existingBan = await req.guild.bans.fetch(userId).catch(() => null); + if (existingBan) { + return res.status(400).json({ + error: 'Already Banned', + message: 'User is already banned from this guild' + }); + } + + const member = req.guild.members.cache.get(userId); + + // If member exists, check permissions + if (member) { + if (!member.bannable) { + return res.status(403).json({ + error: 'Insufficient Permissions', + message: 'Cannot ban this member due to role hierarchy' + }); + } + + if (member.permissions.has('Administrator')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Cannot ban administrators' + }); + } + } + + // Perform ban + await req.guild.members.ban(userId, { + reason: reason || 'No reason provided', + deleteMessageDays: Math.min(deleteMessageDays, 7) + }); + + // Log the action + await ModLog.create({ + guildId: req.guild.id, + userId: userId, + moderatorId: req.member.id, + action: 'BAN', + reason: reason || 'No reason provided' + }); + + const targetUser = member ? member.user : await req.client.users.fetch(userId).catch(() => null); + + res.json({ + success: true, + message: `Successfully banned ${targetUser?.username || 'user'}`, + action: { + type: 'ban', + target: { + id: userId, + username: targetUser?.username || 'Unknown', + discriminator: targetUser?.discriminator || '0000' + }, + moderator: { + id: req.member.id, + username: req.member.user.username + }, + reason: reason || 'No reason provided' + } + }); + + } catch (error) { + req.client.logger.error('Ban user error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to ban user' + }); + } +}); + +/** + * DELETE /api/moderation/:guildId/ban/:userId + * Unban a user from the guild + */ +router.delete('/:guildId/ban/:userId', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId } = req.params; + const { reason } = req.body; + + // Check if user is banned + const ban = await req.guild.bans.fetch(userId).catch(() => null); + if (!ban) { + return res.status(404).json({ + error: 'Not Banned', + message: 'User is not banned from this guild' + }); + } + + // Perform unban + await req.guild.members.unban(userId, reason || 'No reason provided'); + + // Log the action + await ModLog.create({ + guildId: req.guild.id, + userId: userId, + moderatorId: req.member.id, + action: 'UNBAN', + reason: reason || 'No reason provided' + }); + + res.json({ + success: true, + message: `Successfully unbanned ${ban.user.username}`, + action: { + type: 'unban', + target: { + id: ban.user.id, + username: ban.user.username, + discriminator: ban.user.discriminator + }, + moderator: { + id: req.member.id, + username: req.member.user.username + }, + reason: reason || 'No reason provided' + } + }); + + } catch (error) { + req.client.logger.error('Unban user error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to unban user' + }); + } +}); + +/** + * POST /api/moderation/:guildId/timeout + * Timeout a member + */ +router.post('/:guildId/timeout', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId, duration, reason } = req.body; + + if (!userId || !duration) { + return res.status(400).json({ + error: 'Bad Request', + message: 'User ID and duration are required' + }); + } + + const member = req.guild.members.cache.get(userId); + if (!member) { + return res.status(404).json({ + error: 'Member Not Found', + message: 'User is not a member of this guild' + }); + } + + // Check permissions + if (!member.moderatable) { + return res.status(403).json({ + error: 'Insufficient Permissions', + message: 'Cannot timeout this member due to role hierarchy' + }); + } + + if (member.permissions.has('Administrator')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Cannot timeout administrators' + }); + } + + // Validate duration (max 28 days) + const maxDuration = 28 * 24 * 60 * 60 * 1000; // 28 days in milliseconds + const timeoutDuration = Math.min(parseInt(duration), maxDuration); + + // Perform timeout + await member.timeout(timeoutDuration, reason || 'No reason provided'); + + // Log the action + await ModLog.create({ + guildId: req.guild.id, + userId: userId, + moderatorId: req.member.id, + action: 'TIMEOUT', + reason: reason || 'No reason provided', + duration: timeoutDuration + }); + + res.json({ + success: true, + message: `Successfully timed out ${member.user.username} for ${Math.floor(timeoutDuration / (60 * 1000))} minutes`, + action: { + type: 'timeout', + target: { + id: member.user.id, + username: member.user.username, + discriminator: member.user.discriminator + }, + moderator: { + id: req.member.id, + username: req.member.user.username + }, + reason: reason || 'No reason provided', + duration: timeoutDuration + } + }); + + } catch (error) { + req.client.logger.error('Timeout member error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to timeout member' + }); + } +}); + +/** + * GET /api/moderation/:guildId/user/:userId/notes + * Get user notes + */ +router.get('/:guildId/user/:userId/notes', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId } = req.params; + + const userNotes = await UserNotes.findOne({ + guildId: req.guild.id, + userId: userId + }); + + res.json({ + success: true, + notes: userNotes?.notes || [] + }); + + } catch (error) { + req.client.logger.error('User notes fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch user notes' + }); + } +}); + +/** + * POST /api/moderation/:guildId/user/:userId/notes + * Add a note to a user + */ +router.post('/:guildId/user/:userId/notes', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { userId } = req.params; + const { note } = req.body; + + if (!note || note.trim().length === 0) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Note content is required' + }); + } + + const newNote = { + id: Date.now().toString(), + moderatorId: req.member.id, + moderatorTag: req.member.user.tag, + note: note.trim(), + createdAt: new Date() + }; + + let userNotes = await UserNotes.findOne({ + guildId: req.guild.id, + userId: userId + }); + + if (!userNotes) { + userNotes = new UserNotes({ + guildId: req.guild.id, + userId: userId, + notes: [newNote] + }); + } else { + userNotes.notes.push(newNote); + } + + await userNotes.save(); + + res.json({ + success: true, + message: 'Note added successfully', + note: newNote + }); + + } catch (error) { + req.client.logger.error('Add user note error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to add user note' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/music.js b/src/modules/web/routes/music.js new file mode 100644 index 0000000..25bb55b --- /dev/null +++ b/src/modules/web/routes/music.js @@ -0,0 +1,420 @@ +/** + * Music Module Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireDJ, rateLimit } = require('../middleware/auth'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 30)); // 30 requests per minute + +/** + * GET /api/music/:guildId/player + * Get current player status and queue + */ +router.get('/:guildId/player', validateGuildAccess, (req, res) => { + try { + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player) { + return res.json({ + success: true, + player: null, + queue: [], + status: 'not_playing' + }); + } + + const currentTrack = player.current; + const queue = player.queue.map(track => ({ + title: track.title, + author: track.author, + duration: track.duration, + uri: track.uri, + requester: track.requester?.id || null, + thumbnail: track.thumbnail + })); + + res.json({ + success: true, + player: { + guildId: player.guildId, + voiceChannelId: player.voiceChannelId, + textChannelId: player.textChannelId, + connected: player.connected, + playing: player.playing, + paused: player.paused, + volume: player.volume, + position: player.position, + repeatMode: player.repeatMode, + shuffled: player.shuffled + }, + currentTrack: currentTrack ? { + title: currentTrack.title, + author: currentTrack.author, + duration: currentTrack.duration, + uri: currentTrack.uri, + requester: currentTrack.requester?.id || null, + thumbnail: currentTrack.thumbnail, + position: player.position + } : null, + queue, + status: player.playing ? 'playing' : player.paused ? 'paused' : 'stopped' + }); + + } catch (error) { + req.client.logger.error('Music player fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch player status' + }); + } +}); + +/** + * POST /api/music/:guildId/play + * Add a track to queue or start playing + */ +router.post('/:guildId/play', validateGuildAccess, requireDJ, async (req, res) => { + try { + const { query, voiceChannelId } = req.body; + + if (!query) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Search query is required' + }); + } + + if (!voiceChannelId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Voice channel ID is required' + }); + } + + // Validate voice channel + const voiceChannel = req.guild.channels.cache.get(voiceChannelId); + if (!voiceChannel || voiceChannel.type !== 2) { + return res.status(400).json({ + error: 'Invalid Channel', + message: 'Specified voice channel not found' + }); + } + + // Check if manager exists + if (!req.client.manager) { + return res.status(503).json({ + error: 'Service Unavailable', + message: 'Music service is not available' + }); + } + + // Get or create player + let player = req.client.manager.players.cache.get(req.guild.id); + if (!player) { + player = req.client.manager.createPlayer({ + guildId: req.guild.id, + voiceChannelId: voiceChannelId, + textChannelId: req.body.textChannelId || null + }); + } + + // Search for tracks + const searchResult = await req.client.manager.search(query, req.member.user); + + if (!searchResult || !searchResult.tracks.length) { + return res.status(404).json({ + error: 'Not Found', + message: 'No tracks found for the search query' + }); + } + + // Add track(s) to queue + const tracksAdded = searchResult.loadType === 'PLAYLIST_LOADED' + ? searchResult.tracks + : [searchResult.tracks[0]]; + + for (const track of tracksAdded) { + track.requester = req.member.user; + player.queue.add(track); + } + + // Connect and play if not already playing + if (!player.connected) { + await player.connect(); + } + + if (!player.playing && !player.paused) { + await player.play(); + } + + res.json({ + success: true, + message: tracksAdded.length === 1 + ? `Added **${tracksAdded[0].title}** to queue` + : `Added **${tracksAdded.length}** tracks to queue`, + tracksAdded: tracksAdded.map(track => ({ + title: track.title, + author: track.author, + duration: track.duration, + uri: track.uri, + thumbnail: track.thumbnail + })), + queueLength: player.queue.size + }); + + } catch (error) { + req.client.logger.error('Music play error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to play music' + }); + } +}); + +/** + * POST /api/music/:guildId/pause + * Pause/resume playback + */ +router.post('/:guildId/pause', validateGuildAccess, requireDJ, (req, res) => { + try { + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player || !player.current) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music is currently playing' + }); + } + + if (player.paused) { + player.resume(); + res.json({ + success: true, + message: 'Music resumed', + status: 'playing' + }); + } else { + player.pause(); + res.json({ + success: true, + message: 'Music paused', + status: 'paused' + }); + } + + } catch (error) { + req.client.logger.error('Music pause error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to pause/resume music' + }); + } +}); + +/** + * POST /api/music/:guildId/skip + * Skip current track + */ +router.post('/:guildId/skip', validateGuildAccess, requireDJ, (req, res) => { + try { + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player || !player.current) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music is currently playing' + }); + } + + const skippedTrack = player.current.title; + player.skip(); + + res.json({ + success: true, + message: `Skipped **${skippedTrack}**`, + queueLength: player.queue.size + }); + + } catch (error) { + req.client.logger.error('Music skip error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to skip track' + }); + } +}); + +/** + * POST /api/music/:guildId/stop + * Stop playback and clear queue + */ +router.post('/:guildId/stop', validateGuildAccess, requireDJ, (req, res) => { + try { + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music player is active' + }); + } + + player.destroy(); + + res.json({ + success: true, + message: 'Music stopped and queue cleared' + }); + + } catch (error) { + req.client.logger.error('Music stop error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to stop music' + }); + } +}); + +/** + * POST /api/music/:guildId/volume + * Set playback volume + */ +router.post('/:guildId/volume', validateGuildAccess, requireDJ, (req, res) => { + try { + const { volume } = req.body; + + if (volume === undefined || volume < 0 || volume > 150) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Volume must be between 0 and 150' + }); + } + + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music player is active' + }); + } + + player.setVolume(volume); + + res.json({ + success: true, + message: `Volume set to ${volume}%`, + volume + }); + + } catch (error) { + req.client.logger.error('Music volume error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to set volume' + }); + } +}); + +/** + * POST /api/music/:guildId/seek + * Seek to position in current track + */ +router.post('/:guildId/seek', validateGuildAccess, requireDJ, (req, res) => { + try { + const { position } = req.body; + + if (position === undefined || position < 0) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Position must be a positive number in milliseconds' + }); + } + + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player || !player.current) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music is currently playing' + }); + } + + if (position > player.current.duration) { + return res.status(400).json({ + error: 'Invalid Position', + message: 'Position exceeds track duration' + }); + } + + player.seek(position); + + res.json({ + success: true, + message: `Seeked to ${Math.floor(position / 1000)}s`, + position + }); + + } catch (error) { + req.client.logger.error('Music seek error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to seek in track' + }); + } +}); + +/** + * DELETE /api/music/:guildId/queue/:index + * Remove track from queue + */ +router.delete('/:guildId/queue/:index', validateGuildAccess, requireDJ, (req, res) => { + try { + const index = parseInt(req.params.index); + + if (isNaN(index) || index < 0) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Invalid queue index' + }); + } + + const player = req.client.manager?.players.cache.get(req.guild.id); + + if (!player) { + return res.status(400).json({ + error: 'No Active Player', + message: 'No music player is active' + }); + } + + if (index >= player.queue.size) { + return res.status(400).json({ + error: 'Invalid Index', + message: 'Queue index out of range' + }); + } + + const removedTrack = player.queue[index]; + player.queue.splice(index, 1); + + res.json({ + success: true, + message: `Removed **${removedTrack.title}** from queue`, + queueLength: player.queue.size + }); + + } catch (error) { + req.client.logger.error('Queue remove error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to remove track from queue' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/reminders.js b/src/modules/web/routes/reminders.js new file mode 100644 index 0000000..4ec3865 --- /dev/null +++ b/src/modules/web/routes/reminders.js @@ -0,0 +1,170 @@ +/** + * Reminders Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, rateLimit } = require('../middleware/auth'); +const Reminder = require('../../../schemas/Reminder'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/reminders/:guildId + * Get reminders for the guild + */ +router.get('/:guildId', validateGuildAccess, async (req, res) => { + try { + const userId = req.query.userId; // Optional filter by user + const page = parseInt(req.query.page) || 1; + const limit = Math.min(parseInt(req.query.limit) || 20, 100); + + const query = { guildId: req.guild.id }; + + // Users can only see their own reminders unless they're moderators + if (userId) { + if (userId !== req.auth.userId && !req.member.permissions.has('ModerateMembers')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Can only view your own reminders' + }); + } + query.userId = userId; + } else if (!req.member.permissions.has('ModerateMembers')) { + // Regular users can only see their own reminders + query.userId = req.auth.userId; + } + + const total = await Reminder.countDocuments(query); + const reminders = await Reminder.find(query) + .sort({ reminderTime: 1 }) + .limit(limit) + .skip((page - 1) * limit); + + res.json({ + success: true, + reminders, + pagination: { + page, + limit, + total, + totalPages: Math.ceil(total / limit) + } + }); + + } catch (error) { + req.client.logger.error('Reminders fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch reminders' + }); + } +}); + +/** + * POST /api/reminders/:guildId + * Create a new reminder + */ +router.post('/:guildId', validateGuildAccess, async (req, res) => { + try { + const { message, reminderTime, channelId } = req.body; + + if (!message || !reminderTime) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Message and reminder time are required' + }); + } + + const reminderDate = new Date(reminderTime); + if (isNaN(reminderDate.getTime()) || reminderDate <= new Date()) { + return res.status(400).json({ + error: 'Invalid Time', + message: 'Reminder time must be a valid future date' + }); + } + + // Validate channel if provided + if (channelId) { + const channel = req.guild.channels.cache.get(channelId); + if (!channel) { + return res.status(404).json({ + error: 'Channel Not Found', + message: 'Specified channel does not exist' + }); + } + } + + const reminder = new Reminder({ + guildId: req.guild.id, + userId: req.auth.userId, + channelId: channelId || null, + message: message.trim(), + reminderTime: reminderDate, + createdAt: new Date() + }); + + await reminder.save(); + + res.json({ + success: true, + message: 'Reminder created successfully', + reminder + }); + + } catch (error) { + req.client.logger.error('Create reminder error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to create reminder' + }); + } +}); + +/** + * DELETE /api/reminders/:guildId/:reminderId + * Delete a reminder + */ +router.delete('/:guildId/:reminderId', validateGuildAccess, async (req, res) => { + try { + const { reminderId } = req.params; + + const reminder = await Reminder.findOne({ + _id: reminderId, + guildId: req.guild.id + }); + + if (!reminder) { + return res.status(404).json({ + error: 'Reminder Not Found', + message: 'Reminder does not exist' + }); + } + + // Users can only delete their own reminders unless they're moderators + if (reminder.userId !== req.auth.userId && !req.member.permissions.has('ModerateMembers')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Can only delete your own reminders' + }); + } + + await Reminder.deleteOne({ _id: reminderId }); + + res.json({ + success: true, + message: 'Reminder deleted successfully' + }); + + } catch (error) { + req.client.logger.error('Delete reminder error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to delete reminder' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/roles.js b/src/modules/web/routes/roles.js new file mode 100644 index 0000000..18d75e3 --- /dev/null +++ b/src/modules/web/routes/roles.js @@ -0,0 +1,244 @@ +/** + * Role Management Routes (SelfRole & AutoRole) + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireAdmin, rateLimit } = require('../middleware/auth'); +const SelfRole = require('../../../schemas/SelfRole'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/roles/:guildId/selfroles + * Get all self-assignable roles + */ +router.get('/:guildId/selfroles', validateGuildAccess, async (req, res) => { + try { + const selfRoles = await SelfRole.find({ guildId: req.guild.id }); + + // Enrich with Discord role data + const enrichedRoles = selfRoles.map(selfRole => { + const role = req.guild.roles.cache.get(selfRole.roleId); + return { + ...selfRole.toObject(), + exists: !!role, + role: role ? { + name: role.name, + color: role.hexColor, + position: role.position, + memberCount: role.members.size + } : null + }; + }); + + res.json({ + success: true, + selfRoles: enrichedRoles + }); + + } catch (error) { + req.client.logger.error('Self roles fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch self roles' + }); + } +}); + +/** + * POST /api/roles/:guildId/selfroles + * Add a new self-assignable role + */ +router.post('/:guildId/selfroles', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { roleId, emoji, description } = req.body; + + if (!roleId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Role ID is required' + }); + } + + // Validate role exists + const role = req.guild.roles.cache.get(roleId); + if (!role) { + return res.status(404).json({ + error: 'Role Not Found', + message: 'Specified role does not exist' + }); + } + + // Check if role is already a self role + const existing = await SelfRole.findOne({ guildId: req.guild.id, roleId }); + if (existing) { + return res.status(400).json({ + error: 'Already Exists', + message: 'Role is already a self-assignable role' + }); + } + + const selfRole = new SelfRole({ + guildId: req.guild.id, + roleId, + emoji: emoji || null, + description: description || null + }); + + await selfRole.save(); + + res.json({ + success: true, + message: 'Self role added successfully', + selfRole: { + ...selfRole.toObject(), + role: { + name: role.name, + color: role.hexColor, + position: role.position, + memberCount: role.members.size + } + } + }); + + } catch (error) { + req.client.logger.error('Add self role error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to add self role' + }); + } +}); + +/** + * DELETE /api/roles/:guildId/selfroles/:roleId + * Remove a self-assignable role + */ +router.delete('/:guildId/selfroles/:roleId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { roleId } = req.params; + + const selfRole = await SelfRole.findOneAndDelete({ + guildId: req.guild.id, + roleId + }); + + if (!selfRole) { + return res.status(404).json({ + error: 'Not Found', + message: 'Self role does not exist' + }); + } + + res.json({ + success: true, + message: 'Self role removed successfully' + }); + + } catch (error) { + req.client.logger.error('Remove self role error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to remove self role' + }); + } +}); + +/** + * POST /api/roles/:guildId/assign/:userId/:roleId + * Assign a role to a user (admin only) + */ +router.post('/:guildId/assign/:userId/:roleId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { userId, roleId } = req.params; + + const member = req.guild.members.cache.get(userId); + if (!member) { + return res.status(404).json({ + error: 'Member Not Found', + message: 'User is not a member of this guild' + }); + } + + const role = req.guild.roles.cache.get(roleId); + if (!role) { + return res.status(404).json({ + error: 'Role Not Found', + message: 'Specified role does not exist' + }); + } + + if (member.roles.cache.has(roleId)) { + return res.status(400).json({ + error: 'Already Has Role', + message: 'User already has this role' + }); + } + + await member.roles.add(role); + + res.json({ + success: true, + message: `Successfully assigned ${role.name} to ${member.displayName}` + }); + + } catch (error) { + req.client.logger.error('Assign role error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to assign role' + }); + } +}); + +/** + * DELETE /api/roles/:guildId/assign/:userId/:roleId + * Remove a role from a user (admin only) + */ +router.delete('/:guildId/assign/:userId/:roleId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { userId, roleId } = req.params; + + const member = req.guild.members.cache.get(userId); + if (!member) { + return res.status(404).json({ + error: 'Member Not Found', + message: 'User is not a member of this guild' + }); + } + + const role = req.guild.roles.cache.get(roleId); + if (!role) { + return res.status(404).json({ + error: 'Role Not Found', + message: 'Specified role does not exist' + }); + } + + if (!member.roles.cache.has(roleId)) { + return res.status(400).json({ + error: 'Does Not Have Role', + message: 'User does not have this role' + }); + } + + await member.roles.remove(role); + + res.json({ + success: true, + message: `Successfully removed ${role.name} from ${member.displayName}` + }); + + } catch (error) { + req.client.logger.error('Remove role error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to remove role' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/templates.js b/src/modules/web/routes/templates.js new file mode 100644 index 0000000..4880900 --- /dev/null +++ b/src/modules/web/routes/templates.js @@ -0,0 +1,281 @@ +/** + * Template Management Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireAdmin, rateLimit } = require('../middleware/auth'); +const EmbedTemplate = require('../../../schemas/EmbedTemplate'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/templates/:guildId + * Get all embed templates for the guild + */ +router.get('/:guildId', validateGuildAccess, async (req, res) => { + try { + const templates = await EmbedTemplate.find({ guildId: req.guild.id }) + .sort({ name: 1 }); + + res.json({ + success: true, + templates + }); + + } catch (error) { + req.client.logger.error('Templates fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch templates' + }); + } +}); + +/** + * GET /api/templates/:guildId/:templateId + * Get a specific template + */ +router.get('/:guildId/:templateId', validateGuildAccess, async (req, res) => { + try { + const { templateId } = req.params; + + const template = await EmbedTemplate.findOne({ + _id: templateId, + guildId: req.guild.id + }); + + if (!template) { + return res.status(404).json({ + error: 'Template Not Found', + message: 'Template does not exist' + }); + } + + res.json({ + success: true, + template + }); + + } catch (error) { + req.client.logger.error('Template fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch template' + }); + } +}); + +/** + * POST /api/templates/:guildId + * Create a new embed template + */ +router.post('/:guildId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { name, description, embedData } = req.body; + + if (!name || !embedData) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Name and embed data are required' + }); + } + + // Check if template name already exists + const existing = await EmbedTemplate.findOne({ + guildId: req.guild.id, + name: name.trim() + }); + + if (existing) { + return res.status(400).json({ + error: 'Already Exists', + message: 'Template with this name already exists' + }); + } + + const template = new EmbedTemplate({ + guildId: req.guild.id, + name: name.trim(), + description: description?.trim() || null, + embedData, + authorId: req.auth.userId, + createdAt: new Date() + }); + + await template.save(); + + res.json({ + success: true, + message: 'Template created successfully', + template + }); + + } catch (error) { + req.client.logger.error('Create template error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to create template' + }); + } +}); + +/** + * PUT /api/templates/:guildId/:templateId + * Update an embed template + */ +router.put('/:guildId/:templateId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { templateId } = req.params; + const { name, description, embedData } = req.body; + + const template = await EmbedTemplate.findOne({ + _id: templateId, + guildId: req.guild.id + }); + + if (!template) { + return res.status(404).json({ + error: 'Template Not Found', + message: 'Template does not exist' + }); + } + + // Check if new name conflicts with existing template + if (name && name.trim() !== template.name) { + const existing = await EmbedTemplate.findOne({ + guildId: req.guild.id, + name: name.trim(), + _id: { $ne: templateId } + }); + + if (existing) { + return res.status(400).json({ + error: 'Already Exists', + message: 'Template with this name already exists' + }); + } + } + + // Update fields + if (name) template.name = name.trim(); + if (description !== undefined) template.description = description?.trim() || null; + if (embedData) template.embedData = embedData; + template.updatedAt = new Date(); + + await template.save(); + + res.json({ + success: true, + message: 'Template updated successfully', + template + }); + + } catch (error) { + req.client.logger.error('Update template error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update template' + }); + } +}); + +/** + * DELETE /api/templates/:guildId/:templateId + * Delete an embed template + */ +router.delete('/:guildId/:templateId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { templateId } = req.params; + + const template = await EmbedTemplate.findOneAndDelete({ + _id: templateId, + guildId: req.guild.id + }); + + if (!template) { + return res.status(404).json({ + error: 'Template Not Found', + message: 'Template does not exist' + }); + } + + res.json({ + success: true, + message: 'Template deleted successfully' + }); + + } catch (error) { + req.client.logger.error('Delete template error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to delete template' + }); + } +}); + +/** + * POST /api/templates/:guildId/:templateId/send + * Send a template to a specific channel + */ +router.post('/:guildId/:templateId/send', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { templateId } = req.params; + const { channelId } = req.body; + + if (!channelId) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Channel ID is required' + }); + } + + const template = await EmbedTemplate.findOne({ + _id: templateId, + guildId: req.guild.id + }); + + if (!template) { + return res.status(404).json({ + error: 'Template Not Found', + message: 'Template does not exist' + }); + } + + const channel = req.guild.channels.cache.get(channelId); + if (!channel) { + return res.status(404).json({ + error: 'Channel Not Found', + message: 'Specified channel does not exist' + }); + } + + if (!channel.isTextBased()) { + return res.status(400).json({ + error: 'Invalid Channel', + message: 'Channel must be a text channel' + }); + } + + // Send the embed + const message = await channel.send({ embeds: [template.embedData] }); + + res.json({ + success: true, + message: 'Template sent successfully', + messageId: message.id, + channelId: channel.id + }); + + } catch (error) { + req.client.logger.error('Send template error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to send template' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/tempvc.js b/src/modules/web/routes/tempvc.js new file mode 100644 index 0000000..a3b884f --- /dev/null +++ b/src/modules/web/routes/tempvc.js @@ -0,0 +1,180 @@ +/** + * Temporary Voice Channels Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireAdmin, rateLimit } = require('../middleware/auth'); +const TempVCInstance = require('../../../schemas/TempVCInstance'); +const TempVCUserSettings = require('../../../schemas/TempVCUserSettings'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/tempvc/:guildId/instances + * Get all active temporary voice channels + */ +router.get('/:guildId/instances', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const instances = await TempVCInstance.find({ guildId: req.guild.id }); + + // Add live member count from Discord + const enrichedInstances = instances.map(instance => { + const channel = req.guild.channels.cache.get(instance.channelId); + return { + ...instance.toObject(), + memberCount: channel ? channel.members.size : 0, + exists: !!channel + }; + }); + + res.json({ + success: true, + instances: enrichedInstances + }); + + } catch (error) { + req.client.logger.error('TempVC instances fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch TempVC instances' + }); + } +}); + +/** + * GET /api/tempvc/:guildId/settings/:userId + * Get user's TempVC settings + */ +router.get('/:guildId/settings/:userId', validateGuildAccess, async (req, res) => { + try { + const { userId } = req.params; + + // Users can only view their own settings unless admin + if (userId !== req.auth.userId && !req.member.permissions.has('Administrator')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Can only access your own settings' + }); + } + + const settings = await TempVCUserSettings.findOne({ + guildId: req.guild.id, + userId: userId + }); + + res.json({ + success: true, + settings: settings?.defaultSettings || {} + }); + + } catch (error) { + req.client.logger.error('TempVC settings fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch TempVC settings' + }); + } +}); + +/** + * PUT /api/tempvc/:guildId/settings/:userId + * Update user's TempVC settings + */ +router.put('/:guildId/settings/:userId', validateGuildAccess, async (req, res) => { + try { + const { userId } = req.params; + const updates = req.body; + + // Users can only update their own settings unless admin + if (userId !== req.auth.userId && !req.member.permissions.has('Administrator')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Can only update your own settings' + }); + } + + let settings = await TempVCUserSettings.findOne({ + guildId: req.guild.id, + userId: userId + }); + + if (!settings) { + settings = new TempVCUserSettings({ + guildId: req.guild.id, + userId: userId, + defaultSettings: {} + }); + } + + // Update allowed fields + const allowedFields = ['channelName', 'userLimit', 'bitrate', 'isPrivate', 'allowedUsers', 'blockedUsers']; + allowedFields.forEach(field => { + if (updates[field] !== undefined) { + settings.defaultSettings[field] = updates[field]; + } + }); + + await settings.save(); + + res.json({ + success: true, + message: 'TempVC settings updated', + settings: settings.defaultSettings + }); + + } catch (error) { + req.client.logger.error('TempVC settings update error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update TempVC settings' + }); + } +}); + +/** + * DELETE /api/tempvc/:guildId/instances/:channelId + * Delete a temporary voice channel (admin only) + */ +router.delete('/:guildId/instances/:channelId', validateGuildAccess, requireAdmin, async (req, res) => { + try { + const { channelId } = req.params; + + const instance = await TempVCInstance.findOne({ + guildId: req.guild.id, + channelId: channelId + }); + + if (!instance) { + return res.status(404).json({ + error: 'Instance Not Found', + message: 'TempVC instance does not exist' + }); + } + + // Delete the Discord channel + const channel = req.guild.channels.cache.get(channelId); + if (channel) { + await channel.delete('Deleted via dashboard'); + } + + // Remove from database + await TempVCInstance.deleteOne({ _id: instance._id }); + + res.json({ + success: true, + message: 'TempVC instance deleted successfully' + }); + + } catch (error) { + req.client.logger.error('TempVC delete error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to delete TempVC instance' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/tickets.js b/src/modules/web/routes/tickets.js new file mode 100644 index 0000000..28d35b5 --- /dev/null +++ b/src/modules/web/routes/tickets.js @@ -0,0 +1,173 @@ +/** + * Ticket System Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireModerator, rateLimit } = require('../middleware/auth'); +const Ticket = require('../../../schemas/Ticket'); +const TicketConfig = require('../../../schemas/TicketConfig'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/tickets/:guildId + * Get all tickets for a guild + */ +router.get('/:guildId', validateGuildAccess, requireModerator, async (req, res) => { + try { + const page = parseInt(req.query.page) || 1; + const limit = Math.min(parseInt(req.query.limit) || 20, 100); + const status = req.query.status; // open, closed, all + + const query = { guildId: req.guild.id }; + if (status && status !== 'all') { + query.status = status; + } + + const total = await Ticket.countDocuments(query); + const tickets = await Ticket.find(query) + .sort({ createdAt: -1 }) + .limit(limit) + .skip((page - 1) * limit); + + res.json({ + success: true, + tickets, + pagination: { + page, + limit, + total, + totalPages: Math.ceil(total / limit) + } + }); + + } catch (error) { + req.client.logger.error('Tickets fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch tickets' + }); + } +}); + +/** + * GET /api/tickets/:guildId/config + * Get ticket system configuration + */ +router.get('/:guildId/config', validateGuildAccess, requireModerator, async (req, res) => { + try { + const config = await TicketConfig.findOne({ guildId: req.guild.id }); + + res.json({ + success: true, + config: config || { + enabled: false, + categoryId: null, + supportRoles: [], + maxTicketsPerUser: 1, + autoClose: false, + autoCloseTime: 24 + } + }); + + } catch (error) { + req.client.logger.error('Ticket config fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch ticket configuration' + }); + } +}); + +/** + * PUT /api/tickets/:guildId/config + * Update ticket system configuration + */ +router.put('/:guildId/config', validateGuildAccess, requireModerator, async (req, res) => { + try { + const updates = req.body; + + let config = await TicketConfig.findOne({ guildId: req.guild.id }); + if (!config) { + config = new TicketConfig({ guildId: req.guild.id }); + } + + // Update allowed fields + const allowedFields = ['enabled', 'categoryId', 'supportRoles', 'maxTicketsPerUser', 'autoClose', 'autoCloseTime']; + allowedFields.forEach(field => { + if (updates[field] !== undefined) { + config[field] = updates[field]; + } + }); + + await config.save(); + + res.json({ + success: true, + message: 'Ticket configuration updated', + config + }); + + } catch (error) { + req.client.logger.error('Ticket config update error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to update ticket configuration' + }); + } +}); + +/** + * POST /api/tickets/:guildId/:ticketId/close + * Close a ticket + */ +router.post('/:guildId/:ticketId/close', validateGuildAccess, requireModerator, async (req, res) => { + try { + const { ticketId } = req.params; + const { reason } = req.body; + + const ticket = await Ticket.findOne({ + _id: ticketId, + guildId: req.guild.id + }); + + if (!ticket) { + return res.status(404).json({ + error: 'Ticket Not Found', + message: 'Ticket does not exist' + }); + } + + if (ticket.status === 'closed') { + return res.status(400).json({ + error: 'Already Closed', + message: 'Ticket is already closed' + }); + } + + ticket.status = 'closed'; + ticket.closedBy = req.member.id; + ticket.closedAt = new Date(); + ticket.closeReason = reason || 'No reason provided'; + + await ticket.save(); + + res.json({ + success: true, + message: 'Ticket closed successfully', + ticket + }); + + } catch (error) { + req.client.logger.error('Close ticket error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to close ticket' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/src/modules/web/routes/user.js b/src/modules/web/routes/user.js new file mode 100644 index 0000000..af94b6b --- /dev/null +++ b/src/modules/web/routes/user.js @@ -0,0 +1,126 @@ +/** + * User Management Routes + */ + +const express = require('express'); +const router = express.Router(); +const { verifyToken, validateGuildAccess, requireModerator, rateLimit } = require('../middleware/auth'); +const User = require('../../../schemas/User'); + +// Apply authentication and rate limiting to all routes +router.use(verifyToken); +router.use(rateLimit(60000, 50)); // 50 requests per minute + +/** + * GET /api/user/:guildId/:userId + * Get user information + */ +router.get('/:guildId/:userId', validateGuildAccess, async (req, res) => { + try { + const { userId } = req.params; + + // Users can view their own info, moderators can view anyone's + if (userId !== req.auth.userId && !req.member.permissions.has('ModerateMembers')) { + return res.status(403).json({ + error: 'Access Denied', + message: 'Insufficient permissions to view user information' + }); + } + + const member = req.guild.members.cache.get(userId); + if (!member) { + return res.status(404).json({ + error: 'User Not Found', + message: 'User is not a member of this guild' + }); + } + + const userDoc = await User.findOne({ userId: userId }); + + res.json({ + success: true, + user: { + id: member.user.id, + username: member.user.username, + discriminator: member.user.discriminator, + avatar: member.user.displayAvatarURL(), + displayName: member.displayName, + joinedAt: member.joinedAt, + premiumSince: member.premiumSince, + roles: member.roles.cache + .filter(role => role.id !== req.guild.id) + .map(role => ({ + id: role.id, + name: role.name, + color: role.hexColor, + position: role.position + })) + .sort((a, b) => b.position - a.position), + permissions: { + administrator: member.permissions.has('Administrator'), + manageGuild: member.permissions.has('ManageGuild'), + moderateMembers: member.permissions.has('ModerateMembers'), + manageMessages: member.permissions.has('ManageMessages') + }, + database: userDoc || null + } + }); + + } catch (error) { + req.client.logger.error('User info fetch error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to fetch user information' + }); + } +}); + +/** + * GET /api/user/:guildId/search + * Search for users in the guild + */ +router.get('/:guildId/search', validateGuildAccess, requireModerator, (req, res) => { + try { + const query = req.query.q?.toLowerCase(); + const limit = Math.min(parseInt(req.query.limit) || 10, 50); + + if (!query || query.length < 2) { + return res.status(400).json({ + error: 'Bad Request', + message: 'Search query must be at least 2 characters' + }); + } + + const members = Array.from(req.guild.members.cache.values()) + .filter(member => + member.user.username.toLowerCase().includes(query) || + member.displayName.toLowerCase().includes(query) || + member.user.id.includes(query) + ) + .slice(0, limit) + .map(member => ({ + id: member.user.id, + username: member.user.username, + discriminator: member.user.discriminator, + displayName: member.displayName, + avatar: member.user.displayAvatarURL(), + joinedAt: member.joinedAt + })); + + res.json({ + success: true, + users: members, + query, + count: members.length + }); + + } catch (error) { + req.client.logger.error('User search error:', error); + res.status(500).json({ + error: 'Internal Server Error', + message: 'Failed to search users' + }); + } +}); + +module.exports = router; \ No newline at end of file