step

type AddModelObject ¶

type AddModelObject struct {
	Form     form.Element
	Defaults []Step
}

AddModelObject is an action that can add new model objects of any type

func NewAddModelObject(stepInfo mapof.Any) (AddModelObject, error)

func (step AddModelObject) AmStep()

type AddStream ¶ added in v0.6.0

type AddStream struct {
	Style         string                        // Style of input widget to use. Options are: "chooser", "modal", and "inline".  Defaults to "chooser".
	Title         string                        // Title to use on the create modal. Defaults to "Add a Stream"
	Location      string                        // Options are: "top", "child", "outbox".  Defaults to "child".
	TemplateID    string                        // ID of the template to use.  If empty, then template roles are used.
	TemplateRoles []string                      // List of acceptable Template Roles that can be used to make a stream.  If empty, then all template for this container are valid.
	WithData      map[string]*template.Template // Map of values to preset in the new stream
}

AddStream is an action that can add new sub-streams to the domain.

Uses: Display a pop-up to choose a template and create a new stream Embed a custom "create" widget into the current page - possibly selecting between multiple templates Create a new stream using a specific template as a part of a larger pipeline

func NewAddStream(stepInfo mapof.Any) (AddStream, error)

func (step AddStream) AmStep()

type AsConfirmation ¶

type AsConfirmation struct {
	Title   string
	Message string
	Submit  string
}

AsConfirmation displays a confirmation dialog on GET, giving users an option to continue or not

func NewAsConfirmation(stepInfo mapof.Any) (AsConfirmation, error)

func (step AsConfirmation) AmStep()

type AsModal ¶

type AsModal struct {
	SubSteps   []Step
	Options    []string
	Background string
}

AsModal represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewAsModal(stepInfo mapof.Any) (AsModal, error)

func (step AsModal) AmStep()

type AsTooltip ¶ added in v0.6.0

type AsTooltip struct {
	SubSteps []Step
}

AsTooltip represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewAsTooltip(stepInfo mapof.Any) (AsTooltip, error)

func (step AsTooltip) AmStep()

type Delete ¶

type Delete struct {
	Title   *template.Template
	Message *template.Template
	Submit  string
}

Delete represents an action-step that can delete a Stream from the Domain

func NewDelete(stepInfo mapof.Any) (Delete, error)

func (step Delete) AmStep()

type DeleteAttachments ¶

type DeleteAttachments struct {
	All bool
}

DeleteAttachments represents an action that can upload attachments. It can only be used on a StreamBuilder

func NewDeleteAttachments(stepInfo mapof.Any) (DeleteAttachments, error)

func (step DeleteAttachments) AmStep()

type Do ¶ added in v0.6.0

type Do struct {
	Action string
}

Do represents an action-step that calls anoter action to continue processing

func NewDo(stepInfo mapof.Any) (Do, error)

func (step Do) AmStep()

type EditConnection ¶

type EditConnection struct{}

EditConnection contains the configuration data for a modal that lets administrators manage connections to external servers.

func NewEditConnection(stepInfo mapof.Any) (EditConnection, error)

func (step EditConnection) AmStep()

type EditContent ¶

type EditContent struct {
	Filename string
	Format   string
}

EditContent represents an action-step that can edit/update Container in a streamDraft.

func NewEditContent(stepInfo mapof.Any) (EditContent, error)

func (step EditContent) AmStep()

type EditModelObject ¶

type EditModelObject struct {
	Form    form.Element
	Options []*template.Template
}

EditModelObject is an action that can add new sub-streams to the domain.

func NewEditModelObject(stepInfo mapof.Any) (EditModelObject, error)

func (step EditModelObject) AmStep()

type EditWidget ¶ added in v0.6.0

type EditWidget struct{}

EditWidget represents an action-step that locates an existing widget and creates a builder for it.

func NewEditWidget(stepInfo mapof.Any) (EditWidget, error)

func (step EditWidget) AmStep()

type ForwardTo ¶

type ForwardTo struct {
	URL *template.Template
}

