pkg

type AccessTokenHandler interface {
	// CreateJwtBearerToken from a JwtBearerTokenRequest. Returns a signed JWT string.
	CreateJwtBearerToken(request *CreateJwtBearerTokenRequest) (token *JwtBearerTokenResponse, err error)

	// ParseAndValidateJwtBearerToken accepts a jwt encoded bearer token as string and returns the NutsJwtBearerToken object if valid.
	// it returns a ErrLegalEntityNotProvided if the issuer does not contain an legal entity
	// it returns a ErrOrganizationNotFound if the organization in the issuer could not be found in the registry
	ParseAndValidateJwtBearerToken(token string) (*NutsJwtBearerToken, error)

	// BuildAccessToken create a jwt encoded access token from a NutsJwtBearerToken and a ContractValidationResult.
	BuildAccessToken(jwtClaims *NutsJwtBearerToken, identityValidationResult *ContractValidationResult) (token string, err error)

	// ParseAndValidateAccessToken parses and validates an AccessToken and returns a filled NutsAccessToken as result.
	// it returns a ErrLegalEntityNotProvided if the issuer does not contain an legal entity
	// it returns a ErrOrganizationNotFound if the organization in the issuer could not be found in the registry
	ParseAndValidateAccessToken(accessToken string) (*NutsAccessToken, error)
}

type AccessTokenResponse struct {
	AccessToken string
}

type Auth struct {
	Config AuthConfig

	ContractSessionHandler ContractSessionHandler
	ContractValidator      ContractValidator
	AccessTokenHandler     AccessTokenHandler
	// contains filtered or unexported fields
}

type AuthClient interface {
	CreateContractSession(sessionRequest CreateSessionRequest) (*CreateSessionResult, error)
	ContractSessionStatus(sessionID string) (*SessionStatusResult, error)
	ContractByType(contractType ContractType, language Language, version Version) (*Contract, error)
	ValidateContract(request ValidationRequest) (*ContractValidationResult, error)
	CreateAccessToken(request CreateAccessTokenRequest) (*AccessTokenResponse, error)
	CreateJwtBearerToken(request CreateJwtBearerTokenRequest) (*JwtBearerTokenResponse, error)
	IntrospectAccessToken(token string) (*NutsAccessToken, error)
	KeyExistsFor(legalEntity string) bool
	OrganizationNameByID(legalEntity string) (string, error)
}

type AuthConfig struct {
	Mode                      string
	Address                   string
	PublicUrl                 string
	IrmaConfigPath            string
	IrmaSchemeManager         string
	SkipAutoUpdateIrmaSchemas bool
	ActingPartyCn             string
	EnableCORS                bool
}

type Contract struct {
	Type                 ContractType `json:"type"`
	Version              Version      `json:"version"`
	Language             Language     `json:"language"`
	SignerAttributes     []string     `json:"signer_attributes"`
	SignerDemoAttributes []string     `json:"-"`
	Template             string       `json:"template"`
	TemplateAttributes   []string     `json:"template_attributes"`
	Regexp               string       `json:"-"`
}

type ContractFormat string

type ContractSessionHandler interface {
	SessionStatus(session SessionID) (*SessionStatusResult, error)
	StartSession(request interface{}, handler irmaserver.SessionHandler) (*irma.Qr, string, error)
}

type ContractType string

type ContractValidationResult struct {
	ValidationResult ValidationState `json:"validation_result"`
	ContractFormat   ContractFormat  `json:"contract_format"`
	// DisclosedAttributes contain the attributes used to sign this contract
	DisclosedAttributes map[string]string `json:"disclosed_attributes"`
}

type ContractValidator interface {
	ValidateContract(contract string, format ContractFormat, actingPartyCN string) (*ContractValidationResult, error)
	ValidateJwt(contract string, actingPartyCN string) (*ContractValidationResult, error)
	IsInitialized() bool
}

type CreateAccessTokenRequest struct {
	JwtBearerToken   string
	VendorIdentifier string
}

type CreateJwtBearerTokenRequest struct {
	Actor         string
	Custodian     string
	IdentityToken string
	Subject       string
	Scope         string
}

type CreateSessionRequest struct {
	// ContractType such as "BehandelaarLogin"
	Type ContractType
	// Version of the contract such as "v1"
	Version Version
	// Language of the contact such as "NL"
	Language Language
	// LegalEntity denotes the organization of the user
	LegalEntity string
	// ValidFrom describes the time from which this contract should be considered valid
	ValidFrom time.Time
	// ValidFrom describes the time until this contract should be considered valid
	ValidTo time.Time
	// TemplateAttributes is an object containing extra template values. example: {"reason":"providing care"}
	TemplateAttributes map[string]string
}

type CreateSessionResult struct {
	QrCodeInfo irma.Qr
	SessionID  string
}

type DefaultIrmaClient struct {
	I *irmaserver.Server
}

type DefaultValidator struct {
	IrmaServer IrmaServerClient
	IrmaConfig *irma.Configuration
	Registry   registry.RegistryClient
	Crypto     nutscrypto.Client
}

type IrmaServerClient interface {
	GetSessionResult(token string) *server.SessionResult
	StartSession(request interface{}, handler irmaserver.SessionHandler) (*irma.Qr, string, error)
}

type JwtBearerTokenResponse struct {
	BearerToken string
}

type Language string

type NutsAccessToken struct {
	jwt.StandardClaims
	SubjectID  string `json:"sid"`
	Scope      string `json:"scope"`
	Name       string `json:"name"`
	GivenName  string `json:"given_name"`
	Prefix     string `json:"prefix"`
	FamilyName string `json:"family_name"`
	Email      string `json:"email"`
}

type NutsIdentityToken struct {
	jwt.StandardClaims
	//Identifier of the legalEntity who issued and signed the token
	//Issuer string
	// What kind of signature? Currently only IRMA is supported
	Type ContractFormat `json:"type"`
	// The base64 encoded signature
	Signature string `json:"sig"`
}

type NutsJwtBearerToken struct {
	jwt.StandardClaims
	IdentityToken string `json:"usi"`
	SubjectID     string `json:"sid"`
	Scope         string `json:"scope"`
}

type SessionID string

type SessionStatusResult struct {
	server.SessionResult
	// NutsAuthToken contains the JWT if the sessionStatus is DONE
	NutsAuthToken string `json:"nuts_auth_token"`
}

type SignedIrmaContract struct {
	IrmaContract irma.SignedMessage
}

type ValidationRequest struct {
	// ContractFormat specifies the type of format used for the contract, e.g. 'irma'
	ContractFormat ContractFormat

	// The actual contract in string format to validate
	ContractString string

	// ActingPartyCN is the common name of the Acting party extracted from the client cert
	ActingPartyCN string
}

type ValidationState string

type Version string