ZenTasktic package

During implementation, it became obvious that we need to move storage outside the package (packages deployed under p/ cannot store state) and into the realm calling the package. We wanted to maintain the logic separated, though, to follow the ADD workflow. We refactored by creating a manager for each data type (Tasks, Projects, Realms, etc) which returns an avl.Tree that is responsible with the storage in the calling realm.

package zentasktic

import (
	"time"

	"gno.land/p/demo/avl"
)

type Task struct {
	Id 			string `json:"taskId"`
	ProjectId 	string `json:"taskProjectId"`
	ContextId	string `json:"taskContextId"`
	RealmId 	string `json:"taskRealmId"`
	Body 		string `json:"taskBody"`
	Due			string `json:"taskDue"`
	Alert		string `json:"taskAlert"`
}

type ZTaskManager struct {
	Tasks *avl.Tree
}

func NewZTaskManager() *ZTaskManager {
	return &ZTaskManager{
		Tasks: avl.NewTree(),
	}
}

// actions

func (ztm *ZTaskManager) AddTask(t Task) error {
	if ztm.Tasks.Size() != 0 {
		_, exist := ztm.Tasks.Get(t.Id)
		if exist {
			return ErrTaskIdAlreadyExists
		}
	}
	ztm.Tasks.Set(t.Id, t)
	return nil
}

key takeaway: storing data in packages is not ok, there must be a clear separation between logic and state storage.

ZenTasktic Gno realms

The 3 realms deployed are implemeting the same type of workflow, but with different data types.

The basic one, ZenTasktic Core, has just the basic data types defined in the ZenTasktic package.

The ZenTasktic Project realm is multi-user (has Users which can be allocated to Teams) and Rewards.

The ZenTasktic User realm is a barebone realm suitable for an individual tracking his work on potentially more customers.

ZenTasktic Project

This realm has 3 more data types: Users (Actors), Teams and Points. These are hinting towards a type of task / project which can be worked on, individually, or in a team, for a certain reward. We added a Workable interface, which allows, for instance, to implement specific Tasks as WorkableTasks, and new data types, like WorkDurations (can be expressed in hours, work hours, etc).

Here is a snippet from the current implementation:

type Workable interface {
	// restrict implementation of Workable to this realm
	assertWorkable()
}

type isWorkable struct {}

type WorkableTask struct {
    zentasktic.Task
}

func (wt *WorkableTask) assertWorkable() {}

type WorkableProject struct {
    zentasktic.Project
}

func (wp *WorkableProject) assertWorkable() {}

var _ Workable = &WorkableTask{}
var _ Workable = &WorkableProject{}

type WorkDuration struct {
	Id				string `json:"workDurationId"`
    ObjectId 		string `json:"objectId"`
    ObjectType      string `json:"objectType"` // Task, Project
	Duration  		time.Duration `json:"workDuration"`
	Workable   		Workable      `json:"-"`
}

The main logic is implemented using these types, so I wrote an additional wrapper on top of that, which can be invoked by an external client which needs marshalled data. Here is an implementation example:

in the actor.gno file:


type Actor struct {
	Id      string      `json:"actorId"`
	Name    string      `json:"actorName"`
	Address std.Address `json:"actorAddress"`
}

var (
	Actors        []*Actor
	ActorTeams    map[string][]*Team
	ActorTasks    map[string][]*WorkableTask
	ActorProjects map[string][]*WorkableProject
)

// Initialize global maps
func init() {
	ActorTeams = make(map[string][]*Team)
	ActorTasks = make(map[string][]*WorkableTask)
	ActorProjects = make(map[string][]*WorkableProject)
}

// AddActor adds a new actor to the Actors slice
func (a *Actor) AddActor() error {
	if _, exist := GetActorById(a.Id); exist == nil {
		return errors.New("actor ID already exists")
	}
	Actors = append(Actors, a)
	return nil
}

in the actor_wrapper.gno file:

var currentUserID int

func init() {
	currentUserID = 0
}

// users

func AddActorWrap(userName string, userAddress string) error {
	userID := incrementUserID()
	a := &Actor{
		Id:          strconv.Itoa(userID),
		Name:        userName,
		Address: 	 std.Address(userAddress),
	}
	return a.AddActor()
}

ZenTasktic UI

The UI can be accessed at https://gno.zentasktic.com. There is a main dashboard with links for each realm UI. Underneath there is a next.js implementation, with gno-js library for calls and wallet interaction.