def client(bot, client_type='bot'): """ Global Slack client. """ global _client team_name = bot.team.name if team_name not in _client: _client[team_name] = {} if bot.name not in _client[team_name]: _client[team_name][bot.name] = {} if bot.oauth_bot_token: _client[team_name][bot.name]['bot'] = slackclient.SlackClient( bot.oauth_bot_token ) if bot.oauth_user_token: _client[team_name][bot.name]['user'] = slackclient.SlackClient( bot.oauth_user_token ) if client_type == 'bot': try: return _client[team_name][bot.name]['bot'] except KeyError: pass elif client_type == 'user': return _client[team_name][bot.name]['user']
def __init__(self, slack_token): self.slack_token = slack_token self.sc = slackclient.SlackClient(slack_token) while not self.sc.rtm_connect(): logging.critical( 'Connection to slack failed, retrying in 5 minutes') time.sleep(300) self.sc = slackclient.SlackClient(slack_token)
def run(): # initialize slack client jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN) if jackbot_slack_client.rtm_connect(): print(SLACK_NAME + ' Initialized.') while True: try: event_list = jackbot_slack_client.rtm_read() except (TimeoutError, AttributeError, BrokenPipeError) as e: print('Connection lost. Reconnecting. Reason: ' + e.__class__.__name__) event_list = [] jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN) jackbot_slack_client.rtm_connect() except Exception as e: if e.__class__.__name__ == 'WebSocketConnectionClosedException': print('Connection lost. Reconnecting. Reason: ' + e.__class__.__name__) event_list = [] jackbot_slack_client = slackclient.SlackClient(SLACK_TOKEN) jackbot_slack_client.rtm_connect() else: raise if len(event_list) > 0: for event in event_list: type = event.get('type') # check if the event is a message if type and type == 'message': # get all the relevant parts of the event text = event.get('text') if text and isinstance(text, str): user = event.get('user') channel = event.get('channel') # split the message into words command_pieces = text.strip().split() # check if first word is bot mention if helper.is_command(command_pieces, user, SLACK_ID, slack_mention): # handle command options print(text) helper.handle_command(jackbot_slack_client, command_pieces, text, user, channel, commands) elif helper.is_mention(command_pieces, user, SLACK_ID, slack_mention): # handle non-command mention helper.handle_mention(jackbot_slack_client, command_pieces, text, user, channel) time.sleep(SOCKET_DELAY) else: print('[!] Connection to Slack failed.')
def _notify_slack(token, request): import os import json import traceback import slackclient try: # token might be a file token_file = os.path.expanduser(os.path.expandvars(token)) if os.path.isfile(token_file): with open(token_file, "r") as f: token = f.read().strip() if "attachments" in request and not isinstance(request["attachments"], six.string_types): request["attachments"] = json.dumps([request["attachments"]]) sc = slackclient.SlackClient(token) res = sc.api_call("chat.postMessage", **request) if not res["ok"]: logger.warning("unsuccessful Slack API call: {}".format(res)) except Exception as e: t = traceback.format_exc() logger.warning("could not send Slack notification: {}\n{}".format( e, t))
def handle(self, *args, **kwargs): """Handle bot.""" del args, kwargs ws_delay = 1 self.slack_client = slackclient.SlackClient(settings.SLACK_BOT_TOKEN) if self.slack_client.rtm_connect(): try: LOGGER.debug('Fluid Integrates Bot connected and running!') start_msg = 'Fluid Integrates Admin Bot now available.' self.slack_client.api_call('chat.postMessage', channel=CHANNEL, text=start_msg, as_user=True) while True: command, channel, user = \ parse_slack_output(self.slack_client.rtm_read()) if command and channel and user: self.handle_command(command, channel, user) time.sleep(ws_delay) except KeyboardInterrupt: bye_msg = 'Fluid Integrates admin bot has disconnected.' self.slack_client.api_call('chat.postMessage', channel=CHANNEL, text=bye_msg, as_user=True) else: LOGGER.error('Connection failed. Invalid Slack token or bot ID?')
def __init__(self, logger=None): super().__init__() self.logger = logger or logging.getLogger(__name__) self.logger.info('bot initialized!') # Setup some bot metadata # These are optional and will overwrite what the slack bot has. self.name = settings.BOT_NAME self.emoji = settings.BOT_EMOJI # When we instantiate a new bot object, we can access the app # credentials we set earlier in our local development environment. self.oauth = { "client_id": settings.CLIENT_ID, "client_secret": settings.CLIENT_SECRET, # Scopes provide and limit permissions to what our app # can access. It's important to use the most restricted # scope that your app will need. "scope": settings.SCOPE } self.verification = os.environ.get("VERIFICATION_TOKEN") # NOTE: Python-slack requires a client connection to generate # an oauth token. We can connect to the client without authenticating # by passing an empty string as a token and then reinstantiating the # client with a valid OAuth token once we have one. self.client = slackclient.SlackClient("") # BotId is used to ignore messages from self, will be retrieved # automatically once the OAuth token has been retrieved and installed. self.botId = ''
def __init__(self): self.now = datetime.datetime.now() # print(self.now) self.client = slck.SlackClient(os.getenv('SLACK_BOT_TOKEN')) print("Slack bot authenticated!\nrequesting channel list...") self.channel_list = self.list_channels() print("{num} channels received!\nQuerying channels...".format( num=len(self.channel_list))) # print(self.channel_list) self.messages_ch_list = self.list_messages("year") if len(self.messages_ch_list) == 0: self.messages_ch_list = self.list_messages("month") if len(self.messages_ch_list) > 0: self.message = self.messages_ch_list[self.max_emoji_msg()] self.decorated_message = self.decorate_msg() self.post_msg() else: msg = "DAMN! You guys should be talking more..." channel_id = 'random' for ch in self.channel_list: if ch[CH_NAME] == 'random': channel_id = ch[CH_ID] break self.client.api_call(method="chat.postMessage", channel=channel_id, text=msg, username="******")
def execute(self): self.print_title() try: if self.should_notify_a_new_release: if not self.version: raise Exception("The version is missing") if not self.token or not self.channel: self.log_warning( "Slack token or channel is not specified and therefore, no notification will be sent" ) return True self.log_info("Announcing release [%s] on channel %s" % (str(self.version), str(self.channel))) payload = self.message.format(version=str(self.version)) sc = slackclient.SlackClient(self.token) sc.api_call( 'chat.postMessage', channel=str(self.channel), text=payload, ) else: self.log_info("This is not a new release") except: self.log_error('Failed to notify of a new release') return False self.log_info("Done.") return True
def start(self): """Run the Slack network connection.""" self.client = slackclient.SlackClient(self.api_token) self.client.rtm_connect() while True: try: for response in self.client.rtm_read(): self.log.debug(response) if all(x in response for x in ("text", "channel", "user")): r_channel = response["channel"] r_user = response["user"] try: channel = self.client.server.channels.find( r_channel).name user = self.client.server.users.find(r_user).name except AttributeError: continue msg = response["text"] self.log.info("-#%s- <%s> %s" % (channel, user, msg)) _msg = message.Reply(self, msg, user, channel) plugin.poll_messages(self, _msg) time.sleep(.1) except Exception: # NOTE(jk0): Disconnected? Try to reconnect. self.client.rtm_connect() continue
def post_message_to_slack(self, channel, message, debug=False): slack_response = {} try: # SlackHQ Repository for integrating with the Slack API: # https://github.com/slackhq/python-slackclient import slackclient slack = slackclient.SlackClient(self.m_slack_token) slack_response = slack.api_call("chat.postMessage", channel=channel, text=message, username=self.m_bot_name, as_user=True) if "error" in slack_response: print "\nERROR: Slack API call had an error(" + str( slack_response["error"]) + ")\n" except Exception, e: err_msg = "Failed to post message to slack with Ex(" + str( e) + ") SlackResponse(" + str(slack_response) + ")" print "ERROR: " + str(err_msg)
def __init__(self, proxy, token: str) -> None: self.client = slackclient.SlackClient(token) self.proxy = proxy self.users = self.get_usermap() self.channels, self.id_map = self.get_channels() self.membership = {} self.connect()
def run(self): self.slackclient = slackclient.SlackClient(self.api_key) connect = self.slackclient.rtm_connect() if connect: self.connected = True self.id = self.slackclient.server.users.find( self.slackclient.server.username) while True: try: msg = self.send_queue.get(block=False) self.slackclient.rtm_send_message( self.get_channel(), Config["servername"] + "> " + msg) except queue.Empty: responses = self.slackclient.rtm_read() if responses == []: continue for msg in responses: try: if msg['type'] == 'message': self._slack_respond(msg) except KeyError: continue finally: time.sleep(0.1) else: raise Exception("Could not connect to Slack.")
def setup(slack, channel): logging.debug('Setting up Slack Bot.') global slack_client slack_client = slackclient.SlackClient(slack['api_key']) logging.debug('\tSetting Slack API key.') logging.debug('\tSetting Slack channel name.') global channel_name channel_name = channel
def run(self): self.slack = slackclient.SlackClient(self.slack_token) self.timestamp = self.get_last_bot_comment() if not self.slack.rtm_connect(): raise RuntimeError('Could not connect to Slack RTM') while self.slack.server.connected is True: self.refresh_slack() sleep(5)
def get_client_from_env_token(): slack_token = os.environ.get('SLACK_TOKEN') if slack_token is None: message = 'Environment variable SLACK_TOKEN is absent. Abort.' print(message) logging.error(message) sys.exit(1) return slackclient.SlackClient(slack_token)
def init(cls, token): log.info('Initializing slack bot with token') try: cls.slack_client = slackclient.SlackClient(token=token) log.info('Successfully initialized slack bot with token') except Exception as e: log.error('Error initializing slack bot with token. Error: %s', e) raise e
def check_notification(): sc = slackclient.SlackClient(settings.token) if sc.rtm_connect(): while True: get_alert(sc.rtm_read()) # send dictionary # print sc.rtm_read() else: print "Connection Failed, invalid token?"
def _connect_slack(self, token): if not token: raise Exception("Can't find a token to connect to Slack.") try: return slackclient.SlackClient(token) except Exception as e: self._logger.error("Error connecting to Slack: ", e) raise
def _api_call(method, **kwargs): """Function for creating the slack client and doing the actual API call""" if 'SLACK_API_TOKEN' in kwargs: token = kwargs.get('SLACK_API_TOKEN') else: token = os.environ.get('SLACK_API_TOKEN') sc = slackclient.SlackClient(token) return sc.api_call(method, **kwargs)
def _send_message_to_slack(msg): sc = slackclient.SlackClient(token=NFC_BOT_TOKEN) sc.api_call( 'chat.postMessage', channel='#pool', text=msg, username='******', as_user=True, )
def _connect_slack_client(self): self.slacker = slackclient.SlackClient(self.config.slack_client_token) resp = self._send_slack_message("fuzzer started with log " + self.log_file_name) if not resp["ok"]: self.config.root_logger.log( logging.ERROR, "failed to connect slack client to channel " + self.config.slack_channel + " with token " + self.config.slack_client_token)
def __init__(self, token): """ Initialize the Slack object given the provided bot token :param token: :param config: """ self.config = get_config('slack.json') self.client = slackclient.SlackClient(token) self.commands = self.load_commands('/jalbot/src/commands/')
def __init__(self, token, init=False): self.last_ping = 0 self.slack = slackclient.SlackClient(token) self.slack.rtm_connect() if init: self.init() self.plugins = get_plugins(self.slack)
def _fetch_slack_client(config, secrets): try: slack_token = config.slack.token slack_token = slack_token.strip() except AttributeError: return None else: if not slack_token: return None return slackclient.SlackClient(slack_token)
def slack_client(): import hubcommander.bot_components.slack_comm sc = slackclient.SlackClient("testtoken") sc.api_call = MagicMock(side_effect=slack_client_side_effect) # Need to fix both: hubcommander.bot_components.SLACK_CLIENT = sc hubcommander.bot_components.slack_comm.bot_components.SLACK_CLIENT = sc return sc
def __init__(self, token, user): self._client = slackclient.SlackClient(token) self._user = user self._api_call = self._client.api_call if self._client.rtm_connect(): print("Flipbot connected and running!") self._find_users() self._flipper = FlipMarkedupText(self._users) else: print("Connection failed. Invalid Slack token or bot ID?")
def __init__(self, config: Dict[str, Any]) -> None: token = config['slack']['api_token'] self.slack_client = slackclient.SlackClient(token) self.kafka_consumer = kafka.KafkaConsumer( config['kafka']['to_slack']['topic'], bootstrap_servers=config['kafka']['bootstrap_servers'], group_id=config['kafka']['to_slack']['group_id'], )
def __init__(self, token): super(SlackClient, self).__init__() self._log = logging.getLogger(__name__) self.users = dict() self.conversations = dict() self.sleep_time = 0.33 self._notify_on_hello = True self._run = True self._token = token self._slack = slackclient.SlackClient(self._token)
def __init__(self, config_dict, last_message=0): """Construct a new Slack channel message receiver using the given configuration dict and an optional last-message timestamp (unix seconds). """ self.config = SlackConfig(config_dict) self.slack = client.SlackClient(self.config.token) self.channel_id = find_channel_id(self.slack, self.config.channel) if self.channel_id is not None: self.slack.api_call('channels.join', channel=self.channel_id)
def __init__(self, config): """Construct a new Slack channel message sender using the given configuration dict to specify a token and channel name. """ self.config = config self.slack = client.SlackClient(config.token) self.channel_id = find_channel_id(self.slack, config.channel) if self.channel_id is not None: self.slack.api_call('channels.join', channel=self.channel_id)