feat: Enhance CV management features

Author: AryamanSi17

backend/package-lock.json

@@ -18,7 +18,8 @@
     "express": "^5.1.0",
     "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.18.0",
-    "multer": "^2.0.2",
+    "multer": "^1.4.4",
+    "multer-gridfs-storage": "^5.0.2",
     "nodemon": "^3.1.10"
   }
 }

backend/package.json

@@ -38,7 +38,72 @@ const getCV = asyncHandler(async (req, res) => {
     );
 });
 
+const uploadGovCV = asyncHandler(async (req, res) => {
+    const userId = req.user._id;
+    
+    if (!req.file) {
+        throw new ApiError(400, "Government CV file is required");
+    }
+    
+    // File validation (GridFS middleware handles the actual storage)
+    if (!req.file.gridfsId) {
+        throw new ApiError(500, "File upload to GridFS failed");
+    }
+    
+    const govCVData = {
+        userId: userId,
+        originalName: req.file.originalname,
+        filename: req.file.gridfsFilename,
+        fileId: req.file.gridfsId, // GridFS file ID
+        size: req.file.size,
+        uploadDate: new Date(),
+        type: 'government',
+        status: 'pending'
+    };
+    
+    const existingGovCV = await CV.findOne({
+        userId,
+        'govCV.type': 'government'
+    });
+    
+    if (existingGovCV) {
+        const updatedCV = await CV.findOneAndUpdate(
+            { userId },
+            {
+                $set: {
+                    'govCV': govCVData,
+                    lastModified: new Date()
+                }
+            },
+            { new: true }
+        );
+        return res.status(200).json(new ApiResponse(200, updatedCV, "Government CV uploaded successfully"));
+    } else {
+        const existingCV = await CV.findOne({ userId });
+        
+        if (existingCV) {
+            const updatedCV = await CV.findOneAndUpdate(
+                { userId },
+                {
+                    $set: {
+                        govCV: govCVData,
+                        lastModified: new Date()
+                    }
+                },
+                { new: true }
+            );
+            return res.status(200).json(new ApiResponse(200, updatedCV, "Government CV uploaded successfully"));
+        } else {
+            const newCV = await CV.create({
+                userId: userId,
+                govCV: govCVData,
+            });
+            return res.status(201).json(new ApiResponse(201, newCV, "Government CV uploaded and record created successfully"));
+        }
+    }
+});
 export {
     createOrUpdateCV,
-    getCV
+    getCV,
+    uploadGovCV
 }

backend/src/controllers/cv.controller.js

@@ -1,30 +1,72 @@
 import multer from 'multer';
