discljord.messaging — org.suskalo/discljord 0.2.0

Contains functions for communicating with Discord, sending messages, and recieving data.

add-channel-pinned-message! clj

(add-channel-pinned-message! conn
                             channel-id
                             message-id
                             &
                             {:as opts :keys [user-agent]})

Pins the given message to the channel. Returns a promise containing a boolean of if it succeeded.

add-guild-member! clj

(add-guild-member! conn
                   guild-id
                   user-id
                   access-token
                   &
                   {:as opts :keys [nick roles mute deaf user-agent]})

NOT INTENDED FOR BOT USE. Adds a user to a guild. Requires an access token. Returns a promise containing the keyword :already-member if the user is already a member, or the guild member object.

add-guild-member-role! clj

(add-guild-member-role! conn
                        guild-id
                        user-id
                        role-id
                        &
                        {:as opts :keys [user-agent]})

Adds the given role to the user. Returns a promise containing a boolean of if it succeeded.

begin-guild-prune! clj

(begin-guild-prune! conn
                    guild-id
                    days
                    compute-prune-count
                    &
                    {:as opts :keys [user-agent]})

Starts a guild prune. Returns a promise containing nil if compute-prune-count is false, otherwise the number of users to be prouned.

bulk-delete-messages! clj

(bulk-delete-messages! conn channel-id messages & {:as opts :keys [user-agent]})

Deletes all the messages whose id's are in the passed vector. Returns a promise containing a boolean of if it succeeded.

create-channel-invite! clj

(create-channel-invite! conn
                        channel-id
                        &
                        {:as opts
                         :keys [max-age max-uses temporary unique user-agent]})

Returns a promise containing a new invite object.

create-dm! clj

(create-dm! conn user-id & {:as opts :keys [user-agent]})

Returns a promise containing a DM channel object with the given user.

create-group-dm! clj

(create-group-dm! conn access-tokens nicks & {:as opts :keys [user-agent]})

NOT INTENDED FOR BOT USE. Returns a promise containing a DM channel object.

create-guild! clj

(create-guild! conn
               name
               region
               icon
               verification-level
               default-message-notifications
               explicit-content-filter
               role-objects
               channels
               &
               {:as opts :keys [user-agent]})

Returns a promise containing the created guild object.

create-guild-ban! clj

(create-guild-ban! conn
                   guild-id
                   user-id
                   &
                   {:as opts :keys [delete-message-days reason user-agent]})

Bans a user. Returns a promise containing a boolean of if it succeeded.

create-guild-channel! clj

(create-guild-channel! conn
                       guild-id
                       name
                       &
                       {:as opts
                        :keys [type topic bitrate user-limit rate-limit-per-user
                               position permission-overwrites parent-id nsfw
                               user-agent]})

Returns a promise containing the new channel object.

create-guild-emoji! clj

(create-guild-emoji! conn
                     guild-id
                     name
                     image
                     roles
                     &
                     {:as opts :keys [user-agent]})

Creates a new guild emoji. Returns a promise containing the new emoji object.

create-guild-integration! clj

(create-guild-integration! conn
                           guild-id
                           type
                           id
                           &
                           {:as opts :keys [user-agent]})

Creates a new integration in the guild. Returns a promise containing a boolean of if it succeeded.

create-guild-role! clj

(create-guild-role!
  conn
  guild-id
  &
  {:as opts :keys [name permissions color hoist mentionable user-agent]})

Returns a promise containing the created role.

create-message! clj

(create-message! conn
                 channel-id
                 &
                 {:as opts :keys [content tts nonce embed file user-agent]})

Sends a message on the channel. Returns a promise containing the message object.

Currently does not support uploading files.

create-reaction! clj

(create-reaction! conn
                  channel-id
                  message-id
                  emoji
                  &
                  {:as opts :keys [user-agent]})

Creates a new reaction on the message with the given emoji (either unicode or the id of a custom emoji). Returns a promise containing a boolean, telling you if it succeeded.

create-webhook! clj

(create-webhook! conn channel-id name & {:as opts :keys [avatar user-agent]})

Returns a promise containing the new webhook object.

defendpoint clj macro

(defendpoint endpoint-name major-var-type doc-str params opts)

Creates a new non-blocking function for a discord endpoint. endpoint-name must end with an '!'

delete-all-reactions! clj

(delete-all-reactions! conn
                       channel-id
                       message-id
                       &
                       {:as opts :keys [user-agent]})

Deletes all reactions on a message. Returns a promise containing a boolean of if it succeeded.

delete-channel! clj

