kratisto/mangezmieux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
Jeffrey Duroyon
2024-07-19 17:04:42 +02:00
commit 5e0d0ec69f
71 changed files with 3316 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
mangezmieux-backend/internal/acl/handler.go Normal file
View File

@@ -0,0 +1,71 @@
package acl
import (
"errors"
"github.com/go-playground/validator/v10"
"mangezmieux-backend/internal/acl/service"
"mangezmieux-backend/internal/logger"
"mangezmieux-backend/internal/middleware"
"mangezmieux-backend/internal/responses"
"mangezmieux-backend/internal/users/model"
"github.com/gin-gonic/gin"
"net/http"
)
type Handler struct {
service service.Service
Validator *validator.Validate
}
const (
rolePathParam = "roleName"
roleIdPathParam = "roleId"
)
func NewHandler(service service.Service, validator *validator.Validate) *Handler {
return &Handler{
service: service,
Validator: validator,
}
}
func (h Handler) GetAllRole(context *gin.Context) {
roles, err := h.service.GetAllRole()
if err != nil {
logger.GetLogger().Error(err)
var apiError *responses.APIError
if errors.As(err, &apiError) {
responses.JSONError(context.Writer, *apiError)
return
}
responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
return
}
responses.JSON(context.Writer, http.StatusOK, roles)
}
func (h Handler) GetMyRoles(context *gin.Context) {
user, exists := context.Get(middleware.CtxUser)
if !exists {
responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, "User not found in context")
return
}
userModel := user.(*model.User)
userRight, err := h.service.GetRoleForCurrentUser(userModel)
if err != nil {
logger.GetLogger().Error(err)
var apiError *responses.APIError
if errors.As(err, &apiError) {
responses.JSONError(context.Writer, *apiError)
return
}
responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
return
}
responses.JSON(context.Writer, http.StatusOK, userRight)
}

6
mangezmieux-backend/internal/acl/key/key.go Normal file
View File

@@ -0,0 +1,6 @@
package key
const (
ServiceKey = "RoleService"
DaoKey = "DaoService"
)

48
mangezmieux-backend/internal/acl/model/model.go Normal file
View File

@@ -0,0 +1,48 @@
package model
import (
"github.com/google/uuid"
"mangezmieux-backend/internal/model"
)
type UserRight struct {
UserRole []*UserRole `json:"userRole"`
}
type Resource struct {
Id uuid.UUID `json:"id"`
Name string `json:"name"`
model.Metadata
}
type RoleVerbResource struct {
Id uuid.UUID `json:"id"`
Verb string `json:"verb"`
RoleId uuid.UUID `json:"role"`
ResourceId uuid.UUID `json:"resource"`
model.Metadata
}
type RoleEditable struct {
Id uuid.UUID `json:"id"`
Name string `json:"name"`
model.Metadata
}
type Role struct {
RoleEditable
ResourceVerb map[string][]*Verb
}
type Verb struct {
Id uuid.UUID `json:"id"`
Verb string `json:"verb"`
model.Metadata
}
type UserRole struct {
Id uuid.UUID `json:"id"`
RoleId uuid.UUID `json:"role"`
UserId uuid.UUID `json:"user"`
model.Metadata
}

60
mangezmieux-backend/internal/acl/service/service.go Normal file
View File

@@ -0,0 +1,60 @@
package service
import (
"github.com/google/uuid"
"mangezmieux-backend/internal/acl/model"
"mangezmieux-backend/internal/acl/sql"
model2 "mangezmieux-backend/internal/users/model"
)
type service struct {
dao sql.Dao
}
func (s service) GetRoleForCurrentUser(user *model2.User) (*model.UserRight, error) {
userId, err := uuid.Parse(user.ID.String())
if err != nil {
return nil, err
}
userRole, err := s.GetUserRoleByUser(userId)
if err != nil {
return nil, err
}
userRight := &model.UserRight{
UserRole: userRole,
}
return userRight, nil
}
func (s service) GetAllRole() ([]*model.Role, error) {
roles, err := s.dao.GetAllRole()
return roles, err
}
func (s service) GetUserRoleByUser(id uuid.UUID) ([]*model.UserRole, error) {
userRoles, err := s.dao.GetUserRoleByUser(id)
return userRoles, err
}
func (s service) GetRole(id uuid.UUID) (*model.Role, error) {
role, err := s.dao.GetRole(id)
if err != nil {
return nil, err
}
return role, nil
}
type Service interface {
GetAllRole() ([]*model.Role, error)
GetRoleForCurrentUser(user *model2.User) (*model.UserRight, error)
GetUserRoleByUser(id uuid.UUID) ([]*model.UserRole, error)
}
func NewService(dao sql.Dao) Service {
return &service{
dao: dao,
}
}

