mirth

type Bundle struct {
	// Kind names the document: "channel", "channel list", "server backup", "channel group" or "code template libraries".
	Kind string

	// Version is the engine version on the root element, when there is one.
	Version string

	Channels  []*Channel
	Groups    []ChannelGroup
	Libraries []CodeTemplateLibrary

	// GlobalScripts are the server-wide deploy, undeploy, preprocessor and postprocessor scripts, by name. Only a backup has them.
	GlobalScripts map[string]string
}

type Channel struct {
	ID          string
	Name        string
	Description string
	Enabled     bool
	Revision    int

	Source       Connector
	Destinations []Connector

	PreprocessingScript  string
	PostprocessingScript string
	DeployScript         string
	UndeployScript       string

	Properties ChannelProperties

	// Unrecognised holds element names we saw but did not map.
	Unrecognised []string

	// MirthVersion is the version attribute on the root element, if present.
	MirthVersion string
	// contains filtered or unexported fields
}

type ChannelGroup struct {
	ID          string
	Name        string
	Description string
	ChannelIDs  []string
}

type ChannelProperties struct {
	MessageStorageMode      string
	EncryptData             bool
	RemoveContentOnComplete bool
	StoreAttachments        bool
	PruneMetaDataDays       int
	PruneContentDays        int
	ClearGlobalChannelMap   bool
	ResourceIDs             []string
}

type CodeTemplate struct {
	ID   string
	Name string
	// Type is FUNCTION, DRAG_AND_DROP_CODE or COMPILED_CODE. Only FUNCTION and COMPILED_CODE are loaded into a script's scope; a
	// drag-and-drop snippet is pasted into a step by hand in the Administrator, so it is not code that runs by itself.
	Type string
	Code string
	// Contexts are where Mirth makes the template available, such as SOURCE_FILTER_TRANSFORMER.
	Contexts []string
}

type CodeTemplateLibrary struct {
	ID          string
	Name        string
	Description string

	// IncludeNewChannels makes the library visible to every channel not explicitly disabled. Mirth's default for a new library is false.
	IncludeNewChannels bool
	EnabledChannelIDs  []string
	DisabledChannelIDs []string

	Templates []CodeTemplate
}

type Connector struct {
	MetaDataID int
	Name       string
	Mode       ConnectorMode
	Enabled    bool

	// Transport is Mirth's transportName, e.g. "TCP Listener", "HTTP Sender".
	Transport string

	// PropertiesClass is the concrete Java properties class, which identifies
	// the connector far more reliably than the display name.
	PropertiesClass string

	// Properties is the transport's settings flattened to dotted paths.
	Properties map[string]string

	WaitForPrevious bool

	Filter       Filter
	Transformer  Transformer
	Unrecognised []string
	// contains filtered or unexported fields
}

type ConnectorMode string

type ExportResult struct {
	// Warnings lists elements or features that exist on the Channel struct but
	// could not be represented in Mirth XML. A non-empty list means the export
	// is lossy: something will be lost if this file is imported into Mirth.
	Warnings []string
}

type Filter struct {
	Rules []Rule
}

type JavaReport struct {
	Uses []JavaUse

	// Counts by verdict, so a caller does not have to tally them to decide what to show.
	Supported    int
	Rewritable   int
	NeedsFeature int
	OutOfScope   int

	// ExternalScripts holds paths from ExternalScript steps.
	//
	// Separate from Uses because the script is not in the export - only a path on the old server's filesystem - so
	// nothing can be said about its contents. Reporting it as "no Java found" would be a lie by omission, and this is
	// the one finding where the honest answer is that the file has to be fetched and looked at.
	ExternalScripts []string
}

type JavaUse struct {
	// Reference is what the script wrote, near enough to find with a search.
	Reference string

	// Where names the script, in the words the Mirth administrator interface uses.
	Where string

	// Line is the line within that script, counting from one.
	Line int

	// Verdict says what can be done.
	Verdict Verdict

	// Advice says what to do, naming the replacement where there is one.
	Advice string
}

type Portability struct {
	// Total is every Java reference found, including the harmless ones.
	//
	// Reported prominently and immediately qualified. It is the number that looks alarming and is not the finding, and leaving it
	// out would be its own dishonesty - somebody who greps their own exports will find it and wonder what else was shaped.
	Total int `json:"total"`

	// Portable is references that run anywhere: already provided, or ordinary Java with a direct equivalent.
	Portable int `json:"portable"`

	// VendorOnly is the count that constitutes lock-in - calls that need the vendor's own server or a vendor jar.
	VendorOnly int `json:"vendorOnly"`

	// NeedsAnotherRoute is capability that exists outside a script: a channel started through an API rather than in JavaScript.
	//
	// Separate from VendorOnly because the difference is "this is impossible" against "this is a REST call away", and collapsing
	// them would overstate the finding in the direction that flatters the argument.
	NeedsAnotherRoute int `json:"needsAnotherRoute"`

	// Unknown is external scripts, whose contents are not in the export.
	//
	// Counted rather than assumed either way. A path on the old server's filesystem could hold anything, and both "assume it is
	// fine" and "assume it is lock-in" are guesses presented as findings.
	Unknown int `json:"unknown"`

	// VendorReferences are the specific calls behind VendorOnly, deduplicated and sorted.
	//
	// Named because a count is an assertion and a list is evidence. Anybody being shown this should be able to open the channel and
	// look at the line.
	VendorReferences []string `json:"vendorReferences"`
}

type Rule struct {
	Sequence int
	Name     string
	Kind     RuleKind
	RawKind  string

	// Operator is how this rule combines with the previous one: NONE, AND, OR.
	Operator string

	// Field, Condition and Values describe a RuleBuilder rule.
	Field     string
	Condition string
	Values    []string

	// Script holds JavaScript for JavaScript rules.
	Script string

	Children []Rule
}

type RuleKind string

type Step struct {
	Sequence int
	Name     string
	Kind     StepKind

	// RawKind is the original XML element name, kept so an unrecognised step
	// can still be reported precisely.
	RawKind string

	// Variable and Mapping are used by Mapper steps.
	Variable string
	Mapping  string
	// Scope and DefaultValue are a Mapper step's: which map the variable goes into (CHANNEL, CONNECTOR, GLOBAL_CHANNEL, GLOBAL,
	// RESPONSE) and what it holds when the expression is empty or throws.
	Scope        string
	DefaultValue string

	// Script holds JavaScript for JavaScript steps, the stylesheet for XSLT
	// steps, or the path for ExternalScript steps.
	Script string

	// Children are nested steps, used by Iterator.
	Children []Step
}

type StepKind string

type Transformer struct {
	InboundDataType  string
	OutboundDataType string
	Steps            []Step
}

type Verdict string