go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/controller/api.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package controller

import (
	"bytes"
	"compress/gzip"
	"context"
	"encoding/csv"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/wcharczuk/go-incr"
	"go.temporal.io/api/enums/v1"
	"go.temporal.io/api/failure/v1"
	"go.temporal.io/sdk/client"
	"go.temporal.io/sdk/temporal"

	"go.charczuk.com/projects/nodes/pkg/dbmodel"
	"go.charczuk.com/projects/nodes/pkg/incrutil"
	"go.charczuk.com/projects/nodes/pkg/types"
	"go.charczuk.com/projects/nodes/worker/workflows"
	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/iter"
	"go.charczuk.com/sdk/uuid"
	"go.charczuk.com/sdk/web"
)

type API struct {
	apputil.BaseController
	Temporal client.Client
	DB       *dbmodel.Manager
}

func (a API) Register(app *web.App) {
	app.Get("/api/v1/session", web.SessionAware(a.getSession))

	app.Get("/api/v1/graphs", web.SessionRequired(a.getGraphs))
	app.Get("/api/v1/graph/:graph_id", web.SessionRequired(a.getGraph))

	app.Get("/api/v1/workflow/:workflow_id/status/:run_id", web.SessionRequired(a.getWorkflowRunStatus))
	app.Post("/api/v1/workflow/:workflow_id/cancel/:run_id", web.SessionRequired(a.postWorkflowRunCancel))

	app.Get("/api/v1/graph.active", web.SessionRequired(a.getGraphActive))
	app.Post("/api/v1/graph", web.SessionRequired(a.postGraph))
	app.Patch("/api/v1/graph/:graph_id", web.SessionRequired(a.patchGraph))
	app.Delete("/api/v1/graph/:graph_id", web.SessionRequired(a.deleteGraph))

	app.Post("/api/v1/graph.load", web.SessionRequired(a.postGraphLoad))

	app.Get("/api/v1/graph/:graph_id/save", web.SessionRequired(a.getGraphSave))
	app.Get("/api/v1/graph/:graph_id/logs", web.SessionRequired(a.getGraphLogs))

	app.Get("/api/v1/graph/:graph_id/viewport", web.SessionRequired(a.getViewport))
	app.Put("/api/v1/graph/:graph_id/viewport", web.SessionRequired(a.putViewport))

	app.Post("/api/v1/graph/:graph_id/stabilize", web.SessionRequired(a.postStabilize))

	app.Post("/api/v1/graph/:graph_id/node", web.SessionRequired(a.postNode))
	app.Get("/api/v1/graph/:graph_id/node/:id", web.SessionRequired(a.getNode))
	app.Get("/api/v1/graph/:graph_id/nodes", web.SessionRequired(a.getNodes))
	app.Delete("/api/v1/graph/:graph_id/node/:id", web.SessionRequired(a.deleteNode))

	app.Post("/api/v1/graph/:graph_id/node.stale/:id", web.SessionRequired(a.postNodeStale))

	app.Get("/api/v1/graph/:graph_id/node.values", web.SessionRequired(a.getNodeValues))
	app.Get("/api/v1/graph/:graph_id/node.value/:id", web.SessionRequired(a.getNodeValue))
	app.Put("/api/v1/graph/:graph_id/node.value/:id", web.SessionRequired(a.putNodeValue))

	app.Get("/api/v1/graph/:graph_id/node.value.table/:id/info", web.SessionRequired(a.getNodeValueTableInfo))
	app.Get("/api/v1/graph/:graph_id/node.value.table/:id/range", web.SessionRequired(a.getNodeValueTableRange))
	app.Put("/api/v1/graph/:graph_id/node.value.table/:id", web.SessionRequired(a.putNodeValueTableOps))

	app.Get("/api/v1/graph/:graph_id/node.value.table/:id/csv", web.SessionRequired(a.getNodeValueTableExportCSV))
	app.Post("/api/v1/graph/:graph_id/node.value.table/:id/csv", web.SessionRequired(a.postNodeValueTableImportCSV))

	app.Patch("/api/v1/graph/:graph_id/nodes", web.SessionRequired(a.patchNodes))
	app.Patch("/api/v1/graph/:graph_id/node/:id", web.SessionRequired(a.patchNode))

	app.Get("/api/v1/graph/:graph_id/edges", web.SessionRequired(a.getEdges))
	app.Post("/api/v1/graph/:graph_id/edge", web.SessionRequired(a.postEdge))
	app.Delete("/api/v1/graph/:graph_id/edge", web.SessionRequired(a.deleteEdge))
}

