// Discordgo - Discord bindings for Go // Available at https://github.com/bwmarrin/discordgo // Copyright 2015-2016 Bruce Marriner . All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file contains functions for interacting with the Discord REST/JSON API // at the lowest level. package discordgo import ( "bytes" "encoding/json" "errors" "fmt" "image" _ "image/jpeg" // For JPEG decoding _ "image/png" // For PNG decoding "io" "io/ioutil" "log" "net/http" "net/url" "strconv" "strings" "time" "context" ) // All error constants var ( ErrJSONUnmarshal = errors.New("json unmarshal") ErrStatusOffline = errors.New("You can't set your Status to offline") ErrVerificationLevelBounds = errors.New("VerificationLevel out of bounds, should be between 0 and 3") ErrPruneDaysBounds = errors.New("the number of days should be more than or equal to 1") ErrGuildNoIcon = errors.New("guild does not have an icon set") ErrGuildNoSplash = errors.New("guild does not have a splash set") ErrUnauthorized = errors.New("HTTP request was unauthorized. This could be because the provided token was not a bot token. Please add \"Bot \" to the start of your token. https://discord.com/developers/docs/reference#authentication-example-bot-token-authorization-header") ) var ( // Marshal defines function used to encode JSON payloads Marshal func(v interface{}) ([]byte, error) = json.Marshal // Unmarshal defines function used to decode JSON payloads Unmarshal func(src []byte, v interface{}) error = json.Unmarshal ) // RESTError stores error information about a request with a bad response code. // Message is not always present, there are cases where api calls can fail // without returning a json message. type RESTError struct { Request *http.Request Response *http.Response ResponseBody []byte Message *APIErrorMessage // Message may be nil. } // newRestError returns a new REST API error. func newRestError(req *http.Request, resp *http.Response, body []byte) *RESTError { restErr := &RESTError{ Request: req, Response: resp, ResponseBody: body, } // Attempt to decode the error and assume no message was provided if it fails var msg *APIErrorMessage err := Unmarshal(body, &msg) if err == nil { restErr.Message = msg } return restErr } // Error returns a Rest API Error with its status code and body. func (r RESTError) Error() string { return "HTTP " + r.Response.Status + ", " + string(r.ResponseBody) } // RateLimitError is returned when a request exceeds a rate limit // and ShouldRetryOnRateLimit is false. The request may be manually // retried after waiting the duration specified by RetryAfter. type RateLimitError struct { *RateLimit } // Error returns a rate limit error with rate limited endpoint and retry time. func (e RateLimitError) Error() string { return "Rate limit exceeded on " + e.URL + ", retry after " + e.RetryAfter.String() } // RequestConfig is an HTTP request configuration. type RequestConfig struct { Request *http.Request ShouldRetryOnRateLimit bool MaxRestRetries int Client *http.Client } // newRequestConfig returns a new HTTP request configuration based on parameters in Session. func newRequestConfig(s *Session, req *http.Request) *RequestConfig { return &RequestConfig{ ShouldRetryOnRateLimit: s.ShouldRetryOnRateLimit, MaxRestRetries: s.MaxRestRetries, Client: s.Client, Request: req, } } // RequestOption is a function which mutates request configuration. // It can be supplied as an argument to any REST method. type RequestOption func(cfg *RequestConfig) // WithClient changes the HTTP client used for the request. func WithClient(client *http.Client) RequestOption { return func(cfg *RequestConfig) { if client != nil { cfg.Client = client } } } // WithRetryOnRatelimit controls whether session will retry the request on rate limit. func WithRetryOnRatelimit(retry bool) RequestOption { return func(cfg *RequestConfig) { cfg.ShouldRetryOnRateLimit = retry } } // WithRestRetries changes maximum amount of retries if request fails. func WithRestRetries(max int) RequestOption { return func(cfg *RequestConfig) { cfg.MaxRestRetries = max } } // WithHeader sets a header in the request. func WithHeader(key, value string) RequestOption { return func(cfg *RequestConfig) { cfg.Request.Header.Set(key, value) } } // WithAuditLogReason changes audit log reason associated with the request. func WithAuditLogReason(reason string) RequestOption { return WithHeader("X-Audit-Log-Reason", reason) } // WithLocale changes accepted locale of the request. func WithLocale(locale Locale) RequestOption { return WithHeader("X-Discord-Locale", string(locale)) } // WithContext changes context of the request. func WithContext(ctx context.Context) RequestOption { return func(cfg *RequestConfig) { cfg.Request = cfg.Request.WithContext(ctx) } } // Request is the same as RequestWithBucketID but the bucket id is the same as the urlStr func (s *Session) Request(method, urlStr string, data interface{}, options ...RequestOption) (response []byte, err error) { return s.RequestWithBucketID(method, urlStr, data, strings.SplitN(urlStr, "?", 2)[0], options...) } // RequestWithBucketID makes a (GET/POST/...) Requests to Discord REST API with JSON data. func (s *Session) RequestWithBucketID(method, urlStr string, data interface{}, bucketID string, options ...RequestOption) (response []byte, err error) { var body []byte if data != nil { body, err = Marshal(data) if err != nil { return } } return s.request(method, urlStr, "application/json", body, bucketID, 0, options...) } // request makes a (GET/POST/...) Requests to Discord REST API. // Sequence is the sequence number, if it fails with a 502 it will // retry with sequence+1 until it either succeeds or sequence >= session.MaxRestRetries func (s *Session) request(method, urlStr, contentType string, b []byte, bucketID string, sequence int, options ...RequestOption) (response []byte, err error) { if bucketID == "" { bucketID = strings.SplitN(urlStr, "?", 2)[0] } return s.RequestWithLockedBucket(method, urlStr, contentType, b, s.Ratelimiter.LockBucket(bucketID), sequence, options...) } // RequestWithLockedBucket makes a request using a bucket that's already been locked func (s *Session) RequestWithLockedBucket(method, urlStr, contentType string, b []byte, bucket *Bucket, sequence int, options ...RequestOption) (response []byte, err error) { if s.Debug { log.Printf("API REQUEST %8s :: %s\n", method, urlStr) log.Printf("API REQUEST PAYLOAD :: [%s]\n", string(b)) } req, err := http.NewRequest(method, urlStr, bytes.NewBuffer(b)) if err != nil { bucket.Release(nil) return } // Not used on initial login.. // TODO: Verify if a login, otherwise complain about no-token if s.Token != "" { req.Header.Set("authorization", s.Token) } // Discord's API returns a 400 Bad Request is Content-Type is set, but the // request body is empty. if b != nil { req.Header.Set("Content-Type", contentType) } // TODO: Make a configurable static variable. req.Header.Set("User-Agent", s.UserAgent) cfg := newRequestConfig(s, req) for _, opt := range options { opt(cfg) } req = cfg.Request if s.Debug { for k, v := range req.Header { log.Printf("API REQUEST HEADER :: [%s] = %+v\n", k, v) } } resp, err := cfg.Client.Do(req) if err != nil { bucket.Release(nil) return } defer func() { err2 := resp.Body.Close() if s.Debug && err2 != nil { log.Println("error closing resp body") } }() err = bucket.Release(resp.Header) if err != nil { return } response, err = ioutil.ReadAll(resp.Body) if err != nil { return } if s.Debug { log.Printf("API RESPONSE STATUS :: %s\n", resp.Status) for k, v := range resp.Header { log.Printf("API RESPONSE HEADER :: [%s] = %+v\n", k, v) } log.Printf("API RESPONSE BODY :: [%s]\n\n\n", response) } switch resp.StatusCode { case http.StatusOK: case http.StatusCreated: case http.StatusNoContent: case http.StatusBadGateway: // Retry sending request if possible if sequence < cfg.MaxRestRetries { s.log(LogInformational, "%s Failed (%s), Retrying...", urlStr, resp.Status) response, err = s.RequestWithLockedBucket(method, urlStr, contentType, b, s.Ratelimiter.LockBucketObject(bucket), sequence+1, options...) } else { err = fmt.Errorf("Exceeded Max retries HTTP %s, %s", resp.Status, response) } case 429: // TOO MANY REQUESTS - Rate limiting rl := TooManyRequests{} err = Unmarshal(response, &rl) if err != nil { s.log(LogError, "rate limit unmarshal error, %s", err) return } if cfg.ShouldRetryOnRateLimit { s.log(LogInformational, "Rate Limiting %s, retry in %v", urlStr, rl.RetryAfter) s.handleEvent(rateLimitEventType, &RateLimit{TooManyRequests: &rl, URL: urlStr}) time.Sleep(rl.RetryAfter) // we can make the above smarter // this method can cause longer delays than required response, err = s.RequestWithLockedBucket(method, urlStr, contentType, b, s.Ratelimiter.LockBucketObject(bucket), sequence, options...) } else { err = &RateLimitError{&RateLimit{TooManyRequests: &rl, URL: urlStr}} } case http.StatusUnauthorized: if strings.Index(s.Token, "Bot ") != 0 { s.log(LogInformational, ErrUnauthorized.Error()) err = ErrUnauthorized } fallthrough default: // Error condition err = newRestError(req, resp, response) } return } func unmarshal(data []byte, v interface{}) error { err := Unmarshal(data, v) if err != nil { return fmt.Errorf("%w: %s", ErrJSONUnmarshal, err) } return nil } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Users // ------------------------------------------------------------------------------------------------ // User returns the user details of the given userID // userID : A user ID or "@me" which is a shortcut of current user ID func (s *Session) User(userID string, options ...RequestOption) (st *User, err error) { body, err := s.RequestWithBucketID("GET", EndpointUser(userID), nil, EndpointUsers, options...) if err != nil { return } err = unmarshal(body, &st) return } // UserAvatar is deprecated. Please use UserAvatarDecode // userID : A user ID or "@me" which is a shortcut of current user ID func (s *Session) UserAvatar(userID string, options ...RequestOption) (img image.Image, err error) { u, err := s.User(userID, options...) if err != nil { return } img, err = s.UserAvatarDecode(u, options...) return } // UserAvatarDecode returns an image.Image of a user's Avatar // user : The user which avatar should be retrieved func (s *Session) UserAvatarDecode(u *User, options ...RequestOption) (img image.Image, err error) { body, err := s.RequestWithBucketID("GET", EndpointUserAvatar(u.ID, u.Avatar), nil, EndpointUserAvatar("", ""), options...) if err != nil { return } img, _, err = image.Decode(bytes.NewReader(body)) return } // UserUpdate updates current user settings. func (s *Session) UserUpdate(username, avatar string, options ...RequestOption) (st *User, err error) { // NOTE: Avatar must be either the hash/id of existing Avatar or // data:image/png;base64,BASE64_STRING_OF_NEW_AVATAR_PNG // to set a new avatar. // If left blank, avatar will be set to null/blank data := struct { Username string `json:"username,omitempty"` Avatar string `json:"avatar,omitempty"` }{username, avatar} body, err := s.RequestWithBucketID("PATCH", EndpointUser("@me"), data, EndpointUsers, options...) if err != nil { return } err = unmarshal(body, &st) return } // UserConnections returns the user's connections func (s *Session) UserConnections(options ...RequestOption) (conn []*UserConnection, err error) { response, err := s.RequestWithBucketID("GET", EndpointUserConnections("@me"), nil, EndpointUserConnections("@me"), options...) if err != nil { return nil, err } err = unmarshal(response, &conn) if err != nil { return } return } // UserChannelCreate creates a new User (Private) Channel with another User // recipientID : A user ID for the user to which this channel is opened with. func (s *Session) UserChannelCreate(recipientID string, options ...RequestOption) (st *Channel, err error) { data := struct { RecipientID string `json:"recipient_id"` }{recipientID} body, err := s.RequestWithBucketID("POST", EndpointUserChannels("@me"), data, EndpointUserChannels(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // UserGuildMember returns a guild member object for the current user in the given Guild. // guildID : ID of the guild func (s *Session) UserGuildMember(guildID string, options ...RequestOption) (st *Member, err error) { body, err := s.RequestWithBucketID("GET", EndpointUserGuildMember("@me", guildID), nil, EndpointUserGuildMember("@me", guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // UserGuilds returns an array of UserGuild structures for all guilds. // limit : The number guilds that can be returned. (max 100) // beforeID : If provided all guilds returned will be before given ID. // afterID : If provided all guilds returned will be after given ID. func (s *Session) UserGuilds(limit int, beforeID, afterID string, options ...RequestOption) (st []*UserGuild, err error) { v := url.Values{} if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if afterID != "" { v.Set("after", afterID) } if beforeID != "" { v.Set("before", beforeID) } uri := EndpointUserGuilds("@me") if len(v) > 0 { uri += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointUserGuilds(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // UserChannelPermissions returns the permission of a user in a channel. // userID : The ID of the user to calculate permissions for. // channelID : The ID of the channel to calculate permission for. // fetchOptions : Options used to fetch guild, member or channel if they are not present in state. // // NOTE: This function is now deprecated and will be removed in the future. // Please see the same function inside state.go func (s *Session) UserChannelPermissions(userID, channelID string, fetchOptions ...RequestOption) (apermissions int64, err error) { // Try to just get permissions from state. apermissions, err = s.State.UserChannelPermissions(userID, channelID) if err == nil { return } // Otherwise try get as much data from state as possible, falling back to the network. channel, err := s.State.Channel(channelID) if err != nil || channel == nil { channel, err = s.Channel(channelID, fetchOptions...) if err != nil { return } } guild, err := s.State.Guild(channel.GuildID) if err != nil || guild == nil { guild, err = s.Guild(channel.GuildID, fetchOptions...) if err != nil { return } } if userID == guild.OwnerID { apermissions = PermissionAll return } member, err := s.State.Member(guild.ID, userID) if err != nil || member == nil { member, err = s.GuildMember(guild.ID, userID, fetchOptions...) if err != nil { return } } return memberPermissions(guild, channel, userID, member.Roles), nil } // Calculates the permissions for a member. // https://support.discord.com/hc/en-us/articles/206141927-How-is-the-permission-hierarchy-structured- func memberPermissions(guild *Guild, channel *Channel, userID string, roles []string) (apermissions int64) { if userID == guild.OwnerID { apermissions = PermissionAll return } for _, role := range guild.Roles { if role.ID == guild.ID { apermissions |= role.Permissions break } } for _, role := range guild.Roles { for _, roleID := range roles { if role.ID == roleID { apermissions |= role.Permissions break } } } if apermissions&PermissionAdministrator == PermissionAdministrator { apermissions |= PermissionAll } // Apply @everyone overrides from the channel. for _, overwrite := range channel.PermissionOverwrites { if guild.ID == overwrite.ID { apermissions &= ^overwrite.Deny apermissions |= overwrite.Allow break } } var denies, allows int64 // Member overwrites can override role overrides, so do two passes for _, overwrite := range channel.PermissionOverwrites { for _, roleID := range roles { if overwrite.Type == PermissionOverwriteTypeRole && roleID == overwrite.ID { denies |= overwrite.Deny allows |= overwrite.Allow break } } } apermissions &= ^denies apermissions |= allows for _, overwrite := range channel.PermissionOverwrites { if overwrite.Type == PermissionOverwriteTypeMember && overwrite.ID == userID { apermissions &= ^overwrite.Deny apermissions |= overwrite.Allow break } } if apermissions&PermissionAdministrator == PermissionAdministrator { apermissions |= PermissionAllChannel } return apermissions } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Guilds // ------------------------------------------------------------------------------------------------ // Guild returns a Guild structure of a specific Guild. // guildID : The ID of a Guild func (s *Session) Guild(guildID string, options ...RequestOption) (st *Guild, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuild(guildID), nil, EndpointGuild(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildWithCounts returns a Guild structure of a specific Guild with approximate member and presence counts. // guildID : The ID of a Guild func (s *Session) GuildWithCounts(guildID string, options ...RequestOption) (st *Guild, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuild(guildID)+"?with_counts=true", nil, EndpointGuild(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildPreview returns a GuildPreview structure of a specific public Guild. // guildID : The ID of a Guild func (s *Session) GuildPreview(guildID string, options ...RequestOption) (st *GuildPreview, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildPreview(guildID), nil, EndpointGuildPreview(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildCreate creates a new Guild // name : A name for the Guild (2-100 characters) func (s *Session) GuildCreate(name string, options ...RequestOption) (st *Guild, err error) { data := struct { Name string `json:"name"` }{name} body, err := s.RequestWithBucketID("POST", EndpointGuildCreate, data, EndpointGuildCreate, options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildEdit edits a new Guild // guildID : The ID of a Guild // g : A GuildParams struct with the values Name, Region and VerificationLevel defined. func (s *Session) GuildEdit(guildID string, g *GuildParams, options ...RequestOption) (st *Guild, err error) { // Bounds checking for VerificationLevel, interval: [0, 4] if g.VerificationLevel != nil { val := *g.VerificationLevel if val < 0 || val > 4 { err = ErrVerificationLevelBounds return } } // Bounds checking for regions if g.Region != "" { isValid := false regions, _ := s.VoiceRegions(options...) for _, r := range regions { if g.Region == r.ID { isValid = true } } if !isValid { var valid []string for _, r := range regions { valid = append(valid, r.ID) } err = fmt.Errorf("Region not a valid region (%q)", valid) return } } body, err := s.RequestWithBucketID("PATCH", EndpointGuild(guildID), g, EndpointGuild(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildDelete deletes a Guild. // guildID : The ID of a Guild func (s *Session) GuildDelete(guildID string, options ...RequestOption) (st *Guild, err error) { body, err := s.RequestWithBucketID("DELETE", EndpointGuild(guildID), nil, EndpointGuild(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildLeave leaves a Guild. // guildID : The ID of a Guild func (s *Session) GuildLeave(guildID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointUserGuild("@me", guildID), nil, EndpointUserGuild("", guildID), options...) return } // GuildBans returns an array of GuildBan structures for bans in the given guild. // guildID : The ID of a Guild // limit : Max number of bans to return (max 1000) // beforeID : If not empty all returned users will be after the given id // afterID : If not empty all returned users will be before the given id func (s *Session) GuildBans(guildID string, limit int, beforeID, afterID string, options ...RequestOption) (st []*GuildBan, err error) { uri := EndpointGuildBans(guildID) v := url.Values{} if limit != 0 { v.Set("limit", strconv.Itoa(limit)) } if beforeID != "" { v.Set("before", beforeID) } if afterID != "" { v.Set("after", afterID) } if len(v) > 0 { uri += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildBans(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildBanCreate bans the given user from the given guild. // guildID : The ID of a Guild. // userID : The ID of a User // days : The number of days of previous comments to delete. func (s *Session) GuildBanCreate(guildID, userID string, days int, options ...RequestOption) (err error) { return s.GuildBanCreateWithReason(guildID, userID, "", days, options...) } // GuildBan finds ban by given guild and user id and returns GuildBan structure func (s *Session) GuildBan(guildID, userID string, options ...RequestOption) (st *GuildBan, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildBan(guildID, userID), nil, EndpointGuildBan(guildID, userID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildBanCreateWithReason bans the given user from the given guild also providing a reaso. // guildID : The ID of a Guild. // userID : The ID of a User // reason : The reason for this ban // days : The number of days of previous comments to delete. func (s *Session) GuildBanCreateWithReason(guildID, userID, reason string, days int, options ...RequestOption) (err error) { uri := EndpointGuildBan(guildID, userID) queryParams := url.Values{} if days > 0 { queryParams.Set("delete_message_days", strconv.Itoa(days)) } if reason != "" { queryParams.Set("reason", reason) } if len(queryParams) > 0 { uri += "?" + queryParams.Encode() } _, err = s.RequestWithBucketID("PUT", uri, nil, EndpointGuildBan(guildID, ""), options...) return } // GuildBanDelete removes the given user from the guild bans // guildID : The ID of a Guild. // userID : The ID of a User func (s *Session) GuildBanDelete(guildID, userID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildBan(guildID, userID), nil, EndpointGuildBan(guildID, ""), options...) return } // GuildMembers returns a list of members for a guild. // guildID : The ID of a Guild. // after : The id of the member to return members after // limit : max number of members to return (max 1000) func (s *Session) GuildMembers(guildID string, after string, limit int, options ...RequestOption) (st []*Member, err error) { uri := EndpointGuildMembers(guildID) v := url.Values{} if after != "" { v.Set("after", after) } if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if len(v) > 0 { uri += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildMembers(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildMembersSearch returns a list of guild member objects whose username or nickname starts with a provided string // guildID : The ID of a Guild // query : Query string to match username(s) and nickname(s) against // limit : Max number of members to return (default 1, min 1, max 1000) func (s *Session) GuildMembersSearch(guildID, query string, limit int, options ...RequestOption) (st []*Member, err error) { uri := EndpointGuildMembersSearch(guildID) queryParams := url.Values{} queryParams.Set("query", query) if limit > 1 { queryParams.Set("limit", strconv.Itoa(limit)) } body, err := s.RequestWithBucketID("GET", uri+"?"+queryParams.Encode(), nil, uri, options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildMember returns a member of a guild. // guildID : The ID of a Guild. // userID : The ID of a User func (s *Session) GuildMember(guildID, userID string, options ...RequestOption) (st *Member, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildMember(guildID, userID), nil, EndpointGuildMember(guildID, ""), options...) if err != nil { return } err = unmarshal(body, &st) // The returned object doesn't have the GuildID attribute so we will set it here. st.GuildID = guildID return } // GuildMemberAdd force joins a user to the guild. // guildID : The ID of a Guild. // userID : The ID of a User. // data : Parameters of the user to add. func (s *Session) GuildMemberAdd(guildID, userID string, data *GuildMemberAddParams, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("PUT", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) if err != nil { return err } return err } // GuildMemberDelete removes the given user from the given guild. // guildID : The ID of a Guild. // userID : The ID of a User func (s *Session) GuildMemberDelete(guildID, userID string, options ...RequestOption) (err error) { return s.GuildMemberDeleteWithReason(guildID, userID, "", options...) } // GuildMemberDeleteWithReason removes the given user from the given guild. // guildID : The ID of a Guild. // userID : The ID of a User // reason : The reason for the kick func (s *Session) GuildMemberDeleteWithReason(guildID, userID, reason string, options ...RequestOption) (err error) { uri := EndpointGuildMember(guildID, userID) if reason != "" { uri += "?reason=" + url.QueryEscape(reason) } _, err = s.RequestWithBucketID("DELETE", uri, nil, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberEdit edits and returns updated member. // guildID : The ID of a Guild. // userID : The ID of a User. // data : Updated GuildMember data. func (s *Session) GuildMemberEdit(guildID, userID string, data *GuildMemberParams, options ...RequestOption) (st *Member, err error) { var body []byte body, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) if err != nil { return nil, err } err = unmarshal(body, &st) return } // GuildMemberEditComplex edits the nickname and roles of a member. // NOTE: deprecated, use GuildMemberEdit instead. // // guildID : The ID of a Guild. // userID : The ID of a User. // data : A GuildMemberEditData struct with the new nickname and roles func (s *Session) GuildMemberEditComplex(guildID, userID string, data *GuildMemberParams, options ...RequestOption) (st *Member, err error) { return s.GuildMemberEdit(guildID, userID, data, options...) } // GuildMemberMove moves a guild member from one voice channel to another/none // guildID : The ID of a Guild. // userID : The ID of a User. // channelID : The ID of a channel to move user to or nil to remove from voice channel // // NOTE : I am not entirely set on the name of this function and it may change // prior to the final 1.0.0 release of Discordgo func (s *Session) GuildMemberMove(guildID string, userID string, channelID *string, options ...RequestOption) (err error) { data := struct { ChannelID *string `json:"channel_id"` }{channelID} _, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberNickname updates the nickname of a guild member // guildID : The ID of a guild // userID : The ID of a user // userID : The ID of a user or "@me" which is a shortcut of the current user ID // nickname : The nickname of the member, "" will reset their nickname func (s *Session) GuildMemberNickname(guildID, userID, nickname string, options ...RequestOption) (err error) { data := struct { Nick string `json:"nick"` }{nickname} if userID == "@me" { userID += "/nick" } _, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberMute server mutes a guild member // guildID : The ID of a Guild. // userID : The ID of a User. // mute : boolean value for if the user should be muted func (s *Session) GuildMemberMute(guildID string, userID string, mute bool, options ...RequestOption) (err error) { data := struct { Mute bool `json:"mute"` }{mute} _, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberTimeout times out a guild member // guildID : The ID of a Guild. // userID : The ID of a User. // until : The timestamp for how long a member should be timed out. Set to nil to remove timeout. func (s *Session) GuildMemberTimeout(guildID string, userID string, until *time.Time, options ...RequestOption) (err error) { data := struct { CommunicationDisabledUntil *time.Time `json:"communication_disabled_until"` }{until} _, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberDeafen server deafens a guild member // guildID : The ID of a Guild. // userID : The ID of a User. // deaf : boolean value for if the user should be deafened func (s *Session) GuildMemberDeafen(guildID string, userID string, deaf bool, options ...RequestOption) (err error) { data := struct { Deaf bool `json:"deaf"` }{deaf} _, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""), options...) return } // GuildMemberRoleAdd adds the specified role to a given member // guildID : The ID of a Guild. // userID : The ID of a User. // roleID : The ID of a Role to be assigned to the user. func (s *Session) GuildMemberRoleAdd(guildID, userID, roleID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("PUT", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, "", ""), options...) return } // GuildMemberRoleRemove removes the specified role to a given member // guildID : The ID of a Guild. // userID : The ID of a User. // roleID : The ID of a Role to be removed from the user. func (s *Session) GuildMemberRoleRemove(guildID, userID, roleID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, "", ""), options...) return } // GuildChannels returns an array of Channel structures for all channels of a // given guild. // guildID : The ID of a Guild. func (s *Session) GuildChannels(guildID string, options ...RequestOption) (st []*Channel, err error) { body, err := s.request("GET", EndpointGuildChannels(guildID), "", nil, EndpointGuildChannels(guildID), 0, options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildChannelCreateData is provided to GuildChannelCreateComplex type GuildChannelCreateData struct { Name string `json:"name"` Type ChannelType `json:"type"` Topic string `json:"topic,omitempty"` Bitrate int `json:"bitrate,omitempty"` UserLimit int `json:"user_limit,omitempty"` RateLimitPerUser int `json:"rate_limit_per_user,omitempty"` Position int `json:"position,omitempty"` PermissionOverwrites []*PermissionOverwrite `json:"permission_overwrites,omitempty"` ParentID string `json:"parent_id,omitempty"` NSFW bool `json:"nsfw,omitempty"` } // GuildChannelCreateComplex creates a new channel in the given guild // guildID : The ID of a Guild // data : A data struct describing the new Channel, Name and Type are mandatory, other fields depending on the type func (s *Session) GuildChannelCreateComplex(guildID string, data GuildChannelCreateData, options ...RequestOption) (st *Channel, err error) { body, err := s.RequestWithBucketID("POST", EndpointGuildChannels(guildID), data, EndpointGuildChannels(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildChannelCreate creates a new channel in the given guild // guildID : The ID of a Guild. // name : Name of the channel (2-100 chars length) // ctype : Type of the channel func (s *Session) GuildChannelCreate(guildID, name string, ctype ChannelType, options ...RequestOption) (st *Channel, err error) { return s.GuildChannelCreateComplex(guildID, GuildChannelCreateData{ Name: name, Type: ctype, }, options...) } // GuildChannelsReorder updates the order of channels in a guild // guildID : The ID of a Guild. // channels : Updated channels. func (s *Session) GuildChannelsReorder(guildID string, channels []*Channel, options ...RequestOption) (err error) { data := make([]struct { ID string `json:"id"` Position int `json:"position"` }, len(channels)) for i, c := range channels { data[i].ID = c.ID data[i].Position = c.Position } _, err = s.RequestWithBucketID("PATCH", EndpointGuildChannels(guildID), data, EndpointGuildChannels(guildID), options...) return } // GuildInvites returns an array of Invite structures for the given guild // guildID : The ID of a Guild. func (s *Session) GuildInvites(guildID string, options ...RequestOption) (st []*Invite, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildInvites(guildID), nil, EndpointGuildInvites(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildRoles returns all roles for a given guild. // guildID : The ID of a Guild. func (s *Session) GuildRoles(guildID string, options ...RequestOption) (st []*Role, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildRoles(guildID), nil, EndpointGuildRoles(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return // TODO return pointer } // GuildRoleCreate creates a new Guild Role and returns it. // guildID : The ID of a Guild. // data : New Role parameters. func (s *Session) GuildRoleCreate(guildID string, data *RoleParams, options ...RequestOption) (st *Role, err error) { body, err := s.RequestWithBucketID("POST", EndpointGuildRoles(guildID), data, EndpointGuildRoles(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildRoleEdit updates an existing Guild Role and returns updated Role data. // guildID : The ID of a Guild. // roleID : The ID of a Role. // data : Updated Role data. func (s *Session) GuildRoleEdit(guildID, roleID string, data *RoleParams, options ...RequestOption) (st *Role, err error) { // Prevent sending a color int that is too big. if data.Color != nil && *data.Color > 0xFFFFFF { return nil, fmt.Errorf("color value cannot be larger than 0xFFFFFF") } body, err := s.RequestWithBucketID("PATCH", EndpointGuildRole(guildID, roleID), data, EndpointGuildRole(guildID, ""), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildRoleReorder reoders guild roles // guildID : The ID of a Guild. // roles : A list of ordered roles. func (s *Session) GuildRoleReorder(guildID string, roles []*Role, options ...RequestOption) (st []*Role, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointGuildRoles(guildID), roles, EndpointGuildRoles(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildRoleDelete deletes an existing role. // guildID : The ID of a Guild. // roleID : The ID of a Role. func (s *Session) GuildRoleDelete(guildID, roleID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildRole(guildID, roleID), nil, EndpointGuildRole(guildID, ""), options...) return } // GuildPruneCount Returns the number of members that would be removed in a prune operation. // Requires 'KICK_MEMBER' permission. // guildID : The ID of a Guild. // days : The number of days to count prune for (1 or more). func (s *Session) GuildPruneCount(guildID string, days uint32, options ...RequestOption) (count uint32, err error) { count = 0 if days <= 0 { err = ErrPruneDaysBounds return } p := struct { Pruned uint32 `json:"pruned"` }{} uri := EndpointGuildPrune(guildID) + "?days=" + strconv.FormatUint(uint64(days), 10) body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildPrune(guildID), options...) if err != nil { return } err = unmarshal(body, &p) if err != nil { return } count = p.Pruned return } // GuildPrune Begin as prune operation. Requires the 'KICK_MEMBERS' permission. // Returns an object with one 'pruned' key indicating the number of members that were removed in the prune operation. // guildID : The ID of a Guild. // days : The number of days to count prune for (1 or more). func (s *Session) GuildPrune(guildID string, days uint32, options ...RequestOption) (count uint32, err error) { count = 0 if days <= 0 { err = ErrPruneDaysBounds return } data := struct { days uint32 }{days} p := struct { Pruned uint32 `json:"pruned"` }{} body, err := s.RequestWithBucketID("POST", EndpointGuildPrune(guildID), data, EndpointGuildPrune(guildID), options...) if err != nil { return } err = unmarshal(body, &p) if err != nil { return } count = p.Pruned return } // GuildIntegrations returns an array of Integrations for a guild. // guildID : The ID of a Guild. func (s *Session) GuildIntegrations(guildID string, options ...RequestOption) (st []*Integration, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildIntegrations(guildID), nil, EndpointGuildIntegrations(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildIntegrationCreate creates a Guild Integration. // guildID : The ID of a Guild. // integrationType : The Integration type. // integrationID : The ID of an integration. func (s *Session) GuildIntegrationCreate(guildID, integrationType, integrationID string, options ...RequestOption) (err error) { data := struct { Type string `json:"type"` ID string `json:"id"` }{integrationType, integrationID} _, err = s.RequestWithBucketID("POST", EndpointGuildIntegrations(guildID), data, EndpointGuildIntegrations(guildID), options...) return } // GuildIntegrationEdit edits a Guild Integration. // guildID : The ID of a Guild. // integrationType : The Integration type. // integrationID : The ID of an integration. // expireBehavior : The behavior when an integration subscription lapses (see the integration object documentation). // expireGracePeriod : Period (in seconds) where the integration will ignore lapsed subscriptions. // enableEmoticons : Whether emoticons should be synced for this integration (twitch only currently). func (s *Session) GuildIntegrationEdit(guildID, integrationID string, expireBehavior, expireGracePeriod int, enableEmoticons bool, options ...RequestOption) (err error) { data := struct { ExpireBehavior int `json:"expire_behavior"` ExpireGracePeriod int `json:"expire_grace_period"` EnableEmoticons bool `json:"enable_emoticons"` }{expireBehavior, expireGracePeriod, enableEmoticons} _, err = s.RequestWithBucketID("PATCH", EndpointGuildIntegration(guildID, integrationID), data, EndpointGuildIntegration(guildID, ""), options...) return } // GuildIntegrationDelete removes the given integration from the Guild. // guildID : The ID of a Guild. // integrationID : The ID of an integration. func (s *Session) GuildIntegrationDelete(guildID, integrationID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildIntegration(guildID, integrationID), nil, EndpointGuildIntegration(guildID, ""), options...) return } // GuildIcon returns an image.Image of a guild icon. // guildID : The ID of a Guild. func (s *Session) GuildIcon(guildID string, options ...RequestOption) (img image.Image, err error) { g, err := s.Guild(guildID, options...) if err != nil { return } if g.Icon == "" { err = ErrGuildNoIcon return } body, err := s.RequestWithBucketID("GET", EndpointGuildIcon(guildID, g.Icon), nil, EndpointGuildIcon(guildID, ""), options...) if err != nil { return } img, _, err = image.Decode(bytes.NewReader(body)) return } // GuildSplash returns an image.Image of a guild splash image. // guildID : The ID of a Guild. func (s *Session) GuildSplash(guildID string, options ...RequestOption) (img image.Image, err error) { g, err := s.Guild(guildID, options...) if err != nil { return } if g.Splash == "" { err = ErrGuildNoSplash return } body, err := s.RequestWithBucketID("GET", EndpointGuildSplash(guildID, g.Splash), nil, EndpointGuildSplash(guildID, ""), options...) if err != nil { return } img, _, err = image.Decode(bytes.NewReader(body)) return } // GuildEmbed returns the embed for a Guild. // guildID : The ID of a Guild. func (s *Session) GuildEmbed(guildID string, options ...RequestOption) (st *GuildEmbed, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildEmbed(guildID), nil, EndpointGuildEmbed(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildEmbedEdit edits the embed of a Guild. // guildID : The ID of a Guild. // data : New GuildEmbed data. func (s *Session) GuildEmbedEdit(guildID string, data *GuildEmbed, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("PATCH", EndpointGuildEmbed(guildID), data, EndpointGuildEmbed(guildID), options...) return } // GuildAuditLog returns the audit log for a Guild. // guildID : The ID of a Guild. // userID : If provided the log will be filtered for the given ID. // beforeID : If provided all log entries returned will be before the given ID. // actionType : If provided the log will be filtered for the given Action Type. // limit : The number messages that can be returned. (default 50, min 1, max 100) func (s *Session) GuildAuditLog(guildID, userID, beforeID string, actionType, limit int, options ...RequestOption) (st *GuildAuditLog, err error) { uri := EndpointGuildAuditLogs(guildID) v := url.Values{} if userID != "" { v.Set("user_id", userID) } if beforeID != "" { v.Set("before", beforeID) } if actionType > 0 { v.Set("action_type", strconv.Itoa(actionType)) } if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if len(v) > 0 { uri = fmt.Sprintf("%s?%s", uri, v.Encode()) } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildAuditLogs(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildEmojis returns all emoji // guildID : The ID of a Guild. func (s *Session) GuildEmojis(guildID string, options ...RequestOption) (emoji []*Emoji, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildEmojis(guildID), nil, EndpointGuildEmojis(guildID), options...) if err != nil { return } err = unmarshal(body, &emoji) return } // GuildEmoji returns specified emoji. // guildID : The ID of a Guild // emojiID : The ID of an Emoji to retrieve func (s *Session) GuildEmoji(guildID, emojiID string, options ...RequestOption) (emoji *Emoji, err error) { var body []byte body, err = s.RequestWithBucketID("GET", EndpointGuildEmoji(guildID, emojiID), nil, EndpointGuildEmoji(guildID, emojiID), options...) if err != nil { return } err = unmarshal(body, &emoji) return } // GuildEmojiCreate creates a new Emoji. // guildID : The ID of a Guild. // data : New Emoji data. func (s *Session) GuildEmojiCreate(guildID string, data *EmojiParams, options ...RequestOption) (emoji *Emoji, err error) { body, err := s.RequestWithBucketID("POST", EndpointGuildEmojis(guildID), data, EndpointGuildEmojis(guildID), options...) if err != nil { return } err = unmarshal(body, &emoji) return } // GuildEmojiEdit modifies and returns updated Emoji. // guildID : The ID of a Guild. // emojiID : The ID of an Emoji. // data : Updated Emoji data. func (s *Session) GuildEmojiEdit(guildID, emojiID string, data *EmojiParams, options ...RequestOption) (emoji *Emoji, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointGuildEmoji(guildID, emojiID), data, EndpointGuildEmojis(guildID), options...) if err != nil { return } err = unmarshal(body, &emoji) return } // GuildEmojiDelete deletes an Emoji. // guildID : The ID of a Guild. // emojiID : The ID of an Emoji. func (s *Session) GuildEmojiDelete(guildID, emojiID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildEmoji(guildID, emojiID), nil, EndpointGuildEmojis(guildID), options...) return } // GuildTemplate returns a GuildTemplate for the given code // templateCode: The Code of a GuildTemplate func (s *Session) GuildTemplate(templateCode string, options ...RequestOption) (st *GuildTemplate, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildTemplate(templateCode), nil, EndpointGuildTemplate(templateCode), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildCreateWithTemplate creates a guild based on a GuildTemplate // templateCode: The Code of a GuildTemplate // name: The name of the guild (2-100) characters // icon: base64 encoded 128x128 image for the guild icon func (s *Session) GuildCreateWithTemplate(templateCode, name, icon string, options ...RequestOption) (st *Guild, err error) { data := struct { Name string `json:"name"` Icon string `json:"icon"` }{name, icon} body, err := s.RequestWithBucketID("POST", EndpointGuildTemplate(templateCode), data, EndpointGuildTemplate(templateCode), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildTemplates returns all of GuildTemplates // guildID: The ID of the guild func (s *Session) GuildTemplates(guildID string, options ...RequestOption) (st []*GuildTemplate, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildTemplates(guildID), nil, EndpointGuildTemplates(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildTemplateCreate creates a template for the guild // guildID : The ID of the guild // data : Template metadata func (s *Session) GuildTemplateCreate(guildID string, data *GuildTemplateParams, options ...RequestOption) (st *GuildTemplate) { body, err := s.RequestWithBucketID("POST", EndpointGuildTemplates(guildID), data, EndpointGuildTemplates(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildTemplateSync syncs the template to the guild's current state // guildID: The ID of the guild // templateCode: The code of the template func (s *Session) GuildTemplateSync(guildID, templateCode string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("PUT", EndpointGuildTemplateSync(guildID, templateCode), nil, EndpointGuildTemplateSync(guildID, ""), options...) return } // GuildTemplateEdit modifies the template's metadata // guildID : The ID of the guild // templateCode : The code of the template // data : New template metadata func (s *Session) GuildTemplateEdit(guildID, templateCode string, data *GuildTemplateParams, options ...RequestOption) (st *GuildTemplate, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointGuildTemplateSync(guildID, templateCode), data, EndpointGuildTemplateSync(guildID, ""), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildTemplateDelete deletes the template // guildID: The ID of the guild // templateCode: The code of the template func (s *Session) GuildTemplateDelete(guildID, templateCode string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildTemplateSync(guildID, templateCode), nil, EndpointGuildTemplateSync(guildID, ""), options...) return } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Channels // ------------------------------------------------------------------------------------------------ // Channel returns a Channel structure of a specific Channel. // channelID : The ID of the Channel you want returned. func (s *Session) Channel(channelID string, options ...RequestOption) (st *Channel, err error) { body, err := s.RequestWithBucketID("GET", EndpointChannel(channelID), nil, EndpointChannel(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelEdit edits the given channel and returns the updated Channel data. // channelID : The ID of a Channel. // data : New Channel data. func (s *Session) ChannelEdit(channelID string, data *ChannelEdit, options ...RequestOption) (st *Channel, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointChannel(channelID), data, EndpointChannel(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelEditComplex edits an existing channel, replacing the parameters entirely with ChannelEdit struct // NOTE: deprecated, use ChannelEdit instead // channelID : The ID of a Channel // data : The channel struct to send func (s *Session) ChannelEditComplex(channelID string, data *ChannelEdit, options ...RequestOption) (st *Channel, err error) { return s.ChannelEdit(channelID, data, options...) } // ChannelDelete deletes the given channel // channelID : The ID of a Channel func (s *Session) ChannelDelete(channelID string, options ...RequestOption) (st *Channel, err error) { body, err := s.RequestWithBucketID("DELETE", EndpointChannel(channelID), nil, EndpointChannel(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelTyping broadcasts to all members that authenticated user is typing in // the given channel. // channelID : The ID of a Channel func (s *Session) ChannelTyping(channelID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("POST", EndpointChannelTyping(channelID), nil, EndpointChannelTyping(channelID), options...) return } // ChannelMessages returns an array of Message structures for messages within // a given channel. // channelID : The ID of a Channel. // limit : The number messages that can be returned. (max 100) // beforeID : If provided all messages returned will be before given ID. // afterID : If provided all messages returned will be after given ID. // aroundID : If provided all messages returned will be around given ID. func (s *Session) ChannelMessages(channelID string, limit int, beforeID, afterID, aroundID string, options ...RequestOption) (st []*Message, err error) { uri := EndpointChannelMessages(channelID) v := url.Values{} if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if afterID != "" { v.Set("after", afterID) } if beforeID != "" { v.Set("before", beforeID) } if aroundID != "" { v.Set("around", aroundID) } if len(v) > 0 { uri += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointChannelMessages(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelMessage gets a single message by ID from a given channel. // channeld : The ID of a Channel // messageID : the ID of a Message func (s *Session) ChannelMessage(channelID, messageID string, options ...RequestOption) (st *Message, err error) { response, err := s.RequestWithBucketID("GET", EndpointChannelMessage(channelID, messageID), nil, EndpointChannelMessage(channelID, ""), options...) if err != nil { return } err = unmarshal(response, &st) return } // ChannelMessageSend sends a message to the given channel. // channelID : The ID of a Channel. // content : The message to send. func (s *Session) ChannelMessageSend(channelID string, content string, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendComplex(channelID, &MessageSend{ Content: content, }, options...) } var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"") // ChannelMessageSendComplex sends a message to the given channel. // channelID : The ID of a Channel. // data : The message struct to send. func (s *Session) ChannelMessageSendComplex(channelID string, data *MessageSend, options ...RequestOption) (st *Message, err error) { // TODO: Remove this when compatibility is not required. if data.Embed != nil { if data.Embeds == nil { data.Embeds = []*MessageEmbed{data.Embed} } else { err = fmt.Errorf("cannot specify both Embed and Embeds") return } } for _, embed := range data.Embeds { if embed.Type == "" { embed.Type = "rich" } } endpoint := EndpointChannelMessages(channelID) // TODO: Remove this when compatibility is not required. files := data.Files if data.File != nil { if files == nil { files = []*File{data.File} } else { err = fmt.Errorf("cannot specify both File and Files") return } } var response []byte if len(files) > 0 { contentType, body, encodeErr := MultipartBodyWithJSON(data, files) if encodeErr != nil { return st, encodeErr } response, err = s.request("POST", endpoint, contentType, body, endpoint, 0, options...) } else { response, err = s.RequestWithBucketID("POST", endpoint, data, endpoint, options...) } if err != nil { return } err = unmarshal(response, &st) return } // ChannelMessageSendTTS sends a message to the given channel with Text to Speech. // channelID : The ID of a Channel. // content : The message to send. func (s *Session) ChannelMessageSendTTS(channelID string, content string, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendComplex(channelID, &MessageSend{ Content: content, TTS: true, }, options...) } // ChannelMessageSendEmbed sends a message to the given channel with embedded data. // channelID : The ID of a Channel. // embed : The embed data to send. func (s *Session) ChannelMessageSendEmbed(channelID string, embed *MessageEmbed, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendEmbeds(channelID, []*MessageEmbed{embed}, options...) } // ChannelMessageSendEmbeds sends a message to the given channel with multiple embedded data. // channelID : The ID of a Channel. // embeds : The embeds data to send. func (s *Session) ChannelMessageSendEmbeds(channelID string, embeds []*MessageEmbed, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendComplex(channelID, &MessageSend{ Embeds: embeds, }, options...) } // ChannelMessageSendReply sends a message to the given channel with reference data. // channelID : The ID of a Channel. // content : The message to send. // reference : The message reference to send. func (s *Session) ChannelMessageSendReply(channelID string, content string, reference *MessageReference, options ...RequestOption) (*Message, error) { if reference == nil { return nil, fmt.Errorf("reply attempted with nil message reference") } return s.ChannelMessageSendComplex(channelID, &MessageSend{ Content: content, Reference: reference, }, options...) } // ChannelMessageSendEmbedReply sends a message to the given channel with reference data and embedded data. // channelID : The ID of a Channel. // embed : The embed data to send. // reference : The message reference to send. func (s *Session) ChannelMessageSendEmbedReply(channelID string, embed *MessageEmbed, reference *MessageReference, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendEmbedsReply(channelID, []*MessageEmbed{embed}, reference, options...) } // ChannelMessageSendEmbedsReply sends a message to the given channel with reference data and multiple embedded data. // channelID : The ID of a Channel. // embeds : The embeds data to send. // reference : The message reference to send. func (s *Session) ChannelMessageSendEmbedsReply(channelID string, embeds []*MessageEmbed, reference *MessageReference, options ...RequestOption) (*Message, error) { if reference == nil { return nil, fmt.Errorf("reply attempted with nil message reference") } return s.ChannelMessageSendComplex(channelID, &MessageSend{ Embeds: embeds, Reference: reference, }, options...) } // ChannelMessageEdit edits an existing message, replacing it entirely with // the given content. // channelID : The ID of a Channel // messageID : The ID of a Message // content : The contents of the message func (s *Session) ChannelMessageEdit(channelID, messageID, content string, options ...RequestOption) (*Message, error) { return s.ChannelMessageEditComplex(NewMessageEdit(channelID, messageID).SetContent(content), options...) } // ChannelMessageEditComplex edits an existing message, replacing it entirely with // the given MessageEdit struct func (s *Session) ChannelMessageEditComplex(m *MessageEdit, options ...RequestOption) (st *Message, err error) { // TODO: Remove this when compatibility is not required. if m.Embed != nil { if m.Embeds == nil { m.Embeds = []*MessageEmbed{m.Embed} } else { err = fmt.Errorf("cannot specify both Embed and Embeds") return } } for _, embed := range m.Embeds { if embed.Type == "" { embed.Type = "rich" } } endpoint := EndpointChannelMessage(m.Channel, m.ID) var response []byte if len(m.Files) > 0 { contentType, body, encodeErr := MultipartBodyWithJSON(m, m.Files) if encodeErr != nil { return st, encodeErr } response, err = s.request("PATCH", endpoint, contentType, body, EndpointChannelMessage(m.Channel, ""), 0, options...) } else { response, err = s.RequestWithBucketID("PATCH", endpoint, m, EndpointChannelMessage(m.Channel, ""), options...) } if err != nil { return } err = unmarshal(response, &st) return } // ChannelMessageEditEmbed edits an existing message with embedded data. // channelID : The ID of a Channel // messageID : The ID of a Message // embed : The embed data to send func (s *Session) ChannelMessageEditEmbed(channelID, messageID string, embed *MessageEmbed, options ...RequestOption) (*Message, error) { return s.ChannelMessageEditEmbeds(channelID, messageID, []*MessageEmbed{embed}, options...) } // ChannelMessageEditEmbeds edits an existing message with multiple embedded data. // channelID : The ID of a Channel // messageID : The ID of a Message // embeds : The embeds data to send func (s *Session) ChannelMessageEditEmbeds(channelID, messageID string, embeds []*MessageEmbed, options ...RequestOption) (*Message, error) { return s.ChannelMessageEditComplex(NewMessageEdit(channelID, messageID).SetEmbeds(embeds), options...) } // ChannelMessageDelete deletes a message from the Channel. func (s *Session) ChannelMessageDelete(channelID, messageID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointChannelMessage(channelID, messageID), nil, EndpointChannelMessage(channelID, ""), options...) return } // ChannelMessagesBulkDelete bulk deletes the messages from the channel for the provided messageIDs. // If only one messageID is in the slice call channelMessageDelete function. // If the slice is empty do nothing. // channelID : The ID of the channel for the messages to delete. // messages : The IDs of the messages to be deleted. A slice of string IDs. A maximum of 100 messages. func (s *Session) ChannelMessagesBulkDelete(channelID string, messages []string, options ...RequestOption) (err error) { if len(messages) == 0 { return } if len(messages) == 1 { err = s.ChannelMessageDelete(channelID, messages[0], options...) return } if len(messages) > 100 { messages = messages[:100] } data := struct { Messages []string `json:"messages"` }{messages} _, err = s.RequestWithBucketID("POST", EndpointChannelMessagesBulkDelete(channelID), data, EndpointChannelMessagesBulkDelete(channelID), options...) return } // ChannelMessagePin pins a message within a given channel. // channelID: The ID of a channel. // messageID: The ID of a message. func (s *Session) ChannelMessagePin(channelID, messageID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("PUT", EndpointChannelMessagePin(channelID, messageID), nil, EndpointChannelMessagePin(channelID, ""), options...) return } // ChannelMessageUnpin unpins a message within a given channel. // channelID: The ID of a channel. // messageID: The ID of a message. func (s *Session) ChannelMessageUnpin(channelID, messageID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointChannelMessagePin(channelID, messageID), nil, EndpointChannelMessagePin(channelID, ""), options...) return } // ChannelMessagesPinned returns an array of Message structures for pinned messages // within a given channel // channelID : The ID of a Channel. func (s *Session) ChannelMessagesPinned(channelID string, options ...RequestOption) (st []*Message, err error) { body, err := s.RequestWithBucketID("GET", EndpointChannelMessagesPins(channelID), nil, EndpointChannelMessagesPins(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelFileSend sends a file to the given channel. // channelID : The ID of a Channel. // name: The name of the file. // io.Reader : A reader for the file contents. func (s *Session) ChannelFileSend(channelID, name string, r io.Reader, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendComplex(channelID, &MessageSend{File: &File{Name: name, Reader: r}}, options...) } // ChannelFileSendWithMessage sends a file to the given channel with an message. // DEPRECATED. Use ChannelMessageSendComplex instead. // channelID : The ID of a Channel. // content: Optional Message content. // name: The name of the file. // io.Reader : A reader for the file contents. func (s *Session) ChannelFileSendWithMessage(channelID, content string, name string, r io.Reader, options ...RequestOption) (*Message, error) { return s.ChannelMessageSendComplex(channelID, &MessageSend{File: &File{Name: name, Reader: r}, Content: content}, options...) } // ChannelInvites returns an array of Invite structures for the given channel // channelID : The ID of a Channel func (s *Session) ChannelInvites(channelID string, options ...RequestOption) (st []*Invite, err error) { body, err := s.RequestWithBucketID("GET", EndpointChannelInvites(channelID), nil, EndpointChannelInvites(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelInviteCreate creates a new invite for the given channel. // channelID : The ID of a Channel // i : An Invite struct with the values MaxAge, MaxUses and Temporary defined. func (s *Session) ChannelInviteCreate(channelID string, i Invite, options ...RequestOption) (st *Invite, err error) { data := struct { MaxAge int `json:"max_age"` MaxUses int `json:"max_uses"` Temporary bool `json:"temporary"` Unique bool `json:"unique"` }{i.MaxAge, i.MaxUses, i.Temporary, i.Unique} body, err := s.RequestWithBucketID("POST", EndpointChannelInvites(channelID), data, EndpointChannelInvites(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelPermissionSet creates a Permission Override for the given channel. // NOTE: This func name may changed. Using Set instead of Create because // you can both create a new override or update an override with this function. func (s *Session) ChannelPermissionSet(channelID, targetID string, targetType PermissionOverwriteType, allow, deny int64, options ...RequestOption) (err error) { data := struct { ID string `json:"id"` Type PermissionOverwriteType `json:"type"` Allow int64 `json:"allow,string"` Deny int64 `json:"deny,string"` }{targetID, targetType, allow, deny} _, err = s.RequestWithBucketID("PUT", EndpointChannelPermission(channelID, targetID), data, EndpointChannelPermission(channelID, ""), options...) return } // ChannelPermissionDelete deletes a specific permission override for the given channel. // NOTE: Name of this func may change. func (s *Session) ChannelPermissionDelete(channelID, targetID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointChannelPermission(channelID, targetID), nil, EndpointChannelPermission(channelID, ""), options...) return } // ChannelMessageCrosspost cross posts a message in a news channel to followers // of the channel // channelID : The ID of a Channel // messageID : The ID of a Message func (s *Session) ChannelMessageCrosspost(channelID, messageID string, options ...RequestOption) (st *Message, err error) { endpoint := EndpointChannelMessageCrosspost(channelID, messageID) body, err := s.RequestWithBucketID("POST", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelNewsFollow follows a news channel in the targetID // channelID : The ID of a News Channel // targetID : The ID of a Channel where the News Channel should post to func (s *Session) ChannelNewsFollow(channelID, targetID string, options ...RequestOption) (st *ChannelFollow, err error) { endpoint := EndpointChannelFollow(channelID) data := struct { WebhookChannelID string `json:"webhook_channel_id"` }{targetID} body, err := s.RequestWithBucketID("POST", endpoint, data, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Invites // ------------------------------------------------------------------------------------------------ // Invite returns an Invite structure of the given invite // inviteID : The invite code func (s *Session) Invite(inviteID string, options ...RequestOption) (st *Invite, err error) { body, err := s.RequestWithBucketID("GET", EndpointInvite(inviteID), nil, EndpointInvite(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // InviteWithCounts returns an Invite structure of the given invite including approximate member counts // inviteID : The invite code func (s *Session) InviteWithCounts(inviteID string, options ...RequestOption) (st *Invite, err error) { body, err := s.RequestWithBucketID("GET", EndpointInvite(inviteID)+"?with_counts=true", nil, EndpointInvite(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // InviteComplex returns an Invite structure of the given invite including specified fields. // inviteID : The invite code // guildScheduledEventID : If specified, includes specified guild scheduled event. // withCounts : Whether to include approximate member counts or not // withExpiration : Whether to include expiration time or not func (s *Session) InviteComplex(inviteID, guildScheduledEventID string, withCounts, withExpiration bool, options ...RequestOption) (st *Invite, err error) { endpoint := EndpointInvite(inviteID) v := url.Values{} if guildScheduledEventID != "" { v.Set("guild_scheduled_event_id", guildScheduledEventID) } if withCounts { v.Set("with_counts", "true") } if withExpiration { v.Set("with_expiration", "true") } if len(v) != 0 { endpoint += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", endpoint, nil, EndpointInvite(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // InviteDelete deletes an existing invite // inviteID : the code of an invite func (s *Session) InviteDelete(inviteID string, options ...RequestOption) (st *Invite, err error) { body, err := s.RequestWithBucketID("DELETE", EndpointInvite(inviteID), nil, EndpointInvite(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // InviteAccept accepts an Invite to a Guild or Channel // inviteID : The invite code func (s *Session) InviteAccept(inviteID string, options ...RequestOption) (st *Invite, err error) { body, err := s.RequestWithBucketID("POST", EndpointInvite(inviteID), nil, EndpointInvite(""), options...) if err != nil { return } err = unmarshal(body, &st) return } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Voice // ------------------------------------------------------------------------------------------------ // VoiceRegions returns the voice server regions func (s *Session) VoiceRegions(options ...RequestOption) (st []*VoiceRegion, err error) { body, err := s.RequestWithBucketID("GET", EndpointVoiceRegions, nil, EndpointVoiceRegions, options...) if err != nil { return } err = unmarshal(body, &st) return } // ------------------------------------------------------------------------------------------------ // Functions specific to Discord Websockets // ------------------------------------------------------------------------------------------------ // Gateway returns the websocket Gateway address func (s *Session) Gateway(options ...RequestOption) (gateway string, err error) { response, err := s.RequestWithBucketID("GET", EndpointGateway, nil, EndpointGateway, options...) if err != nil { return } temp := struct { URL string `json:"url"` }{} err = unmarshal(response, &temp) if err != nil { return } gateway = temp.URL // Ensure the gateway always has a trailing slash. // MacOS will fail to connect if we add query params without a trailing slash on the base domain. if !strings.HasSuffix(gateway, "/") { gateway += "/" } return } // GatewayBot returns the websocket Gateway address and the recommended number of shards func (s *Session) GatewayBot(options ...RequestOption) (st *GatewayBotResponse, err error) { response, err := s.RequestWithBucketID("GET", EndpointGatewayBot, nil, EndpointGatewayBot, options...) if err != nil { return } err = unmarshal(response, &st) if err != nil { return } // Ensure the gateway always has a trailing slash. // MacOS will fail to connect if we add query params without a trailing slash on the base domain. if !strings.HasSuffix(st.URL, "/") { st.URL += "/" } return } // Functions specific to Webhooks // WebhookCreate returns a new Webhook. // channelID: The ID of a Channel. // name : The name of the webhook. // avatar : The avatar of the webhook. func (s *Session) WebhookCreate(channelID, name, avatar string, options ...RequestOption) (st *Webhook, err error) { data := struct { Name string `json:"name"` Avatar string `json:"avatar,omitempty"` }{name, avatar} body, err := s.RequestWithBucketID("POST", EndpointChannelWebhooks(channelID), data, EndpointChannelWebhooks(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ChannelWebhooks returns all webhooks for a given channel. // channelID: The ID of a channel. func (s *Session) ChannelWebhooks(channelID string, options ...RequestOption) (st []*Webhook, err error) { body, err := s.RequestWithBucketID("GET", EndpointChannelWebhooks(channelID), nil, EndpointChannelWebhooks(channelID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildWebhooks returns all webhooks for a given guild. // guildID: The ID of a Guild. func (s *Session) GuildWebhooks(guildID string, options ...RequestOption) (st []*Webhook, err error) { body, err := s.RequestWithBucketID("GET", EndpointGuildWebhooks(guildID), nil, EndpointGuildWebhooks(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // Webhook returns a webhook for a given ID // webhookID: The ID of a webhook. func (s *Session) Webhook(webhookID string, options ...RequestOption) (st *Webhook, err error) { body, err := s.RequestWithBucketID("GET", EndpointWebhook(webhookID), nil, EndpointWebhooks, options...) if err != nil { return } err = unmarshal(body, &st) return } // WebhookWithToken returns a webhook for a given ID // webhookID: The ID of a webhook. // token : The auth token for the webhook. func (s *Session) WebhookWithToken(webhookID, token string, options ...RequestOption) (st *Webhook, err error) { body, err := s.RequestWithBucketID("GET", EndpointWebhookToken(webhookID, token), nil, EndpointWebhookToken("", ""), options...) if err != nil { return } err = unmarshal(body, &st) return } // WebhookEdit updates an existing Webhook. // webhookID: The ID of a webhook. // name : The name of the webhook. // avatar : The avatar of the webhook. func (s *Session) WebhookEdit(webhookID, name, avatar, channelID string, options ...RequestOption) (st *Role, err error) { data := struct { Name string `json:"name,omitempty"` Avatar string `json:"avatar,omitempty"` ChannelID string `json:"channel_id,omitempty"` }{name, avatar, channelID} body, err := s.RequestWithBucketID("PATCH", EndpointWebhook(webhookID), data, EndpointWebhooks, options...) if err != nil { return } err = unmarshal(body, &st) return } // WebhookEditWithToken updates an existing Webhook with an auth token. // webhookID: The ID of a webhook. // token : The auth token for the webhook. // name : The name of the webhook. // avatar : The avatar of the webhook. func (s *Session) WebhookEditWithToken(webhookID, token, name, avatar string, options ...RequestOption) (st *Role, err error) { data := struct { Name string `json:"name,omitempty"` Avatar string `json:"avatar,omitempty"` }{name, avatar} body, err := s.RequestWithBucketID("PATCH", EndpointWebhookToken(webhookID, token), data, EndpointWebhookToken("", ""), options...) if err != nil { return } err = unmarshal(body, &st) return } // WebhookDelete deletes a webhook for a given ID // webhookID: The ID of a webhook. func (s *Session) WebhookDelete(webhookID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointWebhook(webhookID), nil, EndpointWebhooks, options...) return } // WebhookDeleteWithToken deletes a webhook for a given ID with an auth token. // webhookID: The ID of a webhook. // token : The auth token for the webhook. func (s *Session) WebhookDeleteWithToken(webhookID, token string, options ...RequestOption) (st *Webhook, err error) { body, err := s.RequestWithBucketID("DELETE", EndpointWebhookToken(webhookID, token), nil, EndpointWebhookToken("", ""), options...) if err != nil { return } err = unmarshal(body, &st) return } func (s *Session) webhookExecute(webhookID, token string, wait bool, threadID string, data *WebhookParams, options ...RequestOption) (st *Message, err error) { uri := EndpointWebhookToken(webhookID, token) v := url.Values{} if wait { v.Set("wait", "true") } if threadID != "" { v.Set("thread_id", threadID) } if len(v) != 0 { uri += "?" + v.Encode() } var response []byte if len(data.Files) > 0 { contentType, body, encodeErr := MultipartBodyWithJSON(data, data.Files) if encodeErr != nil { return st, encodeErr } response, err = s.request("POST", uri, contentType, body, uri, 0, options...) } else { response, err = s.RequestWithBucketID("POST", uri, data, uri, options...) } if !wait || err != nil { return } err = unmarshal(response, &st) return } // WebhookExecute executes a webhook. // webhookID: The ID of a webhook. // token : The auth token for the webhook // wait : Waits for server confirmation of message send and ensures that the return struct is populated (it is nil otherwise) func (s *Session) WebhookExecute(webhookID, token string, wait bool, data *WebhookParams, options ...RequestOption) (st *Message, err error) { return s.webhookExecute(webhookID, token, wait, "", data, options...) } // WebhookThreadExecute executes a webhook in a thread. // webhookID: The ID of a webhook. // token : The auth token for the webhook // wait : Waits for server confirmation of message send and ensures that the return struct is populated (it is nil otherwise) // threadID : Sends a message to the specified thread within a webhook's channel. The thread will automatically be unarchived. func (s *Session) WebhookThreadExecute(webhookID, token string, wait bool, threadID string, data *WebhookParams, options ...RequestOption) (st *Message, err error) { return s.webhookExecute(webhookID, token, wait, threadID, data, options...) } // WebhookMessage gets a webhook message. // webhookID : The ID of a webhook // token : The auth token for the webhook // messageID : The ID of message to get func (s *Session) WebhookMessage(webhookID, token, messageID string, options ...RequestOption) (message *Message, err error) { uri := EndpointWebhookMessage(webhookID, token, messageID) body, err := s.RequestWithBucketID("GET", uri, nil, EndpointWebhookToken("", ""), options...) if err != nil { return } err = Unmarshal(body, &message) return } // WebhookMessageEdit edits a webhook message and returns a new one. // webhookID : The ID of a webhook // token : The auth token for the webhook // messageID : The ID of message to edit func (s *Session) WebhookMessageEdit(webhookID, token, messageID string, data *WebhookEdit, options ...RequestOption) (st *Message, err error) { uri := EndpointWebhookMessage(webhookID, token, messageID) var response []byte if len(data.Files) > 0 { contentType, body, err := MultipartBodyWithJSON(data, data.Files) if err != nil { return nil, err } response, err = s.request("PATCH", uri, contentType, body, uri, 0, options...) if err != nil { return nil, err } } else { response, err = s.RequestWithBucketID("PATCH", uri, data, EndpointWebhookToken("", ""), options...) if err != nil { return nil, err } } err = unmarshal(response, &st) return } // WebhookMessageDelete deletes a webhook message. // webhookID : The ID of a webhook // token : The auth token for the webhook // messageID : The ID of a message to edit func (s *Session) WebhookMessageDelete(webhookID, token, messageID string, options ...RequestOption) (err error) { uri := EndpointWebhookMessage(webhookID, token, messageID) _, err = s.RequestWithBucketID("DELETE", uri, nil, EndpointWebhookToken("", ""), options...) return } // MessageReactionAdd creates an emoji reaction to a message. // channelID : The channel ID. // messageID : The message ID. // emojiID : Either the unicode emoji for the reaction, or a guild emoji identifier in name:id format (e.g. "hello:1234567654321") func (s *Session) MessageReactionAdd(channelID, messageID, emojiID string, options ...RequestOption) error { // emoji such as #⃣ need to have # escaped emojiID = strings.Replace(emojiID, "#", "%23", -1) _, err := s.RequestWithBucketID("PUT", EndpointMessageReaction(channelID, messageID, emojiID, "@me"), nil, EndpointMessageReaction(channelID, "", "", ""), options...) return err } // MessageReactionRemove deletes an emoji reaction to a message. // channelID : The channel ID. // messageID : The message ID. // emojiID : Either the unicode emoji for the reaction, or a guild emoji identifier. // userID : @me or ID of the user to delete the reaction for. func (s *Session) MessageReactionRemove(channelID, messageID, emojiID, userID string, options ...RequestOption) error { // emoji such as #⃣ need to have # escaped emojiID = strings.Replace(emojiID, "#", "%23", -1) _, err := s.RequestWithBucketID("DELETE", EndpointMessageReaction(channelID, messageID, emojiID, userID), nil, EndpointMessageReaction(channelID, "", "", ""), options...) return err } // MessageReactionsRemoveAll deletes all reactions from a message // channelID : The channel ID // messageID : The message ID. func (s *Session) MessageReactionsRemoveAll(channelID, messageID string, options ...RequestOption) error { _, err := s.RequestWithBucketID("DELETE", EndpointMessageReactionsAll(channelID, messageID), nil, EndpointMessageReactionsAll(channelID, messageID), options...) return err } // MessageReactionsRemoveEmoji deletes all reactions of a certain emoji from a message // channelID : The channel ID // messageID : The message ID // emojiID : The emoji ID func (s *Session) MessageReactionsRemoveEmoji(channelID, messageID, emojiID string, options ...RequestOption) error { // emoji such as #⃣ need to have # escaped emojiID = strings.Replace(emojiID, "#", "%23", -1) _, err := s.RequestWithBucketID("DELETE", EndpointMessageReactions(channelID, messageID, emojiID), nil, EndpointMessageReactions(channelID, messageID, emojiID), options...) return err } // MessageReactions gets all the users reactions for a specific emoji. // channelID : The channel ID. // messageID : The message ID. // emojiID : Either the unicode emoji for the reaction, or a guild emoji identifier. // limit : max number of users to return (max 100) // beforeID : If provided all reactions returned will be before given ID. // afterID : If provided all reactions returned will be after given ID. func (s *Session) MessageReactions(channelID, messageID, emojiID string, limit int, beforeID, afterID string, options ...RequestOption) (st []*User, err error) { // emoji such as #⃣ need to have # escaped emojiID = strings.Replace(emojiID, "#", "%23", -1) uri := EndpointMessageReactions(channelID, messageID, emojiID) v := url.Values{} if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if afterID != "" { v.Set("after", afterID) } if beforeID != "" { v.Set("before", beforeID) } if len(v) > 0 { uri += "?" + v.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointMessageReaction(channelID, "", "", ""), options...) if err != nil { return } err = unmarshal(body, &st) return } // ------------------------------------------------------------------------------------------------ // Functions specific to threads // ------------------------------------------------------------------------------------------------ // MessageThreadStartComplex creates a new thread from an existing message. // channelID : Channel to create thread in // messageID : Message to start thread from // data : Parameters of the thread func (s *Session) MessageThreadStartComplex(channelID, messageID string, data *ThreadStart, options ...RequestOption) (ch *Channel, err error) { endpoint := EndpointChannelMessageThread(channelID, messageID) var body []byte body, err = s.RequestWithBucketID("POST", endpoint, data, endpoint, options...) if err != nil { return } err = unmarshal(body, &ch) return } // MessageThreadStart creates a new thread from an existing message. // channelID : Channel to create thread in // messageID : Message to start thread from // name : Name of the thread // archiveDuration : Auto archive duration (in minutes) func (s *Session) MessageThreadStart(channelID, messageID string, name string, archiveDuration int, options ...RequestOption) (ch *Channel, err error) { return s.MessageThreadStartComplex(channelID, messageID, &ThreadStart{ Name: name, AutoArchiveDuration: archiveDuration, }, options...) } // ThreadStartComplex creates a new thread. // channelID : Channel to create thread in // data : Parameters of the thread func (s *Session) ThreadStartComplex(channelID string, data *ThreadStart, options ...RequestOption) (ch *Channel, err error) { endpoint := EndpointChannelThreads(channelID) var body []byte body, err = s.RequestWithBucketID("POST", endpoint, data, endpoint, options...) if err != nil { return } err = unmarshal(body, &ch) return } // ThreadStart creates a new thread. // channelID : Channel to create thread in // name : Name of the thread // archiveDuration : Auto archive duration (in minutes) func (s *Session) ThreadStart(channelID, name string, typ ChannelType, archiveDuration int, options ...RequestOption) (ch *Channel, err error) { return s.ThreadStartComplex(channelID, &ThreadStart{ Name: name, Type: typ, AutoArchiveDuration: archiveDuration, }, options...) } // ForumThreadStartComplex starts a new thread (creates a post) in a forum channel. // channelID : Channel to create thread in. // threadData : Parameters of the thread. // messageData : Parameters of the starting message. func (s *Session) ForumThreadStartComplex(channelID string, threadData *ThreadStart, messageData *MessageSend, options ...RequestOption) (th *Channel, err error) { endpoint := EndpointChannelThreads(channelID) // TODO: Remove this when compatibility is not required. if messageData.Embed != nil { if messageData.Embeds == nil { messageData.Embeds = []*MessageEmbed{messageData.Embed} } else { err = fmt.Errorf("cannot specify both Embed and Embeds") return } } for _, embed := range messageData.Embeds { if embed.Type == "" { embed.Type = "rich" } } // TODO: Remove this when compatibility is not required. files := messageData.Files if messageData.File != nil { if files == nil { files = []*File{messageData.File} } else { err = fmt.Errorf("cannot specify both File and Files") return } } data := struct { *ThreadStart Message *MessageSend `json:"message"` }{ThreadStart: threadData, Message: messageData} var response []byte if len(files) > 0 { contentType, body, encodeErr := MultipartBodyWithJSON(data, files) if encodeErr != nil { return th, encodeErr } response, err = s.request("POST", endpoint, contentType, body, endpoint, 0, options...) } else { response, err = s.RequestWithBucketID("POST", endpoint, data, endpoint, options...) } if err != nil { return } err = unmarshal(response, &th) return } // ForumThreadStart starts a new thread (post) in a forum channel. // channelID : Channel to create thread in. // name : Name of the thread. // archiveDuration : Auto archive duration. // content : Content of the starting message. func (s *Session) ForumThreadStart(channelID, name string, archiveDuration int, content string, options ...RequestOption) (th *Channel, err error) { return s.ForumThreadStartComplex(channelID, &ThreadStart{ Name: name, AutoArchiveDuration: archiveDuration, }, &MessageSend{Content: content}, options...) } // ForumThreadStartEmbed starts a new thread (post) in a forum channel. // channelID : Channel to create thread in. // name : Name of the thread. // archiveDuration : Auto archive duration. // embed : Embed data of the starting message. func (s *Session) ForumThreadStartEmbed(channelID, name string, archiveDuration int, embed *MessageEmbed, options ...RequestOption) (th *Channel, err error) { return s.ForumThreadStartComplex(channelID, &ThreadStart{ Name: name, AutoArchiveDuration: archiveDuration, }, &MessageSend{Embeds: []*MessageEmbed{embed}}, options...) } // ForumThreadStartEmbeds starts a new thread (post) in a forum channel. // channelID : Channel to create thread in. // name : Name of the thread. // archiveDuration : Auto archive duration. // embeds : Embeds data of the starting message. func (s *Session) ForumThreadStartEmbeds(channelID, name string, archiveDuration int, embeds []*MessageEmbed, options ...RequestOption) (th *Channel, err error) { return s.ForumThreadStartComplex(channelID, &ThreadStart{ Name: name, AutoArchiveDuration: archiveDuration, }, &MessageSend{Embeds: embeds}, options...) } // ThreadJoin adds current user to a thread func (s *Session) ThreadJoin(id string, options ...RequestOption) error { endpoint := EndpointThreadMember(id, "@me") _, err := s.RequestWithBucketID("PUT", endpoint, nil, endpoint, options...) return err } // ThreadLeave removes current user to a thread func (s *Session) ThreadLeave(id string, options ...RequestOption) error { endpoint := EndpointThreadMember(id, "@me") _, err := s.RequestWithBucketID("DELETE", endpoint, nil, endpoint, options...) return err } // ThreadMemberAdd adds another member to a thread func (s *Session) ThreadMemberAdd(threadID, memberID string, options ...RequestOption) error { endpoint := EndpointThreadMember(threadID, memberID) _, err := s.RequestWithBucketID("PUT", endpoint, nil, endpoint, options...) return err } // ThreadMemberRemove removes another member from a thread func (s *Session) ThreadMemberRemove(threadID, memberID string, options ...RequestOption) error { endpoint := EndpointThreadMember(threadID, memberID) _, err := s.RequestWithBucketID("DELETE", endpoint, nil, endpoint, options...) return err } // ThreadMember returns thread member object for the specified member of a thread func (s *Session) ThreadMember(threadID, memberID string, options ...RequestOption) (member *ThreadMember, err error) { endpoint := EndpointThreadMember(threadID, memberID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &member) return } // ThreadMembers returns all members of specified thread. func (s *Session) ThreadMembers(threadID string, options ...RequestOption) (members []*ThreadMember, err error) { var body []byte body, err = s.RequestWithBucketID("GET", EndpointThreadMembers(threadID), nil, EndpointThreadMembers(threadID), options...) if err != nil { return } err = unmarshal(body, &members) return } // ThreadsActive returns all active threads for specified channel. func (s *Session) ThreadsActive(channelID string, options ...RequestOption) (threads *ThreadsList, err error) { var body []byte body, err = s.RequestWithBucketID("GET", EndpointChannelActiveThreads(channelID), nil, EndpointChannelActiveThreads(channelID), options...) if err != nil { return } err = unmarshal(body, &threads) return } // GuildThreadsActive returns all active threads for specified guild. func (s *Session) GuildThreadsActive(guildID string, options ...RequestOption) (threads *ThreadsList, err error) { var body []byte body, err = s.RequestWithBucketID("GET", EndpointGuildActiveThreads(guildID), nil, EndpointGuildActiveThreads(guildID), options...) if err != nil { return } err = unmarshal(body, &threads) return } // ThreadsArchived returns archived threads for specified channel. // before : If specified returns only threads before the timestamp // limit : Optional maximum amount of threads to return. func (s *Session) ThreadsArchived(channelID string, before *time.Time, limit int, options ...RequestOption) (threads *ThreadsList, err error) { endpoint := EndpointChannelPublicArchivedThreads(channelID) v := url.Values{} if before != nil { v.Set("before", before.Format(time.RFC3339)) } if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if len(v) > 0 { endpoint += "?" + v.Encode() } var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &threads) return } // ThreadsPrivateArchived returns archived private threads for specified channel. // before : If specified returns only threads before the timestamp // limit : Optional maximum amount of threads to return. func (s *Session) ThreadsPrivateArchived(channelID string, before *time.Time, limit int, options ...RequestOption) (threads *ThreadsList, err error) { endpoint := EndpointChannelPrivateArchivedThreads(channelID) v := url.Values{} if before != nil { v.Set("before", before.Format(time.RFC3339)) } if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if len(v) > 0 { endpoint += "?" + v.Encode() } var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &threads) return } // ThreadsPrivateJoinedArchived returns archived joined private threads for specified channel. // before : If specified returns only threads before the timestamp // limit : Optional maximum amount of threads to return. func (s *Session) ThreadsPrivateJoinedArchived(channelID string, before *time.Time, limit int, options ...RequestOption) (threads *ThreadsList, err error) { endpoint := EndpointChannelJoinedPrivateArchivedThreads(channelID) v := url.Values{} if before != nil { v.Set("before", before.Format(time.RFC3339)) } if limit > 0 { v.Set("limit", strconv.Itoa(limit)) } if len(v) > 0 { endpoint += "?" + v.Encode() } var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &threads) return } // ------------------------------------------------------------------------------------------------ // Functions specific to application (slash) commands // ------------------------------------------------------------------------------------------------ // ApplicationCommandCreate creates a global application command and returns it. // appID : The application ID. // guildID : Guild ID to create guild-specific application command. If empty - creates global application command. // cmd : New application command data. func (s *Session) ApplicationCommandCreate(appID string, guildID string, cmd *ApplicationCommand, options ...RequestOption) (ccmd *ApplicationCommand, err error) { endpoint := EndpointApplicationGlobalCommands(appID) if guildID != "" { endpoint = EndpointApplicationGuildCommands(appID, guildID) } body, err := s.RequestWithBucketID("POST", endpoint, *cmd, endpoint, options...) if err != nil { return } err = unmarshal(body, &ccmd) return } // ApplicationCommandEdit edits application command and returns new command data. // appID : The application ID. // cmdID : Application command ID to edit. // guildID : Guild ID to edit guild-specific application command. If empty - edits global application command. // cmd : Updated application command data. func (s *Session) ApplicationCommandEdit(appID, guildID, cmdID string, cmd *ApplicationCommand, options ...RequestOption) (updated *ApplicationCommand, err error) { endpoint := EndpointApplicationGlobalCommand(appID, cmdID) if guildID != "" { endpoint = EndpointApplicationGuildCommand(appID, guildID, cmdID) } body, err := s.RequestWithBucketID("PATCH", endpoint, *cmd, endpoint, options...) if err != nil { return } err = unmarshal(body, &updated) return } // ApplicationCommandBulkOverwrite Creates commands overwriting existing commands. Returns a list of commands. // appID : The application ID. // commands : The commands to create. func (s *Session) ApplicationCommandBulkOverwrite(appID string, guildID string, commands []*ApplicationCommand, options ...RequestOption) (createdCommands []*ApplicationCommand, err error) { endpoint := EndpointApplicationGlobalCommands(appID) if guildID != "" { endpoint = EndpointApplicationGuildCommands(appID, guildID) } body, err := s.RequestWithBucketID("PUT", endpoint, commands, endpoint, options...) if err != nil { return } err = unmarshal(body, &createdCommands) return } // ApplicationCommandDelete deletes application command by ID. // appID : The application ID. // cmdID : Application command ID to delete. // guildID : Guild ID to delete guild-specific application command. If empty - deletes global application command. func (s *Session) ApplicationCommandDelete(appID, guildID, cmdID string, options ...RequestOption) error { endpoint := EndpointApplicationGlobalCommand(appID, cmdID) if guildID != "" { endpoint = EndpointApplicationGuildCommand(appID, guildID, cmdID) } _, err := s.RequestWithBucketID("DELETE", endpoint, nil, endpoint, options...) return err } // ApplicationCommand retrieves an application command by given ID. // appID : The application ID. // cmdID : Application command ID. // guildID : Guild ID to retrieve guild-specific application command. If empty - retrieves global application command. func (s *Session) ApplicationCommand(appID, guildID, cmdID string, options ...RequestOption) (cmd *ApplicationCommand, err error) { endpoint := EndpointApplicationGlobalCommand(appID, cmdID) if guildID != "" { endpoint = EndpointApplicationGuildCommand(appID, guildID, cmdID) } body, err := s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &cmd) return } // ApplicationCommands retrieves all commands in application. // appID : The application ID. // guildID : Guild ID to retrieve all guild-specific application commands. If empty - retrieves global application commands. func (s *Session) ApplicationCommands(appID, guildID string, options ...RequestOption) (cmd []*ApplicationCommand, err error) { endpoint := EndpointApplicationGlobalCommands(appID) if guildID != "" { endpoint = EndpointApplicationGuildCommands(appID, guildID) } body, err := s.RequestWithBucketID("GET", endpoint+"?with_localizations=true", nil, "GET "+endpoint, options...) if err != nil { return } err = unmarshal(body, &cmd) return } // GuildApplicationCommandsPermissions returns permissions for application commands in a guild. // appID : The application ID // guildID : Guild ID to retrieve application commands permissions for. func (s *Session) GuildApplicationCommandsPermissions(appID, guildID string, options ...RequestOption) (permissions []*GuildApplicationCommandPermissions, err error) { endpoint := EndpointApplicationCommandsGuildPermissions(appID, guildID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &permissions) return } // ApplicationCommandPermissions returns all permissions of an application command // appID : The Application ID // guildID : The guild ID containing the application command // cmdID : The command ID to retrieve the permissions of func (s *Session) ApplicationCommandPermissions(appID, guildID, cmdID string, options ...RequestOption) (permissions *GuildApplicationCommandPermissions, err error) { endpoint := EndpointApplicationCommandPermissions(appID, guildID, cmdID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &permissions) return } // ApplicationCommandPermissionsEdit edits the permissions of an application command // appID : The Application ID // guildID : The guild ID containing the application command // cmdID : The command ID to edit the permissions of // permissions : An object containing a list of permissions for the application command // // NOTE: Requires OAuth2 token with applications.commands.permissions.update scope func (s *Session) ApplicationCommandPermissionsEdit(appID, guildID, cmdID string, permissions *ApplicationCommandPermissionsList, options ...RequestOption) (err error) { endpoint := EndpointApplicationCommandPermissions(appID, guildID, cmdID) _, err = s.RequestWithBucketID("PUT", endpoint, permissions, endpoint, options...) return } // ApplicationCommandPermissionsBatchEdit edits the permissions of a batch of commands // appID : The Application ID // guildID : The guild ID to batch edit commands of // permissions : A list of permissions paired with a command ID, guild ID, and application ID per application command // // NOTE: This endpoint has been disabled with updates to command permissions (Permissions v2). Please use ApplicationCommandPermissionsEdit instead. func (s *Session) ApplicationCommandPermissionsBatchEdit(appID, guildID string, permissions []*GuildApplicationCommandPermissions, options ...RequestOption) (err error) { endpoint := EndpointApplicationCommandsGuildPermissions(appID, guildID) _, err = s.RequestWithBucketID("PUT", endpoint, permissions, endpoint, options...) return } // InteractionRespond creates the response to an interaction. // interaction : Interaction instance. // resp : Response message data. func (s *Session) InteractionRespond(interaction *Interaction, resp *InteractionResponse, options ...RequestOption) error { endpoint := EndpointInteractionResponse(interaction.ID, interaction.Token) if resp.Data != nil && len(resp.Data.Files) > 0 { contentType, body, err := MultipartBodyWithJSON(resp, resp.Data.Files) if err != nil { return err } _, err = s.request("POST", endpoint, contentType, body, endpoint, 0, options...) return err } _, err := s.RequestWithBucketID("POST", endpoint, *resp, endpoint, options...) return err } // InteractionResponse gets the response to an interaction. // interaction : Interaction instance. func (s *Session) InteractionResponse(interaction *Interaction, options ...RequestOption) (*Message, error) { return s.WebhookMessage(interaction.AppID, interaction.Token, "@original", options...) } // InteractionResponseEdit edits the response to an interaction. // interaction : Interaction instance. // newresp : Updated response message data. func (s *Session) InteractionResponseEdit(interaction *Interaction, newresp *WebhookEdit, options ...RequestOption) (*Message, error) { return s.WebhookMessageEdit(interaction.AppID, interaction.Token, "@original", newresp, options...) } // InteractionResponseDelete deletes the response to an interaction. // interaction : Interaction instance. func (s *Session) InteractionResponseDelete(interaction *Interaction, options ...RequestOption) error { endpoint := EndpointInteractionResponseActions(interaction.AppID, interaction.Token) _, err := s.RequestWithBucketID("DELETE", endpoint, nil, endpoint, options...) return err } // FollowupMessageCreate creates the followup message for an interaction. // interaction : Interaction instance. // wait : Waits for server confirmation of message send and ensures that the return struct is populated (it is nil otherwise) // data : Data of the message to send. func (s *Session) FollowupMessageCreate(interaction *Interaction, wait bool, data *WebhookParams, options ...RequestOption) (*Message, error) { return s.WebhookExecute(interaction.AppID, interaction.Token, wait, data, options...) } // FollowupMessageEdit edits a followup message of an interaction. // interaction : Interaction instance. // messageID : The followup message ID. // data : Data to update the message func (s *Session) FollowupMessageEdit(interaction *Interaction, messageID string, data *WebhookEdit, options ...RequestOption) (*Message, error) { return s.WebhookMessageEdit(interaction.AppID, interaction.Token, messageID, data, options...) } // FollowupMessageDelete deletes a followup message of an interaction. // interaction : Interaction instance. // messageID : The followup message ID. func (s *Session) FollowupMessageDelete(interaction *Interaction, messageID string, options ...RequestOption) error { return s.WebhookMessageDelete(interaction.AppID, interaction.Token, messageID, options...) } // ------------------------------------------------------------------------------------------------ // Functions specific to stage instances // ------------------------------------------------------------------------------------------------ // StageInstanceCreate creates and returns a new Stage instance associated to a Stage channel. // data : Parameters needed to create a stage instance. // data : The data of the Stage instance to create func (s *Session) StageInstanceCreate(data *StageInstanceParams, options ...RequestOption) (si *StageInstance, err error) { body, err := s.RequestWithBucketID("POST", EndpointStageInstances, data, EndpointStageInstances, options...) if err != nil { return } err = unmarshal(body, &si) return } // StageInstance will retrieve a Stage instance by ID of the Stage channel. // channelID : The ID of the Stage channel func (s *Session) StageInstance(channelID string, options ...RequestOption) (si *StageInstance, err error) { body, err := s.RequestWithBucketID("GET", EndpointStageInstance(channelID), nil, EndpointStageInstance(channelID), options...) if err != nil { return } err = unmarshal(body, &si) return } // StageInstanceEdit will edit a Stage instance by ID of the Stage channel. // channelID : The ID of the Stage channel // data : The data to edit the Stage instance func (s *Session) StageInstanceEdit(channelID string, data *StageInstanceParams, options ...RequestOption) (si *StageInstance, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointStageInstance(channelID), data, EndpointStageInstance(channelID), options...) if err != nil { return } err = unmarshal(body, &si) return } // StageInstanceDelete will delete a Stage instance by ID of the Stage channel. // channelID : The ID of the Stage channel func (s *Session) StageInstanceDelete(channelID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointStageInstance(channelID), nil, EndpointStageInstance(channelID), options...) return } // ------------------------------------------------------------------------------------------------ // Functions specific to guilds scheduled events // ------------------------------------------------------------------------------------------------ // GuildScheduledEvents returns an array of GuildScheduledEvent for a guild // guildID : The ID of a Guild // userCount : Whether to include the user count in the response func (s *Session) GuildScheduledEvents(guildID string, userCount bool, options ...RequestOption) (st []*GuildScheduledEvent, err error) { uri := EndpointGuildScheduledEvents(guildID) if userCount { uri += "?with_user_count=true" } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildScheduledEvents(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildScheduledEvent returns a specific GuildScheduledEvent in a guild // guildID : The ID of a Guild // eventID : The ID of the event // userCount : Whether to include the user count in the response func (s *Session) GuildScheduledEvent(guildID, eventID string, userCount bool, options ...RequestOption) (st *GuildScheduledEvent, err error) { uri := EndpointGuildScheduledEvent(guildID, eventID) if userCount { uri += "?with_user_count=true" } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildScheduledEvent(guildID, eventID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildScheduledEventCreate creates a GuildScheduledEvent for a guild and returns it // guildID : The ID of a Guild // eventID : The ID of the event func (s *Session) GuildScheduledEventCreate(guildID string, event *GuildScheduledEventParams, options ...RequestOption) (st *GuildScheduledEvent, err error) { body, err := s.RequestWithBucketID("POST", EndpointGuildScheduledEvents(guildID), event, EndpointGuildScheduledEvents(guildID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildScheduledEventEdit updates a specific event for a guild and returns it. // guildID : The ID of a Guild // eventID : The ID of the event func (s *Session) GuildScheduledEventEdit(guildID, eventID string, event *GuildScheduledEventParams, options ...RequestOption) (st *GuildScheduledEvent, err error) { body, err := s.RequestWithBucketID("PATCH", EndpointGuildScheduledEvent(guildID, eventID), event, EndpointGuildScheduledEvent(guildID, eventID), options...) if err != nil { return } err = unmarshal(body, &st) return } // GuildScheduledEventDelete deletes a specific GuildScheduledEvent in a guild // guildID : The ID of a Guild // eventID : The ID of the event func (s *Session) GuildScheduledEventDelete(guildID, eventID string, options ...RequestOption) (err error) { _, err = s.RequestWithBucketID("DELETE", EndpointGuildScheduledEvent(guildID, eventID), nil, EndpointGuildScheduledEvent(guildID, eventID), options...) return } // GuildScheduledEventUsers returns an array of GuildScheduledEventUser for a particular event in a guild // guildID : The ID of a Guild // eventID : The ID of the event // limit : The maximum number of users to return (Max 100) // withMember : Whether to include the member object in the response // beforeID : If is not empty all returned users entries will be before the given ID // afterID : If is not empty all returned users entries will be after the given ID func (s *Session) GuildScheduledEventUsers(guildID, eventID string, limit int, withMember bool, beforeID, afterID string, options ...RequestOption) (st []*GuildScheduledEventUser, err error) { uri := EndpointGuildScheduledEventUsers(guildID, eventID) queryParams := url.Values{} if withMember { queryParams.Set("with_member", "true") } if limit > 0 { queryParams.Set("limit", strconv.Itoa(limit)) } if beforeID != "" { queryParams.Set("before", beforeID) } if afterID != "" { queryParams.Set("after", afterID) } if len(queryParams) > 0 { uri += "?" + queryParams.Encode() } body, err := s.RequestWithBucketID("GET", uri, nil, EndpointGuildScheduledEventUsers(guildID, eventID), options...) if err != nil { return } err = unmarshal(body, &st) return } // ---------------------------------------------------------------------- // Functions specific to auto moderation // ---------------------------------------------------------------------- // AutoModerationRules returns a list of auto moderation rules. // guildID : ID of the guild func (s *Session) AutoModerationRules(guildID string, options ...RequestOption) (st []*AutoModerationRule, err error) { endpoint := EndpointGuildAutoModerationRules(guildID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // AutoModerationRule returns an auto moderation rule. // guildID : ID of the guild // ruleID : ID of the auto moderation rule func (s *Session) AutoModerationRule(guildID, ruleID string, options ...RequestOption) (st *AutoModerationRule, err error) { endpoint := EndpointGuildAutoModerationRule(guildID, ruleID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // AutoModerationRuleCreate creates an auto moderation rule with the given data and returns it. // guildID : ID of the guild // rule : Rule data func (s *Session) AutoModerationRuleCreate(guildID string, rule *AutoModerationRule, options ...RequestOption) (st *AutoModerationRule, err error) { endpoint := EndpointGuildAutoModerationRules(guildID) var body []byte body, err = s.RequestWithBucketID("POST", endpoint, rule, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // AutoModerationRuleEdit edits and returns the updated auto moderation rule. // guildID : ID of the guild // ruleID : ID of the auto moderation rule // rule : New rule data func (s *Session) AutoModerationRuleEdit(guildID, ruleID string, rule *AutoModerationRule, options ...RequestOption) (st *AutoModerationRule, err error) { endpoint := EndpointGuildAutoModerationRule(guildID, ruleID) var body []byte body, err = s.RequestWithBucketID("PATCH", endpoint, rule, endpoint, options...) if err != nil { return } err = unmarshal(body, &st) return } // AutoModerationRuleDelete deletes an auto moderation rule. // guildID : ID of the guild // ruleID : ID of the auto moderation rule func (s *Session) AutoModerationRuleDelete(guildID, ruleID string, options ...RequestOption) (err error) { endpoint := EndpointGuildAutoModerationRule(guildID, ruleID) _, err = s.RequestWithBucketID("DELETE", endpoint, nil, endpoint, options...) return } // ApplicationRoleConnectionMetadata returns application role connection metadata. // appID : ID of the application func (s *Session) ApplicationRoleConnectionMetadata(appID string) (st []*ApplicationRoleConnectionMetadata, err error) { endpoint := EndpointApplicationRoleConnectionMetadata(appID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint) if err != nil { return } err = unmarshal(body, &st) return } // ApplicationRoleConnectionMetadataUpdate updates and returns application role connection metadata. // appID : ID of the application // metadata : New metadata func (s *Session) ApplicationRoleConnectionMetadataUpdate(appID string, metadata []*ApplicationRoleConnectionMetadata) (st []*ApplicationRoleConnectionMetadata, err error) { endpoint := EndpointApplicationRoleConnectionMetadata(appID) var body []byte body, err = s.RequestWithBucketID("PUT", endpoint, metadata, endpoint) if err != nil { return } err = unmarshal(body, &st) return } // UserApplicationRoleConnection returns user role connection to the specified application. // appID : ID of the application func (s *Session) UserApplicationRoleConnection(appID string) (st *ApplicationRoleConnection, err error) { endpoint := EndpointUserApplicationRoleConnection(appID) var body []byte body, err = s.RequestWithBucketID("GET", endpoint, nil, endpoint) if err != nil { return } err = unmarshal(body, &st) return } // UserApplicationRoleConnectionUpdate updates and returns user role connection to the specified application. // appID : ID of the application // connection : New ApplicationRoleConnection data func (s *Session) UserApplicationRoleConnectionUpdate(appID string, rconn *ApplicationRoleConnection) (st *ApplicationRoleConnection, err error) { endpoint := EndpointUserApplicationRoleConnection(appID) var body []byte body, err = s.RequestWithBucketID("PUT", endpoint, rconn, endpoint) if err != nil { return } err = unmarshal(body, &st) return }