Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Playground

gnomod.toml

module = "gno.land/r/demo/profile"
gno = "0.9"

[addpkg]
  creator = "g1edq4dugw0sgat4zxcw9xardvuydqf6cgleuc8p"

profile.gno

package profile

import (
	"chain"

	"gno.land/p/nt/avl/v0"
	"gno.land/p/nt/mux/v0"
	"gno.land/p/nt/ufmt/v0"
)

var (
	fields = avl.NewTree()
	router = mux.NewRouter()
)

// Standard fields
const (
	DisplayName        = "DisplayName"
	Homepage           = "Homepage"
	Bio                = "Bio"
	Age                = "Age"
	Location           = "Location"
	Avatar             = "Avatar"
	GravatarEmail      = "GravatarEmail"
	AvailableForHiring = "AvailableForHiring"
	InvalidField       = "InvalidField"
)

// Events
const (
	ProfileFieldCreated = "ProfileFieldCreated"
	ProfileFieldUpdated = "ProfileFieldUpdated"
)

// Field types used when emitting event
const FieldType = "FieldType"

const (
	BoolField   = "BoolField"
	StringField = "StringField"
	IntField    = "IntField"
)

func init() {
	router.HandleFunc("", homeHandler)
	router.HandleFunc("u/{addr}", profileHandler)
	router.HandleFunc("f/{addr}/{field}", fieldHandler)
}

// List of supported string fields
var stringFields = map[string]bool{
	DisplayName:   true,
	Homepage:      true,
	Bio:           true,
	Location:      true,
	Avatar:        true,
	GravatarEmail: true,
}

// List of support int fields
var intFields = map[string]bool{
	Age: true,
}

// List of support bool fields
var boolFields = map[string]bool{
	AvailableForHiring: true,
}

// Setters

func SetStringField(cur realm, field, value string) bool {
	addr := cur.Previous().Address()
	key := addr.String() + ":" + field
	updated := fields.Set(key, value)

	event := ProfileFieldCreated
	if updated {
		event = ProfileFieldUpdated
	}

	chain.Emit(event, FieldType, StringField, field, value)

	return updated
}

func SetIntField(cur realm, field string, value int) bool {
	addr := cur.Previous().Address()
	key := addr.String() + ":" + field
	updated := fields.Set(key, value)

	event := ProfileFieldCreated
	if updated {
		event = ProfileFieldUpdated
	}

	chain.Emit(event, FieldType, IntField, field, string(value))

	return updated
}

func SetBoolField(cur realm, field string, value bool) bool {
	addr := cur.Previous().Address()
	key := addr.String() + ":" + field
	updated := fields.Set(key, value)

	event := ProfileFieldCreated
	if updated {
		event = ProfileFieldUpdated
	}

	chain.Emit(event, FieldType, BoolField, field, ufmt.Sprintf("%t", value))

	return updated
}

// Getters

func GetStringField(addr address, field, def string) string {
	key := addr.String() + ":" + field
	if value := fields.Get(key); value != nil {
		return value.(string)
	}

	return def
}

func GetBoolField(addr address, field string, def bool) bool {
	key := addr.String() + ":" + field
	if value := fields.Get(key); value != nil {
		return value.(bool)
	}

	return def
}

func GetIntField(addr address, field string, def int) int {
	key := addr.String() + ":" + field
	if value := fields.Get(key); value != nil {
		return value.(int)
	}

	return def
}

profile_test.gno

package profile

import (
	"testing"

	"gno.land/p/nt/testutils/v0"
	"gno.land/p/nt/uassert/v0"
)

// Global addresses for test users
var (
	alice   = testutils.TestAddress("alice")
	bob     = testutils.TestAddress("bob")
	charlie = testutils.TestAddress("charlie")
	dave    = testutils.TestAddress("dave")
	eve     = testutils.TestAddress("eve")
	frank   = testutils.TestAddress("frank")
	user1   = testutils.TestAddress("user1")
	user2   = testutils.TestAddress("user2")
)

