@holoyan/adonisjs-permissions 0.5.0 → 0.5.2

package/build/src/services/permissions/permissions_service.js

@@ -288,6 +288,16 @@ export default class PermissionsService extends BaseService {
             const newPermissions = (await this.permissionClassName.createMany(createManyData));
             newPermissions.map((i) => permissionIds.push(i.id));
         }
+        // first check if there are assigned or not
+        const alreadyAssigned = await this.modelPermissionQuery
+            .whereIn('id', permissionIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const alreadyAssignedIds = alreadyAssigned.map((item) => item.id);
+        permissionIds = permissionIds.filter((item) => {
+            return !alreadyAssignedIds.includes(item);
+        });
         let modelPermissionMany = permissionIds.map((i) => ({
             modelType: modelType,
             modelId: modelId,

package/build/src/services/roles/roles_service.js

@@ -36,12 +36,14 @@ export default class RolesService extends BaseService {
     }
     modelRolesQuery(modelType, modelId) {
         return this.roleQuery
-            .join(this.modelRoleTable + ' as mr', 'mr.role_id', '=', this.roleTable + '.id')
+            .leftJoin(this.modelRoleTable + ' as mr', 'mr.role_id', '=', this.roleTable + '.id')
             .where('mr.model_type', modelType)
             .where('mr.model_id', modelId);
     }
     all(modelType, modelId) {
-        return this.modelRolesQuery(modelType, modelId).select(this.roleTable + '.*');
+        return this.modelRolesQuery(modelType, modelId)
+            .distinct(this.roleTable + '.id')
+            .select(this.roleTable + '.*');
     }
     has(modelType, modelId, role) {
         return this.hasAll(modelType, modelId, [role]);
@@ -74,29 +76,30 @@ export default class RolesService extends BaseService {
         // @ts-ignore
         return +r[0].$extras.total > 0;
     }
-    async assign(role, modelType, modelId) {
-        const r = await this.extractRoleModel([role]);
-        if (!r.length) {
-            throw new Error('Role  not found');
-        }
-        await this.modelRoleClassName.create({
-            modelType,
-            modelId,
-            roleId: r[0].id,
-        });
-        return true;
+    assign(role, modelType, modelId) {
+        return this.assignAll([role], modelType, modelId);
     }
     async assignAll(roles, modelType, modelId) {
         const rs = await this.extractRoleModel(roles);
         if (!rs.length) {
             throw new Error('One or many roles not found');
         }
+        let roleIds = rs.map((role) => role.id);
+        const modelRoles = await this.modelRoleQuery
+            .whereIn('role_id', roleIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const modelRoleIds = modelRoles.map((modelRole) => modelRole.id);
+        roleIds = roleIds.filter((roleId) => {
+            return !modelRoleIds.includes(roleId);
+        });
         const data = [];
-        for (const r of rs) {
+        for (const id of roleIds) {
             data.push({
                 modelType,
                 modelId,
-                roleId: r.id,
+                roleId: id,
             });
         }
         await this.modelRoleClassName.createMany(data);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holoyan/adonisjs-permissions",
   "description": "Adonisjs roles and permissions system",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "engines": {
     "node": ">=18.16.0"
   },