workflow

type Config struct {
	// workflow default step timeout.
	// if a workflow does not specify a timeout when enqueueing steps
	// then this default is used. if this default is not sepcified then
	// the engine's default timeout is used.
	Timeout time.Duration

	// defines the workflow exclusivity style
	Exclusivity

	// workflows have the option to receive command responses from
	// any MDM command request type that the engine enqueues (i.e. from
	// other workflows) — not just the commands that this workflow
	// enqueues. specifiy the Request Types for those command here. They
	// will be received by the workflow as an event.
	AllCommandResponseRequestTypes []string

	// event subscriptions. this workflow will get called every time
	// these events happen. use bitwise OR to specify multiple events.
	Events EventFlag
}

type ContextMarshaler interface {
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
}

type Event struct {
	EventFlag
	// EventData is likely a pointer to a struct of the relevent event data.
	// You will need to know the data you're expecting and use Go type
	// conversion to access it if you need it.
	// For example the EventAuthenticate EventFlag will be
	// a `*mdm.Authenticate` under the `interface{}`.
	EventData interface{}
}

type EventFlag uint

type Exclusivity uint

type IntContext int

type MDMContext struct {
	// Params are the URL parameters included in the MDM request from an
	// enrollment. These parameters would be set on the `CheckInURL` or
	// `ServerURL` parameters in the enrollment profile. Note because
	// these come from a connecting MDM client they may not be present
	// in all contexts — only those that originate from an MDM request.
	Params map[string]string
}

type Namer interface {
	// Name returns the name of the workflow; reverse-DNS style by convention.
	// This string is generally used to route actions to this workflow.
	Name() string
}

type StepContext struct {
	// MDM client/server context. Note that a step can be more than one
	// MDM command response. This means MDMContext will likely only
	// come from the very last command to be seen that completed
	// the step. Previous MDMConext will not be seen/provided.
	MDMContext

	InstanceID string // Unique identifier of the workflow instance

	// Name is used by the workflow to identify which step is being processed.
	// This value can help the workflow differentiate steps for a multi-step workflow.
	// It is also passed to the NewContext() method to determine the data
	// type for unmarshalling. Name is empty when starting a workflow.
	Name string

	// Context is a generic holder of data that workflows will be handed when processing steps.
	// Usually this will be an instance of whatever value the workflow
	// NewContext() method returns for a given step name.
	Context ContextMarshaler
}

type StepEnqueueing struct {
	StepContext
	IDs      []string // Enrollment IDs
	Commands []interface{}

	// Timeout specifies a timeout. If any of the commands in this step do
	// not complete by this time then the entire step is considered to have
	// timed out.
	Timeout time.Time

	// A step should not be enqueued (that is, sent to enrollments)
	// until after this time has passed. A delay of sorts.
	NotUntil time.Time
}

type StepEnqueuer interface {
	// EnqueueStep enqueues MDM commands to ids in StepEnqueue.
	// The enqueing system should be able to find this workflow again with Namer.
	EnqueueStep(context.Context, Namer, *StepEnqueueing) error
}

type StepResult struct {
	StepContext
	ID             string
	CommandResults []interface{}
}

type StepStart struct {
	StepContext
	Event *Event
	IDs   []string // Enrollment IDs
}

type StringContext string

type Workflow interface {
	Namer

	// Config returns the workflow configuration.
	Config() *Config

	// NewContextValue returns a newly instantiated context value.
	// This will usally be used by a workflow engine to unmarshal and pass in
	// stored context on a StepContext.
	NewContextValue(stepName string) ContextMarshaler

	// Start starts a new workflow instance for MDM enrollments.
	Start(context.Context, *StepStart) error

	// StepCompleted is the action called when all step MDM commands have reported results.
	// Note that these results may be errors, but NotNow responses are handled for the workflow.
	StepCompleted(context.Context, *StepResult) error

	// StepTimeout occurs when at least one command in a step has failed to complete in time.
	// Timeouts are defined by the step, then any workflow default, then
	// any engine default.
	StepTimeout(context.Context, *StepResult) error

	// Event is called when MDM events happen that are intended for this workflow.
	// A workflow can subscribe to events in its Config struct.
	Event(ctx context.Context, e *Event, id string, mdmCtx *MDMContext) error
}