# 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'
