blasphem/pkg/flow/flow.go

// flow is the data entry flow.
package flow

import (
	"fmt"
	"time"

	"dynatron.me/x/blasphem/internal/generate"
)

type ResultType string
type FlowID     string
type Step       string
type HandlerKey string
type Errors     interface{}

type FlowStore map[FlowID]Handler

type FlowManager struct {
	flows FlowStore
}

type Result struct {
	Type        ResultType             `json:"type"`
	ID          FlowID                 `json:"flow_id"`
	Handler     []*HandlerKey          `json:"handler"`
	Title       *string                `json:"title,omitempty"`
	Data        map[string]interface{} `json:"data,omitempty"`
	StepID      *Step                  `json:"step_id,omitempty"`
	Schema      []SchemaItem           `json:"data_schema"`
	Extra       *string                `json:"extra,omitempty"`
	Required    *bool                  `json:"required,omitempty"`
	Errors      interface{}            `json:"errors"`
	Description *string                `json:"description,omitempty"`
	DescPlace   *string                `json:"description_placeholders"`
	URL         *string                `json:"url,omitempty"`
	Reason      *string                `json:"reason,omitempty"`
	Context     *string                `json:"context,omitempty"`
	Result      interface{}            `json:"result,omitempty"`
	LastStep    *string                `json:"last_step"`
	Options     map[string]interface{} `json:"options,omitempty"`
	Version     *int                   `json:"version,omitempty"`
}

type Handler interface {
	BaseHandler() FlowHandler
	FlowID() FlowID

	flowCtime() time.Time
}

const (
	StepInit Step = "init"
)

func (fs Schema) CheckRequired(rm map[string]interface{}) error {
	for _, si := range fs {
		if si.Required {
			if _, ok := rm[si.Name]; !ok {
				return fmt.Errorf("missing required param %s", si.Name)
			}
		}
	}

	return nil
}

func NewFlowManager() *FlowManager {
	return &FlowManager{
		flows: make(FlowStore),
	}
}

func stepPtr(s Step) *Step { return &s }

type FlowHandler struct {
	ID      FlowID     // ID is the FlowID
	Handler HandlerKey // Handler key

	// curStep is the current step set by the flow manager
	curStep Step

	ctime time.Time
}

func (f *FlowHandler) Step() Step { return f.curStep }

func (f *FlowHandler) BaseHandler() FlowHandler { return *f }

func (f *FlowHandler) FlowID() FlowID {
	return f.ID
}

func (f *FlowHandler) flowCtime() time.Time { return f.ctime }

func NewFlowHandlerBase(hand string) FlowHandler {
	return FlowHandler{
		ID:      FlowID(generate.UUID()),
		Handler: HandlerKey(hand),

		curStep: StepInit,
		ctime:   time.Now(),
	}
}

func (hk *HandlerKey) String() string {
	return string(*hk)
}

func (fm *FlowHandler) Handlers() []*HandlerKey {
	return []*HandlerKey{&fm.Handler, nil}
}

func resultErrs(e Errors) Errors {
	if e == nil {
		return []string{}
	}

	return e
}

type FormOption func(*Result)

func (*FlowHandler) WithErrors(e Errors) FormOption {
	return func(r *Result) {
		r.Errors = e
	}
}

func (*FlowHandler) WithStep(s Step) FormOption {
	return func(r *Result) {
		r.StepID = stepPtr(s)
	}
}

func (*FlowHandler) WithSchema(sch Schemer) FormOption {
	return func(r *Result) {
		r.Schema = sch.FlowSchema()
	}
}

func (fm *FlowHandler) ShowForm(opts ...FormOption) *Result {
	res := &Result{
		Type:    TypeForm,
		ID:      fm.ID,
		StepID:  stepPtr(fm.curStep),
		Handler: fm.Handlers(),
	}

	for _, opt := range opts {
		opt(res)
	}

	res.Errors = resultErrs(res.Errors)
	return res
}

func (fm *FlowManager) Delete(id FlowID) {
	delete(fm.flows, id)
}

const (
	TypeForm             ResultType = "form"
	TypeCreateEntry      ResultType = "create_entry"
	TypeAbort            ResultType = "abort"
	TypeExternalStep     ResultType = "external"
	TypeExternalStepDone ResultType = "external_done"
	TypeShowProgress     ResultType = "progress"
	TypeShowProgressDone ResultType = "progress_done"
	TypeMenu             ResultType = "menu"
)

func (f *FlowHandler) touch() {
	f.ctime = time.Now()
}

func (fm *FlowManager) Register(f Handler) {
	fm.flows.cull()
	fm.flows[f.FlowID()] = f
}

func (fs *FlowManager) Remove(f Handler) {
	delete(fs.flows, f.FlowID())
}

const cullAge = time.Minute * 10

func (fs FlowStore) cull() {
	for k, v := range fs {
		if time.Now().Sub(v.flowCtime()) > cullAge {
			delete(fs, k)
		}
	}
}

func (fs *FlowManager) Get(id FlowID) Handler {
	f, ok := fs.flows[id]
	if ok {
		return f
	}

	return nil
}