func (a API) getStore(r web.Context) (*dbmodel.Store, *dbmodel.Graph, error) {
	graphID, err := getGraphID(r)
	if err != nil {
		return nil, nil, err
	}
	graph, found, err := a.DB.Graph(r, graphID)
	if err != nil {
		return nil, nil, err
	}
	if !found {
		return nil, nil, nil
	}
	if graph.UserID != a.GetUserID(r) {
		return nil, nil, nil
	}
	return &dbmodel.Store{
		GraphID: graph.ID,
		UserID:  graph.UserID,
		Model:   a.DB,
	}, &graph, nil
}

// getSession gets the session.
func (a API) getSession(r web.Context) web.Result {
	session := r.Session()
	if session == nil {
		return web.JSON().NotAuthorized()
	}
	return web.JSON().Result(http.StatusOK, session)
}

type workflowRunInfo struct {
	WorkflowID string `json:"workflow_id"`
	RunID      string `json:"run_id"`
}

func (a API) postStabilize(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	workflowRun, err := a.Temporal.ExecuteWorkflow(r, client.StartWorkflowOptions{
		TaskQueue:                "default",
		WorkflowExecutionTimeout: 120 * time.Second, // eat a worker restart potentially.
		RetryPolicy: &temporal.RetryPolicy{
			MaximumAttempts: 1, // only attempt the _workflow_ once!
		},
	}, workflows.Stabilize, workflows.StabilizeArgs{
		UserID:  store.UserID,
		GraphID: store.GraphID,
	})
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, workflowRunInfo{
		WorkflowID: workflowRun.GetID(),
		RunID:      workflowRun.GetRunID(),
	})
}

type workflowRunStatus struct {
	WorkflowID string           `json:"workflow_id"`
	RunID      string           `json:"run_id"`
	TaskQueue  string           `json:"task_queue"`
	Status     string           `json:"status"`
	StartTime  time.Time        `json:"start_time"`
	CloseTime  time.Time        `json:"close_time"`
	Failure    *failure.Failure `json:"failure"`
}

func (a API) workflowStatusIsFailure(status enums.WorkflowExecutionStatus) bool {
	switch status {
	case enums.WORKFLOW_EXECUTION_STATUS_FAILED, enums.WORKFLOW_EXECUTION_STATUS_TIMED_OUT:
		return true
	default:
		return false
	}
}

func (a API) getWorkflowRunCloseEvent(ctx context.Context, workflowID, runID string) (*failure.Failure, error) {
	historyIterator := a.Temporal.GetWorkflowHistory(ctx, workflowID, runID, false /*isLongPoll*/, enums.HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT)
	if !historyIterator.HasNext() {
		return nil, nil
	}
	history, err := historyIterator.Next()
	if err != nil {
		return nil, err
	}
	switch history.EventType {
	case enums.EVENT_TYPE_WORKFLOW_EXECUTION_FAILED:
		failedEventAttributes := history.GetWorkflowExecutionFailedEventAttributes()
		if failedEventAttributes == nil {
			return nil, nil
		}
		return failedEventAttributes.Failure, nil
	case enums.EVENT_TYPE_ACTIVITY_TASK_FAILED:
		failedEventAttributes := history.GetActivityTaskFailedEventAttributes()
		if failedEventAttributes == nil {
			return nil, nil
		}
		return failedEventAttributes.Failure, nil
	case enums.EVENT_TYPE_ACTIVITY_TASK_TIMED_OUT:
		timedOutEventAttributes := history.GetActivityTaskTimedOutEventAttributes()
		if timedOutEventAttributes == nil {
			return nil, nil
		}
		return timedOutEventAttributes.Failure, nil
	default:
		return nil, nil
	}
}

