No OneTemporary
Actions

Size

23 KB

Subscribers

None

View Options

	diff --git a/read.go b/read.go
	index 7fb700e..35a671f 100644
	--- a/read.go
	+++ b/read.go
	@@ -1,340 +1,342 @@
	/*
	* Copyright © 2018-2021 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"
	"html/template"
	"math"
	"net/http"
	"strconv"
	"time"

	. "github.com/gorilla/feeds"
	"github.com/gorilla/mux"
	stripmd "github.com/writeas/go-strip-markdown"
	"github.com/writeas/impart"
	"github.com/writeas/web-core/log"
	"github.com/writeas/web-core/memo"
	"github.com/writefreely/writefreely/page"
	)

	const (
	tlFeedLimit = 100
	tlAPIPageLimit = 10
	tlMaxAuthorPosts = 5
	tlPostsPerPage = 16
	tlMaxPostCache = 250
	tlCacheDur = 10 * time.Minute
	)

	type localTimeline struct {
	m *memo.Memo
	posts *[]PublicPost

	// Configuration values
	postsPerPage int
	}

	type readPublication struct {
	page.StaticPage
	Posts *[]PublicPost
	CurrentPage int
	TotalPages int
	SelTopic string
	IsAdmin bool
	CanInvite bool

	// Customizable page content
	ContentTitle string
	Content template.HTML
	}

	func initLocalTimeline(app *App) {
	app.timeline = &localTimeline{
	postsPerPage: tlPostsPerPage,
	m: memo.New(app.FetchPublicPosts, tlCacheDur),
	}
	}

	// satisfies memo.Func
	func (app *App) FetchPublicPosts() (interface{}, error) {
	// Conditions
	limit := fmt.Sprintf("LIMIT %d", tlMaxPostCache)
	// This is better than the hard limit when limiting posts from individual authors
	// ageCond := `p.created >= ` + app.db.dateSub(3, "month") + ` AND `

	// Finds all public posts and posts in a public collection published during the owner's active subscription period and within the last 3 months
	- rows, err := app.db.Query(`SELECT p.id, alias, c.title, p.slug, p.title, p.content, p.text_appearance, p.language, p.rtl, p.created, p.updated
	+ rows, err := app.db.Query(`SELECT p.id, c.id, alias, c.title, p.slug, p.title, p.content, p.text_appearance, p.language, p.rtl, p.created, p.updated
	FROM collections c
	LEFT JOIN posts p ON p.collection_id = c.id
	LEFT JOIN users u ON u.id = p.owner_id
	WHERE c.privacy = 1 AND (p.created <= ` + app.db.now() + ` AND pinned_position IS NULL) AND u.status = 0
	ORDER BY p.created DESC
	` + limit)
	if err != nil {
	log.Error("Failed selecting from posts: %v", err)
	return nil, impart.HTTPError{http.StatusInternalServerError, "Couldn't retrieve collection posts." + err.Error()}
	}
	defer rows.Close()

	ap := map[string]uint{}

	posts := []PublicPost{}
	for rows.Next() {
	p := &Post{}
	c := &Collection{}
	var alias, title sql.NullString
	- err = rows.Scan(&p.ID, &alias, &title, &p.Slug, &p.Title, &p.Content, &p.Font, &p.Language, &p.RTL, &p.Created, &p.Updated)
	+ err = rows.Scan(&p.ID, &c.ID, &alias, &title, &p.Slug, &p.Title, &p.Content, &p.Font, &p.Language, &p.RTL, &p.Created, &p.Updated)
	if err != nil {
	log.Error("[READ] Unable to scan row, skipping: %v", err)
	continue
	}
	c.hostName = app.cfg.App.Host

	isCollectionPost := alias.Valid
	if isCollectionPost {
	c.Alias = alias.String
	if c.Alias != "" && ap[c.Alias] == tlMaxAuthorPosts {
	// Don't add post if we've hit the post-per-author limit
	continue
	}

	c.Public = true
	c.Title = title.String
	+ c.Monetization = app.db.GetCollectionAttribute(c.ID, "monetization_pointer")
	}

	p.extractData()
	+ p.handlePremiumContent(c, false, false, app.cfg)
	p.HTMLContent = template.HTML(applyMarkdown([]byte(p.Content), "", app.cfg))
	fp := p.processPost()
	if isCollectionPost {
	fp.Collection = &CollectionObj{Collection: *c}
	}

	posts = append(posts, fp)
	ap[c.Alias]++
	}

	return posts, nil
	}

	func viewLocalTimelineAPI(app App, w http.ResponseWriter, r http.Request) error {
	updateTimelineCache(app.timeline, false)

	skip, _ := strconv.Atoi(r.FormValue("skip"))

	posts := []PublicPost{}
	for i := skip; i < skip+tlAPIPageLimit && i < len(*app.timeline.posts); i++ {
	posts = append(posts, (*app.timeline.posts)[i])
	}

	return impart.WriteSuccess(w, posts, http.StatusOK)
	}

	func viewLocalTimeline(app App, w http.ResponseWriter, r http.Request) error {
	if !app.cfg.App.LocalTimeline {
	return impart.HTTPError{http.StatusNotFound, "Page doesn't exist."}
	}

	vars := mux.Vars(r)
	var p int
	page := 1
	p, _ = strconv.Atoi(vars["page"])
	if p > 0 {
	page = p
	}

	return showLocalTimeline(app, w, r, page, vars["author"], vars["tag"])
	}

	// updateTimelineCache will reset and update the cache if it is stale or
	// the boolean passed in is true.
	func updateTimelineCache(tl *localTimeline, reset bool) {
	if reset {
	tl.m.Reset()
	}

	// Fetch posts if the cache is empty, has been reset or enough time has
	// passed since last cache.
	if tl.posts == nil \|\| reset \|\| tl.m.Invalidate() {
	log.Info("[READ] Updating post cache")

	postsInterfaces, err := tl.m.Get()
	if err != nil {
	log.Error("[READ] Unable to cache posts: %v", err)
	} else {
	castPosts := postsInterfaces.([]PublicPost)
	tl.posts = &castPosts
	}
	}

	}

	func showLocalTimeline(app App, w http.ResponseWriter, r http.Request, page int, author, tag string) error {
	updateTimelineCache(app.timeline, false)

	pl := len(*(app.timeline.posts))
	ttlPages := int(math.Ceil(float64(pl) / float64(app.timeline.postsPerPage)))

	start := 0
	if page > 1 {
	start = app.timeline.postsPerPage * (page - 1)
	if start > pl {
	return impart.HTTPError{http.StatusFound, fmt.Sprintf("/read/p/%d", ttlPages)}
	}
	}
	end := app.timeline.postsPerPage * page
	if end > pl {
	end = pl
	}
	var posts []PublicPost
	if author != "" {
	posts = []PublicPost{}
	for _, p := range *app.timeline.posts {
	if author == "anonymous" {
	if p.Collection == nil {
	posts = append(posts, p)
	}
	} else if p.Collection != nil && p.Collection.Alias == author {
	posts = append(posts, p)
	}
	}
	} else if tag != "" {
	posts = []PublicPost{}
	for _, p := range *app.timeline.posts {
	if p.HasTag(tag) {
	posts = append(posts, p)
	}
	}
	} else {
	posts = *app.timeline.posts
	posts = posts[start:end]
	}

	d := &readPublication{
	StaticPage: pageForReq(app, r),
	Posts: &posts,
	CurrentPage: page,
	TotalPages: ttlPages,
	SelTopic: tag,
	}
	if app.cfg.App.Chorus {
	u := getUserSession(app, r)
	d.IsAdmin = u != nil && u.IsAdmin()
	d.CanInvite = canUserInvite(app.cfg, d.IsAdmin)
	}
	c, err := getReaderSection(app)
	if err != nil {
	return err
	}
	d.ContentTitle = c.Title.String
	d.Content = template.HTML(applyMarkdown([]byte(c.Content), "", app.cfg))

	err = templates["read"].ExecuteTemplate(w, "base", d)
	if err != nil {
	log.Error("Unable to render reader: %v", err)
	fmt.Fprintf(w, ":(")
	}
	return nil
	}

	// NextPageURL provides a full URL for the next page of collection posts
	func (c *readPublication) NextPageURL(n int) string {
	return fmt.Sprintf("/read/p/%d", n+1)
	}

	// PrevPageURL provides a full URL for the previous page of collection posts,
	// returning a /page/N result for pages >1
	func (c *readPublication) PrevPageURL(n int) string {
	if n == 2 {
	// Previous page is 1; no need for /p/ prefix
	return "/read"
	}
	return fmt.Sprintf("/read/p/%d", n-1)
	}

	// handlePostIDRedirect handles a route where a post ID is given and redirects
	// the user to the canonical post URL.
	func handlePostIDRedirect(app App, w http.ResponseWriter, r http.Request) error {
	vars := mux.Vars(r)
	postID := vars["post"]
	p, err := app.db.GetPost(postID, 0)
	if err != nil {
	return err
	}

	if !p.CollectionID.Valid {
	// No collection; send to normal URL
	// NOTE: not handling single user blogs here since this handler is only used for the Reader
	return impart.HTTPError{http.StatusFound, app.cfg.App.Host + "/" + postID + ".md"}
	}

	c, err := app.db.GetCollectionBy("id = ?", fmt.Sprintf("%d", p.CollectionID.Int64))
	if err != nil {
	return err
	}
	c.hostName = app.cfg.App.Host

	// Retrieve collection information and send user to canonical URL
	return impart.HTTPError{http.StatusFound, c.CanonicalURL() + p.Slug.String}
	}

	func viewLocalTimelineFeed(app App, w http.ResponseWriter, req http.Request) error {
	if !app.cfg.App.LocalTimeline {
	return impart.HTTPError{http.StatusNotFound, "Page doesn't exist."}
	}

	updateTimelineCache(app.timeline, false)

	feed := &Feed{
	Title: app.cfg.App.SiteName + " Reader",
	Link: &Link{Href: app.cfg.App.Host},
	Description: "Read the latest posts from " + app.cfg.App.SiteName + ".",
	Created: time.Now(),
	}

	c := 0
	var title, permalink, author string
	for _, p := range *app.timeline.posts {
	if c == tlFeedLimit {
	break
	}

	title = p.PlainDisplayTitle()
	permalink = p.CanonicalURL(app.cfg.App.Host)
	if p.Collection != nil {
	author = p.Collection.Title
	} else {
	author = "Anonymous"
	}
	i := &Item{
	Id: app.cfg.App.Host + "/read/a/" + p.ID,
	Title: title,
	Link: &Link{Href: permalink},
	Description: "<![CDATA[" + stripmd.Strip(p.Content) + "]]>",
	Content: applyMarkdown([]byte(p.Content), "", app.cfg),
	Author: &Author{author, ""},
	Created: p.Created,
	Updated: p.Updated,
	}
	feed.Items = append(feed.Items, i)
	c++
	}

	rss, err := feed.ToRss()
	if err != nil {
	return err
	}

	fmt.Fprint(w, rss)
	return nil
	}
	diff --git a/templates.go b/templates.go
	index 3871258..e0c728e 100644
	--- a/templates.go
	+++ b/templates.go
	@@ -1,229 +1,229 @@
	/*
	* Copyright © 2018-2021 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 (
	"errors"
	"html/template"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"
	"strings"

	"github.com/dustin/go-humanize"
	"github.com/writeas/web-core/l10n"
	"github.com/writeas/web-core/log"
	"github.com/writefreely/writefreely/config"
	)

	var (
	templates = map[string]*template.Template{}
	pages = map[string]*template.Template{}
	userPages = map[string]*template.Template{}
	funcMap = template.FuncMap{
	"largeNumFmt": largeNumFmt,
	"pluralize": pluralize,
	"isRTL": isRTL,
	"isLTR": isLTR,
	"localstr": localStr,
	"localhtml": localHTML,
	"tolower": strings.ToLower,
	"title": strings.Title,
	"hasPrefix": strings.HasPrefix,
	"hasSuffix": strings.HasSuffix,
	"dict": dict,
	}
	)

	const (
	templatesDir = "templates"
	pagesDir = "pages"
	)

	func showUserPage(w http.ResponseWriter, name string, obj interface{}) {
	if obj == nil {
	log.Error("showUserPage: data is nil!")
	return
	}
	if err := userPages[filepath.Join("user", name+".tmpl")].ExecuteTemplate(w, name, obj); err != nil {
	log.Error("Error parsing %s: %v", name, err)
	}
	}

	func initTemplate(parentDir, name string) {
	if debugging {
	log.Info(" " + filepath.Join(parentDir, templatesDir, name+".tmpl"))
	}

	files := []string{
	filepath.Join(parentDir, templatesDir, name+".tmpl"),
	filepath.Join(parentDir, templatesDir, "include", "footer.tmpl"),
	filepath.Join(parentDir, templatesDir, "base.tmpl"),
	filepath.Join(parentDir, templatesDir, "user", "include", "silenced.tmpl"),
	}
	- if name == "collection" \|\| name == "collection-tags" \|\| name == "chorus-collection" {
	+ if name == "collection" \|\| name == "collection-tags" \|\| name == "chorus-collection" \|\| name == "read" {
	// These pages list out collection posts, so we also parse templatesDir + "include/posts.tmpl"
	files = append(files, filepath.Join(parentDir, templatesDir, "include", "posts.tmpl"))
	}
	if name == "chorus-collection" \|\| name == "chorus-collection-post" {
	files = append(files, filepath.Join(parentDir, templatesDir, "user", "include", "header.tmpl"))
	}
	if name == "collection" \|\| name == "collection-tags" \|\| name == "collection-post" \|\| name == "post" \|\| name == "chorus-collection" \|\| name == "chorus-collection-post" {
	files = append(files, filepath.Join(parentDir, templatesDir, "include", "post-render.tmpl"))
	}
	templates[name] = template.Must(template.New("").Funcs(funcMap).ParseFiles(files...))
	}

	func initPage(parentDir, path, key string) {
	if debugging {
	log.Info(" [%s] %s", key, path)
	}

	files := []string{
	path,
	filepath.Join(parentDir, templatesDir, "include", "footer.tmpl"),
	filepath.Join(parentDir, templatesDir, "base.tmpl"),
	filepath.Join(parentDir, templatesDir, "user", "include", "silenced.tmpl"),
	}

	if key == "login.tmpl" \|\| key == "landing.tmpl" \|\| key == "signup.tmpl" {
	files = append(files, filepath.Join(parentDir, templatesDir, "include", "oauth.tmpl"))
	}

	pages[key] = template.Must(template.New("").Funcs(funcMap).ParseFiles(files...))
	}

	func initUserPage(parentDir, path, key string) {
	if debugging {
	log.Info(" [%s] %s", key, path)
	}

	userPages[key] = template.Must(template.New(key).Funcs(funcMap).ParseFiles(
	path,
	filepath.Join(parentDir, templatesDir, "user", "include", "header.tmpl"),
	filepath.Join(parentDir, templatesDir, "user", "include", "footer.tmpl"),
	filepath.Join(parentDir, templatesDir, "user", "include", "silenced.tmpl"),
	filepath.Join(parentDir, templatesDir, "user", "include", "nav.tmpl"),
	))
	}

	// InitTemplates loads all template files from the configured parent dir.
	func InitTemplates(cfg *config.Config) error {
	log.Info("Loading templates...")
	tmplFiles, err := ioutil.ReadDir(filepath.Join(cfg.Server.TemplatesParentDir, templatesDir))
	if err != nil {
	return err
	}

	for _, f := range tmplFiles {
	if !f.IsDir() && !strings.HasPrefix(f.Name(), ".") {
	parts := strings.Split(f.Name(), ".")
	key := parts[0]
	initTemplate(cfg.Server.TemplatesParentDir, key)
	}
	}

	log.Info("Loading pages...")
	// Initialize all static pages that use the base template
	filepath.Walk(filepath.Join(cfg.Server.PagesParentDir, pagesDir), func(path string, i os.FileInfo, err error) error {
	if !i.IsDir() && !strings.HasPrefix(i.Name(), ".") {
	key := i.Name()
	initPage(cfg.Server.PagesParentDir, path, key)
	}

	return nil
	})

	log.Info("Loading user pages...")
	// Initialize all user pages that use base templates
	filepath.Walk(filepath.Join(cfg.Server.TemplatesParentDir, templatesDir, "user"), func(path string, f os.FileInfo, err error) error {
	if !f.IsDir() && !strings.HasPrefix(f.Name(), ".") {
	corePath := path
	if cfg.Server.TemplatesParentDir != "" {
	corePath = corePath[len(cfg.Server.TemplatesParentDir)+1:]
	}
	parts := strings.Split(corePath, string(filepath.Separator))
	key := f.Name()
	if len(parts) > 2 {
	key = filepath.Join(parts[1], f.Name())
	}
	initUserPage(cfg.Server.TemplatesParentDir, path, key)
	}

	return nil
	})

	return nil
	}

	// renderPage retrieves the given template and renders it to the given io.Writer.
	// If something goes wrong, the error is logged and returned.
	func renderPage(w io.Writer, tmpl string, data interface{}) error {
	err := pages[tmpl].ExecuteTemplate(w, "base", data)
	if err != nil {
	log.Error("%v", err)
	}
	return err
	}

	func largeNumFmt(n int64) string {
	return humanize.Comma(n)
	}

	func pluralize(singular, plural string, n int64) string {
	if n == 1 {
	return singular
	}
	return plural
	}

	func isRTL(d string) bool {
	return d == "rtl"
	}

	func isLTR(d string) bool {
	return d == "ltr" \|\| d == "auto"
	}

	func localStr(term, lang string) string {
	s := l10n.Strings(lang)[term]
	if s == "" {
	s = l10n.Strings("")[term]
	}
	return s
	}

	func localHTML(term, lang string) template.HTML {
	s := l10n.Strings(lang)[term]
	if s == "" {
	s = l10n.Strings("")[term]
	}
	s = strings.Replace(s, "write.as", "<a href=\"https://writefreely.org\">writefreely</a>", 1)
	return template.HTML(s)
	}

	// from: https://stackoverflow.com/a/18276968/1549194
	func dict(values ...interface{}) (map[string]interface{}, error) {
	if len(values)%2 != 0 {
	return nil, errors.New("dict: invalid number of parameters")
	}
	dict := make(map[string]interface{}, len(values)/2)
	for i := 0; i < len(values); i += 2 {
	key, ok := values[i].(string)
	if !ok {
	return nil, errors.New("dict: keys must be strings")
	}
	dict[key] = values[i+1]
	}
	return dict, nil
	}
	diff --git a/templates/read.tmpl b/templates/read.tmpl
	index fe42f7b..c032970 100644
	--- a/templates/read.tmpl
	+++ b/templates/read.tmpl
	@@ -1,135 +1,142 @@
	{{define "head"}}<title>{{.SiteName}} Reader</title>

	<link rel="alternate" type="application/rss+xml" title="{{.SiteName}} Reader" href="/read/feed/" />
	{{if gt .CurrentPage 1}}<link rel="prev" href="{{.PrevPageURL .CurrentPage}}">{{end}}
	{{if lt .CurrentPage .TotalPages}}<link rel="next" href="{{.NextPageURL .CurrentPage}}">{{end}}

	<meta name="description" content="Read the latest posts from {{.SiteName}}.">
	<meta itemprop="name" content="{{.SiteName}} Reader">
	<meta itemprop="description" content="Read the latest posts from {{.SiteName}}.">
	<meta name="twitter:card" content="summary_large_image">
	<meta name="twitter:title" content="{{.SiteName}} Reader">
	<meta name="twitter:description" content="Read the latest posts from {{.SiteName}}.">
	<meta property="og:title" content="{{.SiteName}} Reader" />
	<meta property="og:type" content="object" />
	<meta property="og:description" content="Read the latest posts from {{.SiteName}}." />

	<style>
	.heading h1 {
	font-weight: 300;
	text-align: center;
	margin: 3em 0 0;
	}
	.heading p {
	text-align: center;
	margin: 1.5em 0 4.5em;
	font-size: 1.1em;
	color: #777;
	}
	#wrapper {
	font-size: 1.2em;
	}
	.preview {
	max-height: 180px;
	overflow: hidden;
	position: relative;
	}
	.preview .over {
	position: absolute;
	top: 5em;
	bottom: 0;
	left: 0;
	right: 0;
	/* Permalink - use to edit and share this gradient: http://colorzilla.com/gradient-editor/#ffffff+0,ffffff+100&0+0,1+100 */
	background: -moz-linear-gradient(top, rgba(255,255,255,0) 0%, rgba(255,255,255,1) 100%); /* FF3.6-15 */
	background: -webkit-linear-gradient(top, rgba(255,255,255,0) 0%,rgba(255,255,255,1) 100%); /* Chrome10-25,Safari5.1-6 */
	background: linear-gradient(to bottom, rgba(255,255,255,0) 0%,rgba(255,255,255,1) 100%); /* W3C, IE10+, FF16+, Chrome26+, Opera12+, Safari7+ */
	filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#00ffffff', endColorstr='#ffffff',GradientType=0 ); /* IE6-9 */
	}
	p.source {
	font-size: 0.86em;
	margin-top: 0.25em;
	margin-bottom: 0;
	}
	.attention-box {
	text-align: center;
	font-size: 1.1em;
	}
	.attention-box hr { margin: 4rem auto; }
	hr { max-width: 40rem; }
	header {
	padding: 0 !important;
	text-align: left !important;
	margin: 1em !important;
	max-width: 100% !important;
	}
	body#collection header nav {
	display: inline !important;
	}
	body#collection header nav:not(#full-nav):not(#user-nav) {
	margin: 0 0 0 1em !important;
	}
	header nav#user-nav {
	margin-left: 0 !important;
	}
	body#collection header nav.tabs a:first-child {
	margin-left: 1em;
	}
	body#collection article {
	max-width: 40em !important;
	}
	</style>
	{{end}}
	{{define "body-attrs"}}id="collection"{{end}}
	{{define "content"}}
	<div class="content-container snug">
	<h1>{{.ContentTitle}}</h1>
	<p{{if .SelTopic}} style="text-align:center"{{end}}>{{if .SelTopic}}#{{.SelTopic}} posts{{else}}{{.Content}}{{end}}</p>
	</div>
	<div id="wrapper">
	{{ if gt (len .Posts) 0 }}
	<section itemscope itemtype="http://schema.org/Blog">
	{{range .Posts}}<article class="{{.Font}} h-entry" itemscope itemtype="http://schema.org/BlogPosting">
	- {{if .Title.String}}<h2 class="post-title" itemprop="name" class="p-name"><a href="{{if .Slug.String}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}" itemprop="url" class="u-url">{{.PlainDisplayTitle}}</a></h2>
	- <time class="dt-published" datetime="{{.Created8601}}" pubdate itemprop="datePublished" content="{{.Created}}">{{if not .Title.String}}<a href="{{.Collection.CanonicalURL}}{{.Slug.String}}" itemprop="url">{{end}}{{.DisplayDate}}{{if not .Title.String}}</a>{{end}}</time>
	- {{else}}
	- <h2 class="post-title" itemprop="name"><time class="dt-published" datetime="{{.Created8601}}" pubdate itemprop="datePublished" content="{{.Created}}"><a href="{{if .Collection}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}" itemprop="url" class="u-url">{{.DisplayDate}}</a></time></h2>
	- {{end}}
	+ {{if .Title.String -}}
	+ <h2 class="post-title" itemprop="name" class="p-name">
	+ {{- if .IsPaid}}{{template "paid-badge" .}}{{end -}}
	+ <a href="{{if .Slug.String}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}" itemprop="url" class="u-url">{{.PlainDisplayTitle}}</a>
	+ </h2>
	+ <time class="dt-published" datetime="{{.Created8601}}" pubdate itemprop="datePublished" content="{{.Created}}">{{if not .Title.String}}<a href="{{.Collection.CanonicalURL}}{{.Slug.String}}" itemprop="url">{{end}}{{.DisplayDate}}{{if not .Title.String}}</a>{{end}}</time>
	+ {{- else -}}
	+ <h2 class="post-title" itemprop="name">
	+ {{- if .IsPaid}}{{template "paid-badge" .}}{{end -}}
	+ <time class="dt-published" datetime="{{.Created8601}}" pubdate itemprop="datePublished" content="{{.Created}}"><a href="{{if .Collection}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}" itemprop="url" class="u-url">{{.DisplayDate}}</a></time>
	+ </h2>
	+ {{- end}}
	<p class="source">{{if .Collection}}from <a href="{{.Collection.CanonicalURL}}">{{.Collection.DisplayTitle}}</a>{{else}}<em>Anonymous</em>{{end}}</p>
	{{if .Excerpt}}<div class="p-summary" {{if .Language}}lang="{{.Language.String}}"{{end}} dir="{{.Direction}}">{{.Excerpt}}</div>

	<a class="read-more" href="{{if .Collection}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}">{{localstr "Read more..." .Language.String}}</a>{{else}}<div class="e-content preview" {{if .Language}}lang="{{.Language.String}}"{{end}} dir="{{.Direction}}">{{ if not .HTMLContent }}<p id="post-body" class="e-content preview">{{.Content}}</p>{{ else }}{{.HTMLContent}}{{ end }}<div class="over"> </div></div>

	<a class="read-more maybe" href="{{if .Collection}}{{.Collection.CanonicalURL}}{{.Slug.String}}{{else}}{{.CanonicalURL .Host}}.md{{end}}">{{localstr "Read more..." .Language.String}}</a>{{end}}</article>
	{{end}}
	</section>
	{{ else }}
	<div class="attention-box">
	<p>No posts here yet!</p>
	</div>
	{{ end }}

	{{if gt .TotalPages 1}}<nav id="paging" class="content-container clearfix">
	{{if lt .CurrentPage .TotalPages}}<a href="{{.NextPageURL .CurrentPage}}">⇠ Older</a>{{end}}
	{{if gt .CurrentPage 1}}<a style="float:right;" href="{{.PrevPageURL .CurrentPage}}">Newer ⇢</a>{{end}}
	</nav>{{end}}

	</div>
	<script src="/js/localdate.js">
	<script type="text/javascript">
	(function() {
	var $articles = document.querySelectorAll('article');
	for (var i=0; i<$articles.length; i++) {
	var $art = $articles[i];
	var $more = $art.querySelector('.read-more.maybe');
	if ($more != null) {
	if ($art.querySelector('.e-content.preview').clientHeight < 180) {
	$more.parentNode.removeChild($more);
	var $overlay = $art.querySelector('.over');
	$overlay.parentNode.removeChild($overlay);
	}
	}
	}
	})();
	</script>
	{{end}}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jan 31, 12:18 PM (4 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3145740

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions