Skip to content

πŸ“š The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.

Finally remove utils.NodePermission function and deploy new authorizer service

Smaug67395d2052c85b2f
diff --git a/backend/controllers/nodes.controller.go b/backend/controllers/nodes.controller.go
index 2b5076c4..14dca201 100644
--- a/backend/controllers/nodes.controller.go
+++ b/backend/controllers/nodes.controller.go
@@ -38,7 +38,7 @@ func NewNodeController(app *app.App) NodeController {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) GetPublicNode(c *gin.Context) (int, any) {
- nodeId, err := utils.GetTargetUserId(c, c.Param("id"))
+ nodeId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
@@ -64,7 +64,7 @@ func (ctr *Controller) GetSharedNodes(c *gin.Context) (int, any) {
return http.StatusUnauthorized, err
}
// Target user ID from param
- targetUserId, err := utils.GetTargetUserId(c, c.Param("userId"))
+ targetUserId, err := utils.GetTargetId(c, c.Param("userId"))
if err != nil {
return http.StatusBadRequest, err
}
@@ -95,7 +95,7 @@ func (ctr *Controller) GetNodes(c *gin.Context) (int, any) {
return http.StatusUnauthorized, err
}
// Target user ID from param
- targetUserId, err := utils.GetTargetUserId(c, c.Param("userId"))
+ targetUserId, err := utils.GetTargetId(c, c.Param("userId"))
if err != nil {
return http.StatusBadRequest, err
}
@@ -122,7 +122,7 @@ func (ctr *Controller) GetNodes(c *gin.Context) (int, any) {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) GetNode(c *gin.Context) (int, any) {
- nodeId, err := utils.GetTargetUserId(c, c.Param("id"))
+ nodeId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
@@ -210,7 +210,7 @@ func (ctr *Controller) CreateNode(c *gin.Context) (int, any) {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) UpdateNode(c *gin.Context) (int, any) {
- nodeId, err := utils.GetTargetUserId(c, c.Param("id"))
+ nodeId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
@@ -283,7 +283,7 @@ func (ctr *Controller) UpdateNode(c *gin.Context) (int, any) {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) DeleteNode(c *gin.Context) (int, any) {
- nodeId, err := utils.GetTargetUserId(c, c.Param("id"))
+ nodeId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
diff --git a/backend/controllers/permissions.controller.go b/backend/controllers/permissions.controller.go
index 61f3aa13..e04199a7 100644
--- a/backend/controllers/permissions.controller.go
+++ b/backend/controllers/permissions.controller.go
@@ -3,6 +3,7 @@ package controllers
import (
"alexandrie/app"
"alexandrie/models"
+ "alexandrie/permissions"
"alexandrie/utils"
"net/http"
"time"
@@ -19,7 +20,8 @@ type PermissionsController interface {
func NewPermissionsController(app *app.App) PermissionsController {
return &Controller{
- app: app,
+ app: app,
+ authorizer: permissions.NewAuthorizer(app.Services.Permissions),
}
}
@@ -33,18 +35,27 @@ func NewPermissionsController(app *app.App) PermissionsController {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) GetNodePermissions(c *gin.Context) (int, any) {
- nodeId, err := utils.GetTargetUserId(c, c.Param("nodeId"))
+ nodeId, err := utils.GetTargetId(c, c.Param("nodeId"))
if err != nil {
return http.StatusBadRequest, err
}
- node, err := ctr.app.Services.Nodes.GetNode(nodeId)
+
+ // Get connected user ID and role from context
+ connectedUserId, connectedUserRole, err := utils.GetUserContext(c)
if err != nil {
- return http.StatusInternalServerError, err
+ return http.StatusUnauthorized, err
}
- _, _, err = utils.NodePermission(c, node, ctr.app.Services.Permissions, utils.OWNER)
+
+ dbNode, err := ctr.app.Services.Nodes.GetNode(nodeId)
if err != nil {
+ return http.StatusInternalServerError, err
+ }
+
+ allowed, _, err := ctr.authorizer.CanAccessNode(connectedUserId, connectedUserRole, dbNode, permissions.ActionManagePermissions)
+ if !allowed || err != nil {
return http.StatusUnauthorized, err
}
+
perms, err := ctr.app.Services.Permissions.GetNodePermission(nodeId)
if err != nil {
return http.StatusInternalServerError, err
@@ -66,14 +77,23 @@ func (ctr *Controller) CreatePermission(c *gin.Context) (int, any) {
if err := c.ShouldBindJSON(perm); err != nil {
return http.StatusBadRequest, err
}
- node, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
+
+ // Get connected user ID and role from context
+ connectedUserId, connectedUserRole, err := utils.GetUserContext(c)
if err != nil {
- return http.StatusInternalServerError, err
+ return http.StatusUnauthorized, err
}
- _, _, err = utils.NodePermission(c, node, ctr.app.Services.Permissions, utils.OWNER)
+
+ dbNode, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
if err != nil {
+ return http.StatusInternalServerError, err
+ }
+
+ allowed, _, err := ctr.authorizer.CanAccessNode(connectedUserId, connectedUserRole, dbNode, permissions.ActionManagePermissions)
+ if !allowed || err != nil {
return http.StatusUnauthorized, err
}
+
perm = &models.Permission{
Id: ctr.app.Snowflake.Generate(),
NodeId: perm.NodeId,
@@ -99,22 +119,31 @@ func (ctr *Controller) CreatePermission(c *gin.Context) (int, any) {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) UpdatePermission(c *gin.Context) (int, any) {
- permId, err := utils.GetTargetUserId(c, c.Param("id"))
+ permId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
+
+ // Get connected user ID and role from context
+ connectedUserId, connectedUserRole, err := utils.GetUserContext(c)
+ if err != nil {
+ return http.StatusUnauthorized, err
+ }
+
perm, err := ctr.app.Services.Permissions.GetPermission(permId)
if err != nil {
return http.StatusInternalServerError, err
}
- node, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
+ dbNode, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
if err != nil {
return http.StatusInternalServerError, err
}
- _, _, err = utils.NodePermission(c, node, ctr.app.Services.Permissions, utils.OWNER)
- if err != nil {
+
+ allowed, _, err := ctr.authorizer.CanAccessNode(connectedUserId, connectedUserRole, dbNode, permissions.ActionManagePermissions)
+ if !allowed || err != nil {
return http.StatusUnauthorized, err
}
+
requestChange := &models.Permission{}
if err := c.ShouldBindJSON(requestChange); err != nil {
return http.StatusBadRequest, err
@@ -136,20 +165,25 @@ func (ctr *Controller) UpdatePermission(c *gin.Context) (int, any) {
// @Failure 400 {object} Error
// @Failure 401 {object} Error
func (ctr *Controller) DeletePermission(c *gin.Context) (int, any) {
- permId, err := utils.GetTargetUserId(c, c.Param("id"))
+ permId, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, err
}
+ // Get connected user ID and role from context
+ connectedUserId, connectedUserRole, err := utils.GetUserContext(c)
+ if err != nil {
+ return http.StatusUnauthorized, err
+ }
perm, err := ctr.app.Services.Permissions.GetPermission(permId)
if err != nil {
return http.StatusInternalServerError, err
}
- node, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
+ dbNode, err := ctr.app.Services.Nodes.GetNode(perm.NodeId)
if err != nil {
return http.StatusInternalServerError, err
}
- _, _, err = utils.NodePermission(c, node, ctr.app.Services.Permissions, utils.OWNER)
- if err != nil {
+ allowed, _, err := ctr.authorizer.CanAccessNode(connectedUserId, connectedUserRole, dbNode, permissions.ActionManagePermissions)
+ if !allowed || err != nil {
return http.StatusUnauthorized, err
}
err = ctr.app.Services.Permissions.DeletePermission(permId)
diff --git a/backend/controllers/ressources.controller.go b/backend/controllers/ressources.controller.go
index 996dbe84..6c33edda 100644
--- a/backend/controllers/ressources.controller.go
+++ b/backend/controllers/ressources.controller.go
@@ -213,7 +213,7 @@ func (ctr *Controller) DeleteUpload(c *gin.Context) (int, any) {
if ctr.app.MinioClient == nil {
return http.StatusInternalServerError, errors.New("minio client not initialized")
}
- id, err := utils.GetTargetUserId(c, c.Param("id"))
+ id, err := utils.GetTargetId(c, c.Param("id"))
if err != nil {
return http.StatusBadRequest, errors.New("invalid id format")
}
diff --git a/backend/permissions/constants.go b/backend/permissions/constants.go
index 7c01f5f8..e09e9000 100644
--- a/backend/permissions/constants.go
+++ b/backend/permissions/constants.go
@@ -29,6 +29,7 @@ const (
ActionUpdate
ActionDelete
ActionShare
+ ActionManagePermissions
)
func (a NodeAction) RequiredLevel() NodePermissionLevel {
@@ -39,7 +40,9 @@ func (a NodeAction) RequiredLevel() NodePermissionLevel {
return PermWrite
case ActionDelete, ActionShare:
return PermAdmin
+ case ActionManagePermissions:
+ return PermOwner
default:
- return PermNone
+ return PermOwner
}
}
diff --git a/backend/permissions/service.go b/backend/permissions/service.go
index db923edb..e2acd683 100644
--- a/backend/permissions/service.go
+++ b/backend/permissions/service.go
@@ -5,6 +5,7 @@ import (
"alexandrie/services"
"alexandrie/types"
"errors"
+ "fmt"
)
type Authorizer interface {
@@ -27,18 +28,18 @@ func (a *DefaultAuthorizer) CanAccessNode(userID types.Snowflake, userRole UserR
if userID == node.UserId {
return true, PermOwner, nil
}
-
+ fmt.Println("Case 1 failed: not the owner")
// Case 2: Global app admin
if a.IsAppAdmin(userRole) {
return true, PermOwner, nil
}
-
+ fmt.Println("Case 2 failed: not an app admin")
// Case 3: Check in DB via PermissionService
hasPermission, level := a.permService.HasPermission(userID, node.Id, int(action.RequiredLevel()))
if hasPermission {
return true, NodePermissionLevel(level), nil
}
-
+ fmt.Println("Case 3 failed: no sufficient permission in DB")
return false, PermNone, errors.New("unauthorized")
}
diff --git a/backend/router/routes/nodes.go b/backend/router/routes/nodes.go
index d3bdd96c..a0aae936 100644
--- a/backend/router/routes/nodes.go
+++ b/backend/router/routes/nodes.go
@@ -13,7 +13,7 @@ func Nodes(app *app.App, router *gin.RouterGroup) {
node := router.Group("/nodes")
nodeCtrl := controllers.NewNodeController(app)
- node.GET("/public/:id", middlewares.Auth(), utils.WP(nodeCtrl.GetPublicNode))
+ node.GET("/public/:id", utils.WP(nodeCtrl.GetPublicNode))
node.GET("/shared/:userId", middlewares.Auth(), utils.WP(nodeCtrl.GetSharedNodes))
node.GET("/:userId", middlewares.Auth(), utils.WP(nodeCtrl.GetNodes))
node.GET("/:userId/:id", middlewares.Auth(), utils.WP(nodeCtrl.GetNode))
diff --git a/backend/utils/permissions.go b/backend/utils/permissions.go
index b3ca311d..72ed189b 100644
--- a/backend/utils/permissions.go
+++ b/backend/utils/permissions.go
@@ -1,9 +1,7 @@
package utils
import (
- "alexandrie/models"
"alexandrie/permissions"
- "alexandrie/services"
"alexandrie/types"
"errors"
"strconv"
@@ -43,7 +41,7 @@ func CheckUserRequestPermission(ctx *gin.Context, requiredRole permissions.UserR
return false
}
-func GetTargetUserId(ctx *gin.Context, param string) (types.Snowflake, error) {
+func GetTargetId(ctx *gin.Context, param string) (types.Snowflake, error) {
if param == "" {
return 0, errors.New("parameter is empty")
}
@@ -94,7 +92,7 @@ func SelfOrPermission(ctx *gin.Context, allowed permissions.UserRole) (types.Sno
// Otherwise, return an error
// --- 1. Get the target user ID
- targetUserId, err := GetTargetUserId(ctx, ctx.Param("userId"))
+ targetUserId, err := GetTargetId(ctx, ctx.Param("userId"))
if err != nil {
return 0, err
}
@@ -117,42 +115,3 @@ func SelfOrPermission(ctx *gin.Context, allowed permissions.UserRole) (types.Sno
}
return 0, errors.New("unauthorized")
}
-
-func NodePermission(ctx *gin.Context, node *models.Node, permissionService services.PermissionService, permission permissions.NodePermissionLevel) (connectedId types.Snowflake, level permissions.NodePermissionLevel, err error) {
- // Check if the connected user has access to the resource
- // Case 1: User is the owner of the node (connectedUserId == targetId) => allow
- // Case 2: The user is an app administrator => allow
- // Case 3: The user has the required permission on the resource => allow
- // Otherwise, return an error
-
- // Check user is correctly authenticated
- connectedUserId, err := GetUserIdCtx(ctx)
- if err != nil {
- return 0, 0, err
- }
- // Case 1: User is the owner of the resource
- if connectedUserId == node.UserId {
- return connectedUserId, OWNER, nil
- }
- // Case 2: User is an app administrator
- role, exists := ctx.Get("user_role")
- if !exists {
- return connectedUserId, 0, errors.New("user role not found in context")
- }
- if CheckPermission(role.(permissions.UserRole), ADMINISTRATOR) {
- return connectedUserId, OWNER, nil
- }
-
- //if permission == OWNER {
- // return 0, errors.New("unauthorized")
- //}
-
- // Case 3: User has the required permission on the resource
- hasPermission, levelInt := permissionService.HasPermission(connectedUserId, node.Id, int(permission))
-
- if hasPermission {
- return connectedUserId, permissions.NodePermissionLevel(levelInt), nil
- }
-
- return 0, 0, errors.New("unauthorized")
-}
diff --git a/backend/utils/permissions_test.go b/backend/utils/permissions_test.go
deleted file mode 100644
index dd880cc5..00000000
--- a/backend/utils/permissions_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package utils_test
-
-import (
- "alexandrie/utils"
- "testing"
-)
-
-func TestCheckPermission(t *testing.T) {
- tests := []struct {
- userRole int
- requiredRole int
- expected bool
- }{
- {utils.ADMINISTRATOR, utils.ADMINISTRATOR, true},
- {utils.ADMINISTRATOR | utils.MANAGER, utils.MANAGER, true},
- {utils.MANAGER, utils.ADMINISTRATOR, false},
- {0, utils.ADMINISTRATOR, false},
- {1, utils.ADMINISTRATOR, false},
- {1, utils.MANAGER, false},
- {1, utils.MODERATOR, false},
- {2, utils.ADMINISTRATOR, true},
- {2, utils.MANAGER, false},
- {2, utils.MODERATOR, false},
- }
-
- for _, test := range tests {
- result := utils.CheckPermission(test.userRole, test.requiredRole)
- if result != test.expected {
- t.Errorf("CheckPermission(%d, %d) = %v; expected %v", test.userRole, test.requiredRole, result, test.expected)
- }
- }
-}
-func TestCheckPermissionWithMultipleRoles(t *testing.T) {
- tests := []struct {
- userRole int
- requiredRole int
- expected bool
- }{
- {utils.ADMINISTRATOR | utils.MANAGER, utils.MANAGER, true},
- {utils.MANAGER | utils.MODERATOR, utils.MODERATOR, true},
- {utils.MODERATOR, utils.MANAGER, false},
- }
-
- for _, test := range tests {
- result := utils.CheckPermission(test.userRole, test.requiredRole)
- if result != test.expected {
- t.Errorf("CheckPermission(%d, %d) = %v; expected %v", test.userRole, test.requiredRole, result, test.expected)
- }
- }
-}