search

type BSONBuilder ¶

type BSONBuilder func(param SearchParam, searcher *MongoSearcher) (object bson.M, err error)

BSONBuilder returns a BSON object representing the passed in search parameter. This BSON object is expected to be merged with other objects and passed into Mongo's Find function.

type BSONQuery ¶

type BSONQuery struct {
	Resource string
	Query    bson.M
	Pipeline []bson.M
}

BSONQuery is a BSON document constructed from the original string search query.

func NewBSONQuery(resource string) *BSONQuery

func (b *BSONQuery) DebugString() string

type ChainedQueryReference ¶

type ChainedQueryReference struct {
	Type         string // The type of resource being searched
	ChainedQuery Query
}

ChainedQueryReference represents a chained query

type CompositeParam ¶

type CompositeParam struct {
	SearchParamInfo
	CompositeValues []string
}

CompositeParam represents a composite-flavored search parameter. The following description is from the FHIR DSTU2 specification:

A resource may also specify composite parameters that take sequences of single values that match other defined parameters as an argument. The matching parameter of each component in such a sequence is documented in the definition of the parameter. These sequences are formed by joining the single values with a "$". Note that this sequence is a single value and itself can be composed into a set of values, so that, for example, multiple matching state-on-date parameters can be specified as state-on-date=new$2013-05-04,active$2013-05-05.

func ParseCompositeParam(paramString string, info SearchParamInfo) *CompositeParam

type CountCache ¶

type CountCache struct {
	Id    string `bson:"_id"`
	Count uint32 `bson:"count"`
}

CountCache is used to cache the total count of results for a specific query. The Id is the md5 hash of the query string.

type DateParam ¶

type DateParam struct {
	SearchParamInfo
	Date *utils.Date
}

DateParam represents a date-flavored search parameter. The following description is from the FHIR DSTU2 specification:

A date parameter searches on a date/time or period. As is usual for date/time related functionality, while the concepts are relatively straight-forward, there are a number of subtleties involved in ensuring consistent behavior.

func ParseDateParam(paramStr string, info SearchParamInfo) *DateParam

type Error ¶

type Error struct {
	HTTPStatus       int
	OperationOutcome *models.OperationOutcome
}

Error is an interface for search errors, providing an HTTP status and operation outcome

func (e *Error) Error() string

type ExternalReference ¶

type ExternalReference struct {
	Type string
	URL  string
}

ExternalReference represents an external reference by URL

type IncludeOption ¶

type IncludeOption struct {
	Resource  string
	Parameter SearchParamInfo
}

IncludeOption describes the data that should be included in query results

type LocalReference ¶

type LocalReference struct {
	Type string
	ID   string
}

LocalReference represents a local reference by ID (and potentially Type)

type MongoRegistry ¶

type MongoRegistry struct {
	// contains filtered or unexported fields
}

MongoRegistry supports the registration and lookup of Mongo search parameter implementations as BSON builders.

func GlobalMongoRegistry() *MongoRegistry

func (r *MongoRegistry) LookupBSONBuilder(paramType string) (builder BSONBuilder, err error)

func (r *MongoRegistry) RegisterBSONBuilder(paramType string, builder BSONBuilder)

type MongoSearcher ¶

type MongoSearcher struct {
	// contains filtered or unexported fields
}

MongoSearcher implements FHIR searches using the Mongo database.

func NewMongoSearcher(db *mongowrapper.WrappedDatabase, ctx context.Context, countTotalResults, enableCISearches, tokenParametersCaseSensitive, readonly bool) *MongoSearcher

func NewMongoSearcherForUri(mongoUri string, mongoDatabaseName string, countTotalResults, enableCISearches, tokenParametersCaseSensitive, readonly bool) *MongoSearcher

func (m *MongoSearcher) Close()

func (m *MongoSearcher) GetDB() *mongowrapper.WrappedDatabase

func (m *MongoSearcher) Search(query Query) (resources []*models2.Resource, total uint32, err error)

type NumberParam ¶

type NumberParam struct {
	SearchParamInfo
	Number *utils.Number
}