(delete-channel! conn channel-id & {:as opts :keys [user-agent user-agent]})

Deletes a channel. Returns a promise containing the deleted channel object.

delete-channel-permission! clj

(delete-channel-permission! conn
                            channel-id
                            overwrite-id
                            &
                            {:as opts :keys [user-agent]})

Deletes a permission override in a channel. Returns a promise containing a boolean of if it succeeded.

delete-guild! clj

(delete-guild! conn guild-id & {:as opts :keys [user-agent]})

Deletes a guild if the bot is the owner. Returns a promise containing a boolean of if it succeeded.

delete-guild-emoji! clj

(delete-guild-emoji! conn guild-id emoji & {:as opts :keys [user-agent]})

Deletes an emoji from the guild. Returns a promise containing a boolean of if it succeeded.

delete-guild-integration! clj

(delete-guild-integration! conn
                           guild-id
                           integration-id
                           &
                           {:as opts :keys [user-agent]})

Deletes a guild integration. Returns a promise containing a boolean of if it succeeded.

delete-guild-role! clj

(delete-guild-role! conn guild-id role-id & {:as opts :keys [user-agent]})

Deletes a guild role. Returns a promise containing a boolean of if it succeeded.

delete-invite! clj

(delete-invite! conn invite-code & {:as opts :keys [user-agent]})

Deletes the invite. Returns a promise containing the deleted invite.

delete-message! clj

(delete-message! conn channel-id message-id & {:as opts :keys [user-agent]})

Deletes the given message. Returns a promise containing a boolean of if it succeeded.

delete-own-reaction! clj

(delete-own-reaction! conn
                      channel-id
                      message-id
                      emoji
                      &
                      {:as opts :keys [user-agent]})

Deletes your reaction on the messasge with the given emoji (either unicode or the id of a custom emoji). Returns a promise containing a boolean, telling you if it succeeded.

delete-pinned-channel-message! clj

(delete-pinned-channel-message! conn
                                channel-id
                                message-id
                                &
                                {:as opts :keys [user-agent]})

Removes a message from the pinned list in the channel. Returns a promise containing a boolean of if it succeeded.

delete-user-reaction! clj

(delete-user-reaction! conn
                       channel-id
                       message-id
                       emoji
                       user-id
                       &
                       {:as opts :keys [user-agent]})

Deletes a given user's reaction to a message with the given emoji (either unicode or the id of a custom emoji). Returns a promise containing a boolean, telling you if it succeeded.

delete-webhook! clj

(delete-webhook! conn webhook-id & {:as opts :keys [user-agent]})

Deletes the webhook. Returns a promise containing a boolean of if it succeeded.

delete-webhook-with-token! clj

(delete-webhook-with-token! conn
                            webhook-id
                            webhook-token
                            &
                            {:as opts :keys [user-agent]})

Deletes the webhook, but does not require authentication. Returns a promise containing a boolean of if it succeeded.

edit-channel-permissions! clj

(edit-channel-permissions! conn
                           channel-id
                           overwrite-id
                           allow
                           deny
                           type
                           &
                           {:as opts :keys [user-agent]})

Edits the channel's permissions of either a user or role. Returns a promise containing a boolean of if it succeeded.

edit-message! clj

(edit-message! conn
               channel-id
               message-id
               &
               {:as opts :keys [content embed user-agent]})

Edits the given message with the new content or embed. Returns a promise containing the new message.

execute-webhook! clj

(execute-webhook! conn
                  webhook-id
                  webhook-token
                  content
                  file
                  embeds
                  &
                  {:as opts :keys [wait username avatar-url tts user-agent]})

Executes the given webhook. Returns a promise which always contains nil.

get-channel! clj

(get-channel! conn channel-id & {:as opts :keys [user-agent]})

Returns a promise containing a channel object.

get-channel-invites! clj

(get-channel-invites! conn channel-id & {:as opts :keys [user-agent]})

Returns a promise containing a list of invite objects with invite metadata.

get-channel-message! clj

(get-channel-message! conn
                      channel-id
                      message-id
                      &
                      {:as opts :keys [user-agent]})

Returns a promise containing the message object.

get-channel-messages! clj

(get-channel-messages! conn
                       channel-id
                       &
                       {:as opts :keys [around before after limit user-agent]})

Returns a promise containing a vector of message objects.

get-channel-webhooks! clj

