Implement mentor availability endpoint (#64)

Co-authored-by: Yoshitha Rathnayake <[email protected]>

src/controllers/mentor.controller.ts

@@ -1,5 +1,5 @@
 import type { Request, Response } from 'express'
-import { createMentor } from '../services/mentor.service'
+import { createMentor, updateAvailability } from '../services/mentor.service'
 import type Profile from '../entities/profile.entity'
 
 export const mentorApplicationHandler = async (
@@ -9,7 +9,6 @@ export const mentorApplicationHandler = async (
  try {
  const user = req.user as Profile
  const { application, categoryId } = req.body
-
  const { mentor, statusCode, message } = await createMentor(
  user,
  application,
@@ -26,3 +25,22 @@ export const mentorApplicationHandler = async (
  }
  }
 }
+
+export const mentorAvailabilityHandler = async (
+ req: Request,
+ res: Response
+): Promise<void> => {
+ try {
+ const user = req.user as Profile
+ const { availability } = req.body
+ const result = await updateAvailability(user, availability)
+ res.status(result.statusCode).json(result.updatedMentorApplication)
+ } catch (err) {
+ if (err instanceof Error) {
+ console.error('Error executing query', err)
+ res
+ .status(500)
+ .json({ error: 'Internal server error', message: err.message })
+ }
+ }
+}

src/routes/admin/admin.route.test.ts

@@ -0,0 +1,82 @@
+import { startServer } from '../../app'
+import type { Express } from 'express'
+import supertest from 'supertest'
+import Profile from '../../entities/profile.entity'
+import { ProfileTypes } from '../../enums'
+import { dataSource } from '../../configs/dbConfig'
+import bcrypt from 'bcrypt'
+import { mockAdmin, mockUser } from '../../../mocks'
+
+const port = Math.floor(Math.random() * (9999 - 3000 + 1)) + 3000
+let server: Express
+let agent: supertest.SuperAgentTest
+let adminAgent: supertest.SuperAgentTest
+
+describe('Get all users route', () => {
+ beforeAll(async () => {
+ server = await startServer(port)
+ agent = supertest.agent(server)
+ adminAgent = supertest.agent(server)
+
+ const defaultUser = {
+ ...mockUser
+ }
+
+ await supertest(server)
+ .post('/api/auth/register')
+ .send(defaultUser)
+ .expect(201)
+
+ await agent.post('/api/auth/login').send(defaultUser).expect(200)
+
+ const adminUser = {
+ ...mockAdmin
+ }
+
+ const profileRepository = dataSource.getRepository(Profile)
+
+ const hashedPassword = await bcrypt.hash(adminUser.password, 10)
+ const newProfile = profileRepository.create({
+ primary_email: adminUser.email,
+ password: hashedPassword,
+ contact_email: '',
+ first_name: '',
+ last_name: '',
+ image_url: '',
+ linkedin_url: '',
+ type: ProfileTypes.ADMIN
+ })
+
+ await profileRepository.save(newProfile)
+
+ await adminAgent.post('/api/auth/login').send(adminUser).expect(200)
+ }, 5000)
+
+ it('should return a 401 when a valid access token is not provided', async () => {
+ await supertest(server).get('/api/admin/users').expect(401)
+ })
+
+ it('should return a 403 if user is not admin', async () => {
+ await agent.get('/api/admin/users').expect(403)
+ })
+
+ it('should return a 200 with all users if user is admin', async () => {
+ const response = await adminAgent.get('/api/admin/users').expect(200)
+
+ const userProfiles = response.body.profiles
+
+ userProfiles.forEach((userProfile: Partial<Profile>) => {
+ expect(userProfile).toHaveProperty('created_at')
+ expect(userProfile).toHaveProperty('updated_at')
+ expect(userProfile).toHaveProperty('primary_email')
+ expect(userProfile).toHaveProperty('contact_email')
+ expect(userProfile).toHaveProperty('first_name')
+ expect(userProfile).toHaveProperty('last_name')
+ expect(userProfile).toHaveProperty('image_url')
+ expect(userProfile).toHaveProperty('linkedin_url')
+ expect(userProfile).toHaveProperty('type')
+ expect(userProfile).toHaveProperty('uuid')
+ expect(userProfile).not.toHaveProperty('password')
+ })
+ })
+})

src/routes/mentor/mentor.route.test.ts

@@ -61,6 +61,20 @@ describe('Mentor application', () => {
  await supertest(server).post('/api/mentors').send({}).expect(401)
  })
 
+ describe('Update Mentor Availability', () => {
+ it.each([true, false])(
+ 'should update mentor availability and return a 201 with the updated availability',
+ async (availability) => {
+ const response = await agent
+ .put('/api/mentors/me/availability')
+ .send({ availability })
+ .expect(200)
+
+ expect(response.body).toHaveProperty('availability', availability)
+ }
+ )
+ })
+
  afterAll(async () => {
  await dataSource.destroy()
  })

src/routes/mentor/mentor.route.ts

@@ -1,9 +1,13 @@
 import express from 'express'
 import { requireAuth } from './../../controllers/auth.controller'
-import { mentorApplicationHandler } from './../../controllers/mentor.controller'
+import {
+ mentorApplicationHandler,
+ mentorAvailabilityHandler
+} from './../../controllers/mentor.controller'
 
 const mentorRouter = express.Router()
 
 mentorRouter.post('/', requireAuth, mentorApplicationHandler)
+mentorRouter.put('/me/availability', requireAuth, mentorAvailabilityHandler)
 
 export default mentorRouter

src/services/admin.service.ts

@@ -0,0 +1,8 @@
+import { dataSource } from '../configs/dbConfig'
+import Profile from '../entities/profile.entity'
+
+export const getAllUsers = async (): Promise<Profile[] | undefined> => {
+ const profileRepository = dataSource.getRepository(Profile)
+ const allUsers = await profileRepository.find()
+ return allUsers
+}

src/services/mentor.service.ts

@@ -72,3 +72,33 @@ export const createMentor = async (
  throw new Error('Error creating mentor')
  }
 }
+
+export const updateAvailability = async (
+ user: Profile,
+ availability: boolean
+): Promise<{ statusCode: number; updatedMentorApplication: Mentor }> => {
+ try {
+ const mentorRepository = dataSource.getRepository(Mentor)
+ const existingMentorApplications = await mentorRepository.find({
+ where: { profile: { uuid: user.uuid } }
+ })
+
+ const mentorApplication = existingMentorApplications[0]
+
+ if (mentorApplication) {
+ mentorApplication.availability = availability
+ const updatedMentorApplication = await mentorRepository.save(
+ mentorApplication
+ )
+ return {
+ statusCode: 200,
+ updatedMentorApplication
+ }
+ } else {
+ throw new Error('Mentor application not found')
+ }
+ } catch (err) {
+ console.error('Error creating mentor', err)
+ throw new Error('Error creating mentor')
+ }
+}