| // Package admin provides access to the Admin Directory API. |
| // |
| // See https://developers.google.com/admin-sdk/directory/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/admin/directory/v1" |
| // ... |
| // adminService, err := admin.New(oauthHttpClient) |
| package admin // import "google.golang.org/api/admin/directory/v1" |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| context "golang.org/x/net/context" |
| ctxhttp "golang.org/x/net/context/ctxhttp" |
| gensupport "google.golang.org/api/gensupport" |
| googleapi "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 _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| var _ = ctxhttp.Do |
| |
| const apiId = "admin:directory_v1" |
| const apiName = "admin" |
| const apiVersion = "directory_v1" |
| const basePath = "https://www.googleapis.com/admin/directory/v1/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage customer related information |
| AdminDirectoryCustomerScope = "https://www.googleapis.com/auth/admin.directory.customer" |
| |
| // View customer related information |
| AdminDirectoryCustomerReadonlyScope = "https://www.googleapis.com/auth/admin.directory.customer.readonly" |
| |
| // View and manage your Chrome OS devices' metadata |
| AdminDirectoryDeviceChromeosScope = "https://www.googleapis.com/auth/admin.directory.device.chromeos" |
| |
| // View your Chrome OS devices' metadata |
| AdminDirectoryDeviceChromeosReadonlyScope = "https://www.googleapis.com/auth/admin.directory.device.chromeos.readonly" |
| |
| // View and manage your mobile devices' metadata |
| AdminDirectoryDeviceMobileScope = "https://www.googleapis.com/auth/admin.directory.device.mobile" |
| |
| // Manage your mobile devices by performing administrative tasks |
| AdminDirectoryDeviceMobileActionScope = "https://www.googleapis.com/auth/admin.directory.device.mobile.action" |
| |
| // View your mobile devices' metadata |
| AdminDirectoryDeviceMobileReadonlyScope = "https://www.googleapis.com/auth/admin.directory.device.mobile.readonly" |
| |
| // View and manage the provisioning of domains for your customers |
| AdminDirectoryDomainScope = "https://www.googleapis.com/auth/admin.directory.domain" |
| |
| // View domains related to your customers |
| AdminDirectoryDomainReadonlyScope = "https://www.googleapis.com/auth/admin.directory.domain.readonly" |
| |
| // View and manage the provisioning of groups on your domain |
| AdminDirectoryGroupScope = "https://www.googleapis.com/auth/admin.directory.group" |
| |
| // View and manage group subscriptions on your domain |
| AdminDirectoryGroupMemberScope = "https://www.googleapis.com/auth/admin.directory.group.member" |
| |
| // View group subscriptions on your domain |
| AdminDirectoryGroupMemberReadonlyScope = "https://www.googleapis.com/auth/admin.directory.group.member.readonly" |
| |
| // View groups on your domain |
| AdminDirectoryGroupReadonlyScope = "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| |
| // View and manage notifications received on your domain |
| AdminDirectoryNotificationsScope = "https://www.googleapis.com/auth/admin.directory.notifications" |
| |
| // View and manage organization units on your domain |
| AdminDirectoryOrgunitScope = "https://www.googleapis.com/auth/admin.directory.orgunit" |
| |
| // View organization units on your domain |
| AdminDirectoryOrgunitReadonlyScope = "https://www.googleapis.com/auth/admin.directory.orgunit.readonly" |
| |
| // View and manage the provisioning of calendar resources on your domain |
| AdminDirectoryResourceCalendarScope = "https://www.googleapis.com/auth/admin.directory.resource.calendar" |
| |
| // View calendar resources on your domain |
| AdminDirectoryResourceCalendarReadonlyScope = "https://www.googleapis.com/auth/admin.directory.resource.calendar.readonly" |
| |
| // Manage delegated admin roles for your domain |
| AdminDirectoryRolemanagementScope = "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| |
| // View delegated admin roles for your domain |
| AdminDirectoryRolemanagementReadonlyScope = "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| |
| // View and manage the provisioning of users on your domain |
| AdminDirectoryUserScope = "https://www.googleapis.com/auth/admin.directory.user" |
| |
| // View and manage user aliases on your domain |
| AdminDirectoryUserAliasScope = "https://www.googleapis.com/auth/admin.directory.user.alias" |
| |
| // View user aliases on your domain |
| AdminDirectoryUserAliasReadonlyScope = "https://www.googleapis.com/auth/admin.directory.user.alias.readonly" |
| |
| // View users on your domain |
| AdminDirectoryUserReadonlyScope = "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| |
| // Manage data access permissions for users on your domain |
| AdminDirectoryUserSecurityScope = "https://www.googleapis.com/auth/admin.directory.user.security" |
| |
| // View and manage the provisioning of user schemas on your domain |
| AdminDirectoryUserschemaScope = "https://www.googleapis.com/auth/admin.directory.userschema" |
| |
| // View user schemas on your domain |
| AdminDirectoryUserschemaReadonlyScope = "https://www.googleapis.com/auth/admin.directory.userschema.readonly" |
| ) |
| |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Asps = NewAspsService(s) |
| s.Channels = NewChannelsService(s) |
| s.Chromeosdevices = NewChromeosdevicesService(s) |
| s.Customers = NewCustomersService(s) |
| s.DomainAliases = NewDomainAliasesService(s) |
| s.Domains = NewDomainsService(s) |
| s.Groups = NewGroupsService(s) |
| s.Members = NewMembersService(s) |
| s.Mobiledevices = NewMobiledevicesService(s) |
| s.Notifications = NewNotificationsService(s) |
| s.Orgunits = NewOrgunitsService(s) |
| s.Privileges = NewPrivilegesService(s) |
| s.Resources = NewResourcesService(s) |
| s.RoleAssignments = NewRoleAssignmentsService(s) |
| s.Roles = NewRolesService(s) |
| s.Schemas = NewSchemasService(s) |
| s.Tokens = NewTokensService(s) |
| s.Users = NewUsersService(s) |
| s.VerificationCodes = NewVerificationCodesService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Asps *AspsService |
| |
| Channels *ChannelsService |
| |
| Chromeosdevices *ChromeosdevicesService |
| |
| Customers *CustomersService |
| |
| DomainAliases *DomainAliasesService |
| |
| Domains *DomainsService |
| |
| Groups *GroupsService |
| |
| Members *MembersService |
| |
| Mobiledevices *MobiledevicesService |
| |
| Notifications *NotificationsService |
| |
| Orgunits *OrgunitsService |
| |
| Privileges *PrivilegesService |
| |
| Resources *ResourcesService |
| |
| RoleAssignments *RoleAssignmentsService |
| |
| Roles *RolesService |
| |
| Schemas *SchemasService |
| |
| Tokens *TokensService |
| |
| Users *UsersService |
| |
| VerificationCodes *VerificationCodesService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewAspsService(s *Service) *AspsService { |
| rs := &AspsService{s: s} |
| return rs |
| } |
| |
| type AspsService struct { |
| s *Service |
| } |
| |
| func NewChannelsService(s *Service) *ChannelsService { |
| rs := &ChannelsService{s: s} |
| return rs |
| } |
| |
| type ChannelsService struct { |
| s *Service |
| } |
| |
| func NewChromeosdevicesService(s *Service) *ChromeosdevicesService { |
| rs := &ChromeosdevicesService{s: s} |
| return rs |
| } |
| |
| type ChromeosdevicesService struct { |
| s *Service |
| } |
| |
| func NewCustomersService(s *Service) *CustomersService { |
| rs := &CustomersService{s: s} |
| return rs |
| } |
| |
| type CustomersService struct { |
| s *Service |
| } |
| |
| func NewDomainAliasesService(s *Service) *DomainAliasesService { |
| rs := &DomainAliasesService{s: s} |
| return rs |
| } |
| |
| type DomainAliasesService struct { |
| s *Service |
| } |
| |
| func NewDomainsService(s *Service) *DomainsService { |
| rs := &DomainsService{s: s} |
| return rs |
| } |
| |
| type DomainsService struct { |
| s *Service |
| } |
| |
| func NewGroupsService(s *Service) *GroupsService { |
| rs := &GroupsService{s: s} |
| rs.Aliases = NewGroupsAliasesService(s) |
| return rs |
| } |
| |
| type GroupsService struct { |
| s *Service |
| |
| Aliases *GroupsAliasesService |
| } |
| |
| func NewGroupsAliasesService(s *Service) *GroupsAliasesService { |
| rs := &GroupsAliasesService{s: s} |
| return rs |
| } |
| |
| type GroupsAliasesService struct { |
| s *Service |
| } |
| |
| func NewMembersService(s *Service) *MembersService { |
| rs := &MembersService{s: s} |
| return rs |
| } |
| |
| type MembersService struct { |
| s *Service |
| } |
| |
| func NewMobiledevicesService(s *Service) *MobiledevicesService { |
| rs := &MobiledevicesService{s: s} |
| return rs |
| } |
| |
| type MobiledevicesService struct { |
| s *Service |
| } |
| |
| func NewNotificationsService(s *Service) *NotificationsService { |
| rs := &NotificationsService{s: s} |
| return rs |
| } |
| |
| type NotificationsService struct { |
| s *Service |
| } |
| |
| func NewOrgunitsService(s *Service) *OrgunitsService { |
| rs := &OrgunitsService{s: s} |
| return rs |
| } |
| |
| type OrgunitsService struct { |
| s *Service |
| } |
| |
| func NewPrivilegesService(s *Service) *PrivilegesService { |
| rs := &PrivilegesService{s: s} |
| return rs |
| } |
| |
| type PrivilegesService struct { |
| s *Service |
| } |
| |
| func NewResourcesService(s *Service) *ResourcesService { |
| rs := &ResourcesService{s: s} |
| rs.Calendars = NewResourcesCalendarsService(s) |
| return rs |
| } |
| |
| type ResourcesService struct { |
| s *Service |
| |
| Calendars *ResourcesCalendarsService |
| } |
| |
| func NewResourcesCalendarsService(s *Service) *ResourcesCalendarsService { |
| rs := &ResourcesCalendarsService{s: s} |
| return rs |
| } |
| |
| type ResourcesCalendarsService struct { |
| s *Service |
| } |
| |
| func NewRoleAssignmentsService(s *Service) *RoleAssignmentsService { |
| rs := &RoleAssignmentsService{s: s} |
| return rs |
| } |
| |
| type RoleAssignmentsService struct { |
| s *Service |
| } |
| |
| func NewRolesService(s *Service) *RolesService { |
| rs := &RolesService{s: s} |
| return rs |
| } |
| |
| type RolesService struct { |
| s *Service |
| } |
| |
| func NewSchemasService(s *Service) *SchemasService { |
| rs := &SchemasService{s: s} |
| return rs |
| } |
| |
| type SchemasService struct { |
| s *Service |
| } |
| |
| func NewTokensService(s *Service) *TokensService { |
| rs := &TokensService{s: s} |
| return rs |
| } |
| |
| type TokensService struct { |
| s *Service |
| } |
| |
| func NewUsersService(s *Service) *UsersService { |
| rs := &UsersService{s: s} |
| rs.Aliases = NewUsersAliasesService(s) |
| rs.Photos = NewUsersPhotosService(s) |
| return rs |
| } |
| |
| type UsersService struct { |
| s *Service |
| |
| Aliases *UsersAliasesService |
| |
| Photos *UsersPhotosService |
| } |
| |
| func NewUsersAliasesService(s *Service) *UsersAliasesService { |
| rs := &UsersAliasesService{s: s} |
| return rs |
| } |
| |
| type UsersAliasesService struct { |
| s *Service |
| } |
| |
| func NewUsersPhotosService(s *Service) *UsersPhotosService { |
| rs := &UsersPhotosService{s: s} |
| return rs |
| } |
| |
| type UsersPhotosService struct { |
| s *Service |
| } |
| |
| func NewVerificationCodesService(s *Service) *VerificationCodesService { |
| rs := &VerificationCodesService{s: s} |
| return rs |
| } |
| |
| type VerificationCodesService struct { |
| s *Service |
| } |
| |
| // Alias: JSON template for Alias object in Directory API. |
| type Alias struct { |
| // Alias: A alias email |
| Alias string `json:"alias,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Id: Unique id of the group (Read-only) Unique id of the user |
| // (Read-only) |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // PrimaryEmail: Group's primary email (Read-only) User's primary email |
| // (Read-only) |
| PrimaryEmail string `json:"primaryEmail,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Alias") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Alias") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Alias) MarshalJSON() ([]byte, error) { |
| type noMethod Alias |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Aliases: JSON response template to list aliases in Directory API. |
| type Aliases struct { |
| // Aliases: List of alias objects. |
| Aliases []interface{} `json:"aliases,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Aliases") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Aliases") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Aliases) MarshalJSON() ([]byte, error) { |
| type noMethod Aliases |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Asp: The template that returns individual ASP (Access Code) data. |
| type Asp struct { |
| // CodeId: The unique ID of the ASP. |
| CodeId int64 `json:"codeId,omitempty"` |
| |
| // CreationTime: The time when the ASP was created. Expressed in Unix |
| // time format. |
| CreationTime int64 `json:"creationTime,omitempty,string"` |
| |
| // Etag: ETag of the ASP. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#asp. |
| Kind string `json:"kind,omitempty"` |
| |
| // LastTimeUsed: The time when the ASP was last used. Expressed in Unix |
| // time format. |
| LastTimeUsed int64 `json:"lastTimeUsed,omitempty,string"` |
| |
| // Name: The name of the application that the user, represented by their |
| // userId, entered when the ASP was created. |
| Name string `json:"name,omitempty"` |
| |
| // UserKey: The unique ID of the user who issued the ASP. |
| UserKey string `json:"userKey,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "CodeId") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CodeId") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Asp) MarshalJSON() ([]byte, error) { |
| type noMethod Asp |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type Asps struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of ASP resources. |
| Items []*Asp `json:"items,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#aspList. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Asps) MarshalJSON() ([]byte, error) { |
| type noMethod Asps |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CalendarResource: JSON template for Calendar Resource object in |
| // Directory API. |
| type CalendarResource struct { |
| // Etags: ETag of the resource. |
| Etags string `json:"etags,omitempty"` |
| |
| // Kind: The type of the resource. For calendar resources, the value is |
| // admin#directory#resources#calendars#CalendarResource. |
| Kind string `json:"kind,omitempty"` |
| |
| // ResourceDescription: The brief description of the calendar resource. |
| ResourceDescription string `json:"resourceDescription,omitempty"` |
| |
| // ResourceEmail: The read-only email ID for the calendar resource. |
| // Generated as part of creating a new calendar resource. |
| ResourceEmail string `json:"resourceEmail,omitempty"` |
| |
| // ResourceId: The unique ID for the calendar resource. |
| ResourceId string `json:"resourceId,omitempty"` |
| |
| // ResourceName: The name of the calendar resource. For example, |
| // Training Room 1A |
| ResourceName string `json:"resourceName,omitempty"` |
| |
| // ResourceType: The type of the calendar resource. Used for grouping |
| // resources in the calendar user interface. |
| ResourceType string `json:"resourceType,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etags") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etags") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CalendarResource) MarshalJSON() ([]byte, error) { |
| type noMethod CalendarResource |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CalendarResources: JSON template for Calendar Resource List Response |
| // object in Directory API. |
| type CalendarResources struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: The CalendarResources in this page of results. |
| Items []*CalendarResource `json:"items,omitempty"` |
| |
| // Kind: Identifies this as a collection of CalendarResources. This is |
| // always admin#directory#resources#calendars#calendarResourcesList. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: The continuation token, used to page through large |
| // result sets. Provide this value in a subsequent request to return the |
| // next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CalendarResources) MarshalJSON() ([]byte, error) { |
| type noMethod CalendarResources |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Channel: An notification channel used to watch for resource changes. |
| type Channel struct { |
| // Address: The address where notifications are delivered for this |
| // channel. |
| Address string `json:"address,omitempty"` |
| |
| // Expiration: Date and time of notification channel expiration, |
| // expressed as a Unix timestamp, in milliseconds. Optional. |
| Expiration int64 `json:"expiration,omitempty,string"` |
| |
| // Id: A UUID or similar unique string that identifies this channel. |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Identifies this as a notification channel used to watch for |
| // changes to a resource. Value: the fixed string "api#channel". |
| Kind string `json:"kind,omitempty"` |
| |
| // Params: Additional parameters controlling delivery channel behavior. |
| // Optional. |
| Params map[string]string `json:"params,omitempty"` |
| |
| // Payload: A Boolean value to indicate whether payload is wanted. |
| // Optional. |
| Payload bool `json:"payload,omitempty"` |
| |
| // ResourceId: An opaque ID that identifies the resource being watched |
| // on this channel. Stable across different API versions. |
| ResourceId string `json:"resourceId,omitempty"` |
| |
| // ResourceUri: A version-specific identifier for the watched resource. |
| ResourceUri string `json:"resourceUri,omitempty"` |
| |
| // Token: An arbitrary string delivered to the target address with each |
| // notification delivered over this channel. Optional. |
| Token string `json:"token,omitempty"` |
| |
| // Type: The type of delivery mechanism used for this channel. |
| Type string `json:"type,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Address") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Address") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Channel) MarshalJSON() ([]byte, error) { |
| type noMethod Channel |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChromeOsDevice: JSON template for Chrome Os Device resource in |
| // Directory API. |
| type ChromeOsDevice struct { |
| // ActiveTimeRanges: List of active time ranges (Read-only) |
| ActiveTimeRanges []*ChromeOsDeviceActiveTimeRanges `json:"activeTimeRanges,omitempty"` |
| |
| // AnnotatedAssetId: AssetId specified during enrollment or through |
| // later annotation |
| AnnotatedAssetId string `json:"annotatedAssetId,omitempty"` |
| |
| // AnnotatedLocation: Address or location of the device as noted by the |
| // administrator |
| AnnotatedLocation string `json:"annotatedLocation,omitempty"` |
| |
| // AnnotatedUser: User of the device |
| AnnotatedUser string `json:"annotatedUser,omitempty"` |
| |
| // BootMode: Chromebook boot mode (Read-only) |
| BootMode string `json:"bootMode,omitempty"` |
| |
| // DeviceId: Unique identifier of Chrome OS Device (Read-only) |
| DeviceId string `json:"deviceId,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // EthernetMacAddress: Chromebook Mac Address on ethernet network |
| // interface (Read-only) |
| EthernetMacAddress string `json:"ethernetMacAddress,omitempty"` |
| |
| // FirmwareVersion: Chromebook firmware version (Read-only) |
| FirmwareVersion string `json:"firmwareVersion,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // LastEnrollmentTime: Date and time the device was last enrolled |
| // (Read-only) |
| LastEnrollmentTime string `json:"lastEnrollmentTime,omitempty"` |
| |
| // LastSync: Date and time the device was last synchronized with the |
| // policy settings in the G Suite administrator control panel |
| // (Read-only) |
| LastSync string `json:"lastSync,omitempty"` |
| |
| // MacAddress: Chromebook Mac Address on wifi network interface |
| // (Read-only) |
| MacAddress string `json:"macAddress,omitempty"` |
| |
| // Meid: Mobile Equipment identifier for the 3G mobile card in the |
| // Chromebook (Read-only) |
| Meid string `json:"meid,omitempty"` |
| |
| // Model: Chromebook Model (Read-only) |
| Model string `json:"model,omitempty"` |
| |
| // Notes: Notes added by the administrator |
| Notes string `json:"notes,omitempty"` |
| |
| // OrderNumber: Chromebook order number (Read-only) |
| OrderNumber string `json:"orderNumber,omitempty"` |
| |
| // OrgUnitPath: OrgUnit of the device |
| OrgUnitPath string `json:"orgUnitPath,omitempty"` |
| |
| // OsVersion: Chromebook Os Version (Read-only) |
| OsVersion string `json:"osVersion,omitempty"` |
| |
| // PlatformVersion: Chromebook platform version (Read-only) |
| PlatformVersion string `json:"platformVersion,omitempty"` |
| |
| // RecentUsers: List of recent device users, in descending order by last |
| // login time (Read-only) |
| RecentUsers []*ChromeOsDeviceRecentUsers `json:"recentUsers,omitempty"` |
| |
| // SerialNumber: Chromebook serial number (Read-only) |
| SerialNumber string `json:"serialNumber,omitempty"` |
| |
| // Status: status of the device (Read-only) |
| Status string `json:"status,omitempty"` |
| |
| // SupportEndDate: Final date the device will be supported (Read-only) |
| SupportEndDate string `json:"supportEndDate,omitempty"` |
| |
| // WillAutoRenew: Will Chromebook auto renew after support end date |
| // (Read-only) |
| WillAutoRenew bool `json:"willAutoRenew,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ActiveTimeRanges") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ActiveTimeRanges") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsDevice) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsDevice |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type ChromeOsDeviceActiveTimeRanges struct { |
| // ActiveTime: Duration in milliseconds |
| ActiveTime int64 `json:"activeTime,omitempty"` |
| |
| // Date: Date of usage |
| Date string `json:"date,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ActiveTime") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ActiveTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsDeviceActiveTimeRanges) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsDeviceActiveTimeRanges |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type ChromeOsDeviceRecentUsers struct { |
| // Email: Email address of the user. Present only if the user type is |
| // managed |
| Email string `json:"email,omitempty"` |
| |
| // Type: The type of the user |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Email") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Email") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsDeviceRecentUsers) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsDeviceRecentUsers |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChromeOsDeviceAction: JSON request template for firing actions on |
| // ChromeOs Device in Directory Devices API. |
| type ChromeOsDeviceAction struct { |
| // Action: Action to be taken on the ChromeOs Device |
| Action string `json:"action,omitempty"` |
| |
| DeprovisionReason string `json:"deprovisionReason,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Action") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Action") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsDeviceAction) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsDeviceAction |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChromeOsDevices: JSON response template for List Chrome OS Devices |
| // operation in Directory API. |
| type ChromeOsDevices struct { |
| // Chromeosdevices: List of Chrome OS Device objects. |
| Chromeosdevices []*ChromeOsDevice `json:"chromeosdevices,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: Token used to access next page of this result. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Chromeosdevices") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Chromeosdevices") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsDevices) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsDevices |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChromeOsMoveDevicesToOu: JSON request template for moving ChromeOs |
| // Device to given OU in Directory Devices API. |
| type ChromeOsMoveDevicesToOu struct { |
| // DeviceIds: ChromeOs Devices to be moved to OU |
| DeviceIds []string `json:"deviceIds,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "DeviceIds") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DeviceIds") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChromeOsMoveDevicesToOu) MarshalJSON() ([]byte, error) { |
| type noMethod ChromeOsMoveDevicesToOu |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Customer: JSON template for Customer Resource object in Directory |
| // API. |
| type Customer struct { |
| // AlternateEmail: The customer's secondary contact email address. This |
| // email address cannot be on the same domain as the customerDomain |
| AlternateEmail string `json:"alternateEmail,omitempty"` |
| |
| // CustomerCreationTime: The customer's creation time (Readonly) |
| CustomerCreationTime string `json:"customerCreationTime,omitempty"` |
| |
| // CustomerDomain: The customer's primary domain name string. Do not |
| // include the www prefix when creating a new customer. |
| CustomerDomain string `json:"customerDomain,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Id: The unique ID for the customer's G Suite account. (Readonly) |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Identifies the resource as a customer. Value: |
| // admin#directory#customer |
| Kind string `json:"kind,omitempty"` |
| |
| // Language: The customer's ISO 639-2 language code. The default value |
| // is en-US |
| Language string `json:"language,omitempty"` |
| |
| // PhoneNumber: The customer's contact phone number in E.164 format. |
| PhoneNumber string `json:"phoneNumber,omitempty"` |
| |
| // PostalAddress: The customer's postal address information. |
| PostalAddress *CustomerPostalAddress `json:"postalAddress,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "AlternateEmail") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AlternateEmail") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Customer) MarshalJSON() ([]byte, error) { |
| type noMethod Customer |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CustomerPostalAddress: JSON template for postal address of a |
| // customer. |
| type CustomerPostalAddress struct { |
| // AddressLine1: A customer's physical address. The address can be |
| // composed of one to three lines. |
| AddressLine1 string `json:"addressLine1,omitempty"` |
| |
| // AddressLine2: Address line 2 of the address. |
| AddressLine2 string `json:"addressLine2,omitempty"` |
| |
| // AddressLine3: Address line 3 of the address. |
| AddressLine3 string `json:"addressLine3,omitempty"` |
| |
| // ContactName: The customer contact's name. |
| ContactName string `json:"contactName,omitempty"` |
| |
| // CountryCode: This is a required property. For countryCode information |
| // see the ISO 3166 country code elements. |
| CountryCode string `json:"countryCode,omitempty"` |
| |
| // Locality: Name of the locality. An example of a locality value is the |
| // city of San Francisco. |
| Locality string `json:"locality,omitempty"` |
| |
| // OrganizationName: The company or company division name. |
| OrganizationName string `json:"organizationName,omitempty"` |
| |
| // PostalCode: The postal code. A postalCode example is a postal zip |
| // code such as 10009. This is in accordance with - |
| // http://portablecontacts.net/draft-spec.html#address_element. |
| PostalCode string `json:"postalCode,omitempty"` |
| |
| // Region: Name of the region. An example of a region value is NY for |
| // the state of New York. |
| Region string `json:"region,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "AddressLine1") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AddressLine1") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CustomerPostalAddress) MarshalJSON() ([]byte, error) { |
| type noMethod CustomerPostalAddress |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // DomainAlias: JSON template for Domain Alias object in Directory API. |
| type DomainAlias struct { |
| // CreationTime: The creation time of the domain alias. (Read-only). |
| CreationTime int64 `json:"creationTime,omitempty,string"` |
| |
| // DomainAliasName: The domain alias name. |
| DomainAliasName string `json:"domainAliasName,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // ParentDomainName: The parent domain name that the domain alias is |
| // associated with. This can either be a primary or secondary domain |
| // name within a customer. |
| ParentDomainName string `json:"parentDomainName,omitempty"` |
| |
| // Verified: Indicates the verification state of a domain alias. |
| // (Read-only) |
| Verified bool `json:"verified,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "CreationTime") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CreationTime") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *DomainAlias) MarshalJSON() ([]byte, error) { |
| type noMethod DomainAlias |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // DomainAliases: JSON response template to list domain aliases in |
| // Directory API. |
| type DomainAliases struct { |
| // DomainAliases: List of domain alias objects. |
| DomainAliases []*DomainAlias `json:"domainAliases,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "DomainAliases") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DomainAliases") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *DomainAliases) MarshalJSON() ([]byte, error) { |
| type noMethod DomainAliases |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Domains: JSON template for Domain object in Directory API. |
| type Domains struct { |
| // CreationTime: Creation time of the domain. (Read-only). |
| CreationTime int64 `json:"creationTime,omitempty,string"` |
| |
| // DomainAliases: List of domain alias objects. (Read-only) |
| DomainAliases []*DomainAlias `json:"domainAliases,omitempty"` |
| |
| // DomainName: The domain name of the customer. |
| DomainName string `json:"domainName,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // IsPrimary: Indicates if the domain is a primary domain (Read-only). |
| IsPrimary bool `json:"isPrimary,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Verified: Indicates the verification state of a domain. (Read-only). |
| Verified bool `json:"verified,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "CreationTime") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CreationTime") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Domains) MarshalJSON() ([]byte, error) { |
| type noMethod Domains |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Domains2: JSON response template to list Domains in Directory API. |
| type Domains2 struct { |
| // Domains: List of domain objects. |
| Domains []*Domains `json:"domains,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Domains") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Domains") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Domains2) MarshalJSON() ([]byte, error) { |
| type noMethod Domains2 |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Group: JSON template for Group resource in Directory API. |
| type Group struct { |
| // AdminCreated: Is the group created by admin (Read-only) * |
| AdminCreated bool `json:"adminCreated,omitempty"` |
| |
| // Aliases: List of aliases (Read-only) |
| Aliases []string `json:"aliases,omitempty"` |
| |
| // Description: Description of the group |
| Description string `json:"description,omitempty"` |
| |
| // DirectMembersCount: Group direct members count |
| DirectMembersCount int64 `json:"directMembersCount,omitempty,string"` |
| |
| // Email: Email of Group |
| Email string `json:"email,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Id: Unique identifier of Group (Read-only) |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Name: Group name |
| Name string `json:"name,omitempty"` |
| |
| // NonEditableAliases: List of non editable aliases (Read-only) |
| NonEditableAliases []string `json:"nonEditableAliases,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "AdminCreated") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AdminCreated") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Group) MarshalJSON() ([]byte, error) { |
| type noMethod Group |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Groups: JSON response template for List Groups operation in Directory |
| // API. |
| type Groups struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Groups: List of group objects. |
| Groups []*Group `json:"groups,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: Token used to access next page of this result. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Groups) MarshalJSON() ([]byte, error) { |
| type noMethod Groups |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Member: JSON template for Member resource in Directory API. |
| type Member struct { |
| // Email: Email of member (Read-only) |
| Email string `json:"email,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Id: Unique identifier of customer member (Read-only) Unique |
| // identifier of group (Read-only) Unique identifier of member |
| // (Read-only) |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Role: Role of member |
| Role string `json:"role,omitempty"` |
| |
| // Status: Status of member (Immutable) |
| Status string `json:"status,omitempty"` |
| |
| // Type: Type of member (Immutable) |
| Type string `json:"type,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Email") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Email") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Member) MarshalJSON() ([]byte, error) { |
| type noMethod Member |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Members: JSON response template for List Members operation in |
| // Directory API. |
| type Members struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Members: List of member objects. |
| Members []*Member `json:"members,omitempty"` |
| |
| // NextPageToken: Token used to access next page of this result. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Members) MarshalJSON() ([]byte, error) { |
| type noMethod Members |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MobileDevice: JSON template for Mobile Device resource in Directory |
| // API. |
| type MobileDevice struct { |
| // AdbStatus: Adb (USB debugging) enabled or disabled on device |
| // (Read-only) |
| AdbStatus bool `json:"adbStatus,omitempty"` |
| |
| // Applications: List of applications installed on Mobile Device |
| Applications []*MobileDeviceApplications `json:"applications,omitempty"` |
| |
| // BasebandVersion: Mobile Device Baseband version (Read-only) |
| BasebandVersion string `json:"basebandVersion,omitempty"` |
| |
| // BootloaderVersion: Mobile Device Bootloader version (Read-only) |
| BootloaderVersion string `json:"bootloaderVersion,omitempty"` |
| |
| // Brand: Mobile Device Brand (Read-only) |
| Brand string `json:"brand,omitempty"` |
| |
| // BuildNumber: Mobile Device Build number (Read-only) |
| BuildNumber string `json:"buildNumber,omitempty"` |
| |
| // DefaultLanguage: The default locale used on the Mobile Device |
| // (Read-only) |
| DefaultLanguage string `json:"defaultLanguage,omitempty"` |
| |
| // DeveloperOptionsStatus: Developer options enabled or disabled on |
| // device (Read-only) |
| DeveloperOptionsStatus bool `json:"developerOptionsStatus,omitempty"` |
| |
| // DeviceCompromisedStatus: Mobile Device compromised status (Read-only) |
| DeviceCompromisedStatus string `json:"deviceCompromisedStatus,omitempty"` |
| |
| // DeviceId: Mobile Device serial number (Read-only) |
| DeviceId string `json:"deviceId,omitempty"` |
| |
| // DevicePasswordStatus: DevicePasswordStatus (Read-only) |
| DevicePasswordStatus string `json:"devicePasswordStatus,omitempty"` |
| |
| // Email: List of owner user's email addresses (Read-only) |
| Email []string `json:"email,omitempty"` |
| |
| // EncryptionStatus: Mobile Device Encryption Status (Read-only) |
| EncryptionStatus string `json:"encryptionStatus,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // FirstSync: Date and time the device was first synchronized with the |
| // policy settings in the G Suite administrator control panel |
| // (Read-only) |
| FirstSync string `json:"firstSync,omitempty"` |
| |
| // Hardware: Mobile Device Hardware (Read-only) |
| Hardware string `json:"hardware,omitempty"` |
| |
| // HardwareId: Mobile Device Hardware Id (Read-only) |
| HardwareId string `json:"hardwareId,omitempty"` |
| |
| // Imei: Mobile Device IMEI number (Read-only) |
| Imei string `json:"imei,omitempty"` |
| |
| // KernelVersion: Mobile Device Kernel version (Read-only) |
| KernelVersion string `json:"kernelVersion,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // LastSync: Date and time the device was last synchronized with the |
| // policy settings in the G Suite administrator control panel |
| // (Read-only) |
| LastSync string `json:"lastSync,omitempty"` |
| |
| // ManagedAccountIsOnOwnerProfile: Boolean indicating if this account is |
| // on owner/primary profile or not (Read-only) |
| ManagedAccountIsOnOwnerProfile bool `json:"managedAccountIsOnOwnerProfile,omitempty"` |
| |
| // Manufacturer: Mobile Device manufacturer (Read-only) |
| Manufacturer string `json:"manufacturer,omitempty"` |
| |
| // Meid: Mobile Device MEID number (Read-only) |
| Meid string `json:"meid,omitempty"` |
| |
| // Model: Name of the model of the device |
| Model string `json:"model,omitempty"` |
| |
| // Name: List of owner user's names (Read-only) |
| Name []string `json:"name,omitempty"` |
| |
| // NetworkOperator: Mobile Device mobile or network operator (if |
| // available) (Read-only) |
| NetworkOperator string `json:"networkOperator,omitempty"` |
| |
| // Os: Name of the mobile operating system |
| Os string `json:"os,omitempty"` |
| |
| // OtherAccountsInfo: List of accounts added on device (Read-only) |
| OtherAccountsInfo []string `json:"otherAccountsInfo,omitempty"` |
| |
| // Privilege: DMAgentPermission (Read-only) |
| Privilege string `json:"privilege,omitempty"` |
| |
| // ReleaseVersion: Mobile Device release version version (Read-only) |
| ReleaseVersion string `json:"releaseVersion,omitempty"` |
| |
| // ResourceId: Unique identifier of Mobile Device (Read-only) |
| ResourceId string `json:"resourceId,omitempty"` |
| |
| // SecurityPatchLevel: Mobile Device Security patch level (Read-only) |
| SecurityPatchLevel int64 `json:"securityPatchLevel,omitempty,string"` |
| |
| // SerialNumber: Mobile Device SSN or Serial Number (Read-only) |
| SerialNumber string `json:"serialNumber,omitempty"` |
| |
| // Status: Status of the device (Read-only) |
| Status string `json:"status,omitempty"` |
| |
| // SupportsWorkProfile: Work profile supported on device (Read-only) |
| SupportsWorkProfile bool `json:"supportsWorkProfile,omitempty"` |
| |
| // Type: The type of device (Read-only) |
| Type string `json:"type,omitempty"` |
| |
| // UnknownSourcesStatus: Unknown sources enabled or disabled on device |
| // (Read-only) |
| UnknownSourcesStatus bool `json:"unknownSourcesStatus,omitempty"` |
| |
| // UserAgent: Mobile Device user agent |
| UserAgent string `json:"userAgent,omitempty"` |
| |
| // WifiMacAddress: Mobile Device WiFi MAC address (Read-only) |
| WifiMacAddress string `json:"wifiMacAddress,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "AdbStatus") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AdbStatus") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MobileDevice) MarshalJSON() ([]byte, error) { |
| type noMethod MobileDevice |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type MobileDeviceApplications struct { |
| // DisplayName: Display name of application |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // PackageName: Package name of application |
| PackageName string `json:"packageName,omitempty"` |
| |
| // Permission: List of Permissions for application |
| Permission []string `json:"permission,omitempty"` |
| |
| // VersionCode: Version code of application |
| VersionCode int64 `json:"versionCode,omitempty"` |
| |
| // VersionName: Version name of application |
| VersionName string `json:"versionName,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "DisplayName") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DisplayName") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MobileDeviceApplications) MarshalJSON() ([]byte, error) { |
| type noMethod MobileDeviceApplications |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MobileDeviceAction: JSON request template for firing commands on |
| // Mobile Device in Directory Devices API. |
| type MobileDeviceAction struct { |
| // Action: Action to be taken on the Mobile Device |
| Action string `json:"action,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Action") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Action") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MobileDeviceAction) MarshalJSON() ([]byte, error) { |
| type noMethod MobileDeviceAction |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MobileDevices: JSON response template for List Mobile Devices |
| // operation in Directory API. |
| type MobileDevices struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Mobiledevices: List of Mobile Device objects. |
| Mobiledevices []*MobileDevice `json:"mobiledevices,omitempty"` |
| |
| // NextPageToken: Token used to access next page of this result. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MobileDevices) MarshalJSON() ([]byte, error) { |
| type noMethod MobileDevices |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Notification: Template for a notification resource. |
| type Notification struct { |
| // Body: Body of the notification (Read-only) |
| Body string `json:"body,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // FromAddress: Address from which the notification is received |
| // (Read-only) |
| FromAddress string `json:"fromAddress,omitempty"` |
| |
| // IsUnread: Boolean indicating whether the notification is unread or |
| // not. |
| IsUnread bool `json:"isUnread,omitempty"` |
| |
| // Kind: The type of the resource. |
| Kind string `json:"kind,omitempty"` |
| |
| NotificationId string `json:"notificationId,omitempty"` |
| |
| // SendTime: Time at which notification was sent (Read-only) |
| SendTime string `json:"sendTime,omitempty"` |
| |
| // Subject: Subject of the notification (Read-only) |
| Subject string `json:"subject,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Body") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Body") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Notification) MarshalJSON() ([]byte, error) { |
| type noMethod Notification |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Notifications: Template for notifications list response. |
| type Notifications struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: List of notifications in this page. |
| Items []*Notification `json:"items,omitempty"` |
| |
| // Kind: The type of the resource. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: Token for fetching the next page of notifications. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // UnreadNotificationsCount: Number of unread notification for the |
| // domain. |
| UnreadNotificationsCount int64 `json:"unreadNotificationsCount,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Notifications) MarshalJSON() ([]byte, error) { |
| type noMethod Notifications |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OrgUnit: JSON template for Org Unit resource in Directory API. |
| type OrgUnit struct { |
| // BlockInheritance: Should block inheritance |
| BlockInheritance bool `json:"blockInheritance,omitempty"` |
| |
| // Description: Description of OrgUnit |
| Description string `json:"description,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Name: Name of OrgUnit |
| Name string `json:"name,omitempty"` |
| |
| // OrgUnitId: Id of OrgUnit |
| OrgUnitId string `json:"orgUnitId,omitempty"` |
| |
| // OrgUnitPath: Path of OrgUnit |
| OrgUnitPath string `json:"orgUnitPath,omitempty"` |
| |
| // ParentOrgUnitId: Id of parent OrgUnit |
| ParentOrgUnitId string `json:"parentOrgUnitId,omitempty"` |
| |
| // ParentOrgUnitPath: Path of parent OrgUnit |
| ParentOrgUnitPath string `json:"parentOrgUnitPath,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "BlockInheritance") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "BlockInheritance") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OrgUnit) MarshalJSON() ([]byte, error) { |
| type noMethod OrgUnit |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OrgUnits: JSON response template for List Organization Units |
| // operation in Directory API. |
| type OrgUnits struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // OrganizationUnits: List of user objects. |
| OrganizationUnits []*OrgUnit `json:"organizationUnits,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OrgUnits) MarshalJSON() ([]byte, error) { |
| type noMethod OrgUnits |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Privilege: JSON template for privilege resource in Directory API. |
| type Privilege struct { |
| // ChildPrivileges: A list of child privileges. Privileges for a service |
| // form a tree. Each privilege can have a list of child privileges; this |
| // list is empty for a leaf privilege. |
| ChildPrivileges []*Privilege `json:"childPrivileges,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // IsOuScopable: If the privilege can be restricted to an organization |
| // unit. |
| IsOuScopable bool `json:"isOuScopable,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#privilege. |
| Kind string `json:"kind,omitempty"` |
| |
| // PrivilegeName: The name of the privilege. |
| PrivilegeName string `json:"privilegeName,omitempty"` |
| |
| // ServiceId: The obfuscated ID of the service this privilege is for. |
| ServiceId string `json:"serviceId,omitempty"` |
| |
| // ServiceName: The name of the service this privilege is for. |
| ServiceName string `json:"serviceName,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ChildPrivileges") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ChildPrivileges") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Privilege) MarshalJSON() ([]byte, error) { |
| type noMethod Privilege |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Privileges: JSON response template for List privileges operation in |
| // Directory API. |
| type Privileges struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of Privilege resources. |
| Items []*Privilege `json:"items,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#privileges. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Privileges) MarshalJSON() ([]byte, error) { |
| type noMethod Privileges |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Role: JSON template for role resource in Directory API. |
| type Role struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // IsSuperAdminRole: Returns true if the role is a super admin role. |
| IsSuperAdminRole bool `json:"isSuperAdminRole,omitempty"` |
| |
| // IsSystemRole: Returns true if this is a pre-defined system role. |
| IsSystemRole bool `json:"isSystemRole,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#role. |
| Kind string `json:"kind,omitempty"` |
| |
| // RoleDescription: A short description of the role. |
| RoleDescription string `json:"roleDescription,omitempty"` |
| |
| // RoleId: ID of the role. |
| RoleId int64 `json:"roleId,omitempty,string"` |
| |
| // RoleName: Name of the role. |
| RoleName string `json:"roleName,omitempty"` |
| |
| // RolePrivileges: The set of privileges that are granted to this role. |
| RolePrivileges []*RoleRolePrivileges `json:"rolePrivileges,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Role) MarshalJSON() ([]byte, error) { |
| type noMethod Role |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type RoleRolePrivileges struct { |
| // PrivilegeName: The name of the privilege. |
| PrivilegeName string `json:"privilegeName,omitempty"` |
| |
| // ServiceId: The obfuscated ID of the service this privilege is for. |
| ServiceId string `json:"serviceId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "PrivilegeName") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "PrivilegeName") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *RoleRolePrivileges) MarshalJSON() ([]byte, error) { |
| type noMethod RoleRolePrivileges |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // RoleAssignment: JSON template for roleAssignment resource in |
| // Directory API. |
| type RoleAssignment struct { |
| // AssignedTo: The unique ID of the user this role is assigned to. |
| AssignedTo string `json:"assignedTo,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#roleAssignment. |
| Kind string `json:"kind,omitempty"` |
| |
| // OrgUnitId: If the role is restricted to an organization unit, this |
| // contains the ID for the organization unit the exercise of this role |
| // is restricted to. |
| OrgUnitId string `json:"orgUnitId,omitempty"` |
| |
| // RoleAssignmentId: ID of this roleAssignment. |
| RoleAssignmentId int64 `json:"roleAssignmentId,omitempty,string"` |
| |
| // RoleId: The ID of the role that is assigned. |
| RoleId int64 `json:"roleId,omitempty,string"` |
| |
| // ScopeType: The scope in which this role is assigned. Possible values |
| // are: |
| // - CUSTOMER |
| // - ORG_UNIT |
| ScopeType string `json:"scopeType,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "AssignedTo") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AssignedTo") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *RoleAssignment) MarshalJSON() ([]byte, error) { |
| type noMethod RoleAssignment |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // RoleAssignments: JSON response template for List roleAssignments |
| // operation in Directory API. |
| type RoleAssignments struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of RoleAssignment resources. |
| Items []*RoleAssignment `json:"items,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#roleAssignments. |
| Kind string `json:"kind,omitempty"` |
| |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *RoleAssignments) MarshalJSON() ([]byte, error) { |
| type noMethod RoleAssignments |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Roles: JSON response template for List roles operation in Directory |
| // API. |
| type Roles struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of Role resources. |
| Items []*Role `json:"items,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#roles. |
| Kind string `json:"kind,omitempty"` |
| |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Roles) MarshalJSON() ([]byte, error) { |
| type noMethod Roles |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Schema: JSON template for Schema resource in Directory API. |
| type Schema struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Fields: Fields of Schema |
| Fields []*SchemaFieldSpec `json:"fields,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // SchemaId: Unique identifier of Schema (Read-only) |
| SchemaId string `json:"schemaId,omitempty"` |
| |
| // SchemaName: Schema name |
| SchemaName string `json:"schemaName,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Schema) MarshalJSON() ([]byte, error) { |
| type noMethod Schema |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // SchemaFieldSpec: JSON template for FieldSpec resource for Schemas in |
| // Directory API. |
| type SchemaFieldSpec struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // FieldId: Unique identifier of Field (Read-only) |
| FieldId string `json:"fieldId,omitempty"` |
| |
| // FieldName: Name of the field. |
| FieldName string `json:"fieldName,omitempty"` |
| |
| // FieldType: Type of the field. |
| FieldType string `json:"fieldType,omitempty"` |
| |
| // Indexed: Boolean specifying whether the field is indexed or not. |
| // |
| // Default: true |
| Indexed *bool `json:"indexed,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // MultiValued: Boolean specifying whether this is a multi-valued field |
| // or not. |
| MultiValued bool `json:"multiValued,omitempty"` |
| |
| // NumericIndexingSpec: Indexing spec for a numeric field. By default, |
| // only exact match queries will be supported for numeric fields. |
| // Setting the numericIndexingSpec allows range queries to be supported. |
| NumericIndexingSpec *SchemaFieldSpecNumericIndexingSpec `json:"numericIndexingSpec,omitempty"` |
| |
| // ReadAccessType: Read ACLs on the field specifying who can view values |
| // of this field. Valid values are "ALL_DOMAIN_USERS" and |
| // "ADMINS_AND_SELF". |
| ReadAccessType string `json:"readAccessType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SchemaFieldSpec) MarshalJSON() ([]byte, error) { |
| type noMethod SchemaFieldSpec |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // SchemaFieldSpecNumericIndexingSpec: Indexing spec for a numeric |
| // field. By default, only exact match queries will be supported for |
| // numeric fields. Setting the numericIndexingSpec allows range queries |
| // to be supported. |
| type SchemaFieldSpecNumericIndexingSpec struct { |
| // MaxValue: Maximum value of this field. This is meant to be indicative |
| // rather than enforced. Values outside this range will still be |
| // indexed, but search may not be as performant. |
| MaxValue float64 `json:"maxValue,omitempty"` |
| |
| // MinValue: Minimum value of this field. This is meant to be indicative |
| // rather than enforced. Values outside this range will still be |
| // indexed, but search may not be as performant. |
| MinValue float64 `json:"minValue,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "MaxValue") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "MaxValue") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SchemaFieldSpecNumericIndexingSpec) MarshalJSON() ([]byte, error) { |
| type noMethod SchemaFieldSpecNumericIndexingSpec |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| func (s *SchemaFieldSpecNumericIndexingSpec) UnmarshalJSON(data []byte) error { |
| type noMethod SchemaFieldSpecNumericIndexingSpec |
| var s1 struct { |
| MaxValue gensupport.JSONFloat64 `json:"maxValue"` |
| MinValue gensupport.JSONFloat64 `json:"minValue"` |
| *noMethod |
| } |
| s1.noMethod = (*noMethod)(s) |
| if err := json.Unmarshal(data, &s1); err != nil { |
| return err |
| } |
| s.MaxValue = float64(s1.MaxValue) |
| s.MinValue = float64(s1.MinValue) |
| return nil |
| } |
| |
| // Schemas: JSON response template for List Schema operation in |
| // Directory API. |
| type Schemas struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // Schemas: List of UserSchema objects. |
| Schemas []*Schema `json:"schemas,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Schemas) MarshalJSON() ([]byte, error) { |
| type noMethod Schemas |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Token: JSON template for token resource in Directory API. |
| type Token struct { |
| // Anonymous: Whether the application is registered with Google. The |
| // value is true if the application has an anonymous Client ID. |
| Anonymous bool `json:"anonymous,omitempty"` |
| |
| // ClientId: The Client ID of the application the token is issued to. |
| ClientId string `json:"clientId,omitempty"` |
| |
| // DisplayText: The displayable name of the application the token is |
| // issued to. |
| DisplayText string `json:"displayText,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#token. |
| Kind string `json:"kind,omitempty"` |
| |
| // NativeApp: Whether the token is issued to an installed application. |
| // The value is true if the application is installed to a desktop or |
| // mobile device. |
| NativeApp bool `json:"nativeApp,omitempty"` |
| |
| // Scopes: A list of authorization scopes the application is granted. |
| Scopes []string `json:"scopes,omitempty"` |
| |
| // UserKey: The unique ID of the user that issued the token. |
| UserKey string `json:"userKey,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Anonymous") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Anonymous") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Token) MarshalJSON() ([]byte, error) { |
| type noMethod Token |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Tokens: JSON response template for List tokens operation in Directory |
| // API. |
| type Tokens struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of Token resources. |
| Items []*Token `json:"items,omitempty"` |
| |
| // Kind: The type of the API resource. This is always |
| // admin#directory#tokenList. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Tokens) MarshalJSON() ([]byte, error) { |
| type noMethod Tokens |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // User: JSON template for User object in Directory API. |
| type User struct { |
| Addresses interface{} `json:"addresses,omitempty"` |
| |
| // AgreedToTerms: Indicates if user has agreed to terms (Read-only) |
| AgreedToTerms bool `json:"agreedToTerms,omitempty"` |
| |
| // Aliases: List of aliases (Read-only) |
| Aliases []string `json:"aliases,omitempty"` |
| |
| // ChangePasswordAtNextLogin: Boolean indicating if the user should |
| // change password in next login |
| ChangePasswordAtNextLogin bool `json:"changePasswordAtNextLogin,omitempty"` |
| |
| // CreationTime: User's G Suite account creation time. (Read-only) |
| CreationTime string `json:"creationTime,omitempty"` |
| |
| // CustomSchemas: Custom fields of the user. |
| CustomSchemas map[string]googleapi.RawMessage `json:"customSchemas,omitempty"` |
| |
| // CustomerId: CustomerId of User (Read-only) |
| CustomerId string `json:"customerId,omitempty"` |
| |
| DeletionTime string `json:"deletionTime,omitempty"` |
| |
| Emails interface{} `json:"emails,omitempty"` |
| |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| ExternalIds interface{} `json:"externalIds,omitempty"` |
| |
| // HashFunction: Hash function name for password. Supported are MD5, |
| // SHA-1 and crypt |
| HashFunction string `json:"hashFunction,omitempty"` |
| |
| // Id: Unique identifier of User (Read-only) |
| Id string `json:"id,omitempty"` |
| |
| Ims interface{} `json:"ims,omitempty"` |
| |
| // IncludeInGlobalAddressList: Boolean indicating if user is included in |
| // Global Address List |
| IncludeInGlobalAddressList bool `json:"includeInGlobalAddressList,omitempty"` |
| |
| // IpWhitelisted: Boolean indicating if ip is whitelisted |
| IpWhitelisted bool `json:"ipWhitelisted,omitempty"` |
| |
| // IsAdmin: Boolean indicating if the user is admin (Read-only) |
| IsAdmin bool `json:"isAdmin,omitempty"` |
| |
| // IsDelegatedAdmin: Boolean indicating if the user is delegated admin |
| // (Read-only) |
| IsDelegatedAdmin bool `json:"isDelegatedAdmin,omitempty"` |
| |
| // IsEnforcedIn2Sv: Is 2-step verification enforced (Read-only) |
| IsEnforcedIn2Sv bool `json:"isEnforcedIn2Sv,omitempty"` |
| |
| // IsEnrolledIn2Sv: Is enrolled in 2-step verification (Read-only) |
| IsEnrolledIn2Sv bool `json:"isEnrolledIn2Sv,omitempty"` |
| |
| // IsMailboxSetup: Is mailbox setup (Read-only) |
| IsMailboxSetup bool `json:"isMailboxSetup,omitempty"` |
| |
| Keywords interface{} `json:"keywords,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| Languages interface{} `json:"languages,omitempty"` |
| |
| // LastLoginTime: User's last login time. (Read-only) |
| LastLoginTime string `json:"lastLoginTime,omitempty"` |
| |
| Locations interface{} `json:"locations,omitempty"` |
| |
| // Name: User's name |
| Name *UserName `json:"name,omitempty"` |
| |
| // NonEditableAliases: List of non editable aliases (Read-only) |
| NonEditableAliases []string `json:"nonEditableAliases,omitempty"` |
| |
| Notes interface{} `json:"notes,omitempty"` |
| |
| // OrgUnitPath: OrgUnit of User |
| OrgUnitPath string `json:"orgUnitPath,omitempty"` |
| |
| Organizations interface{} `json:"organizations,omitempty"` |
| |
| // Password: User's password |
| Password string `json:"password,omitempty"` |
| |
| Phones interface{} `json:"phones,omitempty"` |
| |
| PosixAccounts interface{} `json:"posixAccounts,omitempty"` |
| |
| // PrimaryEmail: username of User |
| PrimaryEmail string `json:"primaryEmail,omitempty"` |
| |
| Relations interface{} `json:"relations,omitempty"` |
| |
| SshPublicKeys interface{} `json:"sshPublicKeys,omitempty"` |
| |
| // Suspended: Indicates if user is suspended |
| Suspended bool `json:"suspended,omitempty"` |
| |
| // SuspensionReason: Suspension reason if user is suspended (Read-only) |
| SuspensionReason string `json:"suspensionReason,omitempty"` |
| |
| // ThumbnailPhotoEtag: ETag of the user's photo (Read-only) |
| ThumbnailPhotoEtag string `json:"thumbnailPhotoEtag,omitempty"` |
| |
| // ThumbnailPhotoUrl: Photo Url of the user (Read-only) |
| ThumbnailPhotoUrl string `json:"thumbnailPhotoUrl,omitempty"` |
| |
| Websites interface{} `json:"websites,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Addresses") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Addresses") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *User) MarshalJSON() ([]byte, error) { |
| type noMethod User |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserAbout: JSON template for About (notes) of a user in Directory |
| // API. |
| type UserAbout struct { |
| // ContentType: About entry can have a type which indicates the content |
| // type. It can either be plain or html. By default, notes contents are |
| // assumed to contain plain text. |
| ContentType string `json:"contentType,omitempty"` |
| |
| // Value: Actual value of notes. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ContentType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ContentType") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserAbout) MarshalJSON() ([]byte, error) { |
| type noMethod UserAbout |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserAddress: JSON template for address. |
| type UserAddress struct { |
| // Country: Country. |
| Country string `json:"country,omitempty"` |
| |
| // CountryCode: Country code. |
| CountryCode string `json:"countryCode,omitempty"` |
| |
| // CustomType: Custom type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // ExtendedAddress: Extended Address. |
| ExtendedAddress string `json:"extendedAddress,omitempty"` |
| |
| // Formatted: Formatted address. |
| Formatted string `json:"formatted,omitempty"` |
| |
| // Locality: Locality. |
| Locality string `json:"locality,omitempty"` |
| |
| // PoBox: Other parts of address. |
| PoBox string `json:"poBox,omitempty"` |
| |
| // PostalCode: Postal code. |
| PostalCode string `json:"postalCode,omitempty"` |
| |
| // Primary: If this is user's primary address. Only one entry could be |
| // marked as primary. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Region: Region. |
| Region string `json:"region,omitempty"` |
| |
| // SourceIsStructured: User supplied address was structured. Structured |
| // addresses are NOT supported at this time. You might be able to write |
| // structured addresses, but any values will eventually be clobbered. |
| SourceIsStructured bool `json:"sourceIsStructured,omitempty"` |
| |
| // StreetAddress: Street. |
| StreetAddress string `json:"streetAddress,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard values of |
| // that entry. For example address could be of home, work etc. In |
| // addition to the standard type, an entry can have a custom type and |
| // can take any value. Such type should have the CUSTOM value as type |
| // and also have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Country") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Country") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserAddress) MarshalJSON() ([]byte, error) { |
| type noMethod UserAddress |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserEmail: JSON template for an email. |
| type UserEmail struct { |
| // Address: Email id of the user. |
| Address string `json:"address,omitempty"` |
| |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Primary: If this is user's primary email. Only one entry could be |
| // marked as primary. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example email could be of home, work etc. In addition |
| // to the standard type, an entry can have a custom type and can take |
| // any value Such types should have the CUSTOM value as type and also |
| // have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Address") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Address") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserEmail) MarshalJSON() ([]byte, error) { |
| type noMethod UserEmail |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserExternalId: JSON template for an externalId entry. |
| type UserExternalId struct { |
| // CustomType: Custom type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Type: The type of the Id. |
| Type string `json:"type,omitempty"` |
| |
| // Value: The value of the id. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserExternalId) MarshalJSON() ([]byte, error) { |
| type noMethod UserExternalId |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserIm: JSON template for instant messenger of an user. |
| type UserIm struct { |
| // CustomProtocol: Custom protocol. |
| CustomProtocol string `json:"customProtocol,omitempty"` |
| |
| // CustomType: Custom type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Im: Instant messenger id. |
| Im string `json:"im,omitempty"` |
| |
| // Primary: If this is user's primary im. Only one entry could be marked |
| // as primary. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Protocol: Protocol used in the instant messenger. It should be one of |
| // the values from ImProtocolTypes map. Similar to type, it can take a |
| // CUSTOM value and specify the custom name in customProtocol field. |
| Protocol string `json:"protocol,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example instant messengers could be of home, work |
| // etc. In addition to the standard type, an entry can have a custom |
| // type and can take any value. Such types should have the CUSTOM value |
| // as type and also have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomProtocol") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomProtocol") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserIm) MarshalJSON() ([]byte, error) { |
| type noMethod UserIm |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserKeyword: JSON template for a keyword entry. |
| type UserKeyword struct { |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard type of |
| // that entry. For example, keyword could be of type occupation or |
| // outlook. In addition to the standard type, an entry can have a custom |
| // type and can give it any name. Such types should have the CUSTOM |
| // value as type and also have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // Value: Keyword. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserKeyword) MarshalJSON() ([]byte, error) { |
| type noMethod UserKeyword |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserLanguage: JSON template for a language entry. |
| type UserLanguage struct { |
| // CustomLanguage: Other language. User can provide own language name if |
| // there is no corresponding Google III language code. If this is set |
| // LanguageCode can't be set |
| CustomLanguage string `json:"customLanguage,omitempty"` |
| |
| // LanguageCode: Language Code. Should be used for storing Google III |
| // LanguageCode string representation for language. Illegal values cause |
| // SchemaException. |
| LanguageCode string `json:"languageCode,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomLanguage") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomLanguage") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserLanguage) MarshalJSON() ([]byte, error) { |
| type noMethod UserLanguage |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserLocation: JSON template for a location entry. |
| type UserLocation struct { |
| // Area: Textual location. This is most useful for display purposes to |
| // concisely describe the location. For example, "Mountain View, CA", |
| // "Near Seattle", "US-NYC-9TH 9A209A". |
| Area string `json:"area,omitempty"` |
| |
| // BuildingId: Building Identifier. |
| BuildingId string `json:"buildingId,omitempty"` |
| |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // DeskCode: Most specific textual code of individual desk location. |
| DeskCode string `json:"deskCode,omitempty"` |
| |
| // FloorName: Floor name/number. |
| FloorName string `json:"floorName,omitempty"` |
| |
| // FloorSection: Floor section. More specific location within the floor. |
| // For example, if a floor is divided into sections "A", "B", and "C", |
| // this field would identify one of those values. |
| FloorSection string `json:"floorSection,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example location could be of types default and desk. |
| // In addition to standard type, an entry can have a custom type and can |
| // give it any name. Such types should have "custom" as type and also |
| // have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Area") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Area") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserLocation) MarshalJSON() ([]byte, error) { |
| type noMethod UserLocation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserMakeAdmin: JSON request template for setting/revoking admin |
| // status of a user in Directory API. |
| type UserMakeAdmin struct { |
| // Status: Boolean indicating new admin status of the user |
| Status bool `json:"status,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Status") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Status") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserMakeAdmin) MarshalJSON() ([]byte, error) { |
| type noMethod UserMakeAdmin |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserName: JSON template for name of a user in Directory API. |
| type UserName struct { |
| // FamilyName: Last Name |
| FamilyName string `json:"familyName,omitempty"` |
| |
| // FullName: Full Name |
| FullName string `json:"fullName,omitempty"` |
| |
| // GivenName: First Name |
| GivenName string `json:"givenName,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "FamilyName") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "FamilyName") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserName) MarshalJSON() ([]byte, error) { |
| type noMethod UserName |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserOrganization: JSON template for an organization entry. |
| type UserOrganization struct { |
| // CostCenter: The cost center of the users department. |
| CostCenter string `json:"costCenter,omitempty"` |
| |
| // CustomType: Custom type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Department: Department within the organization. |
| Department string `json:"department,omitempty"` |
| |
| // Description: Description of the organization. |
| Description string `json:"description,omitempty"` |
| |
| // Domain: The domain to which the organization belongs to. |
| Domain string `json:"domain,omitempty"` |
| |
| // FullTimeEquivalent: The full-time equivalent percent within the |
| // organization (100000 = 100%). |
| FullTimeEquivalent int64 `json:"fullTimeEquivalent,omitempty"` |
| |
| // Location: Location of the organization. This need not be fully |
| // qualified address. |
| Location string `json:"location,omitempty"` |
| |
| // Name: Name of the organization |
| Name string `json:"name,omitempty"` |
| |
| // Primary: If it user's primary organization. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Symbol: Symbol of the organization. |
| Symbol string `json:"symbol,omitempty"` |
| |
| // Title: Title (designation) of the user in the organization. |
| Title string `json:"title,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example organization could be of school, work etc. In |
| // addition to the standard type, an entry can have a custom type and |
| // can give it any name. Such types should have the CUSTOM value as type |
| // and also have a CustomType value. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CostCenter") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CostCenter") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserOrganization) MarshalJSON() ([]byte, error) { |
| type noMethod UserOrganization |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserPhone: JSON template for a phone entry. |
| type UserPhone struct { |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Primary: If this is user's primary phone or not. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example phone could be of home_fax, work, mobile etc. |
| // In addition to the standard type, an entry can have a custom type and |
| // can give it any name. Such types should have the CUSTOM value as type |
| // and also have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // Value: Phone number. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserPhone) MarshalJSON() ([]byte, error) { |
| type noMethod UserPhone |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserPhoto: JSON template for Photo object in Directory API. |
| type UserPhoto struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Height: Height in pixels of the photo |
| Height int64 `json:"height,omitempty"` |
| |
| // Id: Unique identifier of User (Read-only) |
| Id string `json:"id,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // MimeType: Mime Type of the photo |
| MimeType string `json:"mimeType,omitempty"` |
| |
| // PhotoData: Base64 encoded photo data |
| PhotoData string `json:"photoData,omitempty"` |
| |
| // PrimaryEmail: Primary email of User (Read-only) |
| PrimaryEmail string `json:"primaryEmail,omitempty"` |
| |
| // Width: Width in pixels of the photo |
| Width int64 `json:"width,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserPhoto) MarshalJSON() ([]byte, error) { |
| type noMethod UserPhoto |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserPosixAccount: JSON template for a POSIX account entry. |
| // Description of the field family: go/fbs-posix. |
| type UserPosixAccount struct { |
| // Gecos: The GECOS (user information) for this account. |
| Gecos string `json:"gecos,omitempty"` |
| |
| // Gid: The default group ID. |
| Gid int64 `json:"gid,omitempty"` |
| |
| // HomeDirectory: The path to the home directory for this account. |
| HomeDirectory string `json:"homeDirectory,omitempty"` |
| |
| // Primary: If this is user's primary account within the SystemId. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Shell: The path to the login shell for this account. |
| Shell string `json:"shell,omitempty"` |
| |
| // SystemId: System identifier for which account Username or Uid apply |
| // to. |
| SystemId string `json:"systemId,omitempty"` |
| |
| // Uid: The POSIX compliant user ID. |
| Uid int64 `json:"uid,omitempty"` |
| |
| // Username: The username of the account. |
| Username string `json:"username,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Gecos") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Gecos") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserPosixAccount) MarshalJSON() ([]byte, error) { |
| type noMethod UserPosixAccount |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserRelation: JSON template for a relation entry. |
| type UserRelation struct { |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Type: The relation of the user. Some of the possible values are |
| // mother, father, sister, brother, manager, assistant, partner. |
| Type string `json:"type,omitempty"` |
| |
| // Value: The name of the relation. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserRelation) MarshalJSON() ([]byte, error) { |
| type noMethod UserRelation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserSshPublicKey: JSON template for a POSIX account entry. |
| type UserSshPublicKey struct { |
| // ExpirationTimeUsec: An expiration time in microseconds since epoch. |
| ExpirationTimeUsec int64 `json:"expirationTimeUsec,omitempty,string"` |
| |
| // Fingerprint: A SHA-256 fingerprint of the SSH public key. (Read-only) |
| Fingerprint string `json:"fingerprint,omitempty"` |
| |
| // Key: An SSH public key. |
| Key string `json:"key,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ExpirationTimeUsec") |
| // to unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ExpirationTimeUsec") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserSshPublicKey) MarshalJSON() ([]byte, error) { |
| type noMethod UserSshPublicKey |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserUndelete: JSON request template to undelete a user in Directory |
| // API. |
| type UserUndelete struct { |
| // OrgUnitPath: OrgUnit of User |
| OrgUnitPath string `json:"orgUnitPath,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "OrgUnitPath") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "OrgUnitPath") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserUndelete) MarshalJSON() ([]byte, error) { |
| type noMethod UserUndelete |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // UserWebsite: JSON template for a website entry. |
| type UserWebsite struct { |
| // CustomType: Custom Type. |
| CustomType string `json:"customType,omitempty"` |
| |
| // Primary: If this is user's primary website or not. |
| Primary bool `json:"primary,omitempty"` |
| |
| // Type: Each entry can have a type which indicates standard types of |
| // that entry. For example website could be of home, work, blog etc. In |
| // addition to the standard type, an entry can have a custom type and |
| // can give it any name. Such types should have the CUSTOM value as type |
| // and also have a customType value. |
| Type string `json:"type,omitempty"` |
| |
| // Value: Website. |
| Value string `json:"value,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CustomType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CustomType") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *UserWebsite) MarshalJSON() ([]byte, error) { |
| type noMethod UserWebsite |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Users: JSON response template for List Users operation in Apps |
| // Directory API. |
| type Users struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: Kind of resource this is. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: Token used to access next page of this result. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // TriggerEvent: Event that triggered this response (only used in case |
| // of Push Response) |
| TriggerEvent string `json:"trigger_event,omitempty"` |
| |
| // Users: List of user objects. |
| Users []*User `json:"users,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Users) MarshalJSON() ([]byte, error) { |
| type noMethod Users |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // VerificationCode: JSON template for verification codes in Directory |
| // API. |
| type VerificationCode struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Kind: The type of the resource. This is always |
| // admin#directory#verificationCode. |
| Kind string `json:"kind,omitempty"` |
| |
| // UserId: The obfuscated unique ID of the user. |
| UserId string `json:"userId,omitempty"` |
| |
| // VerificationCode: A current verification code for the user. |
| // Invalidated or used verification codes are not returned as part of |
| // the result. |
| VerificationCode string `json:"verificationCode,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *VerificationCode) MarshalJSON() ([]byte, error) { |
| type noMethod VerificationCode |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // VerificationCodes: JSON response template for List verification codes |
| // operation in Directory API. |
| type VerificationCodes struct { |
| // Etag: ETag of the resource. |
| Etag string `json:"etag,omitempty"` |
| |
| // Items: A list of verification code resources. |
| Items []*VerificationCode `json:"items,omitempty"` |
| |
| // Kind: The type of the resource. This is always |
| // admin#directory#verificationCodesList. |
| Kind string `json:"kind,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Etag") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Etag") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *VerificationCodes) MarshalJSON() ([]byte, error) { |
| type noMethod VerificationCodes |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // method id "directory.asps.delete": |
| |
| type AspsDeleteCall struct { |
| s *Service |
| userKey string |
| codeId int64 |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete an ASP issued by a user. |
| func (r *AspsService) Delete(userKey string, codeId int64) *AspsDeleteCall { |
| c := &AspsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.codeId = codeId |
| 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 *AspsDeleteCall) Fields(s ...googleapi.Field) *AspsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *AspsDeleteCall) Context(ctx context.Context) *AspsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AspsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AspsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/asps/{codeId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| "codeId": strconv.FormatInt(c.codeId, 10), |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.asps.delete" call. |
| func (c *AspsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete an ASP issued by a user.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.asps.delete", |
| // "parameterOrder": [ |
| // "userKey", |
| // "codeId" |
| // ], |
| // "parameters": { |
| // "codeId": { |
| // "description": "The unique ID of the ASP to be deleted.", |
| // "format": "int32", |
| // "location": "path", |
| // "required": true, |
| // "type": "integer" |
| // }, |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/asps/{codeId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.asps.get": |
| |
| type AspsGetCall struct { |
| s *Service |
| userKey string |
| codeId int64 |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Get information about an ASP issued by a user. |
| func (r *AspsService) Get(userKey string, codeId int64) *AspsGetCall { |
| c := &AspsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.codeId = codeId |
| 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 *AspsGetCall) Fields(s ...googleapi.Field) *AspsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *AspsGetCall) IfNoneMatch(entityTag string) *AspsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *AspsGetCall) Context(ctx context.Context) *AspsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AspsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AspsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/asps/{codeId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| "codeId": strconv.FormatInt(c.codeId, 10), |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.asps.get" call. |
| // Exactly one of *Asp or error will be non-nil. Any non-2xx status code |
| // is an error. Response headers are in either |
| // *Asp.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *AspsGetCall) Do(opts ...googleapi.CallOption) (*Asp, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Asp{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get information about an ASP issued by a user.", |
| // "httpMethod": "GET", |
| // "id": "directory.asps.get", |
| // "parameterOrder": [ |
| // "userKey", |
| // "codeId" |
| // ], |
| // "parameters": { |
| // "codeId": { |
| // "description": "The unique ID of the ASP.", |
| // "format": "int32", |
| // "location": "path", |
| // "required": true, |
| // "type": "integer" |
| // }, |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/asps/{codeId}", |
| // "response": { |
| // "$ref": "Asp" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.asps.list": |
| |
| type AspsListCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: List the ASPs issued by a user. |
| func (r *AspsService) List(userKey string) *AspsListCall { |
| c := &AspsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *AspsListCall) Fields(s ...googleapi.Field) *AspsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *AspsListCall) IfNoneMatch(entityTag string) *AspsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *AspsListCall) Context(ctx context.Context) *AspsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AspsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AspsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/asps") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.asps.list" call. |
| // Exactly one of *Asps or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Asps.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *AspsListCall) Do(opts ...googleapi.CallOption) (*Asps, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Asps{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "List the ASPs issued by a user.", |
| // "httpMethod": "GET", |
| // "id": "directory.asps.list", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/asps", |
| // "response": { |
| // "$ref": "Asps" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "admin.channels.stop": |
| |
| type ChannelsStopCall struct { |
| s *Service |
| channel *Channel |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Stop: Stop watching resources through this channel |
| func (r *ChannelsService) Stop(channel *Channel) *ChannelsStopCall { |
| c := &ChannelsStopCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.channel = channel |
| 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 *ChannelsStopCall) Fields(s ...googleapi.Field) *ChannelsStopCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChannelsStopCall) Context(ctx context.Context) *ChannelsStopCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChannelsStopCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChannelsStopCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "/admin/directory_v1/channels/stop") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "admin.channels.stop" call. |
| func (c *ChannelsStopCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Stop watching resources through this channel", |
| // "httpMethod": "POST", |
| // "id": "admin.channels.stop", |
| // "path": "/admin/directory_v1/channels/stop", |
| // "request": { |
| // "$ref": "Channel", |
| // "parameterName": "resource" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias.readonly", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.chromeosdevices.action": |
| |
| type ChromeosdevicesActionCall struct { |
| s *Service |
| customerId string |
| resourceId string |
| chromeosdeviceaction *ChromeOsDeviceAction |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Action: Take action on Chrome OS Device |
| func (r *ChromeosdevicesService) Action(customerId string, resourceId string, chromeosdeviceaction *ChromeOsDeviceAction) *ChromeosdevicesActionCall { |
| c := &ChromeosdevicesActionCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.resourceId = resourceId |
| c.chromeosdeviceaction = chromeosdeviceaction |
| 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 *ChromeosdevicesActionCall) Fields(s ...googleapi.Field) *ChromeosdevicesActionCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesActionCall) Context(ctx context.Context) *ChromeosdevicesActionCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesActionCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesActionCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.chromeosdeviceaction) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos/{resourceId}/action") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "resourceId": c.resourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.action" call. |
| func (c *ChromeosdevicesActionCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Take action on Chrome OS Device", |
| // "httpMethod": "POST", |
| // "id": "directory.chromeosdevices.action", |
| // "parameterOrder": [ |
| // "customerId", |
| // "resourceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "resourceId": { |
| // "description": "Immutable ID of Chrome OS Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos/{resourceId}/action", |
| // "request": { |
| // "$ref": "ChromeOsDeviceAction" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.chromeosdevices.get": |
| |
| type ChromeosdevicesGetCall struct { |
| s *Service |
| customerId string |
| deviceId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve Chrome OS Device |
| func (r *ChromeosdevicesService) Get(customerId string, deviceId string) *ChromeosdevicesGetCall { |
| c := &ChromeosdevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.deviceId = deviceId |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // serialNumber, status, and user) |
| // "FULL" - Includes all metadata fields |
| func (c *ChromeosdevicesGetCall) Projection(projection string) *ChromeosdevicesGetCall { |
| c.urlParams_.Set("projection", projection) |
| 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 *ChromeosdevicesGetCall) Fields(s ...googleapi.Field) *ChromeosdevicesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ChromeosdevicesGetCall) IfNoneMatch(entityTag string) *ChromeosdevicesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesGetCall) Context(ctx context.Context) *ChromeosdevicesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos/{deviceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "deviceId": c.deviceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.get" call. |
| // Exactly one of *ChromeOsDevice or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *ChromeOsDevice.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ChromeosdevicesGetCall) Do(opts ...googleapi.CallOption) (*ChromeOsDevice, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ChromeOsDevice{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve Chrome OS Device", |
| // "httpMethod": "GET", |
| // "id": "directory.chromeosdevices.get", |
| // "parameterOrder": [ |
| // "customerId", |
| // "deviceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "deviceId": { |
| // "description": "Immutable ID of Chrome OS Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, serialNumber, status, and user)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos/{deviceId}", |
| // "response": { |
| // "$ref": "ChromeOsDevice" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos", |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.chromeosdevices.list": |
| |
| type ChromeosdevicesListCall struct { |
| s *Service |
| customerId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all Chrome OS Devices of a customer (paginated) |
| func (r *ChromeosdevicesService) List(customerId string) *ChromeosdevicesListCall { |
| c := &ChromeosdevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 100 |
| func (c *ChromeosdevicesListCall) MaxResults(maxResults int64) *ChromeosdevicesListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // OrderBy sets the optional parameter "orderBy": Column to use for |
| // sorting results |
| // |
| // Possible values: |
| // "annotatedLocation" - Chromebook location as annotated by the |
| // administrator. |
| // "annotatedUser" - Chromebook user as annotated by administrator. |
| // "lastSync" - Chromebook last sync. |
| // "notes" - Chromebook notes as annotated by the administrator. |
| // "serialNumber" - Chromebook Serial Number. |
| // "status" - Chromebook status. |
| // "supportEndDate" - Chromebook support end date. |
| func (c *ChromeosdevicesListCall) OrderBy(orderBy string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("orderBy", orderBy) |
| return c |
| } |
| |
| // OrgUnitPath sets the optional parameter "orgUnitPath": Full path of |
| // the organization unit or its Id |
| func (c *ChromeosdevicesListCall) OrgUnitPath(orgUnitPath string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("orgUnitPath", orgUnitPath) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *ChromeosdevicesListCall) PageToken(pageToken string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // serialNumber, status, and user) |
| // "FULL" - Includes all metadata fields |
| func (c *ChromeosdevicesListCall) Projection(projection string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("projection", projection) |
| return c |
| } |
| |
| // Query sets the optional parameter "query": Search string in the |
| // format given at |
| // http://support.google.com/chromeos/a/bin/answer.py?hl=en&answer=1698333 |
| func (c *ChromeosdevicesListCall) Query(query string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("query", query) |
| return c |
| } |
| |
| // SortOrder sets the optional parameter "sortOrder": Whether to return |
| // results in ascending or descending order. Only of use when orderBy is |
| // also used |
| // |
| // Possible values: |
| // "ASCENDING" - Ascending order. |
| // "DESCENDING" - Descending order. |
| func (c *ChromeosdevicesListCall) SortOrder(sortOrder string) *ChromeosdevicesListCall { |
| c.urlParams_.Set("sortOrder", sortOrder) |
| 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 *ChromeosdevicesListCall) Fields(s ...googleapi.Field) *ChromeosdevicesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ChromeosdevicesListCall) IfNoneMatch(entityTag string) *ChromeosdevicesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesListCall) Context(ctx context.Context) *ChromeosdevicesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.list" call. |
| // Exactly one of *ChromeOsDevices or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *ChromeOsDevices.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ChromeosdevicesListCall) Do(opts ...googleapi.CallOption) (*ChromeOsDevices, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ChromeOsDevices{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all Chrome OS Devices of a customer (paginated)", |
| // "httpMethod": "GET", |
| // "id": "directory.chromeosdevices.list", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 100", |
| // "format": "int32", |
| // "location": "query", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "orderBy": { |
| // "description": "Column to use for sorting results", |
| // "enum": [ |
| // "annotatedLocation", |
| // "annotatedUser", |
| // "lastSync", |
| // "notes", |
| // "serialNumber", |
| // "status", |
| // "supportEndDate" |
| // ], |
| // "enumDescriptions": [ |
| // "Chromebook location as annotated by the administrator.", |
| // "Chromebook user as annotated by administrator.", |
| // "Chromebook last sync.", |
| // "Chromebook notes as annotated by the administrator.", |
| // "Chromebook Serial Number.", |
| // "Chromebook status.", |
| // "Chromebook support end date." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the organization unit or its Id", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, serialNumber, status, and user)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "query": { |
| // "description": "Search string in the format given at http://support.google.com/chromeos/a/bin/answer.py?hl=en\u0026answer=1698333", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "sortOrder": { |
| // "description": "Whether to return results in ascending or descending order. Only of use when orderBy is also used", |
| // "enum": [ |
| // "ASCENDING", |
| // "DESCENDING" |
| // ], |
| // "enumDescriptions": [ |
| // "Ascending order.", |
| // "Descending order." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos", |
| // "response": { |
| // "$ref": "ChromeOsDevices" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos", |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *ChromeosdevicesListCall) Pages(ctx context.Context, f func(*ChromeOsDevices) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.chromeosdevices.moveDevicesToOu": |
| |
| type ChromeosdevicesMoveDevicesToOuCall struct { |
| s *Service |
| customerId string |
| chromeosmovedevicestoou *ChromeOsMoveDevicesToOu |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // MoveDevicesToOu: Move or insert multiple Chrome OS Devices to |
| // Organization Unit |
| func (r *ChromeosdevicesService) MoveDevicesToOu(customerId string, orgUnitPath string, chromeosmovedevicestoou *ChromeOsMoveDevicesToOu) *ChromeosdevicesMoveDevicesToOuCall { |
| c := &ChromeosdevicesMoveDevicesToOuCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.urlParams_.Set("orgUnitPath", orgUnitPath) |
| c.chromeosmovedevicestoou = chromeosmovedevicestoou |
| 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 *ChromeosdevicesMoveDevicesToOuCall) Fields(s ...googleapi.Field) *ChromeosdevicesMoveDevicesToOuCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesMoveDevicesToOuCall) Context(ctx context.Context) *ChromeosdevicesMoveDevicesToOuCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesMoveDevicesToOuCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesMoveDevicesToOuCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.chromeosmovedevicestoou) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos/moveDevicesToOu") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.moveDevicesToOu" call. |
| func (c *ChromeosdevicesMoveDevicesToOuCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Move or insert multiple Chrome OS Devices to Organization Unit", |
| // "httpMethod": "POST", |
| // "id": "directory.chromeosdevices.moveDevicesToOu", |
| // "parameterOrder": [ |
| // "customerId", |
| // "orgUnitPath" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the target organization unit or its Id", |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos/moveDevicesToOu", |
| // "request": { |
| // "$ref": "ChromeOsMoveDevicesToOu" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.chromeosdevices.patch": |
| |
| type ChromeosdevicesPatchCall struct { |
| s *Service |
| customerId string |
| deviceId string |
| chromeosdevice *ChromeOsDevice |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Update Chrome OS Device. This method supports patch semantics. |
| func (r *ChromeosdevicesService) Patch(customerId string, deviceId string, chromeosdevice *ChromeOsDevice) *ChromeosdevicesPatchCall { |
| c := &ChromeosdevicesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.deviceId = deviceId |
| c.chromeosdevice = chromeosdevice |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // serialNumber, status, and user) |
| // "FULL" - Includes all metadata fields |
| func (c *ChromeosdevicesPatchCall) Projection(projection string) *ChromeosdevicesPatchCall { |
| c.urlParams_.Set("projection", projection) |
| 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 *ChromeosdevicesPatchCall) Fields(s ...googleapi.Field) *ChromeosdevicesPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesPatchCall) Context(ctx context.Context) *ChromeosdevicesPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.chromeosdevice) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos/{deviceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "deviceId": c.deviceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.patch" call. |
| // Exactly one of *ChromeOsDevice or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *ChromeOsDevice.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ChromeosdevicesPatchCall) Do(opts ...googleapi.CallOption) (*ChromeOsDevice, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ChromeOsDevice{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Chrome OS Device. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.chromeosdevices.patch", |
| // "parameterOrder": [ |
| // "customerId", |
| // "deviceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "deviceId": { |
| // "description": "Immutable ID of Chrome OS Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, serialNumber, status, and user)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos/{deviceId}", |
| // "request": { |
| // "$ref": "ChromeOsDevice" |
| // }, |
| // "response": { |
| // "$ref": "ChromeOsDevice" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.chromeosdevices.update": |
| |
| type ChromeosdevicesUpdateCall struct { |
| s *Service |
| customerId string |
| deviceId string |
| chromeosdevice *ChromeOsDevice |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Update Chrome OS Device |
| func (r *ChromeosdevicesService) Update(customerId string, deviceId string, chromeosdevice *ChromeOsDevice) *ChromeosdevicesUpdateCall { |
| c := &ChromeosdevicesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.deviceId = deviceId |
| c.chromeosdevice = chromeosdevice |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // serialNumber, status, and user) |
| // "FULL" - Includes all metadata fields |
| func (c *ChromeosdevicesUpdateCall) Projection(projection string) *ChromeosdevicesUpdateCall { |
| c.urlParams_.Set("projection", projection) |
| 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 *ChromeosdevicesUpdateCall) Fields(s ...googleapi.Field) *ChromeosdevicesUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ChromeosdevicesUpdateCall) Context(ctx context.Context) *ChromeosdevicesUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ChromeosdevicesUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ChromeosdevicesUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.chromeosdevice) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/chromeos/{deviceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "deviceId": c.deviceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.chromeosdevices.update" call. |
| // Exactly one of *ChromeOsDevice or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *ChromeOsDevice.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ChromeosdevicesUpdateCall) Do(opts ...googleapi.CallOption) (*ChromeOsDevice, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ChromeOsDevice{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Chrome OS Device", |
| // "httpMethod": "PUT", |
| // "id": "directory.chromeosdevices.update", |
| // "parameterOrder": [ |
| // "customerId", |
| // "deviceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "deviceId": { |
| // "description": "Immutable ID of Chrome OS Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, serialNumber, status, and user)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/chromeos/{deviceId}", |
| // "request": { |
| // "$ref": "ChromeOsDevice" |
| // }, |
| // "response": { |
| // "$ref": "ChromeOsDevice" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.chromeos" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.customers.get": |
| |
| type CustomersGetCall struct { |
| s *Service |
| customerKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a customer. |
| func (r *CustomersService) Get(customerKey string) *CustomersGetCall { |
| c := &CustomersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerKey = customerKey |
| 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 *CustomersGetCall) Fields(s ...googleapi.Field) *CustomersGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *CustomersGetCall) IfNoneMatch(entityTag string) *CustomersGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *CustomersGetCall) Context(ctx context.Context) *CustomersGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *CustomersGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *CustomersGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customers/{customerKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerKey": c.customerKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.customers.get" call. |
| // Exactly one of *Customer or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Customer.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *CustomersGetCall) Do(opts ...googleapi.CallOption) (*Customer, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Customer{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.customers.get", |
| // "parameterOrder": [ |
| // "customerKey" |
| // ], |
| // "parameters": { |
| // "customerKey": { |
| // "description": "Id of the customer to be retrieved", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customers/{customerKey}", |
| // "response": { |
| // "$ref": "Customer" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.customer", |
| // "https://www.googleapis.com/auth/admin.directory.customer.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.customers.patch": |
| |
| type CustomersPatchCall struct { |
| s *Service |
| customerKey string |
| customer *Customer |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Updates a customer. This method supports patch semantics. |
| func (r *CustomersService) Patch(customerKey string, customer *Customer) *CustomersPatchCall { |
| c := &CustomersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerKey = customerKey |
| c.customer = customer |
| 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 *CustomersPatchCall) Fields(s ...googleapi.Field) *CustomersPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *CustomersPatchCall) Context(ctx context.Context) *CustomersPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *CustomersPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *CustomersPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.customer) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customers/{customerKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerKey": c.customerKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.customers.patch" call. |
| // Exactly one of *Customer or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Customer.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *CustomersPatchCall) Do(opts ...googleapi.CallOption) (*Customer, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Customer{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a customer. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.customers.patch", |
| // "parameterOrder": [ |
| // "customerKey" |
| // ], |
| // "parameters": { |
| // "customerKey": { |
| // "description": "Id of the customer to be updated", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customers/{customerKey}", |
| // "request": { |
| // "$ref": "Customer" |
| // }, |
| // "response": { |
| // "$ref": "Customer" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.customer" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.customers.update": |
| |
| type CustomersUpdateCall struct { |
| s *Service |
| customerKey string |
| customer *Customer |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates a customer. |
| func (r *CustomersService) Update(customerKey string, customer *Customer) *CustomersUpdateCall { |
| c := &CustomersUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerKey = customerKey |
| c.customer = customer |
| 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 *CustomersUpdateCall) Fields(s ...googleapi.Field) *CustomersUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *CustomersUpdateCall) Context(ctx context.Context) *CustomersUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *CustomersUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *CustomersUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.customer) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customers/{customerKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerKey": c.customerKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.customers.update" call. |
| // Exactly one of *Customer or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Customer.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *CustomersUpdateCall) Do(opts ...googleapi.CallOption) (*Customer, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Customer{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a customer.", |
| // "httpMethod": "PUT", |
| // "id": "directory.customers.update", |
| // "parameterOrder": [ |
| // "customerKey" |
| // ], |
| // "parameters": { |
| // "customerKey": { |
| // "description": "Id of the customer to be updated", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customers/{customerKey}", |
| // "request": { |
| // "$ref": "Customer" |
| // }, |
| // "response": { |
| // "$ref": "Customer" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.customer" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domainAliases.delete": |
| |
| type DomainAliasesDeleteCall struct { |
| s *Service |
| customer string |
| domainAliasName string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a Domain Alias of the customer. |
| func (r *DomainAliasesService) Delete(customer string, domainAliasName string) *DomainAliasesDeleteCall { |
| c := &DomainAliasesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domainAliasName = domainAliasName |
| 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 *DomainAliasesDeleteCall) Fields(s ...googleapi.Field) *DomainAliasesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainAliasesDeleteCall) Context(ctx context.Context) *DomainAliasesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainAliasesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainAliasesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domainaliases/{domainAliasName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "domainAliasName": c.domainAliasName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domainAliases.delete" call. |
| func (c *DomainAliasesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a Domain Alias of the customer.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.domainAliases.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "domainAliasName" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "domainAliasName": { |
| // "description": "Name of domain alias to be retrieved.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domainaliases/{domainAliasName}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domainAliases.get": |
| |
| type DomainAliasesGetCall struct { |
| s *Service |
| customer string |
| domainAliasName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a domain alias of the customer. |
| func (r *DomainAliasesService) Get(customer string, domainAliasName string) *DomainAliasesGetCall { |
| c := &DomainAliasesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domainAliasName = domainAliasName |
| 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 *DomainAliasesGetCall) Fields(s ...googleapi.Field) *DomainAliasesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *DomainAliasesGetCall) IfNoneMatch(entityTag string) *DomainAliasesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainAliasesGetCall) Context(ctx context.Context) *DomainAliasesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainAliasesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainAliasesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domainaliases/{domainAliasName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "domainAliasName": c.domainAliasName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domainAliases.get" call. |
| // Exactly one of *DomainAlias or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *DomainAlias.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *DomainAliasesGetCall) Do(opts ...googleapi.CallOption) (*DomainAlias, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &DomainAlias{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a domain alias of the customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.domainAliases.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "domainAliasName" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "domainAliasName": { |
| // "description": "Name of domain alias to be retrieved.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domainaliases/{domainAliasName}", |
| // "response": { |
| // "$ref": "DomainAlias" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain", |
| // "https://www.googleapis.com/auth/admin.directory.domain.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domainAliases.insert": |
| |
| type DomainAliasesInsertCall struct { |
| s *Service |
| customer string |
| domainalias *DomainAlias |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Inserts a Domain alias of the customer. |
| func (r *DomainAliasesService) Insert(customer string, domainalias *DomainAlias) *DomainAliasesInsertCall { |
| c := &DomainAliasesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domainalias = domainalias |
| 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 *DomainAliasesInsertCall) Fields(s ...googleapi.Field) *DomainAliasesInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainAliasesInsertCall) Context(ctx context.Context) *DomainAliasesInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainAliasesInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainAliasesInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.domainalias) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domainaliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domainAliases.insert" call. |
| // Exactly one of *DomainAlias or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *DomainAlias.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *DomainAliasesInsertCall) Do(opts ...googleapi.CallOption) (*DomainAlias, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &DomainAlias{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Inserts a Domain alias of the customer.", |
| // "httpMethod": "POST", |
| // "id": "directory.domainAliases.insert", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domainaliases", |
| // "request": { |
| // "$ref": "DomainAlias" |
| // }, |
| // "response": { |
| // "$ref": "DomainAlias" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domainAliases.list": |
| |
| type DomainAliasesListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the domain aliases of the customer. |
| func (r *DomainAliasesService) List(customer string) *DomainAliasesListCall { |
| c := &DomainAliasesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| return c |
| } |
| |
| // ParentDomainName sets the optional parameter "parentDomainName": Name |
| // of the parent domain for which domain aliases are to be fetched. |
| func (c *DomainAliasesListCall) ParentDomainName(parentDomainName string) *DomainAliasesListCall { |
| c.urlParams_.Set("parentDomainName", parentDomainName) |
| 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 *DomainAliasesListCall) Fields(s ...googleapi.Field) *DomainAliasesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *DomainAliasesListCall) IfNoneMatch(entityTag string) *DomainAliasesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainAliasesListCall) Context(ctx context.Context) *DomainAliasesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainAliasesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainAliasesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domainaliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domainAliases.list" call. |
| // Exactly one of *DomainAliases or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *DomainAliases.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *DomainAliasesListCall) Do(opts ...googleapi.CallOption) (*DomainAliases, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &DomainAliases{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists the domain aliases of the customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.domainAliases.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "parentDomainName": { |
| // "description": "Name of the parent domain for which domain aliases are to be fetched.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domainaliases", |
| // "response": { |
| // "$ref": "DomainAliases" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain", |
| // "https://www.googleapis.com/auth/admin.directory.domain.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domains.delete": |
| |
| type DomainsDeleteCall struct { |
| s *Service |
| customer string |
| domainName string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a domain of the customer. |
| func (r *DomainsService) Delete(customer string, domainName string) *DomainsDeleteCall { |
| c := &DomainsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domainName = domainName |
| 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 *DomainsDeleteCall) Fields(s ...googleapi.Field) *DomainsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainsDeleteCall) Context(ctx context.Context) *DomainsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domains/{domainName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "domainName": c.domainName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domains.delete" call. |
| func (c *DomainsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a domain of the customer.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.domains.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "domainName" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "domainName": { |
| // "description": "Name of domain to be deleted", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domains/{domainName}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domains.get": |
| |
| type DomainsGetCall struct { |
| s *Service |
| customer string |
| domainName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a domain of the customer. |
| func (r *DomainsService) Get(customer string, domainName string) *DomainsGetCall { |
| c := &DomainsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domainName = domainName |
| 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 *DomainsGetCall) Fields(s ...googleapi.Field) *DomainsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *DomainsGetCall) IfNoneMatch(entityTag string) *DomainsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainsGetCall) Context(ctx context.Context) *DomainsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domains/{domainName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "domainName": c.domainName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domains.get" call. |
| // Exactly one of *Domains or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Domains.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *DomainsGetCall) Do(opts ...googleapi.CallOption) (*Domains, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Domains{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a domain of the customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.domains.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "domainName" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "domainName": { |
| // "description": "Name of domain to be retrieved", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domains/{domainName}", |
| // "response": { |
| // "$ref": "Domains" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain", |
| // "https://www.googleapis.com/auth/admin.directory.domain.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domains.insert": |
| |
| type DomainsInsertCall struct { |
| s *Service |
| customer string |
| domains *Domains |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Inserts a domain of the customer. |
| func (r *DomainsService) Insert(customer string, domains *Domains) *DomainsInsertCall { |
| c := &DomainsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.domains = domains |
| 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 *DomainsInsertCall) Fields(s ...googleapi.Field) *DomainsInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainsInsertCall) Context(ctx context.Context) *DomainsInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainsInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainsInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.domains) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domains") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domains.insert" call. |
| // Exactly one of *Domains or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Domains.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *DomainsInsertCall) Do(opts ...googleapi.CallOption) (*Domains, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Domains{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Inserts a domain of the customer.", |
| // "httpMethod": "POST", |
| // "id": "directory.domains.insert", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domains", |
| // "request": { |
| // "$ref": "Domains" |
| // }, |
| // "response": { |
| // "$ref": "Domains" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.domains.list": |
| |
| type DomainsListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the domains of the customer. |
| func (r *DomainsService) List(customer string) *DomainsListCall { |
| c := &DomainsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| 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 *DomainsListCall) Fields(s ...googleapi.Field) *DomainsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *DomainsListCall) IfNoneMatch(entityTag string) *DomainsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *DomainsListCall) Context(ctx context.Context) *DomainsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *DomainsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *DomainsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/domains") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.domains.list" call. |
| // Exactly one of *Domains2 or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Domains2.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *DomainsListCall) Do(opts ...googleapi.CallOption) (*Domains2, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Domains2{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists the domains of the customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.domains.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/domains", |
| // "response": { |
| // "$ref": "Domains2" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.domain", |
| // "https://www.googleapis.com/auth/admin.directory.domain.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.delete": |
| |
| type GroupsDeleteCall struct { |
| s *Service |
| groupKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete Group |
| func (r *GroupsService) Delete(groupKey string) *GroupsDeleteCall { |
| c := &GroupsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| 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 *GroupsDeleteCall) Fields(s ...googleapi.Field) *GroupsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsDeleteCall) Context(ctx context.Context) *GroupsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.delete" call. |
| func (c *GroupsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete Group", |
| // "httpMethod": "DELETE", |
| // "id": "directory.groups.delete", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.get": |
| |
| type GroupsGetCall struct { |
| s *Service |
| groupKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve Group |
| func (r *GroupsService) Get(groupKey string) *GroupsGetCall { |
| c := &GroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| 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 *GroupsGetCall) Fields(s ...googleapi.Field) *GroupsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *GroupsGetCall) IfNoneMatch(entityTag string) *GroupsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsGetCall) Context(ctx context.Context) *GroupsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.get" call. |
| // Exactly one of *Group or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Group.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsGetCall) Do(opts ...googleapi.CallOption) (*Group, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Group{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve Group", |
| // "httpMethod": "GET", |
| // "id": "directory.groups.get", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}", |
| // "response": { |
| // "$ref": "Group" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.insert": |
| |
| type GroupsInsertCall struct { |
| s *Service |
| group *Group |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Create Group |
| func (r *GroupsService) Insert(group *Group) *GroupsInsertCall { |
| c := &GroupsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.group = group |
| 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 *GroupsInsertCall) Fields(s ...googleapi.Field) *GroupsInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsInsertCall) Context(ctx context.Context) *GroupsInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.group) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.insert" call. |
| // Exactly one of *Group or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Group.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsInsertCall) Do(opts ...googleapi.CallOption) (*Group, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Group{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Create Group", |
| // "httpMethod": "POST", |
| // "id": "directory.groups.insert", |
| // "path": "groups", |
| // "request": { |
| // "$ref": "Group" |
| // }, |
| // "response": { |
| // "$ref": "Group" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.list": |
| |
| type GroupsListCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all groups in a domain (paginated) |
| func (r *GroupsService) List() *GroupsListCall { |
| c := &GroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| return c |
| } |
| |
| // Customer sets the optional parameter "customer": Immutable ID of the |
| // G Suite account. In case of multi-domain, to fetch all groups for a |
| // customer, fill this field instead of domain. |
| func (c *GroupsListCall) Customer(customer string) *GroupsListCall { |
| c.urlParams_.Set("customer", customer) |
| return c |
| } |
| |
| // Domain sets the optional parameter "domain": Name of the domain. Fill |
| // this field to get groups from only this domain. To return all groups |
| // in a multi-domain fill customer field instead. |
| func (c *GroupsListCall) Domain(domain string) *GroupsListCall { |
| c.urlParams_.Set("domain", domain) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 200 |
| func (c *GroupsListCall) MaxResults(maxResults int64) *GroupsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *GroupsListCall) PageToken(pageToken string) *GroupsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // UserKey sets the optional parameter "userKey": Email or immutable Id |
| // of the user if only those groups are to be listed, the given user is |
| // a member of. If Id, it should match with id of user object |
| func (c *GroupsListCall) UserKey(userKey string) *GroupsListCall { |
| c.urlParams_.Set("userKey", userKey) |
| 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 *GroupsListCall) Fields(s ...googleapi.Field) *GroupsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *GroupsListCall) IfNoneMatch(entityTag string) *GroupsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsListCall) Context(ctx context.Context) *GroupsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.list" call. |
| // Exactly one of *Groups or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Groups.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsListCall) Do(opts ...googleapi.CallOption) (*Groups, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Groups{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all groups in a domain (paginated)", |
| // "httpMethod": "GET", |
| // "id": "directory.groups.list", |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account. In case of multi-domain, to fetch all groups for a customer, fill this field instead of domain.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "domain": { |
| // "description": "Name of the domain. Fill this field to get groups from only this domain. To return all groups in a multi-domain fill customer field instead.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 200", |
| // "format": "int32", |
| // "location": "query", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Email or immutable Id of the user if only those groups are to be listed, the given user is a member of. If Id, it should match with id of user object", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups", |
| // "response": { |
| // "$ref": "Groups" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *GroupsListCall) Pages(ctx context.Context, f func(*Groups) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.groups.patch": |
| |
| type GroupsPatchCall struct { |
| s *Service |
| groupKey string |
| group *Group |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Update Group. This method supports patch semantics. |
| func (r *GroupsService) Patch(groupKey string, group *Group) *GroupsPatchCall { |
| c := &GroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.group = group |
| 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 *GroupsPatchCall) Fields(s ...googleapi.Field) *GroupsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsPatchCall) Context(ctx context.Context) *GroupsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.group) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.patch" call. |
| // Exactly one of *Group or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Group.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsPatchCall) Do(opts ...googleapi.CallOption) (*Group, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Group{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Group. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.groups.patch", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group. If Id, it should match with id of group object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}", |
| // "request": { |
| // "$ref": "Group" |
| // }, |
| // "response": { |
| // "$ref": "Group" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.update": |
| |
| type GroupsUpdateCall struct { |
| s *Service |
| groupKey string |
| group *Group |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Update Group |
| func (r *GroupsService) Update(groupKey string, group *Group) *GroupsUpdateCall { |
| c := &GroupsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.group = group |
| 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 *GroupsUpdateCall) Fields(s ...googleapi.Field) *GroupsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsUpdateCall) Context(ctx context.Context) *GroupsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.group) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.update" call. |
| // Exactly one of *Group or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Group.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsUpdateCall) Do(opts ...googleapi.CallOption) (*Group, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Group{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Group", |
| // "httpMethod": "PUT", |
| // "id": "directory.groups.update", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group. If Id, it should match with id of group object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}", |
| // "request": { |
| // "$ref": "Group" |
| // }, |
| // "response": { |
| // "$ref": "Group" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.aliases.delete": |
| |
| type GroupsAliasesDeleteCall struct { |
| s *Service |
| groupKey string |
| alias string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Remove a alias for the group |
| func (r *GroupsAliasesService) Delete(groupKey string, alias string) *GroupsAliasesDeleteCall { |
| c := &GroupsAliasesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.alias = alias |
| 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 *GroupsAliasesDeleteCall) Fields(s ...googleapi.Field) *GroupsAliasesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsAliasesDeleteCall) Context(ctx context.Context) *GroupsAliasesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsAliasesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsAliasesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/aliases/{alias}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| "alias": c.alias, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.aliases.delete" call. |
| func (c *GroupsAliasesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Remove a alias for the group", |
| // "httpMethod": "DELETE", |
| // "id": "directory.groups.aliases.delete", |
| // "parameterOrder": [ |
| // "groupKey", |
| // "alias" |
| // ], |
| // "parameters": { |
| // "alias": { |
| // "description": "The alias to be removed", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/aliases/{alias}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.aliases.insert": |
| |
| type GroupsAliasesInsertCall struct { |
| s *Service |
| groupKey string |
| alias *Alias |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Add a alias for the group |
| func (r *GroupsAliasesService) Insert(groupKey string, alias *Alias) *GroupsAliasesInsertCall { |
| c := &GroupsAliasesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.alias = alias |
| 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 *GroupsAliasesInsertCall) Fields(s ...googleapi.Field) *GroupsAliasesInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsAliasesInsertCall) Context(ctx context.Context) *GroupsAliasesInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsAliasesInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsAliasesInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.alias) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/aliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.aliases.insert" call. |
| // Exactly one of *Alias or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Alias.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsAliasesInsertCall) Do(opts ...googleapi.CallOption) (*Alias, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Alias{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add a alias for the group", |
| // "httpMethod": "POST", |
| // "id": "directory.groups.aliases.insert", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/aliases", |
| // "request": { |
| // "$ref": "Alias" |
| // }, |
| // "response": { |
| // "$ref": "Alias" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.groups.aliases.list": |
| |
| type GroupsAliasesListCall struct { |
| s *Service |
| groupKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: List all aliases for a group |
| func (r *GroupsAliasesService) List(groupKey string) *GroupsAliasesListCall { |
| c := &GroupsAliasesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| 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 *GroupsAliasesListCall) Fields(s ...googleapi.Field) *GroupsAliasesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *GroupsAliasesListCall) IfNoneMatch(entityTag string) *GroupsAliasesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *GroupsAliasesListCall) Context(ctx context.Context) *GroupsAliasesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *GroupsAliasesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GroupsAliasesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/aliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.groups.aliases.list" call. |
| // Exactly one of *Aliases or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Aliases.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *GroupsAliasesListCall) Do(opts ...googleapi.CallOption) (*Aliases, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Aliases{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "List all aliases for a group", |
| // "httpMethod": "GET", |
| // "id": "directory.groups.aliases.list", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/aliases", |
| // "response": { |
| // "$ref": "Aliases" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| // ], |
| // "supportsSubscription": true |
| // } |
| |
| } |
| |
| // method id "directory.members.delete": |
| |
| type MembersDeleteCall struct { |
| s *Service |
| groupKey string |
| memberKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Remove membership. |
| func (r *MembersService) Delete(groupKey string, memberKey string) *MembersDeleteCall { |
| c := &MembersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.memberKey = memberKey |
| 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 *MembersDeleteCall) Fields(s ...googleapi.Field) *MembersDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersDeleteCall) Context(ctx context.Context) *MembersDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members/{memberKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| "memberKey": c.memberKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.delete" call. |
| func (c *MembersDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Remove membership.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.members.delete", |
| // "parameterOrder": [ |
| // "groupKey", |
| // "memberKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "memberKey": { |
| // "description": "Email or immutable Id of the member", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members/{memberKey}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.members.get": |
| |
| type MembersGetCall struct { |
| s *Service |
| groupKey string |
| memberKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve Group Member |
| func (r *MembersService) Get(groupKey string, memberKey string) *MembersGetCall { |
| c := &MembersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.memberKey = memberKey |
| 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 *MembersGetCall) Fields(s ...googleapi.Field) *MembersGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *MembersGetCall) IfNoneMatch(entityTag string) *MembersGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersGetCall) Context(ctx context.Context) *MembersGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members/{memberKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| "memberKey": c.memberKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.get" call. |
| // Exactly one of *Member or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Member.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *MembersGetCall) Do(opts ...googleapi.CallOption) (*Member, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Member{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve Group Member", |
| // "httpMethod": "GET", |
| // "id": "directory.members.get", |
| // "parameterOrder": [ |
| // "groupKey", |
| // "memberKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "memberKey": { |
| // "description": "Email or immutable Id of the member", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members/{memberKey}", |
| // "response": { |
| // "$ref": "Member" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member", |
| // "https://www.googleapis.com/auth/admin.directory.group.member.readonly", |
| // "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.members.insert": |
| |
| type MembersInsertCall struct { |
| s *Service |
| groupKey string |
| member *Member |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Add user to the specified group. |
| func (r *MembersService) Insert(groupKey string, member *Member) *MembersInsertCall { |
| c := &MembersInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.member = member |
| 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 *MembersInsertCall) Fields(s ...googleapi.Field) *MembersInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersInsertCall) Context(ctx context.Context) *MembersInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.member) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.insert" call. |
| // Exactly one of *Member or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Member.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *MembersInsertCall) Do(opts ...googleapi.CallOption) (*Member, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Member{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add user to the specified group.", |
| // "httpMethod": "POST", |
| // "id": "directory.members.insert", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members", |
| // "request": { |
| // "$ref": "Member" |
| // }, |
| // "response": { |
| // "$ref": "Member" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.members.list": |
| |
| type MembersListCall struct { |
| s *Service |
| groupKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all members in a group (paginated) |
| func (r *MembersService) List(groupKey string) *MembersListCall { |
| c := &MembersListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 200 |
| func (c *MembersListCall) MaxResults(maxResults int64) *MembersListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *MembersListCall) PageToken(pageToken string) *MembersListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Roles sets the optional parameter "roles": Comma separated role |
| // values to filter list results on. |
| func (c *MembersListCall) Roles(roles string) *MembersListCall { |
| c.urlParams_.Set("roles", roles) |
| 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 *MembersListCall) Fields(s ...googleapi.Field) *MembersListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *MembersListCall) IfNoneMatch(entityTag string) *MembersListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersListCall) Context(ctx context.Context) *MembersListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.list" call. |
| // Exactly one of *Members or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Members.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *MembersListCall) Do(opts ...googleapi.CallOption) (*Members, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Members{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all members in a group (paginated)", |
| // "httpMethod": "GET", |
| // "id": "directory.members.list", |
| // "parameterOrder": [ |
| // "groupKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 200", |
| // "format": "int32", |
| // "location": "query", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "roles": { |
| // "description": "Comma separated role values to filter list results on.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members", |
| // "response": { |
| // "$ref": "Members" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member", |
| // "https://www.googleapis.com/auth/admin.directory.group.member.readonly", |
| // "https://www.googleapis.com/auth/admin.directory.group.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *MembersListCall) Pages(ctx context.Context, f func(*Members) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.members.patch": |
| |
| type MembersPatchCall struct { |
| s *Service |
| groupKey string |
| memberKey string |
| member *Member |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Update membership of a user in the specified group. This |
| // method supports patch semantics. |
| func (r *MembersService) Patch(groupKey string, memberKey string, member *Member) *MembersPatchCall { |
| c := &MembersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.memberKey = memberKey |
| c.member = member |
| 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 *MembersPatchCall) Fields(s ...googleapi.Field) *MembersPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersPatchCall) Context(ctx context.Context) *MembersPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.member) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members/{memberKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| "memberKey": c.memberKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.patch" call. |
| // Exactly one of *Member or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Member.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *MembersPatchCall) Do(opts ...googleapi.CallOption) (*Member, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Member{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update membership of a user in the specified group. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.members.patch", |
| // "parameterOrder": [ |
| // "groupKey", |
| // "memberKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group. If Id, it should match with id of group object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "memberKey": { |
| // "description": "Email or immutable Id of the user. If Id, it should match with id of member object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members/{memberKey}", |
| // "request": { |
| // "$ref": "Member" |
| // }, |
| // "response": { |
| // "$ref": "Member" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.members.update": |
| |
| type MembersUpdateCall struct { |
| s *Service |
| groupKey string |
| memberKey string |
| member *Member |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Update membership of a user in the specified group. |
| func (r *MembersService) Update(groupKey string, memberKey string, member *Member) *MembersUpdateCall { |
| c := &MembersUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.groupKey = groupKey |
| c.memberKey = memberKey |
| c.member = member |
| 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 *MembersUpdateCall) Fields(s ...googleapi.Field) *MembersUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MembersUpdateCall) Context(ctx context.Context) *MembersUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MembersUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MembersUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.member) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "groups/{groupKey}/members/{memberKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "groupKey": c.groupKey, |
| "memberKey": c.memberKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.members.update" call. |
| // Exactly one of *Member or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Member.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *MembersUpdateCall) Do(opts ...googleapi.CallOption) (*Member, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Member{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update membership of a user in the specified group.", |
| // "httpMethod": "PUT", |
| // "id": "directory.members.update", |
| // "parameterOrder": [ |
| // "groupKey", |
| // "memberKey" |
| // ], |
| // "parameters": { |
| // "groupKey": { |
| // "description": "Email or immutable Id of the group. If Id, it should match with id of group object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "memberKey": { |
| // "description": "Email or immutable Id of the user. If Id, it should match with id of member object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "groups/{groupKey}/members/{memberKey}", |
| // "request": { |
| // "$ref": "Member" |
| // }, |
| // "response": { |
| // "$ref": "Member" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.group", |
| // "https://www.googleapis.com/auth/admin.directory.group.member" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.mobiledevices.action": |
| |
| type MobiledevicesActionCall struct { |
| s *Service |
| customerId string |
| resourceId string |
| mobiledeviceaction *MobileDeviceAction |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Action: Take action on Mobile Device |
| func (r *MobiledevicesService) Action(customerId string, resourceId string, mobiledeviceaction *MobileDeviceAction) *MobiledevicesActionCall { |
| c := &MobiledevicesActionCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.resourceId = resourceId |
| c.mobiledeviceaction = mobiledeviceaction |
| 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 *MobiledevicesActionCall) Fields(s ...googleapi.Field) *MobiledevicesActionCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MobiledevicesActionCall) Context(ctx context.Context) *MobiledevicesActionCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MobiledevicesActionCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MobiledevicesActionCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.mobiledeviceaction) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/mobile/{resourceId}/action") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "resourceId": c.resourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.mobiledevices.action" call. |
| func (c *MobiledevicesActionCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Take action on Mobile Device", |
| // "httpMethod": "POST", |
| // "id": "directory.mobiledevices.action", |
| // "parameterOrder": [ |
| // "customerId", |
| // "resourceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "resourceId": { |
| // "description": "Immutable ID of Mobile Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/mobile/{resourceId}/action", |
| // "request": { |
| // "$ref": "MobileDeviceAction" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile", |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile.action" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.mobiledevices.delete": |
| |
| type MobiledevicesDeleteCall struct { |
| s *Service |
| customerId string |
| resourceId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete Mobile Device |
| func (r *MobiledevicesService) Delete(customerId string, resourceId string) *MobiledevicesDeleteCall { |
| c := &MobiledevicesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.resourceId = resourceId |
| 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 *MobiledevicesDeleteCall) Fields(s ...googleapi.Field) *MobiledevicesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MobiledevicesDeleteCall) Context(ctx context.Context) *MobiledevicesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MobiledevicesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MobiledevicesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/mobile/{resourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "resourceId": c.resourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.mobiledevices.delete" call. |
| func (c *MobiledevicesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete Mobile Device", |
| // "httpMethod": "DELETE", |
| // "id": "directory.mobiledevices.delete", |
| // "parameterOrder": [ |
| // "customerId", |
| // "resourceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "resourceId": { |
| // "description": "Immutable ID of Mobile Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/mobile/{resourceId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.mobiledevices.get": |
| |
| type MobiledevicesGetCall struct { |
| s *Service |
| customerId string |
| resourceId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve Mobile Device |
| func (r *MobiledevicesService) Get(customerId string, resourceId string) *MobiledevicesGetCall { |
| c := &MobiledevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.resourceId = resourceId |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // model, status, type, and status) |
| // "FULL" - Includes all metadata fields |
| func (c *MobiledevicesGetCall) Projection(projection string) *MobiledevicesGetCall { |
| c.urlParams_.Set("projection", projection) |
| 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 *MobiledevicesGetCall) Fields(s ...googleapi.Field) *MobiledevicesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *MobiledevicesGetCall) IfNoneMatch(entityTag string) *MobiledevicesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MobiledevicesGetCall) Context(ctx context.Context) *MobiledevicesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MobiledevicesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MobiledevicesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/mobile/{resourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "resourceId": c.resourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.mobiledevices.get" call. |
| // Exactly one of *MobileDevice or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *MobileDevice.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *MobiledevicesGetCall) Do(opts ...googleapi.CallOption) (*MobileDevice, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &MobileDevice{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve Mobile Device", |
| // "httpMethod": "GET", |
| // "id": "directory.mobiledevices.get", |
| // "parameterOrder": [ |
| // "customerId", |
| // "resourceId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, model, status, type, and status)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "resourceId": { |
| // "description": "Immutable ID of Mobile Device", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/mobile/{resourceId}", |
| // "response": { |
| // "$ref": "MobileDevice" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile", |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile.action", |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.mobiledevices.list": |
| |
| type MobiledevicesListCall struct { |
| s *Service |
| customerId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all Mobile Devices of a customer (paginated) |
| func (r *MobiledevicesService) List(customerId string) *MobiledevicesListCall { |
| c := &MobiledevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 100 |
| func (c *MobiledevicesListCall) MaxResults(maxResults int64) *MobiledevicesListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // OrderBy sets the optional parameter "orderBy": Column to use for |
| // sorting results |
| // |
| // Possible values: |
| // "deviceId" - Mobile Device serial number. |
| // "email" - Owner user email. |
| // "lastSync" - Last policy settings sync date time of the device. |
| // "model" - Mobile Device model. |
| // "name" - Owner user name. |
| // "os" - Mobile operating system. |
| // "status" - Status of the device. |
| // "type" - Type of the device. |
| func (c *MobiledevicesListCall) OrderBy(orderBy string) *MobiledevicesListCall { |
| c.urlParams_.Set("orderBy", orderBy) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *MobiledevicesListCall) PageToken(pageToken string) *MobiledevicesListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": Restrict |
| // information returned to a set of selected fields. |
| // |
| // Possible values: |
| // "BASIC" - Includes only the basic metadata fields (e.g., deviceId, |
| // model, status, type, and status) |
| // "FULL" - Includes all metadata fields |
| func (c *MobiledevicesListCall) Projection(projection string) *MobiledevicesListCall { |
| c.urlParams_.Set("projection", projection) |
| return c |
| } |
| |
| // Query sets the optional parameter "query": Search string in the |
| // format given at |
| // http://support.google.com/a/bin/answer.py?hl=en&answer=1408863#search |
| func (c *MobiledevicesListCall) Query(query string) *MobiledevicesListCall { |
| c.urlParams_.Set("query", query) |
| return c |
| } |
| |
| // SortOrder sets the optional parameter "sortOrder": Whether to return |
| // results in ascending or descending order. Only of use when orderBy is |
| // also used |
| // |
| // Possible values: |
| // "ASCENDING" - Ascending order. |
| // "DESCENDING" - Descending order. |
| func (c *MobiledevicesListCall) SortOrder(sortOrder string) *MobiledevicesListCall { |
| c.urlParams_.Set("sortOrder", sortOrder) |
| 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 *MobiledevicesListCall) Fields(s ...googleapi.Field) *MobiledevicesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *MobiledevicesListCall) IfNoneMatch(entityTag string) *MobiledevicesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MobiledevicesListCall) Context(ctx context.Context) *MobiledevicesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *MobiledevicesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *MobiledevicesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/devices/mobile") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.mobiledevices.list" call. |
| // Exactly one of *MobileDevices or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *MobileDevices.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *MobiledevicesListCall) Do(opts ...googleapi.CallOption) (*MobileDevices, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &MobileDevices{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all Mobile Devices of a customer (paginated)", |
| // "httpMethod": "GET", |
| // "id": "directory.mobiledevices.list", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 100", |
| // "format": "int32", |
| // "location": "query", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "orderBy": { |
| // "description": "Column to use for sorting results", |
| // "enum": [ |
| // "deviceId", |
| // "email", |
| // "lastSync", |
| // "model", |
| // "name", |
| // "os", |
| // "status", |
| // "type" |
| // ], |
| // "enumDescriptions": [ |
| // "Mobile Device serial number.", |
| // "Owner user email.", |
| // "Last policy settings sync date time of the device.", |
| // "Mobile Device model.", |
| // "Owner user name.", |
| // "Mobile operating system.", |
| // "Status of the device.", |
| // "Type of the device." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "description": "Restrict information returned to a set of selected fields.", |
| // "enum": [ |
| // "BASIC", |
| // "FULL" |
| // ], |
| // "enumDescriptions": [ |
| // "Includes only the basic metadata fields (e.g., deviceId, model, status, type, and status)", |
| // "Includes all metadata fields" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "query": { |
| // "description": "Search string in the format given at http://support.google.com/a/bin/answer.py?hl=en\u0026answer=1408863#search", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "sortOrder": { |
| // "description": "Whether to return results in ascending or descending order. Only of use when orderBy is also used", |
| // "enum": [ |
| // "ASCENDING", |
| // "DESCENDING" |
| // ], |
| // "enumDescriptions": [ |
| // "Ascending order.", |
| // "Descending order." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/devices/mobile", |
| // "response": { |
| // "$ref": "MobileDevices" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile", |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile.action", |
| // "https://www.googleapis.com/auth/admin.directory.device.mobile.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *MobiledevicesListCall) Pages(ctx context.Context, f func(*MobileDevices) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.notifications.delete": |
| |
| type NotificationsDeleteCall struct { |
| s *Service |
| customer string |
| notificationId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a notification |
| func (r *NotificationsService) Delete(customer string, notificationId string) *NotificationsDeleteCall { |
| c := &NotificationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.notificationId = notificationId |
| 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 *NotificationsDeleteCall) Fields(s ...googleapi.Field) *NotificationsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *NotificationsDeleteCall) Context(ctx context.Context) *NotificationsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *NotificationsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *NotificationsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/notifications/{notificationId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "notificationId": c.notificationId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.notifications.delete" call. |
| func (c *NotificationsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a notification", |
| // "httpMethod": "DELETE", |
| // "id": "directory.notifications.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "notificationId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. The customerId is also returned as part of the Users resource.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "notificationId": { |
| // "description": "The unique ID of the notification.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/notifications/{notificationId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.notifications" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.notifications.get": |
| |
| type NotificationsGetCall struct { |
| s *Service |
| customer string |
| notificationId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a notification. |
| func (r *NotificationsService) Get(customer string, notificationId string) *NotificationsGetCall { |
| c := &NotificationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.notificationId = notificationId |
| 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 *NotificationsGetCall) Fields(s ...googleapi.Field) *NotificationsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *NotificationsGetCall) IfNoneMatch(entityTag string) *NotificationsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *NotificationsGetCall) Context(ctx context.Context) *NotificationsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *NotificationsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *NotificationsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/notifications/{notificationId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "notificationId": c.notificationId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.notifications.get" call. |
| // Exactly one of *Notification or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Notification.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *NotificationsGetCall) Do(opts ...googleapi.CallOption) (*Notification, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Notification{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a notification.", |
| // "httpMethod": "GET", |
| // "id": "directory.notifications.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "notificationId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. The customerId is also returned as part of the Users resource.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "notificationId": { |
| // "description": "The unique ID of the notification.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/notifications/{notificationId}", |
| // "response": { |
| // "$ref": "Notification" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.notifications" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.notifications.list": |
| |
| type NotificationsListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieves a list of notifications. |
| func (r *NotificationsService) List(customer string) *NotificationsListCall { |
| c := &NotificationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| return c |
| } |
| |
| // Language sets the optional parameter "language": The ISO 639-1 code |
| // of the language notifications are returned in. The default is English |
| // (en). |
| func (c *NotificationsListCall) Language(language string) *NotificationsListCall { |
| c.urlParams_.Set("language", language) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of notifications to return per page. The default is 100. |
| func (c *NotificationsListCall) MaxResults(maxResults int64) *NotificationsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": The token to |
| // specify the page of results to retrieve. |
| func (c *NotificationsListCall) PageToken(pageToken string) *NotificationsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| 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 *NotificationsListCall) Fields(s ...googleapi.Field) *NotificationsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *NotificationsListCall) IfNoneMatch(entityTag string) *NotificationsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *NotificationsListCall) Context(ctx context.Context) *NotificationsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *NotificationsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *NotificationsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/notifications") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.notifications.list" call. |
| // Exactly one of *Notifications or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Notifications.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *NotificationsListCall) Do(opts ...googleapi.CallOption) (*Notifications, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Notifications{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a list of notifications.", |
| // "httpMethod": "GET", |
| // "id": "directory.notifications.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "language": { |
| // "description": "The ISO 639-1 code of the language notifications are returned in. The default is English (en).", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of notifications to return per page. The default is 100.", |
| // "format": "uint32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "The token to specify the page of results to retrieve.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/notifications", |
| // "response": { |
| // "$ref": "Notifications" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.notifications" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *NotificationsListCall) Pages(ctx context.Context, f func(*Notifications) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.notifications.patch": |
| |
| type NotificationsPatchCall struct { |
| s *Service |
| customer string |
| notificationId string |
| notification *Notification |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Updates a notification. This method supports patch semantics. |
| func (r *NotificationsService) Patch(customer string, notificationId string, notification *Notification) *NotificationsPatchCall { |
| c := &NotificationsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.notificationId = notificationId |
| c.notification = notification |
| 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 *NotificationsPatchCall) Fields(s ...googleapi.Field) *NotificationsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *NotificationsPatchCall) Context(ctx context.Context) *NotificationsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *NotificationsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *NotificationsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.notification) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/notifications/{notificationId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "notificationId": c.notificationId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.notifications.patch" call. |
| // Exactly one of *Notification or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Notification.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *NotificationsPatchCall) Do(opts ...googleapi.CallOption) (*Notification, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Notification{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a notification. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.notifications.patch", |
| // "parameterOrder": [ |
| // "customer", |
| // "notificationId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "notificationId": { |
| // "description": "The unique ID of the notification.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/notifications/{notificationId}", |
| // "request": { |
| // "$ref": "Notification" |
| // }, |
| // "response": { |
| // "$ref": "Notification" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.notifications" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.notifications.update": |
| |
| type NotificationsUpdateCall struct { |
| s *Service |
| customer string |
| notificationId string |
| notification *Notification |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates a notification. |
| func (r *NotificationsService) Update(customer string, notificationId string, notification *Notification) *NotificationsUpdateCall { |
| c := &NotificationsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.notificationId = notificationId |
| c.notification = notification |
| 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 *NotificationsUpdateCall) Fields(s ...googleapi.Field) *NotificationsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *NotificationsUpdateCall) Context(ctx context.Context) *NotificationsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *NotificationsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *NotificationsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.notification) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/notifications/{notificationId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "notificationId": c.notificationId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.notifications.update" call. |
| // Exactly one of *Notification or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Notification.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *NotificationsUpdateCall) Do(opts ...googleapi.CallOption) (*Notification, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Notification{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a notification.", |
| // "httpMethod": "PUT", |
| // "id": "directory.notifications.update", |
| // "parameterOrder": [ |
| // "customer", |
| // "notificationId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "notificationId": { |
| // "description": "The unique ID of the notification.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/notifications/{notificationId}", |
| // "request": { |
| // "$ref": "Notification" |
| // }, |
| // "response": { |
| // "$ref": "Notification" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.notifications" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.delete": |
| |
| type OrgunitsDeleteCall struct { |
| s *Service |
| customerId string |
| orgUnitPath []string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Remove Organization Unit |
| func (r *OrgunitsService) Delete(customerId string, orgUnitPath []string) *OrgunitsDeleteCall { |
| c := &OrgunitsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.orgUnitPath = append([]string{}, orgUnitPath...) |
| 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 *OrgunitsDeleteCall) Fields(s ...googleapi.Field) *OrgunitsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsDeleteCall) Context(ctx context.Context) *OrgunitsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits{/orgUnitPath*}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "orgUnitPath": c.orgUnitPath[0], |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.delete" call. |
| func (c *OrgunitsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Remove Organization Unit", |
| // "httpMethod": "DELETE", |
| // "id": "directory.orgunits.delete", |
| // "parameterOrder": [ |
| // "customerId", |
| // "orgUnitPath" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the organization unit or its Id", |
| // "location": "path", |
| // "repeated": true, |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits{/orgUnitPath*}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.get": |
| |
| type OrgunitsGetCall struct { |
| s *Service |
| customerId string |
| orgUnitPath []string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve Organization Unit |
| func (r *OrgunitsService) Get(customerId string, orgUnitPath []string) *OrgunitsGetCall { |
| c := &OrgunitsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.orgUnitPath = append([]string{}, orgUnitPath...) |
| 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 *OrgunitsGetCall) Fields(s ...googleapi.Field) *OrgunitsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *OrgunitsGetCall) IfNoneMatch(entityTag string) *OrgunitsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsGetCall) Context(ctx context.Context) *OrgunitsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits{/orgUnitPath*}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "orgUnitPath": c.orgUnitPath[0], |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.get" call. |
| // Exactly one of *OrgUnit or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *OrgUnit.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *OrgunitsGetCall) Do(opts ...googleapi.CallOption) (*OrgUnit, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &OrgUnit{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve Organization Unit", |
| // "httpMethod": "GET", |
| // "id": "directory.orgunits.get", |
| // "parameterOrder": [ |
| // "customerId", |
| // "orgUnitPath" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the organization unit or its Id", |
| // "location": "path", |
| // "repeated": true, |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits{/orgUnitPath*}", |
| // "response": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit", |
| // "https://www.googleapis.com/auth/admin.directory.orgunit.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.insert": |
| |
| type OrgunitsInsertCall struct { |
| s *Service |
| customerId string |
| orgunit *OrgUnit |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Add Organization Unit |
| func (r *OrgunitsService) Insert(customerId string, orgunit *OrgUnit) *OrgunitsInsertCall { |
| c := &OrgunitsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.orgunit = orgunit |
| 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 *OrgunitsInsertCall) Fields(s ...googleapi.Field) *OrgunitsInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsInsertCall) Context(ctx context.Context) *OrgunitsInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.orgunit) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.insert" call. |
| // Exactly one of *OrgUnit or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *OrgUnit.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *OrgunitsInsertCall) Do(opts ...googleapi.CallOption) (*OrgUnit, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &OrgUnit{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add Organization Unit", |
| // "httpMethod": "POST", |
| // "id": "directory.orgunits.insert", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits", |
| // "request": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "response": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.list": |
| |
| type OrgunitsListCall struct { |
| s *Service |
| customerId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all Organization Units |
| func (r *OrgunitsService) List(customerId string) *OrgunitsListCall { |
| c := &OrgunitsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| return c |
| } |
| |
| // OrgUnitPath sets the optional parameter "orgUnitPath": the |
| // URL-encoded organization unit's path or its Id |
| func (c *OrgunitsListCall) OrgUnitPath(orgUnitPath string) *OrgunitsListCall { |
| c.urlParams_.Set("orgUnitPath", orgUnitPath) |
| return c |
| } |
| |
| // Type sets the optional parameter "type": Whether to return all |
| // sub-organizations or just immediate children |
| // |
| // Possible values: |
| // "all" - All sub-organization units. |
| // "children" - Immediate children only (default). |
| func (c *OrgunitsListCall) Type(type_ string) *OrgunitsListCall { |
| c.urlParams_.Set("type", type_) |
| 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 *OrgunitsListCall) Fields(s ...googleapi.Field) *OrgunitsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *OrgunitsListCall) IfNoneMatch(entityTag string) *OrgunitsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsListCall) Context(ctx context.Context) *OrgunitsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.list" call. |
| // Exactly one of *OrgUnits or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *OrgUnits.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *OrgunitsListCall) Do(opts ...googleapi.CallOption) (*OrgUnits, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &OrgUnits{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all Organization Units", |
| // "httpMethod": "GET", |
| // "id": "directory.orgunits.list", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "default": "", |
| // "description": "the URL-encoded organization unit's path or its Id", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "type": { |
| // "description": "Whether to return all sub-organizations or just immediate children", |
| // "enum": [ |
| // "all", |
| // "children" |
| // ], |
| // "enumDescriptions": [ |
| // "All sub-organization units.", |
| // "Immediate children only (default)." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits", |
| // "response": { |
| // "$ref": "OrgUnits" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit", |
| // "https://www.googleapis.com/auth/admin.directory.orgunit.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.patch": |
| |
| type OrgunitsPatchCall struct { |
| s *Service |
| customerId string |
| orgUnitPath []string |
| orgunit *OrgUnit |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Update Organization Unit. This method supports patch |
| // semantics. |
| func (r *OrgunitsService) Patch(customerId string, orgUnitPath []string, orgunit *OrgUnit) *OrgunitsPatchCall { |
| c := &OrgunitsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.orgUnitPath = append([]string{}, orgUnitPath...) |
| c.orgunit = orgunit |
| 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 *OrgunitsPatchCall) Fields(s ...googleapi.Field) *OrgunitsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsPatchCall) Context(ctx context.Context) *OrgunitsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.orgunit) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits{/orgUnitPath*}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "orgUnitPath": c.orgUnitPath[0], |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.patch" call. |
| // Exactly one of *OrgUnit or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *OrgUnit.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *OrgunitsPatchCall) Do(opts ...googleapi.CallOption) (*OrgUnit, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &OrgUnit{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Organization Unit. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.orgunits.patch", |
| // "parameterOrder": [ |
| // "customerId", |
| // "orgUnitPath" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the organization unit or its Id", |
| // "location": "path", |
| // "repeated": true, |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits{/orgUnitPath*}", |
| // "request": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "response": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.orgunits.update": |
| |
| type OrgunitsUpdateCall struct { |
| s *Service |
| customerId string |
| orgUnitPath []string |
| orgunit *OrgUnit |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Update Organization Unit |
| func (r *OrgunitsService) Update(customerId string, orgUnitPath []string, orgunit *OrgUnit) *OrgunitsUpdateCall { |
| c := &OrgunitsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.orgUnitPath = append([]string{}, orgUnitPath...) |
| c.orgunit = orgunit |
| 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 *OrgunitsUpdateCall) Fields(s ...googleapi.Field) *OrgunitsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OrgunitsUpdateCall) Context(ctx context.Context) *OrgunitsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *OrgunitsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *OrgunitsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.orgunit) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/orgunits{/orgUnitPath*}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "orgUnitPath": c.orgUnitPath[0], |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.orgunits.update" call. |
| // Exactly one of *OrgUnit or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *OrgUnit.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *OrgunitsUpdateCall) Do(opts ...googleapi.CallOption) (*OrgUnit, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &OrgUnit{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update Organization Unit", |
| // "httpMethod": "PUT", |
| // "id": "directory.orgunits.update", |
| // "parameterOrder": [ |
| // "customerId", |
| // "orgUnitPath" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "orgUnitPath": { |
| // "description": "Full path of the organization unit or its Id", |
| // "location": "path", |
| // "repeated": true, |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/orgunits{/orgUnitPath*}", |
| // "request": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "response": { |
| // "$ref": "OrgUnit" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.orgunit" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.privileges.list": |
| |
| type PrivilegesListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieves a paginated list of all privileges for a customer. |
| func (r *PrivilegesService) List(customer string) *PrivilegesListCall { |
| c := &PrivilegesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| 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 *PrivilegesListCall) Fields(s ...googleapi.Field) *PrivilegesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *PrivilegesListCall) IfNoneMatch(entityTag string) *PrivilegesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *PrivilegesListCall) Context(ctx context.Context) *PrivilegesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *PrivilegesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *PrivilegesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles/ALL/privileges") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.privileges.list" call. |
| // Exactly one of *Privileges or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Privileges.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *PrivilegesListCall) Do(opts ...googleapi.CallOption) (*Privileges, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Privileges{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a paginated list of all privileges for a customer.", |
| // "httpMethod": "GET", |
| // "id": "directory.privileges.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles/ALL/privileges", |
| // "response": { |
| // "$ref": "Privileges" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement", |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.resources.calendars.delete": |
| |
| type ResourcesCalendarsDeleteCall struct { |
| s *Service |
| customer string |
| calendarResourceId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a calendar resource. |
| func (r *ResourcesCalendarsService) Delete(customer string, calendarResourceId string) *ResourcesCalendarsDeleteCall { |
| c := &ResourcesCalendarsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.calendarResourceId = calendarResourceId |
| 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 *ResourcesCalendarsDeleteCall) Fields(s ...googleapi.Field) *ResourcesCalendarsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsDeleteCall) Context(ctx context.Context) *ResourcesCalendarsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars/{calendarResourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "calendarResourceId": c.calendarResourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.delete" call. |
| func (c *ResourcesCalendarsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a calendar resource.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.resources.calendars.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "calendarResourceId" |
| // ], |
| // "parameters": { |
| // "calendarResourceId": { |
| // "description": "The unique ID of the calendar resource to delete.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars/{calendarResourceId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.resources.calendars.get": |
| |
| type ResourcesCalendarsGetCall struct { |
| s *Service |
| customer string |
| calendarResourceId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a calendar resource. |
| func (r *ResourcesCalendarsService) Get(customer string, calendarResourceId string) *ResourcesCalendarsGetCall { |
| c := &ResourcesCalendarsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.calendarResourceId = calendarResourceId |
| 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 *ResourcesCalendarsGetCall) Fields(s ...googleapi.Field) *ResourcesCalendarsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ResourcesCalendarsGetCall) IfNoneMatch(entityTag string) *ResourcesCalendarsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsGetCall) Context(ctx context.Context) *ResourcesCalendarsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars/{calendarResourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "calendarResourceId": c.calendarResourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.get" call. |
| // Exactly one of *CalendarResource or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *CalendarResource.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ResourcesCalendarsGetCall) Do(opts ...googleapi.CallOption) (*CalendarResource, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &CalendarResource{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a calendar resource.", |
| // "httpMethod": "GET", |
| // "id": "directory.resources.calendars.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "calendarResourceId" |
| // ], |
| // "parameters": { |
| // "calendarResourceId": { |
| // "description": "The unique ID of the calendar resource to retrieve.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars/{calendarResourceId}", |
| // "response": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar", |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.resources.calendars.insert": |
| |
| type ResourcesCalendarsInsertCall struct { |
| s *Service |
| customer string |
| calendarresource *CalendarResource |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Inserts a calendar resource. |
| func (r *ResourcesCalendarsService) Insert(customer string, calendarresource *CalendarResource) *ResourcesCalendarsInsertCall { |
| c := &ResourcesCalendarsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.calendarresource = calendarresource |
| 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 *ResourcesCalendarsInsertCall) Fields(s ...googleapi.Field) *ResourcesCalendarsInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsInsertCall) Context(ctx context.Context) *ResourcesCalendarsInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.calendarresource) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.insert" call. |
| // Exactly one of *CalendarResource or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *CalendarResource.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ResourcesCalendarsInsertCall) Do(opts ...googleapi.CallOption) (*CalendarResource, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &CalendarResource{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Inserts a calendar resource.", |
| // "httpMethod": "POST", |
| // "id": "directory.resources.calendars.insert", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars", |
| // "request": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "response": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.resources.calendars.list": |
| |
| type ResourcesCalendarsListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieves a list of calendar resources for an account. |
| func (r *ResourcesCalendarsService) List(customer string) *ResourcesCalendarsListCall { |
| c := &ResourcesCalendarsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. |
| func (c *ResourcesCalendarsListCall) MaxResults(maxResults int64) *ResourcesCalendarsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // the next page in the list. |
| func (c *ResourcesCalendarsListCall) PageToken(pageToken string) *ResourcesCalendarsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| 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 *ResourcesCalendarsListCall) Fields(s ...googleapi.Field) *ResourcesCalendarsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ResourcesCalendarsListCall) IfNoneMatch(entityTag string) *ResourcesCalendarsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsListCall) Context(ctx context.Context) *ResourcesCalendarsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.list" call. |
| // Exactly one of *CalendarResources or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *CalendarResources.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ResourcesCalendarsListCall) Do(opts ...googleapi.CallOption) (*CalendarResources, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &CalendarResources{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a list of calendar resources for an account.", |
| // "httpMethod": "GET", |
| // "id": "directory.resources.calendars.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return.", |
| // "format": "int32", |
| // "location": "query", |
| // "maximum": "500", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify the next page in the list.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars", |
| // "response": { |
| // "$ref": "CalendarResources" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar", |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *ResourcesCalendarsListCall) Pages(ctx context.Context, f func(*CalendarResources) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.resources.calendars.patch": |
| |
| type ResourcesCalendarsPatchCall struct { |
| s *Service |
| customer string |
| calendarResourceId string |
| calendarresource *CalendarResource |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Updates a calendar resource. This method supports patch |
| // semantics. |
| func (r *ResourcesCalendarsService) Patch(customer string, calendarResourceId string, calendarresource *CalendarResource) *ResourcesCalendarsPatchCall { |
| c := &ResourcesCalendarsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.calendarResourceId = calendarResourceId |
| c.calendarresource = calendarresource |
| 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 *ResourcesCalendarsPatchCall) Fields(s ...googleapi.Field) *ResourcesCalendarsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsPatchCall) Context(ctx context.Context) *ResourcesCalendarsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.calendarresource) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars/{calendarResourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "calendarResourceId": c.calendarResourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.patch" call. |
| // Exactly one of *CalendarResource or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *CalendarResource.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ResourcesCalendarsPatchCall) Do(opts ...googleapi.CallOption) (*CalendarResource, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &CalendarResource{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a calendar resource. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.resources.calendars.patch", |
| // "parameterOrder": [ |
| // "customer", |
| // "calendarResourceId" |
| // ], |
| // "parameters": { |
| // "calendarResourceId": { |
| // "description": "The unique ID of the calendar resource to update.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars/{calendarResourceId}", |
| // "request": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "response": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.resources.calendars.update": |
| |
| type ResourcesCalendarsUpdateCall struct { |
| s *Service |
| customer string |
| calendarResourceId string |
| calendarresource *CalendarResource |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates a calendar resource. |
| func (r *ResourcesCalendarsService) Update(customer string, calendarResourceId string, calendarresource *CalendarResource) *ResourcesCalendarsUpdateCall { |
| c := &ResourcesCalendarsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.calendarResourceId = calendarResourceId |
| c.calendarresource = calendarresource |
| 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 *ResourcesCalendarsUpdateCall) Fields(s ...googleapi.Field) *ResourcesCalendarsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ResourcesCalendarsUpdateCall) Context(ctx context.Context) *ResourcesCalendarsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *ResourcesCalendarsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ResourcesCalendarsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.calendarresource) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/resources/calendars/{calendarResourceId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "calendarResourceId": c.calendarResourceId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.resources.calendars.update" call. |
| // Exactly one of *CalendarResource or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *CalendarResource.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ResourcesCalendarsUpdateCall) Do(opts ...googleapi.CallOption) (*CalendarResource, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &CalendarResource{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a calendar resource.", |
| // "httpMethod": "PUT", |
| // "id": "directory.resources.calendars.update", |
| // "parameterOrder": [ |
| // "customer", |
| // "calendarResourceId" |
| // ], |
| // "parameters": { |
| // "calendarResourceId": { |
| // "description": "The unique ID of the calendar resource to update.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/resources/calendars/{calendarResourceId}", |
| // "request": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "response": { |
| // "$ref": "CalendarResource" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.resource.calendar" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roleAssignments.delete": |
| |
| type RoleAssignmentsDeleteCall struct { |
| s *Service |
| customer string |
| roleAssignmentId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a role assignment. |
| func (r *RoleAssignmentsService) Delete(customer string, roleAssignmentId string) *RoleAssignmentsDeleteCall { |
| c := &RoleAssignmentsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleAssignmentId = roleAssignmentId |
| 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 *RoleAssignmentsDeleteCall) Fields(s ...googleapi.Field) *RoleAssignmentsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RoleAssignmentsDeleteCall) Context(ctx context.Context) *RoleAssignmentsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RoleAssignmentsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RoleAssignmentsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roleassignments/{roleAssignmentId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleAssignmentId": c.roleAssignmentId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roleAssignments.delete" call. |
| func (c *RoleAssignmentsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a role assignment.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.roleAssignments.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleAssignmentId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleAssignmentId": { |
| // "description": "Immutable ID of the role assignment.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roleassignments/{roleAssignmentId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roleAssignments.get": |
| |
| type RoleAssignmentsGetCall struct { |
| s *Service |
| customer string |
| roleAssignmentId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve a role assignment. |
| func (r *RoleAssignmentsService) Get(customer string, roleAssignmentId string) *RoleAssignmentsGetCall { |
| c := &RoleAssignmentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleAssignmentId = roleAssignmentId |
| 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 *RoleAssignmentsGetCall) Fields(s ...googleapi.Field) *RoleAssignmentsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *RoleAssignmentsGetCall) IfNoneMatch(entityTag string) *RoleAssignmentsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RoleAssignmentsGetCall) Context(ctx context.Context) *RoleAssignmentsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RoleAssignmentsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RoleAssignmentsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roleassignments/{roleAssignmentId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleAssignmentId": c.roleAssignmentId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roleAssignments.get" call. |
| // Exactly one of *RoleAssignment or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *RoleAssignment.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *RoleAssignmentsGetCall) Do(opts ...googleapi.CallOption) (*RoleAssignment, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &RoleAssignment{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve a role assignment.", |
| // "httpMethod": "GET", |
| // "id": "directory.roleAssignments.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleAssignmentId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleAssignmentId": { |
| // "description": "Immutable ID of the role assignment.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roleassignments/{roleAssignmentId}", |
| // "response": { |
| // "$ref": "RoleAssignment" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement", |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roleAssignments.insert": |
| |
| type RoleAssignmentsInsertCall struct { |
| s *Service |
| customer string |
| roleassignment *RoleAssignment |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Creates a role assignment. |
| func (r *RoleAssignmentsService) Insert(customer string, roleassignment *RoleAssignment) *RoleAssignmentsInsertCall { |
| c := &RoleAssignmentsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleassignment = roleassignment |
| 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 *RoleAssignmentsInsertCall) Fields(s ...googleapi.Field) *RoleAssignmentsInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RoleAssignmentsInsertCall) Context(ctx context.Context) *RoleAssignmentsInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RoleAssignmentsInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RoleAssignmentsInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.roleassignment) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roleassignments") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roleAssignments.insert" call. |
| // Exactly one of *RoleAssignment or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *RoleAssignment.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *RoleAssignmentsInsertCall) Do(opts ...googleapi.CallOption) (*RoleAssignment, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &RoleAssignment{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates a role assignment.", |
| // "httpMethod": "POST", |
| // "id": "directory.roleAssignments.insert", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roleassignments", |
| // "request": { |
| // "$ref": "RoleAssignment" |
| // }, |
| // "response": { |
| // "$ref": "RoleAssignment" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roleAssignments.list": |
| |
| type RoleAssignmentsListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieves a paginated list of all roleAssignments. |
| func (r *RoleAssignmentsService) List(customer string) *RoleAssignmentsListCall { |
| c := &RoleAssignmentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. |
| func (c *RoleAssignmentsListCall) MaxResults(maxResults int64) *RoleAssignmentsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // the next page in the list. |
| func (c *RoleAssignmentsListCall) PageToken(pageToken string) *RoleAssignmentsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // RoleId sets the optional parameter "roleId": Immutable ID of a role. |
| // If included in the request, returns only role assignments containing |
| // this role ID. |
| func (c *RoleAssignmentsListCall) RoleId(roleId string) *RoleAssignmentsListCall { |
| c.urlParams_.Set("roleId", roleId) |
| return c |
| } |
| |
| // UserKey sets the optional parameter "userKey": The user's primary |
| // email address, alias email address, or unique user ID. If included in |
| // the request, returns role assignments only for this user. |
| func (c *RoleAssignmentsListCall) UserKey(userKey string) *RoleAssignmentsListCall { |
| c.urlParams_.Set("userKey", userKey) |
| 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 *RoleAssignmentsListCall) Fields(s ...googleapi.Field) *RoleAssignmentsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *RoleAssignmentsListCall) IfNoneMatch(entityTag string) *RoleAssignmentsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RoleAssignmentsListCall) Context(ctx context.Context) *RoleAssignmentsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RoleAssignmentsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RoleAssignmentsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roleassignments") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roleAssignments.list" call. |
| // Exactly one of *RoleAssignments or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *RoleAssignments.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *RoleAssignmentsListCall) Do(opts ...googleapi.CallOption) (*RoleAssignments, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &RoleAssignments{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a paginated list of all roleAssignments.", |
| // "httpMethod": "GET", |
| // "id": "directory.roleAssignments.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return.", |
| // "format": "int32", |
| // "location": "query", |
| // "maximum": "200", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify the next page in the list.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "roleId": { |
| // "description": "Immutable ID of a role. If included in the request, returns only role assignments containing this role ID.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "The user's primary email address, alias email address, or unique user ID. If included in the request, returns role assignments only for this user.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roleassignments", |
| // "response": { |
| // "$ref": "RoleAssignments" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement", |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *RoleAssignmentsListCall) Pages(ctx context.Context, f func(*RoleAssignments) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.roles.delete": |
| |
| type RolesDeleteCall struct { |
| s *Service |
| customer string |
| roleId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a role. |
| func (r *RolesService) Delete(customer string, roleId string) *RolesDeleteCall { |
| c := &RolesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleId = roleId |
| 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 *RolesDeleteCall) Fields(s ...googleapi.Field) *RolesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesDeleteCall) Context(ctx context.Context) *RolesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles/{roleId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleId": c.roleId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.delete" call. |
| func (c *RolesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Deletes a role.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.roles.delete", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleId": { |
| // "description": "Immutable ID of the role.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles/{roleId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roles.get": |
| |
| type RolesGetCall struct { |
| s *Service |
| customer string |
| roleId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a role. |
| func (r *RolesService) Get(customer string, roleId string) *RolesGetCall { |
| c := &RolesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleId = roleId |
| 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 *RolesGetCall) Fields(s ...googleapi.Field) *RolesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *RolesGetCall) IfNoneMatch(entityTag string) *RolesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesGetCall) Context(ctx context.Context) *RolesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles/{roleId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleId": c.roleId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.get" call. |
| // Exactly one of *Role or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Role.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *RolesGetCall) Do(opts ...googleapi.CallOption) (*Role, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Role{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a role.", |
| // "httpMethod": "GET", |
| // "id": "directory.roles.get", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleId": { |
| // "description": "Immutable ID of the role.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles/{roleId}", |
| // "response": { |
| // "$ref": "Role" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement", |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roles.insert": |
| |
| type RolesInsertCall struct { |
| s *Service |
| customer string |
| role *Role |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Creates a role. |
| func (r *RolesService) Insert(customer string, role *Role) *RolesInsertCall { |
| c := &RolesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.role = role |
| 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 *RolesInsertCall) Fields(s ...googleapi.Field) *RolesInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesInsertCall) Context(ctx context.Context) *RolesInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.role) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.insert" call. |
| // Exactly one of *Role or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Role.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *RolesInsertCall) Do(opts ...googleapi.CallOption) (*Role, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Role{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates a role.", |
| // "httpMethod": "POST", |
| // "id": "directory.roles.insert", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles", |
| // "request": { |
| // "$ref": "Role" |
| // }, |
| // "response": { |
| // "$ref": "Role" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roles.list": |
| |
| type RolesListCall struct { |
| s *Service |
| customer string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieves a paginated list of all the roles in a domain. |
| func (r *RolesService) List(customer string) *RolesListCall { |
| c := &RolesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. |
| func (c *RolesListCall) MaxResults(maxResults int64) *RolesListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // the next page in the list. |
| func (c *RolesListCall) PageToken(pageToken string) *RolesListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| 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 *RolesListCall) Fields(s ...googleapi.Field) *RolesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *RolesListCall) IfNoneMatch(entityTag string) *RolesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesListCall) Context(ctx context.Context) *RolesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.list" call. |
| // Exactly one of *Roles or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Roles.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *RolesListCall) Do(opts ...googleapi.CallOption) (*Roles, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Roles{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a paginated list of all the roles in a domain.", |
| // "httpMethod": "GET", |
| // "id": "directory.roles.list", |
| // "parameterOrder": [ |
| // "customer" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return.", |
| // "format": "int32", |
| // "location": "query", |
| // "maximum": "100", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify the next page in the list.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles", |
| // "response": { |
| // "$ref": "Roles" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement", |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *RolesListCall) Pages(ctx context.Context, f func(*Roles) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.roles.patch": |
| |
| type RolesPatchCall struct { |
| s *Service |
| customer string |
| roleId string |
| role *Role |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Updates a role. This method supports patch semantics. |
| func (r *RolesService) Patch(customer string, roleId string, role *Role) *RolesPatchCall { |
| c := &RolesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleId = roleId |
| c.role = role |
| 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 *RolesPatchCall) Fields(s ...googleapi.Field) *RolesPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesPatchCall) Context(ctx context.Context) *RolesPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.role) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles/{roleId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleId": c.roleId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.patch" call. |
| // Exactly one of *Role or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Role.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *RolesPatchCall) Do(opts ...googleapi.CallOption) (*Role, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Role{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a role. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.roles.patch", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleId": { |
| // "description": "Immutable ID of the role.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles/{roleId}", |
| // "request": { |
| // "$ref": "Role" |
| // }, |
| // "response": { |
| // "$ref": "Role" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.roles.update": |
| |
| type RolesUpdateCall struct { |
| s *Service |
| customer string |
| roleId string |
| role *Role |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates a role. |
| func (r *RolesService) Update(customer string, roleId string, role *Role) *RolesUpdateCall { |
| c := &RolesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customer = customer |
| c.roleId = roleId |
| c.role = role |
| 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 *RolesUpdateCall) Fields(s ...googleapi.Field) *RolesUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *RolesUpdateCall) Context(ctx context.Context) *RolesUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *RolesUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *RolesUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.role) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customer}/roles/{roleId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customer": c.customer, |
| "roleId": c.roleId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.roles.update" call. |
| // Exactly one of *Role or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Role.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *RolesUpdateCall) Do(opts ...googleapi.CallOption) (*Role, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Role{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates a role.", |
| // "httpMethod": "PUT", |
| // "id": "directory.roles.update", |
| // "parameterOrder": [ |
| // "customer", |
| // "roleId" |
| // ], |
| // "parameters": { |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "roleId": { |
| // "description": "Immutable ID of the role.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customer}/roles/{roleId}", |
| // "request": { |
| // "$ref": "Role" |
| // }, |
| // "response": { |
| // "$ref": "Role" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.rolemanagement" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.delete": |
| |
| type SchemasDeleteCall struct { |
| s *Service |
| customerId string |
| schemaKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete schema |
| func (r *SchemasService) Delete(customerId string, schemaKey string) *SchemasDeleteCall { |
| c := &SchemasDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.schemaKey = schemaKey |
| 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 *SchemasDeleteCall) Fields(s ...googleapi.Field) *SchemasDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasDeleteCall) Context(ctx context.Context) *SchemasDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas/{schemaKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "schemaKey": c.schemaKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.delete" call. |
| func (c *SchemasDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete schema", |
| // "httpMethod": "DELETE", |
| // "id": "directory.schemas.delete", |
| // "parameterOrder": [ |
| // "customerId", |
| // "schemaKey" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "schemaKey": { |
| // "description": "Name or immutable Id of the schema", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas/{schemaKey}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.get": |
| |
| type SchemasGetCall struct { |
| s *Service |
| customerId string |
| schemaKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve schema |
| func (r *SchemasService) Get(customerId string, schemaKey string) *SchemasGetCall { |
| c := &SchemasGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.schemaKey = schemaKey |
| 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 *SchemasGetCall) Fields(s ...googleapi.Field) *SchemasGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *SchemasGetCall) IfNoneMatch(entityTag string) *SchemasGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasGetCall) Context(ctx context.Context) *SchemasGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas/{schemaKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "schemaKey": c.schemaKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.get" call. |
| // Exactly one of *Schema or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Schema.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *SchemasGetCall) Do(opts ...googleapi.CallOption) (*Schema, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Schema{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve schema", |
| // "httpMethod": "GET", |
| // "id": "directory.schemas.get", |
| // "parameterOrder": [ |
| // "customerId", |
| // "schemaKey" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "schemaKey": { |
| // "description": "Name or immutable Id of the schema", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas/{schemaKey}", |
| // "response": { |
| // "$ref": "Schema" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema", |
| // "https://www.googleapis.com/auth/admin.directory.userschema.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.insert": |
| |
| type SchemasInsertCall struct { |
| s *Service |
| customerId string |
| schema *Schema |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Create schema. |
| func (r *SchemasService) Insert(customerId string, schema *Schema) *SchemasInsertCall { |
| c := &SchemasInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.schema = schema |
| 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 *SchemasInsertCall) Fields(s ...googleapi.Field) *SchemasInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasInsertCall) Context(ctx context.Context) *SchemasInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.schema) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.insert" call. |
| // Exactly one of *Schema or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Schema.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *SchemasInsertCall) Do(opts ...googleapi.CallOption) (*Schema, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Schema{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Create schema.", |
| // "httpMethod": "POST", |
| // "id": "directory.schemas.insert", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas", |
| // "request": { |
| // "$ref": "Schema" |
| // }, |
| // "response": { |
| // "$ref": "Schema" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.list": |
| |
| type SchemasListCall struct { |
| s *Service |
| customerId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve all schemas for a customer |
| func (r *SchemasService) List(customerId string) *SchemasListCall { |
| c := &SchemasListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| 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 *SchemasListCall) Fields(s ...googleapi.Field) *SchemasListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *SchemasListCall) IfNoneMatch(entityTag string) *SchemasListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasListCall) Context(ctx context.Context) *SchemasListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.list" call. |
| // Exactly one of *Schemas or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Schemas.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *SchemasListCall) Do(opts ...googleapi.CallOption) (*Schemas, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Schemas{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve all schemas for a customer", |
| // "httpMethod": "GET", |
| // "id": "directory.schemas.list", |
| // "parameterOrder": [ |
| // "customerId" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas", |
| // "response": { |
| // "$ref": "Schemas" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema", |
| // "https://www.googleapis.com/auth/admin.directory.userschema.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.patch": |
| |
| type SchemasPatchCall struct { |
| s *Service |
| customerId string |
| schemaKey string |
| schema *Schema |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Update schema. This method supports patch semantics. |
| func (r *SchemasService) Patch(customerId string, schemaKey string, schema *Schema) *SchemasPatchCall { |
| c := &SchemasPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.schemaKey = schemaKey |
| c.schema = schema |
| 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 *SchemasPatchCall) Fields(s ...googleapi.Field) *SchemasPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasPatchCall) Context(ctx context.Context) *SchemasPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.schema) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas/{schemaKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "schemaKey": c.schemaKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.patch" call. |
| // Exactly one of *Schema or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Schema.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *SchemasPatchCall) Do(opts ...googleapi.CallOption) (*Schema, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Schema{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update schema. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.schemas.patch", |
| // "parameterOrder": [ |
| // "customerId", |
| // "schemaKey" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "schemaKey": { |
| // "description": "Name or immutable Id of the schema.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas/{schemaKey}", |
| // "request": { |
| // "$ref": "Schema" |
| // }, |
| // "response": { |
| // "$ref": "Schema" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.schemas.update": |
| |
| type SchemasUpdateCall struct { |
| s *Service |
| customerId string |
| schemaKey string |
| schema *Schema |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Update schema |
| func (r *SchemasService) Update(customerId string, schemaKey string, schema *Schema) *SchemasUpdateCall { |
| c := &SchemasUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.customerId = customerId |
| c.schemaKey = schemaKey |
| c.schema = schema |
| 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 *SchemasUpdateCall) Fields(s ...googleapi.Field) *SchemasUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *SchemasUpdateCall) Context(ctx context.Context) *SchemasUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *SchemasUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *SchemasUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.schema) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "customer/{customerId}/schemas/{schemaKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "customerId": c.customerId, |
| "schemaKey": c.schemaKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.schemas.update" call. |
| // Exactly one of *Schema or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Schema.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *SchemasUpdateCall) Do(opts ...googleapi.CallOption) (*Schema, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Schema{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Update schema", |
| // "httpMethod": "PUT", |
| // "id": "directory.schemas.update", |
| // "parameterOrder": [ |
| // "customerId", |
| // "schemaKey" |
| // ], |
| // "parameters": { |
| // "customerId": { |
| // "description": "Immutable ID of the G Suite account", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "schemaKey": { |
| // "description": "Name or immutable Id of the schema.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "customer/{customerId}/schemas/{schemaKey}", |
| // "request": { |
| // "$ref": "Schema" |
| // }, |
| // "response": { |
| // "$ref": "Schema" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.userschema" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.tokens.delete": |
| |
| type TokensDeleteCall struct { |
| s *Service |
| userKey string |
| clientId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete all access tokens issued by a user for an application. |
| func (r *TokensService) Delete(userKey string, clientId string) *TokensDeleteCall { |
| c := &TokensDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.clientId = clientId |
| 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 *TokensDeleteCall) Fields(s ...googleapi.Field) *TokensDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *TokensDeleteCall) Context(ctx context.Context) *TokensDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *TokensDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *TokensDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/tokens/{clientId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| "clientId": c.clientId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.tokens.delete" call. |
| func (c *TokensDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete all access tokens issued by a user for an application.", |
| // "httpMethod": "DELETE", |
| // "id": "directory.tokens.delete", |
| // "parameterOrder": [ |
| // "userKey", |
| // "clientId" |
| // ], |
| // "parameters": { |
| // "clientId": { |
| // "description": "The Client ID of the application the token is issued to.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/tokens/{clientId}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.tokens.get": |
| |
| type TokensGetCall struct { |
| s *Service |
| userKey string |
| clientId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Get information about an access token issued by a user. |
| func (r *TokensService) Get(userKey string, clientId string) *TokensGetCall { |
| c := &TokensGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.clientId = clientId |
| 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 *TokensGetCall) Fields(s ...googleapi.Field) *TokensGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *TokensGetCall) IfNoneMatch(entityTag string) *TokensGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *TokensGetCall) Context(ctx context.Context) *TokensGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *TokensGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *TokensGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/tokens/{clientId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| "clientId": c.clientId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.tokens.get" call. |
| // Exactly one of *Token or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Token.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *TokensGetCall) Do(opts ...googleapi.CallOption) (*Token, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Token{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get information about an access token issued by a user.", |
| // "httpMethod": "GET", |
| // "id": "directory.tokens.get", |
| // "parameterOrder": [ |
| // "userKey", |
| // "clientId" |
| // ], |
| // "parameters": { |
| // "clientId": { |
| // "description": "The Client ID of the application the token is issued to.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/tokens/{clientId}", |
| // "response": { |
| // "$ref": "Token" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.tokens.list": |
| |
| type TokensListCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Returns the set of tokens specified user has issued to 3rd |
| // party applications. |
| func (r *TokensService) List(userKey string) *TokensListCall { |
| c := &TokensListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *TokensListCall) Fields(s ...googleapi.Field) *TokensListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *TokensListCall) IfNoneMatch(entityTag string) *TokensListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *TokensListCall) Context(ctx context.Context) *TokensListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *TokensListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *TokensListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/tokens") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.tokens.list" call. |
| // Exactly one of *Tokens or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Tokens.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *TokensListCall) Do(opts ...googleapi.CallOption) (*Tokens, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Tokens{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Returns the set of tokens specified user has issued to 3rd party applications.", |
| // "httpMethod": "GET", |
| // "id": "directory.tokens.list", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/tokens", |
| // "response": { |
| // "$ref": "Tokens" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.delete": |
| |
| type UsersDeleteCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Delete user |
| func (r *UsersService) Delete(userKey string) *UsersDeleteCall { |
| c := &UsersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *UsersDeleteCall) Fields(s ...googleapi.Field) *UsersDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersDeleteCall) Context(ctx context.Context) *UsersDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.delete" call. |
| func (c *UsersDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Delete user", |
| // "httpMethod": "DELETE", |
| // "id": "directory.users.delete", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.get": |
| |
| type UsersGetCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: retrieve user |
| func (r *UsersService) Get(userKey string) *UsersGetCall { |
| c := &UsersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| return c |
| } |
| |
| // CustomFieldMask sets the optional parameter "customFieldMask": |
| // Comma-separated list of schema names. All fields from these schemas |
| // are fetched. This should only be set when projection=custom. |
| func (c *UsersGetCall) CustomFieldMask(customFieldMask string) *UsersGetCall { |
| c.urlParams_.Set("customFieldMask", customFieldMask) |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": What subset of |
| // fields to fetch for this user. |
| // |
| // Possible values: |
| // "basic" (default) - Do not include any custom fields for the user. |
| // "custom" - Include custom fields from schemas mentioned in |
| // customFieldMask. |
| // "full" - Include all fields associated with this user. |
| func (c *UsersGetCall) Projection(projection string) *UsersGetCall { |
| c.urlParams_.Set("projection", projection) |
| return c |
| } |
| |
| // ViewType sets the optional parameter "viewType": Whether to fetch the |
| // ADMIN_VIEW or DOMAIN_PUBLIC view of the user. |
| // |
| // Possible values: |
| // "admin_view" (default) - Fetches the ADMIN_VIEW of the user. |
| // "domain_public" - Fetches the DOMAIN_PUBLIC view of the user. |
| func (c *UsersGetCall) ViewType(viewType string) *UsersGetCall { |
| c.urlParams_.Set("viewType", viewType) |
| 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 *UsersGetCall) Fields(s ...googleapi.Field) *UsersGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *UsersGetCall) IfNoneMatch(entityTag string) *UsersGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersGetCall) Context(ctx context.Context) *UsersGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.get" call. |
| // Exactly one of *User or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *User.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersGetCall) Do(opts ...googleapi.CallOption) (*User, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &User{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "retrieve user", |
| // "httpMethod": "GET", |
| // "id": "directory.users.get", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "customFieldMask": { |
| // "description": "Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "default": "basic", |
| // "description": "What subset of fields to fetch for this user.", |
| // "enum": [ |
| // "basic", |
| // "custom", |
| // "full" |
| // ], |
| // "enumDescriptions": [ |
| // "Do not include any custom fields for the user.", |
| // "Include custom fields from schemas mentioned in customFieldMask.", |
| // "Include all fields associated with this user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "viewType": { |
| // "default": "admin_view", |
| // "description": "Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.", |
| // "enum": [ |
| // "admin_view", |
| // "domain_public" |
| // ], |
| // "enumDescriptions": [ |
| // "Fetches the ADMIN_VIEW of the user.", |
| // "Fetches the DOMAIN_PUBLIC view of the user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}", |
| // "response": { |
| // "$ref": "User" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.insert": |
| |
| type UsersInsertCall struct { |
| s *Service |
| user *User |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: create user. |
| func (r *UsersService) Insert(user *User) *UsersInsertCall { |
| c := &UsersInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.user = user |
| 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 *UsersInsertCall) Fields(s ...googleapi.Field) *UsersInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersInsertCall) Context(ctx context.Context) *UsersInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.user) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.insert" call. |
| // Exactly one of *User or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *User.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersInsertCall) Do(opts ...googleapi.CallOption) (*User, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &User{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "create user.", |
| // "httpMethod": "POST", |
| // "id": "directory.users.insert", |
| // "path": "users", |
| // "request": { |
| // "$ref": "User" |
| // }, |
| // "response": { |
| // "$ref": "User" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.list": |
| |
| type UsersListCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Retrieve either deleted users or all users in a domain |
| // (paginated) |
| func (r *UsersService) List() *UsersListCall { |
| c := &UsersListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| return c |
| } |
| |
| // CustomFieldMask sets the optional parameter "customFieldMask": |
| // Comma-separated list of schema names. All fields from these schemas |
| // are fetched. This should only be set when projection=custom. |
| func (c *UsersListCall) CustomFieldMask(customFieldMask string) *UsersListCall { |
| c.urlParams_.Set("customFieldMask", customFieldMask) |
| return c |
| } |
| |
| // Customer sets the optional parameter "customer": Immutable ID of the |
| // G Suite account. In case of multi-domain, to fetch all users for a |
| // customer, fill this field instead of domain. |
| func (c *UsersListCall) Customer(customer string) *UsersListCall { |
| c.urlParams_.Set("customer", customer) |
| return c |
| } |
| |
| // Domain sets the optional parameter "domain": Name of the domain. Fill |
| // this field to get users from only this domain. To return all users in |
| // a multi-domain fill customer field instead. |
| func (c *UsersListCall) Domain(domain string) *UsersListCall { |
| c.urlParams_.Set("domain", domain) |
| return c |
| } |
| |
| // Event sets the optional parameter "event": Event on which |
| // subscription is intended (if subscribing) |
| // |
| // Possible values: |
| // "add" - User Created Event |
| // "delete" - User Deleted Event |
| // "makeAdmin" - User Admin Status Change Event |
| // "undelete" - User Undeleted Event |
| // "update" - User Updated Event |
| func (c *UsersListCall) Event(event string) *UsersListCall { |
| c.urlParams_.Set("event", event) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 100. Max allowed is 500 |
| func (c *UsersListCall) MaxResults(maxResults int64) *UsersListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // OrderBy sets the optional parameter "orderBy": Column to use for |
| // sorting results |
| // |
| // Possible values: |
| // "email" - Primary email of the user. |
| // "familyName" - User's family name. |
| // "givenName" - User's given name. |
| func (c *UsersListCall) OrderBy(orderBy string) *UsersListCall { |
| c.urlParams_.Set("orderBy", orderBy) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *UsersListCall) PageToken(pageToken string) *UsersListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": What subset of |
| // fields to fetch for this user. |
| // |
| // Possible values: |
| // "basic" (default) - Do not include any custom fields for the user. |
| // "custom" - Include custom fields from schemas mentioned in |
| // customFieldMask. |
| // "full" - Include all fields associated with this user. |
| func (c *UsersListCall) Projection(projection string) *UsersListCall { |
| c.urlParams_.Set("projection", projection) |
| return c |
| } |
| |
| // Query sets the optional parameter "query": Query string search. |
| // Should be of the form "". Complete documentation is at |
| // https://developers.google.com/admin-sdk/directory/v1/guides/search-users |
| func (c *UsersListCall) Query(query string) *UsersListCall { |
| c.urlParams_.Set("query", query) |
| return c |
| } |
| |
| // ShowDeleted sets the optional parameter "showDeleted": If set to true |
| // retrieves the list of deleted users. Default is false |
| func (c *UsersListCall) ShowDeleted(showDeleted string) *UsersListCall { |
| c.urlParams_.Set("showDeleted", showDeleted) |
| return c |
| } |
| |
| // SortOrder sets the optional parameter "sortOrder": Whether to return |
| // results in ascending or descending order. |
| // |
| // Possible values: |
| // "ASCENDING" - Ascending order. |
| // "DESCENDING" - Descending order. |
| func (c *UsersListCall) SortOrder(sortOrder string) *UsersListCall { |
| c.urlParams_.Set("sortOrder", sortOrder) |
| return c |
| } |
| |
| // ViewType sets the optional parameter "viewType": Whether to fetch the |
| // ADMIN_VIEW or DOMAIN_PUBLIC view of the user. |
| // |
| // Possible values: |
| // "admin_view" (default) - Fetches the ADMIN_VIEW of the user. |
| // "domain_public" - Fetches the DOMAIN_PUBLIC view of the user. |
| func (c *UsersListCall) ViewType(viewType string) *UsersListCall { |
| c.urlParams_.Set("viewType", viewType) |
| 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 *UsersListCall) Fields(s ...googleapi.Field) *UsersListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *UsersListCall) IfNoneMatch(entityTag string) *UsersListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersListCall) Context(ctx context.Context) *UsersListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.list" call. |
| // Exactly one of *Users or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Users.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *UsersListCall) Do(opts ...googleapi.CallOption) (*Users, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Users{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve either deleted users or all users in a domain (paginated)", |
| // "httpMethod": "GET", |
| // "id": "directory.users.list", |
| // "parameters": { |
| // "customFieldMask": { |
| // "description": "Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "domain": { |
| // "description": "Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "event": { |
| // "description": "Event on which subscription is intended (if subscribing)", |
| // "enum": [ |
| // "add", |
| // "delete", |
| // "makeAdmin", |
| // "undelete", |
| // "update" |
| // ], |
| // "enumDescriptions": [ |
| // "User Created Event", |
| // "User Deleted Event", |
| // "User Admin Status Change Event", |
| // "User Undeleted Event", |
| // "User Updated Event" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 100. Max allowed is 500", |
| // "format": "int32", |
| // "location": "query", |
| // "maximum": "500", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "orderBy": { |
| // "description": "Column to use for sorting results", |
| // "enum": [ |
| // "email", |
| // "familyName", |
| // "givenName" |
| // ], |
| // "enumDescriptions": [ |
| // "Primary email of the user.", |
| // "User's family name.", |
| // "User's given name." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "default": "basic", |
| // "description": "What subset of fields to fetch for this user.", |
| // "enum": [ |
| // "basic", |
| // "custom", |
| // "full" |
| // ], |
| // "enumDescriptions": [ |
| // "Do not include any custom fields for the user.", |
| // "Include custom fields from schemas mentioned in customFieldMask.", |
| // "Include all fields associated with this user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "query": { |
| // "description": "Query string search. Should be of the form \"\". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "showDeleted": { |
| // "description": "If set to true retrieves the list of deleted users. Default is false", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "sortOrder": { |
| // "description": "Whether to return results in ascending or descending order.", |
| // "enum": [ |
| // "ASCENDING", |
| // "DESCENDING" |
| // ], |
| // "enumDescriptions": [ |
| // "Ascending order.", |
| // "Descending order." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "viewType": { |
| // "default": "admin_view", |
| // "description": "Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.", |
| // "enum": [ |
| // "admin_view", |
| // "domain_public" |
| // ], |
| // "enumDescriptions": [ |
| // "Fetches the ADMIN_VIEW of the user.", |
| // "Fetches the DOMAIN_PUBLIC view of the user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users", |
| // "response": { |
| // "$ref": "Users" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ], |
| // "supportsSubscription": true |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersListCall) Pages(ctx context.Context, f func(*Users) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "directory.users.makeAdmin": |
| |
| type UsersMakeAdminCall struct { |
| s *Service |
| userKey string |
| usermakeadmin *UserMakeAdmin |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // MakeAdmin: change admin status of a user |
| func (r *UsersService) MakeAdmin(userKey string, usermakeadmin *UserMakeAdmin) *UsersMakeAdminCall { |
| c := &UsersMakeAdminCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.usermakeadmin = usermakeadmin |
| 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 *UsersMakeAdminCall) Fields(s ...googleapi.Field) *UsersMakeAdminCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersMakeAdminCall) Context(ctx context.Context) *UsersMakeAdminCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersMakeAdminCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMakeAdminCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.usermakeadmin) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/makeAdmin") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.makeAdmin" call. |
| func (c *UsersMakeAdminCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "change admin status of a user", |
| // "httpMethod": "POST", |
| // "id": "directory.users.makeAdmin", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user as admin", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/makeAdmin", |
| // "request": { |
| // "$ref": "UserMakeAdmin" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.patch": |
| |
| type UsersPatchCall struct { |
| s *Service |
| userKey string |
| user *User |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: update user. This method supports patch semantics. |
| func (r *UsersService) Patch(userKey string, user *User) *UsersPatchCall { |
| c := &UsersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.user = user |
| 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 *UsersPatchCall) Fields(s ...googleapi.Field) *UsersPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersPatchCall) Context(ctx context.Context) *UsersPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.user) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.patch" call. |
| // Exactly one of *User or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *User.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersPatchCall) Do(opts ...googleapi.CallOption) (*User, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &User{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "update user. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.users.patch", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user. If Id, it should match with id of user object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}", |
| // "request": { |
| // "$ref": "User" |
| // }, |
| // "response": { |
| // "$ref": "User" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.undelete": |
| |
| type UsersUndeleteCall struct { |
| s *Service |
| userKey string |
| userundelete *UserUndelete |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Undelete: Undelete a deleted user |
| func (r *UsersService) Undelete(userKey string, userundelete *UserUndelete) *UsersUndeleteCall { |
| c := &UsersUndeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.userundelete = userundelete |
| 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 *UsersUndeleteCall) Fields(s ...googleapi.Field) *UsersUndeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersUndeleteCall) Context(ctx context.Context) *UsersUndeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersUndeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersUndeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.userundelete) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/undelete") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.undelete" call. |
| func (c *UsersUndeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Undelete a deleted user", |
| // "httpMethod": "POST", |
| // "id": "directory.users.undelete", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "The immutable id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/undelete", |
| // "request": { |
| // "$ref": "UserUndelete" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.update": |
| |
| type UsersUpdateCall struct { |
| s *Service |
| userKey string |
| user *User |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: update user |
| func (r *UsersService) Update(userKey string, user *User) *UsersUpdateCall { |
| c := &UsersUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.user = user |
| 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 *UsersUpdateCall) Fields(s ...googleapi.Field) *UsersUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersUpdateCall) Context(ctx context.Context) *UsersUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.user) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.update" call. |
| // Exactly one of *User or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *User.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersUpdateCall) Do(opts ...googleapi.CallOption) (*User, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &User{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "update user", |
| // "httpMethod": "PUT", |
| // "id": "directory.users.update", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user. If Id, it should match with id of user object", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}", |
| // "request": { |
| // "$ref": "User" |
| // }, |
| // "response": { |
| // "$ref": "User" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.watch": |
| |
| type UsersWatchCall struct { |
| s *Service |
| channel *Channel |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Watch: Watch for changes in users list |
| func (r *UsersService) Watch(channel *Channel) *UsersWatchCall { |
| c := &UsersWatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.channel = channel |
| return c |
| } |
| |
| // CustomFieldMask sets the optional parameter "customFieldMask": |
| // Comma-separated list of schema names. All fields from these schemas |
| // are fetched. This should only be set when projection=custom. |
| func (c *UsersWatchCall) CustomFieldMask(customFieldMask string) *UsersWatchCall { |
| c.urlParams_.Set("customFieldMask", customFieldMask) |
| return c |
| } |
| |
| // Customer sets the optional parameter "customer": Immutable ID of the |
| // G Suite account. In case of multi-domain, to fetch all users for a |
| // customer, fill this field instead of domain. |
| func (c *UsersWatchCall) Customer(customer string) *UsersWatchCall { |
| c.urlParams_.Set("customer", customer) |
| return c |
| } |
| |
| // Domain sets the optional parameter "domain": Name of the domain. Fill |
| // this field to get users from only this domain. To return all users in |
| // a multi-domain fill customer field instead. |
| func (c *UsersWatchCall) Domain(domain string) *UsersWatchCall { |
| c.urlParams_.Set("domain", domain) |
| return c |
| } |
| |
| // Event sets the optional parameter "event": Event on which |
| // subscription is intended (if subscribing) |
| // |
| // Possible values: |
| // "add" - User Created Event |
| // "delete" - User Deleted Event |
| // "makeAdmin" - User Admin Status Change Event |
| // "undelete" - User Undeleted Event |
| // "update" - User Updated Event |
| func (c *UsersWatchCall) Event(event string) *UsersWatchCall { |
| c.urlParams_.Set("event", event) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of results to return. Default is 100. Max allowed is 500 |
| func (c *UsersWatchCall) MaxResults(maxResults int64) *UsersWatchCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // OrderBy sets the optional parameter "orderBy": Column to use for |
| // sorting results |
| // |
| // Possible values: |
| // "email" - Primary email of the user. |
| // "familyName" - User's family name. |
| // "givenName" - User's given name. |
| func (c *UsersWatchCall) OrderBy(orderBy string) *UsersWatchCall { |
| c.urlParams_.Set("orderBy", orderBy) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to specify |
| // next page in the list |
| func (c *UsersWatchCall) PageToken(pageToken string) *UsersWatchCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Projection sets the optional parameter "projection": What subset of |
| // fields to fetch for this user. |
| // |
| // Possible values: |
| // "basic" (default) - Do not include any custom fields for the user. |
| // "custom" - Include custom fields from schemas mentioned in |
| // customFieldMask. |
| // "full" - Include all fields associated with this user. |
| func (c *UsersWatchCall) Projection(projection string) *UsersWatchCall { |
| c.urlParams_.Set("projection", projection) |
| return c |
| } |
| |
| // Query sets the optional parameter "query": Query string search. |
| // Should be of the form "". Complete documentation is at |
| // https://developers.google.com/admin-sdk/directory/v1/guides/search-users |
| func (c *UsersWatchCall) Query(query string) *UsersWatchCall { |
| c.urlParams_.Set("query", query) |
| return c |
| } |
| |
| // ShowDeleted sets the optional parameter "showDeleted": If set to true |
| // retrieves the list of deleted users. Default is false |
| func (c *UsersWatchCall) ShowDeleted(showDeleted string) *UsersWatchCall { |
| c.urlParams_.Set("showDeleted", showDeleted) |
| return c |
| } |
| |
| // SortOrder sets the optional parameter "sortOrder": Whether to return |
| // results in ascending or descending order. |
| // |
| // Possible values: |
| // "ASCENDING" - Ascending order. |
| // "DESCENDING" - Descending order. |
| func (c *UsersWatchCall) SortOrder(sortOrder string) *UsersWatchCall { |
| c.urlParams_.Set("sortOrder", sortOrder) |
| return c |
| } |
| |
| // ViewType sets the optional parameter "viewType": Whether to fetch the |
| // ADMIN_VIEW or DOMAIN_PUBLIC view of the user. |
| // |
| // Possible values: |
| // "admin_view" (default) - Fetches the ADMIN_VIEW of the user. |
| // "domain_public" - Fetches the DOMAIN_PUBLIC view of the user. |
| func (c *UsersWatchCall) ViewType(viewType string) *UsersWatchCall { |
| c.urlParams_.Set("viewType", viewType) |
| 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 *UsersWatchCall) Fields(s ...googleapi.Field) *UsersWatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersWatchCall) Context(ctx context.Context) *UsersWatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersWatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersWatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/watch") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.watch" call. |
| // Exactly one of *Channel or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Channel.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *UsersWatchCall) Do(opts ...googleapi.CallOption) (*Channel, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Channel{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Watch for changes in users list", |
| // "httpMethod": "POST", |
| // "id": "directory.users.watch", |
| // "parameters": { |
| // "customFieldMask": { |
| // "description": "Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "customer": { |
| // "description": "Immutable ID of the G Suite account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "domain": { |
| // "description": "Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "event": { |
| // "description": "Event on which subscription is intended (if subscribing)", |
| // "enum": [ |
| // "add", |
| // "delete", |
| // "makeAdmin", |
| // "undelete", |
| // "update" |
| // ], |
| // "enumDescriptions": [ |
| // "User Created Event", |
| // "User Deleted Event", |
| // "User Admin Status Change Event", |
| // "User Undeleted Event", |
| // "User Updated Event" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of results to return. Default is 100. Max allowed is 500", |
| // "format": "int32", |
| // "location": "query", |
| // "maximum": "500", |
| // "minimum": "1", |
| // "type": "integer" |
| // }, |
| // "orderBy": { |
| // "description": "Column to use for sorting results", |
| // "enum": [ |
| // "email", |
| // "familyName", |
| // "givenName" |
| // ], |
| // "enumDescriptions": [ |
| // "Primary email of the user.", |
| // "User's family name.", |
| // "User's given name." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "pageToken": { |
| // "description": "Token to specify next page in the list", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projection": { |
| // "default": "basic", |
| // "description": "What subset of fields to fetch for this user.", |
| // "enum": [ |
| // "basic", |
| // "custom", |
| // "full" |
| // ], |
| // "enumDescriptions": [ |
| // "Do not include any custom fields for the user.", |
| // "Include custom fields from schemas mentioned in customFieldMask.", |
| // "Include all fields associated with this user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "query": { |
| // "description": "Query string search. Should be of the form \"\". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "showDeleted": { |
| // "description": "If set to true retrieves the list of deleted users. Default is false", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "sortOrder": { |
| // "description": "Whether to return results in ascending or descending order.", |
| // "enum": [ |
| // "ASCENDING", |
| // "DESCENDING" |
| // ], |
| // "enumDescriptions": [ |
| // "Ascending order.", |
| // "Descending order." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "viewType": { |
| // "default": "admin_view", |
| // "description": "Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.", |
| // "enum": [ |
| // "admin_view", |
| // "domain_public" |
| // ], |
| // "enumDescriptions": [ |
| // "Fetches the ADMIN_VIEW of the user.", |
| // "Fetches the DOMAIN_PUBLIC view of the user." |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/watch", |
| // "request": { |
| // "$ref": "Channel", |
| // "parameterName": "resource" |
| // }, |
| // "response": { |
| // "$ref": "Channel" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ], |
| // "supportsSubscription": true |
| // } |
| |
| } |
| |
| // method id "directory.users.aliases.delete": |
| |
| type UsersAliasesDeleteCall struct { |
| s *Service |
| userKey string |
| alias string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Remove a alias for the user |
| func (r *UsersAliasesService) Delete(userKey string, alias string) *UsersAliasesDeleteCall { |
| c := &UsersAliasesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.alias = alias |
| 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 *UsersAliasesDeleteCall) Fields(s ...googleapi.Field) *UsersAliasesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersAliasesDeleteCall) Context(ctx context.Context) *UsersAliasesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersAliasesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersAliasesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/aliases/{alias}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| "alias": c.alias, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.aliases.delete" call. |
| func (c *UsersAliasesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Remove a alias for the user", |
| // "httpMethod": "DELETE", |
| // "id": "directory.users.aliases.delete", |
| // "parameterOrder": [ |
| // "userKey", |
| // "alias" |
| // ], |
| // "parameters": { |
| // "alias": { |
| // "description": "The alias to be removed", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/aliases/{alias}", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.aliases.insert": |
| |
| type UsersAliasesInsertCall struct { |
| s *Service |
| userKey string |
| alias *Alias |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Add a alias for the user |
| func (r *UsersAliasesService) Insert(userKey string, alias *Alias) *UsersAliasesInsertCall { |
| c := &UsersAliasesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.alias = alias |
| 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 *UsersAliasesInsertCall) Fields(s ...googleapi.Field) *UsersAliasesInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersAliasesInsertCall) Context(ctx context.Context) *UsersAliasesInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersAliasesInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersAliasesInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.alias) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/aliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.aliases.insert" call. |
| // Exactly one of *Alias or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Alias.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *UsersAliasesInsertCall) Do(opts ...googleapi.CallOption) (*Alias, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Alias{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add a alias for the user", |
| // "httpMethod": "POST", |
| // "id": "directory.users.aliases.insert", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/aliases", |
| // "request": { |
| // "$ref": "Alias" |
| // }, |
| // "response": { |
| // "$ref": "Alias" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.aliases.list": |
| |
| type UsersAliasesListCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: List all aliases for a user |
| func (r *UsersAliasesService) List(userKey string) *UsersAliasesListCall { |
| c := &UsersAliasesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| return c |
| } |
| |
| // Event sets the optional parameter "event": Event on which |
| // subscription is intended (if subscribing) |
| // |
| // Possible values: |
| // "add" - Alias Created Event |
| // "delete" - Alias Deleted Event |
| func (c *UsersAliasesListCall) Event(event string) *UsersAliasesListCall { |
| c.urlParams_.Set("event", event) |
| 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 *UsersAliasesListCall) Fields(s ...googleapi.Field) *UsersAliasesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *UsersAliasesListCall) IfNoneMatch(entityTag string) *UsersAliasesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersAliasesListCall) Context(ctx context.Context) *UsersAliasesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersAliasesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersAliasesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/aliases") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.aliases.list" call. |
| // Exactly one of *Aliases or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Aliases.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *UsersAliasesListCall) Do(opts ...googleapi.CallOption) (*Aliases, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Aliases{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "List all aliases for a user", |
| // "httpMethod": "GET", |
| // "id": "directory.users.aliases.list", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "event": { |
| // "description": "Event on which subscription is intended (if subscribing)", |
| // "enum": [ |
| // "add", |
| // "delete" |
| // ], |
| // "enumDescriptions": [ |
| // "Alias Created Event", |
| // "Alias Deleted Event" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/aliases", |
| // "response": { |
| // "$ref": "Aliases" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias.readonly", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ], |
| // "supportsSubscription": true |
| // } |
| |
| } |
| |
| // method id "directory.users.aliases.watch": |
| |
| type UsersAliasesWatchCall struct { |
| s *Service |
| userKey string |
| channel *Channel |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Watch: Watch for changes in user aliases list |
| func (r *UsersAliasesService) Watch(userKey string, channel *Channel) *UsersAliasesWatchCall { |
| c := &UsersAliasesWatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.channel = channel |
| return c |
| } |
| |
| // Event sets the optional parameter "event": Event on which |
| // subscription is intended (if subscribing) |
| // |
| // Possible values: |
| // "add" - Alias Created Event |
| // "delete" - Alias Deleted Event |
| func (c *UsersAliasesWatchCall) Event(event string) *UsersAliasesWatchCall { |
| c.urlParams_.Set("event", event) |
| 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 *UsersAliasesWatchCall) Fields(s ...googleapi.Field) *UsersAliasesWatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersAliasesWatchCall) Context(ctx context.Context) *UsersAliasesWatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersAliasesWatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersAliasesWatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/aliases/watch") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.aliases.watch" call. |
| // Exactly one of *Channel or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Channel.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *UsersAliasesWatchCall) Do(opts ...googleapi.CallOption) (*Channel, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Channel{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Watch for changes in user aliases list", |
| // "httpMethod": "POST", |
| // "id": "directory.users.aliases.watch", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "event": { |
| // "description": "Event on which subscription is intended (if subscribing)", |
| // "enum": [ |
| // "add", |
| // "delete" |
| // ], |
| // "enumDescriptions": [ |
| // "Alias Created Event", |
| // "Alias Deleted Event" |
| // ], |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/aliases/watch", |
| // "request": { |
| // "$ref": "Channel", |
| // "parameterName": "resource" |
| // }, |
| // "response": { |
| // "$ref": "Channel" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias", |
| // "https://www.googleapis.com/auth/admin.directory.user.alias.readonly", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ], |
| // "supportsSubscription": true |
| // } |
| |
| } |
| |
| // method id "directory.users.photos.delete": |
| |
| type UsersPhotosDeleteCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Remove photos for the user |
| func (r *UsersPhotosService) Delete(userKey string) *UsersPhotosDeleteCall { |
| c := &UsersPhotosDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *UsersPhotosDeleteCall) Fields(s ...googleapi.Field) *UsersPhotosDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersPhotosDeleteCall) Context(ctx context.Context) *UsersPhotosDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersPhotosDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersPhotosDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/photos/thumbnail") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.photos.delete" call. |
| func (c *UsersPhotosDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Remove photos for the user", |
| // "httpMethod": "DELETE", |
| // "id": "directory.users.photos.delete", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/photos/thumbnail", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.photos.get": |
| |
| type UsersPhotosGetCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieve photo of a user |
| func (r *UsersPhotosService) Get(userKey string) *UsersPhotosGetCall { |
| c := &UsersPhotosGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *UsersPhotosGetCall) Fields(s ...googleapi.Field) *UsersPhotosGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *UsersPhotosGetCall) IfNoneMatch(entityTag string) *UsersPhotosGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersPhotosGetCall) Context(ctx context.Context) *UsersPhotosGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersPhotosGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersPhotosGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/photos/thumbnail") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.photos.get" call. |
| // Exactly one of *UserPhoto or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *UserPhoto.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersPhotosGetCall) Do(opts ...googleapi.CallOption) (*UserPhoto, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &UserPhoto{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieve photo of a user", |
| // "httpMethod": "GET", |
| // "id": "directory.users.photos.get", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/photos/thumbnail", |
| // "response": { |
| // "$ref": "UserPhoto" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user", |
| // "https://www.googleapis.com/auth/admin.directory.user.readonly" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.photos.patch": |
| |
| type UsersPhotosPatchCall struct { |
| s *Service |
| userKey string |
| userphoto *UserPhoto |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Add a photo for the user. This method supports patch |
| // semantics. |
| func (r *UsersPhotosService) Patch(userKey string, userphoto *UserPhoto) *UsersPhotosPatchCall { |
| c := &UsersPhotosPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.userphoto = userphoto |
| 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 *UsersPhotosPatchCall) Fields(s ...googleapi.Field) *UsersPhotosPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersPhotosPatchCall) Context(ctx context.Context) *UsersPhotosPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersPhotosPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersPhotosPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.userphoto) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/photos/thumbnail") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.photos.patch" call. |
| // Exactly one of *UserPhoto or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *UserPhoto.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersPhotosPatchCall) Do(opts ...googleapi.CallOption) (*UserPhoto, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &UserPhoto{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add a photo for the user. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "directory.users.photos.patch", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/photos/thumbnail", |
| // "request": { |
| // "$ref": "UserPhoto" |
| // }, |
| // "response": { |
| // "$ref": "UserPhoto" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.users.photos.update": |
| |
| type UsersPhotosUpdateCall struct { |
| s *Service |
| userKey string |
| userphoto *UserPhoto |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Add a photo for the user |
| func (r *UsersPhotosService) Update(userKey string, userphoto *UserPhoto) *UsersPhotosUpdateCall { |
| c := &UsersPhotosUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| c.userphoto = userphoto |
| 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 *UsersPhotosUpdateCall) Fields(s ...googleapi.Field) *UsersPhotosUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *UsersPhotosUpdateCall) Context(ctx context.Context) *UsersPhotosUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *UsersPhotosUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersPhotosUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.userphoto) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/photos/thumbnail") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.users.photos.update" call. |
| // Exactly one of *UserPhoto or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *UserPhoto.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersPhotosUpdateCall) Do(opts ...googleapi.CallOption) (*UserPhoto, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &UserPhoto{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Add a photo for the user", |
| // "httpMethod": "PUT", |
| // "id": "directory.users.photos.update", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/photos/thumbnail", |
| // "request": { |
| // "$ref": "UserPhoto" |
| // }, |
| // "response": { |
| // "$ref": "UserPhoto" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.verificationCodes.generate": |
| |
| type VerificationCodesGenerateCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Generate: Generate new backup verification codes for the user. |
| func (r *VerificationCodesService) Generate(userKey string) *VerificationCodesGenerateCall { |
| c := &VerificationCodesGenerateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *VerificationCodesGenerateCall) Fields(s ...googleapi.Field) *VerificationCodesGenerateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *VerificationCodesGenerateCall) Context(ctx context.Context) *VerificationCodesGenerateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *VerificationCodesGenerateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *VerificationCodesGenerateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/verificationCodes/generate") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.verificationCodes.generate" call. |
| func (c *VerificationCodesGenerateCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Generate new backup verification codes for the user.", |
| // "httpMethod": "POST", |
| // "id": "directory.verificationCodes.generate", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/verificationCodes/generate", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.verificationCodes.invalidate": |
| |
| type VerificationCodesInvalidateCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Invalidate: Invalidate the current backup verification codes for the |
| // user. |
| func (r *VerificationCodesService) Invalidate(userKey string) *VerificationCodesInvalidateCall { |
| c := &VerificationCodesInvalidateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *VerificationCodesInvalidateCall) Fields(s ...googleapi.Field) *VerificationCodesInvalidateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *VerificationCodesInvalidateCall) Context(ctx context.Context) *VerificationCodesInvalidateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *VerificationCodesInvalidateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *VerificationCodesInvalidateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/verificationCodes/invalidate") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.verificationCodes.invalidate" call. |
| func (c *VerificationCodesInvalidateCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return err |
| } |
| return nil |
| // { |
| // "description": "Invalidate the current backup verification codes for the user.", |
| // "httpMethod": "POST", |
| // "id": "directory.verificationCodes.invalidate", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Email or immutable Id of the user", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/verificationCodes/invalidate", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |
| |
| // method id "directory.verificationCodes.list": |
| |
| type VerificationCodesListCall struct { |
| s *Service |
| userKey string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Returns the current set of valid backup verification codes for |
| // the specified user. |
| func (r *VerificationCodesService) List(userKey string) *VerificationCodesListCall { |
| c := &VerificationCodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userKey = userKey |
| 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 *VerificationCodesListCall) Fields(s ...googleapi.Field) *VerificationCodesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *VerificationCodesListCall) IfNoneMatch(entityTag string) *VerificationCodesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *VerificationCodesListCall) Context(ctx context.Context) *VerificationCodesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *VerificationCodesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *VerificationCodesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "users/{userKey}/verificationCodes") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userKey": c.userKey, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "directory.verificationCodes.list" call. |
| // Exactly one of *VerificationCodes or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *VerificationCodes.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *VerificationCodesListCall) Do(opts ...googleapi.CallOption) (*VerificationCodes, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &VerificationCodes{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Returns the current set of valid backup verification codes for the specified user.", |
| // "httpMethod": "GET", |
| // "id": "directory.verificationCodes.list", |
| // "parameterOrder": [ |
| // "userKey" |
| // ], |
| // "parameters": { |
| // "userKey": { |
| // "description": "Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "users/{userKey}/verificationCodes", |
| // "response": { |
| // "$ref": "VerificationCodes" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/admin.directory.user.security" |
| // ] |
| // } |
| |
| } |