Netpulse_SasS/server/internal/httpapi/storage.go

package httpapi

import (
	"errors"
	"net/http"

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

// Сховище: розміри, приріст і строки зберігання даних.
//
// ПРО ПРАВА
//
// Дивитись — devices:read, тобто кожен, хто взагалі бачить систему.
// Це те саме рішення, що й для дзеркала конфігів (0054): помітити, що
// диск закінчується, має могти той, хто щодня дивиться на моніторинг, а
// не лише власник кабінету. Ховати розмір бази немає від кого, а от не
// побачити нахил вчасно коштує всієї інсталяції.
//
// Міняти — settings:write. Строк зберігання незворотний за наслідками й
// діє на всю інсталяцію, тобто це рівно те, що описує це право:
// «налаштування організації». Досі його не питав жоден обробник (воно
// значилось у dormantPerms як «налаштувань організації ще немає») —
// тепер вони є.
//
// Попередній перегляд теж під settings:write, хоч він нічого й не
// змінює. Дві причини: він частина шляху зміни, а не самостійна
// довідка, і він дорогий — точний підрахунок рядків по хвосту
// гіпертаблиці має право запускати той, хто збирається натиснути
// «застосувати», а не будь-яка відкрита вкладка.

// handleStorageUsage — скільки що важить і на скільки вистачить місця.
func (s *Server) handleStorageUsage(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "devices:read") {
		return
	}
	out, err := s.store.StorageUsage(r.Context())
	if err != nil {
		s.writeStoreError(w, "розміри сховища", err)
		return
	}
	writeJSON(w, http.StatusOK, out)
}

// handleSetStorageConfig зберігає все, що людина знає про том: його
// ємність (або шлях, за яким її можна виміряти) і пороги попередження.
//
// Ємність питають у людини, бо більше ні в кого: функції «скільки
// вільного на диску» в Postgres немає, а процес API живе в іншому
// контейнері. Без цього числа сторінка чесно не показує запасу — і це
// краще, ніж показати дату переповнення, взяту зі стелі. З 0067 у
// цього числа є й другий шлях: том, змонтований у контейнер збірника,
// міряється, а не вводиться.
//
// Ємність і пороги — одна ручка навмисно. Вони не просто «поруч», вони
// одна річ: поріг «лишилось менше N діб» без ємності не рахується
// взагалі, а ємність без порога нікого ні про що не сповіщає. Дві ручки
// дали б стан «ємність указали, попередження лишили вимкненим» — прилад
// без сигналізації, зібраний тим, хто щойно прийшов його налаштувати.
func (s *Server) handleSetStorageConfig(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "settings:write") {
		return
	}
	// Усі поля попередження — вказівники, і не з любові до вказівників.
	// Відсутність поля має означати «не чіпай», а не «постав нуль»:
	// інакше перше ж збереження ємності зі старої вкладки тихо вимкнуло
	// б попередження й обнулило пороги. Для вимикача ця різниця
	// вирішальна — «не сказали» й «вимкни» тут протилежні за наслідками.
	var in struct {
		DiskBytes int64 `json:"disk_bytes"`
		WarnPct   int   `json:"warn_pct"`

		DataPath     *string `json:"data_path"`
		AlertEnabled *bool   `json:"alert_enabled"`
		DaysWarn     *int    `json:"alert_days_warn"`
		DaysCrit     *int    `json:"alert_days_crit"`
	}
	if !decodeBody(w, r, &in) {
		return
	}
	if in.WarnPct == 0 {
		in.WarnPct = 80
	}
	if err := s.store.SetStorageConfig(r.Context(), in.DiskBytes, in.WarnPct, p.UserID); err != nil {
		s.writeStoreError(w, "збереження ємності тому", err)
		return
	}

	// Поточні значення читаються ДО накладання нових: форма може
	// прислати лише те, що на ній змінили, а решта має лишитись такою,
	// якою була, а не такою, якою її вгадає нуль структури.
	cur, err := s.store.StorageAlertSettings(r.Context())
	if err != nil {
		s.writeStoreError(w, "налаштування попередження про місце", err)
		return
	}
	if in.AlertEnabled != nil {
		cur.Enabled = *in.AlertEnabled
	}
	if in.DaysWarn != nil {
		cur.DaysWarn = *in.DaysWarn
	}
	if in.DaysCrit != nil {
		cur.DaysCrit = *in.DaysCrit
	}
	if err := s.store.SetStorageAlert(r.Context(), cur, in.DataPath, p.UserID); err != nil {
		s.writeStoreError(w, "збереження порогів попередження", err)
		return
	}
	out, err := s.store.StorageUsage(r.Context())
	if err != nil {
		s.writeStoreError(w, "розміри сховища", err)
		return
	}
	writeJSON(w, http.StatusOK, out)
}