func (a API) getWorkflowRunStatus(r web.Context) web.Result {
	workflowID, err := web.RouteValue[string](r, "workflow_id")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	runID, err := web.RouteValue[string](r, "run_id")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	res, err := a.Temporal.DescribeWorkflowExecution(r, workflowID, runID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	var failure *failure.Failure
	if a.workflowStatusIsFailure(res.WorkflowExecutionInfo.GetStatus()) {
		failure, err = a.getWorkflowRunCloseEvent(r, workflowID, runID)
		if err != nil {
			return web.JSON().InternalError(err)
		}
	}
	return web.JSON().Result(http.StatusOK, workflowRunStatus{
		WorkflowID: workflowID,
		RunID:      runID,
		TaskQueue:  res.WorkflowExecutionInfo.GetTaskQueue(),
		Status:     res.WorkflowExecutionInfo.GetStatus().String(),
		StartTime:  res.WorkflowExecutionInfo.GetStartTime().AsTime(),
		CloseTime:  res.WorkflowExecutionInfo.GetCloseTime().AsTime(),
		Failure:    failure,
	})
}

func (a API) postWorkflowRunCancel(r web.Context) web.Result {
	workflowID, err := web.RouteValue[string](r, "workflow_id")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	runID, err := web.RouteValue[string](r, "run_id")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	err = a.Temporal.CancelWorkflow(r, workflowID, runID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().OK()
}

func (a API) getGraphs(r web.Context) web.Result {
	graphs, err := a.DB.GraphsForUser(r, a.GetUserID(r))
	if err != nil {
		return web.JSON().InternalError(err)
	}
	apiGraphs := iter.Apply(graphs, dbmodel.TypeGraphFromGraph)
	return web.JSON().Result(http.StatusOK, apiGraphs)
}

func (a API) getGraph(r web.Context) web.Result {
	graphID, err := getGraphID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	graph, found, err := a.DB.Graph(r, graphID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found || graph.UserID != a.GetUserID(r) {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, dbmodel.TypeGraphFromGraph(graph))
}

func (a API) getGraphActive(r web.Context) web.Result {
	graph, found, err := a.DB.GraphActiveForUser(r, a.GetUserID(r))
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found || graph.UserID != a.GetUserID(r) {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, dbmodel.TypeGraphFromGraph(graph))
}

func (a API) postGraph(r web.Context) web.Result {
	var graph types.Graph
	if err := web.BodyAsJSON(r, &graph); err != nil {
		return web.JSON().BadRequest(err)
	}
	dbgraph := dbmodel.GraphFromType(&graph)
	dbgraph.ID = uuid.V4()
	dbgraph.UserID = a.GetUserID(r)
	dbgraph.CreatedUTC = time.Now().UTC()
	if err := a.DB.Invoke(r).Create(&dbgraph); err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, dbgraph.ID)
}

func (a API) patchGraph(r web.Context) web.Result {
	graphID, err := getGraphID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	graph, found, err := a.DB.Graph(r, graphID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found || graph.UserID != a.GetUserID(r) {
		return web.JSON().NotFound()
	}
	ps := make(types.PatchSet)
	if err := web.BodyAsJSON(r, &ps); err != nil {
		return web.JSON().BadRequest(err)
	}
	if _, err := a.DB.PatchGraph(r, graphID, ps); err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().OK()
}

func (a API) deleteGraph(r web.Context) web.Result {
	graphID, err := getGraphID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	graph, found, err := a.DB.Graph(r, graphID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found || graph.UserID != a.GetUserID(r) {
		return web.JSON().NotFound()
	}
	if _, err := a.DB.DeleteGraph(r, graphID); err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().OK()
}

func (a API) getGraphSave(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}
	saveData, err := store.Save(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if ok := r.Request().URL.Query().Has("raw"); ok {
		r.Response().Header().Set(`Content-Disposition`, `inline; filename="graph.json"`)
		return web.JSON().Result(http.StatusOK, saveData)
	}

	buf := new(bytes.Buffer)
	gzw := gzip.NewWriter(buf)
	if err := json.NewEncoder(gzw).Encode(saveData); err != nil {
		return web.JSON().InternalError(err)
	}
	_ = gzw.Flush()
	_ = gzw.Close()

	r.Response().Header().Set(web.HeaderContentLength, strconv.Itoa(buf.Len()))
	r.Response().Header().Set(`Content-Disposition`, `inline; filename="graph.json.gz"`)
	_, _ = io.Copy(r.Response(), bytes.NewReader(buf.Bytes()))
	if typed, ok := r.Response().(http.Flusher); ok {
		typed.Flush()
	}
	return nil
}

func (a API) postGraphLoad(r web.Context) web.Result {
	store := &dbmodel.Store{
		UserID: a.GetUserID(r),
		Model:  a.DB,
	}
	body, err := r.Request().MultipartReader()
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	bodyPart, err := body.NextPart()
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	var reader io.Reader
	if strings.HasSuffix(strings.ToLower(bodyPart.FileName()), ".gz") {
		reader, err = gzip.NewReader(bodyPart)
		if err != nil {
			return web.JSON().BadRequest(err)
		}
	} else {
		reader = bodyPart
	}

	var data types.GraphFull
	if err = json.NewDecoder(reader).Decode(&data); err != nil {
		return web.JSON().BadRequest(err)
	}
	id, err := store.Load(r, &data)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	return web.JSON().Result(http.StatusOK, id)
}

func (a API) getViewport(r web.Context) web.Result {
	_, graph, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if graph == nil {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, types.Viewport{
		X:    graph.ViewportX,
		Y:    graph.ViewportY,
		Zoom: graph.ViewportZoom,
	})
}

func (a API) putViewport(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	var viewport types.Viewport
	if err := web.BodyAsJSON(r, &viewport); err != nil {
		return web.JSON().BadRequest(err)
	}
	if err := store.SetViewport(r, viewport); err != nil {
		return web.JSON().BadRequest(err)
	}
	return web.JSON().OK()
}

func (a API) getGraphLogs(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	logs, err := store.Logs(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, logs)
}

func (a API) postNode(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	var node types.Node
	err = web.BodyAsJSON(r, &node)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	var in incr.Identifier
	in, err = store.AddNode(r, &node)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	return web.JSON().Result(http.StatusOK, in.String())
}

func (a API) getNodes(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodes, err := store.Nodes(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, nodes)
}

func (a API) getNode(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	node, ok, err := store.Node(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, node)
}

func (a API) deleteNode(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	var ok bool
	ok, err = store.RemoveNode(r, nodeID)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) postNodeStale(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	rawNodeID, err := web.RouteValue[string](r, "id")
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	parsedNodeID, err := incr.ParseIdentifier(rawNodeID)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	var ok bool
	ok, err = store.MarkNodeStale(r, parsedNodeID)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) getNodeValue(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	value, ok, err := store.NodeValue(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, value)
}

func (a API) getNodeValues(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	rawNodeIDs, err := web.QueryValue[string](r, "ids")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	var ids []incr.Identifier
	for _, v := range strings.Split(rawNodeIDs, ",") {
		parsed, err := incr.ParseIdentifier(v)
		if err != nil {
			return web.JSON().BadRequest(err)
		}
		ids = append(ids, parsed)
	}
	values, err := store.NodeValues(r, ids...)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, values)
}

func (a API) putNodeValue(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	// get the node type for the node id
	node, ok, err := store.Node(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	var newElementValue any
	if node.Metadata.NodeType == incrutil.NodeTypeTable {
		bodyValue := new(types.Table)
		if err = web.BodyAsJSON(r, bodyValue); err != nil {
			return web.JSON().BadRequest(err)
		}
		newElementValue = bodyValue
	} else {
		if err = web.BodyAsJSON(r, &newElementValue); err != nil {
			return web.JSON().BadRequest(err)
		}
	}

	ok, err = store.SetNodeValue(r, nodeID, newElementValue)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) getNodeValueTableInfo(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	value, found, err := store.NodeValue(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found {
		return web.JSON().NotFound()
	}
	valueTyped, ok := value.(*types.Table)
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().Result(http.StatusOK, types.TableInfo{
		Rows:    valueTyped.RowCount(),
		Columns: iter.Apply(valueTyped.Columns, func(tc types.TableColumn) string { return tc.Name }),
	})
}

func (a API) getNodeValueTableRange(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	rawRange, err := web.QueryValue[string](r, "range")
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	rawRangeComponents := strings.Split(rawRange, ",")
	if len(rawRangeComponents) != 4 {
		return web.JSON().BadRequest(fmt.Errorf("invalid table range; expect 4 integers in csv form"))
	}
	visibleRange, err := iter.ApplyError(rawRangeComponents, strconv.Atoi)
	if err != nil {
		return web.JSON().BadRequest(fmt.Errorf("invalid table range; expect 4 integers; %w", err))
	}

	value, found, err := store.NodeValue(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found {
		return web.JSON().NotFound()
	}
	valueTyped, ok := value.(*types.Table)
	if !ok {
		return web.JSON().NotFound()
	}
	values := valueTyped.Range(types.TableRange{
		Top:    visibleRange[0],
		Left:   visibleRange[1],
		Bottom: visibleRange[2],
		Right:  visibleRange[3],
	})
	return web.JSON().Result(http.StatusOK, values)
}

func (a API) putNodeValueTableOps(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	var ops []types.TableOp
	if err := web.BodyAsJSON(r, &ops); err != nil {
		return web.JSON().BadRequest(err)
	}
	ok, err := store.PatchNodeTable(r, nodeID, ops...)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) getNodeValueTableExportCSV(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}
	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	value, found, err := store.NodeValue(r, nodeID)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if !found {
		return web.JSON().NotFound()
	}
	typed, ok := value.(*types.Table)
	if !ok {
		return web.JSON().NotFound()
	}

	buf := new(bytes.Buffer)
	csvw := csv.NewWriter(buf)
	_ = csvw.Write(iter.Apply(typed.Columns, func(c types.TableColumn) string { return c.Name }))
	rows := typed.Rows()
	for _, row := range rows {
		rowStrings := make([]string, 0, len(row))
		for _, v := range row {
			if v == nil {
				rowStrings = append(rowStrings, "")
				continue
			}
			rowStrings = append(rowStrings, fmt.Sprint(v))
		}
		csvw.Write(rowStrings)
	}
	csvw.Flush()

	r.Response().Header().Set(web.HeaderContentLength, strconv.Itoa(buf.Len()))
	r.Response().Header().Set(web.HeaderContentType, "text/csv")
	r.Response().Header().Set(`Content-Disposition`, `inline; filename="table.csv"`)
	_, _ = io.Copy(r.Response(), bytes.NewReader(buf.Bytes()))
	if typed, ok := r.Response().(http.Flusher); ok {
		typed.Flush()
	}
	return nil
}

func (a API) postNodeValueTableImportCSV(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	nodeID, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	body, err := r.Request().MultipartReader()
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	bodyPart, err := body.NextPart()
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	csvr := csv.NewReader(bodyPart)
	csvData, err := csvr.ReadAll()
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	table, err := types.TableFromCSV(csvData)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	ok, err := store.SetNodeValue(r, nodeID, table)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) patchNodes(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	var patchSet types.PatchSet
	if err := web.BodyAsJSON(r, &patchSet); err != nil {
		return web.JSON().BadRequest(err)
	}
	if err := store.PatchNodes(r, patchSet); err != nil {
		return web.JSON().BadRequest(err)
	}
	return web.JSON().OK()
}

func (a API) patchNode(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	id, err := getNodeID(r)
	if err != nil {
		return web.JSON().BadRequest(err)
	}

	var patchSet types.PatchSet
	if err := web.BodyAsJSON(r, &patchSet); err != nil {
		return web.JSON().BadRequest(err)
	}
	ok, err := store.PatchNode(r, id, patchSet)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	if !ok {
		return web.JSON().NotFound()
	}
	return web.JSON().OK()
}

func (a API) getEdges(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	edges, err := store.Edges(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	return web.JSON().Result(http.StatusOK, edges)
}

func (a API) postEdge(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	var args types.Edge
	if err := web.BodyAsJSON(r, &args); err != nil {
		return web.JSON().BadRequest(err)
	}
	err = store.LinkInput(r, args)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	return web.JSON().OK()
}

func (a API) deleteEdge(r web.Context) web.Result {
	store, _, err := a.getStore(r)
	if err != nil {
		return web.JSON().InternalError(err)
	}
	if store == nil {
		return web.JSON().NotFound()
	}

	var args types.Edge
	if err := web.BodyAsJSON(r, &args); err != nil {
		return web.JSON().BadRequest(err)
	}
	err = store.UnlinkInput(r, args)
	if err != nil {
		return web.JSON().BadRequest(err)
	}
	return web.JSON().OK()
}