| // Package oauth2 provides access to the Google OAuth2 API. |
| // |
| // See https://developers.google.com/accounts/docs/OAuth2 |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/oauth2/v1" |
| // ... |
| // oauth2Service, err := oauth2.New(oauthHttpClient) |
| package oauth2 |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "golang.org/x/net/context" |
| "google.golang.org/api/googleapi" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Background |
| |
| const apiId = "oauth2:v1" |
| const apiName = "oauth2" |
| const apiVersion = "v1" |
| const basePath = "https://www.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // Know your basic profile info and list of people in your circles. |
| PlusLoginScope = "https://www.googleapis.com/auth/plus.login" |
| |
| // Know who you are on Google |
| PlusMeScope = "https://www.googleapis.com/auth/plus.me" |
| |
| // View your email address |
| UserinfoEmailScope = "https://www.googleapis.com/auth/userinfo.email" |
| |
| // View your basic profile info |
| UserinfoProfileScope = "https://www.googleapis.com/auth/userinfo.profile" |
| ) |
| |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Userinfo = NewUserinfoService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| |
| Userinfo *UserinfoService |
| } |
| |
| func NewUserinfoService(s *Service) *UserinfoService { |
| rs := &UserinfoService{s: s} |
| rs.V2 = NewUserinfoV2Service(s) |
| return rs |
| } |
| |
| type UserinfoService struct { |
| s *Service |
| |
| V2 *UserinfoV2Service |
| } |
| |
| func NewUserinfoV2Service(s *Service) *UserinfoV2Service { |
| rs := &UserinfoV2Service{s: s} |
| rs.Me = NewUserinfoV2MeService(s) |
| return rs |
| } |
| |
| type UserinfoV2Service struct { |
| s *Service |
| |
| Me *UserinfoV2MeService |
| } |
| |
| func NewUserinfoV2MeService(s *Service) *UserinfoV2MeService { |
| rs := &UserinfoV2MeService{s: s} |
| return rs |
| } |
| |
| type UserinfoV2MeService struct { |
| s *Service |
| } |
| |
| type Raw struct { |
| Keyvalues []*RawKeyvalues `json:"keyvalues,omitempty"` |
| } |
| |
| type RawKeyvalues struct { |
| Algorithm string `json:"algorithm,omitempty"` |
| |
| Exponent string `json:"exponent,omitempty"` |
| |
| Keyid string `json:"keyid,omitempty"` |
| |
| Modulus string `json:"modulus,omitempty"` |
| } |
| |
| type Tokeninfo struct { |
| // Access_type: The access type granted with this token. It can be |
| // offline or online. |
| Access_type string `json:"access_type,omitempty"` |
| |
| // Audience: Who is the intended audience for this token. In general the |
| // same as issued_to. |
| Audience string `json:"audience,omitempty"` |
| |
| // Email: The email address of the user. Present only if the email scope |
| // is present in the request. |
| Email string `json:"email,omitempty"` |
| |
| // Email_verified: Boolean flag which is true if the email address is |
| // verified. Present only if the email scope is present in the request. |
| Email_verified bool `json:"email_verified,omitempty"` |
| |
| // Expires_in: The expiry time of the token, as number of seconds left |
| // until expiry. |
| Expires_in int64 `json:"expires_in,omitempty"` |
| |
| // Issued_at: The issue time of the token, as number of seconds. |
| Issued_at int64 `json:"issued_at,omitempty"` |
| |
| // Issued_to: To whom was the token issued to. In general the same as |
| // audience. |
| Issued_to string `json:"issued_to,omitempty"` |
| |
| // Issuer: Who issued the token. |
| Issuer string `json:"issuer,omitempty"` |
| |
| // Nonce: Nonce of the id token. |
| Nonce string `json:"nonce,omitempty"` |
| |
| // Scope: The space separated list of scopes granted to this token. |
| Scope string `json:"scope,omitempty"` |
| |
| // User_id: The Gaia obfuscated user id. |
| User_id string `json:"user_id,omitempty"` |
| |
| // Verified_email: Boolean flag which is true if the email address is |
| // verified. Present only if the email scope is present in the request. |
| Verified_email bool `json:"verified_email,omitempty"` |
| } |
| |
| type Userinfoplus struct { |
| // Email: The user's email address. |
| Email string `json:"email,omitempty"` |
| |
| // Family_name: The user's last name. |
| Family_name string `json:"family_name,omitempty"` |
| |
| // Gender: The user's gender. |
| Gender string `json:"gender,omitempty"` |
| |
| // Given_name: The user's first name. |
| Given_name string `json:"given_name,omitempty"` |
| |
| // Hd: The hosted domain e.g. example.com if the user is Google apps |
| // user. |
| Hd string `json:"hd,omitempty"` |
| |
| // Id: The focus obfuscated gaia id of the user. |
| Id string `json:"id,omitempty"` |
| |
| // Link: URL of the profile page. |
| Link string `json:"link,omitempty"` |
| |
| // Locale: The user's preferred locale. |
| Locale string `json:"locale,omitempty"` |
| |
| // Name: The user's full name. |
| Name string `json:"name,omitempty"` |
| |
| // Picture: URL of the user's picture image. |
| Picture string `json:"picture,omitempty"` |
| |
| // Verified_email: Boolean flag which is true if the email address is |
| // verified. Always verified because we only return the user's primary |
| // email address. |
| Verified_email bool `json:"verified_email,omitempty"` |
| } |
| |
| // method id "oauth2.getCertForOpenIdConnect": |
| |
| type GetCertForOpenIdConnectCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // GetCertForOpenIdConnect: |
| func (s *Service) GetCertForOpenIdConnect() *GetCertForOpenIdConnectCall { |
| c := &GetCertForOpenIdConnectCall{s: s, opt_: make(map[string]interface{})} |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *GetCertForOpenIdConnectCall) Fields(s ...googleapi.Field) *GetCertForOpenIdConnectCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *GetCertForOpenIdConnectCall) Do() (map[string]string, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "oauth2/v1/certs") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret map[string]string |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "httpMethod": "GET", |
| // "id": "oauth2.getCertForOpenIdConnect", |
| // "path": "oauth2/v1/certs", |
| // "response": { |
| // "$ref": "X509" |
| // } |
| // } |
| |
| } |
| |
| // method id "oauth2.getCertForOpenIdConnectRaw": |
| |
| type GetCertForOpenIdConnectRawCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // GetCertForOpenIdConnectRaw: |
| func (s *Service) GetCertForOpenIdConnectRaw() *GetCertForOpenIdConnectRawCall { |
| c := &GetCertForOpenIdConnectRawCall{s: s, opt_: make(map[string]interface{})} |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *GetCertForOpenIdConnectRawCall) Fields(s ...googleapi.Field) *GetCertForOpenIdConnectRawCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *GetCertForOpenIdConnectRawCall) Do() (*Raw, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "oauth2/v1/raw_public_keys") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *Raw |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "httpMethod": "GET", |
| // "id": "oauth2.getCertForOpenIdConnectRaw", |
| // "path": "oauth2/v1/raw_public_keys", |
| // "response": { |
| // "$ref": "Raw" |
| // } |
| // } |
| |
| } |
| |
| // method id "oauth2.getRobotMetadataRaw": |
| |
| type GetRobotMetadataRawCall struct { |
| s *Service |
| robotEmail string |
| opt_ map[string]interface{} |
| } |
| |
| // GetRobotMetadataRaw: |
| func (s *Service) GetRobotMetadataRaw(robotEmail string) *GetRobotMetadataRawCall { |
| c := &GetRobotMetadataRawCall{s: s, opt_: make(map[string]interface{})} |
| c.robotEmail = robotEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *GetRobotMetadataRawCall) Fields(s ...googleapi.Field) *GetRobotMetadataRawCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *GetRobotMetadataRawCall) Do() (*Raw, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "service_accounts/v1/metadata/raw/{robotEmail}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "robotEmail": c.robotEmail, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *Raw |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "httpMethod": "GET", |
| // "id": "oauth2.getRobotMetadataRaw", |
| // "parameterOrder": [ |
| // "robotEmail" |
| // ], |
| // "parameters": { |
| // "robotEmail": { |
| // "description": "The email of robot account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "service_accounts/v1/metadata/raw/{robotEmail}", |
| // "response": { |
| // "$ref": "Raw" |
| // } |
| // } |
| |
| } |
| |
| // method id "oauth2.getRobotMetadataX509": |
| |
| type GetRobotMetadataX509Call struct { |
| s *Service |
| robotEmail string |
| opt_ map[string]interface{} |
| } |
| |
| // GetRobotMetadataX509: |
| func (s *Service) GetRobotMetadataX509(robotEmail string) *GetRobotMetadataX509Call { |
| c := &GetRobotMetadataX509Call{s: s, opt_: make(map[string]interface{})} |
| c.robotEmail = robotEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *GetRobotMetadataX509Call) Fields(s ...googleapi.Field) *GetRobotMetadataX509Call { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *GetRobotMetadataX509Call) Do() (map[string]string, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "service_accounts/v1/metadata/x509/{robotEmail}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "robotEmail": c.robotEmail, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret map[string]string |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "httpMethod": "GET", |
| // "id": "oauth2.getRobotMetadataX509", |
| // "parameterOrder": [ |
| // "robotEmail" |
| // ], |
| // "parameters": { |
| // "robotEmail": { |
| // "description": "The email of robot account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "service_accounts/v1/metadata/x509/{robotEmail}", |
| // "response": { |
| // "$ref": "X509" |
| // } |
| // } |
| |
| } |
| |
| // method id "oauth2.tokeninfo": |
| |
| type TokeninfoCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // Tokeninfo: Get token info |
| func (s *Service) Tokeninfo() *TokeninfoCall { |
| c := &TokeninfoCall{s: s, opt_: make(map[string]interface{})} |
| return c |
| } |
| |
| // Access_token sets the optional parameter "access_token": The oauth2 |
| // access token |
| func (c *TokeninfoCall) Access_token(access_token string) *TokeninfoCall { |
| c.opt_["access_token"] = access_token |
| return c |
| } |
| |
| // Id_token sets the optional parameter "id_token": The ID token |
| func (c *TokeninfoCall) Id_token(id_token string) *TokeninfoCall { |
| c.opt_["id_token"] = id_token |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *TokeninfoCall) Fields(s ...googleapi.Field) *TokeninfoCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *TokeninfoCall) Do() (*Tokeninfo, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["access_token"]; ok { |
| params.Set("access_token", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["id_token"]; ok { |
| params.Set("id_token", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "oauth2/v1/tokeninfo") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *Tokeninfo |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get token info", |
| // "httpMethod": "POST", |
| // "id": "oauth2.tokeninfo", |
| // "parameters": { |
| // "access_token": { |
| // "description": "The oauth2 access token", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "id_token": { |
| // "description": "The ID token", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "oauth2/v1/tokeninfo", |
| // "response": { |
| // "$ref": "Tokeninfo" |
| // } |
| // } |
| |
| } |
| |
| // method id "oauth2.userinfo.get": |
| |
| type UserinfoGetCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // Get: Get user info |
| func (r *UserinfoService) Get() *UserinfoGetCall { |
| c := &UserinfoGetCall{s: r.s, opt_: make(map[string]interface{})} |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *UserinfoGetCall) Fields(s ...googleapi.Field) *UserinfoGetCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *UserinfoGetCall) Do() (*Userinfoplus, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "oauth2/v1/userinfo") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *Userinfoplus |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get user info", |
| // "httpMethod": "GET", |
| // "id": "oauth2.userinfo.get", |
| // "path": "oauth2/v1/userinfo", |
| // "response": { |
| // "$ref": "Userinfoplus" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/plus.login", |
| // "https://www.googleapis.com/auth/plus.me", |
| // "https://www.googleapis.com/auth/userinfo.email", |
| // "https://www.googleapis.com/auth/userinfo.profile" |
| // ] |
| // } |
| |
| } |
| |
| // method id "oauth2.userinfo.v2.me.get": |
| |
| type UserinfoV2MeGetCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // Get: Get user info |
| func (r *UserinfoV2MeService) Get() *UserinfoV2MeGetCall { |
| c := &UserinfoV2MeGetCall{s: r.s, opt_: make(map[string]interface{})} |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. |
| // See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *UserinfoV2MeGetCall) Fields(s ...googleapi.Field) *UserinfoV2MeGetCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *UserinfoV2MeGetCall) Do() (*Userinfoplus, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "userinfo/v2/me") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *Userinfoplus |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get user info", |
| // "httpMethod": "GET", |
| // "id": "oauth2.userinfo.v2.me.get", |
| // "path": "userinfo/v2/me", |
| // "response": { |
| // "$ref": "Userinfoplus" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/plus.login", |
| // "https://www.googleapis.com/auth/plus.me", |
| // "https://www.googleapis.com/auth/userinfo.email", |
| // "https://www.googleapis.com/auth/userinfo.profile" |
| // ] |
| // } |
| |
| } |