Refactored Query

Author: yubarajshrestha

README.md

@@ -22,8 +22,6 @@
 
 Associate users with roles and permissions to control access to your application.
 
-> Note: Give a try and let me know :).
-
 ## Getting Started
 
 Install the package using pip:
@@ -353,14 +351,6 @@ Checking if user can do all of the {permissions}
 
 Please read the [Contributing Documentation](CONTRIBUTING.md) here.
 
-## Maintainers
-
-- [Yubaraj Shrestha](https://www.github.com/yubarajshrestha)
-
 ## License
 
 Masonite Permission is open-sourced software licensed under the [MIT license](LICENSE).
-
-```
-
-```

masonite.sqlite3

@@ -8,7 +8,7 @@
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version="0.1.6",
+    version="0.1.7",
     packages=[
         "masonite_permission",
         "masonite_permission.config",

setup.py

@@ -7,28 +7,19 @@ class HasPermissions:
     def permissions(self):
         from ..models.permission import Permission
 
-        table = self.get_table_name()
-
-        direct_permissions = (
-            Permission.join(
-                "model_has_permissions as mhp", "mhp.permission_id", "=", "permissions.id"
-            )
-            .where("mhp.permissionable_id", self.id)
-            .where("mhp.permissionable_type", table)
-            .select_raw("permissions.*")
-            .get()
-        )
-
-        indirect_permissions = (
-            Permission.join(
-                "model_has_permissions as mhp", "mhp.permission_id", "=", "permissions.id"
-            )
-            .where_in("mhp.permissionable_id", self.roles().pluck("id"))
-            .where("mhp.permissionable_type", "roles")
-            .select_raw("permissions.*")
-            .get()
+        return (
+            Permission.where_in("id", lambda q: (
+                q.table("model_has_permissions")
+                .select("model_has_permissions.permission_id")
+                .where_raw(f"""
+                    (model_has_permissions.permissionable_type = 'users' and model_has_permissions.permissionable_id = {self.id})
+                    or
+                    (model_has_permissions.permissionable_type = 'roles' and model_has_permissions.permissionable_id in (
+                        select role_user.role_id from role_user where role_user.user_id = {self.id}
+                    ))
+                """)
+            )).get()
         )
-        return Collection(list(direct_permissions) + list(indirect_permissions)).unique("slug")
 
     def attach_permission(self, permission):
         """Assign a permission to a role
@@ -143,7 +134,6 @@ def sync_permissions(self, *args):
 
         permission_ids = []
         permission_slugs = []
-        found_ids = []
 
         if len(args) == 0:
             QueryBuilder().table("model_has_permissions").where(
@@ -160,12 +150,16 @@ def sync_permissions(self, *args):
             elif isinstance(permission, str):
                 permission_slugs.append(permission)
             elif isinstance(permission, Permission):
-                found_ids.append(permission.id)
+                permission_ids.append(permission.id)
 
-        permission_by_id = list(Permission.where_in("id", permission_ids).get().pluck("id"))
-        permission_by_slug = list(Permission.where_in("slug", permission_slugs).get().pluck("id"))
+        ids = []
 
-        ids = list(dict.fromkeys(found_ids + permission_by_id + permission_by_slug))
+        if len(permission_ids) > 0 and len(permission_slugs) > 0:
+            ids = Permission.where_raw(f"(id in {permission_ids}) or slug in {permission_slugs}").get().pluck("id")
+        elif len(permission_ids) > 0:
+            ids = list(Permission.where_in("id", permission_ids).get().pluck("id"))
+        elif len(permission_slugs) > 0:
+            ids = list(Permission.where_in("slug", permission_slugs).get().pluck("id"))
 
         data = []
         for permission in ids:
@@ -203,12 +197,6 @@ def has_any_permission(self, *args):
 
         permissions = self.permissions().pluck("slug")
 
-        # get items that are not in the permissions
-        # permissions_diff = set(slugs) - set(permissions)
-        # if len(permissions_diff) > 0:
-        #     diff_permissions = ", ".join(list(permissions_diff))
-        #     raise PermissionException(f"Permission: {diff_permissions} does not exist!")
-
         result = set(slugs).intersection(permissions)
 
         return len(result) > 0

src/masonite_permission/mixins/has_permissions.py

@@ -5,6 +5,8 @@
 from src.masonite_permission.models.permission import Permission
 from src.masonite_permission.models.role import Role
 from tests.integrations.app.models.User import User
+from masoniteorm.expressions import JoinClause
+from masoniteorm.query import QueryBuilder
 
 
 class WelcomeController(Controller):
@@ -18,13 +20,61 @@ def show(self, view: View):
         return view.render("welcome", {"user": user})
 
     def test(self):
+        user = User.first()
+        role = Role.first()
+
+        # user.sync_permissions(["create-post", "edit-user"])
+        # role.sync_permissions(["create-user", "edit-user", "delete-user"])
+
+        return user.permissions()
+        
+        # user_two = User.create(
+        #     {
+        #         "name": "John",
+        #         "email": "john@example.com",
+        #         "password": "OK",
+        #         "phone": "+123456789",
+        #     }
+        # )
+
+        # user_two.sync_permissions("delete-user")
+
+        return (
+            QueryBuilder().table("permissions").select_raw("permissions.id, permissions.name").where_in("id", lambda q: (
+                q.table("model_has_permissions")
+                .select("model_has_permissions.permission_id")
+                .where_raw(f"""
+                    (model_has_permissions.permissionable_type = 'users' and model_has_permissions.permissionable_id = {user.id})
+                    or
+                    (model_has_permissions.permissionable_type = 'roles' and model_has_permissions.permissionable_id in (
+                        select role_user.role_id from role_user where role_user.user_id = {user.id}
+                    ))
+                """)
+            )).get()
+        )
+
+        return (
+            QueryBuilder().table("permissions")
+            .select_raw("permissions.id, permissions.name, permissions.slug, users.id")
+            .join(pivot_query)
+            .join(role_permission_query)
+            .join(user_permission_query)
+            .group_by("permissions.id, users.id")
+            .where("users.id", 1)
+            .get()
+        )
+
+        user = User.first()
+        admin = Role.where("slug", "admin").first()
+        
+        
+        user.attach_permission("edit-user")
 
-        permission = Permission.where("slug", "create-user").first()
+        admin.sync_permissions(["create-post", "edit-post", "delete-post"])
 
-        permission.sync_roles(["admin", "editor", 3])
+        user.sync_roles(['admin', 'editor'])
 
-        permission.detach_role("admin")
-        permission.attach_role("admin")
+        return user.permissions()
 
         return {
             "roles": permission.roles().serialize(),

tests/integrations/app/controllers/WelcomeController.py

@@ -9,20 +9,20 @@
 They can be named whatever you want.
 """
 DATABASES = {
-    "default": env("DB_CONNECTION", "sqlite"),
+    "default": env("DB_CONNECTION", "postgres"),
     "sqlite": {
         "driver": "sqlite",
         "database": env("SQLITE_DB_DATABASE", "masonite.sqlite3"),
         "prefix": "",
         "log_queries": env("DB_LOG"),
     },
     "mysql": {
+        "host": "127.0.0.1",
         "driver": "mysql",
-        "host": env("DB_HOST"),
-        "user": env("DB_USERNAME"),
-        "password": env("DB_PASSWORD"),
-        "database": env("DB_DATABASE"),
-        "port": env("DB_PORT"),
+        "database": "masonite_permission",
+        "user": "meyubaraj",
+        "password": "MDB@123#go",
+        "port": 3306,
         "prefix": "",
         "grammar": "mysql",
         "options": {
@@ -31,12 +31,12 @@
         "log_queries": env("DB_LOG"),
     },
     "postgres": {
+        "host": "127.0.0.1",
         "driver": "postgres",
-        "host": env("DB_HOST"),
-        "user": env("DB_USERNAME"),
-        "password": env("DB_PASSWORD"),
-        "database": env("DB_DATABASE"),
-        "port": env("DB_PORT"),
+        "database": "masonite_permission",
+        "user": "meyubaraj",
+        "password": "MDB@123#go",
+        "port": 5432,
         "prefix": "",
         "grammar": "postgres",
         "log_queries": env("DB_LOG"),

tests/integrations/config/database.py

@@ -6,7 +6,7 @@
 class TestPermission(TestCase):
     @classmethod
     def setUpClass(cls):
-        QueryBuilder().table("permissions").truncate()
+        QueryBuilder().table("permissions").truncate(True)
 
     def setUp(self):
         super().setUp()
@@ -19,7 +19,8 @@ def setUp(self):
 
     def tearDown(self):
         super().tearDown()
-        QueryBuilder().table("permissions").truncate()
+        QueryBuilder().table("permissions").truncate(True)
+        QueryBuilder().table("roles").truncate(True)
 
     def test_permission_created(self):
         permission = Permission.first()

tests/unit/test_permission.py

@@ -6,7 +6,7 @@
 class TestRole(TestCase):
     @classmethod
     def setUpClass(cls):
-        QueryBuilder().table("roles").truncate()
+        QueryBuilder().table("roles").truncate(True)
 
     def setUp(self):
         super().setUp()
@@ -19,7 +19,7 @@ def setUp(self):
 
     def tearDown(self):
         super().tearDown()
-        QueryBuilder().table("roles").truncate()
+        QueryBuilder().table("roles").truncate(True)
 
     def test_role_created(self):
         role = Role.first()

tests/unit/test_role.py

@@ -9,9 +9,9 @@
 class TestUser(TestCase):
     @classmethod
     def setUpClass(cls):
-        QueryBuilder().table("users").truncate()
-        QueryBuilder().table("roles").truncate()
-        QueryBuilder().table("permissions").truncate()
+        QueryBuilder().table("users").truncate(True)
+        QueryBuilder().table("roles").truncate(True)
+        QueryBuilder().table("permissions").truncate(True)
 
     def setUp(self):
         super().setUp()
@@ -26,9 +26,9 @@ def setUp(self):
 
     def tearDown(self):
         super().tearDown()
-        QueryBuilder().table("users").truncate()
-        QueryBuilder().table("roles").truncate()
-        QueryBuilder().table("permissions").truncate()
+        QueryBuilder().table("users").truncate(True)
+        QueryBuilder().table("roles").truncate(True)
+        QueryBuilder().table("permissions").truncate(True)
 
     def test_user_has_roles(self):
         role = Role.create(