@organizasyon/meeting-nanaman-app-backend 1.0.0

package/src/controllers/employees/index.ts

@@ -0,0 +1,210 @@
+import { Response } from 'express'
+import EmployeesModel from '../../models/employees'
+import type { MulterRequest } from '../../types'
+
+class Employees {
+  /**
+   * Create a new employee
+   * Accepts form data with:
+   * - first_name (required)
+   * - middle_name (optional)
+   * - last_name (required)
+   * - address (optional)
+   * - contact_number (optional)
+   * - email (optional)
+   * - position (optional)
+   * - department (optional)
+   */
+  public async create(req: MulterRequest & { body?: Record<string, any> }, res: Response): Promise<void> {
+    try {
+      const body = req.body || {}
+      
+      const firstName = (body.first_name ?? '').toString().trim()
+      const lastName = (body.last_name ?? '').toString().trim()
+
+      if (!firstName || !lastName) {
+        res.status(400).json({ message: 'first_name and last_name are required' })
+        return
+      }
+
+      // Create employee record
+      const employee = await EmployeesModel.create({
+        first_name: firstName,
+        middle_name: (body.middle_name ?? null),
+        last_name: lastName,
+        address: (body.address ?? null),
+        contact_number: (body.contact_number ?? null),
+        email: (body.email ?? null),
+        position: (body.position ?? null),
+        department: (body.department ?? null),
+        created_at: Date.now(),
+        updated_at: Date.now()
+      })
+
+      res.status(201).json({
+        message: 'Employee created successfully',
+        employee: { 
+          id: employee._id, 
+          first_name: employee.first_name, 
+          middle_name: employee.middle_name,
+          last_name: employee.last_name,
+          email: employee.email,
+          position: employee.position,
+          department: employee.department,
+          contact_number: employee.contact_number,
+          address: employee.address
+        }
+      })
+    } catch (err) {
+      console.error('Create employee error', err)
+      res.status(500).json({ message: 'Failed to create employee', error: String(err) })
+    }
+  }
+
+  /**
+   * Get all employees
+   */
+  public async getAll(req: MulterRequest, res: Response): Promise<void> {
+    try {
+      const employees = await EmployeesModel.find({ deleted_at: null })
+        .select('-__v')
+        .sort({ created_at: -1 })
+        .lean()
+        .exec()
+
+      res.json({
+        message: 'Employees retrieved successfully',
+        count: employees.length,
+        employees
+      })
+    } catch (err) {
+      console.error('Get employees error', err)
+      res.status(500).json({ message: 'Failed to retrieve employees', error: String(err) })
+    }
+  }
+
+  /**
+   * Get employee by ID
+   */
+  public async getById(req: MulterRequest, res: Response): Promise<void> {
+    try {
+      const { id } = req.params
+      
+      if (!id) {
+        res.status(400).json({ message: 'Employee ID is required' })
+        return
+      }
+
+      const employee = await EmployeesModel.findOne({ 
+        _id: id, 
+        deleted_at: null 
+      })
+        .select('-__v')
+        .lean()
+        .exec()
+
+      if (!employee) {
+        res.status(404).json({ message: 'Employee not found' })
+        return
+      }
+
+      res.json({
+        message: 'Employee retrieved successfully',
+        employee
+      })
+    } catch (err) {
+      console.error('Get employee error', err)
+      res.status(500).json({ message: 'Failed to retrieve employee', error: String(err) })
+    }
+  }
+
+  /**
+   * Update employee
+   */
+  public async update(req: MulterRequest & { body?: Record<string, any> }, res: Response): Promise<void> {
+    try {
+      const { id } = req.params
+      const body = req.body || {}
+      
+      if (!id) {
+        res.status(400).json({ message: 'Employee ID is required' })
+        return
+      }
+
+      const updateData: any = {
+        updated_at: Date.now()
+      }
+
+      // Only update provided fields
+      const allowedFields = ['first_name', 'middle_name', 'last_name', 'address', 'contact_number', 'email', 'position', 'department']
+      for (const field of allowedFields) {
+        if (body[field] !== undefined) {
+          updateData[field] = body[field]
+        }
+      }
+
+      const employee = await EmployeesModel.findOneAndUpdate(
+        { _id: id, deleted_at: null },
+        updateData,
+        { new: true, runValidators: true }
+      )
+        .select('-__v')
+        .lean()
+        .exec()
+
+      if (!employee) {
+        res.status(404).json({ message: 'Employee not found' })
+        return
+      }
+
+      res.json({
+        message: 'Employee updated successfully',
+        employee
+      })
+    } catch (err) {
+      console.error('Update employee error', err)
+      res.status(500).json({ message: 'Failed to update employee', error: String(err) })
+    }
+  }
+
+  /**
+   * Soft delete employee
+   */
+  public async delete(req: MulterRequest, res: Response): Promise<void> {
+    try {
+      const { id } = req.params
+      
+      if (!id) {
+        res.status(400).json({ message: 'Employee ID is required' })
+        return
+      }
+
+      const employee = await EmployeesModel.findOneAndUpdate(
+        { _id: id, deleted_at: null },
+        { deleted_at: Date.now() },
+        { new: true }
+      )
+        .lean()
+        .exec()
+
+      if (!employee) {
+        res.status(404).json({ message: 'Employee not found' })
+        return
+      }
+
+      res.json({
+        message: 'Employee deleted successfully',
+        employee: {
+          id: employee._id,
+          first_name: employee.first_name,
+          last_name: employee.last_name
+        }
+      })
+    } catch (err) {
+      console.error('Delete employee error', err)
+      res.status(500).json({ message: 'Failed to delete employee', error: String(err) })
+    }
+  }
+}
+
+export default Employees;