// handleGetRetentionSettings — строки разом зі словником видів даних.
//
// Словник їде тим самим запитом, а не окремим: без пояснення «від чого
// залежить обсяг цього виду» форма перетворюється на двадцять полів із
// числами, і заповнюють її навмання.
func (s *Server) handleGetRetentionSettings(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "devices:read") {
		return
	}
	rows, err := s.store.RetentionSettings(r.Context())
	if err != nil {
		s.writeStoreError(w, "строки зберігання", err)
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{
		"kinds": rows,
		// Чи вільно цій людині міняти строки. Клієнт міг би вивести це
		// сам зі свого переліку прав, але тоді правило жило б у двох
		// місцях і розійшлося б на першій же зміні.
		"can_edit": p.Can("settings:write"),
	})
}

// retentionBody — набір строків цілком.
//
// Саме цілком, а не «що змінилось»: половина перевірок тут про
// стосунки між видами («згортка не живе менше за джерело»), і на
// одному полі їх не перевірити. Значення — вказівник: null означає «не
// видаляти», і це не те саме, що нуль.
type retentionBody struct {
	Keep map[string]*int `json:"keep"`
}

// handleRetentionPreview — «що зникне, якщо застосувати ці строки».
//
// Окремий крок і окрема ручка, як у масовому видаленні хостів:
// підтвердження без точного переліку не вважається підтвердженням.
// Різниця лише в тому, що тут зникає не об'єкт зі списку, а хвіст
// історії — і побачити його інакше ніяк.
func (s *Server) handleRetentionPreview(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "settings:write") {
		return
	}
	var in retentionBody
	if !decodeBody(w, r, &in) {
		return
	}
	if err := store.ValidateRetention(in.Keep); err != nil {
		s.writeRetentionError(w, err)
		return
	}

	out, err := s.store.PreviewRetention(r.Context(), in.Keep)
	if err != nil {
		s.writeStoreError(w, "попередній перегляд очистки", err)
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"items": out})
}

// handleSetRetentionSettings зберігає строки й застосовує політики.
func (s *Server) handleSetRetentionSettings(w http.ResponseWriter, r *http.Request, p *Principal) {
	if !requirePerm(w, p, "settings:write") {
		return
	}
	var in retentionBody
	if !decodeBody(w, r, &in) {
		return
	}

	// Знімок ДО збереження: у журнал має поїхати «з 35 діб на 7», а не
	// «зберегли форму». Читаємо до, бо після цієї відповіді вже немає.
	before, err := s.store.RetentionSettings(r.Context())
	if err != nil {
		s.writeStoreError(w, "строки зберігання", err)
		return
	}

	if _, err := s.store.SaveRetention(r.Context(), in.Keep, p.UserID); err != nil {
		s.writeRetentionError(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.AuditActionRetentionSettings,
		ObjectType:   store.AuditObjectRetention,
		Meta:         store.RetentionAuditMeta(before, in.Keep),
	}); err != nil {
		s.log.Error("аудит строків зберігання", "err", err)
	}

	rows, err := s.store.RetentionSettings(r.Context())
	if err != nil {
		s.writeStoreError(w, "строки зберігання", err)
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"kinds": rows, "can_edit": true})
}

// writeRetentionError відрізняє «числа суперечать одне одному» від
// решти.
//
// Обидва — 400, але код різний, і це не формальність: клієнт показує
// такий текст цілком, і «строки суперечать» треба показати поруч із
// полями, а не в загальній смужці помилки нагорі.
func (s *Server) writeRetentionError(w http.ResponseWriter, err error) {
	if errors.Is(err, store.ErrRetentionInvalid) {
		writeError(w, http.StatusBadRequest, "retention_conflict", err.Error())
		return
	}
	s.writeStoreError(w, "строки зберігання", err)
}