NumberParam represents a number-flavored search parameter. The following description is from the FHIR DSTU2 specification:

Searching on a simple numerical value in a resource.

func ParseNumberParam(paramStr string, info SearchParamInfo) *NumberParam

type OrParam ¶

type OrParam struct {
	SearchParamInfo
	Items []SearchParam
}

OrParam represents a search parameter that has multiple OR values. The following description is from the FHIR DSTU2 specification:

If, instead, the search is to find patients that speak either language, then this is a single parameter with multiple values, separated by a ','. For example: "/Patient?language=FR,NL". This is known as an OR search parameter, since the server is expected to respond with results which match either value.

func ParseOrParam(paramStr []string, info SearchParamInfo) *OrParam

type ParameterParser ¶

type ParameterParser func(info SearchParamInfo, data SearchParamData) (SearchParam, error)

ParameterParser parses search parameter data into a SearchParam implementation.

type Prefix ¶

type Prefix string

Prefix is an enum representing FHIR parameter prefixes. The following description is from the FHIR DSTU2 specification:

For the ordered parameter types number, date, and quantity, a prefix to the parameter value may be used to control the nature of the matching.

const (
	EQ Prefix = "eq"
	NE Prefix = "ne"
	GT Prefix = "gt"
	LT Prefix = "lt"
	GE Prefix = "ge"
	LE Prefix = "le"
	SA Prefix = "sa"
	EB Prefix = "eb"
	AP Prefix = "ap"
)

func ExtractPrefixAndValue(s string) (Prefix, string)

func (p Prefix) String() string

type QuantityParam ¶

type QuantityParam struct {
	SearchParamInfo
	Number *utils.Number
	System string
	Code   string
}

QuantityParam represents a quantity-flavored search parameter. The following description is from the FHIR DSTU2 specification:

A quantity parameter searches on the Quantity data type.

func ParseQuantityParam(paramStr string, info SearchParamInfo) *QuantityParam

type Query ¶

type Query struct {
	Resource string
	Query    string
}

Query describes a string-based FHIR query and the resource it is associated with. For example, the URL http://acme.com/Condition?patient=123&onset=2012 should be represented as:

Query { Resource: "Condition", Query: "patient=123&onset=2012" }

func (q *Query) Options() *QueryOptions

func (q *Query) Params() []SearchParam

func (q *Query) SupportsPaging() bool

func (q *Query) URLQueryParameters(withOptions bool) URLQueryParameters

func (q *Query) UsesChainedSearch() bool

func (q *Query) UsesIncludes() bool

func (q *Query) UsesPipeline() bool

func (q *Query) UsesRevIncludes() bool

func (q *Query) UsesReverseChainedSearch() bool

type QueryOptions ¶

type QueryOptions struct {
	Count           int
	Offset          int
	Sort            []SortOption
	Include         []IncludeOption
	RevInclude      []RevIncludeOption
	IsSTU3Sort      bool
	IsIncludeAll    bool
	IsRevincludeAll bool
	Summary         string
}

QueryOptions contains option values such as count and offset.

func NewQueryOptions() *QueryOptions

func (o *QueryOptions) URLQueryParameters() URLQueryParameters

type ReferenceParam ¶

type ReferenceParam struct {
	SearchParamInfo
	Reference interface{}
}

ReferenceParam represents a reference-flavored search parameter. The following description is from the FHIR DSTU2 specification:

A reference parameter refers to references between resources, e.g. find all Conditions where the subject reference is a particular patient, where the patient is selected by name or identifier.

func ParseReferenceParam(paramStr string, info SearchParamInfo) *ReferenceParam

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry supports the registration and lookup of FHIR search parameters, both standard and custom. For custom search parameters, a parameter type implementation may also need to be registered.

func GlobalRegistry() *Registry

func (r *Registry) LookupParameterInfo(resource, name string) (param SearchParamInfo, err error)

func (r *Registry) LookupParameterParser(paramType string) (parser ParameterParser, err error)

func (r *Registry) RegisterParameterInfo(param SearchParamInfo)