package/src/controllers/health/index.ts

@@ -0,0 +1,41 @@
+import { Request, Response } from 'express';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Health Check Controller
+ * Serves a fancy HTML page to show API is running
+ */
+export class HealthController {
+  async healthCheck(req: Request, res: Response) {
+    try {
+      // Get the path to the HTML file
+       const htmlPath = path.join(__dirname, '../../../public/health.html');
+      
+      // Read the HTML file
+      const htmlContent = fs.readFileSync(htmlPath, 'utf8');
+      
+      // Set appropriate headers
+      res.setHeader('Content-Type', 'text/html');
+      res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+      res.setHeader('Pragma', 'no-cache');
+      res.setHeader('Expires', '0');
+      
+      // Send the HTML content
+      res.status(200).send(htmlContent);
+    } catch (error) {
+      console.error('Health check error:', error);
+      
+      // If HTML file not found, return simple JSON response
+      res.status(500).json({
+        status: 'error',
+        message: 'Health check page unavailable',
+        timestamp: new Date().toISOString(),
+        api: 'Inventory Management System',
+        version: '1.0.0'
+      });
+    }
+  }
+}
+
+export default HealthController;

package/src/controllers/index.ts

@@ -0,0 +1,9 @@
+import EmployeesController from './employees';
+import UsersController from './users';
+import { ModulesController } from './modules';
+import { AuthController } from './auth';
+import { HealthController } from './health';
+import MeetingsController from './meetings';
+
+export { EmployeesController, UsersController, ModulesController, AuthController, HealthController, MeetingsController };
+export default { EmployeesController, UsersController, ModulesController, AuthController, HealthController, MeetingsController };

package/src/controllers/meetings/index.ts