ForwardTo represents an action-step that forwards the user to a new page.

func NewForwardTo(stepInfo mapof.Any) (ForwardTo, error)

func (step ForwardTo) AmStep()

type Halt ¶ added in v0.6.0

type Halt struct{}

Halt represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewHalt(stepInfo mapof.Any) (Halt, error)

func (step Halt) AmStep()

type IfCondition ¶

type IfCondition struct {
	Condition *template.Template
	Then      []Step
	Otherwise []Step
}

IfCondition represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewIfCondition(stepInfo mapof.Any) (IfCondition, error)

func (step IfCondition) AmStep()

type InlineError ¶ added in v0.6.0

type InlineError struct {
	Message *template.Template
}

InlineError represents an action-step that displays an "inline failure" message on a form

func NewInlineError(stepInfo mapof.Any) (InlineError, error)

func (step InlineError) AmStep()

type InlineSuccess ¶ added in v0.6.0

type InlineSuccess struct {
	Message *template.Template
}

InlineSuccess represents an action-step that displays an "inline success" message on a form

func NewInlineSuccess(stepInfo mapof.Any) (InlineSuccess, error)

func (step InlineSuccess) AmStep()

type ProcessContent ¶ added in v0.6.0

type ProcessContent struct {
	RemoveHTML bool
	AddTags    bool
	AddLinks   bool
}

ProcessContent is an action that can add new sub-streams to the domain.

func NewProcessContent(stepInfo mapof.Any) (ProcessContent, error)

func (step ProcessContent) AmStep()

type Publish ¶

type Publish struct{}

Publish represents an action-step that can update a stream's PublishDate with the current time.

func NewPublish(stepInfo mapof.Any) (Publish, error)

func (step Publish) AmStep()

type RedirectTo ¶

type RedirectTo struct {
	URL *template.Template
}

RedirectTo represents an action-step that forwards the user to a new page.

func NewRedirectTo(stepInfo mapof.Any) (RedirectTo, error)

func (step RedirectTo) AmStep()

type RefreshPage ¶

type RefreshPage struct{}

RefreshPage represents an pipeline-step that forwards the user to a new page.

func NewRefreshPage(stepInfo mapof.Any) (RefreshPage, error)

func (step RefreshPage) AmStep()

type ReloadPage ¶

type ReloadPage struct{}

ReloadPage represents an pipeline-step that forwards the user to a new page.

func NewReloadPage(stepInfo mapof.Any) (ReloadPage, error)

func (step ReloadPage) AmStep()

type RemoveEvent ¶ added in v0.6.0

type RemoveEvent struct {
	Event string
}

RemoveEvent represents an action-step that removes an HX-Trigger event from the HTTP result

func NewRemoveEvent(stepInfo mapof.Any) (RemoveEvent, error)

func (step RemoveEvent) AmStep()

type Save ¶

type Save struct {
	Comment *template.Template
}

Save represents an action-step that can save changes to any object

func NewSave(stepInfo mapof.Any) (Save, error)

func (step Save) AmStep()

type SendEmail ¶ added in v0.6.0

type SendEmail struct {
	Email string
}

SendEmail represents an action-step that can send a named email to a user

func NewSendEmail(stepInfo mapof.Any) (SendEmail, error)

func (step SendEmail) AmStep()

type ServerRedirect ¶

type ServerRedirect struct {
	On     string
	Action string
}

ServerRedirect represents an action-step that forwards the user to a new page.

func NewServerRedirect(stepInfo mapof.Any) (ServerRedirect, error)

func (step ServerRedirect) AmStep()

type SetData ¶

type SetData struct {
	FromURL  []string                      // List of paths to pull from URL data
	FromForm []string                      // List of paths to pull from Form data
	Values   map[string]*template.Template // values to set directly into the object
	Defaults mapof.Any                     // values to set into the object IFF they are currently empty.
}

SetData represents an action-step that can update the custom data stored in a Stream

func NewSetData(stepInfo mapof.Any) (SetData, error)

func (step SetData) AmStep()