39
mangezmieux-backend/internal/acl/setup.go Normal file
View File

@@ -0,0 +1,39 @@
package acl
import (
"database/sql"
"mangezmieux-backend/internal/acl/key"
"mangezmieux-backend/internal/acl/service"
aclSql "mangezmieux-backend/internal/acl/sql"
"mangezmieux-backend/internal/ginserver"
"mangezmieux-backend/internal/injector"
"mangezmieux-backend/internal/postgres"
"mangezmieux-backend/internal/validator"
"net/http"
"github.com/gin-gonic/gin"
validatorv10 "github.com/go-playground/validator/v10"
)
func SetupDao(inj *injector.Injector) {
client := injector.Get[*sql.DB](inj, postgres.DatabaseKey)
dao := aclSql.NewDao(client)
inj.Set(key.DaoKey, dao)
}
func Setup(inj *injector.Injector) {
securedRoute := injector.Get[*gin.RouterGroup](inj, ginserver.SecuredRouterInjectorKey)
validatorCli := injector.Get[*validatorv10.Validate](inj, validator.ValidatorInjectorKey)
dao := injector.Get[aclSql.Dao](inj, key.DaoKey)
aclService := service.NewService(dao)
handler := NewHandler(aclService, validatorCli)
inj.Set(key.ServiceKey, aclService)
aclRoute := securedRoute.Group("/roles")
aclRoute.Handle(http.MethodGet, "/", handler.GetAllRole)
securedRoute.Handle(http.MethodGet, "/users/me/roles", handler.GetMyRoles)
}

39
mangezmieux-backend/internal/acl/sql/dao.go Normal file
View File

@@ -0,0 +1,39 @@
package sql
import (
"github.com/google/uuid"
"mangezmieux-backend/internal/acl/model"
model2 "mangezmieux-backend/internal/model"
)
type Dao interface {
//Role
GetRole(id uuid.UUID) (*model.Role, error)
GetRoleByName(name string) (*model.Role, error)
AddRole(roleName string, metadata model2.Metadata) (*model.Role, error)
DeleteRole(id uuid.UUID) error
GetAllRole() ([]*model.Role, error)
//Resource
AddResource(resourceName string, metadata model2.Metadata) (*model.Resource, error)
DeleteResource(id uuid.UUID) error
GetResource(id uuid.UUID) (*model.Resource, error)
GetResourceByName(name string) (*model.Resource, error)
GetAllResource() ([]*model.Resource, error)
//RoleVerbResource
GetRoleVerbResource(id uuid.UUID) (*model.RoleVerbResource, error)
GetRoleVerbResourceByRoleResourceAndVerb(roleId, resourceId uuid.UUID, verb string) (*model.RoleVerbResource, error)
GetRoleVerbResourceByRoleResource(roleId, resourceId uuid.UUID) ([]*model.RoleVerbResource, error)
GetRoleVerbResourceByRole(roleId uuid.UUID) ([]*model.RoleVerbResource, error)
AddRoleVerbResource(roleId, resourceId uuid.UUID, verb string, metadata model2.Metadata) (*model.RoleVerbResource, error)
DeleteRoleVerbResource(id uuid.UUID) error
//UserRole
GetUserRole(id uuid.UUID) (*model.UserRole, error)
GetUserRoleByUserAndRole(userId, roleId uuid.UUID) (*model.UserRole, error)
GetUserRoleByUser(userId uuid.UUID) ([]*model.UserRole, error)
GetUserRoleByRole(role uuid.UUID) ([]*model.UserRole, error)
AddUserRole(userId, roleId uuid.UUID, metadata model2.Metadata) (*model.UserRole, error)
DeleteUserRole(id uuid.UUID) error
}

13
mangezmieux-backend/internal/acl/sql/sql.go Normal file
View File

