Netpulse_SasS/server/internal/httpapi/roles.go

package httpapi

import (
	"errors"
	"net/http"
	"sort"
	"strings"

	"github.com/netpulse/netpulse/server/internal/store"
)

// Ролі та права.
//
// Редагування ролей іде під тим самим правом, що й керування
// користувачами (users:write), і окремого права під це НЕ заведено
// свідомо. Той, хто може призначити людині роль «Адмін», уже може все,
// що вміє адмін; додаткова галочка «а ще й правити самі ролі» розділяла
// б те, чого немає різниці розділяти, і водночас створювала б ілюзію
// двох рівнів доступу там, де рівень один.
//
// Опис users:write у 0053 переписано так, щоб це було видно з самого
// опису: «Заводити користувачів, змінювати ролі та склад самих ролей».

const rolesReadPerm = "users:read"
const rolesWritePerm = "users:write"

// maxRoleName — межа не з бази (там text), а з екрана: назва ролі
// стоїть у випадному списку поруч із іменем людини, і довша за це вона
// або обрізається, або ламає рядок.
const maxRoleName = 64
const maxRoleDescription = 300

// handlePermissionCatalog — довідник прав для екрана редактора.
//
// Окрема ручка, а не поле всередині /api/v1/roles: перелік прав — це
// властивість збірки продукту, однакова для всіх ролей і всіх кабінетів,
// і повторювати двадцять чотири описи в кожній із п'яти ролей означало
// б слати ту саму сторінку тексту п'ять разів.
func (s *Server) handlePermissionCatalog(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, rolesReadPerm) {
		return
	}
	groups, err := s.store.PermissionCatalog(r.Context())
	if err != nil {
		s.writeStoreError(w, "довідник прав", err)
		return
	}
	if groups == nil {
		groups = []store.PermissionGroup{}
	}
	writeJSON(w, http.StatusOK, map[string]any{"groups": groups})
}

// handleRoleMemberCounts не існує окремо: скільки людей у кожній ролі,
// сторінка бачить із /api/v1/team, який вона й так завантажує. Друга
// ручка на те саме розійшлася б із першою рівно тоді, коли їх покажуть
// поруч на одному екрані.

type roleBody struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Permissions []string `json:"permissions"`
}

func (in *roleBody) normalize() {
	in.Name = strings.TrimSpace(in.Name)
	in.Description = strings.TrimSpace(in.Description)
	sort.Strings(in.Permissions)
}

func (in *roleBody) validate(w http.ResponseWriter) bool {
	if in.Name == "" {
		writeError(w, http.StatusBadRequest, "invalid", "у ролі має бути назва")
		return false
	}
	if len([]rune(in.Name)) > maxRoleName {
		writeError(w, http.StatusBadRequest, "invalid", "назва ролі задовга")
		return false
	}
	if len([]rune(in.Description)) > maxRoleDescription {
		writeError(w, http.StatusBadRequest, "invalid", "опис ролі задовгий")
		return false
	}
	return true
}

// checkGrantable — заборона роздати більше, ніж маєш сам.
//
// Класичне підвищення привілеїв: людина з users:write, але без ncm:exec,
// заводить роль із ncm:exec і садить у неї підставний обліковий запис —
// або просто колегу, який попросив. Своєї ролі вона змінити не може
// (handleSetRole забороняє це окремо), а от створити роль сильнішу за
// власну — цілком, і жодне з наявних правил цього не ловить.
//
// Правило одне й перевіряється на кожному ключі: віддати можна лише те,
// що маєш. Власника воно не зачіпає взагалі — у нього всі 24 права, —
// тобто ціна правила падає рівно на того, кому доступ і звужували.
func checkGrantable(w http.ResponseWriter, p *Principal, perms []string) bool {
	var missing []string
	for _, k := range perms {
		if !p.Can(k) {
			missing = append(missing, k)
		}
	}
	if len(missing) == 0 {
		return true
	}
	writeError(w, http.StatusForbidden, "not_grantable",
		"не можна надати роль права, яких немає у вас самих: "+strings.Join(missing, ", "))
	return false
}

func (s *Server) handleCreateRole(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, rolesWritePerm) {
		return
	}
	var in roleBody
	if !decodeBody(w, r, &in) {
		return
	}
	in.normalize()
	if !in.validate(w) || !checkGrantable(w, p, in.Permissions) {
		return
	}

	role, err := s.store.CreateRole(r.Context(), p.TenantID, store.RoleInput{
		Name:        in.Name,
		Description: in.Description,
		Permissions: in.Permissions,
	})
	if err != nil {
		s.writeRoleError(w, "створення ролі", err)
		return
	}

	s.auditRole(r, p, store.AuditActionRoleCreate, role.ID, map[string]any{
		"key":  role.Key,
		"name": role.Name,
		"after": map[string]any{
			"name":        role.Name,
			"description": role.Description,
			"permissions": role.Permissions,
		},
	})
	writeJSON(w, http.StatusCreated, role)
}

