Formatted Code

Author: yubarajshrestha

config/database.py

@@ -0,0 +1,56 @@
+from masonite.environment import LoadEnvironment, env
+from masoniteorm.connections import ConnectionResolver
+
+#  Loads in the environment variables when this page is imported.
+LoadEnvironment()
+
+"""
+The connections here don't determine the database but determine the "connection".
+They can be named whatever you want.
+"""
+DATABASES = {
+    "default": env("DB_CONNECTION", "sqlite"),
+    "sqlite": {
+        "driver": "sqlite",
+        "database": env("SQLITE_DB_DATABASE", "masonite.sqlite3"),
+        "prefix": "",
+        "log_queries": env("DB_LOG"),
+    },
+    "mysql": {
+        "driver": "mysql",
+        "host": env("DB_HOST"),
+        "user": env("DB_USERNAME"),
+        "password": env("DB_PASSWORD"),
+        "database": env("DB_DATABASE"),
+        "port": env("DB_PORT"),
+        "prefix": "",
+        "grammar": "mysql",
+        "options": {
+            "charset": "utf8mb4",
+        },
+        "log_queries": env("DB_LOG"),
+    },
+    "postgres": {
+        "driver": "postgres",
+        "host": env("DB_HOST"),
+        "user": env("DB_USERNAME"),
+        "password": env("DB_PASSWORD"),
+        "database": env("DB_DATABASE"),
+        "port": env("DB_PORT"),
+        "prefix": "",
+        "grammar": "postgres",
+        "log_queries": env("DB_LOG"),
+    },
+    "mssql": {
+        "driver": "mssql",
+        "host": env("MSSQL_DATABASE_HOST"),
+        "user": env("MSSQL_DATABASE_USER"),
+        "password": env("MSSQL_DATABASE_PASSWORD"),
+        "database": env("MSSQL_DATABASE_DATABASE"),
+        "port": env("MSSQL_DATABASE_PORT"),
+        "prefix": "",
+        "log_queries": env("DB_LOG"),
+    },
+}
+
+DB = ConnectionResolver().set_connection_details(DATABASES)

config renamed to config_

@@ -1,2 +1,5 @@
 masonite>=4,<5
 masonite-orm>=2,<3
