Notes2/node.go

package main

import (
	// External
	"github.com/jmoiron/sqlx"

	// Standard
	"database/sql"
	"time"
)

type ChecklistItem struct {
	ID      int
	GroupID int `db:"checklist_group_id"`
	Order   int
	Label   string
	Checked bool
}

type ChecklistGroup struct {
	ID     int
	NodeID int `db:"node_id"`
	Order  int
	Label  string
	Items  []ChecklistItem
}

type TreeNode struct {
	UUID       string
	ParentUUID string `db:"parent_uuid"`
	Name       string
	Created    time.Time
	Updated    time.Time
	Deleted    bool
	CreatedSeq uint64        `db:"created_seq"`
	UpdatedSeq uint64        `db:"updated_seq"`
	DeletedSeq sql.NullInt64 `db:"deleted_seq"`
}

type Node struct {
	ID          int
	UserID      int `db:"user_id"`
	ParentID    int `db:"parent_id"`
	CryptoKeyID int `db:"crypto_key_id"`
	Name        string
	Content     string
	Updated     time.Time
	Children    []Node
	Crumbs      []Node
	Files       []File
	Complete    bool
	Level       int

	ChecklistGroups []ChecklistGroup

	ContentEncrypted string `db:"content_encrypted" json:"-"`
	Markdown         bool
}

