careplanservice

type AnyMatchPolicy ¶

type AnyMatchPolicy[T any] struct {
	Policies []Policy[T]
}

AnyMatchPolicy is a policy that allows access if any of the policies in the list allow access.

func (e AnyMatchPolicy[T]) HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)

type AnyonePolicy ¶

type AnyonePolicy[T any] struct {
}

AnyonePolicy is a policy that allows access to anyone.

func (e AnyonePolicy[T]) HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)

type CarePlanCreatedEvent ¶

type CarePlanCreatedEvent struct {
	fhir.CarePlan
}

func (c CarePlanCreatedEvent) Entity() messaging.Entity

func (c CarePlanCreatedEvent) Instance() events.Type

type CareTeamMemberPolicy ¶

type CareTeamMemberPolicy[T fhir.CarePlan] struct {
}

CareTeamMemberPolicy is a policy that allows access if the user is a member of the care team.

func (c CareTeamMemberPolicy[T]) HasAccess(ctx context.Context, resource *T, principal auth.Principal) (*PolicyDecision, error)

type Config ¶

type Config struct {
	Enabled bool         `koanf:"enabled"`
	Events  EventsConfig `koanf:"events"`
}

func DefaultConfig() Config

func (c Config) Validate() error

type CreatorPolicy ¶

type CreatorPolicy[T fhir.HasExtension] struct {
}

CreatorPolicy is a policy that allows access if the principal is the creator of the resource.

func (o CreatorPolicy[T]) HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)

type EventsConfig ¶

type EventsConfig struct {
	WebHooks []WebHookEventHandlerConfig `koanf:"webhooks"`
}

type FHIRClientFactory ¶

type FHIRClientFactory func(ctx context.Context) (fhirclient.Client, error)

func FHIRClientFactoryFor(fhirClient fhirclient.Client) FHIRClientFactory

type FHIRCreateOperationHandler ¶

type FHIRCreateOperationHandler[T fhir.HasExtension] struct {
	// contains filtered or unexported fields
}

func (h FHIRCreateOperationHandler[T]) Handle(ctx context.Context, request FHIRHandlerRequest, tx *coolfhir.BundleBuilder) (FHIRHandlerResult, error)

type FHIRHandler ¶

type FHIRHandler func(http.ResponseWriter, *http.Request, *coolfhir.BundleBuilder) (FHIRHandlerResult, error)

FHIRHandler defines a function that handles a FHIR request and returns a function to write the response. It may be executed singular, or be part of a Bundle that causes multiple handlers to be executed. It is provided with a BundleBuilder to add FHIR resource operations that must be executed on the backing FHIR server. The handler itself must not cause side-effects in the FHIR server: those MUST be effectuated through the transaction.

type FHIRHandlerRequest ¶

type FHIRHandlerRequest struct {
	ResourceId   string
	ResourcePath string
	ResourceData json.RawMessage
	HttpMethod   string
	HttpHeaders  http.Header
	FhirHeaders  *fhirclient.Headers
	QueryParams  url.Values
	RequestUrl   *url.URL
	FullUrl      string
	BaseURL      *url.URL
	Context      context.Context
	Tenant       tenants.Properties
	// Principal contains the identity of the client invoking the FHIR operation.
	Principal *auth.Principal
	// LocalIdentity contains the identifier of the local care organization handling the FHIR operation invocation.
	LocalIdentity *fhir.Identifier
	Upsert        bool
}

type FHIRHandlerResult ¶

type FHIRHandlerResult func(txResult *fhir.Bundle) ([]*fhir.BundleEntry, []any, error)

FHIRHandlerResult is the result of a FHIRHandler execution. It returns: - the resources that should be returned, given the transaction result - a list of resources that should be notified to subscribers

type FHIROperation ¶

type FHIROperation interface {
	Handle(context.Context, FHIRHandlerRequest, *coolfhir.BundleBuilder) (FHIRHandlerResult, error)
}

type FHIRReadOperationHandler ¶

type FHIRReadOperationHandler[T fhir.HasExtension] struct {
	// contains filtered or unexported fields
}

func (h FHIRReadOperationHandler[T]) Handle(ctx context.Context, request FHIRHandlerRequest, tx *coolfhir.BundleBuilder) (FHIRHandlerResult, error)

type FHIRSearchOperationHandler ¶

type FHIRSearchOperationHandler[T any] struct {
	// contains filtered or unexported fields
}

func (h FHIRSearchOperationHandler[T]) Handle(ctx context.Context, request FHIRHandlerRequest, tx *coolfhir.BundleBuilder) (FHIRHandlerResult, error)

type FHIRUpdateOperationHandler ¶