func TestStringFields(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(alice))

	// Get before setting
	name := GetStringField(alice, DisplayName, "anon")
	uassert.Equal(t, "anon", name)

	// Set new key
	updated := SetStringField(cross(cur), DisplayName, "Alice foo")
	uassert.Equal(t, updated, false)
	updated = SetStringField(cross(cur), Homepage, "https://example.com")
	uassert.Equal(t, updated, false)

	// Update the key
	updated = SetStringField(cross(cur), DisplayName, "Alice foo")
	uassert.Equal(t, updated, true)

	// Get after setting
	name = GetStringField(alice, DisplayName, "anon")
	homepage := GetStringField(alice, Homepage, "")
	bio := GetStringField(alice, Bio, "42")

	uassert.Equal(t, "Alice foo", name)
	uassert.Equal(t, "https://example.com", homepage)
	uassert.Equal(t, "42", bio)
}

func TestIntFields(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(bob))

	// Get before setting
	age := GetIntField(bob, Age, 25)
	uassert.Equal(t, 25, age)

	// Set new key
	updated := SetIntField(cross(cur), Age, 30)
	uassert.Equal(t, updated, false)

	// Update the key
	updated = SetIntField(cross(cur), Age, 30)
	uassert.Equal(t, updated, true)

	// Get after setting
	age = GetIntField(bob, Age, 25)
	uassert.Equal(t, 30, age)
}

func TestBoolFields(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(charlie))

	// Get before setting
	hiring := GetBoolField(charlie, AvailableForHiring, false)
	uassert.Equal(t, false, hiring)

	// Set
	updated := SetBoolField(cross(cur), AvailableForHiring, true)
	uassert.Equal(t, updated, false)

	// Update the key
	updated = SetBoolField(cross(cur), AvailableForHiring, true)
	uassert.Equal(t, updated, true)

	// Get after setting
	hiring = GetBoolField(charlie, AvailableForHiring, false)
	uassert.Equal(t, true, hiring)
}

func TestMultipleProfiles(cur realm, t *testing.T) {
	// Set profile for user1
	testing.SetRealm(testing.NewUserRealm(user1))
	updated := SetStringField(cross(cur), DisplayName, "User One")
	uassert.Equal(t, updated, false)

	// Set profile for user2
	testing.SetRealm(testing.NewUserRealm(user2))
	updated = SetStringField(cross(cur), DisplayName, "User Two")
	uassert.Equal(t, updated, false)

	// Get profiles
	testing.SetRealm(testing.NewUserRealm(user1)) // Switch back to user1
	name1 := GetStringField(user1, DisplayName, "anon")
	testing.SetRealm(testing.NewUserRealm(user2)) // Switch back to user2
	name2 := GetStringField(user2, DisplayName, "anon")

	uassert.Equal(t, "User One", name1)
	uassert.Equal(t, "User Two", name2)
}

func TestArbitraryStringField(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(user1))

	// Set arbitrary string field
	updated := SetStringField(cross(cur), "MyEmail", "[email protected]")
	uassert.Equal(t, updated, false)

	val := GetStringField(user1, "MyEmail", "")
	uassert.Equal(t, val, "[email protected]")
}

func TestArbitraryIntField(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(user1))

	// Set arbitrary int field
	updated := SetIntField(cross(cur), "MyIncome", 100_000)
	uassert.Equal(t, updated, false)

	val := GetIntField(user1, "MyIncome", 0)
	uassert.Equal(t, val, 100_000)
}

func TestArbitraryBoolField(cur realm, t *testing.T) {
	testing.SetRealm(testing.NewUserRealm(user1))

	// Set arbitrary bool field
	updated := SetBoolField(cross(cur), "IsWinner", true)
	uassert.Equal(t, updated, false)

	val := GetBoolField(user1, "IsWinner", false)
	uassert.Equal(t, val, true)
}

