org.riversun.xternal.simpleslackapi.SlackSessionWrapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of slacklet Show documentation
description
The newest version!
package org.riversun.xternal.simpleslackapi;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;

import org.riversun.xternal.simpleslackapi.listeners.PinAddedListener;
import org.riversun.xternal.simpleslackapi.listeners.PinRemovedListener;
import org.riversun.xternal.simpleslackapi.listeners.PresenceChangeListener;
import org.riversun.xternal.simpleslackapi.listeners.ReactionAddedListener;
import org.riversun.xternal.simpleslackapi.listeners.ReactionRemovedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelArchivedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelCreatedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelDeletedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelJoinedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelLeftListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelRenamedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackChannelUnarchivedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackConnectedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackDisconnectedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackGroupJoinedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackMessageDeletedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackMessagePostedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackMessageUpdatedListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackTeamJoinListener;
import org.riversun.xternal.simpleslackapi.listeners.SlackUserChangeListener;
import org.riversun.xternal.simpleslackapi.listeners.UserTypingListener;
import org.riversun.xternal.simpleslackapi.replies.EmojiSlackReply;
import org.riversun.xternal.simpleslackapi.replies.GenericSlackReply;
import org.riversun.xternal.simpleslackapi.replies.ParsedSlackReply;
import org.riversun.xternal.simpleslackapi.replies.SlackChannelReply;
import org.riversun.xternal.simpleslackapi.replies.SlackMessageReply;

import com.google.gson.JsonObject;

public class SlackSessionWrapper implements SlackSession {
  protected final SlackSession delegate;

  public SlackSessionWrapper(SlackSession delegate) {
    this.delegate = delegate;
  }

  @Override
  public SlackTeam getTeam() {
    return delegate.getTeam();
  }

  @Override
  public Collection getChannels() {
    return delegate.getChannels();
  }

  @Override
  public Collection getUsers() {
    return delegate.getUsers();
  }

  @Override
  public Collection getBots() {
    return delegate.getBots();
  }

  @Override
  public Collection getIntegrations() {
    return delegate.getIntegrations();
  }

  @Override
  public SlackChannel findChannelByName(String channelName) {
    return delegate.findChannelByName(channelName);
  }

  @Override
  public SlackChannel findChannelById(String channelId) {
    return delegate.findChannelById(channelId);
  }

  @Override
  public SlackIntegration findIntegrationById(String integrationId) {
    return delegate.findIntegrationById(integrationId);
  }

  @Override
  public SlackUser findUserById(String userId) {
    return delegate.findUserById(userId);
  }

  @Override
  public SlackUser findUserByUserName(String userName) {
    return delegate.findUserByUserName(userName);
  }

  @Override
  public SlackUser findUserByEmail(String userMail) {
    return delegate.findUserByEmail(userMail);
  }

  @Override
  public SlackPersona sessionPersona() {
    return delegate.sessionPersona();
  }

  @Override
  public SlackMessageHandle listEmoji() {
    return delegate.listEmoji();
  }

  @Override
  public void refetchUsers() {
    delegate.refetchUsers();
  }

  @Override
  public SlackBot findBotById(String botId) {
    return delegate.findBotById(botId);
  }

  @Override
  public SlackMessageHandle inviteUser(String email, String firstName, boolean setActive) {
    return delegate.inviteUser(email, firstName, setActive);
  }

  @Override
  public void connect() throws IOException {
    delegate.connect();
  }

  @Override
  public void disconnect() throws IOException {
    delegate.disconnect();
  }

  @Override
  public SlackMessageHandle deleteMessage(String timeStamp, SlackChannel channel) {
    return delegate.deleteMessage(timeStamp, channel);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, SlackPreparedMessage preparedMessage,
      SlackChatConfiguration chatConfiguration) {
    return delegate.sendMessage(channel, preparedMessage, chatConfiguration);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, SlackPreparedMessage preparedMessage) {
    return delegate.sendMessage(channel, preparedMessage);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message, SlackAttachment attachment,
      SlackChatConfiguration chatConfiguration, boolean unfurl) {
    return delegate.sendMessage(channel, message, attachment, chatConfiguration, unfurl);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message, SlackAttachment attachment,
      SlackChatConfiguration chatConfiguration) {
    return delegate.sendMessage(channel, message, attachment, chatConfiguration);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message, SlackAttachment attachment, boolean unfurl) {
    return delegate.sendMessage(channel, message, attachment, unfurl);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message, SlackAttachment attachment) {
    return delegate.sendMessage(channel, message, attachment);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message, boolean unfurl) {
    return delegate.sendMessage(channel, message, unfurl);
  }

  @Override
  public SlackMessageHandle sendMessage(SlackChannel channel, String message) {
    return delegate.sendMessage(channel, message);
  }

  @Override
  public SlackMessageHandle sendFile(SlackChannel channel, byte[] data, String fileName) {
    return delegate.sendFile(channel, data, fileName);
  }

  @Override
  public SlackMessageHandle sendFileToUser(SlackUser user, byte[] data, String fileName) {
    return delegate.sendFileToUser(user, data, fileName);
  }

