Page MenuHomeMusing Studio
Files F10528617

No OneTemporary
Actions

View Options

diff --git a/collections.go b/collections.go
index 0ba4089..0ec98df 100644
--- a/collections.go
+++ b/collections.go
@@ -1,69 +1,1041 @@
package writefreely
import (
"database/sql"
+ "encoding/json"
+ "fmt"
+ "html/template"
+ "math"
+ "net/http"
+ "net/url"
+ "regexp"
+ "strconv"
+ "strings"
+ "unicode"
+
+ "github.com/gorilla/mux"
+ "github.com/writeas/impart"
+ "github.com/writeas/web-core/activitystreams"
+ "github.com/writeas/web-core/auth"
+ "github.com/writeas/web-core/bots"
+ "github.com/writeas/web-core/log"
+ waposts "github.com/writeas/web-core/posts"
+ "github.com/writeas/writefreely/author"
+ "github.com/writeas/writefreely/page"
)
type (
+ // TODO: add Direction to db
+ // TODO: add Language to db
Collection struct {
- ID int64 `datastore:"id" json:"-"`
- Alias string `datastore:"alias" schema:"alias" json:"alias"`
- Title string `datastore:"title" schema:"title" json:"title"`
- Description string `datastore:"description" schema:"description" json:"description"`
- Direction string `schema:"dir" json:"dir,omitempty"`
- Language string `schema:"lang" json:"lang,omitempty"`
- StyleSheet string `datastore:"style_sheet" schema:"style_sheet" json:"style_sheet"`
- Script string `datastore:"script" schema:"script" json:"script,omitempty"`
- Public bool `datastore:"public" json:"public"`
- Visibility collVisibility `datastore:"private" json:"-"`
- Format string `datastore:"format" json:"format,omitempty"`
- Views int64 `json:"views"`
- OwnerID int64 `datastore:"owner_id" json:"-"`
- PublicOwner bool `datastore:"public_owner" json:"-"`
- PreferSubdomain bool `datastore:"prefer_subdomain" json:"-"`
- Domain string `datastore:"domain" json:"domain,omitempty"`
- IsDomainActive bool `datastore:"is_active" json:"-"`
- IsSecure bool `datastore:"is_secure" json:"-"`
- CustomHandle string `datastore:"handle" json:"-"`
- Email string `json:"email,omitempty"`
- URL string `json:"url,omitempty"`
-
- app *app
+ ID int64 `datastore:"id" json:"-"`
+ Alias string `datastore:"alias" schema:"alias" json:"alias"`
+ Title string `datastore:"title" schema:"title" json:"title"`
+ Description string `datastore:"description" schema:"description" json:"description"`
+ Direction string `schema:"dir" json:"dir,omitempty"`
+ Language string `schema:"lang" json:"lang,omitempty"`
+ StyleSheet string `datastore:"style_sheet" schema:"style_sheet" json:"style_sheet"`
+ Script string `datastore:"script" schema:"script" json:"script,omitempty"`
+ Public bool `datastore:"public" json:"public"`
+ Visibility collVisibility `datastore:"private" json:"-"`
+ Format string `datastore:"format" json:"format,omitempty"`
+ Views int64 `json:"views"`
+ OwnerID int64 `datastore:"owner_id" json:"-"`
+ PublicOwner bool `datastore:"public_owner" json:"-"`
+ URL string `json:"url,omitempty"`
+
+ db *datastore
}
CollectionObj struct {
Collection
TotalPosts int `json:"total_posts"`
Owner *User `json:"owner,omitempty"`
Posts *[]PublicPost `json:"posts,omitempty"`
}
+ DisplayCollection struct {
+ *CollectionObj
+ Prefix string
+ IsTopLevel bool
+ CurrentPage int
+ TotalPages int
+ Format *CollectionFormat
+ }
SubmittedCollection struct {
// Data used for updating a given collection
ID int64
OwnerID uint64
// Form helpers
PreferURL string `schema:"prefer_url" json:"prefer_url"`
Privacy int `schema:"privacy" json:"privacy"`
Pass string `schema:"password" json:"password"`
- Federate bool `schema:"federate" json:"federate"`
MathJax bool `schema:"mathjax" json:"mathjax"`
Handle string `schema:"handle" json:"handle"`
// Actual collection values updated in the DB
- Alias *string `schema:"alias" json:"alias"`
- Title *string `schema:"title" json:"title"`
- Description *string `schema:"description" json:"description"`
- StyleSheet *sql.NullString `schema:"style_sheet" json:"style_sheet"`
- Script *sql.NullString `schema:"script" json:"script"`
- Visibility *int `schema:"visibility" json:"public"`
- Format *sql.NullString `schema:"format" json:"format"`
- PreferSubdomain *bool `schema:"prefer_subdomain" json:"prefer_subdomain"`
- Domain *sql.NullString `schema:"domain" json:"domain"`
+ Alias *string `schema:"alias" json:"alias"`
+ Title *string `schema:"title" json:"title"`
+ Description *string `schema:"description" json:"description"`
+ StyleSheet *sql.NullString `schema:"style_sheet" json:"style_sheet"`
+ Script *sql.NullString `schema:"script" json:"script"`
+ Visibility *int `schema:"visibility" json:"public"`
+ Format *sql.NullString `schema:"format" json:"format"`
}
CollectionFormat struct {
Format string
}
+
+ collectionReq struct {
+ // Information about the collection request itself
+ prefix, alias, domain string
+ isCustomDomain bool
+
+ // User-related fields
+ isCollOwner bool
+ }
)
+func (sc *SubmittedCollection) FediverseHandle() string {
+ if sc.Handle == "" {
+ return apCustomHandleDefault
+ }
+ return getSlug(sc.Handle, "")
+}
+
// collVisibility represents the visibility level for the collection.
type collVisibility int
+
+// Visibility levels. Values are bitmasks, stored in the database as
+// decimal numbers. If adding types, append them to this list. If removing,
+// replace the desired visibility with a new value.
+const CollUnlisted collVisibility = 0
+const (
+ CollPublic collVisibility = 1 << iota
+ CollPrivate
+ CollProtected
+)
+
+func (cf *CollectionFormat) Ascending() bool {
+ return cf.Format == "novel"
+}
+func (cf *CollectionFormat) ShowDates() bool {
+ return cf.Format == "blog"
+}
+func (cf *CollectionFormat) PostsPerPage() int {
+ if cf.Format == "novel" {
+ return postsPerPage
+ }
+ return postsPerPage
+}
+
+// Valid returns whether or not a format value is valid.
+func (cf *CollectionFormat) Valid() bool {
+ return cf.Format == "blog" ||
+ cf.Format == "novel" ||
+ cf.Format == "notebook"
+}
+
+// NewFormat creates a new CollectionFormat object from the Collection.
+func (c *Collection) NewFormat() *CollectionFormat {
+ cf := &CollectionFormat{Format: c.Format}
+
+ // Fill in default format
+ if cf.Format == "" {
+ cf.Format = "blog"
+ }
+
+ return cf
+}
+
+func (c *Collection) IsUnlisted() bool {
+ return c.Visibility == 0
+}
+
+func (c *Collection) IsPrivate() bool {
+ return c.Visibility&CollPrivate != 0
+}
+
+func (c *Collection) IsProtected() bool {
+ return c.Visibility&CollProtected != 0
+}
+
+func (c *Collection) IsPublic() bool {
+ return c.Visibility&CollPublic != 0
+}
+
+func (c *Collection) FriendlyVisibility() string {
+ if c.IsPrivate() {
+ return "Private"
+ }
+ if c.IsPublic() {
+ return "Public"
+ }
+ if c.IsProtected() {
+ return "Password-protected"
+ }
+ return "Unlisted"
+}
+
+func (c *Collection) ShowFooterBranding() bool {
+ // TODO: implement this setting
+ return true
+}
+
+// CanonicalURL returns a fully-qualified URL to the collection.
+func (c *Collection) CanonicalURL() string {
+ return c.RedirectingCanonicalURL(false)
+}
+
+func (c *Collection) DisplayCanonicalURL() string {
+ us := c.CanonicalURL()
+ u, err := url.Parse(us)
+ if err != nil {
+ return us
+ }
+ p := u.Path
+ if p == "/" {
+ p = ""
+ }
+ return u.Hostname() + p
+}
+
+func (c *Collection) RedirectingCanonicalURL(isRedir bool) string {
+ if isSingleUser {
+ return hostName + "/"
+ }
+
+ return fmt.Sprintf("%s/%s/", hostName, c.Alias)
+}
+
+// PrevPageURL provides a full URL for the previous page of collection posts,
+// returning a /page/N result for pages >1
+func (c *Collection) PrevPageURL(prefix string, n int, tl bool) string {
+ u := ""
+ if n == 2 {
+ // Previous page is 1; no need for /page/ prefix
+ if prefix == "" {
+ u = "/"
+ }
+ // Else leave off trailing slash
+ } else {
+ u = fmt.Sprintf("/page/%d", n-1)
+ }
+
+ if tl {
+ return u
+ }
+ return "/" + prefix + c.Alias + u
+}
+
+// NextPageURL provides a full URL for the next page of collection posts
+func (c *Collection) NextPageURL(prefix string, n int, tl bool) string {
+ if tl {
+ return fmt.Sprintf("/page/%d", n+1)
+ }
+ return fmt.Sprintf("/%s%s/page/%d", prefix, c.Alias, n+1)
+}
+
+func (c *Collection) DisplayTitle() string {
+ if c.Title != "" {
+ return c.Title
+ }
+ return c.Alias
+}
+
+func (c *Collection) StyleSheetDisplay() template.CSS {
+ return template.CSS(c.StyleSheet)
+}
+
+// ForPublic modifies the Collection for public consumption, such as via
+// the API.
+func (c *Collection) ForPublic() {
+ c.ID = 0
+ c.URL = c.CanonicalURL()
+}
+
+var isLowerLetter = regexp.MustCompile("[a-z]").MatchString
+
+func (c *Collection) PersonObject(ids ...int64) *activitystreams.Person {
+ accountRoot := c.FederatedAccount()
+ p := activitystreams.NewPerson(accountRoot)
+ p.URL = c.CanonicalURL()
+ uname := c.Alias
+ p.PreferredUsername = uname
+ p.Name = c.DisplayTitle()
+ p.Summary = c.Description
+ if p.Name != "" {
+ fl := string(unicode.ToLower([]rune(p.Name)[0]))
+ if isLowerLetter(fl) {
+ p.Icon = activitystreams.Image{
+ Type: "Image",
+ MediaType: "image/png",
+ URL: hostName + "/img/avatars/" + fl + ".png",
+ }
+ }
+ }
+
+ collID := c.ID
+ if len(ids) > 0 {
+ collID = ids[0]
+ }
+ pub, priv := c.db.GetAPActorKeys(collID)
+ if pub != nil {
+ p.AddPubKey(pub)
+ p.SetPrivKey(priv)
+ }
+
+ return p
+}
+
+func (c *Collection) FederatedAPIBase() string {
+ return hostName
+}
+
+func (c *Collection) FederatedAccount() string {
+ accountUser := c.Alias
+ return c.FederatedAPIBase() + "api/collections/" + accountUser
+}
+
+func (c *Collection) RenderMathJax() bool {
+ return c.db.CollectionHasAttribute(c.ID, "render_mathjax")
+}
+
+func newCollection(app *app, w http.ResponseWriter, r *http.Request) error {
+ reqJSON := IsJSON(r.Header.Get("Content-Type"))
+ alias := r.FormValue("alias")
+ title := r.FormValue("title")
+
+ var missingParams, accessToken string
+ var u *User
+ c := struct {
+ Alias string `json:"alias" schema:"alias"`
+ Title string `json:"title" schema:"title"`
+ Web bool `json:"web" schema:"web"`
+ }{}
+ if reqJSON {
+ // Decode JSON request
+ decoder := json.NewDecoder(r.Body)
+ err := decoder.Decode(&c)
+ if err != nil {
+ log.Error("Couldn't parse post update JSON request: %v\n", err)
+ return ErrBadJSON
+ }
+ } else {
+ // TODO: move form parsing to formDecoder
+ c.Alias = alias
+ c.Title = title
+ }
+
+ if c.Alias == "" {
+ if c.Title != "" {
+ // If only a title was given, just use it to generate the alias.
+ c.Alias = getSlug(c.Title, "")
+ } else {
+ missingParams += "`alias` "
+ }
+ }
+ if c.Title == "" {
+ missingParams += "`title` "
+ }
+ if missingParams != "" {
+ return impart.HTTPError{http.StatusBadRequest, fmt.Sprintf("Parameter(s) %srequired.", missingParams)}
+ }
+
+ if reqJSON && !c.Web {
+ accessToken = r.Header.Get("Authorization")
+ if accessToken == "" {
+ return ErrNoAccessToken
+ }
+ } else {
+ u = getUserSession(app, r)
+ if u == nil {
+ return ErrNotLoggedIn
+ }
+ }
+
+ if !author.IsValidUsername(app.cfg, c.Alias) {
+ return impart.HTTPError{http.StatusPreconditionFailed, "Collection alias isn't valid."}
+ }
+
+ var coll *Collection
+ var err error
+ if accessToken != "" {
+ coll, err = app.db.CreateCollectionFromToken(c.Alias, c.Title, accessToken)
+ if err != nil {
+ // TODO: handle this
+ return err
+ }
+ } else {
+ coll, err = app.db.CreateCollection(c.Alias, c.Title, u.ID)
+ if err != nil {
+ // TODO: handle this
+ return err
+ }
+ }
+
+ res := &CollectionObj{Collection: *coll}
+
+ if reqJSON {
+ return impart.WriteSuccess(w, res, http.StatusCreated)
+ }
+ redirectTo := "/me/c/"
+ // TODO: redirect to pad when necessary
+ return impart.HTTPError{http.StatusFound, redirectTo}
+}
+
+func apiCheckCollectionPermissions(app *app, r *http.Request, c *Collection) (int64, error) {
+ accessToken := r.Header.Get("Authorization")
+ var userID int64 = -1
+ if accessToken != "" {
+ userID = app.db.GetUserID(accessToken)
+ }
+ isCollOwner := userID == c.OwnerID
+ if c.IsPrivate() && !isCollOwner {
+ // Collection is private, but user isn't authenticated
+ return -1, ErrCollectionNotFound
+ }
+ if c.IsProtected() {
+ // TODO: check access token
+ return -1, ErrCollectionUnauthorizedRead
+ }
+
+ return userID, nil
+}
+
+// fetchCollection handles the API endpoint for retrieving collection data.
+func fetchCollection(app *app, w http.ResponseWriter, r *http.Request) error {
+ accept := r.Header.Get("Accept")
+ if strings.Contains(accept, "application/activity+json") {
+ return handleFetchCollectionActivities(app, w, r)
+ }
+
+ vars := mux.Vars(r)
+ alias := vars["alias"]
+
+ // TODO: move this logic into a common getCollection function
+ // Get base Collection data
+ c, err := app.db.GetCollection(alias)
+ if err != nil {
+ return err
+ }
+ // Redirect users who aren't requesting JSON
+ reqJSON := IsJSON(r.Header.Get("Content-Type"))
+ if !reqJSON {
+ return impart.HTTPError{http.StatusFound, c.CanonicalURL()}
+ }
+
+ // Check permissions
+ userID, err := apiCheckCollectionPermissions(app, r, c)
+ if err != nil {
+ return err
+ }
+ isCollOwner := userID == c.OwnerID
+
+ // Fetch extra data about the Collection
+ res := &CollectionObj{Collection: *c}
+ if c.PublicOwner {
+ u, err := app.db.GetUserByID(res.OwnerID)
+ if err != nil {
+ // Log the error and just continue
+ log.Error("Error getting user for collection: %v", err)
+ } else {
+ res.Owner = u
+ }
+ }
+ app.db.GetPostsCount(res, isCollOwner)
+ // Strip non-public information
+ res.Collection.ForPublic()
+
+ return impart.WriteSuccess(w, res, http.StatusOK)
+}
+
+// fetchCollectionPosts handles an API endpoint for retrieving a collection's
+// posts.
+func fetchCollectionPosts(app *app, w http.ResponseWriter, r *http.Request) error {
+ vars := mux.Vars(r)
+ alias := vars["alias"]
+
+ c, err := app.db.GetCollection(alias)
+ if err != nil {
+ return err
+ }
+
+ // Check permissions
+ userID, err := apiCheckCollectionPermissions(app, r, c)
+ if err != nil {
+ return err
+ }
+ isCollOwner := userID == c.OwnerID
+
+ // Get page
+ page := 1
+ if p := r.FormValue("page"); p != "" {
+ pInt, _ := strconv.Atoi(p)
+ if pInt > 0 {
+ page = pInt
+ }
+ }
+
+ posts, err := app.db.GetPosts(c, page, isCollOwner)
+ if err != nil {
+ return err
+ }
+ coll := &CollectionObj{Collection: *c, Posts: posts}
+ app.db.GetPostsCount(coll, isCollOwner)
+ // Strip non-public information
+ coll.Collection.ForPublic()
+
+ // Transform post bodies if needed
+ if r.FormValue("body") == "html" {
+ for _, p := range *coll.Posts {
+ p.Content = waposts.ApplyMarkdown([]byte(p.Content))
+ }
+ }
+
+ return impart.WriteSuccess(w, coll, http.StatusOK)
+}
+
+type CollectionPage struct {
+ page.StaticPage
+ *DisplayCollection
+ IsCustomDomain bool
+ IsWelcome bool
+ IsOwner bool
+ CanPin bool
+ Username string
+ Collections *[]Collection
+ PinnedPosts *[]PublicPost
+}
+
+func (c *CollectionObj) ScriptDisplay() template.JS {
+ return template.JS(c.Script)
+}
+
+var jsSourceCommentReg = regexp.MustCompile("(?m)^// src:(.+)$")
+
+func (c *CollectionObj) ExternalScripts() []template.URL {
+ scripts := []template.URL{}
+ if c.Script == "" {
+ return scripts
+ }
+
+ matches := jsSourceCommentReg.FindAllStringSubmatch(c.Script, -1)
+ for _, m := range matches {
+ scripts = append(scripts, template.URL(strings.TrimSpace(m[1])))
+ }
+ return scripts
+}
+
+func (c *CollectionObj) CanShowScript() bool {
+ return false
+}
+
+func processCollectionRequest(cr *collectionReq, vars map[string]string, w http.ResponseWriter, r *http.Request) error {
+ cr.prefix = vars["prefix"]
+ cr.alias = vars["collection"]
+ // Normalize the URL, redirecting user to consistent post URL
+ if cr.alias != strings.ToLower(cr.alias) {
+ return impart.HTTPError{http.StatusMovedPermanently, fmt.Sprintf("/%s/", strings.ToLower(cr.alias))}
+ }
+
+ return nil
+}
+
+// processCollectionPermissions checks the permissions for the given
+// collectionReq, returning a Collection if access is granted; otherwise this
+// renders any necessary collection pages, for example, if requesting a custom
+// domain that doesn't yet have a collection associated, or if a collection
+// requires a password. In either case, this will return nil, nil -- thus both
+// values should ALWAYS be checked to determine whether or not to continue.
+func processCollectionPermissions(app *app, cr *collectionReq, u *User, w http.ResponseWriter, r *http.Request) (*Collection, error) {
+ // Display collection if this is a collection
+ var c *Collection
+ var err error
+ if app.cfg.App.SingleUser {
+ c, err = app.db.GetCollectionByID(1)
+ } else {
+ c, err = app.db.GetCollection(cr.alias)
+ }
+ // TODO: verify we don't reveal the existence of a private collection with redirection
+ if err != nil {
+ if err, ok := err.(impart.HTTPError); ok {
+ if err.Status == http.StatusNotFound {
+ if cr.isCustomDomain {
+ // User is on the site from a custom domain
+ //tErr := pages["404-domain.tmpl"].ExecuteTemplate(w, "base", pageForHost(page.StaticPage{}, r))
+ //if tErr != nil {
+ //log.Error("Unable to render 404-domain page: %v", err)
+ //}
+ return nil, nil
+ }
+ if len(cr.alias) >= minIDLen && len(cr.alias) <= maxIDLen {
+ // Alias is within post ID range, so just be sure this isn't a post
+ if app.db.PostIDExists(cr.alias) {
+ // TODO: use StatusFound for vanity post URLs when we implement them
+ return nil, impart.HTTPError{http.StatusMovedPermanently, "/" + cr.alias}
+ }
+ }
+ // Redirect if necessary
+ newAlias := app.db.GetCollectionRedirect(cr.alias)
+ if newAlias != "" {
+ return nil, impart.HTTPError{http.StatusFound, "/" + newAlias + "/"}
+ }
+ }
+ }
+ return nil, err
+ }
+
+ // Update CollectionRequest to reflect owner status
+ cr.isCollOwner = u != nil && u.ID == c.OwnerID
+
+ // Check permissions
+ if !cr.isCollOwner {
+ if c.IsPrivate() {
+ return nil, ErrCollectionNotFound
+ } else if c.IsProtected() {
+ uname := ""
+ if u != nil {
+ uname = u.Username
+ }
+
+ // See if we've authorized this collection
+ authd := isAuthorizedForCollection(app, c.Alias, r)
+
+ if !authd {
+ p := struct {
+ page.StaticPage
+ *CollectionObj
+ Username string
+ Next string
+ Flashes []template.HTML
+ }{
+ StaticPage: pageForReq(app, r),
+ CollectionObj: &CollectionObj{Collection: *c},
+ Username: uname,
+ Next: r.FormValue("g"),
+ Flashes: []template.HTML{},
+ }
+ // Get owner information
+ p.CollectionObj.Owner, err = app.db.GetUserByID(c.OwnerID)
+ if err != nil {
+ // Log the error and just continue
+ log.Error("Error getting user for collection: %v", err)
+ }
+
+ flashes, _ := getSessionFlashes(app, w, r, nil)
+ for _, flash := range flashes {
+ p.Flashes = append(p.Flashes, template.HTML(flash))
+ }
+ err = templates["password-collection"].ExecuteTemplate(w, "password-collection", p)
+ if err != nil {
+ log.Error("Unable to render password-collection: %v", err)
+ return nil, err
+ }
+ return nil, nil
+ }
+ }
+ }
+ return c, nil
+}
+
+func checkUserForCollection(app *app, cr *collectionReq, r *http.Request, isPostReq bool) (*User, error) {
+ u := getUserSession(app, r)
+ return u, nil
+}
+
+func newDisplayCollection(c *Collection, cr *collectionReq, page int) *DisplayCollection {
+ coll := &DisplayCollection{
+ CollectionObj: &CollectionObj{Collection: *c},
+ CurrentPage: page,
+ Prefix: cr.prefix,
+ IsTopLevel: isSingleUser,
+ Format: c.NewFormat(),
+ }
+ c.db.GetPostsCount(coll.CollectionObj, cr.isCollOwner)
+ return coll
+}
+
+func getCollectionPage(vars map[string]string) int {
+ page := 1
+ var p int
+ p, _ = strconv.Atoi(vars["page"])
+ if p > 0 {
+ page = p
+ }
+ return page
+}
+
+// handleViewCollection displays the requested Collection
+func handleViewCollection(app *app, w http.ResponseWriter, r *http.Request) error {
+ vars := mux.Vars(r)
+ cr := &collectionReq{}
+
+ err := processCollectionRequest(cr, vars, w, r)
+ if err != nil {
+ return err
+ }
+
+ u, err := checkUserForCollection(app, cr, r, false)
+ if err != nil {
+ return err
+ }
+
+ page := getCollectionPage(vars)
+
+ c, err := processCollectionPermissions(app, cr, u, w, r)
+ if c == nil || err != nil {
+ return err
+ }
+
+ // Serve ActivityStreams data now, if requested
+ if strings.Contains(r.Header.Get("Accept"), "application/activity+json") {
+ ac := c.PersonObject()
+ ac.Context = []interface{}{activitystreams.Namespace}
+ return impart.RenderActivityJSON(w, ac, http.StatusOK)
+ }
+
+ // Fetch extra data about the Collection
+ // TODO: refactor out this logic, shared in collection.go:fetchCollection()
+ coll := newDisplayCollection(c, cr, page)
+
+ coll.TotalPages = int(math.Ceil(float64(coll.TotalPosts) / float64(coll.Format.PostsPerPage())))
+ if coll.TotalPages > 0 && page > coll.TotalPages {
+ redirURL := fmt.Sprintf("/page/%d", coll.TotalPages)
+ if !app.cfg.App.SingleUser {
+ redirURL = fmt.Sprintf("/%s%s%s", cr.prefix, coll.Alias, redirURL)
+ }
+ return impart.HTTPError{http.StatusFound, redirURL}
+ }
+
+ coll.Posts, _ = app.db.GetPosts(c, page, cr.isCollOwner)
+
+ // Serve collection
+ displayPage := CollectionPage{
+ DisplayCollection: coll,
+ StaticPage: pageForReq(app, r),
+ IsCustomDomain: cr.isCustomDomain,
+ IsWelcome: r.FormValue("greeting") != "",
+ }
+ var owner *User
+ if u != nil {
+ displayPage.Username = u.Username
+ displayPage.IsOwner = u.ID == coll.OwnerID
+ if displayPage.IsOwner {
+ // Add in needed information for users viewing their own collection
+ owner = u
+ displayPage.CanPin = true
+
+ pubColls, err := app.db.GetPublishableCollections(owner)
+ if err != nil {
+ log.Error("unable to fetch collections: %v", err)
+ }
+ displayPage.Collections = pubColls
+ }
+ }
+ if owner == nil {
+ // Current user doesn't own collection; retrieve owner information
+ owner, err = app.db.GetUserByID(coll.OwnerID)
+ if err != nil {
+ // Log the error and just continue
+ log.Error("Error getting user for collection: %v", err)
+ }
+ }
+ displayPage.Owner = owner
+ coll.Owner = displayPage.Owner
+
+ // Add more data
+ // TODO: fix this mess of collections inside collections
+ displayPage.PinnedPosts, _ = app.db.GetPinnedPosts(coll.CollectionObj)
+
+ err = templates["collection"].ExecuteTemplate(w, "collection", displayPage)
+ if err != nil {
+ log.Error("Unable to render collection index: %v", err)
+ }
+
+ // Update collection view count
+ go func() {
+ // Don't update if owner is viewing the collection.
+ if u != nil && u.ID == coll.OwnerID {
+ return
+ }
+ // Only update for human views
+ if r.Method == "HEAD" || bots.IsBot(r.UserAgent()) {
+ return
+ }
+
+ _, err := app.db.Exec("UPDATE collections SET view_count = view_count + 1 WHERE id = ?", coll.ID)
+ if err != nil {
+ log.Error("Unable to update collections count: %v", err)
+ }
+ }()
+
+ return err
+}
+
+func handleViewCollectionTag(app *app, w http.ResponseWriter, r *http.Request) error {
+ vars := mux.Vars(r)
+ tag := vars["tag"]
+
+ cr := &collectionReq{}
+ err := processCollectionRequest(cr, vars, w, r)
+ if err != nil {
+ return err
+ }
+
+ u, err := checkUserForCollection(app, cr, r, false)
+ if err != nil {
+ return err
+ }
+
+ page := getCollectionPage(vars)
+
+ c, err := processCollectionPermissions(app, cr, u, w, r)
+ if c == nil || err != nil {
+ return err
+ }
+
+ coll := newDisplayCollection(c, cr, page)
+
+ coll.Posts, _ = app.db.GetPostsTagged(c, tag, page, cr.isCollOwner)
+ if coll.Posts != nil && len(*coll.Posts) == 0 {
+ return ErrCollectionPageNotFound
+ }
+
+ // Serve collection
+ displayPage := struct {
+ CollectionPage
+ Tag string
+ }{
+ CollectionPage: CollectionPage{
+ DisplayCollection: coll,
+ StaticPage: pageForReq(app, r),
+ IsCustomDomain: cr.isCustomDomain,
+ },
+ Tag: tag,
+ }
+ var owner *User
+ if u != nil {
+ displayPage.Username = u.Username
+ displayPage.IsOwner = u.ID == coll.OwnerID
+ if displayPage.IsOwner {
+ // Add in needed information for users viewing their own collection
+ owner = u
+ displayPage.CanPin = true
+
+ pubColls, err := app.db.GetPublishableCollections(owner)
+ if err != nil {
+ log.Error("unable to fetch collections: %v", err)
+ }
+ displayPage.Collections = pubColls
+ }
+ }
+ if owner == nil {
+ // Current user doesn't own collection; retrieve owner information
+ owner, err = app.db.GetUserByID(coll.OwnerID)
+ if err != nil {
+ // Log the error and just continue
+ log.Error("Error getting user for collection: %v", err)
+ }
+ }
+ displayPage.Owner = owner
+ coll.Owner = displayPage.Owner
+ // Add more data
+ // TODO: fix this mess of collections inside collections
+ displayPage.PinnedPosts, _ = app.db.GetPinnedPosts(coll.CollectionObj)
+
+ err = templates["collection-tags"].ExecuteTemplate(w, "collection-tags", displayPage)
+ if err != nil {
+ log.Error("Unable to render collection tag page: %v", err)
+ }
+
+ return nil
+}
+
+func handleCollectionPostRedirect(app *app, w http.ResponseWriter, r *http.Request) error {
+ vars := mux.Vars(r)
+ slug := vars["slug"]
+
+ cr := &collectionReq{}
+ err := processCollectionRequest(cr, vars, w, r)
+ if err != nil {
+ return err
+ }
+
+ // Normalize the URL, redirecting user to consistent post URL
+ loc := fmt.Sprintf("/%s", slug)
+ if !app.cfg.App.SingleUser {
+ loc = fmt.Sprintf("/%s/%s", cr.alias, slug)
+ }
+ return impart.HTTPError{http.StatusFound, loc}
+}
+
+func existingCollection(app *app, w http.ResponseWriter, r *http.Request) error {
+ reqJSON := IsJSON(r.Header.Get("Content-Type"))
+ vars := mux.Vars(r)
+ collAlias := vars["alias"]
+ isWeb := r.FormValue("web") == "1"
+
+ var u *User
+ if reqJSON && !isWeb {
+ // Ensure an access token was given
+ accessToken := r.Header.Get("Authorization")
+ u = &User{}
+ u.ID = app.db.GetUserID(accessToken)
+ if u.ID == -1 {
+ return ErrBadAccessToken
+ }
+ } else {
+ u = getUserSession(app, r)
+ if u == nil {
+ return ErrNotLoggedIn
+ }
+ }
+
+ if r.Method == "DELETE" {
+ err := app.db.DeleteCollection(collAlias, u.ID)
+ if err != nil {
+ // TODO: if not HTTPError, report error to admin
+ log.Error("Unable to delete collection: %s", err)
+ return err
+ }
+ addSessionFlash(app, w, r, "Deleted your blog, "+collAlias+".", nil)
+ return impart.HTTPError{Status: http.StatusNoContent}
+ }
+
+ c := SubmittedCollection{OwnerID: uint64(u.ID)}
+ var err error
+
+ if reqJSON {
+ // Decode JSON request
+ decoder := json.NewDecoder(r.Body)
+ err = decoder.Decode(&c)
+ if err != nil {
+ log.Error("Couldn't parse collection update JSON request: %v\n", err)
+ return ErrBadJSON
+ }
+ } else {
+ err = r.ParseForm()
+ if err != nil {
+ log.Error("Couldn't parse collection update form request: %v\n", err)
+ return ErrBadFormData
+ }
+
+ err = app.formDecoder.Decode(&c, r.PostForm)
+ if err != nil {
+ log.Error("Couldn't decode collection update form request: %v\n", err)
+ return ErrBadFormData
+ }
+ }
+
+ err = app.db.UpdateCollection(&c, collAlias)
+ if err != nil {
+ if err, ok := err.(impart.HTTPError); ok {
+ if reqJSON {
+ return err
+ }
+ addSessionFlash(app, w, r, err.Message, nil)
+ return impart.HTTPError{http.StatusFound, "/me/c/" + collAlias}
+ } else {
+ log.Error("Couldn't update collection: %v\n", err)
+ return err
+ }
+ }
+
+ if reqJSON {
+ return impart.WriteSuccess(w, struct {
+ }{}, http.StatusOK)
+ }
+
+ addSessionFlash(app, w, r, "Blog updated!", nil)
+ return impart.HTTPError{http.StatusFound, "/me/c/" + collAlias}
+}
+
+// collectionAliasFromReq takes a request and returns the collection alias
+// if it can be ascertained, as well as whether or not the collection uses a
+// custom domain.
+func collectionAliasFromReq(r *http.Request) string {
+ vars := mux.Vars(r)
+ alias := vars["subdomain"]
+ isSubdomain := alias != ""
+ if !isSubdomain {
+ // Fall back to write.as/{collection} since this isn't a custom domain
+ alias = vars["collection"]
+ }
+ return alias
+}
+
+func handleWebCollectionUnlock(app *app, w http.ResponseWriter, r *http.Request) error {
+ var readReq struct {
+ Alias string `schema:"alias" json:"alias"`
+ Pass string `schema:"password" json:"password"`
+ Next string `schema:"to" json:"to"`
+ }
+
+ // Get params
+ if impart.ReqJSON(r) {
+ decoder := json.NewDecoder(r.Body)
+ err := decoder.Decode(&readReq)
+ if err != nil {
+ log.Error("Couldn't parse readReq JSON request: %v\n", err)
+ return ErrBadJSON
+ }
+ } else {
+ err := r.ParseForm()
+ if err != nil {
+ log.Error("Couldn't parse readReq form request: %v\n", err)
+ return ErrBadFormData
+ }
+
+ err = app.formDecoder.Decode(&readReq, r.PostForm)
+ if err != nil {
+ log.Error("Couldn't decode readReq form request: %v\n", err)
+ return ErrBadFormData
+ }
+ }
+
+ if readReq.Alias == "" {
+ return impart.HTTPError{http.StatusBadRequest, "Need a collection `alias` to read."}
+ }
+ if readReq.Pass == "" {
+ return impart.HTTPError{http.StatusBadRequest, "Please supply a password."}
+ }
+
+ var collHashedPass []byte
+ err := app.db.QueryRow("SELECT password FROM collectionpasswords INNER JOIN collections ON id = collection_id WHERE alias = ?", readReq.Alias).Scan(&collHashedPass)
+ if err != nil {
+ if err == sql.ErrNoRows {
+ log.Error("No collectionpassword found when trying to read collection %s", readReq.Alias)
+ return impart.HTTPError{http.StatusInternalServerError, "Something went very wrong. The humans have been alerted."}
+ }
+ return err
+ }
+
+ if !auth.Authenticated(collHashedPass, []byte(readReq.Pass)) {
+ return impart.HTTPError{http.StatusUnauthorized, "Incorrect password."}
+ }
+
+ // Success; set cookie
+ session, err := app.sessionStore.Get(r, blogPassCookieName)
+ if err == nil {
+ session.Values[readReq.Alias] = true
+ err = session.Save(r, w)
+ if err != nil {
+ log.Error("Didn't save unlocked blog '%s': %v", readReq.Alias, err)
+ }
+ }
+
+ next := "/" + readReq.Next
+ if !app.cfg.App.SingleUser {
+ next = "/" + readReq.Alias + next
+ }
+ return impart.HTTPError{http.StatusFound, next}
+}
+
+func isAuthorizedForCollection(app *app, alias string, r *http.Request) bool {
+ authd := false
+ session, err := app.sessionStore.Get(r, blogPassCookieName)
+ if err == nil {
+ _, authd = session.Values[alias]
+ }
+ return authd
+}
diff --git a/export.go b/export.go
new file mode 100644
index 0000000..56b5676
--- /dev/null
+++ b/export.go
@@ -0,0 +1,114 @@
+package writefreely
+
+import (
+ "archive/zip"
+ "bytes"
+ "encoding/csv"
+ "github.com/writeas/web-core/log"
+ "strings"
+ "time"
+)
+
+func exportPostsCSV(u *User, posts *[]PublicPost) []byte {
+ var b bytes.Buffer
+
+ r := [][]string{
+ {"id", "slug", "blog", "url", "created", "title", "body"},
+ }
+ for _, p := range *posts {
+ var blog string
+ if p.Collection != nil {
+ blog = p.Collection.Alias
+ }
+ f := []string{p.ID, p.Slug.String, blog, p.CanonicalURL(), p.Created8601(), p.Title.String, strings.Replace(p.Content, "\n", "\\n", -1)}
+ r = append(r, f)
+ }
+
+ w := csv.NewWriter(&b)
+ w.WriteAll(r) // calls Flush internally
+ if err := w.Error(); err != nil {
+ log.Info("error writing csv:", err)
+ }
+
+ return b.Bytes()
+}
+
+type exportedTxt struct {
+ Name, Body string
+ Mod time.Time
+}
+
+func exportPostsZip(u *User, posts *[]PublicPost) []byte {
+ // Create a buffer to write our archive to.
+ b := new(bytes.Buffer)
+
+ // Create a new zip archive.
+ w := zip.NewWriter(b)
+
+ // Add some files to the archive.
+ var filename string
+ files := []exportedTxt{}
+ for _, p := range *posts {
+ filename = ""
+ if p.Collection != nil {
+ filename += p.Collection.Alias + "/"
+ }
+ if p.Slug.String != "" {
+ filename += p.Slug.String + "_"
+ }
+ filename += p.ID + ".txt"
+ files = append(files, exportedTxt{filename, p.Content, p.Created})
+ }
+
+ for _, file := range files {
+ head := &zip.FileHeader{Name: file.Name}
+ head.SetModTime(file.Mod)
+ f, err := w.CreateHeader(head)
+ if err != nil {
+ log.Error("export zip header: %v", err)
+ }
+ _, err = f.Write([]byte(file.Body))
+ if err != nil {
+ log.Error("export zip write: %v", err)
+ }
+ }
+
+ // Make sure to check the error on Close.
+ err := w.Close()
+ if err != nil {
+ log.Error("export zip close: %v", err)
+ }
+
+ return b.Bytes()
+}
+
+func compileFullExport(app *app, u *User) *ExportUser {
+ exportUser := &ExportUser{
+ User: u,
+ }
+
+ colls, err := app.db.GetCollections(u)
+ if err != nil {
+ log.Error("unable to fetch collections: %v", err)
+ }
+
+ posts, err := app.db.GetAnonymousPosts(u)
+ if err != nil {
+ log.Error("unable to fetch anon posts: %v", err)
+ }
+ exportUser.AnonymousPosts = *posts
+
+ var collObjs []CollectionObj
+ for _, c := range *colls {
+ co := &CollectionObj{Collection: c}
+ co.Posts, err = app.db.GetPosts(&c, 0, true)
+ if err != nil {
+ log.Error("unable to get collection posts: %v", err)
+ }
+ app.db.GetPostsCount(co, true)
+ collObjs = append(collObjs, *co)
+ }
+ exportUser.Collections = &collObjs
+
+ return exportUser
+}
diff --git a/feed.go b/feed.go
new file mode 100644
index 0000000..906c06f
--- /dev/null
+++ b/feed.go
@@ -0,0 +1,100 @@
+package writefreely
+
+import (
+ "fmt"
+ . "github.com/gorilla/feeds"
+ "github.com/gorilla/mux"
+ stripmd "github.com/writeas/go-strip-markdown"
+ "github.com/writeas/web-core/log"
+ "net/http"
+ "time"
+)
+
+func ViewFeed(app *app, w http.ResponseWriter, req *http.Request) error {
+ alias := collectionAliasFromReq(req)
+
+ // Display collection if this is a collection
+ var c *Collection
+ var err error
+ if app.cfg.App.SingleUser {
+ c, err = app.db.GetCollection(alias)
+ } else {
+ c, err = app.db.GetCollectionByID(1)
+ }
+ if err != nil {
+ return nil
+ }
+
+ if c.IsPrivate() || c.IsProtected() {
+ return ErrCollectionNotFound
+ }
+
+ // Fetch extra data about the Collection
+ // TODO: refactor out this logic, shared in collection.go:fetchCollection()
+ coll := &DisplayCollection{CollectionObj: &CollectionObj{Collection: *c}}
+ if c.PublicOwner {
+ u, err := app.db.GetUserByID(coll.OwnerID)
+ if err != nil {
+ // Log the error and just continue
+ log.Error("Error getting user for collection: %v", err)
+ } else {
+ coll.Owner = u
+ }
+ }
+
+ tag := mux.Vars(req)["tag"]
+ if tag != "" {
+ coll.Posts, _ = app.db.GetPostsTagged(c, tag, 1, false)
+ } else {
+ coll.Posts, _ = app.db.GetPosts(c, 1, false)
+ }
+
+ author := ""
+ if coll.Owner != nil {
+ author = coll.Owner.Username
+ }
+
+ collectionTitle := coll.DisplayTitle()
+ if tag != "" {
+ collectionTitle = tag + " &mdash; " + collectionTitle
+ }
+
+ baseUrl := coll.CanonicalURL()
+ basePermalinkUrl := baseUrl
+ siteURL := baseUrl
+ if tag != "" {
+ siteURL += "tag:" + tag
+ }
+
+ feed := &Feed{
+ Title: collectionTitle,
+ Link: &Link{Href: siteURL},
+ Description: coll.Description,
+ Author: &Author{author, ""},
+ Created: time.Now(),
+ }
+
+ var title, permalink string
+ for _, p := range *coll.Posts {
+ title = p.PlainDisplayTitle()
+ permalink = fmt.Sprintf("%s%s", baseUrl, p.Slug.String)
+ feed.Items = append(feed.Items, &Item{
+ Id: fmt.Sprintf("%s%s", basePermalinkUrl, p.Slug.String),
+ Title: title,
+ Link: &Link{Href: permalink},
+ Description: "<![CDATA[" + stripmd.Strip(p.Content) + "]]>",
+ Content: applyMarkdown([]byte(p.Content)),
+ Author: &Author{author, ""},
+ Created: p.Created,
+ Updated: p.Updated,
+ })
+ }
+
+ rss, err := feed.ToRss()
+ if err != nil {
+ return err
+ }
+
+ fmt.Fprint(w, rss)
+ return nil
+}
diff --git a/request.go b/request.go
new file mode 100644
index 0000000..3b72b44
--- /dev/null
+++ b/request.go
@@ -0,0 +1,8 @@
+package writefreely
+
+import "mime"
+
+func IsJSON(h string) bool {
+ ct, _, _ := mime.ParseMediaType(h)
+ return ct == "application/json"
+}
diff --git a/routes.go b/routes.go
index 92462b6..fafc4c1 100644
--- a/routes.go
+++ b/routes.go
@@ -1,64 +1,123 @@
package writefreely
import (
"github.com/gorilla/mux"
"github.com/writeas/go-nodeinfo"
"github.com/writeas/web-core/log"
"github.com/writeas/writefreely/config"
"net/http"
"strings"
)
func initRoutes(handler *Handler, r *mux.Router, cfg *config.Config, db *datastore) {
hostSubroute := cfg.App.Host[strings.Index(cfg.App.Host, "://")+3:]
if cfg.App.SingleUser {
hostSubroute = "{domain}"
} else {
if strings.HasPrefix(hostSubroute, "localhost") {
hostSubroute = "localhost"
}
}
if 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.Host(hostSubroute).Subrouter()
// Federation endpoints
// nodeinfo
niCfg := nodeInfoConfig(cfg)
ni := nodeinfo.NewService(*niCfg, nodeInfoResolver{cfg, db})
write.HandleFunc(nodeinfo.NodeInfoPath, handler.LogHandlerFunc(http.HandlerFunc(ni.NodeInfoDiscover)))
write.HandleFunc(niCfg.InfoURL, handler.LogHandlerFunc(http.HandlerFunc(ni.NodeInfo)))
+ // 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("/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")
+
+ // 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.All(fetchCollection)).Methods("GET")
+ apiColls.HandleFunc("/{alias:[0-9a-zA-Z\\-]+}", handler.All(existingCollection)).Methods("POST", "DELETE")
+ apiColls.HandleFunc("/{alias}/posts", handler.All(fetchCollectionPosts)).Methods("GET")
+ apiColls.HandleFunc("/{alias}/posts", handler.All(newPost)).Methods("POST")
+ apiColls.HandleFunc("/{alias}/posts/{post}", handler.All(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.All(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")
+
// 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.All(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.All(fetchPostProperty)).Methods("GET")
posts.HandleFunc("/claim", handler.All(addPost)).Methods("POST")
posts.HandleFunc("/disperse", handler.All(dispersePost)).Methods("POST")
if cfg.App.SingleUser {
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("/{action}/edit", handler.Web(handleViewPad, UserLevelOptional)).Methods("GET")
write.HandleFunc("/{action}/meta", handler.Web(handleViewMeta, UserLevelOptional)).Methods("GET")
// Collections
if cfg.App.SingleUser {
+ RouteCollections(handler, write.PathPrefix("/").Subrouter())
} else {
+ write.HandleFunc("/{prefix:[@~$!\\-+]}{collection}", handler.Web(handleViewCollection, UserLevelOptional))
+ write.HandleFunc("/{collection}/", handler.Web(handleViewCollection, UserLevelOptional))
+ RouteCollections(handler, write.PathPrefix("/{prefix:[@~$!\\-+]?}{collection}").Subrouter())
// Posts
write.HandleFunc("/{post}", handler.Web(handleViewPost, UserLevelOptional))
}
write.HandleFunc("/", handler.Web(handleViewHome, UserLevelOptional))
}
+
+func RouteCollections(handler *Handler, r *mux.Router) {
+ r.HandleFunc("/page/{page:[0-9]+}", handler.Web(handleViewCollection, UserLevelOptional))
+ r.HandleFunc("/tag:{tag}", handler.Web(handleViewCollectionTag, UserLevelOptional))
+ r.HandleFunc("/tag:{tag}/feed/", handler.Web(ViewFeed, UserLevelOptional))
+ r.HandleFunc("/tags/{tag}", handler.Web(handleViewCollectionTag, UserLevelOptional))
+ r.HandleFunc("/sitemap.xml", handler.All(handleViewSitemap))
+ r.HandleFunc("/feed/", handler.All(ViewFeed))
+ r.HandleFunc("/{slug}", handler.Web(viewCollectionPost, UserLevelOptional))
+ r.HandleFunc("/{slug}/edit", handler.Web(handleViewPad, UserLevelUser))
+ r.HandleFunc("/{slug}/edit/meta", handler.Web(handleViewMeta, UserLevelUser))
+ r.HandleFunc("/{slug}/", handler.Web(handleCollectionPostRedirect, UserLevelOptional)).Methods("GET")
+}
diff --git a/session.go b/session.go
index 931b87b..6e8e4fd 100644
--- a/session.go
+++ b/session.go
@@ -1,126 +1,128 @@
package writefreely
import (
"encoding/gob"
"github.com/gorilla/sessions"
"github.com/writeas/web-core/log"
"net/http"
"strings"
)
const (
day = 86400
sessionLength = 180 * day
cookieName = "wfu"
cookieUserVal = "u"
+
+ blogPassCookieName = "ub"
)
// initSession creates the cookie store. It depends on the keychain already
// being loaded.
func initSession(app *app) *sessions.CookieStore {
// Register complex data types we'll be storing in cookies
gob.Register(&User{})
// Create the cookie store
store := sessions.NewCookieStore(app.keys.cookieAuthKey, app.keys.cookieKey)
store.Options = &sessions.Options{
Path: "/",
MaxAge: sessionLength,
HttpOnly: true,
Secure: strings.HasPrefix(app.cfg.App.Host, "https://"),
}
return store
}
func getSessionFlashes(app *app, w http.ResponseWriter, r *http.Request, session *sessions.Session) ([]string, error) {
var err error
if session == nil {
session, err = app.sessionStore.Get(r, cookieName)
if err != nil {
return nil, err
}
}
f := []string{}
if flashes := session.Flashes(); len(flashes) > 0 {
for _, flash := range flashes {
if str, ok := flash.(string); ok {
f = append(f, str)
}
}
}
saveUserSession(app, r, w)
return f, nil
}
func addSessionFlash(app *app, w http.ResponseWriter, r *http.Request, m string, session *sessions.Session) error {
var err error
if session == nil {
session, err = app.sessionStore.Get(r, cookieName)
}
if err != nil {
log.Error("Unable to add flash '%s': %v", m, err)
return err
}
session.AddFlash(m)
saveUserSession(app, r, w)
return nil
}
func getUserAndSession(app *app, r *http.Request) (*User, *sessions.Session) {
session, err := app.sessionStore.Get(r, cookieName)
if err == nil {
// Got the currently logged-in user
val := session.Values[cookieUserVal]
var u = &User{}
var ok bool
if u, ok = val.(*User); ok {
return u, session
}
}
return nil, nil
}
func getUserSession(app *app, r *http.Request) *User {
u, _ := getUserAndSession(app, r)
return u
}
func saveUserSession(app *app, r *http.Request, w http.ResponseWriter) error {
session, err := app.sessionStore.Get(r, cookieName)
if err != nil {
return ErrInternalCookieSession
}
// Extend the session
session.Options.MaxAge = int(sessionLength)
// Remove any information that accidentally got added
// FIXME: find where Plan information is getting saved to cookie.
val := session.Values[cookieUserVal]
var u = &User{}
var ok bool
if u, ok = val.(*User); ok {
session.Values[cookieUserVal] = u.Cookie()
}
err = session.Save(r, w)
if err != nil {
log.Error("Couldn't saveUserSession: %v", err)
}
return err
}
func getFullUserSession(app *app, r *http.Request) *User {
u := getUserSession(app, r)
if u == nil {
return nil
}
u, _ = app.db.GetUserByID(u.ID)
return u
}
diff --git a/sitemap.go b/sitemap.go
new file mode 100644
index 0000000..0712bf6
--- /dev/null
+++ b/sitemap.go
@@ -0,0 +1,94 @@
+package writefreely
+
+import (
+ "fmt"
+ "github.com/gorilla/mux"
+ "github.com/ikeikeikeike/go-sitemap-generator/stm"
+ "github.com/writeas/web-core/log"
+ "net/http"
+ "time"
+)
+
+func buildSitemap(host, alias string) *stm.Sitemap {
+ sm := stm.NewSitemap()
+ sm.SetDefaultHost(host)
+ if alias != "/" {
+ sm.SetSitemapsPath(alias)
+ }
+
+ sm.Create()
+
+ // Note: Do not call `sm.Finalize()` because it flushes
+ // the underlying datastructure from memory to disk.
+
+ return sm
+}
+
+func handleViewSitemap(app *app, w http.ResponseWriter, r *http.Request) error {
+ vars := mux.Vars(r)
+
+ // Determine canonical blog URL
+ alias := vars["collection"]
+ subdomain := vars["subdomain"]
+ isSubdomain := subdomain != ""
+ if isSubdomain {
+ alias = subdomain
+ }
+
+ host := fmt.Sprintf("%s/%s/", app.cfg.App.Host, alias)
+ var c *Collection
+ var err error
+ pre := "/"
+ if app.cfg.App.SingleUser {
+ c, err = app.db.GetCollectionByID(1)
+ } else {
+ c, err = app.db.GetCollection(alias)
+ }
+ if err != nil {
+ return err
+ }
+
+ if !isSubdomain {
+ pre += alias + "/"
+ }
+ host = c.CanonicalURL()
+
+ sm := buildSitemap(host, pre)
+ posts, err := app.db.GetPosts(c, 0, false)
+ if err != nil {
+ log.Error("Error getting posts: %v", err)
+ return err
+ }
+ lastSiteMod := time.Now()
+ for i, p := range *posts {
+ if i == 0 {
+ lastSiteMod = p.Updated
+ }
+ u := stm.URL{
+ "loc": p.Slug.String,
+ "changefreq": "weekly",
+ "mobile": true,
+ "lastmod": p.Updated,
+ }
+ if len(p.Images) > 0 {
+ imgs := []stm.URL{}
+ for _, i := range p.Images {
+ imgs = append(imgs, stm.URL{"loc": i, "title": ""})
+ }
+ u["image"] = imgs
+ }
+ sm.Add(u)
+ }
+
+ // Add top URL
+ sm.Add(stm.URL{
+ "loc": pre,
+ "changefreq": "daily",
+ "priority": "1.0",
+ "lastmod": lastSiteMod,
+ })
+
+ w.Write(sm.XMLContent())
+
+ return nil
+}
diff --git a/templates/collection-post.tmpl b/templates/collection-post.tmpl
index 289ee60..e581ad9 100644
--- a/templates/collection-post.tmpl
+++ b/templates/collection-post.tmpl
@@ -1,135 +1,134 @@
{{define "post"}}<!DOCTYPE HTML>
<html {{if .Language.Valid}}lang="{{.Language.String}}"{{end}} dir="{{.Direction}}">
<head prefix="og: http://ogp.me/ns# article: http://ogp.me/ns/article#">
<meta charset="utf-8">
<title>{{.PlainDisplayTitle}} &mdash; {{.Collection.DisplayTitle}}</title>
<link rel="stylesheet" type="text/css" href="/css/write.css" />
<link rel="shortcut icon" href="/favicon.ico" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link rel="canonical" href="{{.CanonicalURL}}" />
<meta name="generator" content="Write Freely">
<meta name="title" content="{{.PlainDisplayTitle}} &mdash; {{if .Collection.Title}}{{.Collection.Title}}{{else}}{{.Collection.Alias}}{{end}}">
<meta name="description" content="{{.Summary}}">
{{if gt .Views 1}}<meta name="twitter:label1" value="Views">
<meta name="twitter:data1" value="{{largeNumFmt .Views}}">{{end}}
<meta name="author" content="{{.Collection.Title}}" />
<meta itemprop="description" content="{{.Summary}}">
<meta itemprop="datePublished" content="{{.CreatedDate}}" />
<meta name="twitter:card" content="summary">
<meta name="twitter:description" content="{{.Summary}}">
<meta name="twitter:title" content="{{.PlainDisplayTitle}} &mdash; {{if .Collection.Title}}{{.Collection.Title}}{{else}}{{.Collection.Alias}}{{end}}">
{{if gt (len .Images) 0}}<meta name="twitter:image" content="{{index .Images 0}}">{{else}}<meta name="twitter:image" content="https://write.as/img/w-sq-light.png">{{end}}
<meta property="og:title" content="{{.PlainDisplayTitle}}" />
<meta property="og:description" content="{{.Summary}}" />
<meta property="og:site_name" content="{{.Collection.DisplayTitle}}" />
<meta property="og:type" content="article" />
<meta property="og:url" content="{{.CanonicalURL}}" />
<meta property="og:updated_time" content="{{.Created8601}}" />
{{range .Images}}<meta property="og:image" content="{{.}}" />{{else}}<meta property="og:image" content="https://write.as/img/w-sq-light.png">{{end}}
<meta property="article:published_time" content="{{.Created8601}}">
{{if .Collection.StyleSheet}}<style type="text/css">{{.Collection.StyleSheetDisplay}}</style>{{end}}
{{if .Collection.RenderMathJax}}
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
extensions: ["tex2jax.js"],
jax: ["input/TeX", "output/HTML-CSS"],
tex2jax: {
inlineMath: [ ['$','$'], ["\\(","\\)"] ],
displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
processEscapes: true
},
"HTML-CSS": { fonts: ["TeX"] }
});
</script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML" async></script>{{end}}
</head>
<body id="post">
<div id="overlay"></div>
<header>
<h1 dir="{{.Direction}}" id="blog-title"><a rel="author" href="{{if .IsTopLevel}}/{{else}}/{{.Collection.Alias}}/{{end}}" class="h-card p-author">{{.Collection.DisplayTitle}}</a></h1>
<nav>
{{if .PinnedPosts}}
{{range .PinnedPosts}}<a class="pinned{{if eq .Slug.String $.Slug.String}} selected{{end}}" href="{{if $.IsOwner}}/{{$.Collection.Alias}}/{{.Slug.String}}{{else}}{{.CanonicalURL}}{{end}}">{{.PlainDisplayTitle}}</a>{{end}}
{{end}}
{{ if .IsOwner }}<span class="views" dir="ltr"><strong>{{largeNumFmt .Views}}</strong> {{pluralize "view" "views" .Views}}</span>
<a class="xtra-feature" href="/{{.Collection.Alias}}/{{.Slug.String}}/edit" dir="{{.Direction}}">Edit</a>
{{if .IsPinned}}<a class="xtra-feature unpin" href="/{{.Collection.Alias}}/{{.Slug.String}}/unpin" dir="{{.Direction}}" onclick="unpinPost(event, '{{.ID}}')">Unpin</a>{{end}}
{{ end }}
</nav>
</header>
<article id="post-body" class="{{.Font}} h-entry">{{if .IsScheduled}}<p class="badge">Scheduled</p>{{end}}{{if .Title.String}}<h2 id="title" class="p-name">{{.FormattedDisplayTitle}}</h2>{{end}}<div class="e-content">{{.HTMLContent}}</div></article>
{{ if .Collection.ShowFooterBranding }}
<footer dir="ltr"><hr><nav><p style="font-size: 0.9em">{{localhtml "published with write.as" .Language.String}}</p></nav></footer>
{{ end }}
</body>
{{if .Collection.CanShowScript}}
{{range .Collection.ExternalScripts}}<script type="text/javascript" src="{{.}}" async></script>{{end}}
{{if .Collection.Script}}<script type="text/javascript">{{.Collection.ScriptDisplay}}</script>{{end}}
{{end}}
<script type="text/javascript">
var pinning = false;
function unpinPost(e, postID) {
e.preventDefault();
if (pinning) {
return;
}
pinning = true;
var $header = document.getElementsByTagName('header')[0];
var callback = function() {
// Hide current page
var $pinnedNavLink = $header.getElementsByTagName('nav')[0].querySelector('.pinned.selected');
$pinnedNavLink.style.display = 'none';
- try { _paq.push(['trackEvent', 'Post', 'unpin', 'post']); } catch(e) {}
};
var $pinBtn = $header.getElementsByClassName('unpin')[0];
$pinBtn.innerHTML = '...';
var http = new XMLHttpRequest();
var url = "/api/collections/{{.Collection.Alias}}/unpin";
var params = [ { "id": postID } ];
http.open("POST", url, true);
http.setRequestHeader("Content-type", "application/json");
http.onreadystatechange = function() {
if (http.readyState == 4) {
pinning = false;
if (http.status == 200) {
callback();
$pinBtn.style.display = 'none';
$pinBtn.innerHTML = 'Pin';
} else if (http.status == 409) {
$pinBtn.innerHTML = 'Unpin';
} else {
$pinBtn.innerHTML = 'Unpin';
alert("Failed to unpin." + (http.status>=500?" Please try again.":""));
}
}
}
http.send(JSON.stringify(params));
};
try { // Fonts
WebFontConfig = {
custom: { families: [ 'Lora:400,700:latin', 'Open+Sans:400,700:latin' ], urls: [ '/css/fonts.css' ] }
};
(function() {
var wf = document.createElement('script');
wf.src = '/js/webfont.js';
wf.type = 'text/javascript';
wf.async = 'true';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(wf, s);
})();
} catch (e) { /* ¯\_(ツ)_/¯ */ }
</script>
</html>{{end}}
diff --git a/templates/edit-meta.tmpl b/templates/edit-meta.tmpl
index 026dd49..57eada5 100644
--- a/templates/edit-meta.tmpl
+++ b/templates/edit-meta.tmpl
@@ -1,371 +1,370 @@
{{define "edit-meta"}}<!DOCTYPE HTML>
<html>
<head>
<title>Edit metadata: {{if .Post.Title}}{{.Post.Title}}{{else}}{{.Post.Id}}{{end}} &mdash; {{.SiteName}}</title>
<link rel="stylesheet" type="text/css" href="/css/write.css" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<style type="text/css">
dt {
width: 8em;
}
.error {
display: none;
}
.mono {
font-style: normal;
}
#set-now {
font-style: italic;
margin-left: 0.25rem;
}
.content-container h2 a {
font-size: .6em;
font-weight: normal;
margin-left: 1em;
}
.content-container h2 a:link, .content-container h2 a:visited {
color: blue;
}
.content-container h2 a:hover {
text-decoration: underline;
}
</style>
</head>
<body id="pad-sub" class="light">
<header id="tools">
<div id="clip">
<h1>{{if .User}}<a href="/me/posts/" style="font-weight:normal"><span style="font-size:1.2em;font-weight:bold;margin-right:0.5em">w</span></a>{{else}}<a href="/">w<span class="if-room">rite.as</span></a>{{end}}
</h1>
<nav id="target" class=""><ul>
<li>{{if .EditCollection}}<a href="{{.EditCollection.CanonicalURL}}">{{.EditCollection.Title}}</a>{{else}}<a>Anonymous</a>{{end}}</li>
</ul></nav>
</div>
<div id="belt">
<div class="tool if-room"><a href="{{if .EditCollection}}{{.EditCollection.CanonicalURL}}{{.Post.Slug}}/edit{{else}}/{{.Post.Id}}/edit{{end}}" title="Edit post" id="edit"><img class="ic-24dp" src="/img/ic_edit_dark@2x.png" /></a></div>
<div class="tool if-room room-2"><a href="#theme" title="Toggle theme" id="toggle-theme"><img class="ic-24dp" src="/img/ic_brightness_dark@2x.png" /></a></div>
<div class="tool if-room room-1"><a href="{{if not .User}}/pad/posts{{else}}/me/posts/{{end}}" title="View posts" id="view-posts"><img class="ic-24dp" src="/img/ic_list_dark@2x.png" /></a></div>
</div>
</header>
<div class="content-container tight">
<form action="/api/{{if .EditCollection}}collections/{{.EditCollection.Alias}}/{{end}}posts/{{.Post.Id}}" method="post" onsubmit="return updateMeta()">
<h2>Edit metadata: {{if .Post.Title}}{{.Post.Title}}{{else}}{{.Post.Id}}{{end}} <a href="/{{if .EditCollection}}{{.EditCollection.Alias}}/{{.Post.Slug}}{{else}}{{.Post.Id}}{{end}}">view post</a></h2>
{{if .Flashes}}<ul class="errors">
{{range .Flashes}}<li class="urgent">{{.}}</li>{{end}}
</ul>{{end}}
<dl class="dl-horizontal">
{{if .EditCollection}}
<dt><label for="slug">Slug</label></dt>
<dd><input type="text" id="slug" name="slug" value="{{.Post.Slug}}" /></dd>
{{end}}
<dt><label for="lang">Language</label></dt>
<dd>
<select name="lang" id="lang" dir="auto">
<option value=""></option>
<option value="ab"{{if eq "ab" .Post.Language.String}} selected="selected"{{end}}>аҧсуа бызшәа, аҧсшәа</option>
<option value="aa"{{if eq "aa" .Post.Language.String}} selected="selected"{{end}}>Afaraf</option>
<option value="af"{{if eq "af" .Post.Language.String}} selected="selected"{{end}}>Afrikaans</option>
<option value="ak"{{if eq "ak" .Post.Language.String}} selected="selected"{{end}}>Akan</option>
<option value="sq"{{if eq "sq" .Post.Language.String}} selected="selected"{{end}}>Shqip</option>
<option value="am"{{if eq "am" .Post.Language.String}} selected="selected"{{end}}>አማርኛ</option>
<option dir="rtl" value="ar"{{if eq "ar" .Post.Language.String}} selected="selected"{{end}}>العربية</option>
<option value="an"{{if eq "an" .Post.Language.String}} selected="selected"{{end}}>aragonés</option>
<option value="hy"{{if eq "hy" .Post.Language.String}} selected="selected"{{end}}>Հայերեն</option>
<option value="as"{{if eq "as" .Post.Language.String}} selected="selected"{{end}}>অসমীয়া</option>
<option value="av"{{if eq "av" .Post.Language.String}} selected="selected"{{end}}>авар мацӀ, магӀарул мацӀ</option>
<option value="ae"{{if eq "ae" .Post.Language.String}} selected="selected"{{end}}>avesta</option>
<option value="ay"{{if eq "ay" .Post.Language.String}} selected="selected"{{end}}>aymar aru</option>
<option value="az"{{if eq "az" .Post.Language.String}} selected="selected"{{end}}>azərbaycan dili</option>
<option value="bm"{{if eq "bm" .Post.Language.String}} selected="selected"{{end}}>bamanankan</option>
<option value="ba"{{if eq "ba" .Post.Language.String}} selected="selected"{{end}}>башҡорт теле</option>
<option value="eu"{{if eq "eu" .Post.Language.String}} selected="selected"{{end}}>euskara, euskera</option>
<option value="be"{{if eq "be" .Post.Language.String}} selected="selected"{{end}}>беларуская мова</option>
<option value="bn"{{if eq "bn" .Post.Language.String}} selected="selected"{{end}}>বাংলা</option>
<option value="bh"{{if eq "bh" .Post.Language.String}} selected="selected"{{end}}>भोजपुरी</option>
<option value="bi"{{if eq "bi" .Post.Language.String}} selected="selected"{{end}}>Bislama</option>
<option value="bs"{{if eq "bs" .Post.Language.String}} selected="selected"{{end}}>bosanski jezik</option>
<option value="br"{{if eq "br" .Post.Language.String}} selected="selected"{{end}}>brezhoneg</option>
<option value="bg"{{if eq "bg" .Post.Language.String}} selected="selected"{{end}}>български език</option>
<option value="my"{{if eq "my" .Post.Language.String}} selected="selected"{{end}}>ဗမာစာ</option>
<option value="ca"{{if eq "ca" .Post.Language.String}} selected="selected"{{end}}>català</option>
<option value="ch"{{if eq "ch" .Post.Language.String}} selected="selected"{{end}}>Chamoru</option>
<option value="ce"{{if eq "ce" .Post.Language.String}} selected="selected"{{end}}>нохчийн мотт</option>
<option value="ny"{{if eq "ny" .Post.Language.String}} selected="selected"{{end}}>chiCheŵa, chinyanja</option>
<option value="zh"{{if eq "zh" .Post.Language.String}} selected="selected"{{end}}>中文 (Zhōngwén), 汉语, 漢語</option>
<option value="cv"{{if eq "cv" .Post.Language.String}} selected="selected"{{end}}>чӑваш чӗлхи</option>
<option value="kw"{{if eq "kw" .Post.Language.String}} selected="selected"{{end}}>Kernewek</option>
<option value="co"{{if eq "co" .Post.Language.String}} selected="selected"{{end}}>corsu, lingua corsa</option>
<option value="cr"{{if eq "cr" .Post.Language.String}} selected="selected"{{end}}>ᓀᐦᐃᔭᐍᐏᐣ</option>
<option value="hr"{{if eq "hr" .Post.Language.String}} selected="selected"{{end}}>hrvatski jezik</option>
<option value="cs"{{if eq "cs" .Post.Language.String}} selected="selected"{{end}}>čeština, český jazyk</option>
<option value="da"{{if eq "da" .Post.Language.String}} selected="selected"{{end}}>dansk</option>
<option dir="rtl" value="dv"{{if eq "dv" .Post.Language.String}} selected="selected"{{end}}>ދިވެހި</option>
<option value="nl"{{if eq "nl" .Post.Language.String}} selected="selected"{{end}}>Nederlands, Vlaams</option>
<option value="dz"{{if eq "dz" .Post.Language.String}} selected="selected"{{end}}>རྫོང་ཁ</option>
<option value="en"{{if eq "en" .Post.Language.String}} selected="selected"{{end}}>English</option>
<option value="eo"{{if eq "eo" .Post.Language.String}} selected="selected"{{end}}>Esperanto</option>
<option value="et"{{if eq "et" .Post.Language.String}} selected="selected"{{end}}>eesti, eesti keel</option>
<option value="ee"{{if eq "ee" .Post.Language.String}} selected="selected"{{end}}>Eʋegbe</option>
<option value="fo"{{if eq "fo" .Post.Language.String}} selected="selected"{{end}}>føroyskt</option>
<option value="fj"{{if eq "fj" .Post.Language.String}} selected="selected"{{end}}>vosa Vakaviti</option>
<option value="fi"{{if eq "fi" .Post.Language.String}} selected="selected"{{end}}>suomi, suomen kieli</option>
<option value="fr"{{if eq "fr" .Post.Language.String}} selected="selected"{{end}}>français, langue française</option>
<option value="ff"{{if eq "ff" .Post.Language.String}} selected="selected"{{end}}>Fulfulde, Pulaar, Pular</option>
<option value="gl"{{if eq "gl" .Post.Language.String}} selected="selected"{{end}}>Galego</option>
<option value="ka"{{if eq "ka" .Post.Language.String}} selected="selected"{{end}}>ქართული</option>
<option value="de"{{if eq "de" .Post.Language.String}} selected="selected"{{end}}>Deutsch</option>
<option value="el"{{if eq "el" .Post.Language.String}} selected="selected"{{end}}>ελληνικά</option>
<option value="gn"{{if eq "gn" .Post.Language.String}} selected="selected"{{end}}>Avañe'ẽ</option>
<option value="gu"{{if eq "gu" .Post.Language.String}} selected="selected"{{end}}>ગુજરાતી</option>
<option value="ht"{{if eq "ht" .Post.Language.String}} selected="selected"{{end}}>Kreyòl ayisyen</option>
<option dir="rtl" value="ha"{{if eq "ha" .Post.Language.String}} selected="selected"{{end}}>(Hausa) هَوُسَ</option>
<option dir="rtl" value="he"{{if eq "he" .Post.Language.String}} selected="selected"{{end}}>עברית</option>
<option value="hz"{{if eq "hz" .Post.Language.String}} selected="selected"{{end}}>Otjiherero</option>
<option value="hi"{{if eq "hi" .Post.Language.String}} selected="selected"{{end}}>हिन्दी, हिंदी</option>
<option value="ho"{{if eq "ho" .Post.Language.String}} selected="selected"{{end}}>Hiri Motu</option>
<option value="hu"{{if eq "hu" .Post.Language.String}} selected="selected"{{end}}>magyar</option>
<option value="ia"{{if eq "ia" .Post.Language.String}} selected="selected"{{end}}>Interlingua</option>
<option value="id"{{if eq "id" .Post.Language.String}} selected="selected"{{end}}>Bahasa Indonesia</option>
<option value="ie"{{if eq "ie" .Post.Language.String}} selected="selected"{{end}}>Interlingue</option>
<option value="ga"{{if eq "ga" .Post.Language.String}} selected="selected"{{end}}>Gaeilge</option>
<option value="ig"{{if eq "ig" .Post.Language.String}} selected="selected"{{end}}>Asụsụ Igbo</option>
<option value="ik"{{if eq "ik" .Post.Language.String}} selected="selected"{{end}}>Iñupiaq, Iñupiatun</option>
<option value="io"{{if eq "io" .Post.Language.String}} selected="selected"{{end}}>Ido</option>
<option value="is"{{if eq "is" .Post.Language.String}} selected="selected"{{end}}>Íslenska</option>
<option value="it"{{if eq "it" .Post.Language.String}} selected="selected"{{end}}>Italiano</option>
<option value="iu"{{if eq "iu" .Post.Language.String}} selected="selected"{{end}}>ᐃᓄᒃᑎᑐᑦ</option>
<option value="ja"{{if eq "ja" .Post.Language.String}} selected="selected"{{end}}>日本語 (にほんご)</option>
<option value="jv"{{if eq "jv" .Post.Language.String}} selected="selected"{{end}}>ꦧꦱꦗꦮ, Basa Jawa</option>
<option value="kl"{{if eq "kl" .Post.Language.String}} selected="selected"{{end}}>kalaallisut, kalaallit oqaasii</option>
<option value="kn"{{if eq "kn" .Post.Language.String}} selected="selected"{{end}}>ಕನ್ನಡ</option>
<option value="kr"{{if eq "kr" .Post.Language.String}} selected="selected"{{end}}>Kanuri</option>
<option value="ks"{{if eq "ks" .Post.Language.String}} selected="selected"{{end}}>कश्मीरी, كشميري‎</option>
<option value="kk"{{if eq "kk" .Post.Language.String}} selected="selected"{{end}}>қазақ тілі</option>
<option value="km"{{if eq "km" .Post.Language.String}} selected="selected"{{end}}>ខ្មែរ, ខេមរភាសា, ភាសាខ្មែរ</option>
<option value="ki"{{if eq "ki" .Post.Language.String}} selected="selected"{{end}}>Gĩkũyũ</option>
<option value="rw"{{if eq "rw" .Post.Language.String}} selected="selected"{{end}}>Ikinyarwanda</option>
<option value="ky"{{if eq "ky" .Post.Language.String}} selected="selected"{{end}}>Кыргызча, Кыргыз тили</option>
<option value="kv"{{if eq "kv" .Post.Language.String}} selected="selected"{{end}}>коми кыв</option>
<option value="kg"{{if eq "kg" .Post.Language.String}} selected="selected"{{end}}>Kikongo</option>
<option value="ko"{{if eq "ko" .Post.Language.String}} selected="selected"{{end}}>한국어</option>
<option value="ku"{{if eq "ku" .Post.Language.String}} selected="selected"{{end}}>Kurdî, كوردی‎</option>
<option value="kj"{{if eq "kj" .Post.Language.String}} selected="selected"{{end}}>Kuanyama</option>
<option value="la"{{if eq "la" .Post.Language.String}} selected="selected"{{end}}>latine, lingua latina</option>
<option value="lb"{{if eq "lb" .Post.Language.String}} selected="selected"{{end}}>Lëtzebuergesch</option>
<option value="lg"{{if eq "lg" .Post.Language.String}} selected="selected"{{end}}>Luganda</option>
<option value="li"{{if eq "li" .Post.Language.String}} selected="selected"{{end}}>Limburgs</option>
<option value="ln"{{if eq "ln" .Post.Language.String}} selected="selected"{{end}}>Lingála</option>
<option value="lo"{{if eq "lo" .Post.Language.String}} selected="selected"{{end}}>ພາສາລາວ</option>
<option value="lt"{{if eq "lt" .Post.Language.String}} selected="selected"{{end}}>lietuvių kalba</option>
<option value="lu"{{if eq "lu" .Post.Language.String}} selected="selected"{{end}}>Kiluba</option>
<option value="lv"{{if eq "lv" .Post.Language.String}} selected="selected"{{end}}>Latviešu Valoda</option>
<option value="gv"{{if eq "gv" .Post.Language.String}} selected="selected"{{end}}>Gaelg, Gailck</option>
<option value="mk"{{if eq "mk" .Post.Language.String}} selected="selected"{{end}}>македонски јазик</option>
<option value="mg"{{if eq "mg" .Post.Language.String}} selected="selected"{{end}}>fiteny malagasy</option>
<option value="ms"{{if eq "ms" .Post.Language.String}} selected="selected"{{end}}>Bahasa Melayu, بهاس ملايو‎</option>
<option value="ml"{{if eq "ml" .Post.Language.String}} selected="selected"{{end}}>മലയാളം</option>
<option value="mt"{{if eq "mt" .Post.Language.String}} selected="selected"{{end}}>Malti</option>
<option value="mi"{{if eq "mi" .Post.Language.String}} selected="selected"{{end}}>te reo Māori</option>
<option value="mr"{{if eq "mr" .Post.Language.String}} selected="selected"{{end}}>मराठी</option>
<option value="mh"{{if eq "mh" .Post.Language.String}} selected="selected"{{end}}>Kajin M̧ajeļ</option>
<option value="mn"{{if eq "mn" .Post.Language.String}} selected="selected"{{end}}>Монгол хэл</option>
<option value="na"{{if eq "na" .Post.Language.String}} selected="selected"{{end}}>Dorerin Naoero</option>
<option value="nv"{{if eq "nv" .Post.Language.String}} selected="selected"{{end}}>Diné bizaad</option>
<option value="nd"{{if eq "nd" .Post.Language.String}} selected="selected"{{end}}>isiNdebele</option>
<option value="ne"{{if eq "ne" .Post.Language.String}} selected="selected"{{end}}>नेपाली</option>
<option value="ng"{{if eq "ng" .Post.Language.String}} selected="selected"{{end}}>Owambo</option>
<option value="nb"{{if eq "nb" .Post.Language.String}} selected="selected"{{end}}>Norsk Bokmål</option>
<option value="nn"{{if eq "nn" .Post.Language.String}} selected="selected"{{end}}>Norsk Nynorsk</option>
<option value="no"{{if eq "no" .Post.Language.String}} selected="selected"{{end}}>Norsk</option>
<option value="ii"{{if eq "ii" .Post.Language.String}} selected="selected"{{end}}>ꆈꌠ꒿ Nuosuhxop</option>
<option value="nr"{{if eq "nr" .Post.Language.String}} selected="selected"{{end}}>isiNdebele</option>
<option value="oc"{{if eq "oc" .Post.Language.String}} selected="selected"{{end}}>occitan, lenga d'òc</option>
<option value="oj"{{if eq "oj" .Post.Language.String}} selected="selected"{{end}}>ᐊᓂᔑᓈᐯᒧᐎᓐ</option>
<option value="cu"{{if eq "cu" .Post.Language.String}} selected="selected"{{end}}>ѩзыкъ словѣньскъ</option>
<option value="om"{{if eq "om" .Post.Language.String}} selected="selected"{{end}}>Afaan Oromoo</option>
<option value="or"{{if eq "or" .Post.Language.String}} selected="selected"{{end}}>ଓଡ଼ିଆ</option>
<option value="os"{{if eq "os" .Post.Language.String}} selected="selected"{{end}}>ирон æвзаг</option>
<option value="pa"{{if eq "pa" .Post.Language.String}} selected="selected"{{end}}>ਪੰਜਾਬੀ</option>
<option value="pi"{{if eq "pi" .Post.Language.String}} selected="selected"{{end}}>पाऴि</option>
<option dir="rtl" value="fa"{{if eq "fa" .Post.Language.String}} selected="selected"{{end}}>فارسی</option>
<option value="pl"{{if eq "pl" .Post.Language.String}} selected="selected"{{end}}>Język Polski, Polszczyzna</option>
<option dir="rtl" value="ps"{{if eq "ps" .Post.Language.String}} selected="selected"{{end}}>پښتو</option>
<option value="pt"{{if eq "pt" .Post.Language.String}} selected="selected"{{end}}>Português</option>
<option value="qu"{{if eq "qu" .Post.Language.String}} selected="selected"{{end}}>Runa Simi, Kichwa</option>
<option value="rm"{{if eq "rm" .Post.Language.String}} selected="selected"{{end}}>Rumantsch Grischun</option>
<option value="rn"{{if eq "rn" .Post.Language.String}} selected="selected"{{end}}>Ikirundi</option>
<option value="ro"{{if eq "ro" .Post.Language.String}} selected="selected"{{end}}>Română</option>
<option value="ru"{{if eq "ru" .Post.Language.String}} selected="selected"{{end}}>Русский</option>
<option value="sa"{{if eq "sa" .Post.Language.String}} selected="selected"{{end}}>संस्कृतम्</option>
<option value="sc"{{if eq "sc" .Post.Language.String}} selected="selected"{{end}}>sardu</option>
<option value="sd"{{if eq "sd" .Post.Language.String}} selected="selected"{{end}}>सिन्धी, سنڌي، سندھی‎</option>
<option value="se"{{if eq "se" .Post.Language.String}} selected="selected"{{end}}>Davvisámegiella</option>
<option value="sm"{{if eq "sm" .Post.Language.String}} selected="selected"{{end}}>gagana fa'a Samoa</option>
<option value="sg"{{if eq "sg" .Post.Language.String}} selected="selected"{{end}}>yângâ tî sängö</option>
<option value="sr"{{if eq "sr" .Post.Language.String}} selected="selected"{{end}}>српски језик</option>
<option value="gd"{{if eq "gd" .Post.Language.String}} selected="selected"{{end}}>Gàidhlig</option>
<option value="sn"{{if eq "sn" .Post.Language.String}} selected="selected"{{end}}>chiShona</option>
<option value="si"{{if eq "si" .Post.Language.String}} selected="selected"{{end}}>සිංහල</option>
<option value="sk"{{if eq "sk" .Post.Language.String}} selected="selected"{{end}}>Slovenčina, Slovenský Jazyk</option>
<option value="sl"{{if eq "sl" .Post.Language.String}} selected="selected"{{end}}>Slovenski Jezik, Slovenščina</option>
<option value="so"{{if eq "so" .Post.Language.String}} selected="selected"{{end}}>Soomaaliga, af Soomaali</option>
<option value="st"{{if eq "st" .Post.Language.String}} selected="selected"{{end}}>Sesotho</option>
<option value="es"{{if eq "es" .Post.Language.String}} selected="selected"{{end}}>Español</option>
<option value="su"{{if eq "su" .Post.Language.String}} selected="selected"{{end}}>Basa Sunda</option>
<option value="sw"{{if eq "sw" .Post.Language.String}} selected="selected"{{end}}>Kiswahili</option>
<option value="ss"{{if eq "ss" .Post.Language.String}} selected="selected"{{end}}>SiSwati</option>
<option value="sv"{{if eq "sv" .Post.Language.String}} selected="selected"{{end}}>Svenska</option>
<option value="ta"{{if eq "ta" .Post.Language.String}} selected="selected"{{end}}>தமிழ்</option>
<option value="te"{{if eq "te" .Post.Language.String}} selected="selected"{{end}}>తెలుగు</option>
<option value="tg"{{if eq "tg" .Post.Language.String}} selected="selected"{{end}}>тоҷикӣ, toçikī, تاجیکی‎</option>
<option value="th"{{if eq "th" .Post.Language.String}} selected="selected"{{end}}>ไทย</option>
<option value="ti"{{if eq "ti" .Post.Language.String}} selected="selected"{{end}}>ትግርኛ</option>
<option value="bo"{{if eq "bo" .Post.Language.String}} selected="selected"{{end}}>བོད་ཡིག</option>
<option value="tk"{{if eq "tk" .Post.Language.String}} selected="selected"{{end}}>Türkmen, Түркмен</option>
<option value="tl"{{if eq "tl" .Post.Language.String}} selected="selected"{{end}}>Wikang Tagalog</option>
<option value="tn"{{if eq "tn" .Post.Language.String}} selected="selected"{{end}}>Setswana</option>
<option value="to"{{if eq "to" .Post.Language.String}} selected="selected"{{end}}>Faka Tonga</option>
<option value="tr"{{if eq "tr" .Post.Language.String}} selected="selected"{{end}}>Türkçe</option>
<option value="ts"{{if eq "ts" .Post.Language.String}} selected="selected"{{end}}>Xitsonga</option>
<option value="tt"{{if eq "tt" .Post.Language.String}} selected="selected"{{end}}>татар теле, tatar tele</option>
<option value="tw"{{if eq "tw" .Post.Language.String}} selected="selected"{{end}}>Twi</option>
<option value="ty"{{if eq "ty" .Post.Language.String}} selected="selected"{{end}}>Reo Tahiti</option>
<option value="ug"{{if eq "ug" .Post.Language.String}} selected="selected"{{end}}>ئۇيغۇرچە‎, Uyghurche</option>
<option value="uk"{{if eq "uk" .Post.Language.String}} selected="selected"{{end}}>Українська</option>
<option dir="rtl" value="ur"{{if eq "ur" .Post.Language.String}} selected="selected"{{end}}>اردو</option>
<option value="uz"{{if eq "uz" .Post.Language.String}} selected="selected"{{end}}>Oʻzbek, Ўзбек, أۇزبېك‎</option>
<option value="ve"{{if eq "ve" .Post.Language.String}} selected="selected"{{end}}>Tshivenḓa</option>
<option value="vi"{{if eq "vi" .Post.Language.String}} selected="selected"{{end}}>Tiếng Việt</option>
<option value="vo"{{if eq "vo" .Post.Language.String}} selected="selected"{{end}}>Volapük</option>
<option value="wa"{{if eq "wa" .Post.Language.String}} selected="selected"{{end}}>Walon</option>
<option value="cy"{{if eq "cy" .Post.Language.String}} selected="selected"{{end}}>Cymraeg</option>
<option value="wo"{{if eq "wo" .Post.Language.String}} selected="selected"{{end}}>Wollof</option>
<option value="fy"{{if eq "fy" .Post.Language.String}} selected="selected"{{end}}>Frysk</option>
<option value="xh"{{if eq "xh" .Post.Language.String}} selected="selected"{{end}}>isiXhosa</option>
<option dir="rtl" value="yi"{{if eq "yi" .Post.Language.String}} selected="selected"{{end}}>ייִדיש</option>
<option value="yo"{{if eq "yo" .Post.Language.String}} selected="selected"{{end}}>Yorùbá</option>
<option value="za"{{if eq "za" .Post.Language.String}} selected="selected"{{end}}>Saɯ cueŋƅ, Saw cuengh</option>
<option value="zu"{{if eq "zu" .Post.Language.String}} selected="selected"{{end}}>isiZulu</option>
</select>
</dd>
<dt><label for="rtl">Direction</label></dt>
<dd><input type="checkbox" id="rtl" name="rtl" {{if .Post.IsRTL.Bool}}checked="checked"{{end}} /><label for="rtl"> right-to-left</label></dd>
<dt><label for="created">Created</label></dt>
<dd>
<input type="text" id="created" name="created" value="{{.Post.UserFacingCreated}}" data-time="{{.Post.Created8601}}" placeholder="YYYY-MM-DD HH:MM:SS" maxlength="19" /> <span id="tz">UTC</span> <a href="#" id="set-now">now</a>
<p class="error" id="create-error">Date format should be: <span class="mono"><abbr title="The full year">YYYY</abbr>-<abbr title="The numeric month of the year, where January = 1, with a zero in front if less than 10">MM</abbr>-<abbr title="The day of the month, with a zero in front if less than 10">DD</abbr> <abbr title="The hour (00-23), with a zero in front if less than 10.">HH</abbr>:<abbr title="The minute of the hour (00-59), with a zero in front if less than 10.">MM</abbr>:<abbr title="The seconds (00-59), with a zero in front if less than 10.">SS</abbr></span></p>
</dd>
<dt>&nbsp;</dt><dd><input type="submit" value="Save changes" /></dd>
</dl>
</form>
</div>
<script src="/js/h.js"></script>
<script>
function updateMeta() {
document.getElementById('create-error').style.display = 'none';
var $created = document.getElementById('created');
var dateStr = $created.value.trim();
var m = dateStr.match(/^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}( [0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?)?$/);
if (!m) {
document.getElementById('create-error').style.display = 'block';
return false;
}
// Break up the date and parse. This ensures cross-browser compatibility
var p = dateStr.split(/[^0-9]/);
var d = new Date(p[0], p[1]-1, p[2], p[3] ? p[3] : 0, p[4] ? p[4] : 0, p[5] ? p[5] : 0);
$created.value = d.getUTCFullYear() + '-' + ('0' + (d.getUTCMonth()+1)).slice(-2) + '-' + ('0' + d.getUTCDate()).slice(-2)+' '+('0'+d.getUTCHours()).slice(-2)+':'+('0'+d.getUTCMinutes()).slice(-2)+':'+('0'+d.getUTCSeconds()).slice(-2);
var $tz = document.getElementById('tz');
$tz.style.display = "inline";
var $submit = document.querySelector('input[type=submit]');
$submit.value = "Saving...";
$submit.disabled = true;
return true;
}
function dateToStr(d) {
return d.getFullYear() + '-' + ('0' + (d.getMonth()+1)).slice(-2) + '-' + ('0' + d.getDate()).slice(-2)+' '+('0'+d.getHours()).slice(-2)+':'+('0'+d.getMinutes()).slice(-2)+':'+('0'+d.getSeconds()).slice(-2);
}
function setLocalTime() {
var $created = document.getElementById('created');
var d = new Date($created.getAttribute('data-time'));
$created.value = dateToStr(d);
var $tz = document.getElementById('tz');
$tz.style.display = "none";
}
setLocalTime();
function setToNow() {
var $created = document.getElementById('created');
$created.value = dateToStr(new Date());
}
H.getEl('set-now').on('click', function(e) {
e.preventDefault();
setToNow();
});
function toggleTheme() {
var btns = Array.prototype.slice.call(document.getElementById('tools').querySelectorAll('a img'));
if (document.body.className == 'light') {
document.body.className = 'dark';
for (var i=0; i<btns.length; i++) {
btns[i].src = btns[i].src.replace('_dark@2x.png', '@2x.png');
}
} else {
document.body.className = 'light';
for (var i=0; i<btns.length; i++) {
btns[i].src = btns[i].src.replace('@2x.png', '_dark@2x.png');
}
}
H.set('padTheme', document.body.className);
}
if (H.get('padTheme', 'light') != 'light') {
toggleTheme();
}
var setButtonStates = function() {
if (!canPublish) {
$btnPublish.el.className = 'disabled';
return;
}
if ($writer.el.value.length === 0 || (draftDoc != 'lastDoc' && $writer.el.value == origDoc)) {
$btnPublish.el.className = 'disabled';
} else {
$btnPublish.el.className = '';
}
};
H.getEl('toggle-theme').on('click', function(e) {
e.preventDefault();
try {
var newTheme = 'light';
if (document.body.className == 'light') {
newTheme = 'dark';
}
} catch(e) {}
toggleTheme();
});
WebFontConfig = {
custom: { families: [ 'Lora:400,700:latin' ], urls: [ '/css/fonts.css' ] }
};
try {
(function() {
var wf=document.createElement('script');
wf.src = '/js/webfont.js';
wf.type='text/javascript';
wf.async='true';
var s=document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(wf, s);
})();
} catch (e) {
// whatevs
}
</script>
- <noscript><p><img src="https://analytics.write.as/piwik.php?idsite=1" style="border:0;" alt="" /></p></noscript>
<link href="/css/icons.css" rel="stylesheet">
</body>
</html>{{end}}
diff --git a/unregisteredusers.go b/unregisteredusers.go
new file mode 100644
index 0000000..8cd3dec
--- /dev/null
+++ b/unregisteredusers.go
@@ -0,0 +1,121 @@
+package writefreely
+
+import (
+ "database/sql"
+ "encoding/json"
+ "github.com/writeas/impart"
+ "github.com/writeas/web-core/log"
+ "net/http"
+)
+
+func handleWebSignup(app *app, w http.ResponseWriter, r *http.Request) error {
+ reqJSON := IsJSON(r.Header.Get("Content-Type"))
+
+ // Get params
+ var ur userRegistration
+ if reqJSON {
+ decoder := json.NewDecoder(r.Body)
+ err := decoder.Decode(&ur)
+ if err != nil {
+ log.Error("Couldn't parse signup JSON request: %v\n", err)
+ return ErrBadJSON
+ }
+ } else {
+ err := r.ParseForm()
+ if err != nil {
+ log.Error("Couldn't parse signup form request: %v\n", err)
+ return ErrBadFormData
+ }
+
+ err = app.formDecoder.Decode(&ur, r.PostForm)
+ if err != nil {
+ log.Error("Couldn't decode signup form request: %v\n", err)
+ return ErrBadFormData
+ }
+ }
+ ur.Web = true
+
+ _, err := signupWithRegistration(app, ur, w, r)
+ if err != nil {
+ return err
+ }
+ return impart.HTTPError{http.StatusFound, "/"}
+}
+
+// { "username": "asdf" }
+// result: { code: 204 }
+func handleUsernameCheck(app *app, w http.ResponseWriter, r *http.Request) error {
+ reqJSON := IsJSON(r.Header.Get("Content-Type"))
+
+ // Get params
+ var d struct {
+ Username string `json:"username"`
+ }
+ if reqJSON {
+ decoder := json.NewDecoder(r.Body)
+ err := decoder.Decode(&d)
+ if err != nil {
+ log.Error("Couldn't decode username check: %v\n", err)
+ return ErrBadFormData
+ }
+ } else {
+ return impart.HTTPError{http.StatusNotAcceptable, "Must be JSON request"}
+ }
+
+ // Check if username is okay
+ finalUsername := getSlug(d.Username, "")
+ if finalUsername == "" {
+ errMsg := "Invalid username"
+ if d.Username != "" {
+ // Username was provided, but didn't convert into valid latin characters
+ errMsg += " - must have at least 2 letters or numbers"
+ }
+ return impart.HTTPError{http.StatusBadRequest, errMsg + "."}
+ }
+ if app.db.PostIDExists(finalUsername) {
+ return impart.HTTPError{http.StatusConflict, "Username is already taken."}
+ }
+ var un string
+ err := app.db.QueryRow("SELECT username FROM users WHERE username = ?", finalUsername).Scan(&un)
+ switch {
+ case err == sql.ErrNoRows:
+ return impart.WriteSuccess(w, finalUsername, http.StatusOK)
+ case err != nil:
+ log.Error("Couldn't SELECT username: %v", err)
+ return impart.HTTPError{http.StatusInternalServerError, "We messed up."}
+ }
+
+ // Username was found, so it's taken
+ return impart.HTTPError{http.StatusConflict, "Username is already taken."}
+}
+
+func getValidUsername(app *app, reqName, prevName string) (string, *impart.HTTPError) {
+ // Check if username is okay
+ finalUsername := getSlug(reqName, "")
+ if finalUsername == "" {
+ errMsg := "Invalid username"
+ if reqName != "" {
+ // Username was provided, but didn't convert into valid latin characters
+ errMsg += " - must have at least 2 letters or numbers"
+ }
+ return "", &impart.HTTPError{http.StatusBadRequest, errMsg + "."}
+ }
+ if finalUsername == prevName {
+ return "", &impart.HTTPError{http.StatusNotModified, "Username unchanged."}
+ }
+ if app.db.PostIDExists(finalUsername) {
+ return "", &impart.HTTPError{http.StatusConflict, "Username is already taken."}
+ }
+ var un string
+ err := app.db.QueryRow("SELECT username FROM users WHERE username = ?", finalUsername).Scan(&un)
+ switch {
+ case err == sql.ErrNoRows:
+ return finalUsername, nil
+ case err != nil:
+ log.Error("Couldn't SELECT username: %v", err)
+ return "", &impart.HTTPError{http.StatusInternalServerError, "We messed up."}
+ }
+
+ // Username was found, so it's taken
+ return "", &impart.HTTPError{http.StatusConflict, "Username is already taken."}
+}

File Metadata

Mime Type
text/x-diff
Expires
Sun, Apr 6, 12:29 AM (23 h, 43 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3188688

Event Timeline

musing studio · developers