@@ -0,0 +1,13 @@
package sql
import (
"database/sql"
)
type dao struct {
client *sql.DB
}
func NewDao(client *sql.DB) Dao {
return &dao{client: client}
}

121
mangezmieux-backend/internal/acl/sql/sql_resource.go Normal file
View File

@@ -0,0 +1,121 @@
package sql
import (
"database/sql"
"errors"
"github.com/google/uuid"
"github.com/lib/pq"
"mangezmieux-backend/internal/acl/model"
model2 "mangezmieux-backend/internal/model"
"mangezmieux-backend/internal/postgres"
)
func (sqlDAO dao) AddResource(resourceName string, metadata model2.Metadata) (*model.Resource, error) {
var Id uuid.UUID
q := `
INSERT INTO mangezmieux.resource
(name, creation_date, creation_user)
VALUES
($1, $2, $3)
RETURNING
Id`
err := sqlDAO.client.QueryRow(q, resourceName, metadata.CreationDate, metadata.CreationUser).Scan(&Id)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
resource, err := sqlDAO.GetResource(Id)
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
return resource, nil
}
func (sqlDAO dao) DeleteResource(Id uuid.UUID) error {
q := `
DELETE FROM mangezmieux.resource
WHERE Id = $1
`
_, err := sqlDAO.client.Exec(q, Id.String())
var errPq *pq.Error
if errors.As(err, &errPq) {
return postgres.HandlePgError(errPq)
}
return err
}
func (sqlDAO dao) GetResource(Id uuid.UUID) (*model.Resource, error) {
q := `
SELECT Id, name, creation_date, last_update_date
FROM mangezmieux.resource r
WHERE r.Id = $1
`
row := sqlDAO.client.QueryRow(q, Id.String())
resource := &model.Resource{}
err := row.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return resource, nil
}
func (sqlDAO dao) GetResourceByName(name string) (*model.Resource, error) {
q := `
SELECT Id, name, creation_date, last_update_date
FROM mangezmieux.resource r
WHERE r.name = $1
`
row := sqlDAO.client.QueryRow(q, name)
resource := &model.Resource{}
err := row.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return resource, nil
}
func (sqlDAO dao) GetAllResource() ([]*model.Resource, error) {
q := `
SELECT Id, name, creation_date, last_update_date
FROM mangezmieux.resource r
`
rows, err := sqlDAO.client.Query(q)
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
resources := make([]*model.Resource, 0)
for rows.Next() {
resource := &model.Resource{}
err := rows.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
resources = append(resources, resource)
}
return resources, nil
}

121
mangezmieux-backend/internal/acl/sql/sql_role.go Normal file
View File

@@ -0,0 +1,121 @@
package sql
import (
"database/sql"
"errors"
"github.com/google/uuid"
"github.com/lib/pq"
"mangezmieux-backend/internal/acl/model"
model2 "mangezmieux-backend/internal/model"
"mangezmieux-backend/internal/postgres"
)
func (sqlDAO dao) GetRole(id uuid.UUID) (*model.Role, error) {
q := `
SELECT id, name, creation_date, last_update_date
FROM mangezmieux.role r
WHERE r.id = $1
`
row := sqlDAO.client.QueryRow(q, id.String())
role := &model.Role{}
err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return role, nil
}
func (sqlDAO dao) GetRoleByName(name string) (*model.Role, error) {
q := `
SELECT id, name, creation_date, last_update_date
FROM mangezmieux.role r
WHERE r.name = $1
`
row := sqlDAO.client.QueryRow(q, name)
role := &model.Role{}
err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return role, nil
}
func (sqlDAO dao) AddRole(roleName string, metadata model2.Metadata) (*model.Role, error) {
var id uuid.UUID
q := `
INSERT INTO mangezmieux.role
(name, creation_date, creation_user)
VALUES
($1,$2,$3)
RETURNING
id`
err := sqlDAO.client.QueryRow(q, roleName, metadata.CreationDate, metadata.CreationUser).Scan(&id)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
role, err := sqlDAO.GetRole(id)
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
return role, nil
}
func (sqlDAO dao) DeleteRole(id uuid.UUID) error {
q := `
DELETE FROM mangezmieux.role
WHERE id = $1
`
_, err := sqlDAO.client.Exec(q, id.String())
var errPq *pq.Error
if errors.As(err, &errPq) {
return postgres.HandlePgError(errPq)
}
return err
}
func (sqlDAO dao) GetAllRole() ([]*model.Role, error) {
q := `
SELECT id, name, creation_date, last_update_date
FROM mangezmieux.role r
`
rows, err := sqlDAO.client.Query(q)
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
roles := make([]*model.Role, 0)
for rows.Next() {
role := &model.Role{}
err := rows.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
roles = append(roles, role)
}
return roles, nil
}