(get-channel-webhooks! conn channel-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of webhook objects.

get-current-user! clj

(get-current-user! conn & {:as opts :keys [user-agent]})

Returns a promise containing the user object for the current user.

get-current-user-guilds! clj

(get-current-user-guilds! conn
                          &
                          {:as opts :keys [before after limit user-agent]})

Returns a promise containing the current user's guilds. Pagination will be required if the bot is in over 100 guilds.

get-guild! clj

(get-guild! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing the guild object.

get-guild-audit-log! clj

(get-guild-audit-log! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing an audit log object for the guild.

get-guild-ban! clj

(get-guild-ban! conn guild-id user-id & {:as opts :keys [user-agent]})

Returns a promise containing a ban object for the given user.

get-guild-bans! clj

(get-guild-bans! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of ban objects.

get-guild-channels! clj

(get-guild-channels! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of channel objects.

get-guild-embed! clj

(get-guild-embed! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing the guild embed object.

get-guild-emoji! clj

(get-guild-emoji! conn guild-id emoji & {:as opts :keys [user-agent]})

Returns a promise containing the given guild emoji object.

get-guild-integrations! clj

(get-guild-integrations! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of guild integration objects.

get-guild-invites! clj

(get-guild-invites! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of guild invite objects.

get-guild-member! clj

(get-guild-member! conn guild-id user-id & {:as opts :keys [user-agent]})

Returns a promise containing the guild member object.

get-guild-prune-count! clj

(get-guild-prune-count! conn guild-id & {:as opts :keys [days user-agent]})

Returns a promise containing the number of users to be pruned.

get-guild-roles! clj

(get-guild-roles! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of role objects.

get-guild-vanity-url! clj

(get-guild-vanity-url! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a partial invite object if the guild supports it, otherwise nil.

get-guild-voice-regions! clj

(get-guild-voice-regions! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of voice region objects.

get-guild-webhooks! clj

(get-guild-webhooks! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of webhook objects.

get-guild-widget-image! clj

(get-guild-widget-image! conn guild-id & {:as opts :keys [style user-agent]})

Returns a promise containing the guild widget image.

get-invite! clj

(get-invite! conn invite-code & {:as opts :keys [with-counts? user-agent]})

Returns a promise containing the invite.

get-pinned-messages! clj

(get-pinned-messages! conn channel-id & {:as opts :keys [user-agent]})

Returns a promise containing a list of message objects.

get-reactions! clj

(get-reactions! conn
                channel-id
                message-id
                emoji
                &
                {:as opts :keys [before after limit user-agent]})

Returns a promise containing a list of all users who reacted to the message with the emoji (either unicode or the id of a custom emoji), based on the provided limits.

get-user! clj

(get-user! conn user-id & {:as opts :keys [user-agent]})

Returns a promise containing the user object for the given user.

get-user-connections! clj

(get-user-connections! conn & {:as opts :keys [user-agent]})

NOT INTENDED FOR BOT USE. Returns a promise containing a vector of connection objects.

get-user-dms! clj

(get-user-dms! conn & {:as opts :keys [user-agent]})

Returns a promise containing a vector of DM channel objects.

get-webhook! clj

(get-webhook! conn webhook-id & {:as opts :keys [user-agent]})

Returns a promise containing a webhook object.

get-webhook-with-token! clj

(get-webhook-with-token! conn
                         webhook-id
                         webhook-token
                         &
                         {:as opts :keys [user-agent]})

Returns a promise containing a webhook object, but does not require authentication.

group-dm-add-recipient! clj

(group-dm-add-recipient! conn
                         channel-id
                         user-id
                         &
                         {:as opts :keys [access-token nick user-agent]})

NOT INTENDED FOR BOT USE. Adds a new recipient to a group DM channel. Requires an access token.

group-dm-remove-recipient! clj

(group-dm-remove-recipient! conn
                            channel-id
                            user-id
                            &
                            {:as opts :keys [user-agent]})

NOT INTENDED FOR BOT USE. Removes a recipient from a group DM channel. Requires an access token.

leave-guild! clj

(leave-guild! conn guild-id & {:as opts :keys [user-agent]})

Current user leaves the given guild. Returns a promise containing a boolean of if it succeeded.

list-guild-emojis! clj

(list-guild-emojis! conn guild-id & {:as opts :keys [user-agent]})

Returns a promise containing a vector of guild emoji objects.

list-guild-members! clj

(list-guild-members! conn guild-id & {:as opts :keys [limit after user-agent]})

Returns a promise containing a vector of the guild member objects.

list-voice-regions! clj

(list-voice-regions! conn & {:as opts :keys [user-agent]})

Returns a promise containing a vector of voice regions.

modifiy-guild-role! clj

(modifiy-guild-role!
  conn
  guild-id
  role-id
  &
  {:as opts :keys [name permissions color hoist mentionable user-agent]})

Modifies the given role. Returns a promise containing the modified role object.

modify-channel! clj

(modify-channel! conn
                 channel-id
                 &
                 {:as opts
                  :keys [name position topic nsfw rate-limit-per-user bitrate
                         user-limit permission-overwrites parent-id
                         user-agent]})

Updates a channel's settings. Returns a promise containing the channel object.

modify-current-user! clj

(modify-current-user! conn & {:as opts :keys [username avatar user-agent]})

Modifies the current user object. Returns a promise containing the modified user object.

modify-current-user-nick! clj

(modify-current-user-nick! conn guild-id nick & {:as opts :keys [user-agent]})

Modifies the username of the current user. Returns a promise containing either nil on failure or the new nickname on success.

modify-guild! clj

(modify-guild! conn
               guild-id
               &
               {:as opts
                :keys [name region verification-level
                       default-message-notifications explicit-content-filter
                       afk-channel-id afk-timeout icon owner-id splash
                       system-channel-id user-agent]})

Modifies an existing guild. Returns a promise containing the modified guild object.

modify-guild-channel-positions! clj

(modify-guild-channel-positions! conn
                                 guild-id
                                 channels
                                 &
                                 {:as opts :keys [user-agent]})

Modifies an existing channel. Returns a promise containing the modified channel object.

modify-guild-embed! clj

(modify-guild-embed! conn guild-id embed & {:as opts :keys [user-agent]})

Modifies the guild embed object. Returns a promise containing the modified guild embed object.

modify-guild-emoji! clj

(modify-guild-emoji! conn
                     guild-id
                     emoji
                     name
                     roles
                     &
                     {:as opts :keys [user-agent]})

Modifies an existing guild emoji. Returns a promise containing the modified emoji object.

modify-guild-integration! clj

(modify-guild-integration! conn
                           guild-id
                           integration-id
                           expire-behavior
                           expire-grace-period
                           enable-emoticons
                           &
                           {:as opts :keys [user-agent]})

Modifies an existing guild integration. Returns a promise containing a boolean of if it succeeded.

modify-guild-member! clj

(modify-guild-member! conn
                      guild-id
                      user-id
                      &
                      {:as opts
                       :keys [nick roles mute deaf channel-id user-agent]})

Modifies a guild member. Returns a promise containing the modified guild member object.

modify-guild-role-positions! clj

(modify-guild-role-positions! conn
                              guild-id
                              roles
                              &
                              {:as opts :keys [user-agent]})

Modifies the position of the roles in the vector. Vector must contain at least two roles, each a map with :id and :position. Returns a promise containing a vector of the guild roles.

modify-webhook! clj

(modify-webhook! conn
                 webhook-id
                 &
                 {:as opts :keys [name avatar channel-id user-agent]})

Returns a promise containing the modified webhook object.

modify-webhook-with-token! clj

(modify-webhook-with-token! conn
                            webhook-id
                            webhook-token
                            &
                            {:as opts
                             :keys [name avatar channel-id user-agent]})

Returns a promise containing the modified webhook object, but does not require authentication.

remove-guild-ban! clj

(remove-guild-ban! conn guild-id user-id & {:as opts :keys [user-agent]})

Unbans a user. Returns a promise containing a boolean of if it succeeded.

remove-guild-member! clj

(remove-guild-member! conn guild-id user-id & {:as opts :keys [user-agent]})

Kicks the member from the guild. Returns a promise containing a boolean of if it succeeded.

remove-guild-member-role! clj

(remove-guild-member-role! conn
                           guild-id
                           user-id
                           role-id
                           &
                           {:as opts :keys [user-agent]})

Removes the role from the user. Returns a promise containing a boolean of if it succeeded.

send-message! clj

(send-message! channel-id msg & {:keys [tts none embed file] :as opts})

start-connection! clj

(start-connection! token)

Takes a token for a bot, and returns a channel which is passed to the various messaging functions.

stop-connection! clj

(stop-connection! conn)

Takes a channel returned by start-connection! and stops the associated connection.

sync-guild-integration! clj

(sync-guild-integration! conn
                         guild-id
                         integration-id
                         &
                         {:as opts :keys [user-agent]})

Syncs the guild integration. Returns a promise containing a boolean of if it succeeded.

trigger-typing-indicator! clj

(trigger-typing-indicator! conn channel-id & {:as opts :keys [user-agent]})

Triggers the typing indicator in the given channel (not recommended for bots unless about to send a message which takes a while to compute). Returns a promise containing a boolean of if it succeeded.