func (s *Server) handleUpdateRole(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, rolesWritePerm) {
		return
	}
	var in roleBody
	if !decodeBody(w, r, &in) {
		return
	}
	in.normalize()
	if !in.validate(w) || !checkGrantable(w, p, in.Permissions) {
		return
	}

	roleID := r.PathValue("id")
	before, after, err := s.store.UpdateRole(r.Context(), p.TenantID, roleID, store.RoleInput{
		Name:        in.Name,
		Description: in.Description,
		Permissions: in.Permissions,
	})
	if err != nil {
		s.writeRoleError(w, "зміна ролі", err)
		return
	}

	added, removed := diffPerms(before.Permissions, after.Permissions)
	s.auditRole(r, p, store.AuditActionRoleUpdate, after.ID, map[string]any{
		"key": after.Key,
		"before": map[string]any{
			"name":        before.Name,
			"description": before.Description,
			"permissions": before.Permissions,
		},
		"after": map[string]any{
			"name":        after.Name,
			"description": after.Description,
			"permissions": after.Permissions,
		},
		// Два переліки поруч із двома знімками: знімки відповідають на
		// «як було й як стало», а ці — на «що саме змінилось». Друге
		// шукають першим, а рахувати різницю двох масивів очима в
		// журналі — саме те, чого від журналу не чекають.
		"granted": added,
		"revoked": removed,
	})
	writeJSON(w, http.StatusOK, after)
}

func (s *Server) handleDeleteRole(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, rolesWritePerm) {
		return
	}
	roleID := r.PathValue("id")

	gone, err := s.store.DeleteRole(r.Context(), p.TenantID, roleID)
	if err != nil {
		s.writeRoleError(w, "видалення ролі", err)
		return
	}

	s.auditRole(r, p, store.AuditActionRoleDelete, gone.ID, map[string]any{
		"key":  gone.Key,
		"name": gone.Name,
		// Знімок саме тут найцінніший: після видалення ролі більше
		// немає ніде, і питання «а що вона давала» лишається без
		// відповіді назавжди.
		"before": map[string]any{
			"name":        gone.Name,
			"description": gone.Description,
			"permissions": gone.Permissions,
		},
	})
	w.WriteHeader(http.StatusNoContent)
}

// ---------------------------------------------------------------------

// auditRole пише слід зміни доступу.
//
// Аудит іде після успіху й не перетворює збій журналу на помилку
// запиту: роль уже змінено, і сховати це від людини було б гірше, ніж
// лишити слід лише в логах сервера. Той самий порядок, що й у прогонах
// команд.
//
// «Було» і «стало» лягають у meta, а не в колонки before/after таблиці:
// store.AuditEntry цих полів ще не має, а дописувати їх треба разом із
// рештою місць, які пишуть аудит. Пошук по журналу від цього не
// страждає — індекс audit_search_trgm_idx із 0050 накриває meta так
// само, як before і after.
func (s *Server) auditRole(r *http.Request, p *Principal, action, roleID string, meta map[string]any) {
	if err := s.store.WriteAudit(r.Context(), p.TenantID, store.AuditEntry{
		ActorUserID:  p.UserID,
		ActorTokenID: p.TokenID,
		ActorIP:      clientIP(r),
		Action:       action,
		ObjectType:   store.AuditObjectRole,
		ObjectID:     roleID,
		Meta:         meta,
	}); err != nil {
		s.log.Error("аудит зміни ролі", "дія", action, "роль", roleID, "err", err)
	}
}

func diffPerms(before, after []string) (added, removed []string) {
	was := make(map[string]bool, len(before))
	for _, k := range before {
		was[k] = true
	}
	now := make(map[string]bool, len(after))
	for _, k := range after {
		now[k] = true
	}
	for _, k := range after {
		if !was[k] {
			added = append(added, k)
		}
	}
	for _, k := range before {
		if !now[k] {
			removed = append(removed, k)
		}
	}
	return added, removed
}

// writeRoleError — три відмови, які людина мусить зрозуміти з першого
// разу, бо кожна з них означає окрему подальшу дію.
func (s *Server) writeRoleError(w http.ResponseWriter, what string, err error) {
	switch {
	case errors.Is(err, store.ErrRoleSystem):
		writeError(w, http.StatusForbidden, "role_system",
			"це вбудована роль — вона спільна для всієї інсталяції й не редагується. "+
				"Зробіть її копію та змініть копію")

	case errors.Is(err, store.ErrRoleInUse):
		writeError(w, http.StatusConflict, "role_in_use",
			err.Error()+". Спершу переведіть їх в іншу роль")

	case errors.Is(err, store.ErrLastAdmin):
		writeError(w, http.StatusConflict, "last_admin",
			"після цієї зміни в організації не лишиться жодного учасника з правом "+
				"users:write — повернути його не зміг би ніхто, навіть ви")

	default:
		s.writeStoreError(w, what, err)
	}
}