# To handle requests from flask import Flask # Load the .env file and read values env_path = Path('.') / '.env' load_dotenv(dotenv_path=env_path) SIGNING_SECRET = os.environ['SIGNING_SECRET'] SLACK_TOKEN = os.environ['SLACK_TOKEN'] WEATHER_SECRET = os.environ['WEATHER_SECRET'] #Create the flask application app = Flask(__name__) #Configure the flask app to connect with Slack slack_event_adapter = SlackEventAdapter(SIGNING_SECRET, '/slack/events', app) client = slack.WebClient(token=SLACK_TOKEN) # THIS_BOT_ID = client.api_call("auth.test")['user_id'] #Generic function to send a message def message(msg, channel_id): client.chat_postMessage(channel=channel_id, text=str(msg)) #Send a welcome message on start now = datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)") message("[" + now + "] Bot started on this channel.", "ram-bot")
#report questions to ask chainmessages = custom.reportquestions SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN") SLACK_SIGNIN_SECRET = os.getenv("SLACK_SIGNIN_SECRET") SLACK_VERIFICATION_TOKEN = os.getenv("SLACK_VERIFICATION_TOKEN") context = (os.getenv("certificate"), os.getenv("private_key")) # Slack client slack_client = SlackClient(SLACK_BOT_TOKEN) # Flask web server for incoming traffic from Slack app = Flask(__name__) slack_events_adapter = SlackEventAdapter(SLACK_SIGNIN_SECRET, "/slack/events", app) #greetings and commands list greetings = ['Hello! ', 'Hey', 'Glad', 'Hai'] commands = ['hello', 'hello', 'help', 'joke'] #schduling messages schedule.every().day.at(custom.time1).do(remind.reminder, '0', slack_client) schedule.every().day.at(custom.time2).do(remind.reminder, '0', slack_client) schedule.every(3).seconds.do(remind.sendreminder, slack_client) def _reminders(): """
HOST = os.environ['RABBITMQ_HOST'] connection = pika.BlockingConnection(pika.ConnectionParameters(host=HOST)) channel = connection.channel() #Creamos el exchange 'nestor' de tipo 'fanout' channel.exchange_declare(exchange='nestor', exchange_type='topic', durable=True) ########### APLICACION WEB FLASK ############ # Initialize a Flask app to host the events adapter app = Flask(__name__) # Create an events adapter and register it to an endpoint in the slack app for event injestion. slack_events_adapter = SlackEventAdapter( os.environ.get("SLACK_SIGNING_SECRET"), "/slack/events", app) print(os.environ.get("SLACK_SIGNING_SECRET")) # Initialize a Web API client slack_web_client = WebClient(token=os.environ.get("SLACK_TOKEN")) print(os.environ.get("SLACK_TOKEN")) # An example of one of your Flask app's routes @app.route("/") def hello(): return "Hello there!"
from flask import Flask from slackclient import SlackClient from slackeventsapi import SlackEventAdapter import wolframalpha client = wolframalpha.Client('{WOLFRAM_API_KEY}') # This is the Flask instance that our event handler will be bound to # If you don't have an existing Flask app, the events api adapter # will instantiate it's own Flask instance for you app = Flask(__name__) # Our app's Slack Event Adapter for receiving actions via the Events API SLACK_VERIFICATION_TOKEN = "{SLACK_VERIFICATION_TOKEN}" slack_events_adapter = SlackEventAdapter(SLACK_VERIFICATION_TOKEN, "/slack/events", app) # Create a SlackClient for your bot to use for Web API requests SLACK_BOT_TOKEN = "{SLACK_API_KEY}" slack_client = SlackClient(SLACK_BOT_TOKEN) # ------------------------------------------------------------------------------ @slack_events_adapter.on("message") def handle_message(event_data): message = event_data["event"] if message.get("subtype") is None: # Initialize the answer variable answer = "" # Input/Question from the user
import logging import logging.config from typing import Callable, List from concurrent.futures import ThreadPoolExecutor from slackeventsapi import SlackEventAdapter from flask import Flask, request import slackbot_settings as conf import plugins.hato as hato import plugins.analyze as analyze from library.clientclass import SlackClient, ApiClient from library.database import Database app = Flask(__name__) slack_events_adapter = SlackEventAdapter( signing_secret=conf.SLACK_SIGNING_SECRET, endpoint="/slack/events", server=app) def __init__(): log_format_config = { 'format': '[%(asctime)s] %(message)s', 'datefmt': '%Y-%m-%d %H:%M:%S', 'level': logging.DEBUG, 'stream': sys.stdout, } logging.basicConfig(**log_format_config) logging.getLogger('requests.packages.urllib3.connectionpool').setLevel( logging.WARNING) def analyze_slack_message(messages: List[dict]) -> Callable[[SlackClient], None]:
sys.path.append(os.path.join(os.path.dirname(__file__), "lib")) # Init app = Flask(__name__) slack_bot_token = os.environ['SLACK_BOT_TOKEN'] slack_channel = os.environ['SLACK_CHANNEL'] signing_secret = os.environ['SIGNING_SECRET'] # set routes @app.route('/') def hello(): return 'Hello, World!' slack_event_adapter = SlackEventAdapter(signing_secret, '/slack/events', app) @slack_event_adapter.on('message') def get_event_subscriptions(events_subscription_payload): event = events_subscription_payload.get('event', {}) if event.get('channel') == slack_channel: print(event) if 'bot_id' not in event: # only process non bot messages process_event(event) def process_event(event): text = event.get('text') response = process_text(text) if response is not None:
# slack import slack from slackeventsapi import SlackEventAdapter from flask import Flask # API calls import requests import enchant dic = enchant.Dict('en_US') env_path = Path('.') / '.env' load_dotenv(dotenv_path=env_path) app = Flask(__name__) slack_event_adapter = SlackEventAdapter(os.environ['SIGNING_SECRET'], '/slack/events', app) client = slack.WebClient(token=os.environ['SLACK_TOKEN']) bot_id = client.api_call("auth.test")["user_id"] welcome_messages = {} class WelcomeMessage: START_TEXT = { 'type': 'section', 'text': { 'type': 'mrkdwn', 'text': ('Welcome to this cool Channel! \n\n' '*Get started by completing the tasks!*') }
import os from slackeventsapi import SlackEventAdapter from slackclient import SlackClient slack_signing_secret = os.environ["SLACK_SIGNING_SECRET"] slack_events_adapter = SlackEventAdapter(slack_signing_secret, "/slack/events") slack_bot_token = os.environ["SLACK_BOT_TOKEN"] slack_client = SlackClient(slack_bot_token) _CHANNEL = "introductions" _REACTION = "wave" @slack_events_adapter.on("message") def handle_message(event_data): message = event_data["event"] if message.get("subtype") is None and message["channel"] == _CHANNEL: slack_client.api_call("reactions.add", channel=channel, name=_REACTION, timestamp=message["ts"]) @slack_events_adapter.on("error") def error_handler(err): print("ERROR: " + str(err)) slack_events_adapter.start(port=3000)
import os import logging from flask import Flask from slack import WebClient from slackeventsapi import SlackEventAdapter from jamesbot import JamesBot # Initialize a Flask app to host the events adapter app = Flask(__name__) # Create an events adapter and register it to an endpoint in the slack app for event injestion. slack_events_adapter = SlackEventAdapter(os.environ.get("SLACK_EVENTS_TOKEN"), "/slack/events", app) # Initialize a Web API client slack_web_client = WebClient(token=os.environ.get("SLACK_TOKEN")) def say_hola(channel): # Create a new JamesBot james_bot = JamesBot(channel) # Get the onboarding message payload message = james_bot.get_message_payload() # Post the onboarding message in Slack slack_web_client.chat_postMessage(**message) # When a 'message' event is detected by the events adapter, forward that payload # to this function. @slack_events_adapter.on("message")
class Bot: def __init__(self, bot_token, signing_secret, timezone=None, alt_names=[]): scheduler_options = {} if timezone: scheduler_options['timezone'] = timezone self.scheduler = BackgroundScheduler(**scheduler_options) if not bot_token.startswith('xoxb-'): raise Exception("slappy >= 0.5 supports bot tokens only, you provided: " + bot_token[:5]) self.sc = SlackClient(bot_token) self.slack_events_adapter = SlackEventAdapter( signing_secret, endpoint="/slack/events" ) self.alt_names = alt_names self.bot_id = self.get_bot_id() self.dispatcher = Dispatcher(self.bot_id, self.alt_names) def get_bot_id(self): response = self.sc.api_call('auth.test') if not response['ok']: raise Exception(response['error']) return response['user_id'] @property def flask_app(self): return self.slack_events_adapter.server # Decorators def listen_to(self, regex): def wrap(f): self.dispatcher.register_listener(Listener(regex, f)) return f return wrap def respond_to(self, regex): def wrap(f): self.dispatcher.register_listener(Listener(regex, f, mention_only=True)) return f return wrap def schedule(self, trigger, **kwargs): def wrap(f): def job(*args, **kwargs): try: f(*args, **kwargs) self.cleanup_on_anything() except Exception: self.cleanup_on_exception() raise self.scheduler.add_job(job, trigger, **kwargs) return wrap def action(self, regex): def wrap(f): self.dispatcher.register_action(regex, f) return wrap def command(self, name): def wrap(f): self.dispatcher.register_command(name, f) return f return wrap # Public helper methods def send_message(self, **kwargs): result = self.sc.api_call('chat.postMessage', **kwargs) if not result['ok']: raise Exception(str(result)) # Run and internal methods def process_message(self, msg): if 'bot_id' in msg: return msg = Message(msg, self.sc) try: self.dispatcher.process_message(msg) self.cleanup_on_anything() except Exception as e: traceback.print_exc() self.cleanup_on_exception() msg.reply('Что-то пошло не так: ```{}```'.format(str(e))) def run(self, host='127.0.0.1', port=None): self.scheduler.start() @self.flask_app.route('/slack/action', methods=['POST']) def act(): payload = json.loads(request.form['payload']) try: result = self.dispatcher.process_action(payload) self.cleanup_on_anything() except Exception: self.cleanup_on_exception() raise if not result: return '' return jsonify(result) @self.flask_app.route('/slack/command', methods=['POST']) def command(): payload = request.form try: result = self.dispatcher.process_command(payload) self.cleanup_on_anything() except Exception as e: self.cleanup_on_exception() return 'Что-то пошло не так: ```{}```'.format(str(e)) if type(result) == str: return result else: return jsonify(result) @self.slack_events_adapter.on("message") def on_event(event): logger.debug(event['event']) if request.headers.get('X-Slack-Retry-Reason') == 'http_timeout': logger.warning('Got a retry request because of timeout') return self.process_message(event['event']) self.slack_events_adapter.start(host=host, port=port) # override this method to remove sqlalchemy sessions etc. after exceptions def cleanup_on_exception(self): pass # override this method to remove sqlalchemy sessions etc. after a normal action # (I'm having issues even though I'm using Flask-SQLAlchemy for some reason) def cleanup_on_anything(self): pass
import subprocess import slack import os from time import sleep, time import asyncio import threading import logging from flask import Flask, request, Response app = Flask(__name__) # logging.basicConfig(level=logging.INFO) # Our app's Slack Event Adapter for receiving actions via the Events API slack_signing_secret = os.environ["SLACK_SIGNING_SECRET"] slack_events_adapter = SlackEventAdapter(slack_signing_secret, "/serbot/slack/events") # Create a SlackClient for your bot to use for Web API requests slack_bot_token = os.environ["SLACK_BOT_TOKEN"] slack_client = slack.WebClient(token=slack_bot_token) events = [] @slack_events_adapter.on("app_mention") def handle_mention(event_data): logger.info("event {}".format(event_data)) events.append(event_data) def process_commands():
import os from beautifultable import BeautifulTable import dlpy from slackclient import SlackClient from slackeventsapi import SlackEventAdapter slack_events_adapter = SlackEventAdapter( os.environ['SLACK_VERIFICATION_TOKEN'], '/slack/events') CLIENT = SlackClient(os.environ['TOKEN']) def format_message_to_table(message): table = BeautifulTable() table.column_headers = ['info_type', 'finding'] try: for msg in message.findings: msg.location.byte_range.start table.append_row([msg.info_type.name, msg.likelihood]) except Exception as e: print(e) return None return table @slack_events_adapter.on('message') def handle_message(event_data):
import json from flask import Response from slackeventsapi import SlackEventAdapter from app import app from .utils import setup_mq slack_events_adapter = \ SlackEventAdapter(app.config["SLACK_SIGNING_SECRET"], "/", app) @slack_events_adapter.on("app_mention") def handle_app_mention(event_data): """ This method handles event, app_mention of the slack bot Natalie. It sends a message to the consumer via message queue and returns success response with a header to inform Slack to not retry anymore. :param event_data: :return: Success Response """ channel, connection = setup_mq(app.config) channel.basic_publish(exchange=app.config["EXCHANGE"], routing_key=app.config["ROUTING_KEY"], body=json.dumps(event_data)) response = Response(status=200) response.headers['X-Slack-No-Retry'] = 1 print("Sent Response") connection.close()
from config import Config app.config.from_object('config.Config') # Define the database object which is imported # by modules and controllers db = SQLAlchemy(app) # Import Flask-Migrate and intialise it from flask_migrate import Migrate migrate = Migrate() migrate.init_app(app, db) # Import SlackEventsAdapter and set it up from slackeventsapi import SlackEventAdapter slack_events_adapter = SlackEventAdapter(Config.SLACK_SIGNING_SECRET, "/slack/events", server=app) # Set up the slack client from slack import WebClient client = WebClient(Config.SLACK_BOT_TOKEN) user_client = WebClient(Config.SLACK_USER_TOKEN) # Import a module using its blueprint handler variable from app.server import slack # Register blueprint app.register_blueprint(slack) # Build the database: # This will create the database file using SQLAlchemy
from slack import WebClient from speedy import speedyBot from slackeventsapi import SlackEventAdapter import pymongo import logging import os DATABASE = "speedy_mensajes" # app = Flask(__name__) slack_events_adapter = SlackEventAdapter(os.environ['SLACK_SIGNING_SECRET'], endpoint="/slack/eventos") slack_web_client = WebClient(token=os.environ['SLACK_TOKEN']) onboarding_tutorials_sent = {} def start_onboarding(user_id: str, channel: str): # Create a new onboarding tutorial. speedy_bot = speedyBot(channel) # Get the onboarding message payload message = speedy_bot.get_message_payload() # Post the onboarding message in Slack response = slack_web_client.chat_postMessage(**message) # Capture the timestamp of the message we've just posted so # we can use it to update the message after a user # has completed an onboarding task. speedy_bot.timestamp = response["ts"]
from slackeventsapi import SlackEventAdapter import slack import os # Our app's Slack Event Adapter for receiving actions via the Events API slack_signing_secret = os.environ["SLACK_SIGNING_SECRET"] slack_events_adapter = SlackEventAdapter(slack_signing_secret, "/slack/events") # Create a SlackClient for your bot to use for Web API requests token = os.environ["SLACK_TOKEN"] slack_client = slack.WebClient(token=token) @slack_events_adapter.on("app_mention") def handle_mention(event_data): event = event_data["event"] channel = event["channel"] user = event["user"] message = "<@%s> :zipper_mouth_face:" % (user) slack_client.chat_postMessage(channel=channel, text=message) # Once we have our event listeners configured, we can start the # Flask server with the default `/events` endpoint on port 3000 PORT = os.environ["PORT"] slack_events_adapter.start(host="0.0.0.0", port=PORT) #This is just a new comment
import os from dotenv import load_dotenv from slack import WebClient from slackeventsapi import SlackEventAdapter load_dotenv() SLACK_SIGNING_SECRET = os.environ['SLACK_SIGNING_SECRET'] SLACK_API_TOKEN = token = os.environ['SLACK_API_TOKEN'] slack_client = WebClient(SLACK_API_TOKEN) RECEIVER_ID = slack_client.auth_test()['user_id'] slack_events_adapter = SlackEventAdapter(SLACK_SIGNING_SECRET, "/webmonitor/events") # Create an event listener for "message" events @slack_events_adapter.on('message') def message_event_handler(payload): event = payload.get('event') channel_id = event.get('channel') user_id = event.get('user') user_info = slack_client.users_info(user=user_id) user_name = user_info.get('user').get('name') if (RECEIVER_ID != user_id): response = f'Welcome <@{user_name}>! :wave:' slack_client.chat_postMessage(channel=channel_id, text=response)
def app(): adapter = SlackEventAdapter("SIGNING_SECRET") app = adapter.server app.testing = True return app
from slackclient import SlackClient import json, jenkins, time, re import requests, time tokens = {} with open('configs.json') as json_data: tokens = json.load(json_data) #Slack channels devops_channel = ['<input slack channel ID here !!!>'] dev_channel = ['<input slack channel ID here !!!>'] # Fixed tokens dev_assist_msg = "\nFor you convenience in CI/CD ,I can assist you in the following tasks :construction_worker::\n1. Use *\"@Jenkins view <viewName>\"* to list all the jobs in given view.\n2. Use *\"@Jenkins list view\"* to list all the view.\n3. Use *\"@Jenkins list jobs\"* to list all jobs in jenkins.\n4. Use *\"@Jenkins list plugins\"* to list all the plugins with installed version." devops_assist_msg = "\nFor you convenience in CI/CD ,I can assist you in the following tasks :construction_worker::\n1. Use *\"@Jenkins build <jobName>\"* to build the job.\n2. Use *\"@Jenkins view <viewName>\"* to list all the jobs in given view.\n3. Use *\"@Jenkins list view\"* to list all the view.\n4. Use *\"@Jenkins list jobs\"* to list all jobs in jenkins." slack_events_adapter = SlackEventAdapter( str(tokens.get("slack_signing_secret")), "/slack/events") slack_client = SlackClient(str(tokens.get("slack_bot_token"))) def get_jenkins_instance(): try: instance = jenkins.Jenkins(str(tokens.get('url')), username=str(tokens.get('username')), password=str(tokens.get('password'))) return instance except Exception as e: print('login error') #raise Exception("Sorry!!! Error occured in processing request :no_mouth:.\nPlease contact the DevOps Team.:computer:") # Template Data
from flask_migrate import Migrate # Slack from slackeventsapi import SlackEventAdapter # Env constants SLACK_SIGNING_SECRET = environ['SLACK_BOT_SIGNING_SECRET'] APP_SECRET_KEY = environ['APP_SECRET_KEY'] DB_SECRET_KEY = environ['DB_SECRET_KEY'] # Logger config logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) logger = logging.getLogger(__name__) # Flask app flask_app = Flask(__name__) flask_app.config.from_object(Config) flask_app.secret_key = APP_SECRET_KEY db = SQLAlchemy(flask_app) db_secret = DB_SECRET_KEY migrate = Migrate(flask_app, db) # Slack slack_events_adapter = SlackEventAdapter(SLACK_SIGNING_SECRET, "/api/bot", flask_app) from app import routes, models # noqa from app.commands.event_message import message_handler # noqa
def create_app(test_config=None): """Create the flask app""" logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(threadName)s - %(name)s - %(levelname)s - %(message)s', handlers=[RotatingFileHandler('modron.log', mode='a', maxBytes=1024 * 1024 * 2, backupCount=1), logging.StreamHandler(sys.stdout)]) logger = logging.getLogger(__name__) # Load the system configuration config = get_config() # Record the start time, used for status information start_time = datetime.now() # Get the secure tokens OAUTH_ACCESS_TOKENS = os.environ.get('OAUTH_ACCESS_TOKENS') SIGNING_SECRET = os.environ.get('SLACK_SIGNING_SECRET') CLIENT_SECRET = os.environ.get('CLIENT_SECRET') CLIENT_ID = os.environ.get('CLIENT_ID') # Make the Flask app app = Flask('modron', template_folder='./views/templates', static_folder="./views/static") app.jinja_env.filters['quote_plus'] = quote_plus app.secret_key = CLIENT_SECRET def get_netloc(url): p = urlparse(url) return f'{p.scheme}://{p.netloc}' app.jinja_env.filters['get_netloc'] = get_netloc app.jinja_env.filters['humanize_td'] = humanize.naturaldelta app.jinja_env.filters['humanize_size'] = humanize.naturalsize # Store some details about the runtime configuration app.config['start_time'] = start_time app.config['team_config'] = config app.config['CLIENT_SECRET'] = CLIENT_SECRET app.config['CLIENT_ID'] = CLIENT_ID # Register the views from .views import status, auth, players app.register_blueprint(status.bp) app.register_blueprint(auth.bp) app.register_blueprint(players.bp) # Store the clients clients = {} app.config['clients'] = clients # Make the Slack client and Events adapter if OAUTH_ACCESS_TOKENS is None: logger.warning('OAUTH_ACCESS_TOKENS was unset. Skipping all Slack-related functionality') return app for token in OAUTH_ACCESS_TOKENS.split(":"): client = BotClient(token=token) client.team_info() clients[client.team_id] = client event_adapter = SlackEventAdapter(SIGNING_SECRET, "/slack/events", app) logger.info(f'Finished initializing {len(clients)} Slack clients') # Check that we have configurations for each team authed_teams = set(clients.keys()) missing_config = authed_teams.difference(config.team_options.keys()) if len(missing_config) > 0: raise ValueError(f'Missing configuration data for {len(missing_config)} teams: {", ".join(missing_config)}') # Make the services app.config['services'] = {'reminder': {}, 'backup': {}} reminder_threads = {} for team_id, team_config in config.team_options.items(): if team_id not in clients: logging.warning(f'Missing OAuth Token for {team_id}') continue client = clients[team_id] # Start the reminder thread if team_config.reminders: reminder = ReminderService(clients[team_id], team_config.reminder_channel, team_config.watch_channels) reminder.start() reminder_threads[team_id] = reminder app.config['services']['reminder'][team_config.name] = reminder else: logger.info(f'No reminders for {team_config.name}') # Start the backup thread if team_config.backup_channels is not None: backup = BackupService(client, frequency=timedelta(days=1), channel_regex=team_config.backup_channels) backup.start() app.config['services']['backup'][team_config.name] = backup else: logger.info(f'No backup for {team_config.name}') # Generate the slash command responder modules = [ DiceRollInteraction(clients), StatisticModule(clients), ReminderModule(clients, reminder_threads), NPCGenerator(clients), CharacterSheet(clients) ] modron_cmd_parser = assemble_parser(modules) @app.route('/modron', methods=('POST',)) def modron_slash_cmd(): payload = SlashCommandPayload(**request.form.to_dict()) return handle_slash_command(payload, parser=modron_cmd_parser) @app.route('/oauth', methods=('GET',)) def slack_auth(): # Get the request code from the user code = request.args.get('code', None) logger.info('Received an authorization code. About to exchange it for a token') # Query Slack to get the token res = requests.post( url="https://slack.com/api/oauth.v2.access", data={ 'code': code, 'client_secret': CLIENT_SECRET, 'client_id': CLIENT_ID, 'redirect_uri': request.base_url } ) with open('received-tokens.json', 'w') as fp: json.dump(res.json(), fp) return "Success!" # Register the events event_adapter.on('message', f=partial(status_check, clients=clients, start_time=start_time)) return app
""" Logging Bot is used in slack for logging team public channels """ import os import logging from flask import Flask from slack_sdk.web import WebClient from slackeventsapi import SlackEventAdapter from prometheus_flask_exporter import PrometheusMetrics import config from bot import LoggingBot # Initialize a Flask app to host the events adapter app = Flask(__name__) metrics = PrometheusMetrics(app) slack_events_adapter = SlackEventAdapter(config.SlackSigningSecret, "/slack/events", app) # Initialize a Web API client slack_client = WebClient(token=config.SlackBotToken) # send a test message to make sure we can access what we need slack_client.api_test() bot = LoggingBot(slack_client, config.TriggerWords, config.OnboardChannels, config.AdminGroups, config.AdminUsers, config.OnboardIgnoredUsers) @app.route("/ping") def ping(): return 'PONG'
# line from flask import Flask, request, abort, make_response from linebot.models import (MessageEvent, TextMessage, TextSendMessage, TemplateSendMessage, ButtonsTemplate, PostbackAction, MessageAction) from linebot.exceptions import (InvalidSignatureError) from linebot import (LineBotApi, WebhookHandler, WebhookParser) # slack 연동 정보 입력 부분 SLACK_TOKEN = "xoxb-724397827219-754129653299-FYMIlkI4Jfqt76xgVXBJ3PKf" SLACK_SIGNING_SECRET = "79316cda7ff225f6c6bf997419dc83fd" app = Flask(__name__) slack_events_adaptor = SlackEventAdapter(SLACK_SIGNING_SECRET, "/listening", app) slack_web_client = WebClient(token=SLACK_TOKEN) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # Line 연동 정보 입력 부분 line_bot_api = LineBotApi( 'Y33Wft4HcJ7XyxR89HhtIsT63sIf8p8sqZ2eY8yUZVbie6awKPWo1Jtmviv3tcibvogrZ03SE2aLCQdkWXQ5mK668ylm4Xi8yvCxiI/A1L7Gkv6ukKCpodV4s1ZXeRi1BSIahhFr2+KbvIp8Hi3CtAdB04t89/1O/w1cDnyilFU=' ) handler = WebhookHandler('b1feb1f2420d203cb748fad203dd3d41') Q_gag, A_gag = gag.read_gag() # 챗봇이 멘션을 받았을 경우 @slack_events_adaptor.on("app_mention")
import ssl from os import environ import certifi from flask import Flask from slack import WebClient from slackeventsapi import SlackEventAdapter from our_bot_expressive import CapPun # FIXME replace with your chatbot class # initialize the Flask app app = Flask(__name__) # initialize the Slack objects slack_events_adapter = SlackEventAdapter(environ['SLACK_SIGNING_SECRET'], '/slack/events', app) slack_web_client = WebClient(token=environ['SLACK_BOT_TOKEN']) global_state = { 'bot_id': slack_web_client.auth_test()['user_id'], 'partners': {}, } @slack_events_adapter.on('message') def message(payload): """Pass messages onto a per user, per channel chatbot instance.""" event = payload.get('event', {}) bot_id = global_state['bot_id'] channel_id = event.get('channel')
def adapter(): return SlackEventAdapter("SIGNING_SECRET")
import os import logging import json import requests from flask import Flask from slack import WebClient from slackeventsapi import SlackEventAdapter import ssl as ssl_lib import certifi app = Flask(__name__) slack_events_adapter = SlackEventAdapter(os.environ['SLACK_SIGNING_SECRET'], "/slack/events", app) # Initialize a Web API client client = WebClient(token=os.environ["SLACK_BOT_TOKEN"]) # ================ Team Join Event =============== # # When the user first joins a team, the type of the event will be 'team_join'. # Here we'll link the onboarding_message callback to the 'team_join' event. @slack_events_adapter.on("app_mention") def workflow(payload): """Create and send an onboarding welcome message to new users. Save the time stamp of this message so we can update this message in the future. """ # dictionary for channel channel_dict = { "President": "CTZMY1LS2", "Co-President": "CTZMY1LS2", "Vice-President": "CTZMY1LS2",
import os import btcprice from dotenv import load_dotenv from pathlib import Path from slackeventsapi import SlackEventAdapter from flask import Flask, request, Response # get secrets env_path = Path('.') / '.env' load_dotenv(dotenv_path=env_path) slack_key = os.getenv("SLACK_BOT_TOKEN") sign_sec = os.getenv("SIGNING_SECRET") # flask stuff app = Flask(__name__) slack_event_adapter = SlackEventAdapter(sign_sec, '/slack/events', app) # get price current_price = btcprice.getBitcoinPrice() print(current_price) # instantiate bot client = slack.WebClient(token=slack_key) BOT_ID = client.api_call("auth.test")['user_id'] # client.chat_postMessage(channel='#bottest', text="Monkey typewriters!") # @slack_event_adapter.on('message') # def message(payload): # print(payload)
import logging from flask import Flask from slack import WebClient from slackeventsapi import SlackEventAdapter import ssl as ssl_lib import certifi from logic import Adjutant # from onboarding_tutorial import OnboardingTutorial adjutant = Adjutant(pathlib.Path.cwd().joinpath('adjutant')) # Initialize a Flask app to host the events adapter app = Flask(__name__) slack_events_adapter = SlackEventAdapter( adjutant.memory['SLACK_SIGNING_SECRET'], endpoint="/slack/events", server=app) # Initialize a Web API client slack_web_client = WebClient(token=adjutant.memory['SLACK_BOT_TOKEN']) # # For simplicity we'll store our app data in-memory with the following data structure. # # onboarding_tutorials_sent = {"channel": {"user_id": OnboardingTutorial}} # onboarding_tutorials_sent = {} # # # def start_onboarding(user_id: str, channel: str): # # Create a new onboarding tutorial. # onboarding_tutorial = OnboardingTutorial(channel) # # # Get the onboarding message payload
from flask import Flask from slack import WebClient from slackeventsapi import SlackEventAdapter from botfunc import world_greeting BOT_FUNCTIONS = [ (r"^wgreet", world_greeting), ] # Flaskを作ってgunicornで動くようにする app = Flask(__name__) # Events APIの準備 slack_signing_secret = os.environ["SLACK_SIGNING_SECRET"] slack_events_adapter = SlackEventAdapter(slack_signing_secret, "/slack/events", app) # Web Client APIの準備 slack_bot_token = os.environ["SLACK_BOT_TOKEN"] slack_client = WebClient(slack_bot_token) @slack_events_adapter.on("message") def handle_message(event_data): message = event_data["event"] # subtypeがない場合=普通のメッセージ/botの返答メッセージには反応させない if message.get("subtype") is None and message.get("bot_id") is None: # botが返す結果の入れ物 bot_result = ""
def test_server_not_flask(): with pytest.raises(TypeError) as e: invalid_flask = "I am not a Flask" SlackEventAdapter("DFPK6Jejy3fOatPI2Z35qQzp", "/slack/events", invalid_flask) assert e.value.args[0] == 'Server must be an instance of Flask'