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 var targetErr error if section == "domain-create" { targetCampusUUID = r.FormValue("domain_campus_uuid") } else if section == "domain-update" || section == "domain-delete" || section == "domain-entry" || section == "domain-projection" { id, _ := strconv.ParseInt(r.FormValue("domain_id"), 10, 64) targetCampusUUID, targetErr = s.store.ConfigTargetCampus(r.Context(), true, id) } else if section != "campus-create" && r.FormValue("campus_id") != "" { id, _ := strconv.ParseInt(r.FormValue("campus_id"), 10, 64) targetCampusUUID, targetErr = s.store.ConfigTargetCampus(r.Context(), false, id) } if targetErr != nil || !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": if !s.store.SupportsZombieGC() { http.Error(w, store.ErrBackendFeatureUnavailable.Error(), http.StatusServiceUnavailable) return } _, 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" && s.store.SupportsZombieGC() { 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" }