-import path from 'path';
-import { ApiError } from '../utils/ApiError';
-
-const storage=multer.diskStorage({
-    destination:function(req,file,cb){
-        cb(null,path.join(path.resolve(),"uploads"));
-    },
-    filename:function(req,file,cb){
-        const uniqueSuffix=Date.now()+"-"+Math.round(Math.random()*1E9);
-        cb(null, req.user._id + '-' + uniqueSuffix + path.extname(file.originalname));
-    }
+import { GridFSBucket } from 'mongodb';
+import mongoose from 'mongoose';
+import { ApiError } from '../utils/ApiError.js';
+
+// Create GridFS bucket
+let bucket;
+mongoose.connection.once('open', () => {
+    bucket = new GridFSBucket(mongoose.connection.db, {
+        bucketName: 'uploads'
+    });
 });
 
-const fileFilter = (req, file, cb) => {
-    // Allow only PDF, DOC, DOCX files
-    const allowedTypes = /pdf|doc|docx/;
-    const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
-    const mimetype = allowedTypes.test(file.mimetype);
+// GridFS storage for multer
+const gridFSStorage = multer.memoryStorage();
+
+const pdfFileFilter = (req, file, cb) => {
+    if (file.mimetype === 'application/pdf') {
+        cb(null, true);
+    } else {
+        cb(new ApiError(400, "Only PDF files are allowed"));
+    }
+};
 
-    if (mimetype && extname) {
-        return cb(null, true);
+const documentFileFilter = (req, file, cb) => {
+    const allowedTypes = ['application/pdf', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'];
+    if (allowedTypes.includes(file.mimetype)) {
+        cb(null, true);
     } else {
         cb(new ApiError(400, "Only PDF, DOC, and DOCX files are allowed"));
     }
 };
 
-const upload = multer({ storage, fileFilter });
+// Middleware to save to GridFS after multer processes the file
+const saveToGridFS = (req, res, next) => {
+    if (!req.file || !bucket) {
+        return next();
+    }
+
+    const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1E9);
+    const filename = req.user._id + '-' + uniqueSuffix + '-' + req.file.originalname;
+    
+    const uploadStream = bucket.openUploadStream(filename, {
+        metadata: { uploadedBy: req.user._id }
+    });
+
+    uploadStream.end(req.file.buffer);
+    
+    uploadStream.on('finish', () => {
+        req.file.gridfsId = uploadStream.id;
+        req.file.gridfsFilename = filename;
+        next();
+    });
+
+    uploadStream.on('error', (error) => {
+        next(error);
+    });
+};
+
+const upload = multer({ 
+    storage: gridFSStorage,
+    fileFilter: documentFileFilter,
+    limits: { fileSize: 10 * 1024 * 1024 }
+});
+
+const uploadPDF = multer({ 
+    storage: gridFSStorage,
+    fileFilter: pdfFileFilter,
+    limits: { fileSize: 5 * 1024 * 1024 }
+});
 
-export { upload };
+export { upload, uploadPDF, saveToGridFS };

backend/src/middlewares/multer.middleware.js

@@ -20,6 +20,23 @@ const cvSchema = new mongoose.Schema({
             type: String,
             required: true
         },
+        gender: {
+            type: String,
+            enum: ['male', 'female', 'other', 'prefer-not-to-say'],
+            default: ""
+        },
+        nationality: {
+            type: String,
+            default: ""
+        },
+        usmleId: {
+            type: String,
+            default: ""
+        },
+        address: {
+            type: String,
+            default: ""
+        },
         medicalSchool: {
             type: String,
             required: true
@@ -28,10 +45,28 @@ const cvSchema = new mongoose.Schema({
             type: String,
             required: true
         },
+        mbbsRegNo: {
+            type: String,
+            default: ""
+        },
         city: {
             type: String,
             required: true
-        }
+        },
+        photo: {
+            type: String, // GridFS file ID for profile photo
+            default: null
+        },
+        languages: [{
+            language: {
+                type: String,
+                enum: ['English', 'Hindi', 'Spanish', 'French', 'German', 'Mandarin', 'Arabic', 'Portuguese', 'Russian', 'Japanese']
+            },
+            fluency: {
+                type: String,
+                enum: ['native', 'fluent', 'conversational', 'basic', 'beginner']
+            }
+        }]
     },
     education: {
         medicalSchoolName: {
@@ -191,6 +226,46 @@ const cvSchema = new mongoose.Schema({
             type: String,
             default: ""
         }
+    },
+    // Government CV upload section
+    govCV: {
+        userId: { 
+            type: mongoose.Schema.Types.ObjectId, 
+            ref: 'User' 
+        },
+        originalName: { 
+            type: String 
+        },
+        filename: { 
+            type: String 
+        },
+        fileId: { 
+            type: String // GridFS file ID
+        },
+        size: { 
+            type: Number 
+        },
+        uploadDate: { 
+            type: Date, 
+            default: Date.now 
+        },
+        type: { 
+            type: String, 
+            default: 'government' 
+        },
+        status: {
+            type: String,
+            enum: ['pending', 'approved', 'rejected'],
+            default: 'pending'
+        }
+    },
+    lastModified: {
+        type: Date,
+        default: Date.now
+    },
+    isComplete: {
+        type: Boolean,
+        default: false
     }
 }, {
     timestamps: true

backend/src/models/cv.model.js

@@ -1,9 +1,16 @@
-import {Router} from 'express';
-import {createOrUpdateCV,getCV} from '../controllers/cv.controller.js';
+import { Router } from 'express';
+import { createOrUpdateCV, getCV, uploadGovCV } from '../controllers/cv.controller.js';
 import { verifyJWT } from '../middlewares/auth.middleware.js';
+import { uploadPDF, saveToGridFS } from '../middlewares/multer.middleware.js';
 const router = Router();
 
 router.route('/save').post(verifyJWT, createOrUpdateCV);
 router.route('/:userId').get(verifyJWT, getCV);
+router.route('/upload-gov-csv').post(
+    verifyJWT,
+    uploadPDF.single('govCV'),
+    saveToGridFS,
+    uploadGovCV
+);
 
 export default router;