oauth

type AppSessionTokenHandler struct {
	Database         *appdb.Handle
	JSON             JSONResponseWriter
	AppSessionTokens AppSessionTokenIssuer
}

type AppSessionTokenIssuer interface {
	IssueAppSessionToken(refreshToken string) (string, *oauth.AppSessionToken, error)
}

type AppSessionTokenRequest struct {
	RefreshToken string `json:"refresh_token"`
}

type AppSessionTokenResponse struct {
	AppSessionToken string    `json:"app_session_token"`
	ExpireAt        time.Time `json:"expire_at"`
}

type AuthorizeHandler struct {
	Logger       AuthorizeHandlerLogger
	Database     *appdb.Handle
	AuthzHandler ProtocolAuthorizeHandler
}

type AuthorizeHandlerLogger struct{ *log.Logger }

type ChallengeHandler struct {
	Database   *appdb.Handle
	Challenges ChallengeProvider
	JSON       JSONResponseWriter
}

type ChallengeProvider interface {
	Create(purpose challenge.Purpose) (*challenge.Challenge, error)
}

type ChallengeRequest struct {
	Purpose challenge.Purpose `json:"purpose"`
}

type ChallengeResponse struct {
	Token    string    `json:"token"`
	ExpireAt time.Time `json:"expire_at"`
}

type ConsentHandler struct {
	Logger        ConsentHandlerLogger
	Database      *appdb.Handle
	Handler       ProtocolConsentHandler
	BaseViewModel *viewmodels.BaseViewModeler
	Renderer      Renderer
	Identities    ProtocolIdentityService
	Users         ConsentUserService
}

type ConsentHandlerLogger struct{ *log.Logger }

type ConsentUserService interface {
	Get(userID string, role accesscontrol.Role) (*model.User, error)
}

type ConsentViewModel struct {
	ClientName               string
	ClientPolicyURI          string
	ClientTOSURI             string
	IsRequestingFullUserInfo bool
	IdentityDisplayName      string
	UserProfile              webapp.UserProfile
}

type EndSessionHandler struct {
	Logger            EndSessionHandlerLogger
	Database          *appdb.Handle
	EndSessionHandler ProtocolEndSessionHandler
}

type EndSessionHandlerLogger struct{ *log.Logger }

type JSONResponseWriter interface {
	WriteResponse(rw http.ResponseWriter, resp *api.Response)
}

type JWKSHandler struct {
	Logger JWKSHandlerLogger
	JWKS   JWSSource
}

type JWKSHandlerLogger struct{ *log.Logger }

type JWSSource interface {
	GetPublicKeySet() (jwk.Set, error)
}

type MetadataHandler struct {
	Providers []MetadataProvider
}

type MetadataProvider interface {
	PopulateMetadata(meta map[string]interface{})
}

type OAuthClientResolver interface {
	ResolveClient(clientID string) *config.OAuthClientConfig
}

type ProtocolAuthorizeHandler interface {
	Handle(r protocol.AuthorizationRequest) httputil.Result
}

type ProtocolConsentHandler interface {
	HandleConsentWithoutUserConsent(req *http.Request) (httputil.Result, *oauthhandler.ConsentRequired)
	HandleConsentWithUserConsent(req *http.Request) httputil.Result
	HandleConsentWithUserCancel(req *http.Request) httputil.Result
}

type ProtocolEndSessionHandler interface {
	Handle(session.Session, protocol.EndSessionRequest, *http.Request, http.ResponseWriter) error
}

type ProtocolIdentityService interface {
	ListByUser(userID string) ([]*identity.Info, error)
}

type ProtocolProxyRedirectHandler interface {
	Validate(redirectURIWithQuery string) error
}

type ProtocolRevokeHandler interface {
	Handle(r protocol.RevokeRequest) error
}

type ProtocolTokenHandler interface {
	Handle(rw http.ResponseWriter, req *http.Request, r protocol.TokenRequest) httputil.Result
}

type ProtocolUserInfoProvider interface {
	GetUserInfo(userID string, clientLike *oauth.ClientLike) (map[string]interface{}, error)
}

type ProxyRedirectHandler struct {
	ProxyRedirectHandler ProtocolProxyRedirectHandler
}

type Renderer interface {
	RenderHTML(w http.ResponseWriter, r *http.Request, tpl *template.HTML, data interface{})
}

type RevokeHandler struct {
	Logger        RevokeHandlerLogger
	Database      *appdb.Handle
	RevokeHandler ProtocolRevokeHandler
}

type RevokeHandlerLogger struct{ *log.Logger }

type TokenHandler struct {
	Logger       TokenHandlerLogger
	Database     *appdb.Handle
	TokenHandler ProtocolTokenHandler
}

type TokenHandlerLogger struct{ *log.Logger }

type UserInfoHandler struct {
	Logger              UserInfoHandlerLogger
	Database            *appdb.Handle
	UserInfoProvider    ProtocolUserInfoProvider
	OAuth               *config.OAuthConfig
	OAuthClientResolver OAuthClientResolver
}

type UserInfoHandlerLogger struct{ *log.Logger }