v2: fixed oauth errors, oauth clients native control added

This commit is contained in:
Ivan Rezchikov
2026-09-15 16:21:53 +03:00
parent 83e1849d73
commit 8b0a3d143b
51 changed files with 1392 additions and 3216 deletions
+13 -92
View File
@@ -16,8 +16,7 @@ func NewRouter(
auth *handlers.AuthHandler,
oauth *handlers.OAuthHandler,
consents *handlers.ConsentHandler,
positions *handlers.PositionsHandler,
citizenship *handlers.CitizenshipHandler,
clients *handlers.ClientHandler,
svc *services.Service,
repo *repositories.OAuthRepository,
limiter *services.RateLimiter,
@@ -50,14 +49,15 @@ func NewRouter(
middleware.RateLimit(limiter, services.RevokeRateLimit, middleware.RevokeKeyFn),
oauth.Revoke,
)
o.POST("/introspect", positions.Introspect)
}
api := r.Group("/api/v1")
{
a := api.Group("/auth")
a.POST("/register", auth.Register)
a.POST("/register",
middleware.RateLimit(limiter, services.RegisterRateLimit, middleware.IPKeyFn("register")),
auth.Register,
)
a.POST("/refresh",
middleware.RateLimit(limiter, services.RefreshRateLimit, middleware.RefreshKeyFn),
auth.Refresh,
@@ -69,101 +69,22 @@ func NewRouter(
me.DELETE("", authMiddleware(svc, repo, "profile:delete"), auth.DeleteProfile)
me.GET("/consents", authMiddleware(svc, repo, "profile:consent:read"), consents.GetUserConsents)
me.DELETE("/consent/:clientId", authMiddleware(svc, repo, "profile:consent:delete"), consents.RevokeAppAccess)
me.GET("/positions", authMiddleware(svc, repo, "profile:read"), positions.GetMyPositions)
me.GET("/citizenship", authMiddleware(svc, repo, "profile:read"), citizenship.GetCitizenshipApplicationByUserId)
me.POST("/citizenship", authMiddleware(svc, repo, "profile:edit"), citizenship.CreateCitizenshipApplication)
admin := api.Group("/admin", authMiddleware(svc, repo))
admin := api.Group("/admin")
admin.Use(authMiddleware(svc, repo), middleware.AdminOnly())
{
admin.PATCH("/citizenship/applications/:id", middleware.AdminOnly(), citizenship.ReviewCitizenshipApplication)
manage := admin.Group("", permissionMiddleware(svc, "positions.manage"))
{
manage.GET("/permissions", positions.ListPermissions)
manage.POST("/permissions", positions.CreatePermission)
manage.PUT("/permissions/:code", positions.UpdatePermission)
manage.DELETE("/permissions/:code", positions.DeletePermission)
manage.GET("/positions", positions.ListPositions)
manage.POST("/positions", positions.UpsertPosition)
manage.PUT("/positions/:code", positions.UpdatePosition)
manage.DELETE("/positions/:code", positions.DeletePosition)
manage.POST("/positions/:code/permissions", positions.AddPermissionToPosition)
manage.DELETE("/positions/:code/permissions/:permissionCode", positions.RemovePermissionFromPosition)
}
usersRead := admin.Group("", permissionAnyMiddleware(svc, "positions.assign", "positions.revoke"))
{
usersRead.GET("/users", positions.ListUsersWithPositions)
}
assign := admin.Group("", permissionMiddleware(svc, "positions.assign"))
{
assign.POST("/users/:userId/positions", positions.AssignPosition)
}
revoke := admin.Group("", permissionMiddleware(svc, "positions.revoke"))
{
revoke.DELETE("/users/:userId/positions/:code", positions.RevokePosition)
}
c := admin.Group("/clients")
c.POST("", clients.Create)
c.GET("", clients.List)
c.GET("/:id", clients.Get)
c.PATCH("/:id", clients.Update)
c.DELETE("/:id", clients.Deactivate)
}
}
return r
}
func permissionAnyMiddleware(svc *services.Service, requiredPermissions ...string) gin.HandlerFunc {
return func(c *gin.Context) {
userID, ok := UserIDFromContext(c)
if !ok {
c.Error(models.ErrUnauthorized)
c.Abort()
return
}
for _, permission := range requiredPermissions {
allowed, err := svc.UserHasPermission(c.Request.Context(), userID, permission)
if err != nil {
c.Error(models.ErrInternal)
c.Abort()
return
}
if allowed {
c.Next()
return
}
}
c.Error(models.ErrForbidden.WithMessage("Missing required permissions"))
c.Abort()
}
}
func permissionMiddleware(svc *services.Service, requiredPermission string) gin.HandlerFunc {
return func(c *gin.Context) {
userID, ok := UserIDFromContext(c)
if !ok {
c.Error(models.ErrUnauthorized)
c.Abort()
return
}
allowed, err := svc.UserHasPermission(c.Request.Context(), userID, requiredPermission)
if err != nil {
c.Error(models.ErrInternal)
c.Abort()
return
}
if !allowed {
c.Error(models.ErrForbidden.WithMessage("Missing required permission: " + requiredPermission))
c.Abort()
return
}
c.Next()
}
}
func authMiddleware(svc *services.Service, repo *repositories.OAuthRepository, requiredScopes ...string) gin.HandlerFunc {
return func(c *gin.Context) {
token, ok := bearerToken(c)