feat(examples): forms

examples/gno.land/p/demo/forms/README.md

@@ -0,0 +1,24 @@
+# Gno forms
+
+gno-forms is a package which demonstrates a form editing and sharing application in gno
+
+## Features
+- **Form Creation**: Create new forms with specified titles, descriptions, and fields.
+- **Form Submission**: Submit answers to forms.
+- **Form Retrieval**: Retrieve existing forms and their submissions.
+- **Form Deadline**: Set a precise time range during which a form can be interacted with.
+
+## Field Types
+The system supports the following field types:
+
+type|example
+-|-
+string|`{"label": "Name", "fieldType": "string", "required": true}`
+number|`{"label": "Age", "fieldType": "number", "required": true}`
+boolean|`{"label": "Is Student?", "fieldType": "boolean", "required": false}`
+choice|`{"label": "Favorite Food", "fieldType": "['Pizza', 'Schnitzel', 'Burger']", "required": true}`
+multi-choice|`{"label": "Hobbies", "fieldType": "{'Reading', 'Swimming', 'Gaming'}", "required": false}`
+
+## Web-app
+
+The external repo where the initial development took place and where you can find the frontend is [here](https://github.com/agherasie/gno-forms). 

examples/gno.land/p/demo/forms/create.gno

@@ -0,0 +1,95 @@
+package forms
+
+import (
+	"std"
+	"time"
+
+	"gno.land/p/demo/json"
+	"gno.land/p/demo/ufmt"
+)
+
+func CreateField(label string, fieldType string, required bool) Field {
+	return Field{
+		Label:     label,
+		FieldType: fieldType,
+		Required:  required,
+	}
+}
+
+func ParseDates(openAt string, closeAt string) (*time.Time, *time.Time) {
+	var openAtTime, closeAtTime *time.Time
+
+	dateFormat := "2006-01-02T15:04:05Z"
+
+	// Parse openAt if it's not empty
+	if openAt != "" {
+		res, err := time.Parse(dateFormat, openAt)
+		if err != nil {
+			panic(ufmt.Errorf("invalid date: %v", openAt))
+		}
+		openAtTime = &res
+	}
+
+	// Parse closeAt if it's not empty
+	if closeAt != "" {
+		res, err := time.Parse(dateFormat, closeAt)
+		if err != nil {
+			panic(ufmt.Errorf("invalid date: %v", closeAt))
+		}
+		closeAtTime = &res
+	}
+
+	return openAtTime, closeAtTime
+}
+
+func (db *FormDatabase) CreateForm(title string, description string, openAt string, closeAt string, data string) string {
+	// Parsing dates
+	openAtTime, closeAtTime := ParseDates(openAt, closeAt)
+
+	// Parsing the json submission
+	node, err := json.Unmarshal([]byte(data))
+	if err != nil {
+		ufmt.Errorf("invalid json: %v", err)
+	}
+
+	fieldsCount := node.Size()
+	fields := make([]Field, fieldsCount)
+
+	// Parsing the json submission to create the gno data structures
+	for i := 0; i < fieldsCount; i++ {
+		field, err := node.GetIndex(i)
+		if err != nil {
+			ufmt.Errorf("error: %v", err)
+		}
+
+		labelNode, _ := field.GetKey("label")
+		fieldTypeNode, _ := field.GetKey("fieldType")
+		requiredNode, _ := field.GetKey("required")
+
+		label, _ := labelNode.GetString()
+		fieldType, _ := fieldTypeNode.GetString()
+		required, _ := requiredNode.GetBool()
+
+		fields[i] = CreateField(label, fieldType, required)
+	}
+
+	// Generating the form ID
+	id := db.IDCounter.Next().String()
+
+	// Creating the form
+	form := Form{
+		ID:          id,
+		Owner:       std.PrevRealm().Addr(),
+		Title:       title,
+		Description: description,
+		CreatedAt:   time.Now(),
+		openAt:      openAtTime,
+		closeAt:     closeAtTime,
+		Fields:      fields,
+	}
+
+	// Adding the form to the database
+	db.Forms = append(db.Forms, &form)
+
+	return id
+}

examples/gno.land/p/demo/forms/create_test.gno

@@ -0,0 +1,81 @@
+package forms
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/p/demo/testutils"
+)
+
+func TestCreateForm(t *testing.T) {
+	alice := testutils.TestAddress("alice")
+	std.TestSetOrigCaller(alice)
+
+	title := "Simple Form"
+	description := "This is a form"
+	openAt := "2021-01-01T00:00:00Z"
+	closeAt := "2021-01-02T00:00:00Z"
+	data := `[
+		{
+			"label": "Name",
+			"fieldType": "string",
+			"required": true
+		},
+		{
+			"label": "Age",
+			"fieldType": "number",
+			"required": false
+		},
+		{
+			"label": "Is this a test?",
+			"fieldType": "boolean",
+			"required": false
+		},
+		{
+			"label": "Favorite Food",
+			"fieldType": "['Pizza', 'Schnitzel', 'Burger']",
+			"required": true
+		},
+		{
+			"label": "Favorite Foods",
+			"fieldType": "{'Pizza', 'Schnitzel', 'Burger'}",
+			"required": true
+		}
+	]`
+	db := NewDatabase()
+	id := db.CreateForm(title, description, openAt, closeAt, data)
+	if id == "" {
+		t.Error("Form ID is empty")
+	}
+	form := db.GetForm(id)
+	if form == nil {
+		t.Error("Form is nil")
+	}
+	if form.Owner != alice {
+		t.Error("Owner is not correct")
+	}
+	if form.Title != title {
+		t.Error("Title is not correct")
+	}
+	if form.Description != description {
+		t.Error("Description is not correct")
+	}
+	if len(form.Fields) != 5 {
+		t.Error("Fields are not correct")
+	}
+	if form.Fields[0].Label != "Name" {
+		t.Error("Field 0 label is not correct")
+	}
+	if form.Fields[0].FieldType != "string" {
+		t.Error("Field 0 type is not correct")
+	}
+	if form.Fields[0].Required != true {
+		t.Error("Field 0 required is not correct")
+	}
+	if form.Fields[1].Label != "Age" {
+		t.Error("Field 1 label is not correct")
+	}
+	if form.Fields[1].FieldType != "number" {
+		t.Error("Field 1 type is not correct")
+	}
+}

