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(() => { @@ -24,48 +96,48 @@ 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 = ` - - - - - - - - ${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 subscriptionEmailContent = ` - - - - - + if (users.length === 0) { + return res.status(404).send('No users found'); + } - - ${html} -Thank you for subscribing to our email updates!
-If you would like to unsubscribe, please click here
- - `; - emailSender(email, subject, subscriptionEmailContent); - }); + const recipientEmails = users.map((user) => user.email); + console.log('# sendEmailToAll to', recipientEmails.join(',')); + if (recipientEmails.length === 0) { + throw new Error('No recipients defined'); + } + 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); + }), + ); return res.status(200).send('Email sent successfully'); } catch (error) { console.error('Error sending email:', error); 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/timeEntryController.js b/src/controllers/timeEntryController.js index 6e8d36596..44a50fcfb 100644 --- a/src/controllers/timeEntryController.js +++ b/src/controllers/timeEntryController.js @@ -1,5 +1,6 @@ const moment = require('moment-timezone'); const mongoose = require('mongoose'); +const { v4: uuidv4 } = require('uuid'); const logger = require('../startup/logger'); const UserProfile = require('../models/userProfile'); const Project = require('../models/project'); @@ -419,7 +420,7 @@ const addEditHistory = async (One Community
-ADMINISTRATIVE DETAILS:
Start Date: ${moment(userprofile.startDate).utc().format('M-D-YYYY')}
Role: ${userprofile.role}
@@ -593,7 +594,7 @@ const timeEntrycontroller = function (TimeEntry) { await timeEntry.save({ session }); if (userprofile) { - await userprofile.save({ session }); + await userprofile.save({ session, validateModifiedOnly: true }); // since userprofile is updated, need to remove the cache so that the updated userprofile is fetched next time removeOutdatedUserprofileCache(userprofile._id.toString()); } @@ -866,7 +867,7 @@ const timeEntrycontroller = function (TimeEntry) { } await timeEntry.save({ session }); if (userprofile) { - await userprofile.save({ session }); + await userprofile.save({ session, validateModifiedOnly: true }); // since userprofile is updated, need to remove the cache so that the updated userprofile is fetched next time removeOutdatedUserprofileCache(userprofile._id.toString()); @@ -939,7 +940,7 @@ const timeEntrycontroller = function (TimeEntry) { await timeEntry.remove({ session }); if (userprofile) { - await userprofile.save({ session }); + await userprofile.save({ session, validateModifiedOnly: true }); // since userprofile is updated, need to remove the cache so that the updated userprofile is fetched next time removeOutdatedUserprofileCache(userprofile._id.toString()); @@ -1062,40 +1063,115 @@ const timeEntrycontroller = function (TimeEntry) { }); }; - const getTimeEntriesForReports = function (req, res) { + const getTimeEntriesForReports =async function (req, res) { const { users, fromDate, toDate } = req.body; + const cacheKey = `timeEntry_${fromDate}_${toDate}`; + const timeentryCache=cacheClosure(); + const cacheData=timeentryCache.hasCache(cacheKey) + if(cacheData){ + const data = timeentryCache.getCache(cacheKey); + return res.status(200).send(data); + } + try { + const results = await TimeEntry.find( + { + personId: { $in: users }, + dateOfWork: { $gte: fromDate, $lte: toDate }, + }, + '-createdDateTime' // Exclude unnecessary fields + ) + .lean() // Returns plain JavaScript objects, not Mongoose documents + .populate({ + path: 'projectId', + select: '_id projectName', // Only return necessary fields from the project + }) + .exec(); // Executes the query + const data = results.map(element => { + const record = { + _id: element._id, + isTangible: element.isTangible, + personId: element.personId, + dateOfWork: element.dateOfWork, + hours: formatSeconds(element.totalSeconds)[0], + minutes: formatSeconds(element.totalSeconds)[1], + projectId: element.projectId?._id || '', + projectName: element.projectId?.projectName || '', + }; + return record; + }); + timeentryCache.setCache(cacheKey,data); + return res.status(200).send(data); + } catch (error) { + res.status(400).send(error); + } + }; + const getTimeEntriesForProjectReports = function (req, res) { + const { users, fromDate, toDate } = req.body; + + // Fetch only necessary fields and avoid bringing the entire document TimeEntry.find( { personId: { $in: users }, dateOfWork: { $gte: fromDate, $lte: toDate }, }, - ' -createdDateTime', + 'totalSeconds isTangible dateOfWork projectId', ) - .populate('projectId') - + .populate('projectId', 'projectName _id') + .lean() // lean() for better performance as we don't need Mongoose document methods .then((results) => { - const data = []; - - results.forEach((element) => { - const record = {}; - record._id = element._id; - record.isTangible = element.isTangible; - record.personId = element.personId._id; - record.dateOfWork = element.dateOfWork; + const data = results.map((element) => { + const record = { + isTangible: element.isTangible, + dateOfWork: element.dateOfWork, + projectId: element.projectId ? element.projectId._id : '', + projectName: element.projectId ? element.projectId.projectName : '', + }; + + // Convert totalSeconds to hours and minutes [record.hours, record.minutes] = formatSeconds(element.totalSeconds); - record.projectId = element.projectId ? element.projectId._id : ''; - record.projectName = element.projectId ? element.projectId.projectName : ''; - data.push(record); + + return record; }); res.status(200).send(data); }) .catch((error) => { - res.status(400).send(error); + res.status(400).send({ message: 'Error fetching time entries for project reports', error }); }); }; + const getTimeEntriesForPeopleReports = async function (req, res) { + try { + const { users, fromDate, toDate } = req.body; + + const results = await TimeEntry.find( + { + personId: { $in: users }, + dateOfWork: { $gte: fromDate, $lte: toDate }, + }, + 'personId totalSeconds isTangible dateOfWork', + ).lean(); // Use lean() for better performance + + const data = results + .map((entry) => { + const [hours, minutes] = formatSeconds(entry.totalSeconds); + return { + personId: entry.personId, + hours, + minutes, + isTangible: entry.isTangible, + dateOfWork: entry.dateOfWork, + }; + }) + .filter(Boolean); + + res.status(200).send(data); + } catch (error) { + res.status(400).send({ message: 'Error fetching time entries for people reports', error }); + } + }; + /** * Get time entries for a specified project */ @@ -1208,7 +1284,12 @@ const timeEntrycontroller = function (TimeEntry) { */ const getLostTimeEntriesForTeamList = function (req, res) { const { teams, fromDate, toDate } = req.body; - + const lostteamentryCache=cacheClosure() + const cacheKey = `LostTeamEntry_${fromDate}_${toDate}`; + const cacheData=lostteamentryCache.getCache(cacheKey) + if(cacheData){ + return res.status(200).send(cacheData) + } TimeEntry.find( { entryType: 'team', @@ -1217,7 +1298,7 @@ const timeEntrycontroller = function (TimeEntry) { isActive: { $ne: false }, }, ' -createdDateTime', - ) + ).lean() .populate('teamId') .sort({ lastModifiedDateTime: -1 }) .then((results) => { @@ -1234,7 +1315,8 @@ const timeEntrycontroller = function (TimeEntry) { [record.hours, record.minutes] = formatSeconds(element.totalSeconds); data.push(record); }); - res.status(200).send(data); + lostteamentryCache.setCache(cacheKey,data); + return res.status(200).send(data); }) .catch((error) => { res.status(400).send(error); @@ -1367,10 +1449,12 @@ const timeEntrycontroller = function (TimeEntry) { return newTotalIntangibleHrs; }; + const recalculationTaskQueue = []; + /** - * recalculate the hoursByCatefory for all users and update the field + * recalculate the hoursByCategory for all users and update the field */ - const recalculateHoursByCategoryAllUsers = async function (req, res) { + const recalculateHoursByCategoryAllUsers = async function (taskId) { const session = await mongoose.startSession(); session.startTransaction(); @@ -1385,18 +1469,60 @@ const timeEntrycontroller = function (TimeEntry) { await Promise.all(recalculationPromises); await session.commitTransaction(); - return res.status(200).send({ - message: 'finished the recalculation for hoursByCategory for all users', - }); + + const recalculationTask = recalculationTaskQueue.find((task) => task.taskId === taskId); + if (recalculationTask) { + recalculationTask.status = 'Completed'; + recalculationTask.completionTime = new Date().toISOString(); + } } catch (err) { await session.abortTransaction(); + const recalculationTask = recalculationTaskQueue.find((task) => task.taskId === taskId); + if (recalculationTask) { + recalculationTask.status = 'Failed'; + recalculationTask.completionTime = new Date().toISOString(); + } + logger.logException(err); - return res.status(500).send({ error: err.toString() }); } finally { session.endSession(); } }; + const startRecalculation = async function (req, res) { + const taskId = uuidv4(); + recalculationTaskQueue.push({ + taskId, + status: 'In progress', + startTime: new Date().toISOString(), + completionTime: null, + }); + if (recalculationTaskQueue.length > 10) { + recalculationTaskQueue.shift(); + } + + res.status(200).send({ + message: 'The recalculation task started in the background', + taskId, + }); + + setTimeout(() => recalculateHoursByCategoryAllUsers(taskId), 0); + }; + + const checkRecalculationStatus = async function (req, res) { + const { taskId } = req.params; + const recalculationTask = recalculationTaskQueue.find((task) => task.taskId === taskId); + if (recalculationTask) { + res.status(200).send({ + status: recalculationTask.status, + startTime: recalculationTask.startTime, + completionTime: recalculationTask.completionTime, + }); + } else { + res.status(404).send({ message: 'Task not found' }); + } + }; + /** * recalculate the totalIntangibleHrs for all users and update the field */ @@ -1441,9 +1567,12 @@ const timeEntrycontroller = function (TimeEntry) { getLostTimeEntriesForTeamList, backupHoursByCategoryAllUsers, backupIntangibleHrsAllUsers, - recalculateHoursByCategoryAllUsers, recalculateIntangibleHrsAllUsers, getTimeEntriesForReports, + getTimeEntriesForProjectReports, + getTimeEntriesForPeopleReports, + startRecalculation, + checkRecalculationStatus, }; }; 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/titleController.js b/src/controllers/titleController.js index 08751bdef..277842c43 100644 --- a/src/controllers/titleController.js +++ b/src/controllers/titleController.js @@ -1,130 +1,206 @@ -const Team = require('../models/team'); const Project = require('../models/project'); const cacheClosure = require('../utilities/nodeCache'); -const { getAllTeamCodeHelper } = require("./userProfileController"); +const userProfileController = require("./userProfileController"); +const userProfile = require('../models/userProfile'); +const project = require('../models/project'); + +const controller = userProfileController(userProfile, project); +const { getAllTeamCodeHelper } = controller; const titlecontroller = function (Title) { const cache = cacheClosure(); - const getAllTitles = function (req, res) { - Title.find({}) - .then((results) => res.status(200).send(results)) - .catch((error) => res.status(404).send(error)); + // Update: Confirmed with Jae. Team code is not related to the Team data model. But the team code field within the UserProfile data model. + async function checkTeamCodeExists(teamCode) { + try { + if (cache.getCache('teamCodes')) { + const teamCodes = JSON.parse(cache.getCache('teamCodes')); + return teamCodes.includes(teamCode); + } + const teamCodes = await getAllTeamCodeHelper(); + return teamCodes.includes(teamCode); + } catch (error) { + console.error('Error checking if team code exists:', error); + throw error; + } + } + + async function checkProjectExists(projectID) { + try { + const proj = await Project.findOne({ _id: projectID }).exec(); + return !!proj; + } catch (error) { + console.error('Error checking if project exists:', error); + throw error; + } + } + + const getAllTitles = function (req, res) { + Title.find({}) + .then((results) => res.status(200).send(results)) + .catch((error) => res.status(404).send(error)); }; - const getTitleById = function (req, res) { - const { titleId } = req.params; + const getTitleById = function (req, res) { + const { titleId } = req.params; - Title.findById(titleId) - .then((results) => res.send(results)) - .catch((error) => res.send(error)); - }; + Title.findById(titleId) + .then((results) => res.send(results)) + .catch((error) => res.send(error)); + }; + + const postTitle = async function (req, res) { + const title = new Title(); + title.titleName = req.body.titleName; + title.titleCode = req.body.titleCode; + title.teamCode = req.body.teamCode; + title.projectAssigned = req.body.projectAssigned; + title.mediaFolder = req.body.mediaFolder; + title.teamAssiged = req.body.teamAssiged; + + const titleCodeRegex = /^[A-Za-z]+$/; + if (!title.titleCode || !title.titleCode.trim()) { + return res.status(400).send({ message: 'Title code cannot be empty.' }); + } - const postTitle = async function (req, res) { - const title = new Title(); + if (!titleCodeRegex.test(title.titleCode)) { + return res.status(400).send({ message: 'Title Code must contain only upper or lower case letters.' }); + } + + // valid title name + if (!title.titleName.trim()) { + res.status(400).send({ message: 'Title cannot be empty.' }); + return; + } - title.titleName = req.body.titleName; - title.teamCode = req.body.teamCode; - title.projectAssigned = req.body.projectAssigned; - title.mediaFolder = req.body.mediaFolder; - title.teamAssiged = req.body.teamAssiged; + // if media is empty + if (!title.mediaFolder.trim()) { + res.status(400).send({ message: 'Media folder cannot be empty.' }); + return; + } + + if (!title.teamCode) { + res.status(400).send({ message: 'Please provide a team code.' }); + return; + } + + const teamCodeExists = await checkTeamCodeExists(title.teamCode); + if (!teamCodeExists) { + res.status(400).send({ message: 'Invalid team code. Please provide a valid team code.' }); + return; + } + + // validate if project exist + const projectExist = await checkProjectExists(title.projectAssigned._id); + if (!projectExist) { + res.status(400).send({ message: 'Project lalala is empty or not exist!!!' }); + return; + } + + // validate if team exist + if (title.teamAssiged && title.teamAssiged._id === 'N/A') { + res.status(400).send({ message: 'Team not exists.' }); + return; + } + + title + .save() + .then((results) => res.status(200).send(results)) + .catch((error) => res.status(404).send(error)) + }; + + // update title function. + const updateTitle = async function (req, res) { + try { + + const filter = req.body.id; // valid title name - if (!title.titleName.trim()) { + if (!req.body.titleName.trim()) { res.status(400).send({ message: 'Title cannot be empty.' }); return; } - // if media is empty - if (!title.mediaFolder.trim()) { - res.status(400).send({ message: 'Media folder cannot be empty.' }); + if (!req.body.titleCode.trim()) { + res.status(400).send({ message: 'Title code cannot be empty.' }); return; } - const shortnames = title.titleName.trim().split(' '); - let shortname; - if (shortnames.length > 1) { - shortname = (shortnames[0][0] + shortnames[1][0]).toUpperCase(); - } else if (shortnames.length === 1) { - shortname = shortnames[0][0].toUpperCase(); + const titleCodeRegex = /^[A-Za-z]+$/; + if (!titleCodeRegex.test(req.body.titleCode)) { + return res.status(400).send({ message: 'Title Code must contain only upper or lower case letters.' }); } - title.shortName = shortname; - // Validate team code by checking if it exists in the database - if (!title.teamCode) { + // if media is empty + if (!req.body.mediaFolder.trim()) { + res.status(400).send({ message: 'Media folder cannot be empty.' }); + return; + } + + if (!req.body.teamCode) { res.status(400).send({ message: 'Please provide a team code.' }); return; } - const teamCodeExists = await checkTeamCodeExists(title.teamCode); + const teamCodeExists = await checkTeamCodeExists(req.body.teamCode); if (!teamCodeExists) { res.status(400).send({ message: 'Invalid team code. Please provide a valid team code.' }); return; } // validate if project exist - const projectExist = await checkProjectExists(title.projectAssigned._id); + const projectExist = await checkProjectExists(req.body.projectAssigned._id); if (!projectExist) { - res.status(400).send({ message: 'Project is empty or not exist.' }); + res.status(400).send({ message: 'Project is empty or not exist~~~' }); return; } // validate if team exist - if (title.teamAssiged && title.teamAssiged._id === 'N/A') { + if (req.body.teamAssiged && req.body.teamAssiged._id === 'N/A') { res.status(400).send({ message: 'Team not exists.' }); return; } + const result = await Title.findById(filter); + result.titleName = req.body.titleName; + result.titleCode = req.body.titleCode; + result.teamCode = req.body.teamCode; + result.projectAssigned = req.body.projectAssigned; + result.mediaFolder = req.body.mediaFolder; + result.teamAssiged = req.body.teamAssiged; + const updatedTitle = await result.save(); + res.status(200).send({ message: 'Update successful', updatedTitle }); + + } catch (error) { + console.log(error); + res.status(500).send({ message: 'An error occurred', error }); + } + + }; + + const deleteTitleById = async function (req, res) { + const { titleId } = req.params; + Title.deleteOne({ _id: titleId }) + .then((result) => res.send(result)) + .catch((error) => res.send(error)); + }; - title - .save() - .then((results) => res.status(200).send(results)) - .catch((error) => res.status(404).send(error)); - }; - - const deleteTitleById = async function (req, res) { - const { titleId } = req.params; - Title.deleteOne({ _id: titleId }) - .then((result) => res.send(result)) - .catch((error) => res.send(error)); - }; - - const deleteAllTitles = async function (req, res) { - Title.deleteMany({}) - .then((result) => { - if (result.deletedCount === 0) { - res.send({ message: 'No titles found to delete.' }); - } else { - res.send({ message: `${result.deletedCount} titles were deleted successfully.` }); - } - }) - .catch((error) => { - res.status(500).send(error); - }); - }; - // Update: Confirmed with Jae. Team code is not related to the Team data model. But the team code field within the UserProfile data model. - async function checkTeamCodeExists(teamCode) { - try { - if (cache.getCache('teamCodes')) { - const teamCodes = JSON.parse(cache.getCache('teamCodes')); - return teamCodes.includes(teamCode); + const deleteAllTitles = async function (req, res) { + Title.deleteMany({}) + .then((result) => { + if (result.deletedCount === 0) { + res.send({ message: 'No titles found to delete.' }); + } else { + res.send({ message: `${result.deletedCount} titles were deleted successfully.` }); } - const teamCodes = await getAllTeamCodeHelper(); - return teamCodes.includes(teamCode); - } catch (error) { - console.error('Error checking if team code exists:', error); - throw error; - } - } + }) + .catch((error) => { + console.log(error) + res.status(500).send(error); + }); + }; + + - async function checkProjectExists(projectID) { - try { - const project = await Project.findOne({ _id: projectID }).exec(); - return !!project; - } catch (error) { - console.error('Error checking if project exists:', error); - throw error; - } - } return { getAllTitles, @@ -132,8 +208,8 @@ const titlecontroller = function (Title) { postTitle, deleteTitleById, deleteAllTitles, + updateTitle }; }; - module.exports = titlecontroller; - \ No newline at end of file +module.exports = titlecontroller; diff --git a/src/controllers/userProfileController.js b/src/controllers/userProfileController.js index 8226aee65..6a23dd34b 100644 --- a/src/controllers/userProfileController.js +++ b/src/controllers/userProfileController.js @@ -196,6 +196,38 @@ const userProfileController = function (UserProfile, Project) { .catch((error) => res.status(404).send(error)); }; + /** + * Controller function to retrieve basic user profile information. + * This endpoint checks if the user has the necessary permissions to access user profiles. + * If authorized, it queries the database to fetch only the required fields: + * _id, firstName, lastName, isActive, startDate, and endDate, sorted by last name. + */ + const getUserProfileBasicInfo = async function (req, res) { + if (!(await checkPermission(req, 'getUserProfiles'))) { + forbidden(res, 'You are not authorized to view all users'); + return; + } + + await UserProfile.find({}, '_id firstName lastName isActive startDate createdDate endDate') + .sort({ + lastName: 1, + }) + .then((results) => { + if (!results) { + if (cache.getCache('allusers')) { + const getData = JSON.parse(cache.getCache('allusers')); + res.status(200).send(getData); + return; + } + res.status(500).send({ error: 'User result was invalid' }); + return; + } + cache.setCache('allusers', JSON.stringify(results)); + res.status(200).send(results); + }) + .catch((error) => res.status(404).send(error)); + }; + const getProjectMembers = async function (req, res) { if (!(await hasPermission(req.body.requestor, 'getProjectMembers'))) { res.status(403).send('You are not authorized to view all users'); @@ -326,6 +358,7 @@ const userProfileController = function (UserProfile, Project) { up.adminLinks = req.body.adminLinks; up.teams = Array.from(new Set(req.body.teams)); up.projects = Array.from(new Set(req.body.projects)); + up.teamCode = req.body.teamCode; up.createdDate = req.body.createdDate; up.startDate = req.body.startDate ? req.body.startDate : req.body.createdDate; up.email = req.body.email; @@ -505,7 +538,7 @@ const userProfileController = function (UserProfile, Project) { } }); - // Since we leverage cache for all team code retrival (refer func getAllTeamCode()), + // Since we leverage cache for all team code retrival (refer func getAllTeamCode()), // we need to remove the cache when team code is updated in case of new team code generation if (req.body.teamCode) { // remove teamCode cache when new team assigned @@ -644,7 +677,7 @@ const userProfileController = function (UserProfile, Project) { } if (req.body.startDate !== undefined && record.startDate !== req.body.startDate) { - record.startDate = moment(req.body.startDate).toDate(); + record.startDate = moment.tz(req.body.startDate, 'America/Los_Angeles').toDate(); // Make sure weeklycommittedHoursHistory isn't empty if (record.weeklycommittedHoursHistory.length === 0) { const newEntry = { @@ -667,7 +700,7 @@ const userProfileController = function (UserProfile, Project) { if (req.body.endDate !== undefined) { if (yearMonthDayDateValidator(req.body.endDate)) { - record.endDate = moment(req.body.endDate).toDate(); + record.endDate = moment.tz(req.body.endDate, 'America/Los_Angeles').toDate(); if (isUserInCache) { userData.endDate = record.endDate.toISOString(); } @@ -684,12 +717,7 @@ const userProfileController = function (UserProfile, Project) { userData.startDate = record.startDate.toISOString(); } } - if ( - req.body.infringements !== undefined && - (await hasPermission(req.body.requestor, 'infringementAuthorizer')) - ) { - record.infringements = req.body.infringements; - } + let updatedDiff = null; if (PROTECTED_EMAIL_ACCOUNT.includes(record.email)) { updatedDiff = record.modifiedPaths(); @@ -727,7 +755,17 @@ const userProfileController = function (UserProfile, Project) { 'update', ); }) - .catch((error) => res.status(400).send(error)); + .catch((error) => { + if (error.name === 'ValidationError' && error.errors.lastName) { + const errors = Object.values(error.errors).map((er) => er.message); + return res.status(400).json({ + message: 'Validation Error', + error: errors, + }); + } + console.error('Failed to save record:', error); + return res.status(400).json({ error: 'Failed to save record.' }); + }); }); }; @@ -843,11 +881,11 @@ const userProfileController = function (UserProfile, Project) { const getUserById = function (req, res) { const userid = req.params.userId; - if (cache.getCache(`user-${userid}`)) { - const getData = JSON.parse(cache.getCache(`user-${userid}`)); - res.status(200).send(getData); - return; - } + // if (cache.getCache(`user-${userid}`)) { + // const getData = JSON.parse(cache.getCache(`user-${userid}`)); + // res.status(200).send(getData); + // return; + // } UserProfile.findById(userid, '-password -refreshTokens -lastModifiedDate -__v') .populate([ @@ -877,6 +915,15 @@ const userProfileController = function (UserProfile, Project) { select: '_id badgeName type imageUrl description ranking showReport', }, }, + { + path: 'infringements', // Populate infringements field + select: 'date description', + options: { + sort: { + date: -1, // Sort by date descending if needed + }, + }, + }, ]) .exec() .then((results) => { @@ -1021,7 +1068,7 @@ const userProfileController = function (UserProfile, Project) { const hasUpdatePasswordPermission = await hasPermission(requestor, 'updatePassword'); // if they're updating someone else's password, they need the 'updatePassword' permission. - if (!hasUpdatePasswordPermission) { + if (userId !== requestor.requestorId && !hasUpdatePasswordPermission) { return res.status(403).send({ error: "You are unauthorized to update this user's password", }); @@ -1156,7 +1203,18 @@ const userProfileController = function (UserProfile, Project) { const activationDate = req.body.reactivationDate; const { endDate } = req.body; const isSet = req.body.isSet === 'FinalDay'; - + let activeStatus = status; + let emailThreeWeeksSent = false; + if (endDate && status) { + const dateObject = new Date(endDate); + dateObject.setHours(dateObject.getHours() + 7); + const setEndDate = dateObject; + if (moment().isAfter(moment(setEndDate).add(1, 'days'))) { + activeStatus = false; + } else if (moment().isBefore(moment(endDate).subtract(3, 'weeks'))) { + emailThreeWeeksSent = true; + } + } if (!mongoose.Types.ObjectId.isValid(userId)) { res.status(400).send({ error: 'Bad Request', @@ -1202,13 +1260,14 @@ const userProfileController = function (UserProfile, Project) { logger.logException(err, 'Unexpected error in finding menagement team'); } - UserProfile.findById(userId, 'isActive email firstName lastName') + UserProfile.findById(userId, 'isActive email firstName lastName finalEmailThreeWeeksSent') .then((user) => { user.set({ - isActive: status, + isActive: activeStatus, reactivationDate: activationDate, endDate, isSet, + finalEmailThreeWeeksSent: emailThreeWeeksSent, }); user .save() @@ -1232,6 +1291,8 @@ const userProfileController = function (UserProfile, Project) { user.email, recipients, isSet, + activationDate, + emailThreeWeeksSent, ); auditIfProtectedAccountUpdated( req.body.requestor.requestorId, @@ -1432,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'); @@ -1496,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; @@ -1539,6 +1575,155 @@ const userProfileController = function (UserProfile, Project) { } }; + const addInfringements = async function (req, res) { + if (!(await hasPermission(req.body.requestor, 'addInfringements'))) { + res.status(403).send('You are not authorized to add blue square'); + return; + } + const userid = req.params.userId; + + cache.removeCache(`user-${userid}`); + + if (req.body.blueSquare === undefined) { + res.status(400).send('Invalid Data'); + return; + } + + UserProfile.findById(userid, async (err, record) => { + if (err || !record) { + res.status(404).send('No valid records found'); + return; + } + // find userData in cache + const isUserInCache = cache.hasCache('allusers'); + let allUserData; + let userData; + let userIdx; + if (isUserInCache) { + allUserData = JSON.parse(cache.getCache('allusers')); + userIdx = allUserData.findIndex((users) => users._id === userid); + userData = allUserData[userIdx]; + } + + const originalinfringements = record?.infringements ?? []; + record.infringements = originalinfringements.concat(req.body.blueSquare); + + record + .save() + .then((results) => { + userHelper.notifyInfringements( + originalinfringements, + results.infringements, + results.firstName, + results.lastName, + results.email, + results.role, + results.startDate, + results.jobTitle[0], + results.weeklycommittedHours, + ); + res.status(200).json({ + _id: record._id, + }); + + // update alluser cache if we have cache + if (isUserInCache) { + allUserData.splice(userIdx, 1, userData); + cache.setCache('allusers', JSON.stringify(allUserData)); + } + }) + .catch((error) => res.status(400).send(error)); + }); + }; + + const editInfringements = async function (req, res) { + if (!(await hasPermission(req.body.requestor, 'editInfringements'))) { + res.status(403).send('You are not authorized to edit blue square'); + return; + } + const { userId, blueSquareId } = req.params; + const { dateStamp, summary } = req.body; + + UserProfile.findById(userId, async (err, record) => { + if (err || !record) { + res.status(404).send('No valid records found'); + return; + } + + const originalinfringements = record?.infringements ?? []; + + record.infringements = originalinfringements.map((blueSquare) => { + if (blueSquare._id.equals(blueSquareId)) { + blueSquare.date = dateStamp ?? blueSquare.date; + blueSquare.description = summary ?? blueSquare.description; + } + return blueSquare; + }); + + record + .save() + .then((results) => { + userHelper.notifyInfringements( + originalinfringements, + results.infringements, + results.firstName, + results.lastName, + results.email, + results.role, + results.startDate, + results.jobTitle[0], + results.weeklycommittedHours, + ); + res.status(200).json({ + _id: record._id, + }); + }) + .catch((error) => res.status(400).send(error)); + }); + }; + + const deleteInfringements = async function (req, res) { + if (!(await hasPermission(req.body.requestor, 'deleteInfringements'))) { + res.status(403).send('You are not authorized to delete blue square'); + return; + } + const { userId, blueSquareId } = req.params; + // console.log(userId, blueSquareId); + + UserProfile.findById(userId, async (err, record) => { + if (err || !record) { + res.status(404).send('No valid records found'); + return; + } + + const originalinfringements = record?.infringements ?? []; + + record.infringements = originalinfringements.filter( + (infringement) => !infringement._id.equals(blueSquareId), + ); + + record + .save() + .then((results) => { + userHelper.notifyInfringements( + originalinfringements, + results.infringements, + results.firstName, + results.lastName, + results.email, + results.role, + results.startDate, + results.jobTitle[0], + results.weeklycommittedHours, + ); + res.status(200).json({ + _id: record._id, + }); + }) + .catch((error) => res.status(400).send(error)); + }); + }; + const getProjectsByPerson = async function (req, res) { try { const { name } = req.params; @@ -1548,28 +1733,28 @@ const userProfileController = function (UserProfile, Project) { const query = match[1] ? { - $or: [ - { - firstName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, - }, - { - $and: [ - { firstName: { $regex: new RegExp(`${escapeRegExp(firstName)}`, 'i') } }, - { lastName: { $regex: new RegExp(`${escapeRegExp(lastName)}`, 'i') } }, - ], - }, - ], - } + $or: [ + { + firstName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, + }, + { + $and: [ + { firstName: { $regex: new RegExp(`${escapeRegExp(firstName)}`, 'i') } }, + { lastName: { $regex: new RegExp(`${escapeRegExp(lastName)}`, 'i') } }, + ], + }, + ], + } : { - $or: [ - { - firstName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, - }, - { - lastName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, - }, - ], - }; + $or: [ + { + firstName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, + }, + { + lastName: { $regex: new RegExp(`${escapeRegExp(name)}`, 'i') }, + }, + ], + }; const userProfile = await UserProfile.find(query); @@ -1597,21 +1782,74 @@ const userProfileController = function (UserProfile, Project) { return teamCodes; } const distinctTeamCodes = await UserProfile.distinct('teamCode', { - teamCode: { $ne: null } + teamCode: { $ne: null }, }); cache.setCache('teamCodes', JSON.stringify(distinctTeamCodes)); return distinctTeamCodes; } catch (error) { throw new Error('Encountered an error to get all team codes, please try again!'); } - } + }; const getAllTeamCode = async function (req, res) { try { const distinctTeamCodes = await getAllTeamCodeHelper(); return res.status(200).send({ message: 'Found', distinctTeamCodes }); } catch (error) { - return res.status(500).send({ message: 'Encountered an error to get all team codes, please try again!' }); + return res + .status(500) + .send({ message: 'Encountered an error to get all team codes, please try again!' }); + } + }; + + const getUserByAutocomplete = (req, res) => { + const { searchText } = req.params; + + if (!searchText) { + return res.status(400).send({ message: 'Search text is required' }); + } + + const regex = new RegExp(searchText, 'i'); // Case-insensitive regex for partial matching + + UserProfile.find( + { + $or: [ + { firstName: { $regex: regex } }, + { lastName: { $regex: regex } }, + { + $expr: { + $regexMatch: { + input: { $concat: ['$firstName', ' ', '$lastName'] }, + regex: searchText, + options: 'i', + }, + }, + }, + ], + }, + '_id firstName lastName', // Projection to limit fields returned + ) + .limit(10) // Limit results for performance + .then((results) => { + res.status(200).send(results); + }) + .catch(() => { + res.status(500).send({ error: 'Internal Server Error' }); + }); + }; + + const updateUserInformation = async function (req,res){ + try { + const data=req.body; + data.map(async (e)=> { + const result = await UserProfile.findById(e.user_id); + result[e.item]=e.value + await result.save(); + }) + res.status(200).send({ message: 'Update successful'}); + } catch (error) { + console.log(error) + return res.status(500) } } @@ -1637,9 +1875,15 @@ const userProfileController = function (UserProfile, Project) { getUserByFullName, changeUserRehireableStatus, authorizeUser, + addInfringements, + editInfringements, + deleteInfringements, getProjectsByPerson, getAllTeamCode, getAllTeamCodeHelper, + getUserByAutocomplete, + getUserProfileBasicInfo, + updateUserInformation, }; }; diff --git a/src/controllers/warningsController.js b/src/controllers/warningsController.js index 381844883..08515c207 100644 --- a/src/controllers/warningsController.js +++ b/src/controllers/warningsController.js @@ -1,22 +1,45 @@ /* eslint-disable */ const mongoose = require('mongoose'); const userProfile = require('../models/userProfile'); +const currentWarnings = require('../models/currentWarnings'); +const emailSender = require('../utilities/emailSender'); +const userHelper = require('../helpers/userHelper')(); +let currentWarningDescriptions = null; +let currentUserName = null; +const emailTemplate = { + thirdWarning: { + subject: 'Third Warning', + body: `This is the 3rd time the Admin team has requested the same thing from you. Specifically <“tracked area”>. Please carefully review the communications you’ve gotten about this so you understand what is being requested. Ask questions if anything isn’t clear, the Admin team is here to help.
+Please also be sure to fix this from here on forward, asking for the same thing over and over requires administration that really shouldn’t be needed and will result in a blue square if it happens again.
+With Gratitude,
+One Community
`, + }, + fourthWarning: { + subject: 'Fourth Warning', + body: `username !
+This is the 3rd time the Admin team has requested the same thing from you. Specifically <“tracked area”>. Please carefully review the communications you’ve gotten about this so you understand what is being requested. Ask questions if anything isn’t clear, the Admin team is here to help.
+Please also be sure to fix this from here on forward, asking for the same thing over and over requires administration that really shouldn’t be needed and will result in a blue square if it happens again.
+With Gratitude,
+One Community
`, + }, +}; +async function getWarningDescriptions() { + currentWarningDescriptions = await currentWarnings.find({}, { warningTitle: 1, _id: 0 }); +} -const descriptions = [ - 'Better Descriptions', - 'Log Time to Tasks', - 'Log Time as You Go', - 'Log Time to Action Items', - 'Intangible Time Log w/o Reason', -]; const warningsController = function (UserProfile) { const getWarningsByUserId = async function (req, res) { + currentWarningDescriptions = await currentWarnings.find({ + activeWarning: true, + }); + + currentWarningDescriptions = currentWarningDescriptions.map((a) => a.warningTitle); const { userId } = req.params; try { const { warnings } = await UserProfile.findById(userId); - const completedData = filterWarnings(warnings); + const { completedData } = filterWarnings(currentWarningDescriptions, warnings); if (!warnings) { return res.status(400).send({ message: 'no valiud records' }); @@ -32,13 +55,20 @@ const warningsController = function (UserProfile) { const { userId } = req.params; const { iconId, color, date, description } = req.body; + const { monitorData } = req.body; const record = await UserProfile.findById(userId); if (!record) { return res.status(400).send({ message: 'No valid records found' }); } - const updatedWarnings = await userProfile.findByIdAndUpdate( + const userAssignedWarning = { + firstName: record.firstName, + lastName: record.lastName, + email: record.email, + }; + + const updatedWarnings = await UserProfile.findByIdAndUpdate( { _id: userId, }, @@ -46,7 +76,24 @@ const warningsController = function (UserProfile) { { new: true, upsert: true }, ); - const completedData = filterWarnings(updatedWarnings.warnings); + const { completedData, sendEmail, size } = filterWarnings( + currentWarningDescriptions, + updatedWarnings.warnings, + iconId, + color, + ); + + const adminEmails = await getUserRoleByEmail(record); + if (sendEmail !== null) { + sendEmailToUser( + sendEmail, + description, + userAssignedWarning, + monitorData, + size, + adminEmails, + ); + } res.status(201).send({ message: 'success', warnings: completedData }); } catch (error) { @@ -69,8 +116,8 @@ const warningsController = function (UserProfile) { return res.status(400).send({ message: 'no valid records' }); } - const sortedWarnings = filterWarnings(warnings.warnings); - res.status(201).send({ message: 'succesfully deleted', warnings: sortedWarnings }); + const { completedData } = filterWarnings(currentWarningDescriptions, warnings.warnings); + res.status(201).send({ message: 'succesfully deleted', warnings: completedData }); } catch (error) { res.status(401).send({ message: error.message || error }); } @@ -83,19 +130,80 @@ const warningsController = function (UserProfile) { }; }; -// gests the dsecriptions key from the array -const getDescriptionKey = (val) => { - const descriptions = [ - 'Better Descriptions', - 'Log Time to Tasks', - 'Log Time as You Go', - 'Log Time to Action Items', - 'Intangible Time Log w/o Reason', - ]; - - return descriptions.indexOf(val); +//helper to get the team members admin emails +async function getUserRoleByEmail(user) { + //replacement for jae's email + const recipients = ['test@test.com']; + for (const teamId of user.teams) { + const managementEmails = await userHelper.getTeamManagementEmail(teamId); + if (Array.isArray(managementEmails) && managementEmails.length > 0) { + managementEmails.forEach((management) => { + recipients.push(management.email); + }); + } + } + + return [...new Set(recipients)]; +} + +//helper function to get the ordinal +function getOrdinal(n) { + const suffixes = ['th', 'st', 'nd', 'rd']; + const value = n % 100; + return n + (suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0]); +} +const sendEmailToUser = ( + sendEmail, + warningDescription, + userAssignedWarning, + monitorData, + size, + adminEmails, +) => { + const ordinal = getOrdinal(size); + const subjectTitle = ordinal + ' Warning'; + + const currentUserName = `${userAssignedWarning.firstName} ${userAssignedWarning.lastName}`; + const emailTemplate = + sendEmail === 'issue warning' + ? `Hello ${currentUserName},
+This is the ${ordinal} time the Admin team has requested the same thing from you. Specifically, ${warningDescription}. Please carefully review the previous communications you’ve received to fully understand what is being requested. If anything is unclear, don’t hesitate to ask questions—the Admin team is here to assist.
+Moving forward, please ensure this issue is resolved. Repeated requests for the same thing require unnecessary administrative attention and may result in a blue square being issued if it happens again.
+The Admin member who issued the warning is ${monitorData.firstName} ${monitorData.lastName} and their email is ${monitorData.email}. Please comment on your Google Doc and tag them using this email if you have any questions.
+With Gratitude,
+One Community
` + : `Hello ${currentUserName},
+A blue square has been issued because this is the ${ordinal} time the Admin team has requested the same thing from you. Specifically, ${warningDescription}.
+Moving forward, please ensure this is resolved. Repeated requests for the same thing require unnecessary administrative attention, will result in an additional blue square being issued, and could lead to termination.
+Please carefully review the previous communications you’ve received to fully understand what is being requested. If anything is unclear, feel free to ask questions—the Admin team is here to help.
+The Admin member who issued this blue square is ${monitorData.firstName} ${monitorData.lastName} and can be reached at ${monitorData.email}. If you have any questions, please comment on your Google Doc and tag them using this email.
+With Gratitude,
+One Community
`; + + if (sendEmail === 'issue warning') { + emailSender( + `${userAssignedWarning.email}`, + subjectTitle, + emailTemplate, + null, + adminEmails.toString(), + null, + ); + } else if (sendEmail === 'issue blue square') { + emailSender( + `${userAssignedWarning.email}`, + `Blue Square issued for ${warningDescription}`, + null, + emailTemplate, + adminEmails.toString(), + null, + ); + } }; +// gets the dsecriptions key from the array +const getDescriptionKey = (val) => currentWarningDescriptions.indexOf(val); + const sortKeysAlphabetically = (a, b) => getDescriptionKey(a) - getDescriptionKey(b); // method to see which color is first @@ -118,14 +226,29 @@ const sortByColorAndDate = (a, b) => { return colorComparison; }; -const filterWarnings = (warnings) => { +const filterWarnings = (currentWarningDescriptions, warnings, iconId = null, color = null) => { const warningsObject = {}; + let sendEmail = null; + let size = null; + warnings.forEach((warning) => { if (!warningsObject[warning.description]) { warningsObject[warning.description] = []; } warningsObject[warning.description].push(warning); + + if ( + warningsObject[warning.description].length >= 3 && + warning.iconId === iconId && + color === 'yellow' + ) { + sendEmail = 'issue warning'; + size = warningsObject[warning.description].length; + } else if (warning.iconId === iconId && color === 'red') { + sendEmail = 'issue blue square'; + size = warningsObject[warning.description].length; + } }); const warns = Object.keys(warningsObject) @@ -141,13 +264,13 @@ const filterWarnings = (warnings) => { const completedData = []; - for (const descrip of descriptions) { + for (const descrip of currentWarningDescriptions) { completedData.push({ title: descrip, warnings: warns[descrip] ? warns[descrip] : [], }); } - return completedData; + return { completedData, sendEmail, size }; }; module.exports = warningsController; diff --git a/src/cronjobs/userProfileJobs.js b/src/cronjobs/userProfileJobs.js index f0f69e146..e773847d2 100644 --- a/src/cronjobs/userProfileJobs.js +++ b/src/cronjobs/userProfileJobs.js @@ -11,6 +11,7 @@ const userProfileJobs = () => { async () => { const SUNDAY = 0; // will change back to 0 after fix if (moment().tz('America/Los_Angeles').day() === SUNDAY) { + console.log('Running Cron Jobs'); await userhelper.assignBlueSquareForTimeNotMet(); await userhelper.applyMissedHourForCoreTeam(); await userhelper.emailWeeklySummariesForAllUsers(); @@ -19,6 +20,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 +38,6 @@ const userProfileJobs = () => { ); allUserProfileJobs.start(); + dailyUserDeactivateJobs.start(); }; module.exports = userProfileJobs; diff --git a/src/helpers/dashboardhelper.js b/src/helpers/dashboardhelper.js index 533dbe367..dddb7cca2 100644 --- a/src/helpers/dashboardhelper.js +++ b/src/helpers/dashboardhelper.js @@ -181,14 +181,11 @@ const dashboardhelper = function () { _myTeam.members.forEach((teamMember) => { if (teamMember.userId.equals(userid) && teamMember.visible) isUserVisible = true; }); - if(isUserVisible) - { + if (isUserVisible) { _myTeam.members.forEach((teamMember) => { - if (!teamMember.userId.equals(userid)) - teamMemberIds.push(teamMember.userId); - }); - } - + if (!teamMember.userId.equals(userid)) teamMemberIds.push(teamMember.userId); + }); + } }); teamMembers = await userProfile.find( @@ -203,8 +200,8 @@ const dashboardhelper = function () { timeOffFrom: 1, timeOffTill: 1, endDate: 1, - } - + missedHours: 1, + }, ); } else { // 'Core Team', 'Owner' //All users @@ -220,7 +217,7 @@ const dashboardhelper = function () { timeOffFrom: 1, timeOffTill: 1, endDate: 1, - + missedHours: 1, }, ); } @@ -269,6 +266,7 @@ const dashboardhelper = function () { ? teamMember.weeklySummaries[0].summary !== '' : false, weeklycommittedHours: teamMember.weeklycommittedHours, + missedHours: teamMember.missedHours ?? 0, totaltangibletime_hrs: (timeEntryByPerson[teamMember._id.toString()]?.tangibleSeconds ?? 0) / 3600, totalintangibletime_hrs: @@ -309,255 +307,6 @@ const dashboardhelper = function () { console.log(error); return new Error(error); } - - // return myTeam.aggregate([ - // { - // $match: { - // _id: userid, - // }, - // }, - // { - // $unwind: '$myteam', - // }, - // { - // $project: { - // _id: 0, - // role: 1, - // personId: '$myteam._id', - // name: '$myteam.fullName', - // }, - // }, - // { - // $lookup: { - // from: 'userProfiles', - // localField: 'personId', - // foreignField: '_id', - // as: 'persondata', - // }, - // }, - // { - // $match: { - // // leaderboard user roles hierarchy - // $or: [ - // { - // role: { $in: ['Owner', 'Core Team'] }, - // }, - // { - // $and: [ - // { - // role: 'Administrator', - // }, - // { 'persondata.0.role': { $nin: ['Owner', 'Administrator'] } }, - // ], - // }, - // { - // $and: [ - // { - // role: { $in: ['Manager', 'Mentor'] }, - // }, - // { - // 'persondata.0.role': { - // $nin: ['Manager', 'Mentor', 'Core Team', 'Administrator', 'Owner'], - // }, - // }, - // ], - // }, - // { 'persondata.0._id': userId }, - // { 'persondata.0.role': 'Volunteer' }, - // { 'persondata.0.isVisible': true }, - // ], - // }, - // }, - // { - // $project: { - // personId: 1, - // name: 1, - // role: { - // $arrayElemAt: ['$persondata.role', 0], - // }, - // isVisible: { - // $arrayElemAt: ['$persondata.isVisible', 0], - // }, - // hasSummary: { - // $ne: [ - // { - // $arrayElemAt: [ - // { - // $arrayElemAt: ['$persondata.weeklySummaries.summary', 0], - // }, - // 0, - // ], - // }, - // '', - // ], - // }, - // weeklycommittedHours: { - // $sum: [ - // { - // $arrayElemAt: ['$persondata.weeklycommittedHours', 0], - // }, - // { - // $ifNull: [{ $arrayElemAt: ['$persondata.missedHours', 0] }, 0], - // }, - // ], - // }, - // }, - // }, - // { - // $lookup: { - // from: 'timeEntries', - // localField: 'personId', - // foreignField: 'personId', - // as: 'timeEntryData', - // }, - // }, - // { - // $project: { - // personId: 1, - // name: 1, - // role: 1, - // isVisible: 1, - // hasSummary: 1, - // weeklycommittedHours: 1, - // timeEntryData: { - // $filter: { - // input: '$timeEntryData', - // as: 'timeentry', - // cond: { - // $and: [ - // { - // $gte: ['$$timeentry.dateOfWork', pdtstart], - // }, - // { - // $lte: ['$$timeentry.dateOfWork', pdtend], - // }, - // ], - // }, - // }, - // }, - // }, - // }, - // { - // $unwind: { - // path: '$timeEntryData', - // preserveNullAndEmptyArrays: true, - // }, - // }, - // { - // $project: { - // personId: 1, - // name: 1, - // role: 1, - // isVisible: 1, - // hasSummary: 1, - // weeklycommittedHours: 1, - // totalSeconds: { - // $cond: [ - // { - // $gte: ['$timeEntryData.totalSeconds', 0], - // }, - // '$timeEntryData.totalSeconds', - // 0, - // ], - // }, - // isTangible: { - // $cond: [ - // { - // $gte: ['$timeEntryData.totalSeconds', 0], - // }, - // '$timeEntryData.isTangible', - // false, - // ], - // }, - // }, - // }, - // { - // $addFields: { - // tangibletime: { - // $cond: [ - // { - // $eq: ['$isTangible', true], - // }, - // '$totalSeconds', - // 0, - // ], - // }, - // intangibletime: { - // $cond: [ - // { - // $eq: ['$isTangible', false], - // }, - // '$totalSeconds', - // 0, - // ], - // }, - // }, - // }, - // { - // $group: { - // _id: { - // personId: '$personId', - // weeklycommittedHours: '$weeklycommittedHours', - // name: '$name', - // role: '$role', - // isVisible: '$isVisible', - // hasSummary: '$hasSummary', - // }, - // totalSeconds: { - // $sum: '$totalSeconds', - // }, - // tangibletime: { - // $sum: '$tangibletime', - // }, - // intangibletime: { - // $sum: '$intangibletime', - // }, - // }, - // }, - // { - // $project: { - // _id: 0, - // personId: '$_id.personId', - // name: '$_id.name', - // role: '$_id.role', - // isVisible: '$_id.isVisible', - // hasSummary: '$_id.hasSummary', - // weeklycommittedHours: '$_id.weeklycommittedHours', - // totaltime_hrs: { - // $divide: ['$totalSeconds', 3600], - // }, - // totaltangibletime_hrs: { - // $divide: ['$tangibletime', 3600], - // }, - // totalintangibletime_hrs: { - // $divide: ['$intangibletime', 3600], - // }, - // percentagespentintangible: { - // $cond: [ - // { - // $eq: ['$totalSeconds', 0], - // }, - // 0, - // { - // $multiply: [ - // { - // $divide: ['$tangibletime', '$totalSeconds'], - // }, - // 100, - // ], - // }, - // ], - // }, - // }, - // }, - // { - // $sort: { - // totaltangibletime_hrs: -1, - // name: 1, - // role: 1, - // }, - // }, - // ]); }; /** diff --git a/src/helpers/taskHelper.js b/src/helpers/taskHelper.js index 34fb36be8..fefa9f021 100644 --- a/src/helpers/taskHelper.js +++ b/src/helpers/taskHelper.js @@ -112,9 +112,15 @@ const taskHelper = function () { ); sharedTeamsResult.forEach((_myTeam) => { + let hasTeamVisibility = false; _myTeam.members.forEach((teamMember) => { - if (!teamMember.userId.equals(userid)) teamMemberIds.push(teamMember.userId); + if (teamMember.userId.equals(userid) && teamMember.visible) hasTeamVisibility = true; }); + if (hasTeamVisibility) { + _myTeam.members.forEach((teamMember) => { + if (!teamMember.userId.equals(userid)) teamMemberIds.push(teamMember.userId); + }); + } }); teamMembers = await userProfile diff --git a/src/helpers/userHelper.js b/src/helpers/userHelper.js index ed9c52131..168d704b1 100644 --- a/src/helpers/userHelper.js +++ b/src/helpers/userHelper.js @@ -146,14 +146,14 @@ const userHelper = function () { .localeData() .ordinal( totalInfringements, - )} blue square of 5 and that means you have ${totalInfringements - 5} hour(s) added to your - requirement this week. This is in addition to any hours missed for last week: - ${weeklycommittedHours} hours commitment + ${remainHr} hours owed for last week + ${totalInfringements - 5} hours + )} blue square of 5 and that means you have ${totalInfringements - 5} hour(s) added to your + requirement this week. This is in addition to any hours missed for last week: + ${weeklycommittedHours} hours commitment + ${remainHr} hours owed for last week + ${totalInfringements - 5} hours owed for this being your ${moment .localeData() .ordinal( totalInfringements, - )} blue square = ${hrThisweek + totalInfringements - 5} hours required for this week. + )} blue square = ${hrThisweek + totalInfringements - 5} hours required for this week. .`; } // bold description for 'System auto-assigned infringement for two reasons ....' and 'not submitting a weekly summary' and logged hrs @@ -204,7 +204,7 @@ const userHelper = function () {One Community
-ADMINISTRATIVE DETAILS:
Start Date: ${administrativeContent.startDate}
Role: ${administrativeContent.role}
@@ -656,7 +656,7 @@ const userHelper = function () { } // No extra hours is needed if blue squares isn't over 5. // length +1 is because new infringement hasn't been created at this stage. - const coreTeamExtraHour = Math.max(0, oldInfringements.length - 5); + const coreTeamExtraHour = Math.max(0, oldInfringements.length + 1 - 5); const utcStartMoment = moment(pdtStartOfLastWeek).add(1, 'second'); const utcEndMoment = moment(pdtEndOfLastWeek).subtract(1, 'day').subtract(1, 'second'); @@ -703,7 +703,7 @@ const userHelper = function () { .localeData() .ordinal( oldInfringements.length + 1, - )} blue square. So you should have completed ${weeklycommittedHours} hours and you completed ${timeSpent.toFixed( + )} blue square. So you should have completed ${weeklycommittedHours + coreTeamExtraHour} hours and you completed ${timeSpent.toFixed( 2, )} hours.`; } else { @@ -727,7 +727,7 @@ const userHelper = function () { .localeData() .ordinal( oldInfringements.length + 1, - )} blue square. So you should have completed ${weeklycommittedHours} hours and you completed ${timeSpent.toFixed( + )} blue square. So you should have completed ${weeklycommittedHours + coreTeamExtraHour} hours and you completed ${timeSpent.toFixed( 2, )} hours.`; } else { @@ -956,29 +956,54 @@ const userHelper = function () { $project: { _id: 1, missedHours: { - $max: [ - { - $subtract: [ - { - $sum: [{ $ifNull: ['$missedHours', 0] }, '$weeklycommittedHours'], - }, - { - $divide: [ - { - $sum: { - $map: { - input: '$timeEntries', - in: '$$this.totalSeconds', - }, + $let: { + vars: { + baseMissedHours: { + $max: [ + { + $subtract: [ + { + $sum: [{ $ifNull: ['$missedHours', 0] }, '$weeklycommittedHours'], }, - }, - 3600, - ], - }, + { + $divide: [ + { + $sum: { + $map: { + input: '$timeEntries', + in: '$$this.totalSeconds', + }, + }, + }, + 3600, + ], + }, + ], + }, + 0, + ], + }, + infringementsAdjustment: { + $cond: [ + { + $and: [ + { $gt: ['$infringements', null] }, + { $gt: [{ $size: '$infringements' }, 5] }, + ], + }, + { $subtract: [{ $size: '$infringements' }, 5] }, + 0, + ], + }, + }, + in: { + $cond: [ + { $gt: ['$$baseMissedHours', 0] }, + { $add: ['$$baseMissedHours', '$$infringementsAdjustment'] }, + '$$baseMissedHours', ], }, - 0, - ], + }, }, }, }, @@ -1024,7 +1049,7 @@ const userHelper = function () { }, ); - logger.logInfo(`Job deleting blue squares older than 1 year finished + logger.logInfo(`Job deleting blue squares older than 1 year finished at ${moment().tz('America/Los_Angeles').format()} \nReulst: ${JSON.stringify(results)}`); } catch (err) { logger.logException(err); @@ -1074,11 +1099,11 @@ const userHelper = function () { const emailBody = `Hi Admin!
This email is to let you know that ${person.firstName} ${person.lastName} has been made active again in the Highest Good Network application after being paused on ${endDate}.
- +If you need to communicate anything with them, this is their email from the system: ${person.email}.
- +Thanks!
- +The HGN A.I. (and One Community)
`; emailSender('onecommunityglobal@gmail.com', subject, emailBody, null, null, person.email); @@ -2037,33 +2062,71 @@ const userHelper = function () { email, recipients, isSet, + reactivationDate, + sendThreeWeeks, + followup, ) { - if (endDate && !isSet) { - const subject = `IMPORTANT: ${firstName} ${lastName} has been deactivated in the Highest Good Network`; - const emailBody = `Management,
+ let subject; + let emailBody; + recipients.push('onecommunityglobal@gmail.com'); + recipients = recipients.toString(); + if (reactivationDate) { + subject = `IMPORTANT: ${firstName} ${lastName} has been PAUSED in the Highest Good Network`; + emailBody = `Management,
+ +Please note that ${firstName} ${lastName} has been PAUSED in the Highest Good Network as ${moment(endDate).format('M-D-YYYY')}.
+For a smooth transition, Please confirm all your work with this individual has been wrapped up and nothing further is needed on their part until they return on ${moment(reactivationDate).format('M-D-YYYY')}.
-Please note that ${firstName} ${lastName} has been made inactive in the Highest Good Network as of ${endDate}. - Please confirm all your work with this individual has been wrapped up and nothing further is needed on their part.
-With Gratitude,
- +One Community
`; - recipients.push('onecommunityglobal@gmail.com'); - recipients = recipients.toString(); - emailSender(recipients, subject, emailBody, null, null, email); - } else if (isSet) { - const subject = `IMPORTANT: ${firstName} ${lastName} has been deactivated in the Highest Good Network`; + emailSender(email, subject, emailBody, null, recipients, email); + } else if (endDate && isSet && sendThreeWeeks) { + const subject = `IMPORTANT: The last day for ${firstName} ${lastName} has been set in the Highest Good Network`; const emailBody = `Management,
-Please note that the final day for ${firstName} ${lastName} has been set in the Highest Good Network ${endDate}. - For a smooth transition, please confirm all your work is being wrapped up with this individual and nothing further will be needed on their part after this date.
- +Please note that the final day for ${firstName} ${lastName} has been set in the Highest Good Network as ${moment(endDate).format('M-D-YYYY')}.
+This is more than 3 weeks from now, but you should still start confirming all your work is being wrapped up with this individual and nothing further will be needed on their part after this date.
+ +An additional reminder email will be sent in their final 2 weeks.
+ +With Gratitude,
+ +One Community
`; + emailSender(email, subject, emailBody, null, recipients, email); + } else if (endDate && isSet && followup) { + subject = `IMPORTANT: The last day for ${firstName} ${lastName} has been set in the Highest Good Network`; + emailBody = `Management,
+ +Please note that the final day for ${firstName} ${lastName} has been set in the Highest Good Network as ${moment(endDate).format('M-D-YYYY')}.
+This is coming up soon. For a smooth transition, please confirm all your work is wrapped up with this individual and nothing further will be needed on their part after this date.
+ +With Gratitude,
+ +One Community
`; + emailSender(email, subject, emailBody, null, recipients, email); + } else if (endDate && isSet) { + subject = `IMPORTANT: The last day for ${firstName} ${lastName} has been set in the Highest Good Network`; + emailBody = `Management,
+ +Please note that the final day for ${firstName} ${lastName} has been set in the Highest Good Network as ${moment(endDate).format('M-D-YYYY')}.
+For a smooth transition, Please confirm all your work with this individual has been wrapped up and nothing further is needed on their part.
+With Gratitude,
- + +One Community
`; + emailSender(email, subject, emailBody, null, recipients, email); + } else if (endDate) { + subject = `IMPORTANT: ${firstName} ${lastName} has been deactivated in the Highest Good Network`; + emailBody = `Management,
+ +Please note that ${firstName} ${lastName} has been made inactive in the Highest Good Network as ${moment(endDate).format('M-D-YYYY')}.
+For a smooth transition, Please confirm all your work with this individual has been wrapped up and nothing further is needed on their part.
+ +With Gratitude,
+One Community
`; - recipients.push('onecommunityglobal@gmail.com'); - recipients = recipients.toString(); - emailSender(recipients, subject, emailBody, null, null, email); + emailSender(email, subject, emailBody, null, recipients, email); } }; @@ -2076,13 +2139,42 @@ const userHelper = function () { const recipients = emailReceivers.map((receiver) => receiver.email); const users = await userProfile.find( { isActive: true, endDate: { $exists: true } }, - '_id isActive endDate isSet', + '_id isActive endDate isSet finalEmailThreeWeeksSent reactivationDate', ); for (let i = 0; i < users.length; i += 1) { const user = users[i]; - const { endDate } = user; + const { endDate, finalEmailThreeWeeksSent } = user; endDate.setHours(endDate.getHours() + 7); - if (moment().isAfter(moment(endDate).add(1, 'days'))) { + // notify reminder set final day before 2 weeks + if ( + finalEmailThreeWeeksSent && + moment().isBefore(moment(endDate).subtract(2, 'weeks')) && + moment().isAfter(moment(endDate).subtract(3, 'weeks')) + ) { + const id = user._id; + const person = await userProfile.findById(id); + const lastDay = moment(person.endDate).format('YYYY-MM-DD'); + logger.logInfo(`User with id: ${user._id}'s final Day is set at ${moment().format()}.`); + person.teams.map(async (teamId) => { + const managementEmails = await userHelper.getTeamManagementEmail(teamId); + if (Array.isArray(managementEmails) && managementEmails.length > 0) { + managementEmails.forEach((management) => { + recipients.push(management.email); + }); + } + }); + sendDeactivateEmailBody( + person.firstName, + person.lastName, + lastDay, + person.email, + recipients, + person.isSet, + person.reactivationDate, + false, + true, + ); + } else if (moment().isAfter(moment(endDate).add(1, 'days'))) { try { await userProfile.findByIdAndUpdate( user._id, @@ -2115,6 +2207,8 @@ const userHelper = function () { person.email, recipients, person.isSet, + person.reactivationDate, + undefined, ); } } diff --git a/src/models/currentWarnings.js b/src/models/currentWarnings.js new file mode 100644 index 000000000..18a446199 --- /dev/null +++ b/src/models/currentWarnings.js @@ -0,0 +1,11 @@ +const mongoose = require('mongoose'); + +const { Schema } = mongoose; + +const currentWarnings = new Schema({ + warningTitle: { type: String, required: true }, + activeWarning: { type: Boolean, required: true }, + isPermanent: { type: Boolean, required: true }, +}); + +module.exports = mongoose.model('currentWarning', currentWarnings, 'currentWarnings'); 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/models/team.js b/src/models/team.js index 4d73615f5..109d93221 100644 --- a/src/models/team.js +++ b/src/models/team.js @@ -3,9 +3,9 @@ const mongoose = require('mongoose'); const { Schema } = mongoose; /** - * This schema represents a team in the system. - * - * Deprecated field: teamCode. Team code is no longer associated with a team. + * This schema represents a team in the system. + * + * Deprecated field: teamCode. Team code is no longer associated with a team. * Team code is used as a text string identifier in the user profile data model. */ const team = new Schema({ @@ -15,9 +15,10 @@ const team = new Schema({ modifiedDatetime: { type: Date, default: Date.now() }, members: [ { - userId: { type: mongoose.SchemaTypes.ObjectId, required: true }, + userId: { type: mongoose.SchemaTypes.ObjectId, required: true, index : true }, addDateTime: { type: Date, default: Date.now(), ref: 'userProfile' }, visible: { type : 'Boolean', default:true}, + }, ], // Deprecated field @@ -35,4 +36,5 @@ const team = new Schema({ }, }); + module.exports = mongoose.model('team', team, 'teams'); diff --git a/src/models/timeentry.js b/src/models/timeentry.js index ea5303b3a..1535ab13e 100644 --- a/src/models/timeentry.js +++ b/src/models/timeentry.js @@ -17,5 +17,7 @@ const TimeEntry = new Schema({ lastModifiedDateTime: { type: Date, default: Date.now }, isActive: { type: Boolean, default: true }, }); +TimeEntry.index({ personId: 1, dateOfWork: 1 }); +TimeEntry.index({ entryType: 1, teamId: 1, dateOfWork: 1, isActive: 1 }); module.exports = mongoose.model('timeEntry', TimeEntry, 'timeEntries'); diff --git a/src/models/title.js b/src/models/title.js index 64b9aed92..a41063aea 100644 --- a/src/models/title.js +++ b/src/models/title.js @@ -4,6 +4,7 @@ const { Schema } = mongoose; const title = new Schema({ titleName: { type: String, required: true }, + titleCode: { type: String, required: true }, teamCode: { type: String, require: true }, projectAssigned: { projectName: { type: String, required: true }, @@ -13,8 +14,7 @@ const title = new Schema({ teamAssiged: { teamName: { type: String }, _id: { type: String }, - }, - shortName: { type: String, require: true }, + }, }); diff --git a/src/models/userProfile.js b/src/models/userProfile.js index cc7136f54..61e8e8f91 100644 --- a/src/models/userProfile.js +++ b/src/models/userProfile.js @@ -27,6 +27,7 @@ const userProfileSchema = new Schema({ isActive: { type: Boolean, required: true, default: true }, isRehireable: { type: Boolean, default: true }, isSet: { type: Boolean, required: true, default: false }, + finalEmailThreeWeeksSent: { type: Boolean, required: true, default: false }, role: { type: String, required: true, @@ -75,7 +76,7 @@ const userProfileSchema = new Schema({ startDate: { type: Date, required: true, - default () { + default() { return this.createdDate; }, }, @@ -127,6 +128,7 @@ const userProfileSchema = new Schema({ required: true, default: 'white', }, + iconId: { type: String, required: true }, }, ], location: { diff --git a/src/routes/curentWarningsRouter.js b/src/routes/curentWarningsRouter.js new file mode 100644 index 000000000..f1a004493 --- /dev/null +++ b/src/routes/curentWarningsRouter.js @@ -0,0 +1,23 @@ +const express = require('express'); + +const route = function (currentWarnings) { + const controller = require('../controllers/currentWarningsController')(currentWarnings); + + const currentWarningsRouter = express.Router(); + + currentWarningsRouter + .route('/currentWarnings') + .get(controller.getCurrentWarnings) + .post(controller.postNewWarningDescription); + + currentWarningsRouter.route('/currentWarnings/edit').put(controller.editWarningDescription); + + currentWarningsRouter + .route('/currentWarnings/:warningDescriptionId') + .delete(controller.deleteWarningDescription) + .put(controller.updateWarningDescription); + + return currentWarningsRouter; +}; + +module.exports = route; 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/routes/timeentryRouter.js b/src/routes/timeentryRouter.js index 0fd7db716..b5fd641ae 100644 --- a/src/routes/timeentryRouter.js +++ b/src/routes/timeentryRouter.js @@ -19,6 +19,14 @@ const routes = function (TimeEntry) { TimeEntryRouter.route('/TimeEntry/reports').post(controller.getTimeEntriesForReports); + TimeEntryRouter.route('/TimeEntry/reports/projects').post( + controller.getTimeEntriesForProjectReports, + ); + + TimeEntryRouter.route('/TimeEntry/reports/people').post( + controller.getTimeEntriesForPeopleReports, + ); + TimeEntryRouter.route('/TimeEntry/lostUsers').post(controller.getLostTimeEntriesForUserList); TimeEntryRouter.route('/TimeEntry/lostProjects').post( @@ -32,9 +40,11 @@ const routes = function (TimeEntry) { ); TimeEntryRouter.route('/TimeEntry/recalculateHoursAllUsers/tangible').post( - controller.recalculateHoursByCategoryAllUsers, + controller.startRecalculation, ); + TimeEntryRouter.route('/TimeEntry/checkStatus/:taskId').get(controller.checkRecalculationStatus); + TimeEntryRouter.route('/TimeEntry/recalculateHoursAllUsers/intangible').post( controller.recalculateIntangibleHrsAllUsers, ); diff --git a/src/routes/titleRouter.js b/src/routes/titleRouter.js index f12cb5ec7..1bced1e08 100644 --- a/src/routes/titleRouter.js +++ b/src/routes/titleRouter.js @@ -2,12 +2,14 @@ const express = require('express'); const router = function (title) { const controller = require('../controllers/titleController')(title); - const titleRouter = express.Router(); titleRouter.route('/title') .get(controller.getAllTitles) - .post(controller.postTitle); + .post(controller.postTitle) + // .put(controller.putTitle); + + titleRouter.route('/title/update').post(controller.updateTitle); titleRouter.route('/title/:titleId') .get(controller.getTitleById) diff --git a/src/routes/userProfileRouter.js b/src/routes/userProfileRouter.js index bf6f79237..2d68d2da1 100644 --- a/src/routes/userProfileRouter.js +++ b/src/routes/userProfileRouter.js @@ -23,6 +23,9 @@ const routes = function (userProfile, project) { controller.postUserProfile, ); + userProfileRouter.route('/userProfile/update').patch(controller.updateUserInformation); + // Endpoint to retrieve basic user profile information + userProfileRouter.route('/userProfile/basicInfo').get(controller.getUserProfileBasicInfo); userProfileRouter .route('/userProfile/:userId') .get(controller.getUserById) @@ -102,10 +105,21 @@ const routes = function (userProfile, project) { .route('/userProfile/authorizeUser/weeeklySummaries') .post(controller.authorizeUser); + userProfileRouter.route('/userProfile/:userId/addInfringement').post(controller.addInfringements); + + userProfileRouter + .route('/userProfile/:userId/infringements/:blueSquareId') + .put(controller.editInfringements) + .delete(controller.deleteInfringements); + userProfileRouter.route('/userProfile/projects/:name').get(controller.getProjectsByPerson); userProfileRouter.route('/userProfile/teamCode/list').get(controller.getAllTeamCode); + userProfileRouter + .route('/userProfile/autocomplete/:searchText') + .get(controller.getUserByAutocomplete); + return userProfileRouter; }; 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..8274188bc 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'); @@ -16,6 +15,8 @@ const inventoryItemType = require('../models/inventoryItemType'); const role = require('../models/role'); const rolePreset = require('../models/rolePreset'); const ownerMessage = require('../models/ownerMessage'); +const currentWarnings = require('../models/currentWarnings'); + // Title const title = require('../models/title'); const blueSquareEmailAssignment = require('../models/BlueSquareEmailAssignment'); @@ -49,12 +50,14 @@ const followUp = require('../models/followUp'); const userProfileRouter = require('../routes/userProfileRouter')(userProfile, project); const warningRouter = require('../routes/warningRouter')(userProfile); +const currentWarningsRouter = require('../routes/curentWarningsRouter')(currentWarnings); const badgeRouter = require('../routes/badgeRouter')(badge); const dashboardRouter = require('../routes/dashboardRouter')(weeklySummaryAIPrompt); 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')(); @@ -158,10 +161,12 @@ module.exports = function (app) { app.use('/api', isEmailExistsRouter); app.use('/api', mapLocationRouter); app.use('/api', warningRouter); + app.use('/api', currentWarningsRouter); app.use('/api', titleRouter); 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);