render.gno

package profile

import (
	"bytes"
	"net/url"

	"gno.land/p/nt/mux/v0"
	"gno.land/p/nt/ufmt/v0"
)

const (
	BaseURL           = "/r/demo/profile"
	SetStringFieldURL = BaseURL + "$help&func=SetStringField&field=%s"
	SetIntFieldURL    = BaseURL + "$help&func=SetIntField&field=%s"
	SetBoolFieldURL   = BaseURL + "$help&func=SetBoolField&field=%s"
	ViewAllFieldsURL  = BaseURL + ":u/%s"
	ViewFieldURL      = BaseURL + ":f/%s/%s"
)

func homeHandler(res *mux.ResponseWriter, req *mux.Request) {
	var b bytes.Buffer

	b.WriteString("## Setters\n")
	for field := range stringFields {
		link := ufmt.Sprintf(SetStringFieldURL, field)
		b.WriteString(ufmt.Sprintf("- [Set %s](%s)\n", field, link))
	}

	for field := range intFields {
		link := ufmt.Sprintf(SetIntFieldURL, field)
		b.WriteString(ufmt.Sprintf("- [Set %s](%s)\n", field, link))
	}

	for field := range boolFields {
		link := ufmt.Sprintf(SetBoolFieldURL, field)
		b.WriteString(ufmt.Sprintf("- [Set %s Field](%s)\n", field, link))
	}

	b.WriteString("\n---\n\n")

	res.Write(b.String())
}

func profileHandler(res *mux.ResponseWriter, req *mux.Request) {
	var b bytes.Buffer
	addr := req.GetVar("addr")

	b.WriteString(ufmt.Sprintf("# Profile %s\n", addr))

	address_XXX := address(addr)

	for field := range stringFields {
		value := GetStringField(address_XXX, field, "n/a")
		link := ufmt.Sprintf(SetStringFieldURL, field)
		b.WriteString(ufmt.Sprintf("- %s: %s [Edit](%s)\n", field, value, link))
	}

	for field := range intFields {
		value := GetIntField(address_XXX, field, 0)
		link := ufmt.Sprintf(SetIntFieldURL, field)
		b.WriteString(ufmt.Sprintf("- %s: %d [Edit](%s)\n", field, value, link))
	}

	for field := range boolFields {
		value := GetBoolField(address_XXX, field, false)
		link := ufmt.Sprintf(SetBoolFieldURL, field)
		b.WriteString(ufmt.Sprintf("- %s: %t [Edit](%s)\n", field, value, link))
	}

	res.Write(b.String())
}

func fieldHandler(res *mux.ResponseWriter, req *mux.Request) {
	var b bytes.Buffer
	addr := req.GetVar("addr")
	field := req.GetVar("field")

	b.WriteString(ufmt.Sprintf("# Field %s for %s\n", field, addr))

	address_XXX := address(addr)
	value := "n/a"
	var editLink string

	if _, ok := stringFields[field]; ok {
		value = ufmt.Sprintf("%s", GetStringField(address_XXX, field, "n/a"))
		editLink = ufmt.Sprintf(SetStringFieldURL+"&addr=%s&value=%s", field, addr, url.QueryEscape(value))
	} else if _, ok := intFields[field]; ok {
		value = ufmt.Sprintf("%d", GetIntField(address_XXX, field, 0))
		editLink = ufmt.Sprintf(SetIntFieldURL+"&addr=%s&value=%s", field, addr, value)
	} else if _, ok := boolFields[field]; ok {
		value = ufmt.Sprintf("%t", GetBoolField(address_XXX, field, false))
		editLink = ufmt.Sprintf(SetBoolFieldURL+"&addr=%s&value=%s", field, addr, value)
	}

	b.WriteString(ufmt.Sprintf("- %s: %s [Edit](%s)\n", field, value, editLink))

	res.Write(b.String())
}

func Render(path string) string {
	return router.Render(path)
}