type SetHeader ¶

type SetHeader struct {
	Method string
	Name   string
	Value  *template.Template
}

SetHeader represents an action-step that can update the custom data stored in a Stream

func NewSetHeader(stepInfo mapof.Any) (SetHeader, error)

func (step SetHeader) AmStep()

type SetQueryParam ¶

type SetQueryParam struct {
	Values map[string]*template.Template
}

SetQueryParam represents an action-step that forwards the user to a new page.

func NewSetQueryParam(stepInfo mapof.Any) (SetQueryParam, error)

func (step SetQueryParam) AmStep()

type SetRenderData ¶ added in v0.6.0

type SetRenderData struct {
	Values map[string]*template.Template // values to set directly into the object
}

SetRenderData represents an action-step that can update the custom data stored in a builder

func NewSetRenderData(stepInfo mapof.Any) (SetRenderData, error)

func (step SetRenderData) AmStep()

type SetResponse ¶ added in v0.6.0

type SetResponse struct{}

SetResponse represents an action-step that can create/update a response to the current model object

func NewSetResponse(stepInfo mapof.Any) (SetResponse, error)

func (step SetResponse) AmStep()

type SetSimpleSharing ¶

type SetSimpleSharing struct {
	Title   string
	Message string
	Roles   []string
}

SetSimpleSharing represents an action that can edit a top-level folder in the Domain

func NewSetSimpleSharing(stepInfo mapof.Any) (SetSimpleSharing, error)

func (step SetSimpleSharing) AmStep()

type SetState ¶

type SetState struct {
	State string
}

SetState represents an action-step that can change a Stream's state

func NewSetState(stepInfo mapof.Any) (SetState, error)

func (step SetState) AmStep()

type SetThumbnail ¶

type SetThumbnail struct {
	Path string
}

SetThumbnail represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewSetThumbnail(stepInfo mapof.Any) (SetThumbnail, error)

func (step SetThumbnail) AmStep()

type Sort ¶

type Sort struct {
	Keys    string
	Values  string
	Message string
}

Sort represents an action-step that can update multiple records at once

func NewSort(stepInfo mapof.Any) (Sort, error)

func (step Sort) AmStep()

type SortAttachments ¶

type SortAttachments struct {
	Keys    string
	Values  string
	Message string
}

SortAttachments represents an action-step that can update multiple records at once

func NewSortAttachments(stepInfo mapof.Any) (SortAttachments, error)

func (step SortAttachments) AmStep()

type SortWidgets ¶

type SortWidgets struct{}

SortWidgets represents an action-step that can update multiple records at once

func NewSortWidgets(stepInfo mapof.Any) (SortWidgets, error)

func (step SortWidgets) AmStep()

type Step ¶

type Step interface {
	// AmStep is a NO-OP.  It is only used to validate that a struct contains "step-like" data.
	AmStep()
}

Step interface is used here to bind together the structs in this package

func New(stepInfo mapof.Any) (Step, error)

func NewPipeline[T ~map[string]any](stepInfo []T) ([]Step, error)

type StreamPromoteDraft ¶

type StreamPromoteDraft struct {
	StateID string
}

StreamPromoteDraft represents a pipeline-step that can copy the Container from a StreamDraft into its corresponding Stream

func NewStreamPromoteDraft(stepInfo mapof.Any) (StreamPromoteDraft, error)

func (step StreamPromoteDraft) AmStep()

type TableEditor ¶

type TableEditor struct {
	Path string
	Form form.Element
}

TableEditor is an action that can add new sub-streams to the domain.

func NewTableEditor(stepInfo mapof.Any) (TableEditor, error)

func (step TableEditor) AmStep()

type TriggerEvent ¶

type TriggerEvent struct {
	Event string
	Value *template.Template
}

TriggerEvent represents an action-step that forwards the user to a new page.

func NewTriggerEvent(stepInfo mapof.Any) (TriggerEvent, error)

func (step TriggerEvent) AmStep()

type UnPublish ¶

type UnPublish struct {
	Role string
}

