@organizasyon/meeting-nanaman-app-backend 1.0.0

package/dist/controllers/employees/index.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const employees_1 = __importDefault(require("../../models/employees"));
+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)
+     */
+    async create(req, res) {
+        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 employees_1.default.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
+     */
+    async getAll(req, res) {
+        try {
+            const employees = await employees_1.default.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
+     */
+    async getById(req, res) {
+        try {
+            const { id } = req.params;
+            if (!id) {
+                res.status(400).json({ message: 'Employee ID is required' });
+                return;
+            }
+            const employee = await employees_1.default.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
+     */
+    async update(req, res) {
+        try {
+            const { id } = req.params;
+            const body = req.body || {};
+            if (!id) {
+                res.status(400).json({ message: 'Employee ID is required' });
+                return;
+            }
+            const updateData = {
+                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 employees_1.default.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
+     */
+    async delete(req, res) {
+        try {
+            const { id } = req.params;
+            if (!id) {
+                res.status(400).json({ message: 'Employee ID is required' });
+                return;
+            }
+            const employee = await employees_1.default.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) });
+        }
+    }
+}
+exports.default = Employees;

package/dist/controllers/health/index.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from 'express';
+/**
+ * Health Check Controller
+ * Serves a fancy HTML page to show API is running
+ */
+export declare class HealthController {
+    healthCheck(req: Request, res: Response): Promise<void>;
+}
+export default HealthController;

package/dist/controllers/health/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Health Check Controller
+ * Serves a fancy HTML page to show API is running
+ */
+class HealthController {
+    async healthCheck(req, res) {
+        try {
+            // Get the path to the HTML file
+            const htmlPath = path_1.default.join(__dirname, '../../../public/health.html');
+            // Read the HTML file
+            const htmlContent = fs_1.default.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'
+            });
+        }
+    }
+}
+exports.HealthController = HealthController;
+exports.default = HealthController;

package/dist/controllers/index.d.ts

@@ -0,0 +1,16 @@
+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 };
+declare const _default: {
+    EmployeesController: typeof EmployeesController;
+    UsersController: typeof UsersController;
+    ModulesController: typeof ModulesController;
+    AuthController: typeof AuthController;
+    HealthController: typeof HealthController;
+    MeetingsController: typeof MeetingsController;
+};
+export default _default;

package/dist/controllers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeetingsController = exports.HealthController = exports.AuthController = exports.ModulesController = exports.UsersController = exports.EmployeesController = void 0;
+const employees_1 = __importDefault(require("./employees"));
+exports.EmployeesController = employees_1.default;
+const users_1 = __importDefault(require("./users"));
+exports.UsersController = users_1.default;
+const modules_1 = require("./modules");
+Object.defineProperty(exports, "ModulesController", { enumerable: true, get: function () { return modules_1.ModulesController; } });
+const auth_1 = require("./auth");
+Object.defineProperty(exports, "AuthController", { enumerable: true, get: function () { return auth_1.AuthController; } });
+const health_1 = require("./health");
+Object.defineProperty(exports, "HealthController", { enumerable: true, get: function () { return health_1.HealthController; } });
+const meetings_1 = __importDefault(require("./meetings"));
+exports.MeetingsController = meetings_1.default;
+exports.default = { EmployeesController: employees_1.default, UsersController: users_1.default, ModulesController: modules_1.ModulesController, AuthController: auth_1.AuthController, HealthController: health_1.HealthController, MeetingsController: meetings_1.default };

package/dist/controllers/meetings/index.d.ts

@@ -0,0 +1,23 @@
+declare class Meetings {
+    /**
+     * Create a new meeting
+     */
+    static create(req: any, res: any): Promise<void>;
+    /**
+     * Join a meeting
+     */
+    static join(req: any, res: any): Promise<void>;
+    /**
+     * Leave a meeting
+     */
+    static leave(req: any, res: any): Promise<void>;
+    /**
+     * Get user's meetings
+     */
+    static getMyMeetings(req: any, res: any): Promise<void>;
+    /**
+     * Get meeting details
+     */
+    static getMeeting(req: any, res: any): Promise<void>;
+}
+export default Meetings;

package/dist/controllers/meetings/index.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../models");
+// import { canJoinMeeting } from '../middlewares/meeting';
+// import { sendNotification, sendMeetingInvitation } from '../utils/notifications';
+class Meetings {
+    /**
+     * Create a new meeting
+     */
+    static async create(req, res) {
+        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 = [];
+            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 models_1.Users.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 models_1.Users.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 models_1.Meetings({
+                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
+     */
+    static async join(req, res) {
+        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) => 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) => p.user_id.toString() !== userId && p.is_active)
+                .map((p) => 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
+     */
+    static async leave(req, res) {
+        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) => 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) => 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) => p.user_id.toString() !== userId)
+                .map((p) => 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
+     */
+    static async getMyMeetings(req, res) {
+        try {
+            const userId = req.user.userId;
+            const { status = 'upcoming' } = req.query;
+            let filter = {
+                $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 models_1.Meetings.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
+     */
+    static async getMeeting(req, res) {
+        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' });
+        }
+    }
+}
+exports.default = Meetings;

package/dist/controllers/modules/index.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response } from 'express';
+export declare class ModulesController {
+    getModules(req: Request, res: Response): Promise<void>;
+    runSeeders(req: Request, res: Response): Promise<void>;
+}

package/dist/controllers/modules/index.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModulesController = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const seeder_1 = require("../../database/seeder");
+class ModulesController {
+    async getModules(req, res) {
+        try {
+            // Try multiple possible paths for modules.json
+            let modulesPath;
+            // 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, res) {
+        try {
+            console.log('Running seeders via API call...');
+            await (0, seeder_1.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)
+            });
+        }
+    }
+}
+exports.ModulesController = ModulesController;