func (r *Registry) RegisterParameterParser(paramType string, parser ParameterParser)

type RevIncludeOption ¶

type RevIncludeOption struct {
	Resource  string
	Parameter SearchParamInfo
}

RevIncludeOption describes the data that should be included in query results

type ReverseChainedQueryReference ¶

type ReverseChainedQueryReference struct {
	ReferenceName string // The name of the reference param
	Type          string // The type of resource being searched
	Query         Query
}

ReverseChainedQueryReference represents a reverse chained query

type SearchParam ¶

type SearchParam interface {
	// contains filtered or unexported methods
}

SearchParam is an interface for all search parameter classes that exposes the SearchParamInfo.

type SearchParamData ¶

type SearchParamData struct {
	Modifier string
	Chain    string
	Prefix   Prefix
	Value    string
}

SearchParamData represents the data associated to an instance of a search param

type SearchParamInfo ¶

type SearchParamInfo struct {
	Resource   string
	Name       string
	Type       string
	Paths      []SearchParamPath
	Composites []string
	Targets    []string
	Prefix     Prefix
	Postfix    string
	Modifier   string
}

SearchParamInfo contains information about a FHIR search parameter, including its name, type, and paths or composites.

func (s SearchParamInfo) CreateSearchParam(paramStr string) SearchParam

type SearchParamPath ¶

type SearchParamPath struct {
	Path string
	Type string
}

SearchParamPath indicates a dot-separated path to the property that should be searched, as well as the FHIR type of that property (e.g., "dateTime"). The path indicates elements that are arrays by prefixing the element name with "[]" (e.g., "order.[]item.name"). In the rare case that the search path has an indexer, it will be in the brackets (e.g.,"[0]item.entry")

type SortOption ¶

type SortOption struct {
	Descending bool
	Parameter  SearchParamInfo
}

SortOption indicates what parameter to sort on and the sort order

type StringParam ¶

type StringParam struct {
	SearchParamInfo
	String string
}

StringParam represents a string-flavored search parameter. The following description is from the FHIR DSTU2 specification:

The string parameter refers to simple string searches against sequences of characters. Matches are case- and accent- insensitive. By default, a field matches a string query if the value of the field equals or starts with the supplied parameter value, after both have been normalized by case and accent.

func ParseStringParam(paramString string, info SearchParamInfo) *StringParam

type TokenParam ¶

type TokenParam struct {
	SearchParamInfo
	System    string
	Code      string
	AnySystem bool
}

TokenParam represents a token-flavored search parameter. The following description is from the FHIR DSTU2 specification:

A token type is a parameter that searches on a pair, a URI and a value. It is used against code or identifier value where the value may have a URI that scopes its meaning. The search is performed against the pair from a Coding or an Identifier.

func ParseTokenParam(paramString string, info SearchParamInfo) *TokenParam

type URIParam ¶

type URIParam struct {
	SearchParamInfo
	URI string
}

URIParam represents a uri-flavored search parameter. The following description is from the FHIR DSTU2 specification:

The uri parameter refers to an element which is URI (RFC 3986). Matches are precise (e.g. case, accent, and escape) sensitive, and the entire URI must match.

func ParseURIParam(paramStr string, info SearchParamInfo) *URIParam

type URLQueryParameter ¶

type URLQueryParameter struct {
	Key   string
	Value string
}

URLQueryParameter represents a query parameter as a key/value pair.

type URLQueryParameters ¶

type URLQueryParameters struct {
	// contains filtered or unexported fields
}

URLQueryParameters represents an ordered list of query parameters that can be manipulated in several different ways.

func ParseQuery(query string) (u URLQueryParameters, err error)

func (u *URLQueryParameters) Add(Key string, value string)

func (u *URLQueryParameters) All() []URLQueryParameter

func (u *URLQueryParameters) Encode() string

func (u *URLQueryParameters) Get(key string) string

func (u *URLQueryParameters) GetMulti(key string) []string

func (u *URLQueryParameters) Set(key string, value string)

func (u *URLQueryParameters) Values() url.Values