update: user service

services/user.service.js

@@ -1,122 +1,174 @@
 const { 
   createUserDb,
-  changeUserPasswordDb,
   getUserByIdDb,
-  updateUserDb,
-  deleteUserDb,
   getAllUsersDb,
   getUserByUsernameDb,
-  getAllRoleDb
-} = require("../db/user.db");
-const { ErrorHandler } = require("../helpers/error");
-const { convertId } = require("../helpers/utils");
+  updateUserDb,
+  deleteUserDb,
+  changeUserPasswordDb
+} = require('../db/user.db');
+const { hashPassword } = require('../helpers/hashPassword');
+const { ErrorHandler } = require('../helpers/error');
 
 const statusName = [
-  {
-    status: true,
-    status_name: "Aktif"
-  }, {
-    status: false,
-    status_name: "NonAktif"
-  }
+  { status: true, status_name: "Aktif" },
+  { status: false, status_name: "NonAktif" }
 ];
 
 class UserService {
 
+  // Get all status users
   getAllStatusUsers = async () => {
     try {
       return statusName;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
-  getAllUsers = async (param) => {
+  // Get all users
+  getAllUsers = async () => {
     try {
-      const results = await getAllUsersDb(param);
+      const results = await getAllUsersDb();
 
-      results.data.map(element => {
-        element.is_active = element.is_active == 1 ? true : false
-        element.is_active_name = convertId(statusName, element.is_active, 'status', 'status_name')
+      results.forEach(user => {
+        user.is_active = user.is_active == 1;
+        user.is_active_name = statusName.find(s => s.status === user.is_active)?.status_name;
+        delete user.user_password; // remove password
       });
 
-      return results
+      return results;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
-    }
-  };
-
-  createUser = async (param) => {
-    try {
-      const userByUsername = await getUserByUsernameDb(param.userName, param.tenantID);
-
-      if (userByUsername) {
-        throw new ErrorHandler(401, "username taken already");
-      }
-
-      return await createUserDb(param);
-    } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
+  // Get user by ID
   getUserById = async (id) => {
     try {
       const user = await getUserByIdDb(id);
-      // user.password = undefined;
-      user.is_active = user.is_active == 1 ? true : false
+      if (!user) throw new ErrorHandler(404, "User not found");
+
+      user.is_active = user.is_active == 1;
+      user.is_active_name = statusName.find(s => s.status === user.is_active)?.status_name;
+      delete user.user_password;
       return user;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
-  changeUserPassword = async (password, email, tenantID) => {
+  // Create users
+  createUser = async ({ fullname, name, email, phone, password, role_id = null, is_sa = 0, is_active = 1, approved_by }) => {
     try {
-      return await changeUserPasswordDb(password, email, tenantID);
+      const existingUser = await getUserByUsernameDb(name);
+      if (existingUser) throw new ErrorHandler(400, "Username already taken");
+
+      const hashedPassword = await hashPassword(password);
+
+      const userId = await createUserDb({
+        user_fullname: fullname,
+        user_name: name,
+        user_email: email,
+        user_phone: phone,
+        user_password: hashedPassword,
+        role_id,
+        is_sa,
+        is_active,
+        is_approve: 1,
+        approved_by,
+        approved_at: new Date()
+      });
+
+      return {
+        user_id: userId,
+        user_fullname: fullname,
+        user_name: name,
+        user_email: email,
+        user_phone: phone,
+        role_id,
+        is_sa,
+        is_active,
+        is_approve: 1,
+        approved_by
+      };
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
-  updateUser = async (param) => {
-    const { userName, id } = param;
-    const errors = {};
+  // Update user
+  updateUser = async ({ user_id, fullname, name, email, phone, role_id, is_sa, is_active, is_approve }) => {
     try {
+      const user = await getUserByIdDb(user_id);
+      if (!user) throw new ErrorHandler(404, "User not found");
 
-      const user = await getUserByIdDb(id);
-
-      const findUserByUsername = await getUserByUsernameDb(userName, param.tenantID);
-
-      const usernameChanged = userName && user.user_name.toLowerCase() !== userName.toLowerCase();
-
-      if (usernameChanged && typeof findUserByUsername === "object") {
-        errors["username"] = "Username is already taken";
+      // Cek username
+      if (name && user.user_name.toLowerCase() !== name.toLowerCase()) {
+        const userByName = await getUserByUsernameDb(name);
+        if (userByName) throw new ErrorHandler(400, "Username already taken");
       }
 
-      if (Object.keys(errors).length > 0) {
-        throw new ErrorHandler(403, errors);
-      }
+      const updateData = {
+        ...(fullname && { user_fullname: fullname }),
+        ...(name && { user_name: name }),
+        ...(email && { user_email: email }),
+        ...(phone && { user_phone: phone }),
+        ...(role_id !== undefined && { role_id }),
+        ...(is_sa !== undefined && { is_sa }),
+        ...(is_active !== undefined && { is_active }),
+        ...(is_approve !== undefined && { is_approve })
+      };
 
-      return await updateUserDb(param);
+      await updateUserDb(user_id, updateData);
+
+      const updatedUser = await getUserByIdDb(user_id);
+      delete updatedUser.user_password;
+      updatedUser.is_active = updatedUser.is_active == 1;
+      updatedUser.is_active_name = statusName.find(s => s.status === updatedUser.is_active)?.status_name;
+
+      return updatedUser;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
-  deleteUser = async (id, userID) => {
+  // Approve user
+  approveUser = async (userId, approverId) => {
     try {
-      return await deleteUserDb(id, userID);
+      const updateData = {
+        is_approve: 1,
+        approved_by: approverId,
+        approved_at: new Date()
+      };
+      await updateUserDb(userId, updateData);
+
+      const updatedUser = await getUserByIdDb(userId);
+      delete updatedUser.user_password;
+      return updatedUser;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 
-  getAllRoles = async (tenantID) => {
+  // Delete user (soft delete)
+  deleteUser = async (userId, deletedBy) => {
     try {
-      return await getAllRoleDb(tenantID);
+      await deleteUserDb(userId, deletedBy);
+      return { message: "User deleted successfully" };
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
+    }
+  };
+
+  // Change password
+  changeUserPassword = async (userId, newPassword) => {
+    try {
+      const hashedPassword = await hashPassword(newPassword);
+      await changeUserPasswordDb(userId, hashedPassword);
+      return { message: "Password updated successfully" };
+    } catch (error) {
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   };
 }