@nocobase/plugin-departments 2.0.0-alpha.48 → 2.0.0-alpha.49

package/dist/server/actions/users.js

@@ -81,35 +81,21 @@ const setDepartments = async (ctx, next) => {
   const owners = departments.filter((department) => department.isOwner);
   await ctx.db.sequelize.transaction(async (t) => {
     await user.setDepartments(departmentIds, {
-      through: {
-        isMain: false,
-        isOwner: false
-      },
+      through: { isOwner: false },
+      transaction: t
+    });
+    await repo.update({
+      filterByTk: userId,
+      values: { mainDepartmentId: main ? main.id : null },
       transaction: t
     });
-    if (main) {
-      await throughRepo.update({
-        filter: {
-          userId,
-          departmentId: main.id
-        },
-        values: {
-          isMain: true
-        },
-        transaction: t
-      });
-    }
     if (owners.length) {
       await throughRepo.update({
         filter: {
           userId,
-          departmentId: {
-            $in: owners.map((owner) => owner.id)
-          }
-        },
-        values: {
-          isOwner: true
+          departmentId: { $in: owners.map((o) => o.id) }
         },
+        values: { isOwner: true },
         transaction: t
       });
     }
@@ -118,28 +104,28 @@ const setDepartments = async (ctx, next) => {
 };
 const setMainDepartment = async (ctx, next) => {
   const { userId, departmentId } = ctx.action.params.values || {};
+  const repo = ctx.db.getRepository("users");
   const throughRepo = ctx.db.getRepository("departmentsUsers");
   await ctx.db.sequelize.transaction(async (t) => {
-    await throughRepo.update({
-      filter: {
-        userId,
-        isMain: true
-      },
-      values: {
-        isMain: false
-      },
+    await repo.update({
+      filterByTk: userId,
+      values: { mainDepartmentId: departmentId },
       transaction: t
     });
-    await throughRepo.update({
-      filter: {
-        userId,
-        departmentId
-      },
-      values: {
-        isMain: true
-      },
+    const existingAssoc = await throughRepo.findOne({
+      filter: { userId, departmentId },
       transaction: t
     });
+    if (!existingAssoc) {
+      await throughRepo.create({
+        values: {
+          userId,
+          departmentId,
+          isOwner: false
+        },
+        transaction: t
+      });
+    }
   });
   await next();
 };

package/dist/server/collections/departmentsUsers.js

@@ -38,14 +38,16 @@ var departmentsUsers_default = (0, import_database.defineCollection)({
     {
       type: "boolean",
       name: "isOwner",
-      // Weather the user is the owner of the department
       allowNull: false,
       defaultValue: false
     },
+    /**
+     * @deprecated
+     * use `user.mainDepartmentId` instead
+     */
     {
       type: "boolean",
       name: "isMain",
-      // Weather this is the main department of the user
       allowNull: false,
       defaultValue: false
     }

package/dist/server/collections/users.d.ts

@@ -38,14 +38,9 @@ export declare const mainDepartmentField: {
     name: string;
     target: string;
     foreignKey: string;
-    otherKey: string;
     onDelete: string;
     sourceKey: string;
     targetKey: string;
-    through: string;
-    throughScope: {
-        isMain: boolean;
-    };
     uiSchema: {
         type: string;
         title: string;
@@ -59,6 +54,18 @@ export declare const mainDepartmentField: {
         };
     };
 };
+export declare const mainDepartmentIdField: {
+    collectionName: string;
+    interface: string;
+    type: string;
+    name: string;
+    uiSchema: {
+        type: string;
+        title: string;
+        'x-component': string;
+        'x-read-pretty': boolean;
+    };
+};
 declare const _default: {
     collectionOptions: import("@nocobase/database").CollectionOptions;
     mergeOptions: import("deepmerge").Options;

package/dist/server/collections/users.js

@@ -28,7 +28,8 @@ var users_exports = {};
 __export(users_exports, {
   default: () => users_default,
   departmentsField: () => departmentsField,
-  mainDepartmentField: () => mainDepartmentField
+  mainDepartmentField: () => mainDepartmentField,
+  mainDepartmentIdField: () => mainDepartmentIdField
 });
 module.exports = __toCommonJS(users_exports);
 var import_database = require("@nocobase/database");
@@ -52,45 +53,53 @@ const departmentsField = {
       multiple: true,
       fieldNames: {
         label: "title",
-        value: "name"
+        value: "id"
       }
     }
   }
 };
 const mainDepartmentField = {
   collectionName: "users",
-  interface: "m2m",
-  type: "belongsToMany",
+  interface: "m2o",
+  type: "belongsTo",
   name: "mainDepartment",
   target: "departments",
-  foreignKey: "userId",
-  otherKey: "departmentId",
-  onDelete: "CASCADE",
+  foreignKey: "mainDepartmentId",
+  onDelete: "SET NULL",
   sourceKey: "id",
   targetKey: "id",
-  through: "departmentsUsers",
-  throughScope: {
-    isMain: true
-  },
   uiSchema: {
-    type: "m2m",
+    type: "string",
     title: '{{t("Main department")}}',
-    "x-component": "UserMainDepartmentField",
+    "x-component": "AssociationField",
     "x-component-props": {
       multiple: false,
       fieldNames: {
         label: "title",
-        value: "name"
+        value: "id"
       }
     }
   }
 };
+const mainDepartmentIdField = {
+  collectionName: "users",
+  interface: "inputNumber",
+  type: "bigInt",
+  name: "mainDepartmentId",
+  uiSchema: {
+    type: "number",
+    title: "mainDepartmentId",
+    "x-component": "InputNumber",
+    "x-read-pretty": true
+  }
+};
 var users_default = (0, import_database.extendCollection)({
   name: "users",
-  fields: [departmentsField, mainDepartmentField]
+  fields: [departmentsField, mainDepartmentField, mainDepartmentIdField]
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   departmentsField,
-  mainDepartmentField
+  mainDepartmentField,
+  mainDepartmentIdField
 });

package/dist/server/department-data-sync-resource.js

@@ -177,6 +177,10 @@ class DepartmentDataSyncResource extends import_plugin_user_data_sync.UserDataRe
       if (userDepartments.length) {
         await user.removeDepartments(userDepartments);
       }
+      await this.userRepo.update({
+        filterByTk: user.id,
+        values: { mainDepartmentId: null }
+      });
       if (currentDepartmentIds && currentDepartmentIds.length) {
         return currentDepartmentIds.map((id) => ({ resourcesPk: id, isDeleted: true }));
       } else {
@@ -190,9 +194,7 @@ class DepartmentDataSyncResource extends import_plugin_user_data_sync.UserDataRe
         return sourceDepartment.uid;
       });
       const newDepartmentIds = await this.getDepartmentIdsBySourceUks(sourceDepartmentIds, sourceName);
-      const newDepartments = await this.deptRepo.find({
-        filter: { id: { $in: newDepartmentIds } }
-      });
+      const newDepartments = await this.deptRepo.find({ filter: { id: { $in: newDepartmentIds } } });
       const realCurrentDepartments = await user.getDepartments();
       const toRealRemoveDepartments = realCurrentDepartments.filter((currnetDepartment) => {
         return !newDepartments.find((newDepartment) => newDepartment.id === currnetDepartment.id);
@@ -209,6 +211,7 @@ class DepartmentDataSyncResource extends import_plugin_user_data_sync.UserDataRe
       if (toRealAddDepartments.length) {
         await user.addDepartments(toRealAddDepartments);
       }
+      let mainDepartmentId = null;
       for (const sourceDepartment of sourceDepartments) {
         this.logger.debug("update dept owner: " + JSON.stringify(sourceDepartment));
         let isOwner = false;
@@ -222,47 +225,41 @@ class DepartmentDataSyncResource extends import_plugin_user_data_sync.UserDataRe
           uid = sourceDepartment;
         }
         const deptId = await this.getDepartmentIdBySourceUk(uid, sourceName);
-        this.logger.debug("update dept owner: " + JSON.stringify({ deptId, isOwner, isMain, userId: user.id }));
+        this.logger.debug(
+          "update dept owner: " + JSON.stringify({ deptId, isOwner, mainDepartmentId: isMain ? deptId : null, userId: user.id })
+        );
         if (!deptId) {
           continue;
         }
         await this.deptUserRepo.update({
-          filter: {
-            userId: user.id,
-            departmentId: deptId
-          },
-          values: {
-            isOwner,
-            isMain
-          }
+          filter: { userId: user.id, departmentId: deptId },
+          values: { isOwner }
         });
+        if (isMain) {
+          mainDepartmentId = deptId;
+        }
       }
+      await this.userRepo.update({
+        filterByTk: user.id,
+        values: { mainDepartmentId }
+      });
       const recordResourceChangeds = [];
       if (currentDepartmentIds !== void 0 && currentDepartmentIds.length > 0) {
         const toRemoveDepartmentIds = currentDepartmentIds.filter(
           (currentDepartmentId) => !newDepartmentIds.includes(currentDepartmentId)
         );
         recordResourceChangeds.push(
-          ...toRemoveDepartmentIds.map((departmentId) => {
-            return { resourcesPk: departmentId, isDeleted: true };
-          })
+          ...toRemoveDepartmentIds.map((departmentId) => ({ resourcesPk: departmentId, isDeleted: true }))
         );
         const toAddDepartmentIds = newDepartmentIds.filter(
           (newDepartmentId) => !currentDepartmentIds.includes(newDepartmentId)
         );
         recordResourceChangeds.push(
-          ...toAddDepartmentIds.map((departmentId) => {
-            return { resourcesPk: departmentId, isDeleted: false };
-          })
+          ...toAddDepartmentIds.map((departmentId) => ({ resourcesPk: departmentId, isDeleted: false }))
         );
       } else {
         recordResourceChangeds.push(
-          ...toRealAddDepartments.map((department) => {
-            return {
-              resourcesPk: department.id,
-              isDeleted: false
-            };
-          })
+          ...toRealAddDepartments.map((department) => ({ resourcesPk: department.id, isDeleted: false }))
         );
       }
       return recordResourceChangeds;

package/dist/server/middlewares/set-departments-roles.js

@@ -47,7 +47,7 @@ const setDepartmentsInfo = async (ctx, next) => {
     return next();
   }
   ctx.state.currentUser.departments = departments;
-  ctx.state.currentUser.mainDeparmtent = departments.find((dept) => dept.isMain);
+  ctx.state.currentUser.mainDeparmtent = departments.find((dept) => dept.id === currentUser.mainDepartmentId);
   const departmentIds = departments.map((dept) => dept.id);
   const roleRepo = ctx.db.getRepository("roles");
   const roles = await roleRepo.find({

package/dist/server/middlewares/set-main-department.js

@@ -30,80 +30,70 @@ __export(set_main_department_exports, {
 });
 module.exports = __toCommonJS(set_main_department_exports);
 const setMainDepartment = async (ctx, next) => {
+  var _a, _b;
   await next();
-  const { associatedName, resourceName, associatedIndex, actionName, values } = ctx.action.params;
+  const { associatedName, resourceName, associatedIndex, actionName, values, filterByTk } = ctx.action.params;
   if (associatedName === "departments" && resourceName === "members" && (values == null ? void 0 : values.length)) {
+    const userRepo = ctx.db.getRepository("users");
     const throughRepo = ctx.db.getRepository("departmentsUsers");
-    const usersHasMain = await throughRepo.find({
-      filter: {
-        userId: {
-          $in: values
-        },
-        isMain: true
-      }
-    });
-    const userIdsHasMain = usersHasMain.map((item) => item.userId);
     if (actionName === "add" || actionName === "set") {
-      await throughRepo.update({
-        filter: {
-          userId: {
-            $in: values.filter((id) => !userIdsHasMain.includes(id))
-          },
-          departmentId: associatedIndex
-        },
-        values: {
-          isMain: true
+      for (const userId of values) {
+        const user = await userRepo.findOne({ filterByTk: userId, fields: ["id", "mainDepartmentId"] });
+        if (!(user == null ? void 0 : user.mainDepartmentId)) {
+          await userRepo.update({
+            filterByTk: userId,
+            values: { mainDepartmentId: associatedIndex }
+          });
         }
-      });
+      }
       return;
     }
     if (actionName === "remove") {
-      const userIdsHasNoMain = values.filter((id) => !userIdsHasMain.includes(id));
-      for (const userId of userIdsHasNoMain) {
-        const firstDept = await throughRepo.findOne({
-          filter: {
-            userId
-          }
-        });
-        if (firstDept) {
-          await throughRepo.update({
-            filter: {
-              userId,
-              departmentId: firstDept.departmentId
-            },
-            values: {
-              isMain: true
-            }
+      for (const userId of values) {
+        const user = await userRepo.findOne({ filterByTk: userId, fields: ["id", "mainDepartmentId"] });
+        if ((user == null ? void 0 : user.mainDepartmentId) === Number(associatedIndex)) {
+          const firstDept = await throughRepo.findOne({
+            filter: { userId }
+          });
+          await userRepo.update({
+            filterByTk: userId,
+            values: { mainDepartmentId: firstDept ? firstDept.departmentId : null }
           });
         }
       }
     }
   }
   if (associatedName === "users" && resourceName === "departments" && ["add", "remove", "set"].includes(actionName)) {
+    const userRepo = ctx.db.getRepository("users");
     const throughRepo = ctx.db.getRepository("departmentsUsers");
-    const hasMain = await throughRepo.findOne({
-      filter: {
-        userId: associatedIndex,
-        isMain: true
-      }
-    });
-    if (hasMain) {
-      return;
+    const user = await userRepo.findOne({ filterByTk: associatedIndex, fields: ["id", "mainDepartmentId"] });
+    let hasValidMain = false;
+    if (user == null ? void 0 : user.mainDepartmentId) {
+      const existingAssoc = await throughRepo.findOne({
+        filter: { userId: associatedIndex, departmentId: user.mainDepartmentId }
+      });
+      hasValidMain = !!existingAssoc;
     }
-    const firstDept = await throughRepo.findOne({
-      filter: {
-        userId: associatedIndex
-      }
-    });
-    if (firstDept) {
-      await throughRepo.update({
-        filter: {
-          userId: associatedIndex,
-          departmentId: firstDept.departmentId
-        },
-        values: {
-          isMain: true
-        }
+    if (!hasValidMain) {
+      const firstDept = await throughRepo.findOne({
+        filter: { userId: associatedIndex }
+      });
+      await userRepo.update({
+        filterByTk: associatedIndex,
+        values: { mainDepartmentId: firstDept ? firstDept.departmentId : null }
+      });
+    }
+  }
+  if (resourceName === "users" && actionName === "update") {
+    const userRepo = ctx.db.getRepository("users");
+    const throughRepo = ctx.db.getRepository("departmentsUsers");
+    const userId = associatedIndex ?? filterByTk ?? ((_b = (_a = ctx.body) == null ? void 0 : _a.data) == null ? void 0 : _b.id);
+    if (!userId) return;
+    const deptUsers = await throughRepo.find({ filter: { userId } });
+    if (deptUsers.length === 1) {
+      await userRepo.update({
+        filterByTk: userId,
+        values: { mainDepartmentId: deptUsers[0].departmentId }
       });
     }
   }

package/dist/server/migrations/migrate-main-department-id-20250828100101.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/migrate-main-department-id-20250828100101.js

@@ -0,0 +1,133 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var migrate_main_department_id_20250828100101_exports = {};
+__export(migrate_main_department_id_20250828100101_exports, {
+  default: () => migrate_main_department_id_20250828100101_default
+});
+module.exports = __toCommonJS(migrate_main_department_id_20250828100101_exports);
+var import_server = require("@nocobase/server");
+class migrate_main_department_id_20250828100101_default extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = "<2.0.0";
+  async up() {
+    await this.db.sequelize.transaction(async (transaction) => {
+      var _a, _b;
+      const users = this.db.getCollection("users");
+      const departments = this.db.getCollection("departments");
+      if (!users || !departments) {
+        return;
+      }
+      const fieldRepo = this.db.getRepository("fields");
+      if (!fieldRepo) {
+        return;
+      }
+      const currentMainField = await fieldRepo.findOne({
+        filter: {
+          collectionName: "users",
+          name: "mainDepartment"
+        },
+        transaction
+      });
+      const iface = (_a = currentMainField == null ? void 0 : currentMainField.get) == null ? void 0 : _a.call(currentMainField, "interface");
+      const type = (_b = currentMainField == null ? void 0 : currentMainField.get) == null ? void 0 : _b.call(currentMainField, "type");
+      const shouldMigrate = !currentMainField || type === "belongsToMany" || iface === "m2m";
+      if (!shouldMigrate) {
+        return;
+      }
+      const rows = await this.db.getRepository("departmentsUsers").find({
+        filter: {
+          isMain: true
+        },
+        fields: ["userId", "departmentId"],
+        transaction
+      });
+      for (const row of rows) {
+        await this.db.getRepository("users").update({
+          filter: {
+            id: row.userId
+          },
+          values: {
+            mainDepartmentId: row.departmentId
+          },
+          transaction,
+          hooks: false
+        });
+      }
+      await fieldRepo.destroy({
+        filter: {
+          collectionName: "departmentsUsers",
+          name: "isMain"
+        },
+        transaction
+      });
+      const mainDepartmentField = await fieldRepo.findOne({
+        filter: {
+          collectionName: "users",
+          name: "mainDepartment"
+        },
+        transaction
+      });
+      if (mainDepartmentField) {
+        const nextOptions = {
+          ...mainDepartmentField.options || {},
+          target: "departments",
+          foreignKey: "mainDepartmentId",
+          onDelete: "SET NULL",
+          sourceKey: "id",
+          targetKey: "id",
+          uiSchema: {
+            type: "string",
+            title: '{{t("Main department")}}',
+            "x-component": "AssociationField",
+            "x-component-props": {
+              multiple: false,
+              fieldNames: {
+                label: "title",
+                value: "id"
+              }
+            }
+          }
+        };
+        delete nextOptions.through;
+        delete nextOptions.otherKey;
+        delete nextOptions.throughScope;
+        await fieldRepo.update({
+          filter: {
+            collectionName: "users",
+            name: "mainDepartment"
+          },
+          values: {
+            type: "belongsTo",
+            interface: "m2o",
+            options: nextOptions
+          },
+          transaction
+        });
+      }
+    });
+  }
+}

package/dist/server/plugin.d.ts

@@ -15,5 +15,6 @@ export declare class PluginDepartmentsServer extends Plugin {
     afterEnable(): Promise<void>;
     afterDisable(): Promise<void>;
     remove(): Promise<void>;
+    registerErrorHandler(): void;
 }
 export default PluginDepartmentsServer;