+flake8==4.0.1
+pyflakes==2.4.0
+black==22.3.0

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.5",
+    version="0.1.6",
     packages=[
         "masonite_permission",
         "masonite_permission.config",

requirements.txt

@@ -8,13 +8,13 @@ def up(self):
         with self.schema.create("roles") as table:
             table.increments("id")
             table.string("name").nullable()
-            table.string("slug")
+            table.string("slug").unique()
             table.timestamps()
 
         with self.schema.create("permissions") as table:
             table.increments("id")
             table.string("name").nullable()
-            table.string("slug")
+            table.string("slug").unique()
             table.timestamps()
 
         # user, role, permission polymorphic relationship
@@ -37,6 +37,6 @@ def down(self):
         """Revert the migrations."""
 
         self.schema.drop("role_user")
-        self.schema.drop("permission_role")
+        self.schema.drop("model_has_permissions")
         self.schema.drop("permissions")
         self.schema.drop("roles")

setup.py

@@ -38,14 +38,22 @@ def attach_permission(self, permission):
         """
         from ..models.permission import Permission
 
-        if isinstance(permission, int) or isinstance(permission, str):
-            permission = Permission.find(int(permission))
+        if isinstance(permission, int):
+            permission = Permission.find(permission)
+            if not permission:
+                raise PermissionException(f"Permission: with id {permission} does not exist!")
+
+        elif isinstance(permission, str):
+            permission = Permission.where("slug", permission).first()
+            if not permission:
+                raise PermissionException(f"Permission: {permission} does not exist!")
 
         exists = (
             QueryBuilder()
-            .table("permission_role")
-            .where("role_id", self.id)
+            .table("model_has_permissions")
+            .where("permissionable_id", self.id)
             .where("permission_id", permission.id)
+            .where("permissionable_type", self.get_table_name())
             .count()
         )
 
@@ -60,15 +68,22 @@ def detach_permission(self, permission):
         """
         from ..models.permission import Permission
 
-        permission = Permission.where_slug(permission).first()
-        if not permission:
-            raise PermissionException(f"Permission: {permission} does not exist!")
+        if isinstance(permission, int):
+            permission = Permission.find(permission)
+            if not permission:
+                raise PermissionException(f"Permission: with id {permission} does not exist!")
+
+        elif isinstance(permission, str):
+            permission = Permission.where("slug", permission).first()
+            if not permission:
+                raise PermissionException(f"Permission: {permission} does not exist!")
 
         exists = (
             QueryBuilder()
-            .table("permission_role")
-            .where("role_id", self.id)
+            .table("model_has_permissions")
+            .where("permissionable_id", self.id)
             .where("permission_id", permission.id)
+            .where("permissionable_type", self.get_table_name())
             .count()
         )
 
@@ -126,31 +141,50 @@ def sync_permissions(self, *args):
         """Sync permissions from related model"""
         from ..models.permission import Permission
 
+        permission_ids = []
+        permission_slugs = []
+        found_ids = []
+
+        if len(args) == 0:
+            QueryBuilder().table("model_has_permissions").where(
+                "permissionable_id", self.id
+            ).where("permissionable_type", self.get_table_name()).delete()
+            return
+
         if type(args[0]) == list:
             args = args[0]
 
-        permissions = Permission.where_in("slug", args).get()
-        slugs = permissions.pluck("slug")
-        diff = set(args) - set(slugs)
-        if len(diff) > 0:
-            diff_permissions = ", ".join(list(diff))
-            raise PermissionException(f"Permission: {diff_permissions} does not exist!")
+        for permission in args:
+            if isinstance(permission, int):
+                permission_ids.append(permission)
+            elif isinstance(permission, str):
+                permission_slugs.append(permission)
+            elif isinstance(permission, Permission):
+                found_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 = list(dict.fromkeys(found_ids + permission_by_id + permission_by_slug))
 
         data = []
-        for permission in permissions:
+        for permission in ids:
             data.append(
                 {
-                    "permission_id": permission.id,
+                    "permission_id": permission,
                     "permissionable_id": self.id,
                     "permissionable_type": self.get_table_name(),
                 }
             )
 
-        QueryBuilder().table("model_has_permissions").where("permissionable_id", self.id).where(
+        query = QueryBuilder().table("model_has_permissions")
+
+        query.where("permissionable_id", self.id).where(
             "permissionable_type", self.get_table_name()
         ).delete()
+
         if len(data) > 0:
-            QueryBuilder().table("model_has_permissions").bulk_create(data)
+            query.bulk_create(data)
 
     def has_permission_to(self, permission):
         if type(permission) != str:

src/masonite_permission/migrations/create_permissions_table.py

@@ -1,5 +1,4 @@
 from masoniteorm.query import QueryBuilder
-from masoniteorm.collection.Collection import Collection
 
 from ..exceptions import PermissionException
 
@@ -49,20 +48,44 @@ def has_all_roles(self, *args):
 
         return set(slugs).issubset(roles) and len(set(slugs) - set(roles)) == 0
 
-    def sync_roles(self, roles):
+    def sync_roles(self, *args):
         """Assign a role to a user"""
         from ..models.role import Role
 
-        if type(roles) != Collection and type(roles) != list:
-            raise PermissionException("roles must be a collection of roles or list of role ids!")
+        role_ids = []
+        role_slugs = []
+        found_ids = []
 
-        if len(roles) != 0:
-            role = roles[0]
-            if isinstance(role, int) or isinstance(role, str):
-                roles = Role.where_in("id", roles).get()
+        if len(args) == 0:
+            QueryBuilder().table("role_user").where("user_id", self.id).delete()
+            return
 
-        QueryBuilder().table("role_user").where("user_id", self.id).delete()
-        self.save_many("roles", roles)
+        if type(args[0]) == list:
+            args = args[0]
+
+        for role in args:
+            if isinstance(role, int):
+                role_ids.append(role)
+            elif isinstance(role, str):
+                role_slugs.append(role)
+            elif isinstance(role, Role):
+                found_ids.append(role.id)
+
+        role_by_id = list(Role.where_in("id", role_ids).get().pluck("id"))
+        role_by_slug = list(Role.where_in("slug", role_slugs).get().pluck("id"))
+
+        ids = list(dict.fromkeys(found_ids + role_by_id + role_by_slug))
+
+        data = []
+        for role in ids:
+            data.append({"user_id": self.id, "role_id": role})
+
+        query = QueryBuilder().table("role_user")
+
+        query.where("user_id", self.id).delete()
+
+        if len(data) > 0:
+            query.bulk_create(data)
 
     def assign_role(self, role):
         """Assign a role to a user

src/masonite_permission/mixins/has_permissions.py

@@ -26,32 +26,48 @@ def sync_roles(self, *args):
         """Sync roles from related model"""
         from ..models.role import Role
 
+        role_ids = []
+        role_slugs = []
+        found_ids = []
+
+        if len(args) == 0:
+            QueryBuilder().table("model_has_permissions").where(
+                "permissionable_type", "roles"
+            ).where("permission_id", self.id).delete()
+            return
+
         if type(args[0]) == list:
             args = args[0]
 
-        roles = Role.where_in("slug", args).get()
-        slugs = roles.pluck("slug")
-        diff = set(args) - set(slugs)
+        for role in args:
+            if isinstance(role, int):
+                role_ids.append(role)
+            elif isinstance(role, str):
+                role_slugs.append(role)
+            elif isinstance(role, Role):
+                found_ids.append(role.id)
 
-        if len(diff) > 0:
-            diff_roles = ", ".join(list(diff))
-            raise PermissionException(f"Role: {diff_roles} does not exist!")
+        role_by_id = list(Role.where_in("id", role_ids).get().pluck("id"))
+        role_by_slug = list(Role.where_in("slug", role_slugs).get().pluck("id"))
+
+        ids = list(dict.fromkeys(found_ids + role_by_id + role_by_slug))
 
         data = []
-        for role in roles:
+        for role in ids:
             data.append(
                 {
                     "permission_id": self.id,
-                    "permissionable_id": role.id,
+                    "permissionable_id": role,
                     "permissionable_type": "roles",
                 }
             )
 
-        QueryBuilder().table("model_has_permissions").where("permissionable_type", "roles").where(
-            "permission_id", self.id
-        ).delete()
+        query = QueryBuilder().table("model_has_permissions")
+
+        query.where("permissionable_type", "roles").where("permission_id", self.id).delete()
+
         if len(data) > 0:
-            QueryBuilder().table("model_has_permissions").bulk_create(data)
+            query.bulk_create(data)
 
     def attach_role(self, role):
         """Assign a role to a role
@@ -65,6 +81,10 @@ def attach_role(self, role):
             role = Role.where("slug", role).first()
             if not role:
                 raise PermissionException(f"Role: {role} does not exist!")
+        elif type(role) == int:
+            role = Role.find(role)
+            if not role:
+                raise PermissionException(f"Role: with id {role} does not exist!")
 
         exists = (
             QueryBuilder()
@@ -96,6 +116,10 @@ def detach_role(self, role):
             role = Role.where("slug", role).first()
             if not role:
                 raise PermissionException(f"Role: {role} does not exist!")
+        elif type(role) == int:
+            role = Role.find(role)
+            if not role:
+                raise PermissionException(f"Role: with id {role} does not exist!")
 
         exists = (
             QueryBuilder()