examples/gno.land/p/demo/forms/forms.gno

@@ -0,0 +1,131 @@
+package forms
+
+import (
+	"errors"
+	"std"
+	"time"
+
+	"gno.land/p/demo/seqid"
+)
+
+type Field struct {
+	Label string
+
+	/*
+		string: "string";
+		number: "number";
+		boolean: "boolean";
+		choice: "['Pizza', 'Schnitzel', 'Burger']";
+		multi-choice: "{'Pizza', 'Schnitzel', 'Burger'}";
+	*/
+	FieldType string
+
+	Required bool
+}
+
+type Form struct {
+	ID    string
+	Owner std.Address
+
+	Title       string
+	Description string
+	Fields      []Field
+
+	CreatedAt time.Time
+	openAt    *time.Time
+	closeAt   *time.Time
+}
+
+type Submission struct {
+	FormID string
+
+	Author std.Address
+
+	/* ["Alex", 21, true, 0, [0, 1]] */
+	Answers string // json
+
+	SubmittedAt time.Time
+}
+
+type FormDatabase struct {
+	Forms []*Form
+
+	Answers []*Submission
+
+	IDCounter seqid.ID
+}
+
+func NewDatabase() *FormDatabase {
+	return &FormDatabase{
+		Forms:   make([]*Form, 0),
+		Answers: make([]*Submission, 0),
+	}
+}
+
+func (form *Form) IsOpen() bool {
+	openAt, errOpen := form.OpenAt()
+	closedAt, errClose := form.CloseAt()
+
+	noOpenDate := errOpen != nil
+	noCloseDate := errClose != nil
+
+	if noOpenDate && noCloseDate {
+		return true
+	}
+
+	if noOpenDate && !noCloseDate {
+		return time.Now().Before(closedAt)
+	}
+
+	if !noOpenDate && noCloseDate {
+		return time.Now().After(openAt)
+	}
+
+	return time.Now().After(openAt) && time.Now().Before(closedAt)
+}
+
+func (form *Form) OpenAt() (time.Time, error) {
+	if form.openAt == nil {
+		return time.Time{}, errors.New("Form has no open date")
+	}
+
+	return *form.openAt, nil
+}
+
+func (form *Form) CloseAt() (time.Time, error) {
+	if form.closeAt == nil {
+		return time.Time{}, errors.New("Form has no close date")
+	}
+
+	return *form.closeAt, nil
+}
+
+func (db *FormDatabase) GetForm(id string) *Form {
+	for _, form := range db.Forms {
+		if form.ID == id {
+			return form
+		}
+	}
+	return nil
+}
+
+func (db *FormDatabase) GetAnswer(formID string, author std.Address) *Submission {
+	for _, answer := range db.Answers {
+		if answer.FormID == formID && answer.Author.String() == author.String() {
+			return answer
+		}
+	}
+	return nil
+}
+
+func (db *FormDatabase) GetSubmissionsByFormID(formID string) []*Submission {
+	submissions := make([]*Submission, 0)
+
+	for _, answer := range db.Answers {
+		if answer.FormID == formID {
+			submissions = append(submissions, answer)
+		}
+	}
+
+	return submissions
+}

examples/gno.land/p/demo/forms/gno.mod

@@ -0,0 +1,7 @@
+module gno.land/p/demo/forms
+
+require (
+    gno.land/p/demo/ufmt v0.0.0-latest
+	gno.land/p/demo/seqid v0.0.0-latest
+    gno.land/p/demo/json v0.0.0-latest
+)

examples/gno.land/p/demo/forms/submit.gno

@@ -0,0 +1,41 @@
+package forms
+
+import (
+	"std"
+	"time"
+
+	"gno.land/p/demo/ufmt"
+)
+
+func (db *FormDatabase) SubmitForm(formID string, answers string) {
+	// Check if form exists
+	form := db.GetForm(formID)
+	if form == nil {
+		panic(ufmt.Errorf("Form not found: %s", formID))
+	}
+
+	// Check if form was already submitted by this user
+	previousAnswer := db.GetAnswer(formID, std.PrevRealm().Addr())
+	if previousAnswer != nil {
+		panic("You already submitted this form")
+	}
+
+	// Check time restrictions
+	if !form.IsOpen() {
+		panic("Form is closed")
+	}
+
+	// Check if answers are formatted correctly
+	if ValidateAnswers(answers, form.Fields) == false {
+		panic("Invalid answers")
+	}
+
+	// Save answers
+	answer := Submission{
+		FormID:      formID,
+		Answers:     answers,
+		Author:      std.PrevRealm().Addr(),
+		SubmittedAt: time.Now(),
+	}
+	db.Answers = append(db.Answers, &answer)
+}