Netpulse_SasS/server/internal/httpapi/ncm_configs.go

package httpapi

import (
	"errors"
	"net/http"

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

// Очистка сховища версій конфігів: політика й ручне видалення.
//
// Два різні права, і це навмисно.
//
// Політику читає й пише той, хто вже керує збором (ncm:read / ncm:write):
// це налаштування, воно нічого не знищує в момент збереження, і живе
// поруч зі спільним розкладом, з яким його й налаштовують за один захід.
//
// Ручне видалення — окреме право ncm:delete. Різниця не в масштабі, а в
// природі дії: розклад можна повернути назад, видалену версію — ні.
// Архів конфігів це те, чим доводять, ЯК виглядало залізо в конкретний
// день; право стирати цей доказ не має видаватись разом із правом
// правити розклад. Той самий висновок, що й у 0036 для ncm:exec.

const deletePerm = "ncm:delete"

// handleGetRetention — політика очистки разом із тим, що вона зробить.
func (s *Server) handleGetRetention(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "ncm:read") {
		return
	}
	pol, err := s.store.GetRetention(r.Context(), p.TenantID)
	if err != nil {
		s.writeStoreError(w, "політика очистки конфігів", err)
		return
	}
	writeJSON(w, http.StatusOK, pol)
}

func (s *Server) handleSetRetention(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "ncm:write") {
		return
	}
	var in struct {
		Enabled  bool `json:"enabled"`
		Versions int  `json:"versions"`
		Days     int  `json:"days"`
	}
	if !decodeBody(w, r, &in) {
		return
	}

	if err := s.store.SetRetention(r.Context(), p.TenantID, store.RetentionPolicy{
		Enabled: in.Enabled, Versions: in.Versions, Days: in.Days,
	}); err != nil {
		s.writeStoreError(w, "збереження політики очистки", err)
		return
	}

	// Вмикання політики — не видалення, але його наслідок. Слід у
	// журналі потрібен саме тут: сам прохід прибиральника нікого не
	// питає, і питання «хто дозволив чистити архів» має мати відповідь.
	if err := s.store.WriteAudit(r.Context(), p.TenantID, store.AuditEntry{
		ActorUserID:  p.UserID,
		ActorTokenID: p.TokenID,
		ActorIP:      clientIP(r),
		Action:       store.AuditActionRetentionUpdate,
		ObjectType:   store.AuditObjectBackupDefaults,
		Meta: map[string]any{
			"enabled": in.Enabled, "versions": in.Versions, "days": in.Days,
		},
	}); err != nil {
		s.log.Error("аудит політики очистки", "err", err)
	}

	pol, err := s.store.GetRetention(r.Context(), p.TenantID)
	if err != nil {
		s.writeStoreError(w, "політика очистки конфігів", err)
		return
	}
	writeJSON(w, http.StatusOK, pol)
}

// handleDeleteConfigs видаляє обрані версії.
//
// POST зі списком, а не DELETE /configs/{id} по одній. Дві причини, і
// обидві не про смаки в REST. Підтвердження людина дає один раз на весь
// набір — і саме цей набір має або пройти, або лишити зрозумілий звіт;
// N окремих запитів дали б N рядків аудиту й половину видаленого при
// обриві мережі. І тіло в DELETE підтримується транспортом настільки
// по-різному, що складати список у рядок запиту довелося б власним
// кодуванням масиву.
//
// Захищені версії не роблять запит помилковим: оператор міг обрати
// десять, з яких одна виявилась останньою. Відповідь каже, що зникло, а
// що лишилось і чому.
func (s *Server) handleDeleteConfigs(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, deletePerm) {
		return
	}

	var in struct {
		IDs []string `json:"ids"`
	}
	if !decodeBody(w, r, &in) {
		return
	}
	if len(in.IDs) == 0 {
		writeError(w, http.StatusBadRequest, "no_ids", "не обрано жодної версії")
		return
	}
	// Стеля на розмір запиту: перелік складає клієнт, і без неї одне
	// натискання могло б забрати весь архів тенанта.
	if len(in.IDs) > 500 {
		writeError(w, http.StatusBadRequest, "too_many",
			"за один раз можна видалити не більше 500 версій")
		return
	}

	scope := p.Scope()
	res, err := s.store.DeleteConfigs(r.Context(), p.TenantID, in.IDs, scope.CanWrite)
	if errors.Is(err, store.ErrNothingToDelete) {
		// 409, а не 400: запит правильний, просто жодна з цих версій
		// видаленню не підлягає — і клієнт має показати перелік причин.
		writeJSON(w, http.StatusConflict, map[string]any{
			"error": map[string]string{
				"code": "nothing_to_delete", "message": store.ErrNothingToDelete.Error(),
			},
			"kept": res.Kept,
		})
		return
	}
	if isBadUUID(err) {
		writeError(w, http.StatusBadRequest, "bad_id", "некоректний ідентифікатор версії")
		return
	}
	if err != nil {
		s.writeStoreError(w, "видалення версій конфігу", err)
		return
	}

	// Аудит після успіху й не блокує відповідь: версій уже немає, і
	// приховати це від людини було б гірше, ніж лишити слід лише в
	// журналі сервера. Дати й імена хостів пишуться в meta саме тому,
	// що самих версій уже не існує — з'ясувати їх потім не буде як.
	items := make([]map[string]any, 0, len(res.Deleted))
	for _, d := range res.Deleted {
		items = append(items, map[string]any{
			"id": d.ID, "device_id": d.DeviceID, "device": d.DeviceName,
			"collected_at": d.CollectedAt, "size_bytes": d.SizeBytes,
		})
	}
	if err := s.store.WriteAudit(r.Context(), p.TenantID, store.AuditEntry{
		ActorUserID:  p.UserID,
		ActorTokenID: p.TokenID,
		ActorIP:      clientIP(r),
		Action:       store.AuditActionConfigDelete,
		ObjectType:   store.AuditObjectConfig,
		Meta: map[string]any{
			"deleted":     len(res.Deleted),
			"freed_bytes": res.FreedBytes,
			"kept":        len(res.Kept),
			"versions":    items,
		},
	}); err != nil {
		s.log.Error("аудит видалення конфігів", "err", err)
	}

	s.log.Info("видалено версії конфігів",
		"кількість", len(res.Deleted), "байтів", res.FreedBytes,
		"користувач", p.Username, "user_id", p.UserID)

	if res.Kept == nil {
		res.Kept = []store.KeptConfig{}
	}
	writeJSON(w, http.StatusOK, res)
}