  @Override
  public SlackMessageHandle sendFileToUser(String userName, byte[] data, String fileName) {
    return delegate.sendFileToUser(userName, data, fileName);
  }

  @Override
  public SlackMessageHandle sendMessageToUser(SlackUser user, SlackPreparedMessage preparedMessage) {
    return delegate.sendMessageToUser(user, preparedMessage);
  }

  @Override
  public SlackMessageHandle sendMessageToUser(SlackUser user, String message, SlackAttachment attachment) {
    return delegate.sendMessageToUser(user, message, attachment);
  }

  @Override
  public SlackMessageHandle sendMessageToUser(String userName, String message, SlackAttachment attachment) {
    return delegate.sendMessageToUser(userName, message, attachment);
  }

  @Override
  public SlackMessageHandle updateMessage(String timeStamp, SlackChannel channel, String message) {
    return delegate.updateMessage(timeStamp, channel, message);
  }

  @Override
  public SlackMessageHandle sendMessageOverWebSocket(SlackChannel channel, String message) {
    return delegate.sendMessageOverWebSocket(channel, message);
  }

  @Override
  public SlackMessageHandle addReactionToMessage(SlackChannel channel, String messageTimeStamp, String emojiCode) {
    return delegate.addReactionToMessage(channel, messageTimeStamp, emojiCode);
  }

  @Override
  public SlackMessageHandle removeReactionFromMessage(SlackChannel channel, String messageTimeStamp, String emojiCode) {
    return delegate.removeReactionFromMessage(channel, messageTimeStamp, emojiCode);
  }

  @Override
  public SlackMessageHandle setChannelTopic(SlackChannel channel, String topic) {
    return delegate.setChannelTopic(channel, topic);
  }

  @Override
  public SlackMessageHandle joinChannel(String channelName) {
    return delegate.joinChannel(channelName);
  }

  @Override
  public SlackMessageHandle leaveChannel(SlackChannel channel) {
    return delegate.leaveChannel(channel);
  }

  @Override
  public SlackMessageHandle inviteToChannel(SlackChannel channel, SlackUser user) {
    return delegate.inviteToChannel(channel, user);
  }

  @Override
  public SlackMessageHandle archiveChannel(SlackChannel channel) {
    return delegate.archiveChannel(channel);
  }

  @Override
  public SlackMessageHandle unarchiveChannel(SlackChannel channel) {
    return delegate.unarchiveChannel(channel);
  }

  @Override
  public SlackMessageHandle openDirectMessageChannel(SlackUser user) {
    return delegate.openDirectMessageChannel(user);
  }

  @Override
  public SlackMessageHandle openMultipartyDirectMessageChannel(SlackUser... users) {
    return delegate.openMultipartyDirectMessageChannel(users);
  }

  @Override
  public SlackMessageHandle sendTyping(SlackChannel channel) {
    return delegate.sendTyping(channel);
  }

  @Override
  public SlackPersona.SlackPresence getPresence(SlackPersona persona) {
    return delegate.getPresence(persona);
  }

  @Override
  public void setPresence(SlackPersona.SlackPresence presence) {
    delegate.setPresence(presence);
  }

  @Override
  public SlackMessageHandle postGenericSlackCommand(Map params, String command) {
    return delegate.postGenericSlackCommand(params, command);
  }

  @Override
  public void addChannelArchivedListener(SlackChannelArchivedListener listener) {
    delegate.addChannelArchivedListener(listener);
  }

  @Override
  public void removeChannelArchivedListener(SlackChannelArchivedListener listener) {
    delegate.removeChannelArchivedListener(listener);
  }

  @Override
  public void addChannelCreatedListener(SlackChannelCreatedListener listener) {
    delegate.addChannelCreatedListener(listener);
  }

  @Override
  public void removeChannelCreatedListener(SlackChannelCreatedListener listener) {
    delegate.removeChannelCreatedListener(listener);
  }

  @Override
  public void addChannelDeletedListener(SlackChannelDeletedListener listener) {
    delegate.addChannelDeletedListener(listener);
  }

  @Override
  public void removeChannelDeletedListener(SlackChannelDeletedListener listener) {
    delegate.removeChannelDeletedListener(listener);
  }

  @Override
  public void addChannelRenamedListener(SlackChannelRenamedListener listener) {
    delegate.addChannelRenamedListener(listener);
  }

  @Override
  public void removeChannelRenamedListener(SlackChannelRenamedListener listener) {
    delegate.removeChannelRenamedListener(listener);
  }

  @Override
  public void addChannelUnarchivedListener(SlackChannelUnarchivedListener listener) {
    delegate.addChannelUnarchivedListener(listener);
  }

  @Override
  public void removeChannelUnarchivedListener(SlackChannelUnarchivedListener listener) {
    delegate.removeChannelUnarchivedListener(listener);
  }

  @Override
  public void addMessageDeletedListener(SlackMessageDeletedListener listener) {
    delegate.addMessageDeletedListener(listener);
  }

