Files
pages/internal/server/config_handler.go
T
Anya Tokugawa b90aef79d0
Build and publish container images / images (push) Successful in 11m37s
Release container images / release (push) Successful in 22s
feat: add browser upload queue and trusted sessions with bounded projections
2026-11-08 20:27:04 +09:00

1141 lines
30 KiB
Go

package server
import (
"encoding/json"
"errors"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/google/uuid"
systemext "pageswiki/internal/extensions"
"pageswiki/internal/store"
)
func (s *Server) parseBroadcastTime(value string) int64 {
value = strings.TrimSpace(value)
if value == "" {
return 0
}
for _, layout := range []string{"2006-01-02 15:04", "2006-01-02T15:04"} {
if parsed, err := time.ParseInLocation(layout, value, s.getLocation()); err == nil {
return parsed.UnixMilli()
}
}
return 0
}
func parseNavItemsFromForm(
r *http.Request,
) []NavItem {
labels := r.Form["nav_label"]
hrefs := r.Form["nav_href"]
var items []NavItem
for i := range labels {
label :=
strings.TrimSpace(
labels[i],
)
if label == "" {
continue
}
if i >= len(hrefs) {
continue
}
href :=
strings.TrimSpace(
hrefs[i],
)
if href == "" {
continue
}
items = append(
items,
NavItem{
Label: label,
Href: href,
},
)
}
return items
}
func (s *Server) saveNavConfig(
domainUUID string,
key string,
items []NavItem,
) error {
raw, err :=
json.Marshal(
items,
)
if err != nil {
return err
}
return s.store.SetConfigInDomain(
domainUUID,
key,
string(raw),
)
}
func (s *Server) handleConfig(
w http.ResponseWriter,
r *http.Request,
) {
if personalOrganizerSettings(r) {
s.handleOrganizerSettings(w, r)
return
}
domainUUID := s.domainUUIDForRequest(r)
principal := s.requestPrincipal(r)
currentDomain := s.domainForRequest(r)
if principal == nil {
s.authRequired(w, r)
return
}
currentCampusAdmin := currentDomain != nil && s.store.IsCampusAdmin(currentDomain.CampusUUID, principal.UUID)
currentDomainAdmin := s.store.IsBuiltinGroupAdmin(domainUUID, principal.UUID, "domain_admin")
if !currentCampusAdmin && !currentDomainAdmin {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
if r.Method == http.MethodPost {
err := r.ParseForm()
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
section :=
r.FormValue(
"section",
)
campusAdminRequired := strings.HasPrefix(section, "campus-") || strings.HasPrefix(section, "domain-") || section == "instance-status"
if campusAdminRequired {
targetCampusUUID := currentDomain.CampusUUID
if section == "domain-create" {
targetCampusUUID = r.FormValue("domain_campus_uuid")
} else if section == "domain-update" || section == "domain-delete" || section == "domain-entry" || section == "domain-projection" {
_ = s.store.DB.QueryRow(`SELECT campus_uuid FROM domains WHERE id=?`, r.FormValue("domain_id")).Scan(&targetCampusUUID)
} else if section != "campus-create" && r.FormValue("campus_id") != "" {
_ = s.store.DB.QueryRow(`SELECT uuid FROM campuses WHERE id=?`, r.FormValue("campus_id")).Scan(&targetCampusUUID)
}
if !s.store.IsCampusAdmin(targetCampusUUID, principal.UUID) {
http.Error(w, "campus admin required", http.StatusForbidden)
return
}
}
switch section {
case "external-resource-add":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
item, normalizeErr := normalizeExternalResourceApproval(externalResourceApproval{
Kind: r.FormValue("kind"), URL: r.FormValue("url"), Integrity: r.FormValue("integrity"),
})
if normalizeErr != nil {
http.Error(w, normalizeErr.Error(), http.StatusBadRequest)
return
}
if item.Kind == "script" && r.FormValue("confirm_script_risk") != "1" {
http.Error(w, "external script risk must be confirmed", http.StatusBadRequest)
return
}
items := s.externalResourcePolicy(domainUUID).items
items = append(items, item)
if err = s.saveExternalResourceApprovals(domainUUID, items); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "external-resource-delete":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
kind := strings.ToLower(strings.TrimSpace(r.FormValue("kind")))
resourceURL, normalizeErr := normalizeExternalResourceURL(r.FormValue("url"))
if normalizeErr != nil {
http.Error(w, normalizeErr.Error(), http.StatusBadRequest)
return
}
items := s.externalResourcePolicy(domainUUID).items
filtered := items[:0]
for _, item := range items {
if item.Kind != kind || item.URL != resourceURL {
filtered = append(filtered, item)
}
}
if err = s.saveExternalResourceApprovals(domainUUID, filtered); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "broadcast":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
b := store.Broadcast{UUID: r.FormValue("uuid"), DomainUUID: domainUUID, Title: r.FormValue("title"), Body: r.FormValue("body"), Severity: r.FormValue("severity")}
if b.UUID == "" {
b.UUID = uuid.NewString()
}
b.StartsAtMS = s.parseBroadcastTime(r.FormValue("starts_at"))
b.EndsAtMS = s.parseBroadcastTime(r.FormValue("ends_at"))
if err = s.store.SaveBroadcast(b); err != nil {
http.Error(w, err.Error(), 400)
return
}
if b.StartsAtMS > time.Now().UnixMilli() || (b.EndsAtMS > 0 && b.EndsAtMS <= time.Now().UnixMilli()) {
break
}
principals, listErr := s.store.ListDomainPrincipals(domainUUID)
if listErr != nil {
http.Error(w, listErr.Error(), 500)
return
}
tx, txErr := s.store.DB.BeginTx(r.Context(), nil)
if txErr == nil {
for _, recipient := range principals {
if recipient.State != "active" {
continue
}
if _, _, txErr = s.store.CreateNotificationTx(tx, store.Notification{DomainUUID: domainUUID, RecipientUUID: recipient.UUID, EventUUID: b.UUID, Kind: "broadcast", Href: "/v/notification", Message: b.Title}); txErr != nil {
break
}
}
}
if txErr == nil {
txErr = tx.Commit()
} else if tx != nil {
_ = tx.Rollback()
}
if txErr != nil {
http.Error(w, txErr.Error(), 500)
return
}
case "broadcast-delete":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
if err = s.store.DeleteBroadcast(domainUUID, r.FormValue("uuid")); err != nil {
http.Error(w, err.Error(), 500)
return
}
case "bookmarks":
bookmarks, parseErr := bookmarksFromForm(r)
if parseErr != nil {
http.Error(w, translate(s.getLocale(domainUUID), "config.bookmark_invalid"), http.StatusBadRequest)
return
}
encoded, _ := json.Marshal(bookmarks)
if err = s.store.SetConfigInDomain(domainUUID, "home_bookmarks", string(encoded)); err != nil {
http.Error(w, err.Error(), 500)
return
}
case "groups":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
group, createErr := s.store.CreateGroup(domainUUID, principal.UUID, r.FormValue("name"), r.FormValue("display_name"), r.FormValue("description"), r.FormValue("visibility"))
if createErr != nil {
http.Error(w, createErr.Error(), http.StatusBadRequest)
return
}
http.Redirect(w, r, "/g/"+url.PathEscape(group.Name)+"/_/edit", http.StatusSeeOther)
return
case "extension-toggle":
if !currentDomainAdmin {
http.Error(w, "domain admin required", http.StatusForbidden)
return
}
id := strings.TrimSpace(r.FormValue("extension_id"))
known := false
for _, item := range systemext.Catalog() {
if item.ID == id {
known = true
break
}
}
if !known {
http.Error(w, "unknown extension", http.StatusBadRequest)
return
}
enabled := r.FormValue("enabled") == "on" || r.FormValue("enabled") == "true"
if err = s.setSystemExtensionEnabled(domainUUID, id, enabled); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "home":
palette, paletteErr := s.parseHomePalette(domainUUID, r.Form)
if paletteErr != nil {
http.Error(w, paletteErr.Error(), http.StatusBadRequest)
return
}
if controlled, e := s.store.DomainEntryControlled(domainUUID); e != nil || controlled {
http.Error(w, translate(s.getLocale(domainUUID), "periodical.controlled"), http.StatusConflict)
return
}
wallpaperPath, validWallpaperPath := normalizePickerPath(r.FormValue("home_wallpaper_path"))
if !validWallpaperPath {
http.Error(w, "invalid wallpaper path", http.StatusBadRequest)
return
}
wallpaperOpacity := defaultHomeWallpaperOpacity
if raw := strings.TrimSpace(r.FormValue("home_wallpaper_opacity")); raw != "" {
wallpaperOpacity, err = strconv.Atoi(raw)
if err != nil || wallpaperOpacity < 0 || wallpaperOpacity > 100 {
http.Error(w, "invalid wallpaper opacity", http.StatusBadRequest)
return
}
}
glassTransparency := s.homeGlassTransparency(domainUUID)
if raw := strings.TrimSpace(r.FormValue("home_glass_transparency")); raw != "" {
glassTransparency, err = normalizeHomeGlassTransparency(raw)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
layout := strings.TrimSpace(r.FormValue("home_layout"))
if layout == "" {
layout = "classic"
}
if layout != "classic" && layout != "search" && layout != "directory" && layout != "diary" && layout != "blog" {
http.Error(w, "invalid home layout", http.StatusBadRequest)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "home_layout", layout); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"home_path",
strings.TrimSpace(
r.FormValue("home_path"),
),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "home_wallpaper_path", wallpaperPath); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.saveHomePalette(domainUUID, palette); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "home_wallpaper_opacity", strconv.Itoa(wallpaperOpacity)); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "home_glass_transparency", strconv.Itoa(glassTransparency)); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"virtual_folder_pages",
boolFormValue(r.FormValue("virtual_folder_pages")),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"locale",
normalizeLocale(
strings.TrimSpace(
r.FormValue("locale"),
),
),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
timezoneName :=
strings.TrimSpace(
r.FormValue("timezone"),
)
if timezoneName == "" {
timezoneName = "UTC"
}
_, err = time.LoadLocation(
timezoneName,
)
if err != nil {
http.Error(w, "invalid timezone", http.StatusBadRequest)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"timezone",
timezoneName,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
theme :=
s.getTheme(domainUUID)
if v := strings.TrimSpace(r.FormValue("theme")); v != "" {
if isAllowedTheme(v) {
theme = v
} else {
http.Error(w, "invalid theme", http.StatusBadRequest)
return
}
}
err = s.store.SetConfigInDomain(
domainUUID,
"theme",
theme,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
graceHours :=
strings.TrimSpace(
r.FormValue("zombie_grace_hours"),
)
if graceHours == "" {
graceHours = "24"
}
_, err = strconv.ParseInt(
graceHours,
10,
64,
)
if err != nil {
http.Error(w, "invalid zombie grace hours", http.StatusBadRequest)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"zombie_grace_hours",
graceHours,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "home-appearance":
palette, paletteErr := s.parseHomePalette(domainUUID, r.Form)
if paletteErr != nil {
http.Error(w, paletteErr.Error(), http.StatusBadRequest)
return
}
if controlled, e := s.store.DomainEntryControlled(domainUUID); e != nil || controlled {
http.Error(w, translate(s.getLocale(domainUUID), "periodical.controlled"), http.StatusConflict)
return
}
glassTransparency, parseErr := normalizeHomeGlassTransparency(r.FormValue("home_glass_transparency"))
if parseErr != nil {
http.Error(w, parseErr.Error(), http.StatusBadRequest)
return
}
if err = s.saveHomePalette(domainUUID, palette); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "home_glass_transparency", strconv.Itoa(glassTransparency)); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "nav-home":
err = s.saveNavConfig(
domainUUID,
"home_nav_items",
parseNavItemsFromForm(r),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "nav-system":
err = s.saveNavConfig(
domainUUID,
"system_nav_items",
parseNavItemsFromForm(r),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "editor":
keymap :=
strings.TrimSpace(
r.FormValue("editor_keymap"),
)
if keymap != "vim" {
keymap = "default"
}
format := strings.TrimSpace(r.FormValue("editor_format_default"))
if format != "markdown" {
format = "html"
}
previewDefault := strings.TrimSpace(r.FormValue("editor_preview_default"))
if previewDefault != "hidden" {
previewDefault = "visible"
}
if err = s.store.SetConfigInDomain(domainUUID, "editor_format_default", format); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = s.store.SetConfigInDomain(domainUUID, "editor_preview_default", previewDefault); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"editor_keymap",
keymap,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"editor_syntax_highlight",
boolFormValue(
r.FormValue("editor_syntax_highlight"),
),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = s.store.SetConfigInDomain(
domainUUID,
"editor_autocomplete",
boolFormValue(
r.FormValue("editor_autocomplete"),
),
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "domain-projection":
id, e := strconv.ParseInt(r.FormValue("domain_id"), 10, 64)
if e != nil {
http.Error(w, "invalid domain id", 400)
return
}
if e = s.store.SetPeriodicalProjection(r.Context(), id, principal.UUID, r.FormValue("kind"), r.FormValue("source_uuid"), r.FormValue("prefix")); e != nil {
http.Error(w, translate(s.getLocale(domainUUID), "periodical.projection_invalid"), 400)
return
}
case "domain-entry":
id, e := strconv.ParseInt(r.FormValue("domain_id"), 10, 64)
if e != nil {
http.Error(w, "invalid domain id", 400)
return
}
e = s.store.SetDomainEntry(r.Context(), id, principal.UUID, store.DomainEntrySettings{Layout: r.FormValue("entry_layout"), DiaryEnabled: r.FormValue("diary_enabled") == "1", DiaryPrefix: r.FormValue("diary_prefix"), BlogEnabled: r.FormValue("blog_enabled") == "1", BlogPrefix: r.FormValue("blog_prefix")})
if e != nil {
if errors.Is(e, store.ErrManifestCapability) {
http.Error(w, translate(s.getLocale(domainUUID), "periodical.capability_required"), 409)
return
}
http.Error(w, "invalid or unauthorized domain entry settings", 400)
return
}
case "domain-create":
err = s.store.CreateDomain(
r.FormValue("domain_campus_uuid"),
r.FormValue("domain_name"),
r.FormValue("domain_title"),
r.FormValue("domain_host"),
r.FormValue("domain_placement"),
r.FormValue("domain_instance_fqdn"),
r.FormValue("domain_instance_fingerprint"),
r.FormValue("domain_enabled") == "1",
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "domain-update":
id, parseErr :=
strconv.ParseInt(
r.FormValue("domain_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid domain id", http.StatusBadRequest)
return
}
err = s.store.UpdateDomain(
id,
r.FormValue("domain_campus_uuid"),
r.FormValue("domain_name"),
r.FormValue("domain_title"),
r.FormValue("domain_host"),
r.FormValue("domain_placement"),
r.FormValue("domain_instance_fqdn"),
r.FormValue("domain_instance_fingerprint"),
r.FormValue("domain_enabled") == "1",
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "domain-delete":
id, parseErr :=
strconv.ParseInt(
r.FormValue("domain_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid domain id", http.StatusBadRequest)
return
}
err = s.store.DeleteDomain(
id,
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "campus-create":
err = s.store.CreateCampus(
r.FormValue("campus_name"),
r.FormValue("campus_title"),
r.FormValue("campus_default_lang"),
r.FormValue("campus_authority_mode"),
r.FormValue("campus_fqdn"),
r.FormValue("campus_enabled") == "1",
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "campus-update":
id, parseErr :=
strconv.ParseInt(
r.FormValue("campus_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid campus id", http.StatusBadRequest)
return
}
err = s.store.UpdateCampus(
id,
r.FormValue("campus_name"),
r.FormValue("campus_title"),
r.FormValue("campus_default_lang"),
r.FormValue("campus_authority_mode"),
r.FormValue("campus_fqdn"),
r.FormValue("campus_enabled") == "1",
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "campus-delete":
id, parseErr :=
strconv.ParseInt(
r.FormValue("campus_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid campus id", http.StatusBadRequest)
return
}
err = s.store.DeleteCampus(id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "campus-managed-save":
id, parseErr := strconv.ParseInt(
r.FormValue("campus_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid campus id", http.StatusBadRequest)
return
}
campuses, listErr := s.store.ListCampuses()
if listErr != nil {
http.Error(w, listErr.Error(), http.StatusInternalServerError)
return
}
campus, findErr := managedCampusByID(campuses, id)
if findErr != nil {
http.Error(w, findErr.Error(), http.StatusBadRequest)
return
}
s.probeManagedCampus(campus)
case "campus-token-issue":
token, issueErr := s.store.IssueCampusToken(
r.FormValue("campus_uuid"),
r.FormValue("token_label"),
)
if issueErr != nil {
http.Error(w, issueErr.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusCreated)
_, _ = w.Write([]byte(
"Save this token now; it will not be shown again.\n\n" +
token + "\n",
))
return
case "instance-status":
id, parseErr := strconv.ParseInt(
r.FormValue("instance_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid instance id", http.StatusBadRequest)
return
}
err = s.store.SetFederationInstanceStatus(
id,
r.FormValue("instance_status"),
)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "campus-token-revoke":
id, parseErr := strconv.ParseInt(
r.FormValue("token_id"),
10,
64,
)
if parseErr != nil {
http.Error(w, "invalid token id", http.StatusBadRequest)
return
}
err = s.store.RevokeCampusToken(id)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
case "zombie-purge":
_, err = s.store.PurgeZombieObjectsInDomain(
r.Context(), domainUUID,
s.getZombieGraceSeconds(domainUUID),
100,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
case "scheduler-preview":
s.enqueueAllPreviewEvents()
default:
http.Error(
w,
"unknown config section: "+section,
http.StatusBadRequest,
)
return
}
panel := section
if section == "zombie-purge" {
panel = "objects"
}
if strings.HasPrefix(section, "domain-") {
panel = "domains"
}
if strings.HasPrefix(section, "campus-") {
panel = "campuses"
}
if section == "instance-status" {
panel = "campuses"
}
if section == "scheduler-preview" {
panel = "scheduler"
}
if section == "broadcast-delete" {
panel = "broadcasts"
}
if section == "broadcast" {
panel = "broadcasts"
}
if section == "extension-toggle" {
panel = "extensions"
}
if strings.HasPrefix(section, "external-resource-") {
panel = "external-resources"
}
if (section == "bookmarks" || section == "home-appearance") && strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, 200, map[string]bool{"ok": true})
return
}
if section == "bookmarks" && r.FormValue("return_home") == "true" {
http.Redirect(w, r, "/", http.StatusSeeOther)
return
}
http.Redirect(
w,
r,
"/-/sys/config?panel="+panel,
http.StatusFound,
)
return
}
homePath, err :=
s.store.GetConfigInDomain(
s.domainUUIDForRequest(r),
"home_path",
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
homeWallpaperPath, homeWallpaperOpacity := s.homeWallpaperConfig(s.domainUUIDForRequest(r))
wikiName := s.domainForRequest(r).Title
zombieGraceHours :=
s.getZombieGraceHours(s.domainUUIDForRequest(r))
var zombies []store.ZombieObject
if r.URL.Query().Get("panel") == "objects" {
zombies, err =
s.store.ListZombieObjectsInDomain(
r.Context(), s.domainUUIDForRequest(r),
s.getZombieGraceSeconds(s.domainUUIDForRequest(r)),
store.ZombieGCDefaultLimit,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
domains, err :=
s.store.ListDomains()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
domainEntries, err := s.store.DomainEntryOptions()
if err != nil {
http.Error(w, "entry settings unavailable", 503)
return
}
projections, err := s.store.ListPeriodicalProjections()
if err != nil {
http.Error(w, "projection settings unavailable", 503)
return
}
legacyPeers, err := s.store.CampusLegacyManifestPeers()
if err != nil {
http.Error(w, "instance capabilities unavailable", 503)
return
}
selectedDomain := s.domainForRequest(r)
requestedDomainUUID := strings.TrimSpace(r.URL.Query().Get("objects_domain"))
if requestedDomainUUID != "" {
for i := range domains {
if domains[i].UUID == requestedDomainUUID {
selectedDomain = &domains[i]
break
}
}
}
selectedCampusUUID := selectedDomain.CampusUUID
requestedCampusUUID := strings.TrimSpace(r.URL.Query().Get("objects_campus"))
if requestedCampusUUID != "" &&
requestedCampusUUID != selectedCampusUUID {
for i := range domains {
if domains[i].CampusUUID == requestedCampusUUID {
selectedDomain = &domains[i]
selectedCampusUUID = requestedCampusUUID
break
}
}
}
recent, err := s.store.ListRecentObjectsInDomain(
selectedDomain.UUID,
50,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
objectsDomainHost, err := s.store.GetDomainEffectiveHost(
selectedDomain.UUID,
)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
campuses, err :=
s.store.ListCampuses()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
campusManaged := map[string]bool{}
campusOnline := map[string]bool{}
var federationInstances []store.FederationInstance
for _, campus := range campuses {
campusManaged[campus.UUID] =
campus.AuthorityMode == "managed"
if campus.AuthorityMode == "managed" {
campusOnline[campus.UUID] =
managedCampusOnline(campus, time.Now())
}
instances, listErr := s.store.ListFederationInstances(
campus.UUID,
false,
)
if listErr != nil {
http.Error(w, listErr.Error(), http.StatusInternalServerError)
return
}
federationInstances = append(federationInstances, instances...)
}
campusTokens, err := s.store.ListCampusTokens()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
authPrincipals, err := s.store.ListDomainPrincipals(s.domainUUIDForRequest(r))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
authSessions, err := s.store.ListAuthSessions(s.domainUUIDForRequest(r))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
oidcConfig, _ := s.store.AuthProviderConfig(s.domainUUIDForRequest(r), "oidc")
if oidcConfig.OIDCMatchBy == "" {
oidcConfig.OIDCMatchBy = "email"
}
oidcConfig.ClientSecret = ""
smtpConfig, _ := s.store.AuthProviderConfig(s.domainUUIDForRequest(r), "smtp")
smtpConfig.SMTPPassword = ""
ldapConfig, _ := s.store.AuthProviderConfig(s.domainUUIDForRequest(r), "ldap")
ldapConfig.LDAPBindPassword = ""
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
groups, err := s.store.ListGroups(domainUUID, principal.UUID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
broadcasts, err := s.store.ListBroadcasts(r.Context(), domainUUID)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
s.renderWithContext(
w,
r,
"config.gohtml",
map[string]any{
"ConfigGroups": configPanelGroups(s.getLocale(domainUUID), plugins),
"Groups": groups,
"Broadcasts": broadcasts,
"ExternalResources": s.externalResourcePolicy(domainUUID).items,
"CanCreateGroups": currentDomainAdmin,
"AdapterPlugins": plugins,
"ManagedBookmarks": s.managedBookmarks(domainUUID),
"SystemExtensions": s.systemExtensionCatalog(domainUUID),
"VimSettings": s.domainVimSettings(domainUUID),
"NavItems": resolveNavItems(
s.getSystemNavItems(s.domainUUIDForRequest(r)),
NavContext{},
),
"HomePath": homePath,
"HomeWallpaperPath": homeWallpaperPath,
"HomeWallpaperOpacity": homeWallpaperOpacity,
"HomeGlassTransparency": s.homeGlassTransparency(domainUUID),
"HomePalette": s.homePalette(domainUUID),
"HomeLayout": s.homeLayout(s.domainUUIDForRequest(r)),
"HomeBookmarks": s.homeBookmarksText(s.domainUUIDForRequest(r)),
"VirtualFolderPages": s.getVirtualFolderPages(s.domainUUIDForRequest(r)),
"WikiName": wikiName,
"Locale": s.getLocale(s.domainUUIDForRequest(r)),
"Timezone": s.getTimezoneName(s.domainUUIDForRequest(r)),
"Theme": s.getTheme(s.domainUUIDForRequest(r)),
"ThemeOptions": themeOptions(),
"EditorKeymap": s.getEditorKeymap(s.domainUUIDForRequest(r)),
"EditorFormat": s.getEditorFormat(s.domainUUIDForRequest(r)),
"EditorPreviewDefault": s.getEditorPreviewDefault(s.domainUUIDForRequest(r)),
"EditorSyntax": s.getEditorSyntaxHighlight(s.domainUUIDForRequest(r)),
"EditorAutocomplete": s.getEditorAutocomplete(s.domainUUIDForRequest(r)),
"ZombieGraceHours": zombieGraceHours,
"Objects": recent,
"ZombieObjects": zombies,
"Domains": domains,
"DomainEntries": domainEntries,
"PeriodicalProjections": projections,
"PeriodicalKinds": []string{"diary", "blog"},
"CampusLegacyPeers": legacyPeers,
"Campuses": campuses,
"CampusManaged": campusManaged,
"CampusOnline": campusOnline,
"FederationInstances": federationInstances,
"CampusTokens": campusTokens,
"AuthPrincipals": authPrincipals,
"AuthSessions": authSessions,
"AuthSessionMinutes": s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r)),
"AuthTrustedSessionDays": s.store.TrustedSessionDays(s.domainUUIDForRequest(r)),
"OIDCConfig": oidcConfig,
"SMTPConfig": smtpConfig,
"LDAPConfig": ldapConfig,
"LDAPTest": r.URL.Query().Get("ldap_test"),
"ObjectsCampusUUID": selectedCampusUUID,
"ObjectsDomainUUID": selectedDomain.UUID,
"ObjectsDomainHost": objectsDomainHost,
"HomeNavItemsConfig": s.getHomeNavItems(s.domainUUIDForRequest(r)),
"SystemNavItemsConfig": s.getSystemNavItems(s.domainUUIDForRequest(r)),
},
)
}
func boolFormValue(
v string,
) string {
if v == "on" ||
v == "true" ||
v == "1" {
return "true"
}
return "false"
}