@@ -0,0 +1,251 @@
+import { Meetings as MeetingModel, Users as UserModel } from '../../models';
+// import { canJoinMeeting } from '../middlewares/meeting';
+// import { sendNotification, sendMeetingInvitation } from '../utils/notifications';
+
+class Meetings {
+  /**
+   * Create a new meeting
+   */
+  public static async create(req: any, res: any): Promise<void> {
+   try {
+     const { title, description, meeting_type = 'video', scheduled_at, participants, max_participants = 50 } = req.body;
+     const userId = req.user.userId;
+
+     // Generate unique meeting URL
+     const meeting_url = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+
+      // Process participants - handle both user IDs and email objects
+      const participantsArray: any[] = [];
+      if (Array.isArray(participants)) {
+        for (const participant of participants) {
+          if (typeof participant === 'string') {
+            // Check if it's an email or user ID
+            if (participant.includes('@')) {
+              // Email provided - try to find user or store email
+              const user = await UserModel.findOne({ email: participant.toLowerCase(), deleted_at: null }).lean().exec();
+              if (user) {
+                participantsArray.push({
+                  user_id: user._id,
+                  is_active: false
+                });
+              } else {
+                // User doesn't exist - store as pending invitation
+                participantsArray.push({
+                  email: participant,
+                  is_active: false,
+                  status: 'pending'
+                });
+              }
+            } else {
+              // Direct user ID
+              participantsArray.push({
+                user_id: participant,
+                is_active: false
+              });
+            }
+          } else if (typeof participant === 'object' && participant !== null) {
+           // Object with id or email
+           if (participant.id) {
+             participantsArray.push({
+               user_id: participant.id,
+               is_active: false
+             });
+           } else if (participant.email) {
+             // Email provided - try to find user or store email
+             const user = await UserModel.findOne({ email: participant.email.toLowerCase(), deleted_at: null }).lean().exec();
+             if (user) {
+               participantsArray.push({
+                 user_id: user._id,
+                 is_active: false
+               });
+             } else {
+               // User doesn't exist - store as pending invitation (could be enhanced later)
+               participantsArray.push({
+                 email: participant.email,
+                 is_active: false,
+                 status: 'pending'
+               });
+             }
+           }
+         }
+       }
+     }
+
+     const meeting = new MeetingModel({
+       title,
+       description,
+       host_id: userId,
+       meeting_type,
+       scheduled_at: scheduled_at ? new Date(scheduled_at).getTime() : Date.now(),
+       max_participants,
+       meeting_url,
+       participants: participantsArray
+     });
+
+     await meeting.save();
+     await meeting.populate('host_id', 'first_name last_name email');
+     await meeting.populate('participants.user_id', 'first_name last_name email');
+
+     // Send notifications to participants
+     // if (participants && participants.length > 0) {
+     //   await sendMeetingInvitation(meeting._id, participants, title, description, userId);
+     // }
+
+     res.status(201).json({ success: true, meeting });
+   } catch (error) {
+     console.error('Error creating meeting:', error);
+     res.status(500).json({ error: 'Failed to create meeting' });
+   }
+ }
+
+  /**
+   * Join a meeting
+   */
+  public static async join(req: any, res: any): Promise<void> {
+  try {
+    const { meetingId } = req.params;
+    const userId = req.user.userId;
+
+    const meeting = req.meeting;
+
+    // Mark user as active participant
+    const participantIndex = meeting.participants.findIndex((p: any) => p.user_id.toString() === userId);
+    if (participantIndex !== -1) {
+      meeting.participants[participantIndex].is_active = true;
+      meeting.participants[participantIndex].joined_at = Date.now();
+    }
+
+    // Start meeting if not started
+    if (!meeting.started_at) {
+      meeting.started_at = Date.now();
+    }
+
+    await meeting.save();
+
+    // Notify other participants
+    const otherParticipants = meeting.participants
+      .filter((p: any) => p.user_id.toString() !== userId && p.is_active)
+      .map((p: any) => p.user_id.toString());
+
+    // if (otherParticipants.length > 0) {
+    //   await sendNotification(
+    //     otherParticipants,
+    //     'User Joined Meeting',
+    //     `${req.user.email} has joined the meeting`,
+    //     { type: 'user_joined', userId, meetingId },
+    //     'meeting_update'
+    //   );
+    // }
+
+    res.json({ success: true, meeting_url: meeting.meeting_url });
+  } catch (error) {
+    console.error('Error joining meeting:', error);
+    res.status(500).json({ error: 'Failed to join meeting' });
+  }
+  }
+
+  /**
+   * Leave a meeting
+   */
+  public static async leave(req: any, res: any): Promise<void> {
+  try {
+    const { meetingId } = req.params;
+    const userId = req.user.userId;
+
+    const meeting = req.meeting;
+
+    // Mark user as inactive participant
+    const participantIndex = meeting.participants.findIndex((p: any) => p.user_id.toString() === userId);
+    if (participantIndex !== -1) {
+      meeting.participants[participantIndex].is_active = false;
+      meeting.participants[participantIndex].left_at = Date.now();
+    }
+
+    // Check if meeting should end (only host left or no active participants)
+    const isHost = meeting.host_id.toString() === userId;
+    const activeParticipants = meeting.participants.filter((p: any) => p.is_active);
+
+    if (isHost || activeParticipants.length === 0) {
+      meeting.ended_at = Date.now();
+      meeting.is_active = false;
+    }
+
+    await meeting.save();
+
+    // Notify other participants
+    const remainingParticipants = activeParticipants
+      .filter((p: any) => p.user_id.toString() !== userId)
+      .map((p: any) => p.user_id.toString());
+
+    // if (remainingParticipants.length > 0) {
+    //   await sendNotification(
+    //     remainingParticipants,
+    //     'User Left Meeting',
+    //     `${req.user.email} has left the meeting`,
+    //     { type: 'user_left', userId, meetingId },
+    //     'meeting_update'
+    //   );
+    // }
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error leaving meeting:', error);
+    res.status(500).json({ error: 'Failed to leave meeting' });
+  }
+  }
+
+  /**
+   * Get user's meetings
+   */
+  public static async getMyMeetings(req: any, res: any): Promise<void> {
+  try {
+    const userId = req.user.userId;
+    const { status = 'upcoming' } = req.query;
+
+    let filter: any = {
+      $or: [
+        { host_id: userId },
+        { 'participants.user_id': userId }
+      ]
+    };
+
+    if (status === 'upcoming') {
+      filter.scheduled_at = { $gt: Date.now() };
+    } else if (status === 'ongoing') {
+      filter.started_at = { $ne: null };
+      filter.ended_at = null;
+      filter.is_active = true;
+    } else if (status === 'completed') {
+      filter.ended_at = { $ne: null };
+    }
+
+    const meetings = await MeetingModel.find(filter)
+      .populate('host_id', 'first_name last_name email')
+      .populate('participants.user_id', 'first_name last_name email')
+      .sort({ scheduled_at: -1 });
+
+    res.json({ success: true, meetings });
+  } catch (error) {
+    console.error('Error fetching meetings:', error);
+    res.status(500).json({ error: 'Failed to fetch meetings' });
+  }
+  }
+
+  /**
+   * Get meeting details
+   */
+  public static async getMeeting(req: any, res: any): Promise<void> {
+  try {
+    const meeting = req.meeting;
+    
+    await meeting.populate('host_id', 'first_name last_name email');
+    await meeting.populate('participants.user_id', 'first_name last_name email');
+
+    res.json({ success: true, meeting });
+  } catch (error) {
+    console.error('Error fetching meeting:', error);
+    res.status(500).json({ error: 'Failed to fetch meeting' });
+  }
+  }
+}
+export default Meetings;

