Merge pull request #30 from NextStepFinalProject/NXD-27-Edit-feed-page

Nxd 27 edit feed page

Author: taljacob2

.gitignore

@@ -79,6 +79,7 @@ web_modules/
 .env.test.local
 .env.production.local
 .env.local
+.env*
 
 # parcel-bundler cache (https://parceljs.org/)
 .cache

nextstep-backend/src/app.ts

@@ -62,6 +62,7 @@ app.use(authenticateToken.unless({
         { url: '/comment', methods: ['GET'] },
         { url: '/post', methods: ['GET'] },  // Allow GET to /post
         { url: /^\/resource\/image\/[^\/]+$/, methods: ['GET'] },  // Allow GET to /resource/image/{anything}
+        { url: /^\/resource\/file\/[^\/]+$/, methods: ['GET'] },  // Allow GET to /resource/image/{anything}
     ]
 }));
 

nextstep-backend/src/config/config.ts

@@ -15,6 +15,8 @@ export const config = {
         refresh_token_secret: () => process.env.REFRESH_TOKEN_SECRET || 'secret'
     },
     resources: {
+        filesDirectoryPath: () => 'resources/files',
+        fileMaxSize: () => 10 * 1024 * 1024, // Max file size: 10MB
         imagesDirectoryPath: () => 'resources/images',
         imageMaxSize: () => 10 * 1024 * 1024, // Max file size: 10MB
         resumesDirectoryPath: () => 'resources/resumes',

nextstep-backend/src/controllers/resources_controller.ts

@@ -2,7 +2,7 @@ import { Request, Response } from 'express';
 import { config } from '../config/config';
 import fs from 'fs';
 import path from 'path';
-import { uploadResume, uploadImage } from '../services/resources_service';
+import { uploadResume, uploadImage, uploadFile } from '../services/resources_service';
 import multer from 'multer';
 import {CustomRequest} from "types/customRequest";
 import {updateUserById} from "../services/users_service";
@@ -37,6 +37,19 @@ const createImageResource = async (req: Request, res: Response) => {
     }
 };
 
