chtech-anythingllm/server/models/deptUsers.js

const prisma = require("../utils/prisma");

/**
 * @typedef {Object} DeptUser
 * @property {number} id
 * @property {number} deptId
 * @property {number} userId
 * @property {Date} createdAt
 * @property {Date} updatedAt
 */

const DeptUsers = {
  writable: ["deptId", "userId"],
  validations: {
    deptId: (newValue) => {
      const num = Number(newValue);
      if (isNaN(num)) {
        throw new Error("Dept ID must be a number");
      }
      return num;
    },
    userId: (newValue) => {
      const num = Number(newValue);
      if (isNaN(num)) {
        throw new Error("User ID must be a number");
      }
      return num;
    },
  },
  castColumnValue: function (key, value) {
    switch (key) {
      case "deptId":
      case "userId":
        return Number(value);
      default:
        return value;
    }
  },

  /**
   * 创建组织机构用户关联
   * @param {Object} data - 组织机构用户数据
   * @returns {Promise<{ deptUser: DeptUser | null, error: string | null }>}
   */
  create: async function (data) {
    console.log("55555555555555555", data);
    try {
      const validatedData = {};
      for (const key of this.writable) {
        if (data[key] !== undefined) {
          if (this.validations[key]) {
            validatedData[key] = this.validations[key](data[key]);
          } else {
            validatedData[key] = this.castColumnValue(key, data[key]);
          }
        }
      }

      const deptUser = await prisma.dept_users.create({
        data: {
          ...validatedData,
          createdAt: new Date(),
          updatedAt: new Date(),
        },
      });

      return { deptUser, error: null };
    } catch (error) {
      console.error("FAILED TO CREATE DEPT USER.", error.message);
      return { deptUser: null, error: error.message };
    }
  },

  /**
   * 更新组织机构用户关联
   * @param {number} id - 关联 ID
   * @param {Object} updates - 更新的字段
   * @returns {Promise<{ success: boolean, error: string | null, deptUser: DeptUser | null }>}
   */
  update: async function (id, updates = {}) {
    try {
      if (!id) throw new Error("No ID provided for update");

      const currentDeptUser = await prisma.dept_users.findUnique({
        where: { id },
      });
      if (!currentDeptUser) throw new Error("Dept user not found");

      const validatedUpdates = {};
      for (const key of this.writable) {
        if (updates[key] !== undefined) {
          if (this.validations[key]) {
            validatedUpdates[key] = this.validations[key](updates[key]);
          } else {
            validatedUpdates[key] = this.castColumnValue(key, updates[key]);
          }
        }
      }

      validatedUpdates.updatedAt = new Date();

      const updatedDeptUser = await prisma.dept_users.update({
        where: { id },
        data: validatedUpdates,
      });

      return { success: true, error: null, deptUser: updatedDeptUser };
    } catch (error) {
      console.error(error.message);
      return { success: false, error: error.message, deptUser: null };
    }
  },

  /**
   * 获取组织机构用户关联
   * @param {Object} clause - 查询条件
   * @returns {Promise<{ deptUser: DeptUser | null }>}
   */
  get: async function (clause = {}) {
    try {
      const deptUser = await prisma.dept_users.findFirst({
        where: clause,
      });
      return deptUser ? { deptUser } : null;
    } catch (error) {
      console.error(error.message);
      return null;
    }
  },

  /**
   * 删除组织机构用户关联
   * @param {Object} clause - 删除条件
   * @returns {Promise<boolean>}
   */
  delete: async function (clause = {}) {
    try {
      const affectedRows = await prisma.dept_users.deleteMany({
        where: clause,
      });
      return affectedRows.count > 0;
    } catch (error) {
      console.error(error.message);
      return false;
    }
  },

  /**
   * 查询组织机构用户关联列表
   * @param {Object} clause - 查询条件
   * @param {number} limit - 限制数量
   * @returns {Promise<DeptUser[]>}
   */
  where: async function (clause = {}, limit = null) {
    try {
      const deptUsers = await prisma.dept_users.findMany({
        where: clause,
        take: limit !== null ? limit : undefined,
      });
      return deptUsers;
    } catch (error) {
      console.error(error.message);
      return [];
    }
  },
};

module.exports = { DeptUsers };