pawa-user/controllers/userController.js

A user management service for Cosmo Pawa, handling authentication and authorization.

const bcrypt = require("bcryptjs");
const { Op } = require("sequelize");

let User;
let UserActivity;

const setModels = (userModel, userActivityModel) => {
  User = userModel;
  UserActivity = userActivityModel;
};

// Create a new user
exports.createUser = async (userData) => {
  try {
    const hashedPassword = await bcrypt.hash(userData.password, 10);
    userData.role = userData.role || "user"; // Default role to 'user' if not provided
    userData.status = userData.status || 1; // Default status to 'active' if not provided
    userData.email = userData.email.toLowerCase(); // Normalize email to lowercase
    // Check if user already exists
    const existingUser = await User.findOne({
      where: { email: userData.email },
    });
    console.log("Checking for existing user with email:", userData);
    if (existingUser) {
      throw new Error("User with this email already exists");
    }
    // Create user and log activity
    console.log("Creating user with data:", userData);
    const user = await User.create({ ...userData, password: hashedPassword });
    await UserActivity.create({
      userId: user.id,
      activityType: "User Created",
      details: { email: user.email },
    });
    return user;
  } catch (error) {
    throw new Error("Error creating user: " + error.message);
  }
};

// Get all users
exports.getAllUsers = async () => {
  try {
    const users = await User.findAll({
      attributes: { exclude: ["password"] },
    });
    return users;
  } catch (error) {
    throw new Error("Error fetching users: " + error.message);
  }
};

// Get user by ID
exports.getUserById = async (id) => {
  try {
    const user = await User.findByPk(id, {
      attributes: { exclude: ["password"] },
    });
    if (!user) {
      throw new Error("User not found");
    }
    return user;
  } catch (error) {
    throw new Error("Error fetching user: " + error.message);
  }
};

// Update user by ID
exports.updateUser = async (id, userData) => {
  try {
    const user = await User.findByPk(id);
    if (!user) {
      throw new Error("User not found");
    }
    if (userData.password) {
      userData.password = await bcrypt.hash(userData.password, 10);
    }
    await user.update(userData);
    await UserActivity.create({
      userId: user.id,
      activityType: "User Updated",
      details: { email: user.email, updatedFields: Object.keys(userData) },
    });
    return user;
  } catch (error) {
    throw new Error("Error updating user: " + error.message);
  }
};

// Delete user by ID
exports.deleteUser = async (id) => {
  try {
    const user = await User.findByPk(id);
    if (!user) {
      throw new Error("User not found");
    }
    await user.destroy();
    await UserActivity.create({
      userId: user.id,
      activityType: "User Deleted",
      details: { email: user.email },
    });
    return { message: "User deleted successfully" };
  } catch (error) {
    throw new Error("Error deleting user: " + error.message);
  }
};

// Get user activity for the last 30 days
exports.getUserActivity = async (userId) => {
  try {
    const thirtyDaysAgo = new Date();
    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);

    const activities = await UserActivity.findAll({
      where: {
        userId: userId,
        timestamp: { [Op.gte]: thirtyDaysAgo },
      },
      order: [["timestamp", "DESC"]],
    });
    return activities;
  } catch (error) {
    throw new Error("Error fetching user activity: " + error.message);
  }
};

exports.setModels = setModels;