Merge pull request #27 from advanced-computer-lab-2023/task_42_43

Task 42 43

client/.eslintrc

@@ -63,6 +63,7 @@
     "import/prefer-default-export": 0,
     "react/function-component-definition": 0,
     "jsx-a11y/control-has-associated-label": 0,
+    "import/no-unresolved": 0,
     "react/jsx-no-useless-fragment": [
       1,
       {

server/package.json

@@ -36,6 +36,7 @@
     "stripe": "^8.174.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2",
+    "uuid": "^9.0.1",
     "validator": "^13.9.0"
   },
   "devDependencies": {

server/src/models/doctor.model.ts

@@ -6,7 +6,6 @@ const options = { discriminatorKey: 'role' };
 interface DailySchedule {
   from: { hours: number; minutes: number };
   to: { hours: number; minutes: number };
-  maxPatients: number;
 }
 
 interface IDoctor extends ICommonUser {
@@ -49,10 +48,6 @@ const dailyScheduleSchema = {
       minutes: { type: Number, required: false, default: 0, min: 0, max: 59 }
     },
     required: true
-  },
-  maxPatients: {
-    type: Number,
-    required: true
   }
 };
 

server/src/routes/doctor.route.ts

@@ -1,9 +1,19 @@
 import express, { Request, Response } from 'express';
 
 import controller from '../controllers';
-import { getDoctors } from '../services';
+import { createAppointment, getDoctors, viewAvailableAppointments } from '../services';
+import { isAuthenticated, isAuthorized } from '../middlewares';
 
 const router = express.Router();
+router.use(isAuthenticated);
+
+router.get('/:id/availableAppointments', isAuthorized('Patient'), (req: Request, res: Response) => {
+  controller(res)(viewAvailableAppointments)(req.params.id);
+});
+
+router.post('/:id/appointments', isAuthorized('Patient'), (req: Request, res: Response) => {
+  controller(res)(createAppointment)(req.decoded.id, req.params.id, req.body);
+});
 
 router.get('/:id', (req: Request, res: Response) => {
   controller(res)(getDoctors)({ _id: req.params.id });

server/src/routes/me.route.ts

@@ -2,7 +2,15 @@ import express, { Request, Response } from 'express';
 
 import controller from '../controllers';
 import { isAuthenticated, isAuthorized } from '../middlewares';
-import { getUsers, updateInfo, getAppointments, getPrescriptions, addFamilyMember, getFamily } from '../services';
+import {
+  getUsers,
+  updateInfo,
+  getAppointments,
+  getPrescriptions,
+  addFamilyMember,
+  getFamily,
+  getHealthRecords
+} from '../services';
 
 const router = express.Router();
 
@@ -58,9 +66,10 @@ router.get('/prescriptions', (req: Request, res: Response) => {
   controller(res)(getPrescriptions)(req.query);
 });
 
-router.get('/medicalhistory', (req: Request, res: Response) => {
-  // controller(res)()();
+router.get('/medicalhistory', isAuthorized('Patient'), (req: Request, res: Response) => {
+  controller(res)(getHealthRecords)(req.decoded.id);
 });
+
 router.post('/medicalhistory', (req: Request, res: Response) => {
   // controller(res)()();
 });

server/src/routes/patient.route.ts

@@ -1,29 +1,27 @@
 import express, { Request, Response } from 'express';
 
 import controller from '../controllers';
-import { getMyPatients } from '../services';
+import { addHealthRecord, getHealthRecords, getMyPatients } from '../services';
 import { isAuthenticated, isAuthorized } from '../middlewares';
 
 const router = express.Router();
 
 router.use(isAuthenticated);
 router.use(isAuthorized('Doctor'));
 
-router.get('/:id/medicalhistory', (req: Request, res: Response) => {
-  // controller(res)()();
-});
-
 router.get('/:id', (req: Request, res: Response) => {
   controller(res)(getMyPatients)({ doctorID: req.decoded.id, patientID: req.params.id });
 });
 router.get('/', (req: Request, res: Response) => {
   controller(res)(getMyPatients)({ doctorID: req.decoded.id });
 });
 
-router.post('/:id/medicalhistory', (req: Request, res: Response) => {
-  // Handle medical history update logic here
-  // notice that doctors can update patients medical history
-  // controller(res)()();
+router.get('/:id/medicalhistory', isAuthorized('Doctor'), (req: Request, res: Response) => {
+  controller(res)(getHealthRecords)(req.params.id);
+});
+
+router.post('/:id/medicalhistory', isAuthorized('Doctor'), (req: Request, res: Response) => {
+  controller(res)(addHealthRecord)(req.params.id, req.body);
 });
 
 export default router;

server/src/services/appointment.service.ts

@@ -1,4 +1,4 @@
-import { Appointment } from '../models';
+import { Appointment, Doctor } from '../models';
 import { StatusCodes } from 'http-status-codes';
 import mongoose from 'mongoose';
 import { HttpError } from '../utils';
@@ -18,4 +18,19 @@ const getAppointments = async (query: any) => {
   };
 };
 
-export { getAppointments };
+const createAppointment = async (patientID: String, doctorID: String, body: any) => {
+  const doctor = await Doctor.findById(doctorID);
+  if (!doctor) throw new HttpError(StatusCodes.NOT_FOUND, 'Doctor not found');
+
+  body.patientID = patientID;
+  body.doctorID = doctorID;
+  const newAppointment = await Appointment.create(body);
+
+  return {
+    status: StatusCodes.CREATED,
+    message: 'Appointment created successfully',
+    result: newAppointment
+  };
+};
+
+export { getAppointments, createAppointment };

server/src/services/doctor.service.ts

@@ -1,3 +1,4 @@
+const { v4: uuidv4 } = require('uuid');
 import { HttpError } from '../utils';
 import StatusCodes from 'http-status-codes';
 import { User, Contract, Appointment, IPatient, IDoctor, Doctor } from '../models';
@@ -44,4 +45,108 @@ const getDoctors = async (query: any) => {
   return { result: doctors, status: StatusCodes.OK };
 };
 
-export { getDoctors, getMyPatients };
+const viewAvailableAppointments = async (doctorID: string) => {
+  const doctor = await Doctor.findById(doctorID);
+  if (!doctor) throw new HttpError(StatusCodes.NOT_FOUND, 'Doctor not found');
+
+  const weeklySlots = doctor.weeklySlots;
+  if (!weeklySlots) throw new HttpError(StatusCodes.NOT_FOUND, 'No available appointments for this doctor');
+
+  let availableAppointments = {};
+
+  const thisDay = new Date();
+  const currentYear = thisDay.getUTCFullYear();
+  const currentMonth = thisDay.getUTCMonth();
+  const currentDate = thisDay.getUTCDate();
+  const currentDay = thisDay.getUTCDay();
+  const lastDay = currentDay + 6;
+
+  // Get all doctor's appointments
+  const appointments = await Appointment.find({
+    doctorID: doctorID
+  });
+
+  for (let i = currentDay; i <= lastDay; i++) {
+    const dayOfWeek = i % 7;
+    const day = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][dayOfWeek];
+    const dailySlots = weeklySlots[day as keyof typeof weeklySlots];
+
+    for (const slot of dailySlots) {
+      const slotHour = slot.from.hours;
+      const slotMinute = slot.from.minutes;
+      const slotHourEnd = slot.to.hours;
+      const slotMinuteEnd = slot.to.minutes;
+      let isSlotAvailable = true;
+
+      for (const appointment of appointments) {
+        const appointmentStartDate = appointment.startDate;
+        const appointmentYear = appointmentStartDate.getUTCFullYear();
+        const appointmentMonth = appointmentStartDate.getUTCMonth();
+        const appointmentDate = appointmentStartDate.getUTCDate();
+        const appointmentDay = appointmentStartDate.getUTCDay();
+        const appointmentHour = appointmentStartDate.getUTCHours();
+        const appointmentMinute = appointmentStartDate.getUTCMinutes();
+
+        if (
+          appointmentYear === currentYear &&
+          appointmentMonth === currentMonth &&
+          appointmentDate >= currentDate &&
+          appointmentDate <= currentDate + 6 &&
+          appointmentDay % 7 === dayOfWeek &&
+          slotHour === appointmentHour &&
+          slotMinute === appointmentMinute
+        ) {
+          isSlotAvailable = false;
+          break;
+        }
+      }
+
+      if (isSlotAvailable) {
+        const startDate = new Date(
+          currentYear,
+          currentMonth,
+          currentDate + i - currentDay,
+          slotHour + 2,
+          slotMinute,
+          0,
+          0
+        );
+        const endDate = new Date(
+          currentYear,
+          currentMonth,
+          currentDate + i - currentDay,
+          slotHourEnd + 2,
+          slotMinuteEnd,
+          0,
+          0
+        );
+
+        const price = Math.floor(doctor.hourRate * (slotHourEnd - slotHour + (slotMinuteEnd - slotMinute) / 60));
+
+        const id = uuidv4();
+
+        const slot = {
+          status: 'Upcoming',
+          sessionPrice: price,
+          startDate: startDate.toISOString(),
+          endDate: endDate.toISOString(),
+          isFollowUp: false,
+          _id: id
+        };
+
+        if (!(availableAppointments as any)[day]) {
+          (availableAppointments as any)[day] = []; // Initialize the day as an array if it doesn't exist
+        }
+        (availableAppointments as any)[day].push(slot);
+      }
+    }
+  }
+
+  return {
+    status: StatusCodes.OK,
+    message: 'Available Appointments retrieved successfully',
+    result: availableAppointments
+  };
+};
+
+export { getDoctors, getMyPatients, viewAvailableAppointments };

server/src/services/patient.service.ts

@@ -98,4 +98,46 @@ const viewDoctorsForPatient = async (patientId: string, query: any) => {
   };
 };
 
-export { viewDoctorsForPatient as viewAllDoctorsForPatient, getFamily, addFamilyMember };
+const addHealthRecord = async (patientID: String, body: any) => {
+  const { name, medicalRecord } = body;
+  if (!name || !medicalRecord) throw new HttpError(StatusCodes.BAD_REQUEST, 'Please provide name, medicalRecord');
+
+  const update = {
+    $push: {
+      medicalHistory: {
+        name,
+        medicalRecord
+      }
+    }
+  };
+  const updatedUser = await Patient.findByIdAndUpdate(patientID, update, { new: true });
+  if (!updatedUser) throw new HttpError(StatusCodes.NOT_FOUND, 'User not found');
+
+  return {
+    result: updatedUser,
+    status: StatusCodes.OK,
+    message: 'Health record added successfully'
+  };
+};
+
+const getHealthRecords = async (patientID: String) => {
+  const user: any = await Patient.findById(patientID).select('medicalHistory');
+  if (!user) throw new HttpError(StatusCodes.NOT_FOUND, 'patient not found');
+
+  const healthRecords = user.medicalHistory;
+  if (!healthRecords) throw new HttpError(StatusCodes.NOT_FOUND, 'health records not found');
+
+  return {
+    result: healthRecords,
+    status: StatusCodes.OK,
+    message: 'Health records retrieved successfully'
+  };
+};
+
+export {
+  viewDoctorsForPatient as viewAllDoctorsForPatient,
+  getFamily,
+  addFamilyMember,
+  addHealthRecord,
+  getHealthRecords
+};