191
mangezmieux-backend/internal/acl/sql/sql_role_verb_resource.go Normal file
View File

@@ -0,0 +1,191 @@
package sql
import (
"database/sql"
"errors"
"mangezmieux-backend/internal/acl/model"
model2 "mangezmieux-backend/internal/model"
"mangezmieux-backend/internal/postgres"
"github.com/google/uuid"
"github.com/lib/pq"
)
func (sqlDAO dao) GetRoleVerbResource(id uuid.UUID) (*model.RoleVerbResource, error) {
q := `
SELECT id, role_id, verb, resource_id, creation_date, last_update_date
FROM mangezmieux.role_verb_resource r
WHERE r.id = $1
`
row := sqlDAO.client.QueryRow(q, id.String())
roleVerbResource := &model.RoleVerbResource{}
err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return roleVerbResource, nil
}
func (sqlDAO dao) GetRoleVerbResourceByRoleResourceAndVerb(roleId, resourceId uuid.UUID, verb string) (*model.RoleVerbResource, error) {
q := `
SELECT id, role_id, verb, resource_id, creation_date, last_update_date
FROM mangezmieux.role_verb_resource r
WHERE r.role_id = $1
AND r.resource_id = $2
AND r.verb = $3
`
row := sqlDAO.client.QueryRow(q, roleId.String(), resourceId.String(), verb)
roleVerbResource := &model.RoleVerbResource{}
err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return roleVerbResource, nil
}
func (sqlDAO dao) GetRoleVerbResourceByResourceAndVerb(resourceId uuid.UUID, verb string) ([]*model.RoleVerbResource, error) {
q := `
SELECT id, role_id, verb, resource_id, creation_date, last_update_date
FROM mangezmieux.role_verb_resource r
WHERE r.resource_id = $1
AND r.verb = $2
`
rows, err := sqlDAO.client.Query(q, resourceId.String(), verb)
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
roleVerResources := make([]*model.RoleVerbResource, 0)
for rows.Next() {
roleVerbResource := &model.RoleVerbResource{}
err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
roleVerResources = append(roleVerResources, roleVerbResource)
}
return roleVerResources, nil
}
func (sqlDAO dao) GetRoleVerbResourceByRoleResource(roleId, resourceId uuid.UUID) ([]*model.RoleVerbResource, error) {
q := `
SELECT id, role_id, verb, resource_id, creation_date, last_update_date
FROM mangezmieux.role_verb_resource r
WHERE r.role_id = $1
AND r.resource_id = $2
`
rows, err := sqlDAO.client.Query(q, roleId.String(), resourceId.String())
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
roleVerResources := make([]*model.RoleVerbResource, 0)
for rows.Next() {
roleVerbResource := &model.RoleVerbResource{}
err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
roleVerResources = append(roleVerResources, roleVerbResource)
}
return roleVerResources, nil
}
func (sqlDAO dao) GetRoleVerbResourceByRole(roleId uuid.UUID) ([]*model.RoleVerbResource, error) {
q := `
SELECT id, role_id, verb, resource_id, creation_date, last_update_date
FROM mangezmieux.role_verb_resource r
WHERE r.role_id = $1
`
rows, err := sqlDAO.client.Query(q, roleId.String())
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
roleVerResources := make([]*model.RoleVerbResource, 0)
for rows.Next() {
roleVerbResource := &model.RoleVerbResource{}
err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
roleVerResources = append(roleVerResources, roleVerbResource)
}
return roleVerResources, nil
}
func (sqlDAO dao) AddRoleVerbResource(roleId, resourceId uuid.UUID, verb string, metadata model2.Metadata) (*model.RoleVerbResource, error) {
var Id uuid.UUID
q := `
INSERT INTO mangezmieux.role_verb_resource
(role_id, verb, resource_id, creation_date, creation_user)
VALUES
($1,$2,$3,$4,$5)
RETURNING
Id`
err := sqlDAO.client.QueryRow(q, roleId.String(), verb, resourceId.String(), metadata.CreationDate, metadata.CreationUser).Scan(&Id)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
roleVerbResource, err := sqlDAO.GetRoleVerbResource(Id)
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
return roleVerbResource, nil
}
func (sqlDAO dao) DeleteRoleVerbResource(id uuid.UUID) error {
q := `
DELETE FROM mangezmieux.role_verb_resource
WHERE Id = $1
`
_, err := sqlDAO.client.Exec(q, id.String())
var errPq *pq.Error
if errors.As(err, &errPq) {
return postgres.HandlePgError(errPq)
}
return err
}

