Thank you for subscribing to our email updates!
+If you would like to unsubscribe, please click here
+ + `; + +function extractImagesAndCreateAttachments(html) { + const $ = cheerio.load(html); + const attachments = []; + + $('img').each((i, img) => { + const src = $(img).attr('src'); + if (src.startsWith('data:image')) { + const base64Data = src.split(',')[1]; + const _cid = `image-${i}`; + attachments.push({ + filename: `image-${i}.png`, + content: Buffer.from(base64Data, 'base64'), + cid: _cid, + }); + $(img).attr('src', `cid:${_cid}`); + } + }); + return { + html: $.html(), + attachments, + }; +} + const sendEmail = async (req, res) => { + const canSendEmail = await hasPermission(req.body.requestor, 'sendEmails'); + if (!canSendEmail) { + res.status(403).send('You are not authorized to send emails.'); + return; + } try { const { to, subject, html } = req.body; + // Validate required fields + if (!subject || !html || !to) { + const missingFields = []; + if (!subject) missingFields.push('Subject'); + if (!html) missingFields.push('HTML content'); + if (!to) missingFields.push('Recipient email'); + console.log('missingFields', missingFields); + return res + .status(400) + .send(`${missingFields.join(' and ')} ${missingFields.length > 1 ? 'are' : 'is'} required`); + } + + // Extract images and create attachments + const { html: processedHtml, attachments } = extractImagesAndCreateAttachments(html); + + // Log recipient for debugging + console.log('Recipient:', to); + await emailSender(to, subject, html) .then(result => { @@ -21,6 +93,7 @@ const sendEmail = async (req, res) => { res.status(500).send('Error sending email'); }); + } catch (error) { console.error('Error sending email:', error); return res.status(500).send('Error sending email'); @@ -28,48 +101,51 @@ const sendEmail = async (req, res) => { }; const sendEmailToAll = async (req, res) => { + const canSendEmailToAll = await hasPermission(req.body.requestor, 'sendEmailToAll'); + if (!canSendEmailToAll) { + res.status(403).send('You are not authorized to send emails to all.'); + return; + } try { const { subject, html } = req.body; + if (!subject || !html) { + return res.status(400).send('Subject and HTML content are required'); + } + + const { html: processedHtml, attachments } = extractImagesAndCreateAttachments(html); + const users = await userProfile.find({ - firstName: 'Haoji', + firstName: '', email: { $ne: null }, isActive: true, emailSubscriptions: true, }); - let to = ''; - const emailContent = ` - - - - + if (users.length === 0) { + return res.status(404).send('No users found'); + } + const recipientEmails = users.map((user) => user.email); + console.log('# sendEmailToAll to', recipientEmails.join(',')); + if (recipientEmails.length === 0) { + throw new Error('No recipients defined'); + } - - ${html} - - `; - users.forEach((user) => { - to += `${user.email},`; - }); - emailSender(to, subject, emailContent); - const emailList = await EmailSubcriptionList.find({ email: { $ne: null } }); - emailList.forEach((emailObject) => { - const { email } = emailObject; - const emailContent = ` - - - - + const emailContentToOCmembers = handleContentToOC(processedHtml); + await Promise.all( + recipientEmails.map((email) => + emailSender(email, subject, emailContentToOCmembers, attachments), + ), + ); + const emailSubscribers = await EmailSubcriptionList.find({ email: { $exists: true, $ne: '' } }); + console.log('# sendEmailToAll emailSubscribers', emailSubscribers.length); + await Promise.all( + emailSubscribers.map(({ email }) => { + const emailContentToNonOCmembers = handleContentToNonOC(processedHtml, email); + return emailSender(email, subject, emailContentToNonOCmembers, attachments); + }), + ); - - ${html} -Thank you for subscribing to our email updates!
-If you would like to unsubscribe, please click here
- - `; - emailSender(email, subject, emailContent); - }); return res.status(200).send('Email sent successfully'); } catch (error) { console.error('Error sending email:', error); @@ -107,13 +183,9 @@ const addNonHgnEmailSubscription = async (req, res) => { } const payload = { email }; - const token = jwt.sign( - payload, - jwtSecret, - { - expiresIn: 360, - }, - ); + const token = jwt.sign(payload, jwtSecret, { + expiresIn: 360, + }); const emailContent = ` diff --git a/src/controllers/emailController.spec.js b/src/controllers/emailController.spec.js new file mode 100644 index 000000000..f5327a328 --- /dev/null +++ b/src/controllers/emailController.spec.js @@ -0,0 +1,146 @@ +const { mockReq, mockRes, assertResMock } = require('../test'); +const emailController = require('./emailController'); +const jwt = require('jsonwebtoken'); +const userProfile = require('../models/userProfile'); + + +jest.mock('jsonwebtoken'); +jest.mock('../models/userProfile'); +jest.mock('../utilities/emailSender'); + + + + +const makeSut = () => { + const { + sendEmail, + sendEmailToAll, + updateEmailSubscriptions, + addNonHgnEmailSubscription, + removeNonHgnEmailSubscription, + confirmNonHgnEmailSubscription, + } = emailController; + return { + sendEmail, + sendEmailToAll, + updateEmailSubscriptions, + addNonHgnEmailSubscription, + removeNonHgnEmailSubscription, + confirmNonHgnEmailSubscription, + }; +}; +describe('emailController Controller Unit tests', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + describe('sendEmail function', () => { + test('should send email successfully', async () => { + const { sendEmail } = makeSut(); + const mockReq = { + body: { + to: 'recipient@example.com', + subject: 'Test Subject', + html: 'Test Body
', + }, + }; + const response = await sendEmail(mockReq, mockRes); + assertResMock(200, 'Email sent successfully', response, mockRes); + }); +}); + + describe('updateEmailSubscriptions function', () => { + test('should handle error when updating email subscriptions', async () => { + const { updateEmailSubscriptions } = makeSut(); + + + userProfile.findOneAndUpdate = jest.fn(); + + userProfile.findOneAndUpdate.mockRejectedValue(new Error('Update failed')); + + const mockReq = { + body: { + emailSubscriptions: ['subscription1', 'subscription2'], + requestor: { + email: 'test@example.com', + }, + }, + }; + + const response = await updateEmailSubscriptions(mockReq, mockRes); + + assertResMock(500, 'Error updating email subscriptions', response, mockRes); + }); + }); + + + describe('confirmNonHgnEmailSubscription function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + beforeAll(() => { + jwt.verify = jest.fn(); + }); + + test('should return 400 if token is not provided', async () => { + const { confirmNonHgnEmailSubscription } = makeSut(); + + const mockReq = { body: {} }; + const response = await confirmNonHgnEmailSubscription(mockReq, mockRes); + + assertResMock(400, 'Invalid token', response, mockRes); + }); + + test('should return 401 if token is invalid', async () => { + const { confirmNonHgnEmailSubscription } = makeSut(); + const mockReq = { body: { token: 'invalidToken' } }; + + jwt.verify.mockImplementation(() => { + throw new Error('Token is not valid'); + }); + + await confirmNonHgnEmailSubscription(mockReq, mockRes); + + expect(mockRes.status).toHaveBeenCalledWith(401); + expect(mockRes.json).toHaveBeenCalledWith({ + errors: [ + { msg: 'Token is not valid' }, + ], + }); + }); + + + test('should return 400 if email is missing from payload', async () => { + const { confirmNonHgnEmailSubscription } = makeSut(); + const mockReq = { body: { token: 'validToken' } }; + + // Mocking jwt.verify to return a payload without email + jwt.verify.mockReturnValue({}); + + const response = await confirmNonHgnEmailSubscription(mockReq, mockRes); + + assertResMock(400, 'Invalid token', response, mockRes); + }); + + + + + + }); + describe('removeNonHgnEmailSubscription function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('should return 400 if email is missing', async () => { + const { removeNonHgnEmailSubscription } = makeSut(); + const mockReq = { body: {} }; + + const response = await removeNonHgnEmailSubscription(mockReq, mockRes); + + assertResMock(400, 'Email is required', response, mockRes); + }); + }); + + }); diff --git a/src/controllers/informationController.js b/src/controllers/informationController.js index 792620995..03a23ba57 100644 --- a/src/controllers/informationController.js +++ b/src/controllers/informationController.js @@ -1,17 +1,17 @@ -const mongoose = require('mongoose'); +// const mongoose = require('mongoose'); // const userProfile = require('../models/userProfile'); // const hasPermission = require('../utilities/permissions'); const escapeRegex = require('../utilities/escapeRegex'); -const cache = require('../utilities/nodeCache')(); +const cacheClosure = require('../utilities/nodeCache'); const informationController = function (Information) { + const cache = cacheClosure(); const getInformations = function (req, res) { // return all informations if cache is available if (cache.hasCache('informations')) { res.status(200).send(cache.getCache('informations')); return; } - Information.find({}, 'infoName infoContent visibility') .then((results) => { // cache results diff --git a/src/controllers/informationController.spec.js b/src/controllers/informationController.spec.js new file mode 100644 index 000000000..e69dd2a32 --- /dev/null +++ b/src/controllers/informationController.spec.js @@ -0,0 +1,392 @@ +/* eslint-disable no-unused-vars */ +// const mongoose = require('mongoose'); +const mongoose = require('mongoose'); + +jest.mock('../utilities/nodeCache'); +const cache = require('../utilities/nodeCache'); +const Information = require('../models/information'); +const escapeRegex = require('../utilities/escapeRegex'); +const informationController = require('./informationController'); +const { mockReq, mockRes, assertResMock } = require('../test'); + +/* eslint-disable no-unused-vars */ +/* eslint-disable prefer-promise-reject-errors */ + +const makeSut = () => { + const { addInformation, getInformations, updateInformation, deleteInformation } = + informationController(Information); + + return { + addInformation, + getInformations, + updateInformation, + deleteInformation, + }; +}; +// Define flushPromises function)); +const flushPromises = () => new Promise(setImmediate); + +const makeMockCache = (method, value) => { + const cacheObject = { + getCache: jest.fn(), + removeCache: jest.fn(), + hasCache: jest.fn(), + setCache: jest.fn(), + }; + + const mockCache = jest.spyOn(cacheObject, method).mockImplementationOnce(() => value); + + cache.mockImplementationOnce(() => cacheObject); + + return { mockCache, cacheObject }; +}; + +describe('informationController module', () => { + beforeEach(() => {}); + afterEach(() => { + jest.clearAllMocks(); + }); + describe('addInformation function', () => { + test('Ensure addInformation returns 500 if any error when finding any information', async () => { + const { addInformation } = makeSut(); + const newMockReq = { + ...mockReq.body, + body: { + infoName: 'some infoName', + }, + }; + jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.reject(new Error('Error when finding'))); + const response = addInformation(newMockReq, mockRes); + await flushPromises(); + assertResMock(500, { error: new Error('Error when finding') }, response, mockRes); + }); + test('Ensure addInformation returns 400 if duplicate info Name', async () => { + const { addInformation } = makeSut(); + const data = [{ infoName: 'test Info' }]; + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.resolve(data)); + const newMockReq = { + body: { + ...mockReq.body, + infoName: 'test Info', + }, + }; + const response = addInformation(newMockReq, mockRes); + await flushPromises(); + expect(findSpy).toHaveBeenCalledWith({ + infoName: { $regex: escapeRegex(newMockReq.body.infoName), $options: 'i' }, + }); + assertResMock( + 400, + { + error: `Info Name must be unique. Another infoName with name ${newMockReq.body.infoName} already exists. Please note that info names are case insensitive`, + }, + response, + mockRes, + ); + }); + test('Ensure addInformations returns 400 if any error when saving new Information', async () => { + const { addInformation } = makeSut(); + const newMockReq = { + body: { + ...mockReq.body, + infoName: 'some Info', + }, + }; + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.resolve(true)); + jest + .spyOn(Information.prototype, 'save') + .mockImplementationOnce(() => Promise.reject(new Error('Error when saving'))); + const response = addInformation(newMockReq, mockRes); + await flushPromises(); + + expect(findSpy).toHaveBeenCalledWith({ + infoName: { $regex: escapeRegex(newMockReq.body.infoName), $options: 'i' }, + }); + assertResMock(400, new Error('Error when saving'), response, mockRes); + }); + + test('Ensure addInformation returns 201 if creating information successfully when no cache', async () => { + const { mockCache: hasCacheMock } = makeMockCache('hasCache', ''); + const { addInformation } = makeSut(); + const data = { + infoName: 'mockAdd', + infoContent: 'mockContent', + visibility: '1', + }; + + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.resolve([])); + jest.spyOn(Information.prototype, 'save').mockImplementationOnce(() => Promise.resolve(data)); + const newMockReq = { + body: { + ...mockReq.body, + infoName: 'some addInfo', + infoContent: '1', + visibility: '1', + }, + }; + const response = addInformation(newMockReq, mockRes); + await flushPromises(); + expect(findSpy).toHaveBeenCalledWith({ + infoName: { $regex: escapeRegex(newMockReq.body.infoName), $options: 'i' }, + }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + assertResMock(201, data, response, mockRes); + }); + test('Ensure addInformation returns 201 if creating information successfully', async () => { + const { mockCache: hasCacheMock, cacheObject } = makeMockCache('hasCache', '[{_id: 1}]'); + const removeCacheMock = jest + .spyOn(cacheObject, 'removeCache') + .mockImplementationOnce(() => null); + const { addInformation } = makeSut(); + const data = [ + { + infoName: 'mockAdd', + infoContent: 'mockContent', + visibility: '1', + }, + ]; + + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.resolve([])); + jest.spyOn(Information.prototype, 'save').mockImplementationOnce(() => Promise.resolve(data)); + const newMockReq = { + body: { + ...mockReq.body, + infoName: 'some addInfo', + infoContent: '1', + visibility: '1', + }, + }; + addInformation(newMockReq, mockRes); + await flushPromises(); + expect(findSpy).toHaveBeenCalledWith({ + infoName: { $regex: escapeRegex(newMockReq.body.infoName), $options: 'i' }, + }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(removeCacheMock).toHaveBeenCalledWith('informations'); + }); + }); + describe('getInformations function', () => { + test('Ensure getInformations returns 200 if when informations key in cache', async () => { + const data = [ + { + _id: 1, + infoName: 'infoName', + infoContent: 'infoContent', + visibility: '1', + }, + ]; + const { mockCache: hasCacheMock, cacheObject } = makeMockCache('hasCache', data); + const getCacheMock = jest.spyOn(cacheObject, 'getCache').mockImplementationOnce(() => data); + const { getInformations } = makeSut(); + + const response = getInformations(mockReq, mockRes); + await flushPromises(); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(getCacheMock).toHaveBeenCalledWith('informations'); + assertResMock(200, data, response, mockRes); + }); + test('Ensure getInformations returns 404 if any error when no informations key and catch error in finding', async () => { + const { mockCache: hasCacheMock } = makeMockCache('hasCache', ''); + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.reject(new Error('Error when finding information'))); + const { getInformations } = makeSut(); + + const response = getInformations(mockReq, mockRes); + await flushPromises(); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(findSpy).toHaveBeenCalledWith({}, 'infoName infoContent visibility'); + assertResMock(404, new Error('Error when finding information'), response, mockRes); + }); + + test('Ensure getInformations returns 200 when no informations key and no duplicated information', async () => { + const data = [ + { + infoName: 'mockAdd', + infoContent: 'mockContent', + visibility: '1', + }, + ]; + const { mockCache: hasCacheMock, cacheObject } = makeMockCache('hasCache', ''); + const findSpy = jest + .spyOn(Information, 'find') + .mockImplementationOnce(() => Promise.resolve(data)); + const setCacheMock = jest.spyOn(cacheObject, 'setCache').mockImplementationOnce(() => data); + + const { getInformations } = makeSut(); + const newMockReq = { + body: { + ...mockReq.body, + infoName: 'some getInfo', + infoContent: '1', + visibility: '1', + }, + }; + const response = getInformations(newMockReq, mockRes); + await flushPromises(); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(findSpy).toHaveBeenCalledWith({}, 'infoName infoContent visibility'); + expect(setCacheMock).toHaveBeenCalledWith('informations', data); + assertResMock(200, data, response, mockRes); + }); + }); + describe('deleteInformation function', () => { + test('Ensure deleteInformation returns 400 if any error when finding and delete information', async () => { + const errorMsg = 'Error when finding and deleting information by Id'; + const { deleteInformation } = makeSut(); + jest + .spyOn(Information, 'findOneAndDelete') + .mockImplementationOnce(() => Promise.reject(new Error(errorMsg))); + const response = deleteInformation(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, new Error(errorMsg), response, mockRes); + }); + test('Ensure deleteInformation returns 200 if delete information successfully no cache', async () => { + const { mockCache: hasCacheMock } = makeMockCache('hasCache', ''); + const deletedData = { + id: '601acda376045c7879d13a77', + infoName: 'deletedInfo', + infoContent: 'deleted', + visibility: '1', + }; + const { deleteInformation } = makeSut(); + const newMockReq = { + ...mockReq.body, + params: { + ...mockReq.params, + id: '601acda376045c7879d13a77', + }, + }; + const findOneDeleteSpy = jest + .spyOn(Information, 'findOneAndDelete') + .mockImplementationOnce(() => Promise.resolve(deletedData)); + const response = deleteInformation(newMockReq, mockRes); + await flushPromises(); + expect(findOneDeleteSpy).toHaveBeenCalledWith({ _id: deletedData.id }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + assertResMock(200, deletedData, response, mockRes); + }); + test('Ensure deleteInformation returns if delete information successfully and has cache', async () => { + const { mockCache: hasCacheMock, cacheObject } = makeMockCache('hasCache', '[{_id:123}]'); + const removeCacheMock = jest + .spyOn(cacheObject, 'removeCache') + .mockImplementationOnce(() => null); + const deletedData = { + id: '601acda376045c7879d13a77', + infoName: 'deletedInfo', + infoContent: 'deleted', + visibility: '1', + }; + const { deleteInformation } = makeSut(); + const newMockReq = { + ...mockReq.body, + params: { + ...mockReq.params, + id: '601acda376045c7879d13a77', + infoName: 'deletedInfo', + infoContent: 'deleted', + visibility: '1', + }, + }; + const findOneDeleteSpy = jest + .spyOn(Information, 'findOneAndDelete') + .mockImplementationOnce(() => Promise.resolve(deletedData)); + deleteInformation(newMockReq, mockRes); + await flushPromises(); + expect(findOneDeleteSpy).toHaveBeenCalledWith({ _id: deletedData.id }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(removeCacheMock).toHaveBeenCalledWith('informations'); + }); + }); + describe('updateInformation function', () => { + test('Ensure updateInformation returns 400 if any error when finding and update information', async () => { + const errorMsg = 'Error when finding and updating information by Id'; + const { updateInformation } = makeSut(); + jest + .spyOn(Information, 'findOneAndUpdate') + .mockImplementationOnce(() => Promise.reject(new Error(errorMsg))); + const response = updateInformation(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, new Error(errorMsg), response, mockRes); + }); + test('Ensure updateInformation returns 200 if finding and update information successfuly when nocache', async () => { + const { mockCache: hasCacheMock } = makeMockCache('hasCache', ''); + const data = { + id: '601acda376045c7879d13a77', + infoName: 'updatedInfo', + infoContent: 'updated', + visibility: '1', + }; + const newMockReq = { + body: { + id: '601acda376045c7879d13a77', + infoName: 'oldInfo', + infoContent: 'old', + visibility: '0', + }, + params: { + ...mockReq.params, + id: '601acda376045c7879d13a77', + }, + }; + const findOneUpdateSpy = jest + .spyOn(Information, 'findOneAndUpdate') + .mockImplementationOnce(() => Promise.resolve(data)); + const { updateInformation } = makeSut(); + const response = updateInformation(newMockReq, mockRes); + await flushPromises(); + expect(findOneUpdateSpy).toHaveBeenCalledWith({ _id: data.id }, newMockReq.body, { + new: true, + }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + assertResMock(200, data, response, mockRes); + }); + test('Ensure updateInformation returns if finding and update information successfuly when hascache', async () => { + const { mockCache: hasCacheMock, cacheObject } = makeMockCache('hasCache', '[{_id:123}]'); + const removeCacheMock = jest + .spyOn(cacheObject, 'removeCache') + .mockImplementationOnce(() => null); + const data = { + id: '601acda376045c7879d13a77', + infoName: 'updatedInfo', + infoContent: 'updated', + visibility: '1', + }; + const newMockReq = { + body: { + id: '601acda376045c7879d13a77', + infoName: 'oldInfo', + infoContent: 'old', + visibility: '0', + }, + params: { + ...mockReq.params, + id: '601acda376045c7879d13a77', + }, + }; + const findOneUpdateSpy = jest + .spyOn(Information, 'findOneAndUpdate') + .mockImplementationOnce(() => Promise.resolve(data)); + const { updateInformation } = makeSut(); + updateInformation(newMockReq, mockRes); + await flushPromises(); + expect(findOneUpdateSpy).toHaveBeenCalledWith({ _id: data.id }, newMockReq.body, { + new: true, + }); + expect(hasCacheMock).toHaveBeenCalledWith('informations'); + expect(removeCacheMock).toHaveBeenCalledWith('informations'); + }); + }); +}); diff --git a/src/controllers/jobsController.js b/src/controllers/jobsController.js new file mode 100644 index 000000000..65cfeafdc --- /dev/null +++ b/src/controllers/jobsController.js @@ -0,0 +1,131 @@ +const Job = require('../models/jobs'); // Import the Job model + +// Controller to fetch all jobs with pagination, search, and filtering +const getJobs = async (req, res) => { + const { page = 1, limit = 18, search = '', category = '' } = req.query; + + try { + // Validate query parameters + const pageNumber = Math.max(1, parseInt(page, 10)); // Ensure page is at least 1 + const limitNumber = Math.max(1, parseInt(limit, 10)); // Ensure limit is at least 1 + + // Build query object + const query = {}; + if (search) query.title = { $regex: search, $options: 'i' }; // Case-insensitive search + if (category) query.category = category; + + // Fetch total count for pagination metadata + const totalJobs = await Job.countDocuments(query); + + // Fetch paginated results + const jobs = await Job.find(query) + .skip((pageNumber - 1) * limitNumber) + .limit(limitNumber); + + // Prepare response + res.json({ + jobs, + pagination: { + totalJobs, + totalPages: Math.ceil(totalJobs / limitNumber), + currentPage: pageNumber, + limit: limitNumber, + hasNextPage: pageNumber < Math.ceil(totalJobs / limitNumber), + hasPreviousPage: pageNumber > 1, + }, + }); + } catch (error) { + res.status(500).json({ error: 'Failed to fetch jobs', details: error.message }); + } +}; + +// Controller to fetch job details by ID +const getJobById = async (req, res) => { + const { id } = req.params; + + try { + const job = await Job.findById(id); + if (!job) { + return res.status(404).json({ error: 'Job not found' }); + } + res.json(job); + } catch (error) { + res.status(500).json({ error: 'Failed to fetch job', details: error.message }); + } +}; + +// Controller to create a new job +const createJob = async (req, res) => { + const { title, category, description, imageUrl, location, applyLink, jobDetailsLink } = req.body; + + try { + const newJob = new Job({ + title, + category, + description, + imageUrl, + location, + applyLink, + jobDetailsLink, + }); + + const savedJob = await newJob.save(); + res.status(201).json(savedJob); + } catch (error) { + res.status(500).json({ error: 'Failed to create job', details: error.message }); + } +}; + +// Controller to update an existing job by ID +const updateJob = async (req, res) => { + const { id } = req.params; + + try { + const updatedJob = await Job.findByIdAndUpdate(id, req.body, { new: true }); + if (!updatedJob) { + return res.status(404).json({ error: 'Job not found' }); + } + res.json(updatedJob); + } catch (error) { + res.status(500).json({ error: 'Failed to update job', details: error.message }); + } +}; + +// Controller to delete a job by ID +const deleteJob = async (req, res) => { + const { id } = req.params; + + try { + const deletedJob = await Job.findByIdAndDelete(id); + if (!deletedJob) { + return res.status(404).json({ error: 'Job not found' }); + } + res.json({ message: 'Job deleted successfully' }); + } catch (error) { + res.status(500).json({ error: 'Failed to delete job', details: error.message }); + } +}; + +const getCategories = async (req, res) => { + try { + const categories = await Job.distinct('category', {}); + + // Sort categories alphabetically + categories.sort((a, b) => a.localeCompare(b)); + + res.status(200).json({ categories }); + } catch (error) { + console.error('Error fetching categories:', error); + res.status(500).json({ message: 'Failed to fetch categories' }); + } +}; + +// Export controllers as a plain object +module.exports = { + getJobs, + getJobById, + createJob, + updateJob, + deleteJob, + getCategories, +}; diff --git a/src/controllers/logincontroller.js b/src/controllers/logincontroller.js index 3ba0203aa..794d00d70 100644 --- a/src/controllers/logincontroller.js +++ b/src/controllers/logincontroller.js @@ -63,7 +63,7 @@ const logincontroller = function () { res.status(200).send({ token }); } else { - res.status(403).send({ + res.status(404).send({ message: 'Invalid password.', }); } diff --git a/src/controllers/logincontroller.spec.js b/src/controllers/logincontroller.spec.js index 595bfe77b..995be69de 100644 --- a/src/controllers/logincontroller.spec.js +++ b/src/controllers/logincontroller.spec.js @@ -110,7 +110,7 @@ describe('logincontroller module', () => { expect(findOneSpy).toHaveBeenCalledWith({ email: mockReqModified.body.email }); assertResMock( - 403, + 404, { message: 'Invalid password.', }, diff --git a/src/controllers/ownerMessageController.js b/src/controllers/ownerMessageController.js index 1b2c30205..3f74cb112 100644 --- a/src/controllers/ownerMessageController.js +++ b/src/controllers/ownerMessageController.js @@ -1,8 +1,11 @@ +const helper = require('../utilities/permissions'); + const ownerMessageController = function (OwnerMessage) { const getOwnerMessage = async function (req, res) { try { const results = await OwnerMessage.find({}); - if (results.length === 0) { // first time initialization + if (results.length === 0) { + // first time initialization const ownerMessage = new OwnerMessage(); await ownerMessage.save(); res.status(200).send({ ownerMessage }); @@ -15,7 +18,9 @@ const ownerMessageController = function (OwnerMessage) { }; const updateOwnerMessage = async function (req, res) { - if (req.body.requestor.role !== 'Owner') { + if ( + !(await helper.hasPermission(req.body.requestor, 'editHeaderMessage')) + ) { res.status(403).send('You are not authorized to create messages!'); } const { isStandard, newMessage } = req.body; @@ -40,7 +45,9 @@ const ownerMessageController = function (OwnerMessage) { }; const deleteOwnerMessage = async function (req, res) { - if (req.body.requestor.role !== 'Owner') { + if ( + !(await helper.hasPermission(req.body.requestor, 'editHeaderMessage')) + ) { res.status(403).send('You are not authorized to delete messages!'); } try { diff --git a/src/controllers/popupEditorController.spec.js b/src/controllers/popupEditorController.spec.js new file mode 100644 index 000000000..e70b05553 --- /dev/null +++ b/src/controllers/popupEditorController.spec.js @@ -0,0 +1,163 @@ +const PopUpEditor = require('../models/popupEditor'); +const { mockReq, mockRes, assertResMock } = require('../test'); + +jest.mock('../utilities/permissions'); + +const helper = require('../utilities/permissions'); +const popupEditorController = require('./popupEditorController'); + +const flushPromises = () => new Promise(setImmediate); + +const mockHasPermission = (value) => + jest.spyOn(helper, 'hasPermission').mockImplementationOnce(() => Promise.resolve(value)); + +const makeSut = () => { + const { getAllPopupEditors, getPopupEditorById, createPopupEditor, updatePopupEditor } = + popupEditorController(PopUpEditor); + return { getAllPopupEditors, getPopupEditorById, createPopupEditor, updatePopupEditor }; +}; + +describe('popupEditorController Controller Unit tests', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + describe(`getAllPopupEditors function`, () => { + test(`Should return 200 and popup editors on success`, async () => { + const { getAllPopupEditors } = makeSut(); + const mockPopupEditors = [{ popupName: 'popup', popupContent: 'content' }]; + jest.spyOn(PopUpEditor, 'find').mockResolvedValue(mockPopupEditors); + const response = await getAllPopupEditors(mockReq, mockRes); + assertResMock(200, mockPopupEditors, response, mockRes); + }); + + test(`Should return 404 on error`, async () => { + const { getAllPopupEditors } = makeSut(); + const error = new Error('Test Error'); + + jest.spyOn(PopUpEditor, 'find').mockRejectedValue(error); + const response = await getAllPopupEditors(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + }); + }); + + describe(`getPopupEditorById function`, () => { + test(`Should return 200 and popup editor on success`, async () => { + const { getPopupEditorById } = makeSut(); + const mockPopupEditor = { popupName: 'popup', popupContent: 'content' }; + jest.spyOn(PopUpEditor, 'findById').mockResolvedValue(mockPopupEditor); + const response = await getPopupEditorById(mockReq, mockRes); + assertResMock(200, mockPopupEditor, response, mockRes); + }); + + test(`Should return 404 on error`, async () => { + const { getPopupEditorById } = makeSut(); + const error = new Error('Test Error'); + + jest.spyOn(PopUpEditor, 'findById').mockRejectedValue(error); + const response = await getPopupEditorById(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + }); + }); + + describe(`createPopupEditor function`, () => { + test(`Should return 403 if user is not authorized`, async () => { + const { createPopupEditor } = makeSut(); + mockHasPermission(false); + const response = await createPopupEditor(mockReq, mockRes); + assertResMock( + 403, + { error: 'You are not authorized to create new popup' }, + response, + mockRes, + ); + }); + + test(`Should return 400 if popupName or popupContent is missing`, async () => { + const { createPopupEditor } = makeSut(); + mockHasPermission(true); + const response = await createPopupEditor(mockReq, mockRes); + assertResMock( + 400, + { error: 'popupName , popupContent are mandatory fields' }, + response, + mockRes, + ); + }); + + test(`Should return 201 and popup editor on success`, async () => { + const { createPopupEditor } = makeSut(); + mockHasPermission(true); + mockReq.body = { popupName: 'popup', popupContent: 'content' }; + const mockPopupEditor = { save: jest.fn().mockResolvedValue(mockReq.body) }; + jest.spyOn(PopUpEditor.prototype, 'save').mockImplementationOnce(mockPopupEditor.save); + const response = await createPopupEditor(mockReq, mockRes); + expect(mockPopupEditor.save).toHaveBeenCalled(); + assertResMock(201, mockReq.body, response, mockRes); + }); + + test(`Should return 500 on error`, async () => { + const { createPopupEditor } = makeSut(); + mockHasPermission(true); + const error = new Error('Test Error'); + + jest.spyOn(PopUpEditor.prototype, 'save').mockRejectedValue(error); + const response = await createPopupEditor(mockReq, mockRes); + await flushPromises(); + + assertResMock(500, { error }, response, mockRes); + }); + }); + describe(`updatePopupEditor function`, () => { + test(`Should return 403 if user is not authorized`, async () => { + const { updatePopupEditor } = makeSut(); + mockHasPermission(false); + const response = await updatePopupEditor(mockReq, mockRes); + assertResMock( + 403, + { error: 'You are not authorized to create new popup' }, + response, + mockRes, + ); + }); + + test(`Should return 400 if popupContent is missing`, async () => { + const { updatePopupEditor } = makeSut(); + mockReq.body = {}; + mockHasPermission(true); + const response = await updatePopupEditor(mockReq, mockRes); + assertResMock(400, { error: 'popupContent is mandatory field' }, response, mockRes); + }); + + test(`Should return 201 and popup editor on success`, async () => { + const { updatePopupEditor } = makeSut(); + mockHasPermission(true); + mockReq.body = { popupContent: 'content' }; + const mockPopupEditor = { save: jest.fn().mockResolvedValue(mockReq.body) }; + jest.spyOn(PopUpEditor, 'findById').mockImplementationOnce((mockReq, callback) => callback(null, mockPopupEditor)); + jest.spyOn(PopUpEditor.prototype, 'save').mockImplementationOnce(mockPopupEditor.save); + const response = await updatePopupEditor(mockReq, mockRes); + expect(mockPopupEditor.save).toHaveBeenCalled(); + assertResMock(201, mockReq.body, response, mockRes); + }); + + test('Should return 500 on popupEditor save error', async () => { + const { updatePopupEditor } = makeSut(); + mockHasPermission(true); + const err = new Error('Test Error'); + mockReq.body = { popupContent: 'content' }; + const mockPopupEditor = { save: jest.fn().mockRejectedValue(err)}; + jest + .spyOn(PopUpEditor, 'findById') + .mockImplementation((mockReq, callback) => callback(null, mockPopupEditor)); + jest.spyOn(PopUpEditor.prototype, 'save').mockImplementationOnce(mockPopupEditor.save); + const response = await updatePopupEditor(mockReq, mockRes); + await flushPromises(); + assertResMock(500, {err}, response, mockRes); + }); + }); +}); diff --git a/src/controllers/profileInitialSetupController.js b/src/controllers/profileInitialSetupController.js index fcf24ce1a..e56e7e406 100644 --- a/src/controllers/profileInitialSetupController.js +++ b/src/controllers/profileInitialSetupController.js @@ -172,13 +172,22 @@ const profileInitialSetupController = function ( const link = `${baseUrl}/ProfileInitialSetup/${savedToken.token}`; await session.commitTransaction(); - const acknowledgment = await sendEmailWithAcknowledgment( - email, - 'NEEDED: Complete your One Community profile setup', - sendLinkMessage(link), - ); - - return res.status(200).send(acknowledgment); + // Send response immediately without waiting for email acknowledgment + res.status(200).send({ message: 'Token created successfully, email is being sent.' }); + + // Asynchronously send the email acknowledgment + setImmediate(async () => { + try { + await sendEmailWithAcknowledgment( + email, + 'NEEDED: Complete your One Community profile setup', + sendLinkMessage(link), + ); + } catch (emailError) { + // Log email sending failure + LOGGER.logException(emailError, 'sendEmailWithAcknowledgment', JSON.stringify({ email, link }), null); + } + }); } catch (error) { await session.abortTransaction(); LOGGER.logException(error, 'getSetupToken', JSON.stringify(req.body), null); @@ -523,30 +532,26 @@ const profileInitialSetupController = function ( */ const getSetupInvitation = (req, res) => { const { role } = req.body.requestor; - if (role === 'Administrator' || role === 'Owner') { - try { - ProfileInitialSetupToken.find({ isSetupCompleted: false }) - .sort({ createdDate: -1 }) - .exec((err, result) => { - // Handle the result - if (err) { - LOGGER.logException(err); - return res - .status(500) - .send( - 'Internal Error: Please retry. If the problem persists, please contact the administrator', - ); - } - return res.status(200).send(result); - }); - } catch (error) { - LOGGER.logException(error); - return res - .status(500) - .send( - 'Internal Error: Please retry. If the problem persists, please contact the administrator', - ); - } + + const { permissions } = req.body.requestor; + let user_permissions = ['getUserProfiles','postUserProfile','putUserProfile','changeUserStatus'] + if ((role === 'Administrator') || (role === 'Owner') || (role === 'Manager') || (role === 'Mentor') || user_permissions.some(e=>permissions.frontPermissions.includes(e))) { + try{ + ProfileInitialSetupToken + .find({ isSetupCompleted: false }) + .sort({ createdDate: -1 }) + .exec((err, result) => { + // Handle the result + if (err) { + LOGGER.logException(err); + return res.status(500).send('Internal Error: Please retry. If the problem persists, please contact the administrator'); + } + return res.status(200).send(result); + }); + } catch (error) { + LOGGER.logException(error); + return res.status(500).send('Internal Error: Please retry. If the problem persists, please contact the administrator'); + } } else { return res.status(403).send('You are not authorized to get setup history.'); } diff --git a/src/controllers/projectController.js b/src/controllers/projectController.js index 72522ba80..3e48b3f42 100644 --- a/src/controllers/projectController.js +++ b/src/controllers/projectController.js @@ -291,12 +291,21 @@ const projectController = function (Project) { res.status(400).send('Invalid request'); return; } - const getId = await hasPermission(req.body.requestor, 'getProjectMembers'); + const getProjMembers = await hasPermission(req.body.requestor, 'getProjectMembers'); + + // If a user has permission to post, edit, or suggest tasks, they also have the ability to assign resources to those tasks. + // Therefore, the _id field must be included when retrieving the user profile for project members (resources). + const postTask = await hasPermission(req.body.requestor, 'postTask'); + const updateTask = await hasPermission(req.body.requestor, 'updateTask'); + const suggestTask = await hasPermission(req.body.requestor, 'suggestTask'); + + const canGetId = (getProjMembers || postTask || updateTask || suggestTask); + userProfile .find( { projects: projectId }, - { firstName: 1, lastName: 1, isActive: 1, profilePic: 1, _id: getId }, + { firstName: 1, lastName: 1, isActive: 1, profilePic: 1, _id: canGetId }, ) .sort({ firstName: 1, lastName: 1 }) .then((results) => { diff --git a/src/controllers/reasonSchedulingController.spec.js b/src/controllers/reasonSchedulingController.spec.js new file mode 100644 index 000000000..e58c77466 --- /dev/null +++ b/src/controllers/reasonSchedulingController.spec.js @@ -0,0 +1,626 @@ +const moment = require('moment-timezone'); +const { mockReq, mockRes, mockUser } = require('../test'); +const UserModel = require('../models/userProfile'); + +jest.mock('../utilities/emailSender'); +const emailSender = require('../utilities/emailSender') + +const { + postReason, + getAllReasons, + getSingleReason, + patchReason, + deleteReason, +} = require('./reasonSchedulingController'); + +// assertResMock +const ReasonModel = require('../models/reason'); + +const flushPromises = () => new Promise(setImmediate); + +function mockDay(dayIdx, past = false) { + const date = moment().tz('America/Los_Angeles').startOf('day'); + while (date.day() !== dayIdx) { + date.add(past ? -1 : 1, 'days'); + } + return date; +} + +describe('reasonScheduling Controller', () => { + beforeEach(() => { + jest.clearAllMocks(); + mockRes.json = jest.fn(); + mockReq.body = { + ...mockReq.body, + ...mockUser(), + reasonData: { + date: mockDay(0), + message: 'some reason', + }, + currentDate: moment.tz('America/Los_Angeles').startOf('day'), + }; + mockReq.params = { + ...mockReq.params, + ...mockUser(), + }; + }); + afterEach(() => { + jest.clearAllMocks(); + }); + describe('postReason method', () => { + test('Ensure postReason returns 400 for warning to choose Sunday', async () => { + mockReq.body.reasonData.date = mockDay(1, true); + await postReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: + "You must choose the Sunday YOU'LL RETURN as your date. This is so your reason ends up as a note on that blue square.", + errorCode: 0, + }), + ); + }); + test('Ensure postReason returns 400 for warning to choose a future date', async () => { + mockReq.body.reasonData.date = mockDay(0, true); + await postReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'You should select a date that is yet to come', + errorCode: 7, + }), + ); + }); + test('Ensure postReason returns 400 for not providing reason', async () => { + mockReq.body.reasonData.message = null; + await postReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'You must provide a reason.', + errorCode: 6, + }), + ); + }); + test('Ensure postReason returns 404 when error in finding user Id', async () => { + const mockFindUser = jest.spyOn(UserModel, 'findById').mockImplementationOnce(() => + Promise.resolve(null)); + + await postReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.body.userId); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'User not found', + errorCode: 2, + }), + ); + }); + test('Ensure postReason returns 403 when duplicate reason to the date', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + jest.spyOn(UserModel, 'findOneAndUpdate').mockResolvedValueOnce({ + _id: mockReq.body.userId, + timeOffFrom: mockReq.body.currentDate, + timeOffTill: mockReq.body.reasonData.date, + }); + const mockReason = { + reason: 'Some Reason', + userId: mockReq.body.userId, + date: moment.tz('America/Los_Angeles').startOf('day').toISOString(), + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValue(mockReason); + + await postReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(403); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.body.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.body.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'The reason must be unique to the date', + errorCode: 3, + }), + ); + }); + test('Ensure postReason returns 400 when any error in saving.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + jest.spyOn(UserModel, 'findOneAndUpdate').mockResolvedValueOnce({ + _id: mockReq.body.userId, + timeOffFrom: mockReq.body.currentDate, + timeOffTill: mockReq.body.reasonData.date, + }); + mockRes.sendStatus = jest.fn().mockReturnThis(); + const newReason = { + reason: mockReq.body.reasonData.message, + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.body.userId, + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValue(); + const mockSave = jest.spyOn(ReasonModel.prototype, 'save').mockRejectedValue(newReason); + emailSender.mockImplementation(() => { + throw new Error('Failed to send email'); + }); + + await postReason(mockReq, mockRes); + await flushPromises(); + emailSender.mockRejectedValue(new Error('Failed')); + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.body.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.body.userId, + }); + expect(mockSave).toHaveBeenCalledWith(); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + errMessage: 'Something went wrong', + }), + ); + }); + test('Ensure postReason returns 200 if schedule reason and send blue sqaure email successfully', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + jest.spyOn(UserModel, 'findOneAndUpdate').mockResolvedValueOnce({ + _id: mockReq.body.userId, + timeOffFrom: mockReq.body.currentDate, + timeOffTill: mockReq.body.reasonData.date, + }); + mockRes.sendStatus = jest.fn().mockReturnThis(); + const newReason = { + reason: mockReq.body.reasonData.message, + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.body.userId, + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValue(); + const mockSave = jest.spyOn(ReasonModel.prototype, 'save').mockResolvedValue(newReason); + emailSender.mockImplementation(() => { + Promise.resolve(); + }); + await postReason(mockReq, mockRes); + await flushPromises(); + expect(mockRes.sendStatus).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.body.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.body.userId, + }); + expect(mockSave).toHaveBeenCalledWith(); + }); + }); + describe('getAllReason method', () => { + test('Ensure get AllReason returns 404 when error in finding user Id', async () => { + const mockFindUser = jest.spyOn(UserModel, 'findById').mockImplementationOnce(() => null); + + await getAllReasons(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'User not found', + }), + ); + }); + test('Ensure get AllReason returns 400 when any error in fetching the user', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const mockFoundReason = jest.spyOn(ReasonModel, 'find').mockRejectedValueOnce(null); + await getAllReasons(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + userId: mockReq.params.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + errMessage: 'Something went wrong while fetching the user', + }), + ); + }); + test('Ensure get AllReason returns 200 when get schedule reason successfully', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const reasons = { + reason: 'Some Reason', + userId: mockReq.params.userId, + date: moment.tz('America/Los_Angeles').startOf('day').toISOString(), + isSet: true, + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'find').mockResolvedValue(reasons); + await getAllReasons(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + userId: mockReq.params.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + reasons, + }), + ); + }); + }); + describe('getSingleReason method', () => { + test('Ensure getSingleReason return 400 when any error in fetching the user', async () => { + await getSingleReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Something went wrong while fetching single reason', + }), + ); + }); + test('Ensure getSingleReason return 404 when any error in find user by Id', async () => { + mockReq.query = { + queryData: mockDay(0), + }; + const mockFindUser = jest.spyOn(UserModel, 'findById').mockImplementationOnce(() => null); + + await getSingleReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'User not found', + errorCode: 2, + }), + ); + }); + test('Ensure getSingleReason return 200 if not found schedule reason and return empty object successfully.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + + mockReq.query = { + queryDate: mockDay(0), + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValueOnce(); + + await getSingleReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.query.queryDate, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith({ + reason: '', + date: '', + userId: '', + isSet: false, + }); + }); + test('Ensure getSingleReason return 200 if found schedule reason and return reason successfully.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + + mockReq.query = { + queryDate: mockDay(0), + }; + const singleReason = { + reason: 'Some Reason', + userId: mockReq.params.userId, + date: moment.tz('America/Los_Angeles').startOf('day').toISOString(), + isSet: true, + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValue(singleReason); + + await getSingleReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.query.queryDate, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith(singleReason); + }); + }); + describe('patchReason method', () => { + test('Ensure patchReason returns 400 for not providing reason', async () => { + mockReq.body.reasonData.message = null; + await patchReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'You must provide a reason.', + errorCode: 6, + }), + ); + }); + test('Ensure patchReason returns 404 when error in finding user Id', async () => { + const mockFindUser = jest.spyOn(UserModel, 'findById').mockImplementationOnce(() => null); + + await patchReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'User not found', + errorCode: 2, + }), + ); + }); + test('Ensure patchReason returns 404 when error in finding reason', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValueOnce(); + await patchReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Reason not found', + errorCode: 4, + }), + ); + }); + test('Ensure patchReason returns 400 when any error in saving.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const oldReason = { + reason: 'old message', + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + save: jest.fn().mockRejectedValueOnce(), + }; + emailSender.mockImplementation(() => { + throw new Error('Failed to send email'); + }); + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValueOnce(oldReason); + await patchReason(mockReq, mockRes); + await flushPromises(); + emailSender.mockRejectedValue(new Error('Failed')); + expect(mockRes.status).toHaveBeenCalledWith(400); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + }); + expect(oldReason.save).toHaveBeenCalledWith(); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'something went wrong while patching the reason', + }), + ); + }); + test('Ensure patchReason returns 200 when any error in saving.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const oldReason = { + reason: mockReq.body.reasonData.message, + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + save: jest.fn().mockResolvedValueOnce(), + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValueOnce(oldReason); + emailSender.mockImplementation(() => { + Promise.resolve(); + }); + await patchReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + }); + expect(oldReason.save).toHaveBeenCalledWith(); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Reason Updated!', + }), + ); + }); + }); + describe('deleteReason method', () => { + test('Ensure deleteReason return 403 when no permission to delete', async () => { + const newMockReq = { + ...mockReq, + body: { + ...mockReq.body, + ...mockReq.requestor, + requestor: { + role: 'Volunteer', + }, + }, + }; + await deleteReason(newMockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(403); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'You must be an Owner or Administrator to schedule a reason for a Blue Square', + + errorCode: 1, + }), + ); + }); + test('Ensure deleteReason return 404 when not finding user by ID', async () => { + const mockFindUser = jest.spyOn(UserModel, 'findById').mockImplementationOnce(() => null); + await deleteReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'User not found', + errorCode: 2, + }), + ); + }); + test('Ensure deleteReason returns 404 when error in finding reason', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockResolvedValueOnce(); + await deleteReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(404); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Reason not found', + errorCode: 4, + }), + ); + }); + test('Ensure deleteReason returns 500 when error in removing reason', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const foundReason = { + reason: mockReq.body.reasonData.message, + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + remove: jest.fn((cb) => cb(true)), + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockReturnValueOnce(foundReason); + + await deleteReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(500); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Error while deleting document', + errorCode: 5, + }), + ); + }); + test('Ensure deleteReason returns 200 if delete reason successfully.', async () => { + const mockFindUser = jest + .spyOn(UserModel, 'findById') + .mockImplementationOnce(() => mockUser()); + const foundReason = { + reason: mockReq.body.reasonData.message, + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + userId: mockReq.params.userId, + remove: jest.fn((cb) => cb(false)), + }; + const mockFoundReason = jest.spyOn(ReasonModel, 'findOne').mockReturnValueOnce(foundReason); + + await deleteReason(mockReq, mockRes); + await flushPromises(); + + expect(mockRes.status).toHaveBeenCalledWith(200); + expect(mockFindUser).toHaveBeenCalledWith(mockReq.params.userId); + expect(mockFoundReason).toHaveBeenCalledWith({ + date: moment + .tz(mockReq.body.reasonData.date, 'America/Los_Angeles') + .startOf('day') + .toISOString(), + }); + expect(mockRes.json).toHaveBeenCalledWith( + expect.objectContaining({ + message: 'Document deleted', + }), + ); + }); + }); +}); diff --git a/src/controllers/taskController.js b/src/controllers/taskController.js index 1e019ffa1..b4d71a5dd 100644 --- a/src/controllers/taskController.js +++ b/src/controllers/taskController.js @@ -683,7 +683,10 @@ const taskController = function (Task) { }; const updateTask = async (req, res) => { - if (!(await hasPermission(req.body.requestor, 'updateTask'))) { + if ( + !(await hasPermission(req.body.requestor, 'updateTask')) && + !(await hasPermission(req.body.requestor, 'removeUserFromTask')) + ) { res.status(403).send({ error: 'You are not authorized to update Task.' }); return; } diff --git a/src/controllers/taskController.spec.js b/src/controllers/taskController.spec.js new file mode 100644 index 000000000..7d1196df7 --- /dev/null +++ b/src/controllers/taskController.spec.js @@ -0,0 +1,1555 @@ +const mongoose = require('mongoose'); + +// Utility to aid in testing +jest.mock('../utilities/permissions', () => ({ + hasPermission: jest.fn(), +})); + +jest.mock('../utilities/emailSender', () => jest.fn()); + +const taskHelperMethods = { + getTasksForTeams: jest.fn(), + getTasksForSingleUser: jest.fn(), +}; +jest.mock('../helpers/taskHelper', () => () => ({ ...taskHelperMethods })); + +const flushPromises = () => new Promise(setImmediate); +const { mockReq, mockRes, assertResMock } = require('../test'); +const { hasPermission } = require('../utilities/permissions'); +const emailSender = require('../utilities/emailSender'); + +// controller to test +const taskController = require('./taskController'); + +// MongoDB Model imports +const Task = require('../models/task'); +const Project = require('../models/project'); +const UserProfile = require('../models/userProfile'); +const WBS = require('../models/wbs'); +const FollowUp = require('../models/followUp'); + +const makeSut = () => { + const { + getTasks, + getWBSId, + importTask, + postTask, + updateNum, + moveTask, + deleteTask, + deleteTaskByWBS, + updateTask, + swap, + getTaskById, + fixTasks, + updateAllParents, + getTasksByUserId, + sendReviewReq, + getTasksForTeamsByUser, + updateTaskStatus, + } = taskController(Task); + + return { + getTasks, + getWBSId, + importTask, + postTask, + updateNum, + moveTask, + deleteTask, + deleteTaskByWBS, + updateTask, + swap, + getTaskById, + fixTasks, + updateAllParents, + getTasksByUserId, + sendReviewReq, + getTasksForTeamsByUser, + updateTaskStatus, + }; +}; + +describe('Unit Tests for taskController.js', () => { + afterAll(() => { + jest.resetAllMocks(); + }); + + describe('getTasks function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Returns 200 on successfully querying the document', async () => { + const { getTasks } = makeSut(); + const mockData = 'some random data'; + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce(mockData); + + const response = await getTasks(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, mockData, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalledTimes(1); + }); + + test('Returns 200 on successfully querying the document', async () => { + const { getTasks } = makeSut(); + const error = 'some random error'; + + const taskFindSpy = jest.spyOn(Task, 'find').mockRejectedValueOnce(error); + + const response = await getTasks(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalledTimes(1); + }); + }); + + describe('getWBSId function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Returns 200 on successfully querying the document', async () => { + const { getWBSId } = makeSut(); + const mockData = 'some random data'; + + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValueOnce(mockData); + + const response = await getWBSId(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, mockData, response, mockRes); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalledTimes(1); + }); + + test('Returns 200 on successfully querying the document', async () => { + const { getWBSId } = makeSut(); + const error = 'some random error'; + + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockRejectedValueOnce(error); + + const response = await getWBSId(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalledTimes(1); + }); + }); + + describe('importTasks function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `importTask` permission is missing', async () => { + const { importTask } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to create new Task.' }; + + const response = await importTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 201 on successful import operation', async () => { + const { importTask } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.params.wbs = 'wbs123'; + mockReq.body.list = [ + { + _id: 'mongoDB-Id', + num: '1', + level: 1, + parentId1: null, + parentId2: null, + parentId3: null, + mother: null, + resources: ['parth|userId123|parthProfilePic', 'test|test123|testProfilePic'], + }, + ]; + + const saveMock = jest + .fn() + .mockImplementation(() => Promise.resolve({ _id: '1', wbsId: 'wbs123' })); + const TaskConstructorSpy = jest.spyOn(Task.prototype, 'save').mockImplementation(saveMock); + + const data = 'done'; + + const response = await importTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(201, data, response, mockRes); + expect(TaskConstructorSpy).toBeCalled(); + }); + + test('Return 400 on encountering any error while saving task', async () => { + const { importTask } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.params.wbs = 'wbs123'; + mockReq.body.list = [ + { + _id: 'mongoDB-Id', + num: '1', + level: 1, + parentId1: null, + parentId2: null, + parentId3: null, + mother: null, + resources: ['parth|userId123|parthProfilePic', 'test|test123|testProfilePic'], + }, + ]; + + const error = new Error('error while saving'); + + const saveMock = jest.fn().mockImplementation(() => Promise.reject(error)); + const TaskConstructorSpy = jest.spyOn(Task.prototype, 'save').mockImplementation(saveMock); + + const response = await importTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(TaskConstructorSpy).toBeCalled(); + }); + }); + + describe('postTask function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `postTask` permission is missing', async () => { + const { postTask } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to create new Task.' }; + + const response = await postTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test.each([ + [ + { taskName: undefined, isActive: true }, + 'Task Name, Active status, Task Number are mandatory fields', + ], + [ + { taskName: 'some task name', isActive: undefined }, + 'Task Name, Active status, Task Number are mandatory fields', + ], + [ + { taskName: undefined, isActive: undefined }, + 'Task Name, Active status, Task Number are mandatory fields', + ], + ])('Return 400 if any required field is missing', async (body, expectedError) => { + const { postTask } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + // Set the request body based on the current test case + mockReq.body.taskName = body.taskName; + mockReq.body.isActive = body.isActive; + + const error = { error: expectedError }; + + const response = await postTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 201 on successfully saving a new Task', async () => { + const { postTask } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + const newTask = { + taskName: 'Sample Task', + wbsId: new mongoose.Types.ObjectId(), + num: '1', + level: 1, + position: 1, + childrenQty: 0, + isActive: true, + }; + + // Mock the current datetime + const currentDate = Date.now(); + + // Mock Task model + const mockTask = { + save: jest.fn().mockResolvedValue({ + _id: new mongoose.Types.ObjectId(), + wbsId: new mongoose.Types.ObjectId(), + createdDatetime: currentDate, + modifiedDatetime: currentDate, + }), + }; + const taskSaveSpy = jest.spyOn(Task.prototype, 'save').mockResolvedValue(mockTask); + + // Mock WBS model + const mockWBS = { + _id: new mongoose.Types.ObjectId(), + projectId: 'projectId', + modifiedDatetime: Date.now(), + save: jest.fn().mockResolvedValue({ + _id: new mongoose.Types.ObjectId(), + projectId: 'projectId', + modifiedDatetime: Date.now(), + }), + }; + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockWBS); + + // Mock Project model + const mockProjectObj = { + save: jest.fn().mockResolvedValue({ + _id: new mongoose.Types.ObjectId(), + modifiedDatetime: currentDate, + }), + modifiedDatetime: currentDate, + }; + const projectFindByIdSpy = jest.spyOn(Project, 'findById').mockResolvedValue(mockProjectObj); + + // add the necessary request params + mockReq.params = { + ...mockReq.params, + id: new mongoose.Types.ObjectId(), + }; + + // add the necessary body parameters + mockReq.body = { + ...mockReq.body, + ...newTask, + }; + + const response = await postTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(201, expect.anything(), response, mockRes); + expect(taskSaveSpy).toBeCalled(); + expect(wbsFindByIdSpy).toBeCalled(); + expect(projectFindByIdSpy).toBeCalled(); + }); + + test('Return 400 on encountering any error during Promise.all', async () => { + const { postTask } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + const newTask = { + taskName: 'Sample Task', + wbsId: new mongoose.Types.ObjectId(), + num: '1', + level: 1, + position: 1, + childrenQty: 0, + isActive: true, + }; + + // Mock the current datetime + const currentDate = Date.now(); + + // Mock the Task model + const mockTaskError = new Error('Failed to save task'); + + // Use jest.fn() to mock the save method to reject with an error + const taskSaveMock = jest.fn().mockRejectedValue(mockTaskError); + + // Spy on the Task prototype's save method + const taskSaveSpy = jest.spyOn(Task.prototype, 'save').mockImplementation(taskSaveMock); + + // Mock WBS model + const mockWBS = { + _id: new mongoose.Types.ObjectId(), + projectId: 'projectId', + modifiedDatetime: Date.now(), + save: jest.fn().mockResolvedValue({ + _id: new mongoose.Types.ObjectId(), + projectId: 'projectId', + modifiedDatetime: Date.now(), + }), + }; + // Mock `WBS.findById` to return `mockWBS` + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockWBS); + + // Mock Project model + const mockProjectObj = { + save: jest.fn().mockResolvedValueOnce({ + _id: new mongoose.Types.ObjectId(), + modifiedDatetime: currentDate, + }), + modifiedDatetime: currentDate, + }; + const projectFindByIdSpy = jest + .spyOn(Project, 'findById') + .mockResolvedValueOnce(mockProjectObj); + + // add the necessary request params + mockReq.params = { + ...mockReq.params, + id: new mongoose.Types.ObjectId(), + }; + + // add the necessary body parameters + mockReq.body = { + ...mockReq.body, + ...newTask, + }; + + const response = await postTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, mockTaskError, response, mockRes); + expect(taskSaveSpy).toBeCalled(); + expect(wbsFindByIdSpy).toBeCalled(); + expect(projectFindByIdSpy).toBeCalled(); + }); + }); + + describe('updateNum function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `updateNum` permission is missing', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to create new projects.' }; + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 400 if `nums` is missing from the request body', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + const error = { error: 'Num is a mandatory fields' }; + mockReq.body.nums = null; + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 200 on successful update - nums is empty array', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.nums = []; + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, true, response, mockRes); + }); + + test('Return 200 on successful update - nums is not an empty array', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.nums = [ + { + id: 'sample-id', + num: 'sample-num', + }, + ]; + + const mockDataForTaskFindByIdSpy = { + num: 0, + save: jest.fn().mockResolvedValue({}), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + callback(null, mockDataForTaskFindByIdSpy); + }); + + const mockDataForTaskFindSpy = []; + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce(mockDataForTaskFindSpy); + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, true, response, mockRes); + expect(taskFindSpy).toBeCalled(); + expect(taskFindByIdSpy).toBeCalled(); + }); + + test('Return 404 if error occurs on Task.find()', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.nums = [ + { + id: 'sample-id', + num: 'sample-num', + }, + ]; + + const mockDataForTaskFindByIdSpy = { + num: 0, + save: jest.fn().mockResolvedValue({}), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + callback(null, mockDataForTaskFindByIdSpy); + }); + + const mockError = new Error({ error: 'some error occurred' }); + const taskFindSpy = jest.spyOn(Task, 'find').mockRejectedValueOnce(mockError); + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, mockError, response, mockRes); + expect(taskFindSpy).toBeCalled(); + expect(taskFindByIdSpy).toBeCalled(); + }); + + test('Return 400 if error occurs while saving a Task within Task.findById()', async () => { + const { updateNum } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.nums = [ + { + id: 'sample-id', + num: 'sample-num', + }, + ]; + + const mockError = new Error({ error: 'some error occurred' }); + + const mockDataForTaskFindByIdSpy = { + num: 0, + save: jest.fn().mockRejectedValueOnce(mockError), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + callback(null, mockDataForTaskFindByIdSpy); + }); + + const mockDataForTaskFindSpy = []; + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce(mockDataForTaskFindSpy); + + const response = await updateNum(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, mockError, response, mockRes); + expect(taskFindSpy).toBeCalled(); + expect(taskFindByIdSpy).toBeCalled(); + }); + }); + + describe('moveTask function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 400 if either `fromNum` or `toNum` is missing in request body', async () => { + const { moveTask } = makeSut(); + + const error = { error: 'wbsId, fromNum, toNum are mandatory fields' }; + mockReq.body.fromNum = null; + + const response = await moveTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 200 on successful exeecution', async () => { + const { moveTask } = makeSut(); + + const requestData = { + body: { + fromNum: '1.0', + toNum: '2.0', + }, + }; + + mockReq.body = { + ...mockReq.body, + ...requestData.body, + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValue([ + { num: '1.0', save: jest.fn().mockResolvedValue({}) }, + { num: '1.1', save: jest.fn().mockResolvedValue({}) }, + ]); + + mockReq.params.wbsId = 'someWbsId'; + + const response = await moveTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, 'Success!', response, mockRes); + expect(taskFindSpy).toBeCalled(); + }); + + test('Return 400 on some error', async () => { + const { moveTask } = makeSut(); + + const requestData = { + body: { + fromNum: '1.0', + toNum: '2.0', + }, + }; + + mockReq.body = { + ...mockReq.body, + ...requestData.body, + }; + + const error = new Error({ error: 'some error' }); + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValue([ + { num: '1.0', save: jest.fn().mockResolvedValue({}) }, + { num: '1.1', save: jest.fn().mockRejectedValueOnce(error) }, + ]); + + mockReq.params.wbsId = 'someWbsId'; + + const response = await moveTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindSpy).toBeCalled(); + }); + }); + + describe('deleteTask function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `deleteTask` permission is missing', async () => { + const { deleteTask } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to deleteTasks.' }; + + const response = await deleteTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 400 if no Task found', async () => { + const { deleteTask } = makeSut(); + + const error = { error: 'No valid records found' }; + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + mother: 'null', + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValue([]); + const followUpFindOneAndDeleteSpy = jest + .spyOn(FollowUp, 'findOneAndDelete') + .mockResolvedValue(true); + + const response = await deleteTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + expect(followUpFindOneAndDeleteSpy).toHaveBeenCalled(); + }); + + test('Return 200 on successfully deleting task', async () => { + const { deleteTask } = makeSut(); + + const message = { message: 'Task successfully deleted' }; + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + mother: 'null', + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValue([ + { + remove: jest.fn().mockImplementation(() => Promise.resolve(1)), + }, + ]); + const followUpFindOneAndDeleteSpy = jest + .spyOn(FollowUp, 'findOneAndDelete') + .mockResolvedValue(true); + + const response = await deleteTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, message, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + expect(followUpFindOneAndDeleteSpy).toHaveBeenCalled(); + }); + }); + + describe('deleteTaskByWBS function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `deleteTask` permission is missing', async () => { + const { deleteTaskByWBS } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to deleteTasks.' }; + + const response = await deleteTaskByWBS(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 400 if no Task found', async () => { + const { deleteTaskByWBS } = makeSut(); + + const error = { error: 'No valid records found' }; + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + wbsId: 456, + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockImplementation((query, callback) => { + callback(null, []); + return { + catch: jest.fn(), + }; + }); + + const response = await deleteTaskByWBS(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + }); + + test('Return 400 if Task.find fails', async () => { + const { deleteTaskByWBS } = makeSut(); + + const expectedError = new Error('Database error'); + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + wbsId: 456, + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockImplementation((query, callback) => { + callback(expectedError, null); + return { + catch: jest.fn((catchCallback) => { + catchCallback(expectedError); + return Promise.resolve(); + }), + }; + }); + + const response = await deleteTaskByWBS(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, expectedError, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + }); + + test('Return 200 on successfully deleting task', async () => { + const { deleteTaskByWBS } = makeSut(); + + const message = { message: ' Tasks were successfully deleted' }; + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + wbsId: 456, + }; + + const taskFindSpy = jest.spyOn(Task, 'find').mockImplementation((query, callback) => { + callback(null, [ + { + remove: jest.fn().mockImplementation(() => Promise.resolve(1)), + }, + ]); + return { + catch: jest.fn(), + }; + }); + + const followUpFindOneAndDeleteSpy = jest + .spyOn(FollowUp, 'findOneAndDelete') + .mockResolvedValue(true); + + const response = await deleteTaskByWBS(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, message, response, mockRes); + expect(taskFindSpy).toHaveBeenCalled(); + expect(followUpFindOneAndDeleteSpy).toHaveBeenCalled(); + }); + }); + + describe('updateTask function()', () => { + const mockedTask = { + wbs: 111, + }; + const mockedWBS = { + projectId: 111, + modifiedDatetime: new Date(), + save: jest.fn(), + }; + const mockedProject = { + projectId: 111, + modifiedDatetime: new Date(), + save: jest.fn(), + }; + + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `updateTask` permission is missing', async () => { + const { updateTask } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to update Task.' }; + + const response = await updateTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 200 on successful update', async () => { + const { updateTask } = makeSut(); + + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValue(mockedTask); + const taskFindOneAndUpdateSpy = jest + .spyOn(Task, 'findOneAndUpdate') + .mockResolvedValueOnce(true); + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockedWBS); + const projectFindByIdSpy = jest.spyOn(Project, 'findById').mockResolvedValue(mockedProject); + + const response = await updateTask(mockReq, mockRes); + await flushPromises(); + + // assertResMock(201, null, response, mockRes); + expect(mockRes.status).toBeCalledWith(201); + expect(response).toBeUndefined(); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindOneAndUpdateSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(projectFindByIdSpy).toHaveBeenCalled(); + }); + + test('Return 404 on encountering error', async () => { + const { updateTask } = makeSut(); + + const error = { error: 'No valid records found' }; + hasPermission.mockResolvedValueOnce(true); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValue(mockedTask); + const taskFindOneAndUpdateSpy = jest + .spyOn(Task, 'findOneAndUpdate') + .mockRejectedValueOnce(error); + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockedWBS); + const projectFindByIdSpy = jest.spyOn(Project, 'findById').mockResolvedValue(mockedProject); + + const response = await updateTask(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindOneAndUpdateSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(projectFindByIdSpy).toHaveBeenCalled(); + }); + }); + + describe('swap function()', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Return 403 if `swapTask` permission is missing', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(false); + + const error = { error: 'You are not authorized to create new projects.' }; + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(403, error, response, mockRes); + }); + + test('Return 400 if `taskId1` is missing', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = null; + mockReq.body.taskId2 = 'some-value'; + + const error = { error: 'taskId1 and taskId2 are mandatory fields' }; + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 400 if `taskId2` is missing', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'some-value'; + mockReq.body.taskId2 = null; + + const error = { error: 'taskId1 and taskId2 are mandatory fields' }; + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 400 if `taskId1` and `taskId2` are missing', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = null; + mockReq.body.taskId2 = null; + + const error = { error: 'taskId1 and taskId2 are mandatory fields' }; + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Return 400 if no task exists with the id same as `taskId1`', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'invalid-taskId1'; + mockReq.body.taskId2 = 'some value'; + + const error = 'No valid records found'; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'invalid-taskId1') { + callback(null, null); // the first null shows no error | second null show no task1 + } else if (id === 'invalid-taskId2') { + callback(null, 'some task2 exists'); + } + }); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + }); + + test('Return 400 if no task exists with the id same as `taskId2`', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'valid-taskId1'; + mockReq.body.taskId2 = 'invalid-taskId2'; + + const error = 'No valid records found'; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'valid-taskId1') { + callback(null, { _id: 'valid-taskId1', name: 'Task 1' }); + } + + if (id === 'invalid-taskId2') { + callback(null, null); // the first null shows no error | second null show no task2 found + } + }); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalledTimes(2); + expect(taskFindByIdSpy).toHaveBeenNthCalledWith(1, 'valid-taskId1', expect.any(Function)); + expect(taskFindByIdSpy).toHaveBeenNthCalledWith(2, 'invalid-taskId2', expect.any(Function)); + }); + + test('Return 400 if some error occurs while saving task1', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'valid-taskId1'; + mockReq.body.taskId2 = 'valid-taskId2'; + + const error = 'some error'; + + const validTask1 = { + _id: 'valid-taskId1', + name: 'Task 1', + num: 1, + parentId: 'pId', + save: jest.fn().mockRejectedValue(error), + }; + + const validTask2 = { + _id: 'valid-taskId2', + name: 'Task 2', + num: 2, + parentId: 'pId', + save: jest.fn().mockResolvedValue('sadasd'), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'valid-taskId1') { + callback(null, validTask1); + } + if (id === 'valid-taskId2') { + callback(null, validTask2); + } + }); + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce('works fine'); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalled(); + }); + + test('Return 400 if some error occurs while saving task2', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'valid-taskId1'; + mockReq.body.taskId2 = 'valid-taskId2'; + + const error = 'some error'; + + const validTask1 = { + _id: 'valid-taskId1', + name: 'Task 1', + num: 1, + parentId: 'pId', + save: jest.fn().mockResolvedValue(), + }; + + const validTask2 = { + _id: 'valid-taskId2', + name: 'Task 2', + num: 2, + parentId: 'pId', + save: jest.fn().mockRejectedValue(error), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'valid-taskId1') { + callback(null, validTask1); + } + if (id === 'valid-taskId2') { + callback(null, validTask2); + } + }); + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce('works fine'); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalled(); + }); + + test('Return 404 if some error occurs while saving task.find', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'valid-taskId1'; + mockReq.body.taskId2 = 'valid-taskId2'; + + const error = 'some error'; + + const validTask1 = { + _id: 'valid-taskId1', + name: 'Task 1', + num: 1, + parentId: 'pId', + save: jest.fn().mockResolvedValue(), + }; + + const validTask2 = { + _id: 'valid-taskId2', + name: 'Task 2', + num: 2, + parentId: 'pId', + save: jest.fn().mockResolvedValue(), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'valid-taskId1') { + callback(null, validTask1); + } + if (id === 'valid-taskId2') { + callback(null, validTask2); + } + }); + + const taskFindSpy = jest.spyOn(Task, 'find').mockRejectedValueOnce(error); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalled(); + }); + + test('Return 200 if swapped correctly', async () => { + const { swap } = makeSut(); + hasPermission.mockResolvedValueOnce(true); + + mockReq.body.taskId1 = 'valid-taskId1'; + mockReq.body.taskId2 = 'valid-taskId2'; + + const message = 'no error'; + + const validTask1 = { + _id: 'valid-taskId1', + name: 'Task 1', + num: 1, + parentId: 'pId', + save: jest.fn().mockResolvedValue(), + }; + + const validTask2 = { + _id: 'valid-taskId2', + name: 'Task 2', + num: 2, + parentId: 'pId', + save: jest.fn().mockResolvedValue(), + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockImplementation((id, callback) => { + if (id === 'valid-taskId1') { + callback(null, validTask1); + } + if (id === 'valid-taskId2') { + callback(null, validTask2); + } + }); + + const taskFindSpy = jest.spyOn(Task, 'find').mockResolvedValueOnce(message); + + const response = await swap(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, message, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindSpy).toHaveBeenCalled(); + }); + }); + + describe('getTaskById function()', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + test('Returns 400 if the taskId is missing from the params', async () => { + const { getTaskById } = makeSut(); + + mockReq.params.id = null; + + const error = { error: 'Task ID is missing' }; + + const response = await getTaskById(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + }); + + test('Returns 400 if the taskId is missing from the params', async () => { + const { getTaskById } = makeSut(); + + mockReq.params.id = 'someTaskId'; + + const error = { error: 'This is not a valid task' }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValueOnce(null); + + const response = await getTaskById(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + }); + + test('Returns 500 if some error occurs at Task.findById', async () => { + const { getTaskById } = makeSut(); + + mockReq.params.id = 'someTaskId'; + + const error = new Error('some error occurred'); + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockRejectedValueOnce(error); + + const response = await getTaskById(mockReq, mockRes); + await flushPromises(); + + assertResMock( + 500, + { error: 'Internal Server Error', details: error.message }, + response, + mockRes, + ); + expect(taskFindByIdSpy).toHaveBeenCalled(); + }); + + test('Returns 200 if some error occurs at Task.findById', async () => { + const { getTaskById } = makeSut(); + + mockReq.params.id = 'someTaskId'; + + const mockTask = { + resources: [], + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValueOnce(mockTask); + + const response = await getTaskById(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, mockTask, response, mockRes); + expect(taskFindByIdSpy).toHaveBeenCalled(); + }); + }); + + describe('fixTasks function()', () => { + test('Returns 200 without performing any action', async () => { + const { fixTasks } = makeSut(); + + const response = fixTasks(mockReq, mockRes); + + await flushPromises(); + + assertResMock(200, 'done', response, mockRes); + }); + }); + + describe('updateAllParents function()', () => { + test('Returns 200 Task.Find() on successful operation', async () => { + const { updateAllParents } = makeSut(); + + const mockTasks = []; + + const taskFind = jest.spyOn(Task, 'find').mockResolvedValueOnce(mockTasks); + const response = updateAllParents(mockReq, mockRes); + + await flushPromises(); + + assertResMock(200, 'done', response, mockRes); + expect(taskFind).toHaveBeenCalled(); + }); + + test('Returns 400 on some error', async () => { + const { updateAllParents } = makeSut(); + + const error = new Error('some error'); + + const taskFind = jest.spyOn(Task, 'find').mockImplementationOnce(() => { + throw error; + }); + const response = await updateAllParents(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, error, response, mockRes); + expect(taskFind).toHaveBeenCalled(); + }); + }); + + describe('getTasksByUserId function()', () => { + test('Returns 200 and tasks when aggregation is successful', async () => { + const { getTasksByUserId } = makeSut(); + + mockReq.params.userId = '507f1f77bcf86cd799439011'; + + const mockTasks = [ + { _id: 'task1', taskName: 'Task 1', wbsName: 'WBS 1', projectName: 'Project 1' }, + { _id: 'task2', taskName: 'Task 2', wbsName: 'WBS 2', projectName: 'Project 2' }, + ]; + + // Mock the Task.aggregate method + const mockAggregate = { + match: jest.fn().mockReturnThis(), + lookup: jest.fn().mockReturnThis(), + unwind: jest.fn().mockReturnThis(), + addFields: jest.fn().mockReturnThis(), + project: jest.fn().mockReturnThis(), + }; + + mockAggregate.project.mockResolvedValue(mockTasks); + + const taskAggregate = jest.spyOn(Task, 'aggregate').mockReturnValue(mockAggregate); + + const response = await getTasksByUserId(mockReq, mockRes); + + assertResMock(200, mockTasks, response, mockRes); + expect(taskAggregate).toHaveBeenCalled(); + }); + + test('Returns 400 when error occurs', async () => { + const { getTasksByUserId } = makeSut(); + + mockReq.params.userId = '507f1f77bcf86cd799439011'; + + const mockError = new Error('some error'); + + // Mock the Task.aggregate method + const mockAggregate = { + match: jest.fn().mockReturnThis(), + lookup: jest.fn().mockReturnThis(), + unwind: jest.fn().mockReturnThis(), + addFields: jest.fn().mockReturnThis(), + project: jest.fn().mockReturnThis(), + }; + + mockAggregate.project.mockRejectedValueOnce(mockError); + + const taskAggregate = jest.spyOn(Task, 'aggregate').mockReturnValue(mockAggregate); + + const response = await getTasksByUserId(mockReq, mockRes); + + assertResMock(400, mockError, response, mockRes); + expect(taskAggregate).toHaveBeenCalled(); + }); + }); + + describe('sendReviewReq function()', () => { + test('Returns 200 on success', async () => { + const { sendReviewReq } = makeSut(); + + mockReq.body = { + ...mockReq.body, + myUserId: 'id', + name: 'name', + taskName: 'task', + }; + + const userProfileFindByIdSpy = jest.spyOn(UserProfile, 'findById').mockResolvedValueOnce([]); + const userProfileFindSpy = jest.spyOn(UserProfile, 'find').mockResolvedValueOnce([]); + + const response = await sendReviewReq(mockReq, mockRes); + + assertResMock(200, 'Success', response, mockRes); + expect(emailSender).toHaveBeenCalledWith( + [], + expect.any(String), + expect.any(String), + null, + null, + ); + expect(userProfileFindByIdSpy).toHaveBeenCalled(); + expect(userProfileFindSpy).toHaveBeenCalled(); + }); + + test('Returns 400 on error', async () => { + const { sendReviewReq } = makeSut(); + + mockReq.body = { + ...mockReq.body, + myUserId: 'id', + name: 'name', + taskName: 'task', + }; + + const mockError = new Error('some error'); + + emailSender.mockImplementation(() => mockError); + + const userProfileFindByIdSpy = jest.spyOn(UserProfile, 'findById').mockResolvedValueOnce([]); + const userProfileFindSpy = jest.spyOn(UserProfile, 'find').mockResolvedValueOnce([]); + + const response = await sendReviewReq(mockReq, mockRes); + + assertResMock(400, mockError, response, mockRes); + + expect(emailSender).toHaveBeenCalledWith( + [], + expect.any(String), + expect.any(String), + null, + null, + ); + expect(userProfileFindByIdSpy).toHaveBeenCalled(); + expect(userProfileFindSpy).toHaveBeenCalled(); + }); + }); + + describe('getTasksForTeamsByUser function()', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + test('Returns 200 on success - getTasksForTeams', async () => { + mockReq.params.userId = 1234; + const mockData = ['mockData']; + + taskHelperMethods.getTasksForTeams.mockResolvedValueOnce(mockData); + + const { getTasksForTeamsByUser } = makeSut(); + + const response = await getTasksForTeamsByUser(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, mockData, response, mockRes); + }); + + test('Returns 200 on success - getTasksForTeamsByUser', async () => { + mockReq.params.userId = 1234; + const mockData = ['mockData']; + + const execMock = { + exec: jest.fn().mockResolvedValueOnce(mockData), + }; + + taskHelperMethods.getTasksForTeams.mockResolvedValueOnce([]); + taskHelperMethods.getTasksForSingleUser.mockImplementation(() => execMock); + + const { getTasksForTeamsByUser } = makeSut(); + + const response = await getTasksForTeamsByUser(mockReq, mockRes); + await flushPromises(); + + assertResMock(200, mockData, response, mockRes); + }); + + test('Returns 400 on error', async () => { + mockReq.params.userId = 1234; + const mockError = new Error('error'); + + taskHelperMethods.getTasksForTeams.mockRejectedValueOnce(mockError); + + const { getTasksForTeamsByUser } = makeSut(); + + const response = await getTasksForTeamsByUser(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, { error: mockError }, response, mockRes); + }); + }); + + describe('updateTaskStatus function()', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + const mockedTask = { + wbs: 111, + }; + const mockedWBS = { + projectId: 111, + modifiedDatetime: new Date(), + save: jest.fn(), + }; + const mockedProject = { + projectId: 111, + modifiedDatetime: new Date(), + save: jest.fn(), + }; + + test('Returns 200 on success - updateTaskStatus', async () => { + const { updateTaskStatus } = makeSut(); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValue(mockedTask); + const taskFindOneAndUpdateSpy = jest + .spyOn(Task, 'findOneAndUpdate') + .mockResolvedValueOnce(true); + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockedWBS); + const projectFindByIdSpy = jest.spyOn(Project, 'findById').mockResolvedValue(mockedProject); + + const response = await updateTaskStatus(mockReq, mockRes); + await flushPromises(); + + // assertResMock(201, null, response, mockRes); + expect(mockRes.status).toBeCalledWith(201); + expect(response).toBeUndefined(); + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindOneAndUpdateSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(projectFindByIdSpy).toHaveBeenCalled(); + }); + + test('Returns 400 on error', async () => { + const { updateTaskStatus } = makeSut(); + const error = new Error('some error'); + + mockReq.params = { + ...mockReq.params, + taskId: 456, + }; + + const taskFindByIdSpy = jest.spyOn(Task, 'findById').mockResolvedValue(mockedTask); + const taskFindOneAndUpdateSpy = jest + .spyOn(Task, 'findOneAndUpdate') + .mockRejectedValueOnce(error); + const wbsFindByIdSpy = jest.spyOn(WBS, 'findById').mockResolvedValue(mockedWBS); + const projectFindByIdSpy = jest.spyOn(Project, 'findById').mockResolvedValue(mockedProject); + + const response = await updateTaskStatus(mockReq, mockRes); + await flushPromises(); + + assertResMock(404, error, response, mockRes); + + expect(taskFindByIdSpy).toHaveBeenCalled(); + expect(taskFindOneAndUpdateSpy).toHaveBeenCalled(); + expect(wbsFindByIdSpy).toHaveBeenCalled(); + expect(projectFindByIdSpy).toHaveBeenCalled(); + }); + }); +}); diff --git a/src/controllers/teamController.js b/src/controllers/teamController.js index 41f515e99..42d9d8d25 100644 --- a/src/controllers/teamController.js +++ b/src/controllers/teamController.js @@ -6,8 +6,66 @@ const Logger = require('../startup/logger'); const teamcontroller = function (Team) { const getAllTeams = function (req, res) { - Team.find({}) - .sort({ teamName: 1 }) + Team.aggregate([ + { + $unwind: '$members', + }, + { + $lookup: { + from: 'userProfiles', + localField: 'members.userId', + foreignField: '_id', + as: 'userProfile', + }, + }, + { + $unwind: '$userProfile', + }, + { + $match: { + isActive: true, + } + }, + { + $group: { + _id: { + teamId: '$_id', + teamCode: '$userProfile.teamCode', + }, + count: { $sum: 1 }, + teamName: { $first: '$teamName' }, + members: { + $push: { + _id: '$userProfile._id', + name: '$userProfile.name', + email: '$userProfile.email', + teamCode: '$userProfile.teamCode', + addDateTime: '$members.addDateTime', + }, + }, + createdDatetime: { $first: '$createdDatetime' }, + modifiedDatetime: { $first: '$modifiedDatetime' }, + isActive: { $first: '$isActive' }, + }, + }, + { + $sort: { count: -1 }, // Sort by the most frequent teamCode + }, + { + $group: { + _id: '$_id.teamId', + teamCode: { $first: '$_id.teamCode' }, // Get the most frequent teamCode + teamName: { $first: '$teamName' }, + members: { $first: '$members' }, + createdDatetime: { $first: '$createdDatetime' }, + modifiedDatetime: { $first: '$modifiedDatetime' }, + isActive: { $first: '$isActive' }, + }, + }, + { + $sort: { teamName: 1 }, // Sort teams by name + }, + ]) .then((results) => res.status(200).send(results)) .catch((error) => { Logger.logException(error); @@ -110,14 +168,15 @@ const teamcontroller = function (Team) { return; } - const canEditTeamCode = - req.body.requestor.role === 'Owner' || - req.body.requestor.permissions?.frontPermissions.includes('editTeamCode'); + // Removed the permission check as the permission check if done in earlier + // const canEditTeamCode = + // req.body.requestor.role === 'Owner' || + // req.body.requestor.permissions?.frontPermissions.includes('editTeamCode'); - if (!canEditTeamCode) { - res.status(403).send('You are not authorized to edit team code.'); - return; - } + // if (!canEditTeamCode) { + // res.status(403).send('You are not authorized to edit team code.'); + // return; + // } record.teamName = req.body.teamName; record.isActive = req.body.isActive; @@ -222,59 +281,62 @@ const teamcontroller = function (Team) { }, }, ]) - .then((result) => res.status(200).send(result)) + .then((result) => { + res.status(200).send(result) + }) .catch((error) => { Logger.logException(error, null, `TeamId: ${teamId} Request:${req.body}`); - res.status(500).send(error); + return res.status(500).send(error); }); }; const updateTeamVisibility = async (req, res) => { - console.log("==============> 9 "); + console.log('==============> 9 '); const { visibility, teamId, userId } = req.body; - + try { Team.findById(teamId, (error, team) => { if (error || team === null) { res.status(400).send('No valid records found'); return; } - - const memberIndex = team.members.findIndex(member => member.userId.toString() === userId); + + const memberIndex = team.members.findIndex((member) => member.userId.toString() === userId); if (memberIndex === -1) { res.status(400).send('Member not found in the team.'); return; } - + team.members[memberIndex].visible = visibility; team.modifiedDatetime = Date.now(); - - team.save() - .then(updatedTeam => { - // Additional operations after team.save() + + team + .save() + .then((updatedTeam) => { + // Additional operations after team.save() const assignlist = []; const unassignlist = []; - team.members.forEach(member => { + team.members.forEach((member) => { if (member.userId.toString() === userId) { // Current user, no need to process further return; } - + if (visibility) { assignlist.push(member.userId); } else { - console.log("Visiblity set to false so removing it"); + console.log('Visiblity set to false so removing it'); unassignlist.push(member.userId); } }); - + const addTeamToUserProfile = userProfile .updateMany({ _id: { $in: assignlist } }, { $addToSet: { teams: teamId } }) .exec(); const removeTeamFromUserProfile = userProfile .updateMany({ _id: { $in: unassignlist } }, { $pull: { teams: teamId } }) .exec(); - + Promise.all([addTeamToUserProfile, removeTeamFromUserProfile]) .then(() => { res.status(200).send({ result: 'Done' }); @@ -283,18 +345,17 @@ const teamcontroller = function (Team) { res.status(500).send({ error }); }); }) - .catch(errors => { + .catch((errors) => { console.error('Error saving team:', errors); res.status(400).send(errors); }); - }); } catch (error) { - res.status(500).send(`Error updating team visibility: ${ error.message}`); + res.status(500).send(`Error updating team visibility: ${error.message}`); } }; - /** + /** * Leaner version of the teamcontroller.getAllTeams * Remove redundant data: members, isActive, createdDatetime, modifiedDatetime. */ @@ -308,7 +369,48 @@ const teamcontroller = function (Team) { res.status(500).send('Fetch team code failed.'); }); }; - + + const getAllTeamMembers = async function (req,res) { + try{ + const teamIds = req.body; + const cacheKey='teamMembersCache' + if(cache.hasCache(cacheKey)){ + let data=cache.getCache('teamMembersCache') + return res.status(200).send(data); + } + if (!Array.isArray(teamIds) || teamIds.length === 0 || !teamIds.every(team => mongoose.Types.ObjectId.isValid(team._id))) { + return res.status(400).send({ error: 'Invalid request: teamIds must be a non-empty array of valid ObjectId strings.' }); + } + let data = await Team.aggregate([ + { + $match: { _id: { $in: teamIds.map(team => mongoose.Types.ObjectId(team._id)) } } + }, + { $unwind: '$members' }, + { + $lookup: { + from: 'userProfiles', + localField: 'members.userId', + foreignField: '_id', + as: 'userProfile', + }, + }, + { $unwind: { path: '$userProfile', preserveNullAndEmptyArrays: true } }, + { + $group: { + _id: '$_id', // Group by team ID + teamName: { $first: '$teamName' }, // Use $first to keep the team name + createdDatetime: { $first: '$createdDatetime' }, + members: { $push: '$members' }, // Rebuild the members array + }, + }, + ]) + cache.setCache(cacheKey,data) + res.status(200).send(data); + }catch(error){ + console.log(error) + res.status(500).send({'message':"Fetching team members failed"}); + } + } return { getAllTeams, getAllTeamCode, @@ -319,6 +421,7 @@ const teamcontroller = function (Team) { assignTeamToUsers, getTeamMembership, updateTeamVisibility, + getAllTeamMembers }; }; diff --git a/src/controllers/timeZoneAPIController.js b/src/controllers/timeZoneAPIController.js index 07c9c0b17..2023f312a 100644 --- a/src/controllers/timeZoneAPIController.js +++ b/src/controllers/timeZoneAPIController.js @@ -1,11 +1,11 @@ // eslint-disable-next-line import/no-extraneous-dependencies const fetch = require('node-fetch'); +const dotenv = require('dotenv'); + +dotenv.config(); const ProfileInitialSetupToken = require('../models/profileInitialSetupToken'); const { hasPermission } = require('../utilities/permissions'); -const premiumKey = process.env.TIMEZONE_PREMIUM_KEY; -const commonKey = process.env.TIMEZONE_COMMON_KEY; - const performTimeZoneRequest = async (req, res, apiKey) => { const { location } = req.params; @@ -17,7 +17,6 @@ const performTimeZoneRequest = async (req, res, apiKey) => { try { const geocodeAPIEndpoint = 'https://api.opencagedata.com/geocode/v1/json'; const url = `${geocodeAPIEndpoint}?key=${apiKey}&q=${location}&pretty=1&limit=1`; - const response = await fetch(url); const data = await response.json(); @@ -53,16 +52,17 @@ const performTimeZoneRequest = async (req, res, apiKey) => { const timeZoneAPIController = function () { const getTimeZone = async (req, res) => { + const premiumKey = process.env.TIMEZONE_PREMIUM_KEY; + const commonKey = process.env.TIMEZONE_COMMON_KEY; const { requestor } = req.body; - if (!requestor.role) { res.status(403).send('Unauthorized Request'); return; } - const userAPIKey = (await hasPermission(requestor, 'getTimeZoneAPIKey')) ? premiumKey : commonKey; + if (!userAPIKey) { res.status(401).send('API Key Missing'); return; @@ -72,6 +72,7 @@ const timeZoneAPIController = function () { }; const getTimeZoneProfileInitialSetup = async (req, res) => { + const commonKey = process.env.TIMEZONE_COMMON_KEY; const { token } = req.body; if (!token) { res.status(400).send('Missing token'); diff --git a/src/controllers/timeZoneAPIController.spec.js b/src/controllers/timeZoneAPIController.spec.js new file mode 100644 index 000000000..2f3607cc6 --- /dev/null +++ b/src/controllers/timeZoneAPIController.spec.js @@ -0,0 +1,316 @@ +jest.mock('../utilities/permissions', () => ({ + hasPermission: jest.fn(), // Mocking the hasPermission function +})); + +jest.mock('node-fetch'); +// eslint-disable-next-line import/no-extraneous-dependencies +const fetch = require('node-fetch'); + +const originalPremiumKey = process.env.TIMEZONE_PREMIUM_KEY; +process.env.TIMEZONE_PREMIUM_KEY = 'mockPremiumKey'; + +const originalCommonKey = process.env.TIMEZONE_COMMON_KEY; +delete process.env.TIMEZONE_COMMON_KEY; + +const successfulFetchRequestWithResults = jest.fn(() => + Promise.resolve({ + json: () => + Promise.resolve({ + status: { + code: 200, + message: 'Request Processed Successfully', + }, + results: [ + { + annotations: { + timezone: { + name: 'timeZone - Fiji', + }, + }, + geometry: { + lat: 1, + lng: 1, + }, + components: { + country: 'U.S.', + city: 'Paris', + }, + }, + ], + }), + }), +); + +const successfulFetchRequestWithNoResults = jest.fn(() => + Promise.resolve({ + json: () => + Promise.resolve({ + status: { + code: 200, + message: 'Request Processed Successfully', + }, + results: [], + }), + }), +); + +const unsuccessfulFetchRequestInternalServerError = jest.fn(() => + Promise.resolve({ + json: () => + Promise.resolve({ + status: { + code: null, + message: 'Internal Server Error', + }, + results: [], + }), + }), +); + +const { hasPermission } = require('../utilities/permissions'); +const timeZoneAPIController = require('./timeZoneAPIController'); +const ProfileInitialSetupToken = require('../models/profileInitialSetupToken'); +const { mockReq, mockRes, assertResMock } = require('../test'); + +const flushPromises = () => new Promise(setImmediate); +const makeSut = () => { + const { getTimeZone, getTimeZoneProfileInitialSetup } = timeZoneAPIController(); + return { getTimeZone, getTimeZoneProfileInitialSetup }; +}; + +describe('timeZoneAPIController Unit Tests', () => { + afterAll(() => { + // Reseting TIMEZONE_PREMIUM_KEY and TIMEZONE_COMMON_KEY environment variables to their original values + if (originalPremiumKey) { + process.env.TIMEZONE_PREMIUM_KEY = originalPremiumKey; + } else { + delete process.env.TIMEZONE_PREMIUM_KEY; + } + + if (originalCommonKey) { + process.env.TIMEZONE_COMMON_KEY = originalCommonKey; + } else { + delete process.env.TIMEZONE_COMMON_KEY; + } + }); + + describe('getTimeZone() function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + beforeEach(() => { + hasPermission.mockResolvedValue(true); + }); + test('Returns 403, as requestor.role is missing in request body', async () => { + const { getTimeZone } = makeSut(); + + // setting request.role to `Null` + mockReq.body.requestor.role = null; + + const response = await getTimeZone(mockReq, mockRes); + + assertResMock(403, 'Unauthorized Request', response, mockRes); + }); + + test('Returns 401, as API is missing', async () => { + delete process.env.TIMEZONE_COMMON_KEY; + + const { getTimeZone } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + + hasPermission.mockResolvedValue(false); + + const response = await getTimeZone(mockReq, mockRes); + await flushPromises(); + + expect(hasPermission).toBeCalledTimes(1); + assertResMock(401, 'API Key Missing', response, mockRes); + }); + + test('Returns 400, when `location` is missing in req.params', async () => { + const { getTimeZone } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + + const response = await getTimeZone(mockReq, mockRes); + await flushPromises(); + + expect(hasPermission).toBeCalledTimes(1); + assertResMock(400, 'Missing location', response, mockRes); + }); + + test('Returns 500, when status.code !== 200 and status code is missing', async () => { + const { getTimeZone } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + fetch.mockImplementation(unsuccessfulFetchRequestInternalServerError); + + const response = await getTimeZone(mockReq, mockRes); + await flushPromises(); + + expect(fetch).toHaveBeenCalledTimes(1); + expect(hasPermission).toBeCalledTimes(1); + assertResMock(500, 'opencage error- Internal Server Error', response, mockRes); + }); + + test('Returns 404, when status.code == 200 and data.results is empty', async () => { + const { getTimeZone } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + fetch.mockImplementation(successfulFetchRequestWithNoResults); + + const response = await getTimeZone(mockReq, mockRes); + await flushPromises(); + + expect(fetch).toHaveBeenCalledTimes(1); + expect(hasPermission).toBeCalledTimes(1); + assertResMock(404, 'No results found', response, mockRes); + }); + + test('Returns 200, when status.code == 200 and data.results is not empty', async () => { + const { getTimeZone } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + fetch.mockImplementation(successfulFetchRequestWithResults); + const timezone = 'timeZone - Fiji'; // mocking the timezone data to be returned by `successfulFetchRequestWithResults` + const currentLocation = { + // mocking the currentLocation data to be returned by `successfulFetchRequestWithResults` + userProvided: mockReq.params.location, + coords: { + lat: 1, + lng: 1, + }, + country: 'U.S.', + city: 'Paris', + }; + + const response = await getTimeZone(mockReq, mockRes); + await flushPromises(); + + expect(fetch).toHaveBeenCalledTimes(1); + expect(hasPermission).toBeCalledTimes(1); + assertResMock(200, { timezone, currentLocation }, response, mockRes); + }); + }); + + describe('getTimeZoneProfileInitialSetup() function', () => { + afterEach(() => { + jest.clearAllMocks(); + }); + + beforeEach(() => { + hasPermission.mockResolvedValue(true); + }); + + test('Returns status code 400 if token is missing in request.body', async () => { + mockReq.body.token = null; + + const { getTimeZoneProfileInitialSetup } = makeSut(); + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + assertResMock(400, 'Missing token', response, mockRes); + }); + + test('Returns status code 403 if token is missing in request.body', async () => { + mockReq.body.token = 'random_token_value'; + + const { getTimeZoneProfileInitialSetup } = makeSut(); + const profileInitialSetupTokenFindOneSpy = jest + .spyOn(ProfileInitialSetupToken, 'findOne') + .mockReturnValue(null); + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + expect(profileInitialSetupTokenFindOneSpy).toBeCalledTimes(1); + assertResMock(403, 'Unauthorized Request', response, mockRes); + }); + + test('Returns 500, when status.code !== 200 and status code is missing', async () => { + const { getTimeZoneProfileInitialSetup } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + const profileInitialSetupTokenFindOneSpy = jest + .spyOn(ProfileInitialSetupToken, 'findOne') + .mockReturnValue('token'); + fetch.mockImplementation(unsuccessfulFetchRequestInternalServerError); + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + expect(profileInitialSetupTokenFindOneSpy).toHaveBeenCalledTimes(1); + expect(fetch).toHaveBeenCalledTimes(1); + assertResMock(500, 'opencage error- Internal Server Error', response, mockRes); + }); + + test('Returns 404, when status.code == 200 and data.results is empty', async () => { + const { getTimeZoneProfileInitialSetup } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + const profileInitialSetupTokenFindOneSpy = jest + .spyOn(ProfileInitialSetupToken, 'findOne') + .mockReturnValue('token'); + fetch.mockImplementation(successfulFetchRequestWithNoResults); + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + expect(profileInitialSetupTokenFindOneSpy).toBeCalledTimes(1); + expect(fetch).toHaveBeenCalledTimes(1); + assertResMock(404, 'No results found', response, mockRes); + }); + + test('Returns 200, when status.code == 200 and data.results is not empty', async () => { + const { getTimeZoneProfileInitialSetup } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = 'New Jersey'; + + const profileInitialSetupTokenFindOneSpy = jest + .spyOn(ProfileInitialSetupToken, 'findOne') + .mockReturnValue('token'); + fetch.mockImplementation(successfulFetchRequestWithResults); + + const timezone = 'timeZone - Fiji'; // mocking the timezone data to be returned by `successfulFetchRequestWithResults` + const currentLocation = { + // mocking the currentLocation data to be returned by `successfulFetchRequestWithResults` + userProvided: mockReq.params.location, + coords: { + lat: 1, + lng: 1, + }, + country: 'U.S.', + city: 'Paris', + }; + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + expect(profileInitialSetupTokenFindOneSpy).toBeCalledTimes(1); + expect(fetch).toHaveBeenCalledTimes(1); + assertResMock(200, { timezone, currentLocation }, response, mockRes); + }); + + test('Returns 400, when `location` is missing in req.params', async () => { + const { getTimeZoneProfileInitialSetup } = makeSut(); + mockReq.body.requestor.role = 'Volunteer'; + mockReq.params.location = null; + + const profileInitialSetupTokenFindOneSpy = jest + .spyOn(ProfileInitialSetupToken, 'findOne') + .mockReturnValue('token'); + + const response = await getTimeZoneProfileInitialSetup(mockReq, mockRes); + await flushPromises(); + + expect(profileInitialSetupTokenFindOneSpy).toBeCalledTimes(1); + assertResMock(400, 'Missing location', response, mockRes); + }); + }); +}); diff --git a/src/controllers/userProfileController.js b/src/controllers/userProfileController.js index 83a21a4da..6a23dd34b 100644 --- a/src/controllers/userProfileController.js +++ b/src/controllers/userProfileController.js @@ -1493,26 +1493,7 @@ const userProfileController = function (UserProfile, Project) { res.status(200).send({ refreshToken: currentRefreshToken }); }; - // Search for user by first name - // const getUserBySingleName = (req, res) => { - // const pattern = new RegExp(`^${ req.params.singleName}`, 'i'); - - // // Searches for first or last name - // UserProfile.find({ - // $or: [ - // { firstName: { $regex: pattern } }, - // { lastName: { $regex: pattern } }, - // ], - // }) - // .select('firstName lastName') - // .then((users) => { - // if (users.length === 0) { - // return res.status(404).send({ error: 'Users Not Found' }); - // } - // res.status(200).send(users); - // }) - // .catch((error) => res.status(500).send(error)); - // }; + const getUserBySingleName = (req, res) => { const pattern = new RegExp(`^${req.params.singleName}`, 'i'); @@ -1557,13 +1538,7 @@ const userProfileController = function (UserProfile, Project) { .catch((error) => res.status(500).send(error)); }; - // function escapeRegExp(string) { - // return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); - // } - /** - * Authorizes user to be able to add Weekly Report Recipients - * - */ + const authorizeUser = async (req, res) => { try { let authorizedUser; diff --git a/src/cronjobs/userProfileJobs.js b/src/cronjobs/userProfileJobs.js index f0f69e146..e7a8662a6 100644 --- a/src/cronjobs/userProfileJobs.js +++ b/src/cronjobs/userProfileJobs.js @@ -19,6 +19,16 @@ const userProfileJobs = () => { } await userhelper.awardNewBadges(); await userhelper.reActivateUser(); + }, + null, + false, + 'America/Los_Angeles', + ); + + // Job to run every day, 1 minute past midnight to deactivate the user + const dailyUserDeactivateJobs = new CronJob( + '1 0 * * *', // Every day, 1 minute past midnight + async () => { await userhelper.deActivateUser(); }, null, @@ -27,5 +37,6 @@ const userProfileJobs = () => { ); allUserProfileJobs.start(); + dailyUserDeactivateJobs.start(); }; module.exports = userProfileJobs; diff --git a/src/models/jobs.js b/src/models/jobs.js new file mode 100644 index 000000000..b1f98a34a --- /dev/null +++ b/src/models/jobs.js @@ -0,0 +1,17 @@ +const mongoose = require('mongoose'); + +const { Schema } = mongoose; + +const jobSchema = new Schema({ + title: { type: String, required: true }, // Job title + category: { type: String, required: true }, // General category (e.g., Engineering, Marketing) + description: { type: String, required: true }, // Detailed job description + imageUrl: { type: String, required: true }, // URL of the job-related image + location: { type: String, required: true }, // Job location (optional for remote jobs) + applyLink: { type: String, required: true }, // URL for the application form + featured: { type: Boolean, default: false }, // Whether the job should be featured prominently + datePosted: { type: Date, default: Date.now }, // Date the job was posted + jobDetailsLink: { type: String, required: true }, // Specific job details URL +}); + +module.exports = mongoose.model('Job', jobSchema); diff --git a/src/routes/informationRouter.test.js b/src/routes/informationRouter.test.js new file mode 100644 index 000000000..12a600723 --- /dev/null +++ b/src/routes/informationRouter.test.js @@ -0,0 +1,145 @@ +const request = require('supertest'); +const { jwtPayload } = require('../test'); +const cache = require('../utilities/nodeCache')(); +const { app } = require('../app'); +const { + mockReq, + createUser, + mongoHelper: { dbConnect, dbDisconnect, dbClearCollections, dbClearAll }, +} = require('../test'); + +const agent = request.agent(app); + +describe('information routes', () => { + let user; + let token; + let reqBody = { + ...mockReq.body, + }; + beforeAll(async () => { + await dbConnect(); + user = await createUser(); + token = jwtPayload(user); + reqBody = { + ...reqBody, + infoName: 'some infoName', + infoContent: 'some infoContent', + visibility: '1', + }; + }); + beforeEach(async () => { + await dbClearCollections('informations'); + }); + + afterAll(async () => { + await dbClearAll(); + await dbDisconnect(); + }); + describe('informationRoutes', () => { + it('should return 401 if authorization header is not present', async () => { + await agent.post('/api/informations').send(reqBody).expect(401); + await agent.get('/api/informations/randomID').send(reqBody).expect(401); + }); + }); + describe('Post Information route', () => { + it('Should return 201 if the information is successfully added', async () => { + const response = await agent + .post('/api/informations') + .send(reqBody) + .set('Authorization', token) + .expect(201); + + expect(response.body).toEqual({ + _id: expect.anything(), + __v: expect.anything(), + infoName: reqBody.infoName, + infoContent: reqBody.infoContent, + visibility: reqBody.visibility, + }); + }); + }); + describe('Get Information route', () => { + it('Should return 201 if the information is successfully added', async () => { + const informations = [ + { + _id: '6605f860f948db61dab6f27m', + infoName: 'get info', + infoContent: 'get infoConten', + visibility: '1', + }, + ]; + cache.setCache('informations', JSON.stringify(informations)); + const response = await agent + .get('/api/informations') + .send(reqBody) + .set('Authorization', token) + .expect(200); + expect(response.body).toEqual({}); + }); + }); + describe('Delete Information route', () => { + it('Should return 400 if the route does not exist', async () => { + await agent + .delete('/api/informations/random123') + .send(reqBody) + .set('Authorization', token) + .expect(400); + }); + // thrown: "Exceeded timeout of 5000 ms for a test. + // Add a timeout value to this test to increase the timeout, if this is a long-running test. See https://jestjs.io/docs/api#testname-fn-timeout." + // it('Should return 200 if deleting successfully', async () => { + // const _info = new Information(); + // _info.infoName = reqBody.infoName; + // _info.infoContent = reqBody.infoContent; + // _info.visibility = reqBody.visibility; + // const info = await _info.save(); + // const response = await agent + // .delete(`/api/informations/${info._id}`) + // .set('Authorization', token) + // .send(reqBody) + // .expect(200); + + // expect(response.body).toEqual( + // { + // _id: expect.anything(), + // __v: expect.anything(), + // infoName: info.infoName, + // infoContent: info.infoContent, + // visibility: info.visibility, + // }); + // }); + }); + describe('Update Information route', () => { + it('Should return 400 if the route does not exist', async () => { + await agent + .put('/api/informations/random123') + .send(reqBody) + .set('Authorization', token) + .expect(400); + }); + // thrown: "Exceeded timeout of 5000 ms for a test. + // Add a timeout value to this test to increase the timeout, if this is a long-running test. See https://jestjs.io/docs/api#testname-fn-timeout." + // it('Should return 200 if udapted successfully', async () => { + // const _info = new Information(); + // _info.infoName = reqBody.infoName; + // _info.infoContent = reqBody.infoContent; + // _info.visibility = reqBody.visibility; + // const info = await _info.save(); + + // const response = await agent + // .put(`/api/informations/${info.id}`) + // .send(reqBody) + // .set('Authorization', token) + // .expect(200); + // expect(response.body).toEqual( + // { + // _id: expect.anything(), + // __v: expect.anything(), + // infoName: info.infoName, + // infoContent: info.infoContent, + // visibility: info.visibility, + // }); + + // }); + }); +}); diff --git a/src/routes/jobsRouter.js b/src/routes/jobsRouter.js new file mode 100644 index 000000000..5b66735a6 --- /dev/null +++ b/src/routes/jobsRouter.js @@ -0,0 +1,14 @@ +const express = require('express'); +const jobsController = require('../controllers/jobsController'); // Adjust the path if needed + +const router = express.Router(); + +// Define routes +router.get('/', jobsController.getJobs); +router.get('/categories', jobsController.getCategories); +router.get('/:id', jobsController.getJobById); +router.post('/', jobsController.createJob); +router.put('/:id', jobsController.updateJob); +router.delete('/:id', jobsController.deleteJob); + +module.exports = router; diff --git a/src/routes/reasonRouter.test.js b/src/routes/reasonRouter.test.js new file mode 100644 index 000000000..a1f1ab6dc --- /dev/null +++ b/src/routes/reasonRouter.test.js @@ -0,0 +1,338 @@ +const request = require('supertest'); +const moment = require('moment-timezone'); +const { jwtPayload } = require('../test'); +const cache = require('../utilities/nodeCache')(); +const { app } = require('../app'); +const { + mockReq, + mockUser, + createUser, + createTestPermissions, + mongoHelper: { dbConnect, dbDisconnect, dbClearCollections, dbClearAll }, +} = require('../test'); +// const Reason = require('../models/reason'); + +function mockDay(dayIdx, past = false) { + const date = moment().tz('America/Los_Angeles').startOf('day'); + while (date.day() !== dayIdx) { + date.add(past ? -1 : 1, 'days'); + } + return date; +} +const agent = request.agent(app); +describe('reason routers', () => { + let adminUser; + let adminToken; + let reqBody = { + body: { + ...mockReq.body, + ...mockUser(), + }, + }; + beforeAll(async () => { + await dbConnect(); + await createTestPermissions(); + adminUser = await createUser(); + adminToken = jwtPayload(adminUser); + }); + beforeEach(async () => { + await dbClearCollections('reason'); + await dbClearCollections('userProfiles'); + cache.setCache('allusers', '[]'); + reqBody = { + body: { + ...mockReq.body, + ...mockUser(), + reasonData: { + date: mockDay(0), + message: 'some reason', + }, + currentDate: moment.tz('America/Los_Angeles').startOf('day'), + }, + }; + }); + afterAll(async () => { + await dbClearAll(); + await dbDisconnect(); + }); + describe('reasonRouters', () => { + it('should return 401 if authorization header is not present', async () => { + await agent.post('/api/reason/').send(reqBody.body).expect(401); + await agent.get('/api/reason/randomId').send(reqBody.body).expect(401); + await agent.get('/api/reason/single/randomId').send(reqBody.body).expect(401); + await agent.patch('/api/reason/randomId/').send(reqBody.body).expect(401); + await agent.delete('/api/reason/randomId').send(reqBody.body).expect(401); + }); + }); + describe('Post reason route', () => { + it('Should return 400 if user did not choose SUNDAY', async () => { + reqBody.body.reasonData.date = mockDay(1, true); + const response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(400); + expect(response.body).toEqual({ + message: + "You must choose the Sunday YOU'LL RETURN as your date. This is so your reason ends up as a note on that blue square.", + errorCode: 0, + }); + }); + it('Should return 400 if warning to choose a future date', async () => { + reqBody.body.reasonData.date = mockDay(0, true); + const response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(400); + expect(response.body).toEqual({ + message: 'You should select a date that is yet to come', + errorCode: 7, + }); + }); + it('Should return 400 if not providing reason', async () => { + reqBody.body.reasonData.message = null; + const response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(400); + expect(response.body).toEqual({ + message: 'You must provide a reason.', + errorCode: 6, + }); + }); + it('Should return 404 if error in finding user Id', async () => { + reqBody.body.userId = null; + const response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(404); + expect(response.body).toEqual({ + message: 'User not found', + errorCode: 2, + }); + }); + it('Should return 403 if duplicate resonse', async () => { + // const userProfile = new userPro + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent + .get('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + expect(response.body).toBeTruthy(); + response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(403); + }); + it('Should return 200 if post successfully', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent + .get('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .post('/api/reason/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + }); + }); + describe('Get AllReason route', () => { + it('Should return 400 if route does not exist', async () => { + const response = await agent + .get(`/api/reason/random123`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(400); + expect(response.body).toEqual({ + errMessage: 'Something went wrong while fetching the user', + }); + }); + it('Should return 200 if get all reasons', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent + .get('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .get(`/api/reason/${userId}`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + }); + }); + describe('Get Single Reason route', () => { + it('Should return 400 if route does not exist', async () => { + reqBody.query = { + queryDate: mockDay(1, true), + }; + const response = await agent + .get(`/api/reason/single/5a7e21f00317bc1538def4b9`) + .set('Authorization', adminToken) + .expect(404); + expect(response.body).toEqual({ + message: 'User not found', + errorCode: 2, + }); + }); + it('Should return 200 if get all reasons', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent.get('/api/userProfile').set('Authorization', adminToken).expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + reqBody.query = { + queryDate: mockDay(1, true), + }; + response = await agent + .get(`/api/reason/single/${userId}`) + .set('Authorization', adminToken) + .expect(200); + }); + }); + describe('Patch reason route', () => { + it('Should return 404 if error in finding user Id', async () => { + reqBody.body.userId = null; + const response = await agent + .patch('/api/reason/5a7e21f00317bc1538def4b9/') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(404); + expect(response.body).toEqual({ + message: 'User not found', + errorCode: 2, + }); + }); + it('Should return 404 if duplicate reasons', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent.get('/api/userProfile').set('Authorization', adminToken).expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .patch(`/api/reason/${userId}/`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(404); + expect(response.body).toEqual({ + message: 'Reason not found', + errorCode: 4, + }); + }); + it('Should return 200 if patch successfully', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent.get('/api/userProfile').set('Authorization', adminToken).expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .post(`/api/reason/`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + expect(response.body).toBeTruthy(); + response = await agent + .patch(`/api/reason/${userId}/`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + expect(response.body).toEqual({ + message: 'Reason Updated!', + }); + }); + }); + describe('Delete reason route', () => { + it('Should return 404 if route does not exist', async () => { + const response = await agent + .delete(`/api/reason/5a7e21f00317bc1538def4b9`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(404); + expect(response.body).toEqual({ + message: 'User not found', + errorCode: 2, + }); + }); + it('Should return 200 if deleting successfully', async () => { + let response = await agent + .post('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + + expect(response.body).toBeTruthy(); + response = await agent + .get('/api/userProfile') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + const userId = response.body[0]._id; + reqBody.body.userId = userId; + response = await agent + .post(`/api/reason/`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + expect(response.body).toBeTruthy(); + response = await agent + .delete(`/api/reason/${userId}`) + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(200); + expect(response.body).toEqual({ + message: 'Document deleted', + }); + }); + }); +}); diff --git a/src/routes/teamRouter.js b/src/routes/teamRouter.js index 1bf8cfc44..3fbd8abb5 100644 --- a/src/routes/teamRouter.js +++ b/src/routes/teamRouter.js @@ -11,6 +11,10 @@ const router = function (team) { .post(controller.postTeam) .put(controller.updateTeamVisibility); + teamRouter + .route("/team/reports") + .post(controller.getAllTeamMembers); + teamRouter .route('/team/:teamId') .get(controller.getTeamById) diff --git a/src/routes/timeZoneAPIRoutes.test.js b/src/routes/timeZoneAPIRoutes.test.js new file mode 100644 index 000000000..975e56ac2 --- /dev/null +++ b/src/routes/timeZoneAPIRoutes.test.js @@ -0,0 +1,208 @@ +const request = require('supertest'); +const { jwtPayload } = require('../test'); + +const originalPremiumKey = process.env.TIMEZONE_PREMIUM_KEY; + +const { app } = require('../app'); +const { + mockReq, + mongoHelper: { dbConnect, dbDisconnect }, + createTestPermissions, + createUser, + mockUser, +} = require('../test'); + +const UserProfile = require('../models/userProfile'); +const ProfileInitialSetupToken = require('../models/profileInitialSetupToken'); + +const agent = request.agent(app); + +describe('timeZoneAPI routes', () => { + let adminUser; + let adminToken; + let volunteerUser; + let volunteerToken; + + const reqBody = {}; + const incorrectLocationParams = 'r'; + const locationParamsThatResultsInNoMatch = 'someReallyRandomLocation'; + const correctLocationParams = 'Berlin,+Germany'; + + beforeAll(async () => { + await dbConnect(); + await createTestPermissions(); + + reqBody.body = { + // This is the user we want to create + ...mockReq.body, + }; + adminUser = await createUser(); // This is the admin requestor user + adminToken = jwtPayload(adminUser); + + volunteerUser = mockUser(); // This is the admin requestor user + volunteerUser.email = 'volunteer@onecommunity.com'; + volunteerUser.role = 'Volunteer'; + volunteerUser = new UserProfile(volunteerUser); + volunteerUser = await volunteerUser.save(); + volunteerToken = jwtPayload(volunteerUser); + }); + + afterAll(async () => { + await dbDisconnect(); + + if (originalPremiumKey) { + process.env.TIMEZONE_PREMIUM_KEY = originalPremiumKey; + } else { + delete process.env.TIMEZONE_PREMIUM_KEY; + } + }); + + describe('API routes', () => { + it("should return 404 if route doesn't exist", async () => { + await agent + .post('/api/timezonesss') + .send(reqBody.body) + .set('Authorization', adminToken) + .expect(404); + }); + }); + + describe('getTimeZone - request parameter `location` based tests', () => { + test('401 when `API key` is missing', async () => { + const location = 'Berlin,+Germany'; + delete process.env.TIMEZONE_PREMIUM_KEY; + + const response = await agent + .get(`/api/timezone/${location}`) + .set('Authorization', adminToken) + .send(reqBody.body) + .expect(401); + + expect(response.error.text).toBe('API Key Missing'); + }); + + test('400 when `location` is incorrect', async () => { + const response = await agent + .get(`/api/timezone/${incorrectLocationParams}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(400); + + expect(response.error.text).toBeTruthy(); + }); + + test('200 when `location` is correctly formatted', async () => { + const response = await agent + .get(`/api/timezone/${correctLocationParams}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(200); + + expect(response).toBeTruthy(); + expect(response._body.timezone).toBeTruthy(); + expect(response._body.currentLocation).toBeTruthy(); + expect(response._body.currentLocation.userProvided).toBe(correctLocationParams); + }); + + test('404 when results.length === 0', async () => { + const response = await agent + .get(`/api/timezone/${locationParamsThatResultsInNoMatch}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(404); + + expect(response).toBeTruthy(); + }); + }); + + describe('getTimeZoneProfileInitialSetup - token is missing in body or in ProfileInitialSetupToken', () => { + test('401 when `token` is missing in request body', async () => { + const location = 'Berlin,+Germany'; + + const response = await agent + .post(`/api/timezone/${location}`) + .set('Authorization', adminToken) + .send(reqBody.body) + .expect(400); + + expect(response.error.text).toBe('Missing token'); + }); + + test('403 when ProfileInitialSetupToken does not contains `req.body.token`', async () => { + const location = 'Berlin,+Germany'; + reqBody.body = { + ...reqBody, + token: 'randomToken', + }; + + const response = await agent + .post(`/api/timezone/${location}`) + .set('Authorization', adminToken) + .send(reqBody.body) + .expect(403); + + expect(response.error.text).toBe('Unauthorized Request'); + }); + }); + + describe('getTimeZoneProfileInitialSetup - token is present in ProfileInitialSetupToken', () => { + const tokenData = 'randomToken'; + + beforeAll(async () => { + const expirationDate = new Date().setDate(new Date().getDate() + 10); + + let data = { + token: tokenData, + email: 'randomEmail', + weeklyCommittedHours: 5, + expiration: expirationDate, + createdDate: new Date(), + isCancelled: false, + isSetupCompleted: true, + }; + + data = new ProfileInitialSetupToken(data); + + // eslint-disable-next-line no-unused-vars + data = await data.save(); + + reqBody.body = { + ...reqBody, + token: tokenData, + }; + }); + + test('400 when `location` is incorrect', async () => { + const response = await agent + .get(`/api/timezone/${incorrectLocationParams}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(400); + + expect(response.error.text).toBeTruthy(); + }); + + test('200 when `location` is correctly formatted', async () => { + const response = await agent + .get(`/api/timezone/${correctLocationParams}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(200); + + expect(response).toBeTruthy(); + expect(response._body.timezone).toBeTruthy(); + expect(response._body.currentLocation).toBeTruthy(); + expect(response._body.currentLocation.userProvided).toBe(correctLocationParams); + }); + + test('404 when results.length === 0', async () => { + const response = await agent + .get(`/api/timezone/${locationParamsThatResultsInNoMatch}`) // Make sure this is the intended test + .set('Authorization', volunteerToken) + .send(reqBody.body) + .expect(404); + + expect(response).toBeTruthy(); + }); + }); +}); diff --git a/src/startup/db.js b/src/startup/db.js index c3c61807c..719c17f94 100644 --- a/src/startup/db.js +++ b/src/startup/db.js @@ -33,7 +33,7 @@ const afterConnect = async () => { module.exports = function () { const uri = `mongodb://${process.env.user}:${encodeURIComponent(process.env.password)}@${process.env.cluster}/${process.env.dbName}?ssl=true&replicaSet=${process.env.replicaSetName}&authSource=admin`; - + mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true, diff --git a/src/startup/middleware.js b/src/startup/middleware.js index eef3bd71b..400f5af6c 100644 --- a/src/startup/middleware.js +++ b/src/startup/middleware.js @@ -10,9 +10,8 @@ module.exports = function (app) { } if ( - (req.originalUrl === '/api/login' - || req.originalUrl === '/api/forgotpassword') - && req.method === 'POST' + (req.originalUrl === '/api/login' || req.originalUrl === '/api/forgotpassword') && + req.method === 'POST' ) { next(); return; @@ -21,12 +20,26 @@ module.exports = function (app) { next(); return; } - if (((req.originalUrl === '/api/ProfileInitialSetup' || req.originalUrl === '/api/validateToken' || req.originalUrl === '/api/getTimeZoneAPIKeyByToken') && req.method === 'POST') || (req.originalUrl === '/api/getTotalCountryCount' && req.method === 'GET') || (req.originalUrl.includes('/api/timezone') && req.method === 'POST') + if ( + ((req.originalUrl === '/api/ProfileInitialSetup' || + req.originalUrl === '/api/validateToken' || + req.originalUrl === '/api/getTimeZoneAPIKeyByToken') && + req.method === 'POST') || + (req.originalUrl === '/api/getTotalCountryCount' && req.method === 'GET') || + (req.originalUrl.includes('/api/timezone') && req.method === 'POST') ) { next(); return; } - if (req.originalUrl === '/api/add-non-hgn-email-subscription' || req.originalUrl === '/api/confirm-non-hgn-email-subscription' || req.originalUrl === '/api/remove-non-hgn-email-subscription' && req.method === 'POST') { + if ( + req.originalUrl === '/api/add-non-hgn-email-subscription' || + req.originalUrl === '/api/confirm-non-hgn-email-subscription' || + (req.originalUrl === '/api/remove-non-hgn-email-subscription' && req.method === 'POST') + ) { + next(); + return; + } + if (req.originalUrl.startsWith('/api/jobs') && req.method === 'GET') { next(); return; } @@ -44,13 +57,12 @@ module.exports = function (app) { res.status(401).send('Invalid token'); return; } - if ( - !payload - || !payload.expiryTimestamp - || !payload.userid - || !payload.role - || moment().isAfter(payload.expiryTimestamp) + !payload || + !payload.expiryTimestamp || + !payload.userid || + !payload.role || + moment().isAfter(payload.expiryTimestamp) ) { res.status(401).send('Unauthorized request'); return; diff --git a/src/startup/routes.js b/src/startup/routes.js index 82a4155a8..b307ac4f4 100644 --- a/src/startup/routes.js +++ b/src/startup/routes.js @@ -4,7 +4,6 @@ const project = require('../models/project'); const information = require('../models/information'); const team = require('../models/team'); // const actionItem = require('../models/actionItem'); -const notification = require('../models/notification'); const wbs = require('../models/wbs'); const task = require('../models/task'); const popup = require('../models/popupEditor'); @@ -55,6 +54,7 @@ const timeEntryRouter = require('../routes/timeentryRouter')(timeEntry); const projectRouter = require('../routes/projectRouter')(project); const informationRouter = require('../routes/informationRouter')(information); const teamRouter = require('../routes/teamRouter')(team); +const jobsRouter = require('../routes/jobsRouter'); // const actionItemRouter = require('../routes/actionItemRouter')(actionItem); const notificationRouter = require('../routes/notificationRouter')(); const loginRouter = require('../routes/loginRouter')(); @@ -162,6 +162,7 @@ module.exports = function (app) { app.use('/api', timeOffRequestRouter); app.use('/api', followUpRouter); app.use('/api', blueSquareEmailAssignmentRouter); + app.use('/api/jobs', jobsRouter) // bm dashboard app.use('/api/bm', bmLoginRouter); app.use('/api/bm', bmMaterialsRouter); diff --git a/src/test/createTestPermissions.js b/src/test/createTestPermissions.js index 58623ea3f..e0f9eddf1 100644 --- a/src/test/createTestPermissions.js +++ b/src/test/createTestPermissions.js @@ -51,7 +51,9 @@ const permissionsRoles = [ 'changeUserStatus', 'updatePassword', 'deleteUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', // WBS 'postWbs', 'deleteWbs', @@ -111,7 +113,9 @@ const permissionsRoles = [ 'getUserProfiles', 'getProjectMembers', 'putUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', 'getReporteesLimitRoles', 'updateTask', 'putTeam', @@ -139,7 +143,9 @@ const permissionsRoles = [ 'getUserProfiles', 'getProjectMembers', 'putUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', 'getReporteesLimitRoles', 'getAllInvInProjectWBS', 'postInvInProjectWBS', @@ -194,6 +200,8 @@ const permissionsRoles = [ 'editTimeEntryToggleTangible', 'deleteTimeEntry', 'postTimeEntry', + 'sendEmails', + 'sendEmailToAll', 'updatePassword', 'getUserProfiles', 'getProjectMembers', @@ -202,7 +210,9 @@ const permissionsRoles = [ 'putUserProfileImportantInfo', 'updateSummaryRequirements', 'deleteUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', 'postWbs', 'deleteWbs', 'getAllInvInProjectWBS', diff --git a/src/utilities/createInitialPermissions.js b/src/utilities/createInitialPermissions.js index 43dfec2a0..062679cdd 100644 --- a/src/utilities/createInitialPermissions.js +++ b/src/utilities/createInitialPermissions.js @@ -52,7 +52,9 @@ const permissionsRoles = [ 'changeUserRehireableStatus', 'updatePassword', 'deleteUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', 'manageAdminLinks', 'manageTimeOffRequests', 'changeUserRehireableStatus', @@ -149,7 +151,6 @@ const permissionsRoles = [ { roleName: 'Mentor', permissions: [ - 'updateTask', 'suggestTask', 'putReviewStatus', 'getReporteesLimitRoles', @@ -212,6 +213,8 @@ const permissionsRoles = [ 'editTimeEntryToggleTangible', 'deleteTimeEntry', 'postTimeEntry', + 'sendEmails', + 'sendEmailToAll', 'updatePassword', 'getUserProfiles', 'getProjectMembers', @@ -220,7 +223,9 @@ const permissionsRoles = [ 'putUserProfileImportantInfo', 'updateSummaryRequirements', 'deleteUserProfile', - 'infringementAuthorizer', + 'addInfringements', + 'editInfringements', + 'deleteInfringements', 'postWbs', 'deleteWbs', 'getAllInvInProjectWBS', @@ -251,7 +256,10 @@ const permissionsRoles = [ 'seeUsersInDashboard', 'changeUserRehireableStatus', - 'manageAdminLinks', + + 'removeUserFromTask', + + 'editHeaderMessage', ], }, ]; diff --git a/src/utilities/emailSender.js b/src/utilities/emailSender.js index 19834abf4..b0fb40112 100644 --- a/src/utilities/emailSender.js +++ b/src/utilities/emailSender.js @@ -2,112 +2,113 @@ const nodemailer = require('nodemailer'); const { google } = require('googleapis'); const logger = require('../startup/logger'); -const closure = () => { - const queue = []; - - const CLIENT_EMAIL = process.env.REACT_APP_EMAIL; - const CLIENT_ID = process.env.REACT_APP_EMAIL_CLIENT_ID; - const CLIENT_SECRET = process.env.REACT_APP_EMAIL_CLIENT_SECRET; - const REDIRECT_URI = process.env.REACT_APP_EMAIL_CLIENT_REDIRECT_URI; - const REFRESH_TOKEN = process.env.REACT_APP_EMAIL_REFRESH_TOKEN; - // Create the email envelope (transport) - const transporter = nodemailer.createTransport({ - service: 'gmail', - auth: { - type: 'OAuth2', - user: CLIENT_EMAIL, - clientId: CLIENT_ID, - clientSecret: CLIENT_SECRET, - }, - }); +const config = { + email: process.env.REACT_APP_EMAIL, + clientId: process.env.REACT_APP_EMAIL_CLIENT_ID, + clientSecret: process.env.REACT_APP_EMAIL_CLIENT_SECRET, + redirectUri: process.env.REACT_APP_EMAIL_CLIENT_REDIRECT_URI, + refreshToken: process.env.REACT_APP_EMAIL_REFRESH_TOKEN, + batchSize: 50, + concurrency: 3, + rateLimitDelay: 1000, +}; - const OAuth2Client = new google.auth.OAuth2(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI); +const OAuth2Client = new google.auth.OAuth2( + config.clientId, + config.clientSecret, + config.redirectUri, +); +OAuth2Client.setCredentials({ refresh_token: config.refreshToken }); - OAuth2Client.setCredentials({ refresh_token: REFRESH_TOKEN }); +// Create the email envelope (transport) +const transporter = nodemailer.createTransport({ + service: 'gmail', + auth: { + type: 'OAuth2', + user: config.email, + clientId: config.clientId, + clientSecret: config.clientSecret, + }, +}); - setInterval(async () => { - const nextItem = queue.shift(); +const sendEmail = async (mailOptions) => { + try { + const { token } = await OAuth2Client.getAccessToken(); + mailOptions.auth = { + user: config.email, + refreshToken: config.refreshToken, + accessToken: token, + }; + const result = await transporter.sendMail(mailOptions); + if (process.env.NODE_ENV === 'local') { + logger.logInfo(`Email sent: ${JSON.stringify(result)}`); + } + return result; + } catch (error) { + logger.logException(error, `Error sending email: ${mailOptions.to}`); + throw error; + } +}; - if (!nextItem) return; +const queue = []; +let isProcessing = false; - const { recipient, subject, message, cc, bcc, replyTo, acknowledgingReceipt, resolve, reject} = nextItem; +const processQueue = async () => { + if (isProcessing || queue.length === 0) return; - try { - // Generate the accessToken on the fly - const res = await OAuth2Client.getAccessToken(); - const ACCESSTOKEN = res.token; + isProcessing = true; + console.log('Processing email queue...'); - const mailOptions = { - from: CLIENT_EMAIL, - to: recipient, - cc, - bcc, - subject, - html: message, - replyTo, - auth: { - user: CLIENT_EMAIL, - refreshToken: REFRESH_TOKEN, - accessToken: ACCESSTOKEN, - }, - }; + const processBatch = async () => { + if (queue.length === 0) { + isProcessing = false; + return; + } - const result = await transporter.sendMail(mailOptions); - if (typeof acknowledgingReceipt === 'function') { - acknowledgingReceipt(null, result); - } - // Prevent logging email in production - // Why? - // 1. Could create a security risk - // 2. Could create heavy loads on the server if emails are sent to many people - // 3. Contain limited useful info: - // result format : {"accepted":["emailAddr"],"rejected":[],"envelopeTime":209,"messageTime":566,"messageSize":317,"response":"250 2.0.0 OK 17***69 p11-2***322qvd.85 - gsmtp","envelope":{"from":"emailAddr", "to":"emailAddr"}} - if (process.env.NODE_ENV === 'local') { - logger.logInfo(`Email sent: ${JSON.stringify(result)}`); - } - resolve(result); + const batch = queue.shift(); + try { + console.log('Sending email...'); + await sendEmail(batch); } catch (error) { - if (typeof acknowledgingReceipt === 'function') { - acknowledgingReceipt(error, null); - } - logger.logException( - error, - `Error sending email: from ${CLIENT_EMAIL} to ${recipient} subject ${subject}`, - `Extra Data: cc ${cc} bcc ${bcc}`, - ); - reject(error); + logger.logException(error, 'Failed to send email batch'); } - }, process.env.MAIL_QUEUE_INTERVAL || 1000); - const emailSender = function ( - recipient, - subject, - message, - cc = null, - bcc = null, - replyTo = null, - acknowledgingReceipt = null, - ) { - return new Promise((resolve, reject) => { - if (process.env.sendEmail) { - queue.push({ - recipient, - subject, - message, - cc, - bcc, - replyTo, - acknowledgingReceipt, - resolve, - reject, - }); - } else { - resolve('Email sending is disabled'); - } - }); + setTimeout(processBatch, config.rateLimitDelay); }; - return emailSender; + const concurrentProcesses = Array(config.concurrency).fill().map(processBatch); + + try { + await Promise.all(concurrentProcesses); + } finally { + isProcessing = false; + } +}; + +const emailSender = ( + recipients, + subject, + message, + attachments = null, + cc = null, + replyTo = null, +) => { + if (!process.env.sendEmail) return; + const recipientsArray = Array.isArray(recipients) ? recipients : [recipients]; + for (let i = 0; i < recipients.length; i += config.batchSize) { + const batchRecipients = recipientsArray.slice(i, i + config.batchSize); + queue.push({ + from: config.email, + bcc: batchRecipients.join(','), + subject, + html: message, + attachments, + cc, + replyTo, + }); + } + console.log('Emails queued:', queue.length); + setImmediate(processQueue); }; -module.exports = closure(); +module.exports = emailSender; diff --git a/src/utilities/permissions.js b/src/utilities/permissions.js index 2299e8812..75aee3b59 100644 --- a/src/utilities/permissions.js +++ b/src/utilities/permissions.js @@ -64,10 +64,10 @@ const canRequestorUpdateUser = async (requestorId, targetUserId) => { // Find out a list of protected email account ids and allowed email id allowedEmailAccountIds = query .filter(({ email }) => ALLOWED_EMAIL_ACCOUNT.includes(email)) - .map(({ _id }) => _id); + .map(({ _id }) => _id.toString()); protectedEmailAccountIds = query .filter(({ email }) => PROTECTED_EMAIL_ACCOUNT.includes(email)) - .map(({ _id }) => _id); + .map(({ _id }) => _id.toString()); serverCache.setCache('protectedEmailAccountIds', protectedEmailAccountIds); serverCache.setCache('allowedEmailAccountIds', allowedEmailAccountIds);