ory-am/hydra

Method DefaultStrategy.authenticationSession has 6 return statements (exceeds 4 allowed).

Open

func (s *DefaultStrategy) authenticationSession(ctx context.Context, _ http.ResponseWriter, r *http.Request) (*flow.LoginSession, error) {
    store, err := s.r.CookieStore(ctx)
    if err != nil {
        return nil, err
    }

Method Flow.HandleLoginRequest has 6 return statements (exceeds 4 allowed).

Open

func (f *Flow) HandleLoginRequest(h *HandledLoginRequest) error {
    if f.LoginWasUsed {
        return errors.WithStack(x.ErrConflict.WithHint("The login request was already used and can no longer be changed."))
    }

Function NewCreateClientsCommand has 6 return statements (exceeds 4 allowed).

Open

func NewCreateClientsCommand() *cobra.Command {
    cmd := &cobra.Command{
        Use:     "oauth2-client",
        Short:   "Create an OAuth 2.0 Client",
        Aliases: []string{"client"},

Function serve has 6 return statements (exceeds 4 allowed).

Open

func serve(
    ctx context.Context,
    d driver.Registry,
    cmd *cobra.Command,
    wg *sync.WaitGroup,

Method Handler.setOidcDynamicClient has 6 return statements (exceeds 4 allowed).

Open

func (h *Handler) setOidcDynamicClient(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    if err := h.requireDynamicAuth(r); err != nil {
        h.r.Writer().WriteError(w, r, err)
        return
    }

Method RegistrySQL.HealthHandler has 6 return statements (exceeds 4 allowed).

Open

func (m *RegistrySQL) HealthHandler() *healthx.Handler {
    if m.hh == nil {
        m.hh = healthx.NewHandler(m.Writer(), m.buildVersion, healthx.ReadyCheckers{
            "database": func(_ *http.Request) error {
                return m.Ping()

Function NewUpdateClientCmd has 6 return statements (exceeds 4 allowed).

Open

func NewUpdateClientCmd() *cobra.Command {
    cmd := &cobra.Command{
        Use:     "oauth2-client [id]",
        Aliases: []string{"client"},
        Short:   "Update an OAuth 2.0 Client",

Method MigrateHandler.MigrateStatus has 6 return statements (exceeds 4 allowed).

Open

func (h *MigrateHandler) MigrateStatus(cmd *cobra.Command, args []string) error {
    p, err := h.makePersister(cmd, args)
    if err != nil {
        return err
    }

Method Persister.findSessionBySignature has 6 return statements (exceeds 4 allowed).

Open

func (p *Persister) findSessionBySignature(ctx context.Context, signature string, session fosite.Session, table tableName) (fosite.Requester, error) {
    r := OAuth2RequestSQL{Table: table}
    err := p.QueryWithNetwork(ctx).Where("signature = ?", signature).First(&r)
    if errors.Is(err, sql.ErrNoRows) {
        return nil, errorsx.WithStack(fosite.ErrNotFound)

Method Handler.getOidcUserInfo has 6 return statements (exceeds 4 allowed).

Open

func (h *Handler) getOidcUserInfo(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    session := NewSessionWithCustomClaims(ctx, h.c, "")
    tokenType, ar, err := h.r.OAuth2Provider().IntrospectToken(ctx, fosite.AccessTokenFromRequest(r), fosite.AccessToken, session)
    if err != nil {

Method GrantValidator.Validate has 6 return statements (exceeds 4 allowed).

Open

func (v *GrantValidator) Validate(request createGrantRequest) error {
    if request.Issuer == "" {
        return errorsx.WithStack(ErrMissingRequiredParameter.WithHint("Field 'issuer' is required."))
    }

Function GetOrGenerateKeys has 6 return statements (exceeds 4 allowed).

Open

func GetOrGenerateKeys(ctx context.Context, r InternalRegistry, m Manager, set, kid, alg string) (private *jose.JSONWebKey, err error) {
    getLock(set).Lock()
    defer getLock(set).Unlock()

    keys, err := m.GetKeySet(ctx, set)

Similar blocks of code found in 3 locations. Consider refactoring.

Open

                    if encryptSecret && result.ClientSecret != nil {
                        enc, err := ek.Encrypt([]byte(*result.ClientSecret))
                        if err != nil {
                            _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Failed to encrypt client secret: %s", err)
                            return cmdx.FailSilently(cmd)

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            if encryptSecret && client.ClientSecret != nil {
                enc, err := ek.Encrypt([]byte(*client.ClientSecret))
                if err != nil {
                    _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Failed to encrypt client secret: %s", err)
                    return cmdx.FailSilently(cmd)

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            if encryptSecret && client.ClientSecret != nil {
                enc, err := ek.Encrypt([]byte(*client.ClientSecret))
                if err != nil {
                    _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Failed to encrypt client secret: %s", err)
                    return cmdx.FailSilently(cmd)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      consent: {
        accept: acceptConsent = true,
        skip: skipConsent = false,
        remember: rememberConsent = false,
        scope: acceptScope = [],

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      consent: {
        accept: acceptConsent = true,
        skip: skipConsent = false,
        remember: rememberConsent = false,
        scope: acceptScope = [],

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

  if (!req.query.code) {
    res.send(JSON.stringify({ result: "error", error: "no code given" }))
    return
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

  if (!req.query.code) {
    res.send(JSON.stringify({ result: "error", error: "no code given" }))
    return
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        for _, tc := range []struct{ token string }{
            {""},
            {"foo"},
            {"foo.bar"},
            // tokens with three parts will be handled by the JWT strategy

• Read up
  Read up