+const createFileResource = async (req: Request, res: Response) => {
+    try {
+        const filename = await uploadFile(req);
+        return res.status(201).send(filename);
+    } catch (error) {
+        if (error instanceof multer.MulterError || error instanceof TypeError) {
+            return res.status(400).send({ message: error.message });
+        } else {
+            handleError(error, res);
+        }
+    }
+};
+
 const getImageResource = async (req: Request, res: Response) => {
     try {
         const { filename } = req.params;
@@ -52,9 +65,27 @@ const getImageResource = async (req: Request, res: Response) => {
     }
 };
 
+const getFileResource = async (req: Request, res: Response) => {
+    try {
+        const { filename } = req.params;
+        const filePath = path.resolve(config.resources.filesDirectoryPath(), filename);
+
+        if (!fs.existsSync(filePath)) {
+            return res.status(404).send('File not found');
+        }
+
+        // res.sendFile(filePath);
+        return res.download(filePath);
+    } catch (error) {
+        handleError(error, res);
+    }
+};
+
 const createResumeResource = async (req: Request, res: Response) => {
     try {
-        const resumeFilename = await uploadResume(req);    
+        const resumeFilename = await uploadResume(req);
+
+
         return res.status(201).send(resumeFilename);
     } catch (error) {
         if (error instanceof multer.MulterError || error instanceof TypeError) {
@@ -83,7 +114,9 @@ const getResumeResource = async (req: Request, res: Response) => {
 export default {
     createUserImageResource,
     createImageResource,
+    createFileResource,
     getImageResource,
+    getFileResource,
     getResumeResource,
     createResumeResource
 };

nextstep-backend/src/controllers/resume_controller.ts

@@ -2,11 +2,20 @@ import { Request, Response } from 'express';
 import { config } from '../config/config';
 import fs from 'fs';
 import path from 'path';
-import { scoreResume, streamScoreResume, parseResumeFields } from '../services/resume_service';
+import { scoreResume, streamScoreResume, parseResumeFields,
+    saveParsedResume, getResumeByOwner, updateResume } from '../services/resume_service';
 import multer from 'multer';
+import {getResumeBuffer, resumeExists} from '../services/resources_service';
 import { CustomRequest } from "types/customRequest";
 import { handleError } from "../utils/handle_error";
 
+// Simple in-memory cache: { [key: string]: { scoreAndFeedback, timestamp } }
+const resumeScoreCache: Record<string, { data: any, timestamp: number }> = {};
+const CACHE_TTL_MS = 24* 60 * 60 * 1000; // 24 hour
+
+const getCacheKey = (filename: string, jobDescription?: string) =>
+    `${filename}::${jobDescription || ''}`;
+
 const getResumeScore = async (req: Request, res: Response) => {
     try {
         const { filename } = req.params;
@@ -17,7 +26,14 @@ const getResumeScore = async (req: Request, res: Response) => {
             return res.status(404).send('Resume not found');
         }
 
+        const cacheKey = getCacheKey(filename, jobDescription);
+        const cached = resumeScoreCache[cacheKey];
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+            return res.status(200).send(cached.data);
+        }
+
         const scoreAndFeedback = await scoreResume(resumePath, jobDescription);
+        resumeScoreCache[cacheKey] = { data: scoreAndFeedback, timestamp: Date.now() };
         return res.status(200).send(scoreAndFeedback);
     } catch (error) {
         if (error instanceof TypeError) {
@@ -28,7 +44,7 @@ const getResumeScore = async (req: Request, res: Response) => {
     }
 };
 
-const getStreamResumeScore = async (req: Request, res: Response) => {
+const getStreamResumeScore = async (req: CustomRequest, res: Response) => {
     try {
         const { filename } = req.params;
         const resumePath = path.resolve(config.resources.resumesDirectoryPath(), filename);
@@ -38,6 +54,18 @@ const getStreamResumeScore = async (req: Request, res: Response) => {
             return res.status(404).send('Resume not found');
         }
 
+        const cacheKey = getCacheKey(filename, jobDescription);
+        const cached = resumeScoreCache[cacheKey];
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+            // Stream cached result as SSE
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.write(`data: ${JSON.stringify({ ...cached.data, done: true })}\n\n`);
+            res.end();
+            return;
+        }
+
         // Set headers for SSE
         res.setHeader('Content-Type', 'text/event-stream');
         res.setHeader('Cache-Control', 'no-cache');
@@ -49,17 +77,24 @@ const getStreamResumeScore = async (req: Request, res: Response) => {
         });
 
         // Stream the response
-        const score = await streamScoreResume(
+        let fullChunk = '';
+        const [score, fullText] = await streamScoreResume(
             resumePath,
             jobDescription,
             (chunk) => {
+                fullChunk += chunk;
                 res.write(`data: ${JSON.stringify({ chunk })}\n\n`);
             }
         );
 
         // Send the final score
         res.write(`data: ${JSON.stringify({ score, done: true })}\n\n`);
         res.end();
+
+        // Optionally cache the result (score and fullText)
+        resumeScoreCache[cacheKey] = { data: { score, fullText }, timestamp: Date.now() };
+        await updateResume(req.user.id, jobDescription, fullText, score);
+
     } catch (error) {
         if (error instanceof TypeError) {
             return res.status(400).send(error.message);
@@ -69,17 +104,57 @@ const getStreamResumeScore = async (req: Request, res: Response) => {
     }
 };
 
-const parseResume = async (req: Request, res: Response) => {
+
+const parseResume = async (req: CustomRequest, res: Response) => {
     try {
-      if (!req.file) {
+      if (!req.body.resumefileName) {
         return res.status(400).json({ error: 'No resume file uploaded' });
       }
-      const parsed = await parseResumeFields(req.file.buffer, req.file.originalname);
+      else if (!resumeExists(req.body.resumefileName)) {
+          return res.status(400).json({ error: 'No resume file uploaded' });
+      }
+
+      const resumeFilename = req.body.resumefileName;
+      const parsed = await parseResumeFields(getResumeBuffer(req.body.resumefileName), resumeFilename);
+      const resumeData = await saveParsedResume(parsed, req.user.id, resumeFilename, req.body.originfilename);
+
       return res.status(200).json(parsed);
     } catch (err: any) {
       console.error('Error parsing resume:', err);
       return handleError(err, res);
     }
   };
 
-export default { parseResume, getResumeScore, getStreamResumeScore };
+const getResume = async (req: CustomRequest, res: Response) => {
+    try {
+        const ownerId = req.user.id;
+        const resume = await getResumeByOwner(ownerId);
+
+        if (!resume) {
+            return res.status(404).json({ error: 'Resume not found' });
+        }
+
+        return res.status(200).json(resume);
+    } catch (error) {
+        console.error('Error retrieving resume:', error);
+        return handleError(error, res);
+    }
+}
+
+
+const getResumeData = async (req: CustomRequest, res: Response) => {
+    try {
+        const ownerId = req.user.id;
+        // Get the optional version parameter from query string
+        const version = req.query.version ? parseInt(req.query.version as string) : undefined;
+        const resume = await getResumeByOwner(ownerId, version);
+
+        return res.status(200).json(resume);
+    } catch (error) {
+        console.error('Error retrieving resume data:', error);
+        return handleError(error, res);
+    }
+};
+
+export default { parseResume, getResumeScore,
+    getStreamResumeScore, getResumeData, getResume };

nextstep-backend/src/controllers/users_controller.ts

@@ -36,6 +36,25 @@ export const getUserById = async (req: Request, res: Response): Promise<void> =>
 }
 
 
+export const updateUserProfile = async (req: Request, res: Response) => {
+    const { aboutMe, skills, selectedRole } = req.body;
+
+    if (!req.params.id) {
+        return res.status(400).json({ error: 'User ID is required' });
+    }
+
+    try {
+        const updatedUser = await usersService.updateUserProfile(req.params.id, aboutMe, skills, selectedRole);
+        if (!updatedUser) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+
+        res.status(200).json(updatedUser);
+    } catch (error) {
+        handleError(error, res);
+    }
+};
+
 export const updateUserById = async (req: Request, res: Response): Promise<void> => {
     try {
         const user = await usersService.updateUserById(req.params.id, req.body);

nextstep-backend/src/models/resume_model.ts

@@ -0,0 +1,39 @@
+import mongoose, { Schema } from 'mongoose';
+import {ResumeData} from "types/resume_types";
+
+const ResumeSchema = new Schema({
+    owner: { type: Schema.Types.ObjectId, ref: 'User', required: true },
+    version: { type: Number, required: true },
+    rawContentLink: { type: String, required: true },
+    parsedData: {
+        type: {
+            fileName: { type: String, required: false },
+            aboutMe: { type: String, required: false },
+            skills: { type: [String], required: false },
+            roleMatch: { type: String, required: false },
+            experience: { type: [String], required: false },
+            jobDescription: { type: String, required: false },
+            feedback: { type: String, required: false },
+            score: { type: Number, required: false },
+        },
+        required: false
+    },
+    createdAt: { type: Date, default: Date.now }
+}, { versionKey: false });
+
+
+ResumeSchema.set('toJSON', {
+    transform: (doc, ret): ResumeData => {
+        return {
+            id: ret._id,
+            owner: ret.owner._id.toString(),
+            createdAt: ret.createdAt,
+            updatedAt: ret.updatedAt,
+            version: ret.version,
+            rawContentLink: ret.rawContentLink,
+            parsedData: ret.parsedData
+        };
+    }
+});
+
+export const ResumeModel = mongoose.model('Resume', ResumeSchema);

nextstep-backend/src/models/user_model.ts

@@ -23,6 +23,18 @@ const userSchema: Schema = new Schema({
         type: Date,
         default: Date.now
     },
+    aboutMe: {
+        type: String,
+        default: ""
+    },
+    skills: {
+        type: [String],
+        default: []
+    },
+    selectedRole: {
+        type: String,
+        default: ""
+    },
     authProvider: {
         type: String
     }
@@ -37,7 +49,10 @@ userSchema.set('toJSON', {
             password: ret.password as string,
             imageFilename: ret?.imageFilename as string | undefined,
             createdAt: ret.createdAt ? ret.createdAt.toISOString() : undefined,
-            updatedAt: ret.updatedAt ? ret.updatedAt.toISOString() : undefined
+            updatedAt: ret.updatedAt ? ret.updatedAt.toISOString() : undefined,
+            aboutMe: ret?.aboutMe as string | undefined,
+            skills: ret?.skills as string[] | undefined,
+            selectedRole: ret?.selectedRole as string | undefined
         };
     }
 });

nextstep-backend/src/routes/resources_routes.ts

@@ -7,8 +7,10 @@ const router = express.Router();
 router.post('/image/user', (req: Request, res: Response) => Resource.createUserImageResource(req as CustomRequest, res));
 
 router.post('/image', Resource.createImageResource);
+router.post('/file', Resource.createFileResource);
 
 router.get('/image/:filename', Resource.getImageResource);
+router.get('/file/:filename', Resource.getFileResource);
 
 router.post('/resume', Resource.createResumeResource);
 

nextstep-backend/src/routes/resume_routes.ts

@@ -2,15 +2,22 @@ import express, { Request, Response } from 'express';
 import Resume from '../controllers/resume_controller';
 import { CustomRequest } from "types/customRequest";
 import multer from 'multer';
+import * as commentsController from "../controllers/comments_controller";
 
 const upload = multer(); 
 
 const router = express.Router();
 
 router.get('/score/:filename', Resume.getResumeScore);
 
-router.get('/streamScore/:filename', Resume.getStreamResumeScore);
+router.get('/streamScore/:filename', (req: Request, res: Response) => Resume.getStreamResumeScore(req as CustomRequest, res));
+
+router.post('/parseResume',  upload.single('resume'), (req: Request, res: Response) => Resume.parseResume(req as CustomRequest, res));
+
+// TODO - Use it in the frontend after the parse and upload resume
+router.get('/resumeData/:version', (req: Request, res: Response) => Resume.getResumeData(req as CustomRequest, res))
+
+router.get('/', (req: Request, res: Response) => Resume.getResume(req as CustomRequest, res))
 
-router.post('/parseResume',  upload.single('resume'), Resume.parseResume);
 
 export default router;