Restructure Files

server/src/models/appointment.model.ts

@@ -1,6 +1,6 @@
 import mongoose, { Document, Schema } from 'mongoose';
 
-interface Appointment {
+interface IAppointment {
   doctorID: mongoose.Schema.Types.ObjectId;
   patientID: mongoose.Schema.Types.ObjectId;
   status: 'Upcoming' | 'Completed' | 'Cancelled' | 'Rescheduled';
@@ -10,8 +10,8 @@ interface Appointment {
   isFollowUp: boolean;
   previousAppointment?: mongoose.Schema.Types.ObjectId;
 }
-
-const appointmentSchema = new Schema<Appointment & Document>({
+type IAppointmentDocument = IAppointment & Document;
+const appointmentSchema = new Schema<IAppointmentDocument>({
   doctorID: {
     type: mongoose.Schema.Types.ObjectId,
     ref: 'User',
@@ -32,6 +32,6 @@ const appointmentSchema = new Schema<Appointment & Document>({
 appointmentSchema.index({ doctorID: 1 });
 appointmentSchema.index({ patientID: 1 });
 
-const AppointmentModel = mongoose.model<Appointment & Document>('Appointment', appointmentSchema);
+const AppointmentModel = mongoose.model<IAppointmentDocument>('Appointment', appointmentSchema);
 
 export default AppointmentModel;

server/src/models/chatroom.model.ts

@@ -11,8 +11,8 @@ interface IChatRoom {
   messages: ChatMessage[];
   date: Date;
 }
-
-const chatRoomSchema = new Schema<IChatRoom>({
+type IChatRoomDocument = IChatRoom & Document;
+const chatRoomSchema = new Schema<IChatRoomDocument>({
   patientID: {
     type: mongoose.Schema.Types.ObjectId,
     ref: 'User',
@@ -39,6 +39,6 @@ const chatRoomSchema = new Schema<IChatRoom>({
 chatRoomSchema.index({ patientID: 1 });
 chatRoomSchema.index({ medicID: 1 });
 
-const ChatRoomModel = mongoose.model<IChatRoom>('ChatRoom', chatRoomSchema);
+const ChatRoomModel = mongoose.model<IChatRoomDocument>('ChatRoom', chatRoomSchema);
 
 export default ChatRoomModel;

server/src/models/contract.model.ts

@@ -1,14 +1,14 @@
 import mongoose, { Document, Schema } from 'mongoose';
 
-interface IContract extends Document {
+interface IContract {
   doctorID: mongoose.Schema.Types.ObjectId;
   start: Date;
   state: 'Rejected' | 'Accepted' | 'Pending';
   end: Date;
   markUpProfit: number;
 }
-
-const contractSchema = new Schema<IContract>({
+type IContractDocument = IContract & Document;
+const contractSchema = new Schema<IContractDocument>({
   doctorID: {
     type: mongoose.Schema.Types.ObjectId,
     ref: 'User',
@@ -20,6 +20,6 @@ const contractSchema = new Schema<IContract>({
   markUpProfit: { type: Number, required: true }
 });
 contractSchema.index({ doctorID: 1 });
-const ContractModel = mongoose.model<IContract>('Contract', contractSchema);
+const ContractModel = mongoose.model<IContractDocument>('Contract', contractSchema);
 
 export default ContractModel;

server/src/models/prescription.model.ts

@@ -5,7 +5,7 @@ interface MedicineDosage {
   dosage: string;
 }
 
-interface IPrescription extends Document {
+interface IPrescription {
   doctorID: mongoose.Types.ObjectId;
   patientID: mongoose.Types.ObjectId;
   medicines: MedicineDosage[];
@@ -14,8 +14,8 @@ interface IPrescription extends Document {
   dateIssued: Date;
   isSubmitted: boolean;
 }
-
-const prescriptionSchema = new Schema<IPrescription>({
+type IPrescriptionDocument = IPrescription & Document;
+const prescriptionSchema = new Schema<IPrescriptionDocument>({
   doctorID: {
     type: mongoose.Schema.Types.ObjectId,
     ref: 'User',
@@ -42,6 +42,6 @@ const prescriptionSchema = new Schema<IPrescription>({
 });
 prescriptionSchema.index({ doctorID: 1 });
 prescriptionSchema.index({ patientID: 1 });
-const PrescriptionModel = mongoose.model<IPrescription>('Prescription', prescriptionSchema);
+const PrescriptionModel = mongoose.model<IPrescriptionDocument>('Prescription', prescriptionSchema);
 
 export default PrescriptionModel;

server/src/models/request.model.ts

@@ -3,16 +3,16 @@ interface ILicenses {
   licenseID: string;
   licenseImage: string;
 }
-interface IRequest extends Document {
+interface IRequest {
   medicID: mongoose.Schema.Types.ObjectId;
   ID: String;
   degree: string[];
   licenses: string[];
   status: 'Pending' | 'Approved' | 'Rejected';
   date: Date;
 }
-
-const requestSchema = new Schema<IRequest>({
+type IRequestDocument = IRequest & Document;
+const requestSchema = new Schema<IRequestDocument>({
   medicID: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
   ID: { type: String, required: true },
   degree: { type: [String], required: true },
@@ -21,6 +21,6 @@ const requestSchema = new Schema<IRequest>({
   date: { type: Date, default: Date.now(), required: true }
 });
 
-const Request = mongoose.model<IRequest>('Request', requestSchema);
+const Request = mongoose.model<IRequestDocument>('Request', requestSchema);
 
 export default Request;

server/src/models/user.model.ts

@@ -4,14 +4,14 @@ import mongoose, { Document, Schema } from 'mongoose';
 
 interface FamilyMemberWithID {
   userID: mongoose.Types.ObjectId;
-  relation: "Husband" | "Wife" | "Child";
+  relation: 'Husband' | 'Wife' | 'Child';
 }
 
 interface FamilyMemberWithDetails {
   name: string;
   nationalID: string;
   phone: string;
-  relation: "Husband" | "Wife" | "Child";
+  relation: 'Husband' | 'Wife' | 'Child';
 }
 
 type FamilyMember = FamilyMemberWithID | FamilyMemberWithDetails;
@@ -31,10 +31,10 @@ interface ICommonUser {
   email: string;
   password: string;
   birthDate: Date;
-  gender: "Male" | "Female";
+  gender: 'Male' | 'Female';
   phone: string;
   addresses: string[];
-  role: "Patient" | "Doctor" | "Administrator";
+  role: 'Patient' | 'Doctor' | 'Administrator';
   profileImage: string;
   isEmailVerified: boolean;
   wallet: number;
@@ -90,16 +90,16 @@ const dailyScheduleSchema = new mongoose.Schema({
   },
   maxPatients: {
     type: Number,
-    required: true,
-  },
+    required: true
+  }
 });
 
 const userSchema = new Schema<IUserDocument>(
   {
     name: {
       first: { type: String, required: true },
       middle: String,
-      last: { type: String, required: true },
+      last: { type: String, required: true }
     },
     email: {
       type: String,
@@ -108,18 +108,18 @@ const userSchema = new Schema<IUserDocument>(
       trim: true,
       validate(value: string) {
         return validator.isEmail(value);
-      },
+      }
     },
     username: { type: String, required: true, unique: true },
     password: { type: String, required: true },
     birthDate: { type: Date, required: true },
-    gender: { type: String, enum: ["Male", "Female"], required: true },
+    gender: { type: String, enum: ['Male', 'Female'], required: true },
     phone: { type: String, required: true },
     addresses: { type: [String], required: false },
     role: {
       type: String,
-      enum: ["Patient", "Doctor", "Administrator"],
-      required: true,
+      enum: ['Patient', 'Doctor', 'Administrator'],
+      required: true
     },
     profileImage: { type: String, required: true },
     isEmailVerified: { type: Boolean, required: true },
@@ -134,8 +134,8 @@ const userSchema = new Schema<IUserDocument>(
         }
       ],
       required: function () {
-        return this.role === "Patient";
-      },
+        return this.role === 'Patient';
+      }
     },
     family: {
       type: [
@@ -146,15 +146,16 @@ const userSchema = new Schema<IUserDocument>(
           phone: String,
           relation: {
             type: String,
-            enum: ["Husband", "Wife", "Child"],
-            required: true,
-          },
-        },
+            enum: ['Husband', 'Wife', 'Child'],
+            required: true
+          }
+        }
       ],
       required: function () {
-        return this.role === "Patient";
+        return this.role === 'Patient';
       },
       validate: {
+        //TODO
         validator: function (arr: any) {
           try {
             arr.forEach((elem: any) => {
@@ -176,43 +177,43 @@ const userSchema = new Schema<IUserDocument>(
         }
       ],
       required: function () {
-        return this.role === "Patient";
-      },
+        return this.role === 'Patient';
+      }
     },
     package: {
       type: {
         packageID: {
           type: mongoose.Schema.Types.ObjectId,
-          ref: "Package",
-          required: true,
+          ref: 'Package',
+          required: true
         },
         packageStatus: {
           type: String,
           enum: ['subscribed', 'unsubscribed', 'cancelled'],
           required: true
         },
-        endDate: { type: Date, required: true },
+        endDate: { type: Date, required: true }
       },
       required: false
     },
 
     hourRate: {
       type: Number,
       required: function () {
-        return this.role === "Doctor";
-      },
+        return this.role === 'Doctor';
+      }
     },
     hospital: {
       type: String,
       required: function () {
-        return this.role === "Doctor";
-      },
+        return this.role === 'Doctor';
+      }
     },
     specialty: {
       type: String,
       required: function () {
-        return this.role === "Doctor";
-      },
+        return this.role === 'Doctor';
+      }
     },
     weeklySlots: {
       type: {
@@ -222,7 +223,7 @@ const userSchema = new Schema<IUserDocument>(
         Wednesday: [dailyScheduleSchema],
         Thursday: [dailyScheduleSchema],
         Friday: [dailyScheduleSchema],
-        Saturday: [dailyScheduleSchema],
+        Saturday: [dailyScheduleSchema]
       },
       required: function () {
         return this.role === 'Doctor';
@@ -237,11 +238,11 @@ const userSchema = new Schema<IUserDocument>(
   },
   {
     toObject: {
-      virtuals: true,
+      virtuals: true
     },
     toJSON: {
-      virtuals: true,
-    },
+      virtuals: true
+    }
   }
 );
 
@@ -271,9 +272,7 @@ userSchema.pre<IUserDocument>('save', function (next) {
   next();
 });
 
-userSchema.methods.isCorrectPassword = function (
-  enteredPassword: string
-): boolean {
+userSchema.methods.isCorrectPassword = function (enteredPassword: string): boolean {
   return bcrypt.compareSync(enteredPassword, this.password);
 };
 
@@ -282,7 +281,12 @@ userSchema.methods.isCorrectPassword = function (
 // https://docs.mongodb.com/manual/indexes/#default-id-index
 
 const UserModel = mongoose.model<IUserDocument>('User', userSchema);
-
+userSchema.virtual('contract', {
+  ref: 'Contract',
+  localField: '_id',
+  foreignKey: 'doctorID',
+  justOne: true
+});
 export default UserModel;
 export { FamilyMember, IEmergencyContact };
 export { IUser, IUserDocument, IPatient, IDoctor, ICommonUser };

server/src/routes/auth.route.ts

@@ -1,5 +1,5 @@
 import express, { Request, Response } from 'express';
-import { login, logout, register, changePassword } from '../services/auth';
+import { login, logout, register, changePassword } from '../services/auth.service';
 import controller from '../controllers/controller';
 const loginRouter = express.Router();
 

server/src/routes/chatroom.route.ts

@@ -1,8 +1,4 @@
 import express from 'express';
 const router = express.Router();
-// http methods required for this router
-
-//
 
 export default router;
-

server/src/routes/contract.route.ts

@@ -1,8 +1,4 @@
 import express from 'express';
 const router = express.Router();
-// http methods required for this router
-
-//
 
 export default router;
-

server/src/routes/general.route.ts

@@ -1,8 +1,8 @@
 import express, { Request, Response } from 'express';
-import { login, logout, register, changePassword } from '../services/auth';
+import { login, logout, register, changePassword } from '../services/auth.service';
 import controller from '../controllers/controller';
-import { viewAllDoctorsForPatient } from '../services/patient';
-import { getAllDoctor } from '../services/doctor';
+import { viewAllDoctorsForPatient } from '../services/patient.service';
+import { getAllDoctor } from '../services/doctor.service';
 
 import { decodeJWTToken } from '../middlewares/authorization';
 

server/src/routes/notification.route.ts

@@ -1,7 +1,4 @@
 import express from 'express';
 const router = express.Router();
-// http methods required for this router
-
-//
 
 export default router;