161
mangezmieux-backend/internal/acl/sql/sql_user_role.go Normal file
View File

@@ -0,0 +1,161 @@
package sql
import (
"database/sql"
"errors"
"mangezmieux-backend/internal/acl/model"
model2 "mangezmieux-backend/internal/model"
"mangezmieux-backend/internal/postgres"
"github.com/google/uuid"
"github.com/lib/pq"
)
func (sqlDAO dao) GetUserRole(id uuid.UUID) (*model.UserRole, error) {
q := `
SELECT id, role_id, user_id, creation_date, last_update_date
FROM mangezmieux.user_role r
WHERE r.id = $1
`
row := sqlDAO.client.QueryRow(q, id.String())
userRole := &model.UserRole{}
err := row.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return userRole, nil
}
func (sqlDAO dao) GetUserRoleByUserAndRole(userId, roleId uuid.UUID) (*model.UserRole, error) {
q := `
SELECT id, role_id, user_id, creation_date, last_update_date
FROM mangezmieux.user_role r
WHERE r.role_id = $1
AND r.user_id = $2
`
row := sqlDAO.client.QueryRow(q, roleId.String(), userId.String())
userRole := &model.UserRole{}
err := row.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
return userRole, nil
}
func (sqlDAO dao) GetUserRoleByUser(userId uuid.UUID) ([]*model.UserRole, error) {
q := `
SELECT id, role_id, user_id, creation_date, last_update_date
FROM mangezmieux.user_role r
WHERE r.user_id = $1
`
rows, err := sqlDAO.client.Query(q, userId.String())
if errors.Is(err, sql.ErrNoRows) {
return make([]*model.UserRole, 0), nil
}
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
userRoles := make([]*model.UserRole, 0)
for rows.Next() {
userRole := &model.UserRole{}
err := rows.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
userRoles = append(userRoles, userRole)
}
return userRoles, nil
}
func (sqlDAO dao) GetUserRoleByRole(role uuid.UUID) ([]*model.UserRole, error) {
q := `
SELECT id, role_id, user_id, creation_date, last_update_date
FROM mangezmieux.user_role r
WHERE r.role_id = $1
`
rows, err := sqlDAO.client.Query(q, role.String())
if err != nil {
return nil, err
}
if rows.Err() != nil {
return nil, rows.Err()
}
defer rows.Close()
userRoles := make([]*model.UserRole, 0)
for rows.Next() {
userRole := &model.UserRole{}
err := rows.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
if errors.Is(err, sql.ErrNoRows) {
return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
}
userRoles = append(userRoles, userRole)
}
return userRoles, nil
}
func (sqlDAO dao) AddUserRole(userId, roleId uuid.UUID, metadata model2.Metadata) (*model.UserRole, error) {
var Id uuid.UUID
q := `
INSERT INTO mangezmieux.user_role
(user_id, role_id, creation_date, creation_user)
VALUES
($1,$2,$3,$4)
RETURNING
Id`
err := sqlDAO.client.QueryRow(q, userId.String(), roleId.String(), metadata.CreationDate, metadata.CreationUser).Scan(&Id)
var errPq *pq.Error
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
userRole, err := sqlDAO.GetUserRole(Id)
if errors.As(err, &errPq) {
return nil, postgres.HandlePgError(errPq)
}
return userRole, nil
}
func (sqlDAO dao) DeleteUserRole(id uuid.UUID) error {
q := `
DELETE FROM mangezmieux.user_role
WHERE Id = $1
`
_, err := sqlDAO.client.Exec(q, id.String())
var errPq *pq.Error
if errors.As(err, &errPq) {
return postgres.HandlePgError(errPq)
}
return err
}