@goplusvn/core 0.1.0 → 0.1.1

package/src/user/user-service.ts

@@ -0,0 +1,538 @@
+import type { CrudResponse } from "../types";
+
+// Define the shape of the Prisma Client required by this service
+// This allows us to pass a transaction client or the main client
+export interface UserPrismaClient {
+  user: any;
+  role: any;
+  department: any;
+  $transaction: (args: any) => Promise<any>;
+}
+
+export interface GetUsersParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: string;
+  roleCode?: string;
+  departmentId?: string;
+}
+
+export interface UserWithDetails {
+  id: string;
+  name: string | null;
+  email: string;
+  image: string | null;
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  roles: { code: string; name: string }[];
+  department: { id: string; name: string; code: string } | null;
+  jobTitle: { id: string; name: string; code: string; level: number } | null;
+  branches: { id: string; name: string; isDefault: boolean }[];
+  branchIds: string[];
+}
+
+export interface UsersStats {
+  totalUsers: number;
+  activeUsers: number;
+  inactiveUsers: number;
+  totalRoles: number;
+  employees: number;
+  customers: number;
+  suppliers: number;
+}
+
+export interface UsersDataResponse extends CrudResponse<UserWithDetails> {
+  stats: UsersStats;
+}
+
+export async function getUsersData(
+  db: UserPrismaClient,
+  params: GetUsersParams,
+): Promise<CrudResponse<any>> {
+  const { page = 1, pageSize = 10, search, status } = params;
+  const skip = (page - 1) * pageSize;
+
+  // Build where clause
+  const whereConditions: any[] = [];
+
+  if (search) {
+    whereConditions.push({
+      OR: [
+        { name: { contains: search, mode: "insensitive" } },
+        { email: { contains: search, mode: "insensitive" } },
+      ],
+    });
+  }
+
+  if (status !== undefined && status !== "") {
+    whereConditions.push({ isActive: status === "active" });
+  }
+
+  if (params.roleCode) {
+    whereConditions.push({
+      userRoles: {
+        some: {
+          role: {
+            code: params.roleCode,
+          },
+        },
+      },
+    });
+  }
+
+  const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
+
+  // ⚡ Bolt: Execute independent read queries concurrently to reduce latency
+  const [users, total] = await Promise.all([
+    db.user.findMany({
+      where,
+      skip,
+      take: pageSize,
+      orderBy: { createdAt: "desc" },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+        image: true,
+        isActive: true,
+        lastLoginAt: true,
+        createdAt: true,
+        updatedAt: true,
+        userType: true, // Added userType
+        userRoles: {
+          select: {
+            role: {
+              select: {
+                code: true,
+                name: true,
+              },
+            },
+          },
+        },
+        userBranches: {
+          select: {
+            branch: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+            isDefault: true,
+          },
+        },
+        // Removed invalid userSuppliers selection
+        profiles: {
+          select: {
+            department: true,
+            departmentRef: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+            jobTitleId: true,
+            jobTitleRef: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+            address: true, // Added address
+            phone: true,   // Added phone
+            gender: true,
+            dateOfBirth: true,
+            groupId: true,
+            idNumber: true,
+            supplierId: true, // Select supplierId from profiles
+            supplier: { // Select supplier details from profiles
+              select: {
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    }),
+    db.user.count({ where }),
+  ]);
+
+  // Transform data for CRUD table display
+  const data = users.map((user: any) => ({
+    id: user.id,
+    name: user.name,
+    email: user.email,
+    image: user.image,
+    status: user.isActive ? "active" : "inactive",
+    userType: user.userType || "employee",
+    supplierId: user.profiles?.supplierId || "",
+    supplierName: user.profiles?.supplier?.name || "",
+    address: user.profiles?.address || "", // Added address
+    phone: user.profiles?.phone || "",     // Added phone
+    gender: user.profiles?.gender || "",
+    birthday: user.profiles?.dateOfBirth || null,
+    groupId: user.profiles?.groupId || "",
+    idNumber: user.profiles?.idNumber || "",
+    lastLoginAt: user.lastLoginAt,
+    createdAt: user.createdAt,
+    updatedAt: user.updatedAt,
+    departmentId: user.profiles?.departmentRef?.id || null,
+    departmentName: user.profiles?.departmentRef?.name || null,
+    jobTitleId: user.profiles?.jobTitleRef?.id || null,
+    jobTitleName: user.profiles?.jobTitleRef?.name || null,
+    roleNames:
+      user.userRoles?.map((ur: any) => ur.role.name) || [],
+    roleCodes: user.userRoles?.map((ur: any) => ur.role.code) || [],
+    branches: user.userBranches?.map((ub: any) => ({
+      id: ub.branch?.id,
+      name: ub.branch?.name,
+      isDefault: ub.isDefault,
+    })).filter((b: any) => b.id) || [],
+    branchIds: user.userBranches?.map((ub: any) => ub.branch?.id).filter(Boolean) || [],
+    branchNames: user.userBranches?.map((ub: any) => ub.branch?.name).filter(Boolean) || [],
+  }));
+
+  return {
+    data,
+    total,
+    page,
+    pageSize,
+  };
+}
+
+/**
+ * Get users with extended details including roles, department, and job title
+ */
+export async function getUsersWithDetails(
+  db: UserPrismaClient,
+  params: GetUsersParams,
+): Promise<UsersDataResponse> {
+  const {
+    page = 1,
+    pageSize = 10,
+    search,
+    status,
+    roleCode,
+    departmentId,
+  } = params;
+  const skip = (page - 1) * pageSize;
+
+  // Build where clause
+  const whereConditions: any[] = [];
+
+  if (search) {
+    whereConditions.push({
+      OR: [
+        { name: { contains: search, mode: "insensitive" } },
+        { email: { contains: search, mode: "insensitive" } },
+      ],
+    });
+  }
+
+  if (status !== undefined && status !== "") {
+    whereConditions.push({ isActive: status === "active" });
+  }
+
+  if (roleCode) {
+    whereConditions.push({
+      userRoles: {
+        some: { roleCode },
+      },
+    });
+  }
+
+  if (departmentId) {
+    whereConditions.push({
+      profiles: {
+        is: {
+          departmentId: departmentId,
+        },
+      },
+    });
+  }
+
+  const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
+
+  // ⚡ Bolt: Execute independent read queries concurrently to reduce latency
+  const [users, total, activeCount, rolesCount, customers, suppliers] =
+    await Promise.all([
+      db.user.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { createdAt: "desc" },
+        select: {
+          id: true,
+          name: true,
+          email: true,
+          image: true,
+          isActive: true,
+          createdAt: true,
+          updatedAt: true,
+          userRoles: {
+            select: {
+              role: {
+                select: {
+                  code: true,
+                  name: true,
+                },
+              },
+            },
+          },
+          userBranches: {
+            select: {
+              branch: {
+                select: {
+                  id: true,
+                  name: true,
+                },
+              },
+              isDefault: true,
+            },
+          },
+          profiles: {
+            select: {
+              departmentRef: {
+                select: {
+                  id: true,
+                  name: true,
+                  code: true,
+                },
+              },
+              jobTitleRef: {
+                select: {
+                  id: true,
+                  name: true,
+                  code: true,
+                  level: true,
+                },
+              },
+              address: true, // Added address
+              phone: true,   // Added phone
+              gender: true,
+              dateOfBirth: true,
+              groupId: true,
+              idNumber: true,
+              supplierId: true, // Added supplierId
+              supplier: { // Added supplier
+                select: {
+                  name: true
+                }
+              }
+            },
+          },
+        },
+      }),
+      db.user.count({ where }),
+      db.user.count({ where: { ...where, isActive: true } }),
+      db.role.count({ where: { status: "active" } }),
+      db.user.count({ where: { userType: "customer" } }).catch(() => 0),
+      db.user.count({ where: { userType: "supplier" } }).catch(() => 0),
+    ]);
+
+  // Get total users count (without filters)
+  const totalUsersCount = await db.user.count();
+  const totalActiveCount = await db.user.count({ where: { isActive: true } });
+  const employees = Math.max(0, totalUsersCount - customers - suppliers);
+
+  // Transform data
+  const data: UserWithDetails[] = (users as any[]).map((user: any) => ({
+    id: user.id,
+    name: user.name,
+    email: user.email,
+    image: user.image,
+    isActive: user.isActive,
+    userType: user.userType || "employee", // Added userType
+    supplierId: user.profiles?.supplierId || "", // Added supplierId
+    address: user.profiles?.address || "", // Added address
+    phone: user.profiles?.phone || "",     // Added phone
+    gender: user.profiles?.gender || "",
+    birthday: user.profiles?.dateOfBirth || null,
+    groupId: user.profiles?.groupId || "",
+    idNumber: user.profiles?.idNumber || "",
+    createdAt: user.createdAt,
+    updatedAt: user.updatedAt,
+    roles: user.userRoles.map((ur: any) => ({
+      code: ur.role.code,
+      name: ur.role.name,
+    })),
+    branches: user.userBranches?.map((ub: any) => ({
+      id: ub.branch?.id,
+      name: ub.branch?.name,
+      isDefault: ub.isDefault,
+    })).filter((b: any) => b.id) || [],
+    branchIds: user.userBranches?.map((ub: any) => ub.branch?.id).filter(Boolean) || [],
+    branchNames: user.userBranches?.map((ub: any) => ub.branch?.name).filter(Boolean) || [],
+    department: user.profiles?.departmentRef || null,
+    jobTitle: user.profiles?.jobTitleRef || null,
+  }));
+
+  return {
+    data,
+    total,
+    page,
+    pageSize,
+    stats: {
+      totalUsers: totalUsersCount,
+      activeUsers: totalActiveCount,
+      inactiveUsers: totalUsersCount - totalActiveCount,
+      totalRoles: rolesCount,
+      employees,
+      customers,
+      suppliers,
+    },
+  };
+}
+
+/**
+ * Get all active roles for filter dropdown
+ */
+export async function getActiveRoles(db: UserPrismaClient) {
+  const roles = await db.role.findMany({
+    where: { status: "active" },
+    select: {
+      code: true,
+      name: true,
+      status: true,
+    },
+    orderBy: { name: "asc" },
+  });
+  return roles;
+}
+
+/**
+ * Get all active departments for filter dropdown
+ */
+export async function getActiveDepartments(db: UserPrismaClient) {
+  const departments = await db.department.findMany({
+    where: { status: "active" },
+    select: {
+      id: true,
+      code: true,
+      name: true,
+    },
+    orderBy: { order: "asc" },
+  });
+  return departments;
+}
+
+/**
+ * Get user statistics
+ */
+export async function getUserStats(db: UserPrismaClient) {
+  const [totalUsers, activeUsers, customers, suppliers, totalRoles] =
+    await Promise.all([
+      db.user.count(),
+      db.user.count({ where: { isActive: true } }),
+      db.user.count({ where: { userType: "customer" } }).catch(() => 0),
+      db.user.count({ where: { userType: "supplier" } }).catch(() => 0),
+      db.role.count({ where: { status: "active" } }),
+    ]);
+
+  // Employees are users that are not customers or suppliers
+  const employees = Math.max(0, totalUsers - customers - suppliers);
+
+  return {
+    totalUsers,
+    activeUsers,
+    inactiveUsers: totalUsers - activeUsers,
+    totalRoles,
+    employees,
+    customers,
+    suppliers,
+  };
+}
+
+/**
+ * Get user profile by ID
+ */
+export async function getUserProfile(db: UserPrismaClient, userId: string) {
+  const user = await db.user.findUnique({
+    where: { id: userId },
+    select: {
+      id: true,
+      name: true,
+      email: true,
+      image: true,
+      isActive: true,
+      createdAt: true,
+      updatedAt: true,
+      userType: true, // Added userType
+      userRoles: {
+        select: {
+          role: {
+            select: {
+              code: true,
+              name: true,
+            },
+          },
+        },
+      },
+      // Removed invalid userSuppliers selection
+      profiles: {
+        select: {
+          departmentRef: {
+            select: {
+              id: true,
+              name: true,
+              code: true,
+            },
+          },
+          jobTitleRef: {
+            select: {
+              id: true,
+              name: true,
+              code: true,
+            },
+          },
+          address: true, // Added address
+          phone: true,   // Added phone
+          gender: true,
+          dateOfBirth: true,
+          groupId: true,
+          idNumber: true,
+          supplierId: true, // Select supplierId from profiles
+          supplier: {
+            select: {
+              name: true
+            }
+          }
+        },
+      },
+    },
+  });
+
+  if (!user) return null;
+
+  // Map to UserType expected by ProfilePage
+  const nameParts = (user.name || "").split(" ");
+  const lastName = nameParts.pop() || "";
+  const firstName = nameParts.join(" ");
+
+  return {
+    id: user.id,
+    firstName: firstName,
+    lastName: lastName,
+    name: user.name || "",
+    username: user.email?.split("@")[0] || "",
+    email: user.email || "",
+    avatar: user.image || "",
+    role: user.userRoles?.[0]?.role?.name || "User",
+    background: "",
+    status: user.isActive ? "active" : "inactive",
+    phoneNumber: user.profiles?.phone || "",
+    state: "",
+    country: "",
+    address: user.profiles?.address || "",
+    zipCode: "",
+    language: "English",
+    timeZone: "GMT+07:00",
+    currency: "USD",
+    organization: "",
+    twoFactorAuth: false,
+    loginAlerts: false,
+    connections: 0,
+    followers: 0,
+  };
+}