274 lines
7.6 KiB
Go
274 lines
7.6 KiB
Go
package repositories
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"github.com/dusiburg/kotosoft-id/internal/models"
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
type PositionRepository struct {
|
|
db *pgxpool.Pool
|
|
}
|
|
|
|
func NewPositionRepository(db *pgxpool.Pool) *PositionRepository {
|
|
return &PositionRepository{db: db}
|
|
}
|
|
|
|
func (r *PositionRepository) GetAllPermissions(ctx context.Context) ([]models.Permission, error) {
|
|
rows, err := r.db.Query(ctx, `
|
|
SELECT id, code, COALESCE(description, ''), created_at
|
|
FROM permissions
|
|
ORDER BY code
|
|
`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var result []models.Permission
|
|
for rows.Next() {
|
|
var p models.Permission
|
|
if err := rows.Scan(&p.ID, &p.Code, &p.Description, &p.CreatedAt); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, p)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PositionRepository) GetPermissionByCode(ctx context.Context, code string) (*models.Permission, error) {
|
|
var p models.Permission
|
|
err := r.db.QueryRow(ctx, `
|
|
SELECT id, code, COALESCE(description, ''), created_at
|
|
FROM permissions WHERE code = $1
|
|
`, code).Scan(&p.ID, &p.Code, &p.Description, &p.CreatedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &p, nil
|
|
}
|
|
|
|
func (r *PositionRepository) GetPositionPermissions(ctx context.Context, positionID uuid.UUID) ([]models.Permission, error) {
|
|
rows, err := r.db.Query(ctx, `
|
|
SELECT p.id, p.code, COALESCE(p.description, ''), p.created_at
|
|
FROM position_permissions pp
|
|
JOIN permissions p ON pp.permission_id = p.id
|
|
WHERE pp.position_id = $1
|
|
ORDER BY p.code
|
|
`, positionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var result []models.Permission
|
|
for rows.Next() {
|
|
var p models.Permission
|
|
if err := rows.Scan(&p.ID, &p.Code, &p.Description, &p.CreatedAt); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, p)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PositionRepository) AddPermissionToPosition(ctx context.Context, positionID, permissionID uuid.UUID) error {
|
|
_, err := r.db.Exec(ctx, `
|
|
INSERT INTO position_permissions (position_id, permission_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT DO NOTHING
|
|
`, positionID, permissionID)
|
|
return err
|
|
}
|
|
|
|
func (r *PositionRepository) RemovePermissionFromPosition(ctx context.Context, positionID, permissionID uuid.UUID) error {
|
|
_, err := r.db.Exec(ctx, `
|
|
DELETE FROM position_permissions
|
|
WHERE position_id = $1 AND permission_id = $2
|
|
`, positionID, permissionID)
|
|
return err
|
|
}
|
|
|
|
func (r *PositionRepository) GetPositionByCode(ctx context.Context, code string) (*models.Position, error) {
|
|
var p models.Position
|
|
err := r.db.QueryRow(ctx, `
|
|
SELECT id, code, created_at, updated_at
|
|
FROM positions WHERE code = $1
|
|
`, code).Scan(&p.ID, &p.Code, &p.CreatedAt, &p.UpdatedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &p, nil
|
|
}
|
|
|
|
func (r *PositionRepository) GetUserPositions(ctx context.Context, userID uuid.UUID, locale string) ([]models.PositionLocalized, error) {
|
|
rows, err := r.db.Query(ctx, `
|
|
SELECT p.id, p.code,
|
|
COALESCE(pt.name, p.code) AS name,
|
|
pt.description
|
|
FROM user_positions up
|
|
JOIN positions p ON up.position_id = p.id
|
|
LEFT JOIN position_translations pt
|
|
ON pt.position_id = p.id AND pt.locale = $2
|
|
WHERE up.user_id = $1
|
|
AND (up.valid_to IS NULL OR up.valid_to > now())
|
|
ORDER BY name
|
|
`, userID, strings.ToLower(locale))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var result []models.PositionLocalized
|
|
for rows.Next() {
|
|
var p models.PositionLocalized
|
|
var positionID uuid.UUID
|
|
if err := rows.Scan(&positionID, &p.Code, &p.Name, &p.Description); err != nil {
|
|
return nil, err
|
|
}
|
|
perms, err := r.GetPositionPermissions(ctx, positionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.Permissions = perms
|
|
if p.Permissions == nil {
|
|
p.Permissions = []models.Permission{}
|
|
}
|
|
result = append(result, p)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PositionRepository) GetAllPositions(ctx context.Context, locale string) ([]models.PositionLocalized, error) {
|
|
rows, err := r.db.Query(ctx, `
|
|
SELECT p.id, p.code,
|
|
COALESCE(pt.name, p.code) AS name,
|
|
pt.description
|
|
FROM positions p
|
|
LEFT JOIN position_translations pt
|
|
ON pt.position_id = p.id AND pt.locale = $1
|
|
ORDER BY name
|
|
`, strings.ToLower(locale))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var result []models.PositionLocalized
|
|
for rows.Next() {
|
|
var p models.PositionLocalized
|
|
var positionID uuid.UUID
|
|
if err := rows.Scan(&positionID, &p.Code, &p.Name, &p.Description); err != nil {
|
|
return nil, err
|
|
}
|
|
perms, err := r.GetPositionPermissions(ctx, positionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.Permissions = perms
|
|
if p.Permissions == nil {
|
|
p.Permissions = []models.Permission{}
|
|
}
|
|
result = append(result, p)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PositionRepository) UpsertPositionForLocale(ctx context.Context, code, locale, name string, description *string) error {
|
|
tx, err := r.db.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
var positionID uuid.UUID
|
|
err = tx.QueryRow(ctx, `
|
|
INSERT INTO positions (code)
|
|
VALUES ($1)
|
|
ON CONFLICT (code) DO UPDATE SET updated_at = now()
|
|
RETURNING id
|
|
`, code).Scan(&positionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = tx.Exec(ctx, `
|
|
INSERT INTO position_translations (position_id, locale, name, description)
|
|
VALUES ($1, $2, $3, $4)
|
|
ON CONFLICT (position_id, locale) DO UPDATE
|
|
SET name = EXCLUDED.name, description = EXCLUDED.description
|
|
`, positionID, strings.ToLower(locale), name, description)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
func (r *PositionRepository) AssignPosition(ctx context.Context, userID, positionID uuid.UUID, assignedBy *uuid.UUID, validFrom interface{}, validTo *interface{}) error {
|
|
_, err := r.db.Exec(ctx, `
|
|
INSERT INTO user_positions (user_id, position_id, assigned_by, valid_from, valid_to)
|
|
VALUES ($1, $2, $3, COALESCE($4, now()), $5)
|
|
`, userID, positionID, assignedBy, validFrom, validTo)
|
|
return err
|
|
}
|
|
|
|
func (r *PositionRepository) RevokePosition(ctx context.Context, userID, positionID uuid.UUID) error {
|
|
_, err := r.db.Exec(ctx, `
|
|
UPDATE user_positions
|
|
SET valid_to = now()
|
|
WHERE user_id = $1
|
|
AND position_id = $2
|
|
AND valid_to IS NULL
|
|
`, userID, positionID)
|
|
return err
|
|
}
|
|
|
|
func (r *PositionRepository) UserHasPermission(ctx context.Context, userID uuid.UUID, permissionCode string) (bool, string, error) {
|
|
var positionCode string
|
|
err := r.db.QueryRow(ctx, `
|
|
SELECT p.code
|
|
FROM user_positions up
|
|
JOIN positions p ON up.position_id = p.id
|
|
JOIN position_permissions pp ON pp.position_id = p.id
|
|
JOIN permissions perm ON pp.permission_id = perm.id
|
|
WHERE up.user_id = $1
|
|
AND perm.code = $2
|
|
AND (up.valid_to IS NULL OR up.valid_to > now())
|
|
LIMIT 1
|
|
`, userID, permissionCode).Scan(&positionCode)
|
|
if err != nil {
|
|
return false, "", nil
|
|
}
|
|
return true, positionCode, nil
|
|
}
|
|
|
|
func (r *PositionRepository) GetUserPermissions(ctx context.Context, userID uuid.UUID) ([]models.Permission, error) {
|
|
rows, err := r.db.Query(ctx, `
|
|
SELECT DISTINCT perm.id, perm.code, COALESCE(perm.description, ''), perm.created_at
|
|
FROM user_positions up
|
|
JOIN position_permissions pp ON pp.position_id = up.position_id
|
|
JOIN permissions perm ON pp.permission_id = perm.id
|
|
WHERE up.user_id = $1
|
|
AND (up.valid_to IS NULL OR up.valid_to > now())
|
|
ORDER BY perm.code
|
|
`, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var result []models.Permission
|
|
for rows.Next() {
|
|
var p models.Permission
|
|
if err := rows.Scan(&p.ID, &p.Code, &p.Description, &p.CreatedAt); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, p)
|
|
}
|
|
return result, rows.Err()
|
|
}
|