func NodeTree(userID int, synced uint64) (nodes []TreeNode, maxSeq uint64, err error) { // {{{
	var rows *sqlx.Rows
	rows, err = db.Queryx(`
		SELECT
			uuid,
			COALESCE(parent_uuid, '') AS parent_uuid,
			name,
			created,
			updated,
			deleted IS NOT NULL AS deleted,
			created_seq,
			updated_seq,
			deleted_seq
		FROM
			public.node
		WHERE
			user_id = $1 AND (
				created_seq > $2 OR
				updated_seq > $2 OR
				deleted_seq > $2
			)
		ORDER BY
			created ASC
		`,
		userID,
		synced,
	)
	if err != nil {
		return
	}
	defer rows.Close()

	type resultRow struct {
		Node
		Level int
	}

	nodes = []TreeNode{}
	for rows.Next() {
		node := TreeNode{}
		if err = rows.StructScan(&node); err != nil {
			return
		}
		nodes = append(nodes, node)
		maxSeq = max(maxSeq, node.CreatedSeq, node.UpdatedSeq, uint64(node.DeletedSeq.Int64))
	}

	return
} // }}}
func RetrieveNode(userID, nodeID int) (node Node, err error) { // {{{
	if nodeID == 0 {
		return RootNode(userID)
	}

	var rows *sqlx.Rows
	rows, err = db.Queryx(`
		WITH RECURSIVE recurse AS (
			SELECT
				id,
				user_id,
				COALESCE(parent_id, 0) AS parent_id,
				COALESCE(crypto_key_id, 0) AS crypto_key_id,
				name,
				content,
				content_encrypted,
				markdown,
				0 AS level
			FROM node
			WHERE
				user_id = $1 AND
				id = $2
			
			UNION
			
			SELECT
				n.id,
				n.user_id,
				n.parent_id,
				COALESCE(n.crypto_key_id, 0) AS crypto_key_id,
				n.name,
				'' AS content,
				'' AS content_encrypted,
				false AS markdown,
				r.level + 1 AS level
			FROM node n
			INNER JOIN recurse r ON n.parent_id = r.id AND r.level = 0
			WHERE
				n.user_id = $1
		)

		SELECT * FROM recurse ORDER BY level ASC
		`,
		userID,
		nodeID,
	)
	if err != nil {
		return
	}
	defer rows.Close()

	type resultRow struct {
		Node
		Level int
	}

	node = Node{}
	node.Children = []Node{}
	for rows.Next() {
		row := resultRow{}
		if err = rows.StructScan(&row); err != nil {
			return
		}

		if row.Level == 0 {
			node.ID = row.ID
			node.UserID = row.UserID
			node.ParentID = row.ParentID
			node.CryptoKeyID = row.CryptoKeyID
			node.Name = row.Name
			node.Complete = true
			node.Markdown = row.Markdown

			if node.CryptoKeyID > 0 {
				node.Content = row.ContentEncrypted
			} else {
				node.Content = row.Content
			}

			node.retrieveChecklist()
		}

		if row.Level == 1 {
			node.Children = append(node.Children, Node{
				ID:          row.ID,
				UserID:      row.UserID,
				ParentID:    row.ParentID,
				CryptoKeyID: row.CryptoKeyID,
				Name:        row.Name,
			})
		}
	}

	node.Crumbs, err = NodeCrumbs(node.ID)
	node.Files, err = Files(userID, node.ID, 0)

	return
} // }}}
func RootNode(userID int) (node Node, err error) { // {{{
	var rows *sqlx.Rows
	rows, err = db.Queryx(`
			SELECT
				id,
				user_id,
				0 AS parent_id,
				name
			FROM node
			WHERE
				user_id = $1 AND
				parent_id IS NULL
		`,
		userID,
	)
	if err != nil {
		return
	}
	defer rows.Close()

	node.Name = "Start"
	node.UserID = userID
	node.Complete = true
	node.Children = []Node{}
	node.Crumbs = []Node{}
	node.Files = []File{}
	for rows.Next() {
		row := Node{}
		if err = rows.StructScan(&row); err != nil {
			return
		}

		node.Children = append(node.Children, Node{
			ID:       row.ID,
			UserID:   row.UserID,
			ParentID: row.ParentID,
			Name:     row.Name,
		})
	}

	return
} // }}}
func (node *Node) retrieveChecklist() (err error) { // {{{
	var rows *sqlx.Rows
	rows, err = db.Queryx(`
		SELECT
			g.id AS group_id,
			g.order AS group_order,
			g.label AS group_label,

			COALESCE(i.id, 0) AS item_id,
			COALESCE(i.order, 0) AS item_order,
			COALESCE(i.label, '') AS item_label,
			COALESCE(i.checked, false) AS checked

		FROM public.checklist_group g
		LEFT JOIN public.checklist_item i ON i.checklist_group_id = g.id
		WHERE
			g.node_id = $1
		ORDER BY
			g.order DESC,
			i.order DESC
	`, node.ID)
	if err != nil {
		return
	}
	defer rows.Close()

	groups := make(map[int]*ChecklistGroup)
	var found bool
	var group *ChecklistGroup
	var item ChecklistItem
	for rows.Next() {
		row := struct {
			GroupID    int    `db:"group_id"`
			GroupOrder int    `db:"group_order"`
			GroupLabel string `db:"group_label"`

			ItemID    int    `db:"item_id"`
			ItemOrder int    `db:"item_order"`
			ItemLabel string `db:"item_label"`
			Checked   bool
		}{}
		err = rows.StructScan(&row)
		if err != nil {
			return
		}

		if group, found = groups[row.GroupID]; !found {
			group = new(ChecklistGroup)
			group.ID = row.GroupID
			group.NodeID = node.ID
			group.Order = row.GroupOrder
			group.Label = row.GroupLabel
			group.Items = []ChecklistItem{}
			groups[group.ID] = group
		}

		item = ChecklistItem{}
		item.ID = row.ItemID
		item.GroupID = row.GroupID
		item.Order = row.ItemOrder
		item.Label = row.ItemLabel
		item.Checked = row.Checked

		if item.ID > 0 {
			group.Items = append(group.Items, item)
		}
	}

	node.ChecklistGroups = []ChecklistGroup{}
	for _, group := range groups {
		node.ChecklistGroups = append(node.ChecklistGroups, *group)
	}

	return
} // }}}
func NodeCrumbs(nodeID int) (nodes []Node, err error) { // {{{
	var rows *sqlx.Rows
	rows, err = db.Queryx(`
		WITH RECURSIVE nodes AS (
			SELECT
				id,
				COALESCE(parent_id, 0) AS parent_id,
				name
			FROM node
			WHERE
				id = $1

			UNION
			
			SELECT
				n.id,
				COALESCE(n.parent_id, 0) AS parent_id,
				n.name
			FROM node n
			INNER JOIN nodes nr ON n.id = nr.parent_id
		)
		SELECT * FROM nodes
	`, nodeID)
	if err != nil {
		return
	}
	defer rows.Close()

	nodes = []Node{}
	for rows.Next() {
		node := Node{}
		if err = rows.StructScan(&node); err != nil {
			return
		}
		nodes = append(nodes, node)
	}
	return
} // }}}