UnPublish represents an action-step that can update a stream's UnPublishDate with the current time.

func NewUnPublish(stepInfo mapof.Any) (UnPublish, error)

func (step UnPublish) AmStep()

type UploadAttachment ¶

type UploadAttachment struct {
	Maximum int
}

UploadAttachment represents an action that can upload attachments. It can only be used on a StreamBuilder

func NewUploadAttachment(stepInfo mapof.Any) (UploadAttachment, error)

func (step UploadAttachment) AmStep()

type ViewFeed ¶

type ViewFeed struct {
}

ViewFeed represents an action-step that can build a Stream into HTML

func NewViewFeed(stepInfo mapof.Any) (ViewFeed, error)

func (step ViewFeed) AmStep()

type ViewHTML ¶

type ViewHTML struct {
	File   string
	Method string
}

ViewHTML represents an action-step that can build a Stream into HTML

func NewViewHTML(stepInfo mapof.Any) (ViewHTML, error)

func (step ViewHTML) AmStep()

type ViewJSONLD ¶ added in v0.6.0

type ViewJSONLD struct {
	Method string
}

ViewJSONLD represents an action-step that can build a Stream into HTML

func NewViewJSONLD(stepInfo mapof.Any) (ViewJSONLD, error)

func (step ViewJSONLD) AmStep()

type WebSub ¶

type WebSub struct {
}

WebSub represents an action-step that can build a Stream into HTML

func NewWebSub(stepInfo mapof.Any) (WebSub, error)

func (step WebSub) AmStep()

type WithChildren ¶

type WithChildren struct {
	SubSteps []Step
}

WithChildren represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithChildren(stepInfo mapof.Any) (WithChildren, error)

func (step WithChildren) AmStep()

type WithDraft ¶

type WithDraft struct {
	SubSteps []Step
}

WithDraft represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithDraft(stepInfo mapof.Any) (WithDraft, error)

func (step WithDraft) AmStep()

type WithFolder ¶

type WithFolder struct {
	SubSteps []Step
}

WithFolder represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithFolder(stepInfo mapof.Any) (WithFolder, error)

func (step WithFolder) AmStep()

type WithFollower ¶

type WithFollower struct {
	SubSteps []Step
}

WithFollower represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithFollower(stepInfo mapof.Any) (WithFollower, error)

func (step WithFollower) AmStep()

type WithFollowing ¶

type WithFollowing struct {
	SubSteps []Step
}

WithFollowing represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithFollowing(stepInfo mapof.Any) (WithFollowing, error)

func (step WithFollowing) AmStep()

type WithMessage ¶

type WithMessage struct {
	SubSteps []Step
}

WithMessage represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithMessage(stepInfo mapof.Any) (WithMessage, error)

func (step WithMessage) AmStep()

type WithNextSibling ¶

type WithNextSibling struct {
	SubSteps []Step
}

WithNextSibling represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithNextSibling(stepInfo mapof.Any) (WithNextSibling, error)

func (step WithNextSibling) AmStep()

type WithParent ¶

type WithParent struct {
	SubSteps []Step
}

WithParent represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithParent(stepInfo mapof.Any) (WithParent, error)

func (step WithParent) AmStep()

type WithPrevSibling ¶

type WithPrevSibling struct {
	SubSteps []Step
}

WithPrevSibling represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithPrevSibling(stepInfo mapof.Any) (WithPrevSibling, error)

func (step WithPrevSibling) AmStep()

type WithResponse ¶ added in v0.6.0

type WithResponse struct {
	SubSteps []Step
}

WithResponse represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithResponse(stepInfo mapof.Any) (WithResponse, error)

func (step WithResponse) AmStep()

type WithRule ¶ added in v0.6.0

type WithRule struct {
	SubSteps []Step
}

WithRule represents an action-step that can update the data.DataMap custom data stored in a Stream

func NewWithRule(stepInfo mapof.Any) (WithRule, error)

func (step WithRule) AmStep()