  @Override
  public void removeMessageDeletedListener(SlackMessageDeletedListener listener) {
    delegate.removeMessageDeletedListener(listener);
  }

  @Override
  public void addMessagePostedListener(SlackMessagePostedListener listener) {
    delegate.addMessagePostedListener(listener);
  }

  @Override
  public void removeMessagePostedListener(SlackMessagePostedListener listener) {
    delegate.removeMessagePostedListener(listener);
  }

  @Override
  public void addMessageUpdatedListener(SlackMessageUpdatedListener listener) {
    delegate.addMessageUpdatedListener(listener);
  }

  @Override
  public void removeMessageUpdatedListener(SlackMessageUpdatedListener listener) {
    delegate.removeMessageUpdatedListener(listener);
  }

  @Override
  public void addChannelJoinedListener(SlackChannelJoinedListener listener) {
    delegate.addChannelJoinedListener(listener);
  }

  @Override
  public void removeChannelJoinedListener(SlackChannelJoinedListener listener) {
    delegate.removeChannelJoinedListener(listener);
  }

  @Override
  public void addChannelLeftListener(SlackChannelLeftListener listener) {
    delegate.addChannelLeftListener(listener);
  }

  @Override
  public void removeChannelLeftListener(SlackChannelLeftListener listener) {
    delegate.removeChannelLeftListener(listener);
  }

  @Override
  public void addGroupJoinedListener(SlackGroupJoinedListener listener) {
    delegate.addGroupJoinedListener(listener);
  }

  @Override
  public void removeGroupJoinedListener(SlackGroupJoinedListener listener) {
    delegate.removeGroupJoinedListener(listener);
  }

  @Override
  public void addUserTypingListener(UserTypingListener listener) {
    delegate.addUserTypingListener(listener);
  }

  @Override
  public void removeUserTypingListener(UserTypingListener listener) {
    delegate.removeUserTypingListener(listener);
  }

  @Override
  public void addSlackConnectedListener(SlackConnectedListener listener) {
    delegate.addSlackConnectedListener(listener);
  }

  @Override
  public void removeSlackConnectedListener(SlackConnectedListener listener) {
    delegate.removeSlackConnectedListener(listener);
  }

  @Override
  public void addSlackDisconnectedListener(SlackDisconnectedListener listener) {
    delegate.addSlackDisconnectedListener(listener);
  }

  @Override
  public void removeSlackDisconnectedListener(SlackDisconnectedListener listener) {
    delegate.removeSlackDisconnectedListener(listener);
  }

  @Override
  public boolean isConnected() {
    return delegate.isConnected();
  }

  @Override
  public void addReactionAddedListener(ReactionAddedListener listener) {
    delegate.addReactionAddedListener(listener);
  }

  @Override
  public void removeReactionAddedListener(ReactionAddedListener listener) {
    delegate.removeReactionAddedListener(listener);
  }

  @Override
  public void addReactionRemovedListener(ReactionRemovedListener listener) {
    delegate.addReactionRemovedListener(listener);
  }

  @Override
  public void removeReactionRemovedListener(ReactionRemovedListener listener) {
    delegate.removeReactionRemovedListener(listener);
  }

  @Override
  public void addSlackUserChangeListener(SlackUserChangeListener listener) {
    delegate.addSlackUserChangeListener(listener);
  }

  @Override
  public void removeSlackUserChangeListener(SlackUserChangeListener listener) {
    delegate.removeSlackUserChangeListener(listener);
  }

  @Override
  public void addSlackTeamJoinListener(SlackTeamJoinListener listener) {
    delegate.addSlackTeamJoinListener(listener);
  }

  @Override
  public void removeSlackTeamJoinListener(SlackTeamJoinListener listener) {
    delegate.removeSlackTeamJoinListener(listener);
  }

  @Override
  public void addPinAddedListener(PinAddedListener listener) {
    delegate.addPinAddedListener(listener);
  }

  @Override
  public void removePinAddedListener(PinAddedListener listener) {
    delegate.removePinAddedListener(listener);
  }

  @Override
  public void addPresenceChangeListener(PresenceChangeListener listener) {
    delegate.addPresenceChangeListener(listener);
  }

  @Override
  public void removePresenceChangeListener(PresenceChangeListener listener) {
    delegate.removePresenceChangeListener(listener);
  }

  @Override
  public void addPinRemovedListener(PinRemovedListener listener) {
    delegate.addPinRemovedListener(listener);
  }

  @Override
  public void removePinRemovedListener(PinRemovedListener listener) {
    delegate.removePinRemovedListener(listener);
  }

  @Override
  public long getHeartbeat() {
    return delegate.getHeartbeat();
  }

  @Override
  public SlackMessageHandle sendRawMessageOverWebSocket(JsonObject messageJSON) {

    return delegate.sendRawMessageOverWebSocket(messageJSON);
  }

  @Override
  public SlackMessageHandle sendPresenceSubMessageOverWebSocket(String[] ids) {

    return delegate.sendPresenceSubMessageOverWebSocket(ids);
  }
}