升级企业版后更新 API 授权

package main

import (
   "context"
   "errors"
   "fmt"
   "os"

   "github.com/coze-dev/coze-go"
)

// How to use personal access token to init Coze client.
//
// Firstly, you need to access https://www.coze.com/open/oauth/pats (for the cn environment,
// visit https://www.coze.cn/open/oauth/pats).
//
// Click to add a new token. After setting the appropriate name, expiration time, and
// permissions, click OK to generate your personal access token. Please store it in a
// secure environment to prevent this personal access token from being disclosed.
func main() {
   cozeAPIToken := os.Getenv("COZE_API_TOKEN")
   cozeAPIToken4Enterprise := os.Getenv("COZE_API_TOKEN_ENTERPRISE")

   //
   // The default access is api.coze.com, but if you need to access api.coze.cn,
   // please use base_url to configure the api endpoint to access
   //
   cozeAPIBase := os.Getenv("COZE_API_BASE")

   ctx := context.Background()
   //
   // The Coze SDK offers the TokenAuth class for constructing an Auth class based on a fixed
   // access token. Meanwhile, the Coze class enables the passing in of an Auth class to build
   // a coze client.
   //
   // Therefore, you can utilize the following code to initialize a coze client.
   //
   
   cozeCli := coze.NewCozeAPI(coze.NewTokenAuth(cozeAPIToken), coze.WithBaseURL(cozeAPIBase))
   cozeCli4Enterprise := coze.NewCozeAPI(coze.NewTokenAuth(cozeAPIToken4Enterprise), coze.WithBaseURL(cozeAPIBase))
   
   // Try chat with the bot under your personal account
   resp, err := cozeCli.Chat.Create(ctx, &coze.CreateChatsReq{
      // your chat request params
   })
   if err == nil {
      fmt.Println(resp)
      return
   }
   // Retry chat with the bot under your enterprise account
   cozeErr := coze.Error{}
   if errors.As(err, &cozeErr) {
      // Authentication or Authorization Deny
      if cozeErr.Code == 4100 || cozeErr.Code == 4101 {
         resp, err = cozeCli4Enterprise.Chat.Create(ctx, &coze.CreateChatsReq{
            // your chat request params
         })
         if err == nil {
            fmt.Println(resp)
            return
         }
      }
   }
   fmt.Println(err)
}

package main

import (
   "context"
   "errors"
   "fmt"
   "net/http"
   "os"

   "github.com/coze-dev/coze-go"
)

// How to effectuate OpenAPI authorization through the OAuth authorization code method.
//
// Firstly, users need to access https://www.coze.com/open/oauth/apps. For the cn environment,
// users need to access https://www.coze.cn/open/oauth/apps to create an OAuth App of the type
// of Web application.
// The specific creation process can be referred to in the document:
// https://www.coze.com/docs/developer_guides/oauth_code. For the cn environment, it can be
// accessed at https://www.coze.cn/docs/developer_guides/oauth_code.
// After the creation is completed, the client ID, client secret, and redirect link, can be
// obtained. For the client secret, users need to keep it securely to avoid leakage.

func main() {
   redirectURI := os.Getenv("COZE_WEB_OAUTH_REDIRECT_URI")
   clientSecret := os.Getenv("COZE_WEB_OAUTH_CLIENT_SECRET")
   clientID := os.Getenv("COZE_WEB_OAUTH_CLIENT_ID")
   ctx := context.Background()

   // The default access is api.coze.com, but if you need to access api.coze.cn,
   // please use base_url to configure the api endpoint to access
   cozeAPIBase := os.Getenv("COZE_API_BASE")
   if cozeAPIBase == "" {
      cozeAPIBase = coze.ComBaseURL
   }

   // The sdk offers the WebOAuthClient class to establish an authorization for Web OAuth.
   // Firstly, it is required to initialize the WebOAuthApp with the client ID and client secret.
   oauth, err := coze.NewWebOAuthClient(clientID, clientSecret, coze.WithAuthBaseURL(cozeAPIBase))
   if err != nil {
      fmt.Printf("Failed to create OAuth client: %v\n", err)
      return
   }

   // Generate the authorization link and direct the user to open it.
   oauthURL := oauth.GetOAuthURL(ctx, &coze.GetWebOAuthURLReq{
      RedirectURI: redirectURI,
      State:       "state",
   })
   fmt.Println(oauthURL)

   // The space permissions for which the Access Token is granted can be specified. As following codes:
   // oauthURL = oauth.GetOAuthURL(&coze.GetWebOAuthURLReq{
   //     RedirectURI: redirectURI,
   //     State:       "state",
   //     WorkspaceID: &workspaceID,
   // })
   // fmt.Println(oauthURL)

   // After the user clicks the authorization consent button, the coze web page will redirect
   // to the redirect address configured in the authorization link and carry the authorization
   // code and state parameters in the address via the query string.
   //
   // Get from the query of the redirect interface: query.get('code')
   code := "mock code"

   // After obtaining the code after redirection, the interface to exchange the code for a
   // token can be invoked to generate the coze access_token of the authorized user.
   resp, err := oauth.GetAccessToken(ctx, &coze.GetWebOAuthAccessTokenReq{
      Code:        code,
      RedirectURI: redirectURI,
   })
   if err != nil {
      fmt.Printf("Failed to get access token: %v\n", err)
      return
   }
   fmt.Println(resp)

   // When the token expires, you can also refresh and re-obtain the token
   resp, err = oauth.RefreshToken(ctx, resp.RefreshToken)
   if err != nil {
      fmt.Printf("Failed to refresh token: %v\n", err)
      return
   }

   fmt.Printf("%+v\n", resp)

   // you can get request log by getLogID method
   fmt.Println(resp.LogID())

   // use the access token to init Coze client
   cozeCli := coze.NewCozeAPI(coze.NewTokenAuth(resp.AccessToken))
   _, err = cozeCli.Chat.Create(ctx, &coze.CreateChatsReq{
      // chat request params
   })
   if err != nil {
      cozeErr := coze.Error{}
      if errors.As(err, &cozeErr) {
         // no permission error code
         if cozeErr.Code == 4101 || cozeErr.Code == 4100 {
            // request user authorization agin
            // redirect to oauthURL
            // call http.Redirect(w, r, oauthURL, http.StatusFound)
         }
      }
   }
   _ = cozeCli
}