No OneTemporary
Actions

Size

29 KB

Subscribers

None

View Options

	diff --git a/admin.go b/admin.go
	index fdbb82f..5b3acab 100644
	--- a/admin.go
	+++ b/admin.go
	@@ -1,459 +1,501 @@
	/*
	* Copyright © 2018-2019 A Bunch Tell LLC.
	*
	* This file is part of WriteFreely.
	*
	* WriteFreely is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License, included
	* in the LICENSE file in this source code package.
	*/

	package writefreely

	import (
	"database/sql"
	"fmt"
	"net/http"
	"runtime"
	"strconv"
	+ "strings"
	"time"

	"github.com/gorilla/mux"
	"github.com/writeas/impart"
	"github.com/writeas/web-core/auth"
	"github.com/writeas/web-core/log"
	+ "github.com/writeas/web-core/passgen"
	"github.com/writeas/writefreely/appstats"
	"github.com/writeas/writefreely/config"
	)

	var (
	appStartTime = time.Now()
	sysStatus systemStatus
	)

	const adminUsersPerPage = 30

	type systemStatus struct {
	Uptime string
	NumGoroutine int

	// General statistics.
	MemAllocated string // bytes allocated and still in use
	MemTotal string // bytes allocated (even if freed)
	MemSys string // bytes obtained from system (sum of XxxSys below)
	Lookups uint64 // number of pointer lookups
	MemMallocs uint64 // number of mallocs
	MemFrees uint64 // number of frees

	// Main allocation heap statistics.
	HeapAlloc string // bytes allocated and still in use
	HeapSys string // bytes obtained from system
	HeapIdle string // bytes in idle spans
	HeapInuse string // bytes in non-idle span
	HeapReleased string // bytes released to the OS
	HeapObjects uint64 // total number of allocated objects

	// Low-level fixed-size structure allocator statistics.
	// Inuse is bytes used now.
	// Sys is bytes obtained from system.
	StackInuse string // bootstrap stacks
	StackSys string
	MSpanInuse string // mspan structures
	MSpanSys string
	MCacheInuse string // mcache structures
	MCacheSys string
	BuckHashSys string // profiling bucket hash table
	GCSys string // GC metadata
	OtherSys string // other system allocations

	// Garbage collector statistics.
	NextGC string // next run in HeapAlloc time (bytes)
	LastGC string // last run in absolute time (ns)
	PauseTotalNs string
	PauseNs string // circular buffer of recent GC pause times, most recent at [(NumGC+255)%256]
	NumGC uint32
	}

	type inspectedCollection struct {
	CollectionObj
	Followers int
	LastPost string
	}

	type instanceContent struct {
	ID string
	Type string
	Title sql.NullString
	Content string
	Updated time.Time
	}

	func (c instanceContent) UpdatedFriendly() string {
	/*
	// TODO: accept a locale in this method and use that for the format
	var loc monday.Locale = monday.LocaleEnUS
	return monday.Format(u.Created, monday.DateTimeFormatsByLocale[loc], loc)
	*/
	return c.Updated.Format("January 2, 2006, 3:04 PM")
	}

	func handleViewAdminDash(app App, u User, w http.ResponseWriter, r *http.Request) error {
	updateAppStats()
	p := struct {
	*UserPage
	SysStatus systemStatus
	Config config.AppCfg

	Message, ConfigMessage string
	}{
	UserPage: NewUserPage(app, r, u, "Admin", nil),
	SysStatus: sysStatus,
	Config: app.cfg.App,

	Message: r.FormValue("m"),
	ConfigMessage: r.FormValue("cm"),
	}

	showUserPage(w, "admin", p)
	return nil
	}

	func handleViewAdminUsers(app App, u User, w http.ResponseWriter, r *http.Request) error {
	p := struct {
	*UserPage
	Config config.AppCfg
	Message string

	Users *[]User
	CurPage int
	TotalUsers int64
	TotalPages []int
	}{
	UserPage: NewUserPage(app, r, u, "Users", nil),
	Config: app.cfg.App,
	Message: r.FormValue("m"),
	}

	p.TotalUsers = app.db.GetAllUsersCount()
	ttlPages := p.TotalUsers / adminUsersPerPage
	p.TotalPages = []int{}
	for i := 1; i <= int(ttlPages); i++ {
	p.TotalPages = append(p.TotalPages, i)
	}

	var err error
	p.CurPage, err = strconv.Atoi(r.FormValue("p"))
	if err != nil \|\| p.CurPage < 1 {
	p.CurPage = 1
	} else if p.CurPage > int(ttlPages) {
	p.CurPage = int(ttlPages)
	}

	p.Users, err = app.db.GetAllUsers(uint(p.CurPage))
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get users: %v", err)}
	}

	showUserPage(w, "users", p)
	return nil
	}

	func handleViewAdminUser(app App, u User, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	username := vars["username"]
	if username == "" {
	return impart.HTTPError{http.StatusFound, "/admin/users"}
	}

	p := struct {
	*UserPage
	- Config config.AppCfg
	- Message string
	-
	- User *User
	- Colls []inspectedCollection
	- LastPost string
	-
	- TotalPosts int64
	+ Config config.AppCfg
	+ Message string
	+ OwnUserPage bool
	+
	+ User *User
	+ Colls []inspectedCollection
	+ LastPost string
	+ NewPassword string
	+ TotalPosts int64
	}{
	Config: app.cfg.App,
	Message: r.FormValue("m"),
	Colls: []inspectedCollection{},
	}

	+ flashes, _ := getSessionFlashes(app, w, r, nil)
	+ for _, flash := range flashes {
	+ if strings.HasPrefix(flash, "SUCCESS: ") {
	+ p.NewPassword = strings.TrimPrefix(flash, "SUCCESS: ")
	+ }
	+ }
	+
	var err error
	p.User, err = app.db.GetUserForAuth(username)
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get user: %v", err)}
	}
	+ p.OwnUserPage = u.ID == p.User.ID
	p.UserPage = NewUserPage(app, r, u, p.User.Username, nil)
	p.TotalPosts = app.db.GetUserPostsCount(p.User.ID)
	lp, err := app.db.GetUserLastPostTime(p.User.ID)
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get user's last post time: %v", err)}
	}
	if lp != nil {
	p.LastPost = lp.Format("January 2, 2006, 3:04 PM")
	}

	colls, err := app.db.GetCollections(p.User, app.cfg.App.Host)
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get user's collections: %v", err)}
	}
	for _, c := range *colls {
	ic := inspectedCollection{
	CollectionObj: CollectionObj{Collection: c},
	}

	if app.cfg.App.Federation {
	folls, err := app.db.GetAPFollowers(&c)
	if err == nil {
	// TODO: handle error here (at least log it)
	ic.Followers = len(*folls)
	}
	}

	app.db.GetPostsCount(&ic.CollectionObj, true)

	lp, err := app.db.GetCollectionLastPostTime(c.ID)
	if err != nil {
	log.Error("Didn't get last post time for collection %d: %v", c.ID, err)
	}
	if lp != nil {
	ic.LastPost = lp.Format("January 2, 2006, 3:04 PM")
	}

	p.Colls = append(p.Colls, ic)
	}

	showUserPage(w, "view-user", p)
	return nil
	}

	+func handleAdminResetUserPass(app App, u User, w http.ResponseWriter, r *http.Request) error {
	+ vars := mux.Vars(r)
	+ username := vars["username"]
	+ if username == "" {
	+ return impart.HTTPError{http.StatusFound, "/admin/users"}
	+ }
	+ // Generate new random password since none supplied
	+ pass := passgen.New()
	+ hashedPass, err := auth.HashPass([]byte(pass))
	+ if err != nil {
	+ return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not create password hash: %v", err)}
	+ }
	+
	+ userIDVal := r.FormValue("user")
	+ log.Info("ADMIN: Changing user %s password", userIDVal)
	+ id, err := strconv.Atoi(userIDVal)
	+ if err != nil {
	+ return impart.HTTPError{http.StatusBadRequest, fmt.Sprintf("Invalid user ID: %v", err)}
	+ }
	+
	+ err = app.db.ChangePassphrase(int64(id), true, "", hashedPass)
	+ if err != nil {
	+ return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not update passphrase: %v", err)}
	+ }
	+ log.Info("ADMIN: Successfully changed.")
	+
	+ addSessionFlash(app, w, r, fmt.Sprintf("SUCCESS: %s", pass), nil)
	+
	+ return impart.HTTPError{http.StatusFound, fmt.Sprintf("/admin/user/%s", username)}
	+}
	+
	func handleViewAdminPages(app App, u User, w http.ResponseWriter, r *http.Request) error {
	p := struct {
	*UserPage
	Config config.AppCfg
	Message string

	Pages []*instanceContent
	}{
	UserPage: NewUserPage(app, r, u, "Pages", nil),
	Config: app.cfg.App,
	Message: r.FormValue("m"),
	}

	var err error
	p.Pages, err = app.db.GetInstancePages()
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get pages: %v", err)}
	}

	// Add in default pages
	var hasAbout, hasPrivacy bool
	for i, c := range p.Pages {
	if hasAbout && hasPrivacy {
	break
	}
	if c.ID == "about" {
	hasAbout = true
	if !c.Title.Valid {
	p.Pages[i].Title = defaultAboutTitle(app.cfg)
	}
	} else if c.ID == "privacy" {
	hasPrivacy = true
	if !c.Title.Valid {
	p.Pages[i].Title = defaultPrivacyTitle()
	}
	}
	}
	if !hasAbout {
	p.Pages = append(p.Pages, &instanceContent{
	ID: "about",
	Title: defaultAboutTitle(app.cfg),
	Content: defaultAboutPage(app.cfg),
	Updated: defaultPageUpdatedTime,
	})
	}
	if !hasPrivacy {
	p.Pages = append(p.Pages, &instanceContent{
	ID: "privacy",
	Title: defaultPrivacyTitle(),
	Content: defaultPrivacyPolicy(app.cfg),
	Updated: defaultPageUpdatedTime,
	})
	}

	showUserPage(w, "pages", p)
	return nil
	}

	func handleViewAdminPage(app App, u User, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	slug := vars["slug"]
	if slug == "" {
	return impart.HTTPError{http.StatusFound, "/admin/pages"}
	}

	p := struct {
	*UserPage
	Config config.AppCfg
	Message string

	Banner *instanceContent
	Content *instanceContent
	}{
	Config: app.cfg.App,
	Message: r.FormValue("m"),
	}

	var err error
	// Get pre-defined pages, or select slug
	if slug == "about" {
	p.Content, err = getAboutPage(app)
	} else if slug == "privacy" {
	p.Content, err = getPrivacyPage(app)
	} else if slug == "landing" {
	p.Banner, err = getLandingBanner(app)
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get banner: %v", err)}
	}
	p.Content, err = getLandingBody(app)
	p.Content.ID = "landing"
	} else if slug == "reader" {
	p.Content, err = getReaderSection(app)
	} else {
	p.Content, err = app.db.GetDynamicContent(slug)
	}
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not get page: %v", err)}
	}
	title := "New page"
	if p.Content != nil {
	title = "Edit " + p.Content.ID
	} else {
	p.Content = &instanceContent{}
	}
	p.UserPage = NewUserPage(app, r, u, title, nil)

	showUserPage(w, "view-page", p)
	return nil
	}

	func handleAdminUpdateSite(app App, u User, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["page"]

	// Validate
	if id != "about" && id != "privacy" && id != "landing" && id != "reader" {
	return impart.HTTPError{http.StatusNotFound, "No such page."}
	}

	var err error
	m := ""
	if id == "landing" {
	// Handle special landing page
	err = app.db.UpdateDynamicContent("landing-banner", "", r.FormValue("banner"), "section")
	if err != nil {
	m = "?m=" + err.Error()
	return impart.HTTPError{http.StatusFound, "/admin/page/" + id + m}
	}
	err = app.db.UpdateDynamicContent("landing-body", "", r.FormValue("content"), "section")
	} else if id == "reader" {
	// Update sections with titles
	err = app.db.UpdateDynamicContent(id, r.FormValue("title"), r.FormValue("content"), "section")
	} else {
	// Update page
	err = app.db.UpdateDynamicContent(id, r.FormValue("title"), r.FormValue("content"), "page")
	}
	if err != nil {
	m = "?m=" + err.Error()
	}
	return impart.HTTPError{http.StatusFound, "/admin/page/" + id + m}
	}

	func handleAdminUpdateConfig(apper Apper, u User, w http.ResponseWriter, r http.Request) error {
	apper.App().cfg.App.SiteName = r.FormValue("site_name")
	apper.App().cfg.App.SiteDesc = r.FormValue("site_desc")
	apper.App().cfg.App.Landing = r.FormValue("landing")
	apper.App().cfg.App.OpenRegistration = r.FormValue("open_registration") == "on"
	mul, err := strconv.Atoi(r.FormValue("min_username_len"))
	if err == nil {
	apper.App().cfg.App.MinUsernameLen = mul
	}
	mb, err := strconv.Atoi(r.FormValue("max_blogs"))
	if err == nil {
	apper.App().cfg.App.MaxBlogs = mb
	}
	apper.App().cfg.App.Federation = r.FormValue("federation") == "on"
	apper.App().cfg.App.PublicStats = r.FormValue("public_stats") == "on"
	apper.App().cfg.App.Private = r.FormValue("private") == "on"
	apper.App().cfg.App.LocalTimeline = r.FormValue("local_timeline") == "on"
	if apper.App().cfg.App.LocalTimeline && apper.App().timeline == nil {
	log.Info("Initializing local timeline...")
	initLocalTimeline(apper.App())
	}
	apper.App().cfg.App.UserInvites = r.FormValue("user_invites")
	if apper.App().cfg.App.UserInvites == "none" {
	apper.App().cfg.App.UserInvites = ""
	}
	apper.App().cfg.App.DefaultVisibility = r.FormValue("default_visibility")

	m := "?cm=Configuration+saved."
	err = apper.SaveConfig(apper.App().cfg)
	if err != nil {
	m = "?cm=" + err.Error()
	}
	return impart.HTTPError{http.StatusFound, "/admin" + m + "#config"}
	}

	func updateAppStats() {
	sysStatus.Uptime = appstats.TimeSincePro(appStartTime)

	m := new(runtime.MemStats)
	runtime.ReadMemStats(m)
	sysStatus.NumGoroutine = runtime.NumGoroutine()

	sysStatus.MemAllocated = appstats.FileSize(int64(m.Alloc))
	sysStatus.MemTotal = appstats.FileSize(int64(m.TotalAlloc))
	sysStatus.MemSys = appstats.FileSize(int64(m.Sys))
	sysStatus.Lookups = m.Lookups
	sysStatus.MemMallocs = m.Mallocs
	sysStatus.MemFrees = m.Frees

	sysStatus.HeapAlloc = appstats.FileSize(int64(m.HeapAlloc))
	sysStatus.HeapSys = appstats.FileSize(int64(m.HeapSys))
	sysStatus.HeapIdle = appstats.FileSize(int64(m.HeapIdle))
	sysStatus.HeapInuse = appstats.FileSize(int64(m.HeapInuse))
	sysStatus.HeapReleased = appstats.FileSize(int64(m.HeapReleased))
	sysStatus.HeapObjects = m.HeapObjects

	sysStatus.StackInuse = appstats.FileSize(int64(m.StackInuse))
	sysStatus.StackSys = appstats.FileSize(int64(m.StackSys))
	sysStatus.MSpanInuse = appstats.FileSize(int64(m.MSpanInuse))
	sysStatus.MSpanSys = appstats.FileSize(int64(m.MSpanSys))
	sysStatus.MCacheInuse = appstats.FileSize(int64(m.MCacheInuse))
	sysStatus.MCacheSys = appstats.FileSize(int64(m.MCacheSys))
	sysStatus.BuckHashSys = appstats.FileSize(int64(m.BuckHashSys))
	sysStatus.GCSys = appstats.FileSize(int64(m.GCSys))
	sysStatus.OtherSys = appstats.FileSize(int64(m.OtherSys))

	sysStatus.NextGC = appstats.FileSize(int64(m.NextGC))
	sysStatus.LastGC = fmt.Sprintf("%.1fs", float64(time.Now().UnixNano()-int64(m.LastGC))/1000/1000/1000)
	sysStatus.PauseTotalNs = fmt.Sprintf("%.1fs", float64(m.PauseTotalNs)/1000/1000/1000)
	sysStatus.PauseNs = fmt.Sprintf("%.3fs", float64(m.PauseNs[(m.NumGC+255)%256])/1000/1000/1000)
	sysStatus.NumGC = m.NumGC
	}

	func adminResetPassword(app App, u User, newPass string) error {
	hashedPass, err := auth.HashPass([]byte(newPass))
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not create password hash: %v", err)}
	}

	err = app.db.ChangePassphrase(u.ID, true, "", hashedPass)
	if err != nil {
	return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not update passphrase: %v", err)}
	}
	return nil
	}
	diff --git a/routes.go b/routes.go
	index 0113e93..003b7d1 100644
	--- a/routes.go
	+++ b/routes.go
	@@ -1,206 +1,207 @@
	/*
	* Copyright © 2018-2019 A Bunch Tell LLC.
	*
	* This file is part of WriteFreely.
	*
	* WriteFreely is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License, included
	* in the LICENSE file in this source code package.
	*/

	package writefreely

	import (
	"net/http"
	"path/filepath"
	"strings"

	"github.com/gorilla/mux"
	"github.com/writeas/go-webfinger"
	"github.com/writeas/web-core/log"
	"github.com/writefreely/go-nodeinfo"
	)

	// InitStaticRoutes adds routes for serving static files.
	// TODO: this should just be a func, not method
	func (app App) InitStaticRoutes(r mux.Router) {
	// Handle static files
	fs := http.FileServer(http.Dir(filepath.Join(app.cfg.Server.StaticParentDir, staticDir)))
	app.shttp = http.NewServeMux()
	app.shttp.Handle("/", fs)
	r.PathPrefix("/").Handler(fs)
	}

	// InitRoutes adds dynamic routes for the given mux.Router.
	func InitRoutes(apper Apper, r mux.Router) mux.Router {
	// Create handler
	handler := NewWFHandler(apper)

	// Set up routes
	hostSubroute := apper.App().cfg.App.Host[strings.Index(apper.App().cfg.App.Host, "://")+3:]
	if apper.App().cfg.App.SingleUser {
	hostSubroute = "{domain}"
	} else {
	if strings.HasPrefix(hostSubroute, "localhost") {
	hostSubroute = "localhost"
	}
	}

	if apper.App().cfg.App.SingleUser {
	log.Info("Adding %s routes (single user)...", hostSubroute)
	} else {
	log.Info("Adding %s routes (multi-user)...", hostSubroute)
	}

	// Primary app routes
	write := r.PathPrefix("/").Subrouter()

	// Federation endpoint configurations
	wf := webfinger.Default(wfResolver{apper.App().db, apper.App().cfg})
	wf.NoTLSHandler = nil

	// Federation endpoints
	// host-meta
	write.HandleFunc("/.well-known/host-meta", handler.Web(handleViewHostMeta, UserLevelReader))
	// webfinger
	write.HandleFunc(webfinger.WebFingerPath, handler.LogHandlerFunc(http.HandlerFunc(wf.Webfinger)))
	// nodeinfo
	niCfg := nodeInfoConfig(apper.App().db, apper.App().cfg)
	ni := nodeinfo.NewService(*niCfg, nodeInfoResolver{apper.App().cfg, apper.App().db})
	write.HandleFunc(nodeinfo.NodeInfoPath, handler.LogHandlerFunc(http.HandlerFunc(ni.NodeInfoDiscover)))
	write.HandleFunc(niCfg.InfoURL, handler.LogHandlerFunc(http.HandlerFunc(ni.NodeInfo)))

	// Set up dyamic page handlers
	// Handle auth
	auth := write.PathPrefix("/api/auth/").Subrouter()
	if apper.App().cfg.App.OpenRegistration {
	auth.HandleFunc("/signup", handler.All(apiSignup)).Methods("POST")
	}
	auth.HandleFunc("/login", handler.All(login)).Methods("POST")
	auth.HandleFunc("/read", handler.WebErrors(handleWebCollectionUnlock, UserLevelNone)).Methods("POST")
	auth.HandleFunc("/me", handler.All(handleAPILogout)).Methods("DELETE")

	// Handle logged in user sections
	me := write.PathPrefix("/me").Subrouter()
	me.HandleFunc("/", handler.Redirect("/me", UserLevelUser))
	me.HandleFunc("/c", handler.Redirect("/me/c/", UserLevelUser)).Methods("GET")
	me.HandleFunc("/c/", handler.User(viewCollections)).Methods("GET")
	me.HandleFunc("/c/{collection}", handler.User(viewEditCollection)).Methods("GET")
	me.HandleFunc("/c/{collection}/stats", handler.User(viewStats)).Methods("GET")
	me.HandleFunc("/posts", handler.Redirect("/me/posts/", UserLevelUser)).Methods("GET")
	me.HandleFunc("/posts/", handler.User(viewArticles)).Methods("GET")
	me.HandleFunc("/posts/export.csv", handler.Download(viewExportPosts, UserLevelUser)).Methods("GET")
	me.HandleFunc("/posts/export.zip", handler.Download(viewExportPosts, UserLevelUser)).Methods("GET")
	me.HandleFunc("/posts/export.json", handler.Download(viewExportPosts, UserLevelUser)).Methods("GET")
	me.HandleFunc("/export", handler.User(viewExportOptions)).Methods("GET")
	me.HandleFunc("/export.json", handler.Download(viewExportFull, UserLevelUser)).Methods("GET")
	me.HandleFunc("/settings", handler.User(viewSettings)).Methods("GET")
	me.HandleFunc("/invites", handler.User(handleViewUserInvites)).Methods("GET")
	me.HandleFunc("/logout", handler.Web(viewLogout, UserLevelNone)).Methods("GET")

	write.HandleFunc("/api/me", handler.All(viewMeAPI)).Methods("GET")
	apiMe := write.PathPrefix("/api/me/").Subrouter()
	apiMe.HandleFunc("/", handler.All(viewMeAPI)).Methods("GET")
	apiMe.HandleFunc("/posts", handler.UserAPI(viewMyPostsAPI)).Methods("GET")
	apiMe.HandleFunc("/collections", handler.UserAPI(viewMyCollectionsAPI)).Methods("GET")
	apiMe.HandleFunc("/password", handler.All(updatePassphrase)).Methods("POST")
	apiMe.HandleFunc("/self", handler.All(updateSettings)).Methods("POST")
	apiMe.HandleFunc("/invites", handler.User(handleCreateUserInvite)).Methods("POST")

	// Sign up validation
	write.HandleFunc("/api/alias", handler.All(handleUsernameCheck)).Methods("POST")

	// Handle collections
	write.HandleFunc("/api/collections", handler.All(newCollection)).Methods("POST")
	apiColls := write.PathPrefix("/api/collections/").Subrouter()
	apiColls.HandleFunc("/{alias:[0-9a-zA-Z\\-]+}", handler.AllReader(fetchCollection)).Methods("GET")
	apiColls.HandleFunc("/{alias:[0-9a-zA-Z\\-]+}", handler.All(existingCollection)).Methods("POST", "DELETE")
	apiColls.HandleFunc("/{alias}/posts", handler.AllReader(fetchCollectionPosts)).Methods("GET")
	apiColls.HandleFunc("/{alias}/posts", handler.All(newPost)).Methods("POST")
	apiColls.HandleFunc("/{alias}/posts/{post}", handler.AllReader(fetchPost)).Methods("GET")
	apiColls.HandleFunc("/{alias}/posts/{post:[a-zA-Z0-9]{10}}", handler.All(existingPost)).Methods("POST")
	apiColls.HandleFunc("/{alias}/posts/{post}/{property}", handler.AllReader(fetchPostProperty)).Methods("GET")
	apiColls.HandleFunc("/{alias}/collect", handler.All(addPost)).Methods("POST")
	apiColls.HandleFunc("/{alias}/pin", handler.All(pinPost)).Methods("POST")
	apiColls.HandleFunc("/{alias}/unpin", handler.All(pinPost)).Methods("POST")
	apiColls.HandleFunc("/{alias}/inbox", handler.All(handleFetchCollectionInbox)).Methods("POST")
	apiColls.HandleFunc("/{alias}/outbox", handler.AllReader(handleFetchCollectionOutbox)).Methods("GET")
	apiColls.HandleFunc("/{alias}/following", handler.AllReader(handleFetchCollectionFollowing)).Methods("GET")
	apiColls.HandleFunc("/{alias}/followers", handler.AllReader(handleFetchCollectionFollowers)).Methods("GET")

	// Handle posts
	write.HandleFunc("/api/posts", handler.All(newPost)).Methods("POST")
	posts := write.PathPrefix("/api/posts/").Subrouter()
	posts.HandleFunc("/{post:[a-zA-Z0-9]{10}}", handler.AllReader(fetchPost)).Methods("GET")
	posts.HandleFunc("/{post:[a-zA-Z0-9]{10}}", handler.All(existingPost)).Methods("POST", "PUT")
	posts.HandleFunc("/{post:[a-zA-Z0-9]{10}}", handler.All(deletePost)).Methods("DELETE")
	posts.HandleFunc("/{post:[a-zA-Z0-9]{10}}/{property}", handler.AllReader(fetchPostProperty)).Methods("GET")
	posts.HandleFunc("/claim", handler.All(addPost)).Methods("POST")
	posts.HandleFunc("/disperse", handler.All(dispersePost)).Methods("POST")

	write.HandleFunc("/auth/signup", handler.Web(handleWebSignup, UserLevelNoneRequired)).Methods("POST")
	write.HandleFunc("/auth/login", handler.Web(webLogin, UserLevelNoneRequired)).Methods("POST")

	write.HandleFunc("/admin", handler.Admin(handleViewAdminDash)).Methods("GET")
	write.HandleFunc("/admin/users", handler.Admin(handleViewAdminUsers)).Methods("GET")
	write.HandleFunc("/admin/user/{username}", handler.Admin(handleViewAdminUser)).Methods("GET")
	+ write.HandleFunc("/admin/user/{username}", handler.Admin(handleAdminResetUserPass)).Methods("POST")
	write.HandleFunc("/admin/pages", handler.Admin(handleViewAdminPages)).Methods("GET")
	write.HandleFunc("/admin/page/{slug}", handler.Admin(handleViewAdminPage)).Methods("GET")
	write.HandleFunc("/admin/update/config", handler.AdminApper(handleAdminUpdateConfig)).Methods("POST")
	write.HandleFunc("/admin/update/{page}", handler.Admin(handleAdminUpdateSite)).Methods("POST")

	// Handle special pages first
	write.HandleFunc("/login", handler.Web(viewLogin, UserLevelNoneRequired))
	write.HandleFunc("/signup", handler.Web(handleViewLanding, UserLevelNoneRequired))
	write.HandleFunc("/invite/{code}", handler.Web(handleViewInvite, UserLevelOptional)).Methods("GET")
	// TODO: show a reader-specific 404 page if the function is disabled
	write.HandleFunc("/read", handler.Web(viewLocalTimeline, UserLevelReader))
	RouteRead(handler, UserLevelReader, write.PathPrefix("/read").Subrouter())

	draftEditPrefix := ""
	if apper.App().cfg.App.SingleUser {
	draftEditPrefix = "/d"
	write.HandleFunc("/me/new", handler.Web(handleViewPad, UserLevelOptional)).Methods("GET")
	} else {
	write.HandleFunc("/new", handler.Web(handleViewPad, UserLevelOptional)).Methods("GET")
	}

	// All the existing stuff
	write.HandleFunc(draftEditPrefix+"/{action}/edit", handler.Web(handleViewPad, UserLevelOptional)).Methods("GET")
	write.HandleFunc(draftEditPrefix+"/{action}/meta", handler.Web(handleViewMeta, UserLevelOptional)).Methods("GET")
	// Collections
	if apper.App().cfg.App.SingleUser {
	RouteCollections(handler, write.PathPrefix("/").Subrouter())
	} else {
	write.HandleFunc("/{prefix:[@~$!\\-+]}{collection}", handler.Web(handleViewCollection, UserLevelReader))
	write.HandleFunc("/{collection}/", handler.Web(handleViewCollection, UserLevelReader))
	RouteCollections(handler, write.PathPrefix("/{prefix:[@~$!\\-+]?}{collection}").Subrouter())
	// Posts
	}
	write.HandleFunc(draftEditPrefix+"/{post}", handler.Web(handleViewPost, UserLevelOptional))
	write.HandleFunc("/", handler.Web(handleViewHome, UserLevelOptional))
	return r
	}

	func RouteCollections(handler Handler, r mux.Router) {
	r.HandleFunc("/page/{page:[0-9]+}", handler.Web(handleViewCollection, UserLevelReader))
	r.HandleFunc("/tag:{tag}", handler.Web(handleViewCollectionTag, UserLevelReader))
	r.HandleFunc("/tag:{tag}/feed/", handler.Web(ViewFeed, UserLevelReader))
	r.HandleFunc("/tags/{tag}", handler.Web(handleViewCollectionTag, UserLevelReader))
	r.HandleFunc("/sitemap.xml", handler.AllReader(handleViewSitemap))
	r.HandleFunc("/feed/", handler.AllReader(ViewFeed))
	r.HandleFunc("/{slug}", handler.CollectionPostOrStatic)
	r.HandleFunc("/{slug}/edit", handler.Web(handleViewPad, UserLevelUser))
	r.HandleFunc("/{slug}/edit/meta", handler.Web(handleViewMeta, UserLevelUser))
	r.HandleFunc("/{slug}/", handler.Web(handleCollectionPostRedirect, UserLevelReader)).Methods("GET")
	}

	func RouteRead(handler Handler, readPerm UserLevelFunc, r mux.Router) {
	r.HandleFunc("/api/posts", handler.Web(viewLocalTimelineAPI, readPerm))
	r.HandleFunc("/p/{page}", handler.Web(viewLocalTimeline, readPerm))
	r.HandleFunc("/feed/", handler.Web(viewLocalTimelineFeed, readPerm))
	r.HandleFunc("/t/{tag}", handler.Web(viewLocalTimeline, readPerm))
	r.HandleFunc("/a/{post}", handler.Web(handlePostIDRedirect, readPerm))
	r.HandleFunc("/{author}", handler.Web(viewLocalTimeline, readPerm))
	r.HandleFunc("/", handler.Web(viewLocalTimeline, readPerm))
	}
	diff --git a/templates/user/admin/view-user.tmpl b/templates/user/admin/view-user.tmpl
	index 2a74e5b..211297d 100644
	--- a/templates/user/admin/view-user.tmpl
	+++ b/templates/user/admin/view-user.tmpl
	@@ -1,87 +1,130 @@
	{{define "view-user"}}
	{{template "header" .}}
	<style>
	table.classy th {
	text-align: left;
	}
	h3 {
	font-weight: normal;
	}
	+input.copy-text {
	+ text-align: center;
	+ font-size: 1.2em;
	+ color: #555;
	+ margin-left: 1rem;
	+}
	+button[type="submit"].danger {
	+ padding-left: 2rem;
	+ padding-right: 2rem;
	+}
	</style>
	<div class="snug content-container">
	{{template "admin-header" .}}

	<h2 id="posts-header">{{.User.Username}}</h2>
	-
	+ {{if .NewPassword}}<p class="alert success">New password for user <strong>{{.User.Username}}</strong> is
	+ <input
	+ type="text"
	+ class="copy-text"
	+ value="{{.NewPassword}}"
	+ onfocus="if (this.select) this.select(); else this.setSelectionRange(0, this.value.length);"
	+ readonly />
	+ <br/><br/>
	+ You must share this new password with the user, this is the only time it will be displayed.
	+ </p>
	+ {{end}}
	<table class="classy export">
	<tr>
	<th>No.</th>
	<td>{{.User.ID}}</td>
	</tr>
	<tr>
	<th>Type</th>
	<td>{{if .User.IsAdmin}}Admin{{else}}User{{end}}</td>
	</tr>
	<tr>
	<th>Username</th>
	<td>{{.User.Username}}</td>
	</tr>
	<tr>
	<th>Joined</th>
	<td>{{.User.CreatedFriendly}}</td>
	</tr>
	<tr>
	<th>Total Posts</th>
	<td>{{.TotalPosts}}</td>
	</tr>
	<tr>
	<th>Last Post</th>
	<td>{{if .LastPost}}{{.LastPost}}{{else}}Never{{end}}</td>
	</tr>
	+ <tr>
	+ <th>Password</th>
	+ <td>
	+ {{if not .OwnUserPage}}
	+ <form id="reset-form" action="/admin/user/{{.User.Username}}" method="post" autocomplete="false">
	+ <input type="hidden" name="user" value="{{.User.ID}}"/>
	+ <button
	+ class="danger"
	+ type="submit">Reset</button>
	+ </form>
	+ {{else}}
	+ <a href="/me/settings" title="Go to reset password page">Change your password</a>
	+ {{end}}
	+ </td>
	+ </tr>
	</table>

	<h2>Blogs</h2>

	{{range .Colls}}
	<h3><a href="/{{.Alias}}/">{{.Title}}</a></h3>
	<table class="classy export">
	<tr>
	<th>Alias</th>
	<td>{{.Alias}}</td>
	</tr>
	<tr>
	<th>Title</th>
	<td>{{.Title}}</td>
	</tr>
	<tr>
	<th>Description</th>
	<td>{{.Description}}</td>
	</tr>
	<tr>
	<th>Visibility</th>
	<td>{{.FriendlyVisibility}}</td>
	</tr>
	<tr>
	<th>Views</th>
	<td>{{.Views}}</td>
	</tr>
	<tr>
	<th>Posts</th>
	<td>{{.TotalPosts}}</td>
	</tr>
	<tr>
	<th>Last Post</th>
	<td>{{if .LastPost}}{{.LastPost}}{{else}}Never{{end}}</td>
	</tr>
	{{if $.Config.Federation}}
	<tr>
	<th>Fediverse Followers</th>
	<td>{{.Followers}}</td>
	</tr>
	{{end}}
	</table>
	{{end}}
	</div>

	+<script type="text/javascript">
	+ form = document.getElementById("reset-form");
	+ form.addEventListener('submit', function(e) {
	+ e.preventDefault();
	+ agreed = confirm("Really reset password for {{.User.Username}}?\nYou will have to record and share the new password with them.");
	+ if (agreed === true) { form.submit();}
	+ });
	+</script>
	{{template "footer" .}}
	{{end}}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 25, 2:04 AM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3106500

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions