blockchain/accesstokens.go

   1 package blockchain
   2
   3 import (
   4         "context"
   5         "encoding/json"
   6
   7         "github.com/bytom/blockchain/accesstoken"
   8         "github.com/bytom/errors"
   9         //      "github.com/bytom/net/http/authz"
  10         "github.com/bytom/net/http/httpjson"
  11 )
  12
  13 /*
  14 const (
  15         defGenericPageSize = 100
  16 )
  17 */
  18 var errCurrentToken = errors.New("token cannot delete itself")
  19
  20 func (bcr *BlockchainReactor) createAccessToken(ctx context.Context, x struct{ ID, Type string }) (*accesstoken.Token, error) {
  21         token, err := bcr.accesstoken.Create(ctx, x.ID, x.Type)
  22         if err != nil {
  23                 return nil, errors.Wrap(err)
  24         }
  25
  26
  27         if x.Type == "" {
  28                 return token, nil
  29         }
  30
  31         data := map[string]interface{}{
  32                 "id": token.ID,
  33         }
  34         _, err = json.Marshal(data)
  35         //      guardData, err := json.Marshal(data)
  36         if err != nil {
  37                 return nil, errors.Wrap(err)
  38         }
  39         /*
  40                 var grant *authz.Grant
  41
  42                 // Type is deprecated; however, for backward compatibility, using the
  43                 // Type field will create a grant associated with this new token.
  44                 switch x.Type {
  45                 case "client":
  46                         grant = &authz.Grant{
  47                                 GuardType: "access_token",
  48                                 GuardData: guardData,
  49                                 Policy:    "client-readwrite",
  50                         }
  51                 case "network":
  52                         grant = &authz.Grant{
  53                                 GuardType: "access_token",
  54                                 GuardData: guardData,
  55                                 Policy:    "crosscore",
  56                         }
  57                 default:
  58                         // We've already returned if x.Type wasn't specified, so this must be a bad type.
  59                         return nil, accesstoken.ErrBadType
  60                 }
  61                 err = a.sdb.Exec(ctx, a.grants.Save(ctx, grant))
  62                 if err != nil {
  63                         return nil, errors.Wrap(err)
  64                 }
  65         */
  66         token.Type = x.Type // deprecated
  67
  68         return token, nil
  69 }
  70
  71 func (bcr *BlockchainReactor) listAccessTokens(ctx context.Context, x requestQuery) (*page, error) {
  72         limit := x.PageSize
  73         if limit == 0 {
  74                 limit = 100
  75         }
  76
  77         tokens, next, err := bcr.accesstoken.List(ctx, x.Type, x.After, limit)
  78         if err != nil {
  79                 return nil, err
  80         }
  81
  82
  83         outQuery := x
  84         outQuery.After = next
  85
  86         return &page{
  87                 Items:    httpjson.Array(tokens),
  88                 LastPage: len(tokens) < limit,
  89                 Next:     outQuery,
  90         }, nil
  91 }
  92
  93 func (bcr *BlockchainReactor) deleteAccessToken(ctx context.Context, x struct{ ID string }) error {
  94         currentID, _, _ := httpjson.Request(ctx).BasicAuth()
  95         if currentID == x.ID {
  96                 return errCurrentToken
  97         }
  98         err := bcr.accesstoken.Delete(ctx, x.ID)
  99         if err != nil {
 100                 return err
 101         }
 102
 103
 104         /*      err = a.sdb.Exec(ctx, a.deleteGrantsByAccessToken(x.ID))
 105                 if err != nil {
 106                         // well, technically we did delete the access token, so don't return the error
 107                         // TODO(tessr): make this whole operation atomic, such that we either delete
 108                         // both the access token and its grants, or we return a failure.
 109                         log.Printkv(ctx, log.KeyError, err, "at", "revoking grants for access token", "token", x.ID)
 110                 }
 111         */return nil
 112 }