def run_slack_client():
app_token = os.environ.get("SLACK_APP_TOKEN")
if app_token:
from slack_bolt.adapter.socket_mode import SocketModeHandler
SocketModeHandler(slack_app, app_token).start()
else:
slack_app.start(port=3300)
def test_interactions(self):
t = Thread(target=start_socket_mode_server(self, 3011))
t.daemon = True
t.start()
time.sleep(2) # wait for the server
app = App(client=self.web_client)
result = {"shortcut": False, "command": False}
@app.shortcut("do-something")
def shortcut_handler(ack):
result["shortcut"] = True
ack()
@app.command("/hello-socket-mode")
def command_handler(ack):
result["command"] = True
ack()
handler = SocketModeHandler(
app_token="xapp-A111-222-xyz",
app=app,
trace_enabled=True,
)
try:
handler.client.ping_pong_trace_enabled = True
handler.client.wss_uri = "ws://127.0.0.1:3011/link"
handler.connect()
assert handler.client.is_connected() is True
time.sleep(2) # wait for the message receiver
handler.client.send_message("foo")
time.sleep(2)
assert result["shortcut"] is True
assert result["command"] is True
finally:
handler.client.close()
self.server.stop()
self.server.close()
"""
# Needed for the slash command
ack()
# Slash Command and team_join events store user_id differently
try:
user_id = body["user_id"]
except KeyError:
user_id = event["user"]["id"]
channel_id = welcome_config["channel"]
replacement_dict = {'user_id': user_id, 'channel_id': channel_id}
message_public = welcome_config["header"].format(**replacement_dict)
message_reply = welcome_config["fold"].format(**replacement_dict)
# get thread_ts from first say in order to send second message as a thread
thread_ts = say(text=message_public, channel=channel_id)["ts"]
say(text=message_reply, channel=channel_id, thread_ts=thread_ts)
welcome_config = load_welcome_config()
# connects, joins the designated welcome channel, and starts running
if __name__ == "__main__":
SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]).connect()
app.client.conversations_join(channel=welcome_config["channel"])
app.start()
# Check liveness
@app.event("app_mention")
def event_test(say):
say("Hi there!")
def strip_links(message):
for match in LINK_PATTERN.finditer(message):
message = re.sub(LINK_PATTERN, match.groups()[0], message, 1)
return message
@app.event("message")
def make_it_short(client, message):
channel_id = message["channel"]
if message["channel_type"] in ["group", "channel"
] and "thread_ts" not in message:
message_len = len(strip_links(message["text"]))
if message_len > CONSTS.MAX_MESSAGE_LEN:
result = client.chat_postMessage(
channel=channel_id,
thread_ts=message["ts"],
text=CONSTS.MAX_MESSAGE_COMMENT.format(
max_message_len=CONSTS.MAX_MESSAGE_LEN,
message_len=message_len,
manager=MANAGER))
if __name__ == "__main__":
SocketModeHandler(app, os.environ.get("SLACK_APP_TOKEN")).start()
def main():
database.connect()
database.create_models()
handler = SocketModeHandler(app, SLACK_APP_TOKEN)
handler.start()
def main():
SocketModeHandler(app, SLACK_SOCKET_TOKEN).start()
def record_end_break_command(ack, command, say):
ack()
record_end_break(say, SlackRequest.build_from_command(command))
# setting
@app.command("/employee-code")
def employee_code_command(ack, command, say):
ack()
register_employee_code(say, SlackRequest.build_from_command(command))
# misc
# FIX ME react only @mention
# @app.event("message")
# def handle_message_events(event, say):
# if re.search(r'感謝|ありがとう|好き|すごい', event['text']):
# be_shy(say)
# elif re.search(r'アレクサ|Alexa|alexa', event['text']):
# i_am_not_alexa(say)
# elif re.search(r'Hey Siri', event['text']):
# i_am_not_siri(say)
if __name__ == "__main__":
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
logger.info('start slackbot')
SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]).start()
logging.basicConfig(level=logging.DEBUG)
import os
from slack_sdk import WebClient
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
# pip3 install proxy.py
# proxy --port 9000 --log-level d
proxy_url = "http://*****:*****@app.event("app_mention")
def event_test(event, say):
say(f"Hi there, <@{event['user']}>!")
if __name__ == "__main__":
# export SLACK_APP_TOKEN=xapp-***
# export SLACK_BOT_TOKEN=xoxb-***
SocketModeHandler(
app=app,
app_token=os.environ["SLACK_APP_TOKEN"],
proxy=proxy_url,
).start()
def access_sheet():
"""
Access sheet according to sheet id provided.
Returns the sheet object
"""
scope = [
'https://www.googleapis.com/auth/spreadsheets',
'https://www.googleapis.com/auth/drive'
]
creds = ServiceAccountCredentials.from_json_keyfile_name(creds_file, scope)
client = gspread.authorize(creds)
sheet = client.open_by_key(excel_id)
return sheet
def readsheet():
"""
Accepts sheet name to be read
Returns sheet data object of the specified sheet.
"""
sheet = access_sheet()
worksheet = sheet.worksheet(sheet_name)
# sheet_data = worksheet.get_all_values()
return worksheet
if __name__ == "__main__":
SocketModeHandler(app, SLACK_APP_TOKEN).start()
def start(self):
logger.info("Starting slack socket mode...")
self.socket_mode = SocketModeHandler(self.bolt, self.app_token)
self.socket_mode.start()
class jibot_slack_app:
global slack_app_token, slack_bot_token, slack_bot_slash_command, slack_signing_secret, slack_port
bolt: App = None
app_dir: str = os.getcwd()
plugins_dir: str = app_dir + os.sep + 'plugins'
app_token: str = slack_app_token
bot_token: str = slack_bot_token
bot_slash_command: str = slack_bot_slash_command
signing_secret: str = slack_signing_secret
bot_user = None
channels = None
bot_channels: list = []
users = None
plugins: list = []
event_types: list = [
"action", "command", "event", "message", "shortcut", "view"
]
def __init__(self):
logger.info("Initializing slack...")
self.bolt = App(
signing_secret=self.signing_secret,
token=self.bot_token,
)
self.test_slack_client_connection()
self.who_is_bot()
self.get_slack_info()
self.bot_says_hi()
self.bolt.use(self.global_middleware_listener)
self.load_plugins()
try:
self.start()
except KeyboardInterrupt:
self.close()
def load_plugins(self):
logger.info("Loading slack plugins...")
plugin_files = glob.glob(self.plugins_dir + os.sep + "**" + os.sep +
"[!__]*.py",
recursive=True)
for plugin_path in plugin_files:
relative_path = os.path.relpath(plugin_path, os.getcwd())
import_path = relative_path.replace(".py", "").replace(os.sep, ".")
for event_type in self.event_types:
plugin = Plugin(event_type,
importlib.import_module(import_path))
if plugin.callback is not None:
if hasattr(self.bolt, plugin.type):
event_handler: callable = getattr(
self.bolt, plugin.type)
event_handler(plugin.keyword)(plugin.callback)
self.plugins.append(plugin)
def start(self):
logger.info("Starting slack socket mode...")
self.socket_mode = SocketModeHandler(self.bolt, self.app_token)
self.socket_mode.start()
def close(self):
logger.info("Disconnecting socket mode...")
self.bot_says_bye()
self.socket_mode.disconnect()
def test_slack_client_connection(self):
logger.info("Testing slack client connectivity...")
try:
self.bolt.client.api_test().get("ok")
logger.info("Slack client OK.")
except SlackApiError as e:
logger.error("Unable to establish a slack web client connection!")
self.slack_api_error(e)
def who_is_bot(self):
logger.info("Establishing bot presence...")
try:
bot_auth = self.bolt.client.auth_test(token=self.bot_token)
self.bot_user = self.bolt.client.users_info(
user=bot_auth.get("user_id")).get("user")
logger.info("Bot OK")
logger.debug(self.bot_user)
except SlackApiError as e:
self.slack_api_error(e)
def bot_says_hi(self):
logger.info("Announce bot presence in slack...")
if self.channels is not None:
for channel in self.channels:
try:
channel_members = self.bolt.client.conversations_members(
channel=channel.get('id')).get('members')
if self.bot_user is not None and self.bot_user.get(
'id') in channel_members:
self.bot_channels.append(channel)
self.bolt.client.chat_postMessage(
channel=channel.get('id'),
text=
f"Hello #{channel.get('name')}! I am waking up.")
except SlackApiError as e:
self.slack_api_error(e)
def bot_says_bye(self):
logger.info("Announce bot exit from slack...")
if self.bot_channels is not None:
for channel in self.bot_channels:
try:
self.bolt.client.chat_postMessage(
channel=channel.get('id'),
text=
f"Goodbye #{channel.get('name')}! I am shutting down.")
except SlackApiError as e:
self.slack_api_error(e)
def get_slack_info(self):
logger.info("Get info about slack team, channels, etc...")
if self.bot_user is not None:
team_id = self.bot_user.get("team_id", None)
try:
self.team = self.bolt.client.team_info(
team=team_id).get("team")
self.channels = self.bolt.client.conversations_list().get(
'channels')
self.users = self.bolt.client.users_list().get('members')
except SlackApiError as e:
self.slack_api_error(e)
def global_middleware_listener(self, payload: dict, next):
payload['plugins'] = self.plugins
next()
def slack_api_error(self, error: SlackApiError):
error_name = error.response['error']
assert (error_name)
if error_name == 'missing_scope':
missing_scope = error.response['needed']
message = f"The bot is missing proper oauth scope!({missing_scope}). Scopes are added to your bot at https://api.slack.com/apps."
logger.error(message)
logger.error(error)
@app.command("/parrotcheckhealth")
def parrotcheckhealth(client, ack, body, say):
t = "I'm running! Here is my terminal output: \n" \
"stdout\n```\n" \
+ open("/var/opt/slack-parrotbot/stdout").read() \
+ "```\nstderr\n```\n" \
+ open("/var/opt/slack-parrotbot/stderr").read() \
+ "```"
if "quiet" in body['text']:
ack(t)
else:
say(t)
ack()
if __name__ == "__main__":
for chan in app.client.conversations_list()['channels']:
if not (chan['is_im'] or chan['is_member'] or chan['is_archived']):
app.client.conversations_join(channel=chan['id'])
SocketModeHandler(
app,
open("/opt/slack-parrotbot/secrets/SLACK_APP_TOKEN").read()).start()
SocketModeHandler(
app,
open("/opt/slack-parrotbot/secrets/SLACK_APP_TOKEN").read()).start()
def send_dm(message, say, logger, context):
'''send DM
`@BOTNAME dm`
'''
user_id = message['user']
msg = 'test message'
client = WebClient(token=slack_user_token)
msgp.dm_write(user_id, msg, client, logger)
@app.event('message')
def nop(message, logger):
'''dump debug message when any message is posted in the slack
'''
logger.debug(str(message))
if __name__ == "__main__":
logger = logging.getLogger()
# logger.setLevel(logging.INFO)
# logger.setLevel(logging.DEBUG)
# log file
fh = logging.FileHandler('garie.log')
logger.addHandler(fh)
handler = SocketModeHandler(app, slack_app_token)
handler.start()
@app.event("message")
def processMessage(event, client):
"""Process users' commands"""
channel_id = event.get("channel")
user_id = event.get("user")
text = event.get("text")
non_slash(
text,
lambda x: client.chat_postMessage(**{
"channel": channel_id,
"username": user_id,
"text": x
}),
lambda x, y, z: ShowView().slack(x, channel_id, user_id, client, y, **z
),
)
if __name__ == "__main__":
# TODO: replace with GST logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
handler = SocketModeHandler(
app,
os.environ["GT_SLACK_BOT_TOKEN"],
)
handler.start()
print(app)
@app.command("/hello-socket-mode")
def hello_command(ack, body):
user_id = body["user_id"]
ack(f"Hi, <@{user_id}>!")
@app.event("app_mention")
def event_test(say):
say("Hi there!")
# This will match any message that contains 👋
@app.message(":wave:")
def say_hello(message, say):
user = message['user']
say(f"Hi there, <@{user}>!")
# Listens for messages containing "knock knock" and responds with an italicized "who's there?"
@app.message("knock knock")
def ask_who(message, say):
say("_Who's there?_")
if __name__ == "__main__":
SocketModeHandler(app, app_token).start()
