Worker -> Employee

server/src/controllers/accounts.controllers.ts

 import bcrypt from "bcrypt";
 import { Request, Response } from "express";
-import Worker from "../db/models/Worker";
+import Employee from "../db/models/Employee";
 //create new account
 const createAccountController = async (req: Request, res: Response) => {
   try {
@@ -12,7 +12,7 @@ const createAccountController = async (req: Request, res: Response) => {
 
     const { first_name, last_name, email, password, role } = req.body;
 
-    const existedAccount = await Worker.findAll({
+    const existedAccount = await Employee.findAll({
       where: {
         email: email,
       },
@@ -26,7 +26,7 @@ const createAccountController = async (req: Request, res: Response) => {
 
     const hashedPassword = await bcrypt.hash(password, 10);
 
-    const newAccount = await Worker.create({
+    const newAccount = await Employee.create({
       email,
       first_name: first_name,
       last_name: last_name,
@@ -55,7 +55,7 @@ const showAllAccounts = async (req: Request, res: Response) => {
         .status(403)
         .json({ success: false, error: "MustBeCoordinator" });
     }
-    const allAccounts = await Worker.findAll();
+    const allAccounts = await Employee.findAll();
     return res.status(200).send({ success: true, result: allAccounts });
   } catch (error) {
     console.error("server error: ", error.message);
@@ -63,7 +63,7 @@ const showAllAccounts = async (req: Request, res: Response) => {
   }
 };
 
-//show a specific account using given id: email is the primary key for a worker
+//show a specific account using given id: email is the primary key for a Employee
 const showAccountById = async (req: Request, res: Response) => {
   try {
     if (!(res.locals.user.role === "coordinator")) {
@@ -72,7 +72,7 @@ const showAccountById = async (req: Request, res: Response) => {
         .json({ success: false, error: "MustBeCoordinator" });
     }
     const givenId = req.params.id;
-    const account = await Worker.findByPk(givenId);
+    const account = await Employee.findByPk(givenId);
     if (account) {
       return res.status(200).json({ success: true, result: account });
     }
@@ -104,16 +104,16 @@ const updateAccount = async (req: Request, res: Response) => {
       input.password = await bcrypt.hash(input.password, 10);
     }
 
-    //update worker
-    const userDataAfterUpdate = await Worker.update(input, {
+    //update Employee
+    const userDataAfterUpdate = await Employee.update(input, {
       where: {
-        id: givenId, //primary key in worker is email
+        id: givenId, //primary key in Employee is email
       },
       returning: true,
     });
 
-    //worker not found with given id
-    //not Working!!!! by giving wrong id -> server error gets thrown 
+    //Employee not found with given id
+    //not Working!!!! by giving wrong id -> server error gets thrown
     if (userDataAfterUpdate[0] === 0) {
       return res.status(404).json({ success: false, error: "accountNotFound" });
     }
@@ -141,7 +141,7 @@ const deleteAccountById = async (req: Request, res: Response) => {
     }
     //delete using given id (email)
     const givenId = req.params.id;
-    const accountToDelete = await Worker.destroy({
+    const accountToDelete = await Employee.destroy({
       where: {
         id: givenId,
       },

server/src/controllers/auth.controllers.ts

 import bcrypt from "bcrypt";
 import { Request, Response } from "express";
 import jwt from "jsonwebtoken";
+import Employee from "../db/models/Employee";
 import envVars from "../config";
-import Worker from "../db/models/Worker";
 
 const authLoginController = async (req: Request, res: Response) => {
   try {
     const { email, password } = req.body;
 
-    const worker = await Worker.findOne({
+    const employee = await Employee.findOne({
       attributes: ["email", "password", "role"],
       where: {
         email: email,
       },
     });
 
-    if (!worker) {
+    if (!employee) {
       return res.status(401).json({ success: false, error: "invalidEmail" });
     }
 
-    const isPasswordCorrect = await bcrypt.compare(password, worker.password);
+    const isPasswordCorrect = await bcrypt.compare(password, employee.password);
 
     if (isPasswordCorrect) {
       const payload = {
-        email: worker.email,
-        role: worker.role,
+        email: employee.email,
+        role: employee.role,
       };
 
       const token = jwt.sign(payload, envVars.JWT_SECRET);

server/src/controllers/userControllers.controllers.ts

-import Worker from "../db/models/Worker";
+import Employee from "../db/models/Employee";
 import { Request, Response } from "express";
 import bcrypt from "bcrypt";
 
@@ -6,7 +6,7 @@ import bcrypt from "bcrypt";
 const showCurrentUserController = async (req: Request, res: Response) => {
   try {
     const currentUser = res.locals.user; //payload
-    const currentUserData = await Worker.findOne({
+    const currentUserData = await Employee.findOne({
       where: {
         email: currentUser.email,
       },
@@ -19,7 +19,7 @@ const showCurrentUserController = async (req: Request, res: Response) => {
   }
 };
 
-//update current user PUT
+//update current user PATCH 
 const updateCurrentUser = async (req: Request, res: Response) => {
   try {
     //check role
@@ -40,17 +40,17 @@ const updateCurrentUser = async (req: Request, res: Response) => {
     const currentUserEmail = currentUser.email; //updating data of current user: payload in token has the unique email + role
 
     //update coordinator data after finding wanted user through found email
-    const workerDataAfterUpdate = await Worker.update(input, {
+    const EmployeeDataAfterUpdate = await Employee.update(input, {
       where: {
         email: currentUserEmail,
       },
       returning: true,
     });
 
-    const updatedWorker = workerDataAfterUpdate[1][0];
-    delete updatedWorker.password;
+    const updatedEmployee = EmployeeDataAfterUpdate[1][0];
+    delete updatedEmployee.password;
 
-    return res.status(200).json({ success: true, result: updatedWorker });
+    return res.status(200).json({ success: true, result: updatedEmployee });
   } catch (error) {
     console.error("server error: ", error.message);
     return res.status(500).json({ success: false, error: "serverError" });

server/src/db/createInitialEmployee.ts

+import bcrypt from "bcrypt";
+import envVars from "../config";
+import Employee from "./models/Employee";
+
+const createInitialEmployeeIfNotExists = async () => {
+  const numberOfEmployees = await Employee.count();
+
+  if (numberOfEmployees === 0) {
+    const initialCoordinatorPassword = envVars.INITIAL_COORDINATOR_PASSWORD;
+    const initialCoordinatorEmail = envVars.INITIAL_COORDINATOR_EMAIL;
+
+    const hashedPassword = await bcrypt.hash(initialCoordinatorPassword, 10);
+
+    await Employee.create({
+      email: initialCoordinatorEmail,
+      password: hashedPassword,
+      first_name: "coordinator_firstName",
+      last_name: "coordinator_lastName",
+      role: "coordinator",
+    });
+  }
+};
+export default createInitialEmployeeIfNotExists;

server/src/db/index.ts

@@ -5,7 +5,7 @@ import { initBoat } from "./models/Boat";
 import { initBoatType } from "./models/BoatType";
 import { initCheckIn } from "./models/CheckIn";
 import { initCustomer } from "./models/Customer";
-import { initWorker } from "./models/Worker";
+import { initEmployee } from "./models/Employee";
 
 const initializeDatabase = async () => {
   const client = new Client({
@@ -42,7 +42,7 @@ const initializeDatabase = async () => {
   await initBoatType(sequelize);
   await initCheckIn(sequelize);
   await initCustomer(sequelize);
-  await initWorker(sequelize);
+  await initEmployee(sequelize);
 
   await sequelize.sync();
   return sequelize;

server/src/db/models/Employee.ts

+import { DataTypes, Model, Optional, Sequelize } from "sequelize";
+
+interface EmployeeAttributes {
+  id: string;
+  email: string;
+  first_name: string;
+  last_name: string;
+  password: string;
+  role: string;
+}
+export interface EmployeeInput extends Optional<EmployeeAttributes, "id"> {}
+class Employee
+  extends Model<EmployeeAttributes, EmployeeInput>
+  implements EmployeeAttributes
+{
+  declare id: string;
+  declare email: string;
+  declare first_name: string;
+  declare last_name: string;
+  declare password: string;
+  declare role: string;
+  declare readonly createdAt: Date;
+  declare readonly updatedAt: Date;
+}
+export const initEmployee = async (sequelizeConnection: Sequelize) => {
+  Employee.init(
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+      },
+      email: {
+        type: new DataTypes.STRING(),
+        allowNull: false,
+        unique: true,
+      },
+      first_name: {
+        type: new DataTypes.STRING(),
+        allowNull: false,
+      },
+      last_name: {
+        type: new DataTypes.STRING(),
+        allowNull: false,
+      },
+      password: {
+        type: new DataTypes.STRING(),
+        allowNull: false,
+      },
+      role: {
+        type: new DataTypes.STRING(),
+        allowNull: false,
+      },
+    },
+    {
+      tableName: "employee",
+      sequelize: sequelizeConnection,
+    }
+  );
+};
+
+export default Employee;

server/src/server.ts

@@ -2,11 +2,11 @@ import cookieParser from "cookie-parser";
 import "dotenv/config";
 import express from "express";
 import initializeDatabase from "./db";
-import createInitialWorkerIfNotExists from "./db/createInitialWorker";
+import createInitialEmployeeIfNotExists from "./db/createInitialEmployee";
 import showAllDBs from "./db/DB_Information/showAllDBs";
 import showTables from "./db/DB_Information/showDBTables";
 import showTableContent from "./db/DB_Information/showTableContent";
-import runSeeders from "./db/seeder";
+// import runSeeders from "./db/seeder";
 import accountsRouter from "./routes/accounts.routes";
 import authRouter from "./routes/auth.routes";
 import boatsRouter from "./routes/boatRoutes.routes";
@@ -16,8 +16,8 @@ import boatTypeRouter from "./routes/boatTypeRoutes.routes";
 let init = async () => {
   //DB
   const sequelize = await initializeDatabase();
-  await createInitialWorkerIfNotExists();
-  await runSeeders();
+  await createInitialEmployeeIfNotExists();
+  // await runSeeders();
   // server
   const app = express();
   app.use(express.json());
@@ -33,7 +33,7 @@ let init = async () => {
   //DB-information section
   await showAllDBs(sequelize);
   await showTables(sequelize);
-  await showTableContent("worker", sequelize);
+  await showTableContent("employee", sequelize);
 };
 
 init().then(() => {});