fix: crud user

services/user.service.js

@@ -1,174 +1,151 @@
-const { 
-  createUserDb,
-  getUserByIdDb,
+const {
   getAllUsersDb,
+  getUserByIdDb,
+  getUserByUserEmailDb,
   getUserByUsernameDb,
+  createUserDb,
   updateUserDb,
+  approveUserDb,
   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" }
-];
-
 class UserService {
 
-  // Get all status users
-  getAllStatusUsers = async () => {
-    try {
-      return statusName;
-    } catch (error) {
-      throw new ErrorHandler(error.statusCode || 500, error.message);
-    }
-  };
-
   // Get all users
-  getAllUsers = async () => {
+  static async getAllUsers(param) {
     try {
-      const results = await getAllUsersDb();
-
-      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
-      });
-
+      const results = await getAllUsersDb(param);
       return results;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode || 500, error.message);
+      throw new ErrorHandler(error.statusCode, error.message);
     }
-  };
+  }
 
   // Get user by ID
-  getUserById = async (id) => {
+  static async getUserById(id) {
     try {
-      const user = await getUserByIdDb(id);
-      if (!user) throw new ErrorHandler(404, "User not found");
+      const result = await getUserByIdDb(id);
 
-      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;
+      if (!result) throw new ErrorHandler(404, 'User not found');
+
+      return result;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode || 500, error.message);
+      throw new ErrorHandler(error.statusCode, error.message);
     }
-  };
+  }
 
-  // Create users
-  createUser = async ({ fullname, name, email, phone, password, role_id = null, is_sa = 0, is_active = 1, approved_by }) => {
+  // Create user
+  static async createUser(data) {
     try {
-      const existingUser = await getUserByUsernameDb(name);
-      if (existingUser) throw new ErrorHandler(400, "Username already taken");
+      if (!data || typeof data !== 'object') data = {};
 
-      const hashedPassword = await hashPassword(password);
+      const creatorId = data.userId;
 
-      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()
-      });
+      const existingEmail = await getUserByUserEmailDb(data.user_email);
+      const existingUsername = await getUserByUsernameDb(data.user_name);
 
-      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 || 500, error.message);
-    }
-  };
-
-  // Update user
-  updateUser = async ({ user_id, fullname, name, email, phone, role_id, is_sa, is_active, is_approve, updatedById }) => {
-    try {
-      const user = await getUserByIdDb(user_id);
-      if (!user) throw new ErrorHandler(404, "User not found");
-
-      // 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 (existingUsername) {
+        throw new ErrorHandler(400, 'Username is already taken');
+      }
+      if (existingEmail) {
+        throw new ErrorHandler(400, 'Email is already taken');
       }
 
-      const updateData = {
-        ...(fullname && { user_fullname: fullname }),
-        ...(name && { user_name: name }),
-        ...(email && { user_email: email }),
-        ...(phone && { user_phone: phone }),
-        ...(role_id !== undefined && { role_id }),
-        ...(updatedById !== undefined && { updated_by: updatedById })
-      };
+      if (data.user_password) {
+        data.user_password = await hashPassword(data.user_password);
+      }
 
-      await updateUserDb(user_id, updateData);
+      data.is_approve = 1;
+      data.approved_by = creatorId;
+      data.created_by = creatorId;
+      data.updated_by = creatorId;
+      data.is_sa = 0;
+      data.is_active = 1;
+      delete data.userId;
 
-      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;
+      const result = await createUserDb(data);
+      return result;
     } catch (error) {
       throw new ErrorHandler(error.statusCode || 500, error.message);
     }
-  };
+  }
+
+  // Update user
+  static async updateUser(id, data) {
+    try {
+      if (!data || typeof data !== 'object') data = {};
+
+      const existingEmail = await getUserByUserEmailDb(data.user_email);
+      const existingUsername = await getUserByUsernameDb(data.user_name);
+
+      if (existingUsername) {
+        throw new ErrorHandler(400, 'Username is already taken');
+      }
+      if (existingEmail) {
+        throw new ErrorHandler(400, 'Email is already taken')
+      }
+
+      const userExist = await getUserByIdDb(id);
+      if (!userExist) throw new ErrorHandler(404, 'User not found');
+
+      const result = await updateUserDb(id, data);
+      return result;
+    } catch (error) {
+      throw new ErrorHandler(error.statusCode, error.message);
+    }
+  }
 
   // Approve user
-  approveUser = async (userId, approverId) => {
+  static async approveUser(userId, approverId) {
     try {
-      const updateData = {
-        is_approve: 1,
-        approved_by: approverId,
-        approved_at: new Date()
-      };
-      await updateUserDb(userId, updateData);
+      if (!userId) {
+        throw new ErrorHandler(400, 'User ID is required');
+      }
 
-      const updatedUser = await getUserByIdDb(userId);
-      delete updatedUser.user_password;
+      const existingUser = await getUserByIdDb(userId);
+      if (!existingUser) {
+        throw new ErrorHandler(404, 'User not found');
+      }
+
+      if (existingUser.is_approve) {
+        throw new ErrorHandler(400, 'User is already approved');
+      }
+
+      const updatedUser = await approveUserDb(userId, approverId);
       return updatedUser;
     } catch (error) {
       throw new ErrorHandler(error.statusCode || 500, error.message);
     }
-  };
+  }
 
-  // Delete user (soft delete)
-  deleteUser = async (userId, deletedBy) => {
+  // Soft delete user
+  static async deleteUser(id, userId) {
     try {
-      await deleteUserDb(userId, deletedBy);
-      return { message: "User deleted successfully" };
+      const userExist = await getUserByIdDb(id);
+      if (!userExist) throw new ErrorHandler(404, 'User not found');
+
+      const result = await deleteUserDb(id, userId);
+      return result;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode || 500, error.message);
+      throw new ErrorHandler(error.statusCode, error.message);
     }
-  };
+  }
 
   // Change password
-  changeUserPassword = async (user_Id, new_Password) => {
+  static async changeUserPassword(id, newPassword) {
     try {
-      const hashedPassword = await hashPassword(new_Password);
-      await changeUserPasswordDb(user_Id, hashedPassword);
-      return { message: "Password updated successfully" };
+      const userExist = await getUserByIdDb(id);
+      if (!userExist) throw new ErrorHandler(404, 'User not found');
+
+      const result = await changeUserPasswordDb(id, newPassword);
+      return result;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode || 500, error.message);
+      throw new ErrorHandler(error.statusCode, error.message);
     }
-  };
+  }
 }
 
-module.exports = new UserService();
+module.exports = UserService;