Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
1116 lines
29 KiB
Go
1116 lines
29 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,
|
|
) {
|
|
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":
|
|
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.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":
|
|
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.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),
|
|
"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,
|
|
"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"
|
|
}
|