type FHIRUpdateOperationHandler[T fhir.HasExtension] struct {
	// contains filtered or unexported fields
}

func (h FHIRUpdateOperationHandler[T]) Handle(ctx context.Context, request FHIRHandlerRequest, tx *coolfhir.BundleBuilder) (FHIRHandlerResult, error)

type LocalOrganizationPolicy ¶

type LocalOrganizationPolicy[T any] struct {
	// contains filtered or unexported fields
}

LocalOrganizationPolicy is a policy that allows access if the principal is a local organization.

func (l LocalOrganizationPolicy[T]) HasAccess(ctx context.Context, _ T, principal auth.Principal) (*PolicyDecision, error)

type MockPolicy ¶

type MockPolicy[T any] struct {
	// contains filtered or unexported fields
}

MockPolicy is a mock of Policy interface.

func NewMockPolicy[T any](ctrl *gomock.Controller) *MockPolicy[T]

func (m *MockPolicy[T]) EXPECT() *MockPolicyMockRecorder[T]

func (m *MockPolicy[T]) HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)

type MockPolicyMockRecorder ¶

type MockPolicyMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

MockPolicyMockRecorder is the mock recorder for MockPolicy.

func (mr *MockPolicyMockRecorder[T]) HasAccess(ctx, resource, principal any) *gomock.Call

type PatientValidator ¶

type PatientValidator struct {
}

func (v *PatientValidator) Validate(patient *fhir.Patient) []*validation.Error

type Policy ¶

type Policy[T any] interface {
	HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)
}

func CreateConditionAuthzPolicy(profile profile.Provider) Policy[*fhir.Condition]

func CreatePatientAuthzPolicy(profile profile.Provider) Policy[*fhir.Patient]

func CreateQuestionnaireAuthzPolicy() Policy[*fhir.Questionnaire]

func CreateQuestionnaireResponseAuthzPolicy(profile profile.Provider) Policy[*fhir.QuestionnaireResponse]

func CreateServiceRequestAuthzPolicy(profile profile.Provider) Policy[*fhir.ServiceRequest]

func ReadCarePlanAuthzPolicy() Policy[*fhir.CarePlan]

func ReadConditionAuthzPolicy(fhirClientFactory FHIRClientFactory) Policy[*fhir.Condition]

func ReadPatientAuthzPolicy(fhirClientFactory FHIRClientFactory) Policy[*fhir.Patient]

func ReadQuestionnaireAuthzPolicy() Policy[*fhir.Questionnaire]

func ReadQuestionnaireResponseAuthzPolicy(fhirClientFactory FHIRClientFactory) Policy[*fhir.QuestionnaireResponse]

func ReadServiceRequestAuthzPolicy(fhirClientFactory FHIRClientFactory) Policy[*fhir.ServiceRequest]

func ReadTaskAuthzPolicy(fhirClientFactory FHIRClientFactory) Policy[*fhir.Task]

func UpdateConditionAuthzPolicy() Policy[*fhir.Condition]

func UpdatePatientAuthzPolicy() Policy[*fhir.Patient]

func UpdateQuestionnaireAuthzPolicy() Policy[*fhir.Questionnaire]

func UpdateQuestionnaireResponseAuthzPolicy() Policy[*fhir.QuestionnaireResponse]

func UpdateServiceRequestAuthzPolicy() Policy[*fhir.ServiceRequest]

type PolicyDecision ¶

type PolicyDecision struct {
	Allowed bool
	Reasons []string
}

type RelatedResourcePolicy ¶

type RelatedResourcePolicy[T any, R any] struct {
	// contains filtered or unexported fields
}

RelatedResourcePolicy is a policy that allows access if the user has access to the related resource(s). For instance, if the user has access to a ServiceRequest, if the user has access to the related Task.

func (r RelatedResourcePolicy[T, R]) HasAccess(ctx context.Context, resource T, principal auth.Principal) (*PolicyDecision, error)

type Service ¶

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

func New(config Config, tenantCfg tenants.Config, profile profile.Provider, orcaPublicURL *url.URL, messageBroker messaging.Broker, eventManager events.Manager) (*Service, error)

func (s *Service) RegisterHandlers(mux *http.ServeMux)

type TaskOwnerOrRequesterPolicy ¶

type TaskOwnerOrRequesterPolicy[T fhir.Task] struct {
}

TaskOwnerOrRequesterPolicy is a policy that allows access if the user is the owner of the task or the requester of the task.

func (t TaskOwnerOrRequesterPolicy[T]) HasAccess(ctx context.Context, resource *T, principal auth.Principal) (*PolicyDecision, error)

type WebHookEventHandlerConfig ¶

type WebHookEventHandlerConfig struct {
	// URL is the URL to which the event should be sent.
	URL string
}