Playground
gnomod.toml
module = "gno.land/r/moul/present/v0" gno = "0.9" [addpkg] creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5" height = 26347 max_deposit = "100000000ugnot"
present.gno
package present
import (
"net/url"
"strconv"
"strings"
"time"
"chain/runtime"
"gno.land/p/moul/md/v0"
"gno.land/p/moul/mdtable/v0"
"gno.land/p/moul/realmpath/v0"
"gno.land/p/moul/txlink/v0"
"gno.land/p/nt/avl/v0"
"gno.land/p/nt/avl/pager/v0"
"gno.land/p/nt/ownable/v0"
"gno.land/p/nt/seqid/v0"
"gno.land/p/nt/ufmt/v0"
)
var chainDomain = runtime.ChainDomain()
type Presentation struct {
id string
Slug string
Title string
Event string
Author string
Uploader address
Date time.Time
Content string
EditDate time.Time
NumSlides int
}
var (
byID avl.Tree // id -> *Presentation
bySlug avl.Tree // slug -> *Presentation
idgen seqid.ID
Ownable *ownable.Ownable
)
// owner is the realm admin allowed to add/update/delete presentations.
const owner address = "g1manfred47kzduec920z88wfr64ylksmdcedlf5" // @moul
func init() {
Ownable = ownable.NewWithAddress(owner)
}
// Render handles the realm's rendering logic
func Render(path string) string {
req := realmpath.Parse(path)
// Get slug from path
slug := req.PathPart(0)
// List view (home)
if slug == "" {
return renderList(req)
}
// Slides view
if req.PathPart(1) == "slides" {
page := 1
if pageStr := req.Query.Get("page"); pageStr != "" {
var err error
page, err = strconv.Atoi(pageStr)
if err != nil {
return "400: invalid page number"
}
}
return renderSlides(slug, page)
}
// Regular view
return renderView(slug)
}
// Set adds or updates a presentation
func Set(cur realm, slug, title, event, author, date, content string) string {
caller := cur.Previous().Address()
Ownable.AssertOwnedBy(caller)
return setPresentation(caller, slug, title, event, author, date, content)
}
// setPresentation is the shared record-mutation preamble used by both the
// owner-gated Set entrypoint and the init seeding.
func setPresentation(uploader address, slug, title, event, author, date, content string) string {
parsedDate, err := time.Parse("2006-01-02", date)
if err != nil {
return "400: invalid date format (expected: YYYY-MM-DD)"
}
numSlides := 1 // Count intro slide
for _, line := range strings.Split(content, "\n") {
if strings.HasPrefix(line, "## ") {
numSlides++
}
}
numSlides++ // Count thank you slide
// Reuse the existing id when the slug is already known (update in place).
var id string
if v := bySlug.Get(slug); v != nil {
id = v.(*Presentation).id
} else {
id = idgen.Next().String()
}
p := &Presentation{
id: id,
Slug: slug,
Title: title,
Event: event,
Author: author,
Uploader: uploader,
Date: parsedDate,
Content: content,
EditDate: time.Now(),
NumSlides: numSlides,
}
byID.Set(id, p)
bySlug.Set(slug, p)
return "presentation saved successfully"
}
// Delete removes a presentation
func Delete(cur realm, slug string) string {
Ownable.AssertOwnedBy(cur.Previous().Address())
v := bySlug.Get(slug)
if v == nil {
return "404: presentation not found"
}
p := v.(*Presentation)
// XXX: consider this:
// if p.Uploader != cur.Previous().Address() {
// return "401: unauthorized - only the uploader can delete their presentations"
// }
byID.Remove(p.id)
bySlug.Remove(slug)
return "presentation deleted successfully"
}
func renderList(req *realmpath.Request) string {
var out strings.Builder
out.WriteString(md.H1("Presentations"))
// Setup pager over a tree sorted by the requested field.
tree := buildSortTree(getSortField(req))
pgr := pager.NewPager(tree, 10, isSortReversed(req))
// Get current page. The pager only reads the query string; pass just the
// query so url.Parse is not tripped by the "/realm:slug" colon in the
// full realm path.
page := pgr.MustGetPageByPath("?" + req.Query.Encode())
// Create table
dateColumn := renderSortLink(req, "date", "Date")
titleColumn := renderSortLink(req, "title", "Title")
authorColumn := renderSortLink(req, "author", "Author")
table := mdtable.Table{
Headers: []string{dateColumn, titleColumn, "Event", authorColumn, "Slides"},
}
// Add rows from current page
for _, item := range page.Items {
p := item.Value.(*Presentation)
table.Append([]string{
p.Date.Format("2006-01-02"),
md.Link(p.Title, localPath(p.Slug, nil)),
p.Event,
p.Author,
ufmt.Sprintf("%d", p.NumSlides),
})
}
out.WriteString(table.String())
out.WriteString(page.Picker("?" + req.Query.Encode()))
return out.String()
}
// buildSortTree builds an avl.Tree whose keys order the presentations by the
// requested field. A trailing id keeps keys unique and makes ties
// deterministic (insertion order).
func buildSortTree(field string) *avl.Tree {
tree := avl.NewTree()
byID.Iterate("", "", func(id string, v any) bool {
p := v.(*Presentation)
var key string
switch field {
case "title":
key = p.Title + "\x00" + id
case "author":
key = p.Author + "\x00" + id
default: // date (and any unknown field)
key = p.Date.Format("2006-01-02") + "\x00" + id
}
tree.Set(key, p)
return false
})
return tree
}
func (p *Presentation) FirstSlide() string {
var out strings.Builder
out.WriteString(md.H1(p.Title))
out.WriteString(md.Paragraph(md.Bold(p.Event) + ", " + p.Date.Format("2 Jan 2006")))
out.WriteString(md.Paragraph("by " + md.Bold(p.Author))) // XXX: link to u/?
return out.String()
}
func (p *Presentation) LastSlide() string {
var out strings.Builder
out.WriteString(md.H1(p.Title))
out.WriteString(md.H2("Thank You!"))
out.WriteString(md.Paragraph(p.Author))
fullPath := "https://" + chainDomain + localPath(p.Slug, nil)
out.WriteString(md.Paragraph("🔗 " + md.Link(fullPath, fullPath)))
// XXX: QRCode
return out.String()
}
func renderView(slug string) string {
if slug == "" {
return "400: missing presentation slug"
}
v := bySlug.Get(slug)
if v == nil {
return "404: presentation not found"
}
p := v.(*Presentation)
var out strings.Builder
// Header using FirstSlide helper
out.WriteString(p.FirstSlide())
// Slide mode link
out.WriteString(md.Link("View as slides", localPath(p.Slug+"/slides", nil)) + "\n\n")
out.WriteString(md.HorizontalRule())
out.WriteString(md.Paragraph(p.Content))
// Metadata footer
out.WriteString(md.HorizontalRule())
out.WriteString(ufmt.Sprintf("Last edited: %s\n\n", p.EditDate.Format("2006-01-02 15:04:05")))
out.WriteString(ufmt.Sprintf("Uploader: `%s`\n\n", p.Uploader))
out.WriteString(ufmt.Sprintf("Number of slides: %d\n\n", p.NumSlides))
// Admin actions
// XXX: consider a dynamic toggle for admin actions
editLink := txlink.Call("Set",
"slug", p.Slug,
"title", p.Title,
"author", p.Author,
"event", p.Event,
"date", p.Date.Format("2006-01-02"),
)
deleteLink := txlink.Call("Delete", "slug", p.Slug)
out.WriteString(md.Paragraph(md.Link("Edit", editLink) + " | " + md.Link("Delete", deleteLink)))
return out.String()
}
// renderSlidesNavigation returns the navigation bar for slides
func renderSlidesNavigation(slug string, currentPage, totalSlides int) string {
var out strings.Builder
if currentPage > 1 {
prevLink := localPath(slug+"/slides", url.Values{"page": {ufmt.Sprintf("%d", currentPage-1)}})
out.WriteString(md.Link("← Prev", prevLink) + " ")
}
out.WriteString(ufmt.Sprintf("| %d/%d |", currentPage, totalSlides))
if currentPage < totalSlides {
nextLink := localPath(slug+"/slides", url.Values{"page": {ufmt.Sprintf("%d", currentPage+1)}})
out.WriteString(" " + md.Link("Next →", nextLink))
}
return md.Paragraph(out.String())
}
func renderSlides(slug string, currentPage int) string {
if slug == "" {
return "400: missing presentation ID"
}
v := bySlug.Get(slug)
if v == nil {
return "404: presentation not found"
}
p := v.(*Presentation)
slides := strings.Split("\n"+p.Content, "\n## ")
if currentPage < 1 || currentPage > p.NumSlides {
return "404: invalid slide number"
}
var out strings.Builder
// Display current slide
if currentPage == 1 {
out.WriteString(p.FirstSlide())
} else if currentPage == p.NumSlides {
out.WriteString(p.LastSlide())
} else {
out.WriteString(md.H1(p.Title))
out.WriteString("## " + slides[currentPage-1] + "\n\n")
}
out.WriteString(renderSlidesNavigation(slug, currentPage, p.NumSlides))
return out.String()
}
// Helper functions for sorting and pagination
func getSortField(req *realmpath.Request) string {
field := req.Query.Get("sort")
switch field {
case "date", "author", "title":
return field
}
return "date"
}
func isSortReversed(req *realmpath.Request) bool {
return req.Query.Get("order") != "asc"
}
func renderSortLink(req *realmpath.Request, field, label string) string {
currentField := getSortField(req)
currentOrder := req.Query.Get("order")
newOrder := "desc"
if field == currentField && currentOrder != "asc" {
newOrder = "asc"
}
query := req.Query
query.Set("sort", field)
query.Set("order", newOrder)
if field == currentField {
if newOrder == "asc" {
label += " ↑"
} else {
label += " ↓"
}
}
return md.Link(label, "?"+query.Encode())
}
// helper to create local realm links
func localPath(path string, query url.Values) string {
req := &realmpath.Request{
Path: path,
Query: query,
}
return req.String()
}
present_init.gno
package present
func init() {
_ = setPresentation(
Ownable.Owner(),
"demo", // slug
"Demo Slides", // title
"Demo Event", // event
"@demo", // author
"2025-02-02", // date
`## Slide One
- Point A
- Point B
- Point C
## Slide Two
- Feature 1
- Feature 2
- Feature 3
## Slide Three
- Next step
- Another step
- Final step`,
)
}