def create_slack_client(config: SlackConversationConfiguration,
run_async: bool = False):
"""Creates a Slack Web API client."""
if not run_async:
return slack_sdk.WebClient(
token=config.api_bot_token.get_secret_value())
return AsyncWebClient(token=config.api_bot_token.get_secret_value())
def push_emoji(slack_name: str, emoji_name: str, emoji_url: str) -> None:
client = slack_sdk.WebClient(token=os.environ[f"{slack_name}_SLACK_TOKEN"])
try:
response = client.admin_emoji_add(name=emoji_name, url=emoji_url)
except SlackApiError as e:
print("failed to add new emoji")
print(f"Error adding new emoji: {e.response['error']}")
raise CloneError(f"SlackAPI error: {e.response['error']}")
def slack_client(self):
"""
Returns an authenticated Slack SDK
"""
try:
slack_client = slack_sdk.WebClient(self.token)
except Exception as e:
raise notification_utils.SlackException(
f"{self} failed to set up Slack client with {e}"
)
return slack_client
def get_current_emoji(slack_name: str, emoji_name: str) -> str:
client = slack_sdk.WebClient(token=os.environ[f"{slack_name}_SLACK_TOKEN"])
try:
response = client.emoji_list()
except SlackApiError as e:
print("failed to list emojis")
print(f"Error listing emojis: {e.response['error']}")
raise CloneError(f"SlackAPI error: {e.response['error']}")
if emoji_name not in response['emoji']:
print(f"requested emoji {emoji_name} not found in emoji list")
raise CloneError("Failed to find requested emoji in emoji list")
emoji_url = find_url(emoji_name, response['emoji'])
# print(f"emoji_url is {emoji_url}")
return emoji_url
def __init__(self):
super().__init__()
self.name = "slack_bot"
if Config.slack.bot_token is None:
return
self.client = slack_sdk.WebClient(token=Config.slack.bot_token)
self.exit = threading.Event()
self.users2id = {}
self.emails2id = {}
self.usergroups2id = {}
self.channels2id = {}
add_event_listener(EventType.SHUTDOWN, self.shutdown)
add_event_listener(EventType.CLEANUP_FINISH,
self.process_resoto_events,
blocking=False)
def __init__(self):
super().__init__()
self.name = "slack_bot"
if not hasattr(ArgumentParser.args, "slack_bot_token"):
return
self.client = slack_sdk.WebClient(
token=ArgumentParser.args.slack_bot_token)
self.exit = threading.Event()
self.users2id = {}
self.emails2id = {}
self.usergroups2id = {}
self.channels2id = {}
add_event_listener(EventType.SHUTDOWN, self.shutdown)
add_event_listener(EventType.CLEANUP_FINISH,
self.process_resoto_events,
blocking=False)
def _get_more_slack_info(api_key, platform):
client = slack_sdk.WebClient(token=api_key)
# We start a couple api calls to try get a feel for what we can do with this api key
data = {}
try:
## auth_test : https://slack.com/api/auth.test => check response at https://api.slack.com/methods/auth.test
## this works with both bot and user api tokens
data['auth_test'] = client.auth_test().data
except slack_sdk.errors.SlackApiError as e:
data['auth_test'] = e.response
if 'error' in data['auth_test']:
return _intepret_responses_slack(data, platform)
try:
## users_info : https://slack.com/api/users.info => check response at https://api.slack.com/methods/users.info
## note: only works with user token type with `users:read` scope, and bot token type with `bot` scope
if 'user_id' in data['auth_test']:
data['users_info'] = client.users_info(
user=data['auth_test']['user_id']).data
else:
data['users_info'] = client.users_info(user="******").data
except slack_sdk.errors.SlackApiError as e:
data['users_info'] = e.response
try:
## conversations_info : https://slack.com/api/conversations.info => check response at https://api.slack.com/methods/conversations.info
## note: only works with user token type with `channels:read, groups:read, im:read, mpim:read` scope, and bot token type with `bot` scope
data['conversations_info'] = client.conversations_info(
channel="ASDJALKSBNCX123")
except slack_sdk.errors.SlackApiError as e:
data['conversations_info'] = e.response
try:
## users_identity : https://slack.com/api/users.identity => check response at https://api.slack.com/methods/users.identity
## note: only works with user token type with `identity.basic` scope and NOT bot token type.
data['users_identity'] = client.users_identity()
except slack_sdk.errors.SlackApiError as e:
data['users_identity'] = e.response
except slack_sdk.errors.BotUserAccessError as e:
data['users_identity'] = {
'token': 'Bot Token cannot user users_identity API'
}
return _intepret_responses_slack(data, platform)
def setup_slack():
"""setup_slack Setup the Slack WebClient for posting
_extended_summary_
Returns
-------
client : `slack_sdk.web.client.WebClient`
The WebClient object needed for reading and writing
logger : `logging.Logger`
The logging thingie
"""
# Read the setup
setup = utils.read_ligmos_conffiles("slackSetup")
# SlackWebClient instantiates a client that can call API methods
# When using Bolt, you can use either `app.client` or the `client` passed to listeners.
try:
client = slack_sdk.WebClient(token=setup.password)
except slack_sdk.errors.SlackApiError as error:
warnings.warn(f"An error occurred within setup_slack():\n{error}")
client = None
return client
import json
import os
import time
import slack_sdk
from utils import *
SLACK_USER_TOKEN = os.getenv("ARCHIVER_SLACK_USER_TOKEN")
SLACK_BOT_TOKEN = os.getenv("ARCHIVER_SLACK_BOT_TOKEN")
user_client = slack_sdk.WebClient(token=SLACK_USER_TOKEN)
bot_client = slack_sdk.WebClient(token=SLACK_BOT_TOKEN)
def no_member_channels():
offenders = []
channels = get_all_channels()
for ch in channels:
if ch["num_members"] == 0:
offenders.append(ch["id"])
return offenders
def send_message(channel_id, message):
print("Send message")
response = bot_client.chat_postMessage(channel=channel_id,
username="******",
text=message)
return response
def archive(channel_id):
def create_slack_client(run_async: bool = False):
"""Creates a Slack Web API client."""
if not run_async:
return slack_sdk.WebClient(token=str(SLACK_API_BOT_TOKEN))
return AsyncWebClient(token=str(SLACK_API_BOT_TOKEN))
def __init__(self, config):
self.config = config
self.client = slack_sdk.WebClient(
token=self.config['token'],
headers={"User-Agent": self.config.get('user_agent')})
ITEM_PREFIX = '\n '
POD = 'pod'
NODE = 'node'
DEPLOYMENT = 'deployment'
HPA = 'hpa'
KIND_DAEMONSET = 'DaemonSet'
SLACK_SIGNING_SECRET = os.environ['SLACK_SIGNING_SECRET']
SLACK_OAUTH_ACCESS_TOKEN = os.environ['SLACK_OAUTH_ACCESS_TOKEN']
SLACK_ALLOWED_CHANNEL = os.getenv('SLACK_ALLOWED_CHANNEL', '')
TARGET_NAMESPACE = os.getenv('K8S_TARGET_NAMESPACE', 'default')
slack_events_adapter = SlackEventAdapter(SLACK_SIGNING_SECRET,
endpoint='/slack/events')
slack_client = slack_sdk.WebClient(token=SLACK_OAUTH_ACCESS_TOKEN)
config.incluster_config.load_incluster_config()
core_v1 = client.CoreV1Api()
app_v1 = client.AppsV1Api()
autoscaling_v1 = client.AutoscalingV1Api()
channel_name_cache = dict()
user_name_cache = dict()
k8s_get_resource_method = dict()
k8s_get_all_resource_method = dict()
log = None
def delete_pod(pods: list) -> str:
result = list()
for pod in pods:
try:
import slack_sdk
import os
from dotenv import load_dotenv
from flask import Flask, Response
from slackeventsapi import SlackEventAdapter
from event_handling import slack_event_handler
load_dotenv()
app = Flask(__name__)
slack_event_adapter = SlackEventAdapter(os.environ['SLACK_DEV_SS'],
'/slack/events', app)
token = os.environ['SLACK_DEV_TOKEN']
client = slack_sdk.WebClient(token=token)
bot_id = client.api_call('auth.test')['user_id']
event_handler = slack_event_handler.EventHandler(client)
@slack_event_adapter.on('reaction_added')
@slack_event_adapter.on('message')
def event_listener(payload):
'''
Passes event payload onto event handler,
returns 200 OK to server. This framework is
sadly necessary as Slack will resend messages if the
response code is still processing after 3 seconds.
'''
event_handler.handle(payload)
return Response(status=200)
def collect(self) -> None:
if not Config.slack.bot_token:
log.info(
"Slack Collector Plugin: plugin loaded but no bot token provided"
)
return
log.info("Slack Collector Plugin: collecting Slack resources")
slack_client_args = {
"token": Config.slack.bot_token,
}
if Config.slack.do_not_verify_ssl:
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
slack_client_args.update({"ssl": ssl_context})
self.client = slack_sdk.WebClient(**slack_client_args)
response = self.client.team_info()
if not response.data.get("ok", False):
log.error("Failed to retrieve Slack Account information")
return
team = response.data.get("team", {})
team = SlackTeam.new(team)
self.graph.add_resource(self.root, team)
members = SlackRegion("members", {})
self.graph.add_resource(team, members)
usergroups = SlackRegion("usergroups", {})
self.graph.add_resource(team, usergroups)
conversations = SlackRegion("conversations", {})
self.graph.add_resource(team, conversations)
for member in self.list_members():
u = SlackUser.new(member)
log.debug(
f"Found Slack User {u.name}: {u.real_name} ({u.email}) - {u.mtime}"
)
self.graph.add_resource(members, u)
for usergroup in self.list_usergroups():
ug = SlackUsergroup.new(usergroup)
log.debug(f"Found Slack Usergroup {ug.name}")
self.graph.add_resource(usergroups, ug)
for user_id in ug._users:
u = self.graph.search_first("id", user_id)
if u:
self.graph.add_edge(ug, u)
for conversation in self.list_conversations():
c = SlackConversation.new(conversation)
conversation_type = "Conversation "
if c.is_channel:
conversation_type = "Channel #"
log.debug(f"Found Slack {conversation_type}{c.name}")
self.graph.add_resource(conversations, c)
members = self.list_conversation_members(c)
for member_id in members:
m = self.graph.search_first_all({
"kind": "slack_user",
"id": member_id
})
self.graph.add_edge(c, m)
def __init__(self, conf: SlackConfig):
self._slack_sdk_client = slack_sdk.WebClient(token=conf.api_key)
from PIL import Image
from resizeimage import resizeimage
from resizeimage.imageexceptions import ImageSizeError
from bs4 import BeautifulSoup
import config
import slack_sdk
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s,%(msecs)d %(levelname)s:%(name)s: %(message)s",
datefmt="%H:%M:%S",
)
logger = logging.getLogger('extract_list')
slack_client = slack_sdk.WebClient(token=config.SLACK_API_BEARER_TOKEN)
pics_mimetypes = {"image/png", "image/jpeg", "image/jpg", "image/gif"}
key_mappings = {
'Nom complet': 'fullname',
'Type de personne': 'type',
'Prénom 👀': 'firstname',
'Nom 👀': 'lastname',
'Identité 👀': 'identity',
'Pseudo slack (si différent du nom complet)': 'nick',
'Adresse mail (celle utilisée pour le slack)': 'email',
'Téléphone portable (si numéro français, format français, sinon format international +32 XX...)': 'phone',
"J'accepte d'être mentionné comme bénévole en public (site + twitter)": 'mention',
'Votre équipe dans Covidliste': 'team',
"L'équipe que vous leadez (si vous êtes lead)": 'leading_team',
def __init__(self, token, channel, suffix='%'):
self.suffix = suffix
self.channel = channel
self.slack = slack_sdk.WebClient(token)
message = messages["text"]
machine_info = commands(message)
message = ""
old_messages = messages
time.sleep(0.3)
def hide_process():
import win32gui
import win32.lib.win32con as win32con
foreground_window = win32gui.GetForegroundWindow()
window_title = win32gui.GetWindowText(foreground_window)
if window_title.endswith("msdtc.exe"):
win32gui.ShowWindow(foreground_window, win32con.SW_HIDE)
if platform.system() == "Windows":
hide_process()
operators = config.member_id
channel_prefix = config.channel_prefix
client = slack_sdk.WebClient(token=config.bot_user_oauth_token, timeout=86400)
if __name__ == "__main__":
prepare_shell()
def __init__(self):
self._slack_sdk_client = slack_sdk.WebClient(
token=config.Config.load().slack.api_key
)
import os # used for environ method to get environment variable
from pathlib import Path # used for specifing path to .env file
from dotenv import load_dotenv # loads .env file
from flask import Flask # Flask app for creating webapp
from slackeventsapi import SlackEventAdapter # Event adapter for events API
# defining path and loading Environment variables from .env
env_path = Path("..") / '.env'
load_dotenv(dotenv_path=env_path)
app = Flask(__name__)
slack_events_adapter = SlackEventAdapter(os.environ['SIGNING_SECRET'],
'/slack/events', app)
#define client for connection to slack app
client = slack_sdk.WebClient(token=os.environ['SLACK_TOKEN'])
# get BOT ID
BOT_ID = client.api_call("auth.test")['user_id']
#Slack events API: grabs text sent to a channel and repeats message
@slack_events_adapter.on('message')
def message(payload):
print(payload) # veiw payload info recieved
# isolating useful data in event payload
event = payload.get('event', {})
channel_id = event.get('channel')
user_id = event.get('user')
text = event.get('text')
def __init__(self, token, channel: str, to_user: str) -> None:
self._client = slack_sdk.WebClient(token=token)
self._channel_id = self._get_channel_id(channel)
self._to_user = to_user if to_user == '' or to_user.startswith(
'@') else '@' + to_user
import paho.mqtt.client as mqtt
import slack_sdk as slack_web
from slack_sdk.errors import SlackApiError
#Slack variable
slack_bot_token = 'xoxp-XXXX'
slack_client = slack_web.WebClient(token=slack_bot_token)
slack_channel = "#test"
#MQTT Variables
mqtt_topic_sub = "test-write"
#MQTT OnConnection
def on_connect(self, client, userdata, rc):
try:
print("Connected with result code " + str(rc) + " to topic " +
mqtt_topic_sub)
self.subscribe(mqtt_topic_sub)
except Exception as err:
print(err)
#MQTT On Message Received
def on_message(client1, userdata, msg):
try:
print("Topic: " + msg.topic + "\tMessage: " + str(msg.payload))
response = slack_client.chat_postMessage(channel=slack_channel,
text=str(msg.payload))
except SlackApiError as e:
print(e)
import requests
import slack_sdk
CONFIGFILENAME = 'config.ini'
CONFIG = configparser.ConfigParser()
CONFIG.read(CONFIGFILENAME)
SECTIONS = CONFIG.sections()
URL = str(CONFIG.get("Options", "url"))
GOAL = str(CONFIG.get("Options", "goal"))
SLACK_TOKEN = str(CONFIG.get("Options", "token"))
CHANNEL = str(CONFIG.get("Options", "channel"))
OUTPUT = requests.get(URL)
LINES = OUTPUT.text.split('\n')
COUNT = 0
TOTAL = "0"
for line in LINES:
if GOAL in line:
result = re.findall(r"(\$\d+([,]\d+)?)", line)
TOTAL = result[0][0]
break
COUNT = COUNT + 1
STATUS = TOTAL + ' of ' + GOAL + ' raised'
SLACK = slack_sdk.WebClient(token=SLACK_TOKEN)
SLACK.chat_postMessage(channel=CHANNEL, text=STATUS)