package/src/controllers/modules/index.ts

@@ -0,0 +1,74 @@
+import { Request, Response } from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+import { runSeeders } from '../../database/seeder';
+
+export class ModulesController {
+  async getModules(req: Request, res: Response) {
+    try {
+      // Try multiple possible paths for modules.json
+      let modulesPath: string | undefined;
+      
+      // List of possible paths to check
+      const possiblePaths = [
+        // Development path
+        path.join(__dirname, '../data/modules.json'),
+        // Production path (when called from user-api)
+        path.join(__dirname, '../../data/modules.json'),
+        // Alternative production path
+        path.join(__dirname, '../../../backend/src/data/modules.json'),
+        // Relative to backend project root
+        path.join(process.cwd(), 'src/data/modules.json'),
+        // Relative to backend project root (dist)
+        path.join(process.cwd(), 'dist/data/modules.json'),
+        // Absolute path fallback
+        '/Users/abdegracia/aldrin-degracia/code/rnd/inventory-management-system/backend/src/data/modules.json'
+      ];
+      
+      // Find the first existing path
+      for (const testPath of possiblePaths) {
+        if (fs.existsSync(testPath)) {
+          modulesPath = testPath;
+          break;
+        }
+      }
+      
+      if (!modulesPath) {
+        throw new Error('modules.json file not found in any expected location');
+      }
+      
+      const modulesData = JSON.parse(fs.readFileSync(modulesPath, 'utf-8'));
+      
+      res.json({
+        success: true,
+        data: modulesData
+      });
+    } catch (error) {
+      console.error('Error reading modules data:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to load modules data',
+        error: String(error)
+      });
+    }
+  }
+
+  async runSeeders(req: Request, res: Response) {
+    try {
+      console.log('Running seeders via API call...');
+      await runSeeders();
+      
+      res.json({
+        success: true,
+        message: 'Seeders executed successfully'
+      });
+    } catch (error) {
+      console.error('Error running seeders:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to run seeders',
+        error: String(error)
+      });
+    }
+  }
+}