class Client:
def __init__(self, user_session: UserSession):
self.user_session = user_session
self.driver = Driver({
'login_id': self.user_session.username,
'password': self.user_session.password,
'verify': False,
'scheme': os.getenv('MATTERMOST_SCHEME'),
'url': os.getenv('MATTERMOST_URL_WITH_PORT')
})
self.driver.login()
def get_channels(self) -> List[Dict]:
teams_list = self.driver.api['teams'].get_teams()
def channels_per_team(team: Dict) -> List[Dict]:
team_id = team.get('id')
channels_list = \
self.driver.api['teams'].get_public_channels(team_id)
def channel_transformer(channel: Dict) -> Dict:
return {
'id': channel.get('id'),
'name': channel.get('display_name')
}
return _.map_(channels_list, channel_transformer)
return _.flatten(_.map_(teams_list, channels_per_team))
def get_channel_messages(self, channel_id: str) -> List[Dict]:
channel_messages: Dict = \
self.driver.api['posts'].get_posts_for_channel(channel_id)
def message_transformer(post_id: str) -> Dict:
return {
'userid':
channel_messages.get('posts', {}).get(post_id,
{}).get('user_id'),
'content':
channel_messages.get('posts', {}).get(post_id,
{}).get('message'),
'timestamp':
datetime.fromtimestamp(
float(
channel_messages.get('posts', {}).get(
post_id, {}).get('create_at')) / 1000)
}
return sorted(_.map_(_.reverse(channel_messages.get('order')),
message_transformer),
key=lambda message: message.get('timestamp'))
def get_channels_messages(self) -> List[List[Dict]]:
return _.map_(
self.get_channels(),
lambda channel: self.get_channel_messages(channel.get('id')))
def get_username_by_id(self, id: str) -> str:
return self.driver.api['users'].get_user(id).get('username')
def mattermost(reportFile, issueList, target):
accessToken = configs("mattermost")['accesstoken']
reportFile = os.path.join(tempfile.gettempdir(), reportFile)
issueList = '\n'.join('{}: {}'.format(*k) for k in enumerate(issueList, 1))
mmost = Driver({
'url': 'mattermost.viidakko.fi',
'token': accessToken,
'scheme': 'https',
'port': 443,
'basepath': '/api/v4',
'verify': True,
'timeout': 30,
# 'mfa_token': 'TheMfaToken'
})
mmost.login()
channel_id = mmost.api['channels'].get_channel_by_name_and_team_name(
'development', 'burp-scan-reports')['id']
file_id = mmost.api['files'].upload_file(
channel_id=channel_id,
files={'files': (reportFile, open(reportFile))})['file_infos'][0]['id']
mmost.api['posts'].create_post(
options={
'channel_id': channel_id,
'message': ':bell: **Scan result for ' + target + '**\n' +
issueList,
'file_ids': [file_id]
})
print(
"\033[32m[+]\x1b[0m " +
"Mattermost message sent, 'Burp Scan Report' channel, report file: \033[32m{}\x1b[0m"
.format(reportFileName))
def main():
print("Creating Mattermost Driver...")
driver_options = {
'url': config.URL,
'login_id': config.USERNAME,
'password': config.PASSWORD,
'port': config.PORT
}
driver = Driver(driver_options)
print("Authenticating...")
driver.login()
driver.users.get_user('me')
print("Successfully authenticated.")
print("Retrieving Coffee Buddies participants...")
team_name = config.TEAM_NAME
channel_name = config.CHANNEL_NAME
members = utils.get_channel_members(driver, team_name, channel_name)
print("Successfully retrieved Coffee Buddies participants.")
print("Preparing participants database...")
utils.create_users(members)
utils.create_pairs(members)
print("Succesfully prepared participants database.")
print("Pairing Coffee Buddies participants...")
pairs = utils.get_pairs(members)
print("Successfully paired Coffee Buddies participants.")
print("Messaging paired Coffee Buddies participants...")
utils.message_pairs(driver, pairs)
print("Successfully messaged paired Coffee Buddies participants.")
def connect(host: str, login_token: str = None, username: str = None, password: str = None) -> Driver:
d = Driver({
"url": host,
"port": 443,
"token": login_token,
"username": username,
"password": password
})
d.login()
return d
def upload(src: str) -> None:
driver = Driver({
'scheme': 'https',
'url': MattermostImport._getHost(),
'token': MattermostImport._getToken(),
'port': 443,
})
driver.login()
print(driver.emoji.get_custom_emoji_by_name("doge"))
def get_driver():
my_driver = Driver({
'url': params['MM_IP'],
'token': params['PLOT_BOT_TOKEN'],
'scheme': 'http',
'port': 8065,
'basepath': '/api/v4',
'debug': False
})
my_driver.login()
return my_driver
def mattermost_login(self):
mm = Driver({
'url': os.environ['MATTERMOST_ADDRESS'],
'login_id': os.environ['MATTERMOST_LOGIN_ID'],
'password': os.environ['MATTERMOST_PASSWORD'],
'scheme': 'http',
'port': int(os.environ['MATTERMOST_PORT']),
'basepath': '/api/v3',
'timeout': 30,
})
mm.login()
return mm
def get_standup_members(server_config: Dict) -> List[str]:
d = Driver(server_config)
d.login()
channel_id = d.channels.get_channel_by_name_and_team_name(
'team_name', 'channel')['id']
channel_members = d.channels.get_channel_members(channel_id)
d.logout()
return channel_members
def login(url, port, username, password, token):
driver = Driver({
'url': url,
'port': int(port),
'login_id': username,
'password': password,
'basepath': '/api/v4',
'scheme': 'http',
'token': token
})
driver.login()
return driver
def post_mattermost(msg, hashtag="", data=None):
"""
Post a message to a mattermost server.
Optionally pass a dictionary to print as a table.
All messages prefixed with #API
:param msg: String message
:param hashtag: e.g. #Oncore
:param data: Dictionary
:return:
"""
try:
driver = Driver(
dict(url=MATTERMOST_URL,
login_id=MATTERMOST_USER,
password=MATTERMOST_PW,
scheme='https',
verify=False,
port=443))
if data is not None:
msg = f'| #API {hashtag} | {msg} |\n' \
f'| :--- | :--- |\n'
for k in data:
v = data[k]
if isinstance(v, str) and v is not "":
msg += f'| {k} | {v} |\n'
elif isinstance(v, dict):
for inner_key in v:
inner_val = v[inner_key]
if isinstance(inner_val, str) and inner_val is not "":
msg += f'| {inner_key} | {v[inner_key]} |\n'
else:
msg = f'#API {hashtag} {msg}'
driver.login()
channel_id = driver.channels.get_channel_by_name_and_team_name(
MATTERMOST_TEAM, MATTERMOST_CHANNEL)['id']
driver.posts.create_post(options={
'channel_id': channel_id,
'message': msg
})
driver.logout()
except Exception as e:
logging.error("Error while posting to mattermost")
logging.error(e)
class Connection:
"""
This class allows the user to connect to a Mattermost server and start the bot.
There should be only one instance per program."""
instance = None
def __init__(self, settings):
assert Connection.instance is None
self.driver = Driver(settings)
#self.driver.client.activate_verbose_logging()
self.bot = Bot(convert_to_mmpy_bot(settings))
Connection.instance = self
# workaround for python versions < 3.7
if sys.version_info.major < 3 or sys.version_info.minor < 7:
api.load_driver_attributes()
def __getattr__(self, name):
return getattr(self.driver, name)
def login(self):
logger.info("login...")
self.driver.login()
api.me = api.User.by_id(self.driver.client.userid)
logger.info(f"logged in as {api.me}")
def start(self):
# start bot at the end because the method will not return unless an exception occurs
logger.info("start bot...")
self.bot.run()
logger.info("bot started")
def stop(self):
self.driver.logout()
# TODO stop bot
def __enter__(self):
self.start()
return self
def __exit__(self, type, value, tb):
self.stop()
def main():
print("Creating Mattermost Driver...")
driver_options = {
'url': config.URL,
'login_id': config.USERNAME,
'password': config.PASSWORD,
'token': config.TOKEN,
'port': config.PORT
}
driver = Driver(driver_options)
print("Authenticating...")
driver.login()
driver.users.get_user('me')
print("Successfully authenticated.")
for team_name, channel_name in utils.get_channels(driver):
print("Retrieving Coffee Buddies participants for {:s}/{:s}...".format(
team_name, channel_name))
utils.message_channel(driver, team_name, channel_name)
members = utils.get_channel_members(driver, team_name, channel_name)
print("Successfully retrieved Coffee Buddies participants.")
print("Preparing participants database...")
utils.create_users(members)
utils.create_pairs(members)
print("Successfully prepared participants database.")
print("Pairing Coffee Buddies participants...")
pairs, unmatched = utils.get_pairs(members)
print("Successfully paired Coffee Buddies participants.")
print("Messaging paired Coffee Buddies participants...")
utils.message_pairs(driver, pairs, unmatched)
print("Successfully messaged paired Coffee Buddies participants.")
def cli(ctx, host, token, port, config):
if config:
settings = configparser.ConfigParser()
settings.read(config)
if not host and 'host' in settings['Default']:
host = settings['Default']['host']
if not token and 'token' in settings['Default']:
token = settings['Default']['token']
if not port and 'port' in settings['Default']:
port = int(settings['Default']['port'])
if not host:
click.echo('Missing parameter `--host/-h`.', err=True)
click.echo(cli.get_help(ctx))
sys.exit(1)
if not port:
click.echo('Missing parameter `--port/-p`.', err=True)
click.echo(cli.get_help(ctx))
sys.exit(1)
if not token:
click.echo('Missing parameter `--token/-t`.', err=True)
click.echo(cli.get_help(ctx))
sys.exit(1)
connect = Driver({'url': host, 'token': token, 'port': port})
try:
connect.login()
except exceptions.NoAccessTokenProvided:
sys.exit('No or invalid Access Token.')
ctx.obj = Config(connect)
ctx.obj.set_config('host', host)
ctx.obj.set_config('token', token)
ctx.obj.set_config('port', port)
if config:
ctx.obj.set_config('settings', settings._sections)
def init(channel, access_token, team_id = 'n1f7ge4biifutrbeq9wdx6sz6y') :
global mm, channel_id
# Tuning needed here to switch between GNA and DRW instance may be
# static override with gna team id to post on gna channels
# at current time get_team() doesnt return gna team id , only DRW one at index 0 - will need to chat to drw about this.
# team_id = mm.api['teams'].get_teams()[0]['id']
url = 'chat.drwholdings.com'
mm = Driver({
'url': url,
'token': access_token,
'scheme': 'https',
'port': 443,
'basepath': '/api/v4',
'verify': True,
'timeout': 20
})
r = mm.login()
channel_id = mm.api['channels'].get_channel_by_name(team_id, channel)['id']
return r
def post(markdown_file: Path, channel: str = 'APD'):
mattermost = Driver({
'url': 'chat.asf.alaska.edu',
'token': os.environ.get('MATTERMOST_PAT'),
'scheme': 'https',
'port': 443
})
response = mattermost.login()
logging.debug(response)
channel_info = mattermost.channels.get_channel_by_name_and_team_name(
'asf', channel)
markdown = markdown_file.read_text()
response = mattermost.posts.create_post(options={
'channel_id': channel_info['id'],
'message': markdown,
})
logging.debug(response)
return response
class ConnectorMattermost(Connector):
"""A connector for Mattermost."""
def __init__(self, config, opsdroid=None):
"""Create the connector."""
super().__init__(config, opsdroid=opsdroid)
_LOGGER.debug(_("Starting Mattermost connector"))
self.name = config.get("name", "mattermost")
self.token = config["token"]
self.url = config["url"]
self.team_name = config["team-name"]
self.scheme = config.get("scheme", "https")
self.port = config.get("port", 8065)
self.verify = config.get("ssl-verify", True)
self.timeout = config.get("connect-timeout", 30)
self.request_timeout = None
self.mfa_token = None
self.debug = False
self.listening = True
self.bot_id = None
self.mm_driver = Driver({
"url": self.url,
"token": self.token,
"scheme": self.scheme,
"port": self.port,
"verify": self.verify,
"timeout": self.timeout,
"request_timeout": self.request_timeout,
"mfa_token": self.mfa_token,
"debug": self.debug,
})
async def connect(self):
"""Connect to the chat service."""
_LOGGER.info(_("Connecting to Mattermost"))
login_response = self.mm_driver.login()
_LOGGER.info(login_response)
if "id" in login_response:
self.bot_id = login_response["id"]
if "username" in login_response:
self.bot_name = login_response["username"]
_LOGGER.info(_("Connected as %s"), self.bot_name)
self.mm_driver.websocket = Websocket(self.mm_driver.options,
self.mm_driver.client.token)
_LOGGER.info(_("Connected successfully"))
async def disconnect(self):
"""Disconnect from Mattermost."""
self.listening = False
self.mm_driver.logout()
async def listen(self):
"""Listen for and parse new messages."""
await self.mm_driver.websocket.connect(self.process_message)
async def process_message(self, raw_message):
"""Process a raw message and pass it to the parser."""
_LOGGER.info(raw_message)
message = json.loads(raw_message)
if "event" in message and message["event"] == "posted":
data = message["data"]
post = json.loads(data["post"])
# if connected to Mattermost, don't parse our own messages
# (https://github.com/opsdroid/opsdroid/issues/1775)
if self.bot_id is None or self.bot_id != post["user_id"]:
await self.opsdroid.parse(
Message(
text=post["message"],
user=data["sender_name"],
target=data["channel_name"],
connector=self,
raw_event=message,
))
@register_event(Message)
async def send_message(self, message):
"""Respond with a message."""
_LOGGER.debug(_("Responding with: '%s' in room %s"), message.text,
message.target)
channel_id = self.mm_driver.channels.get_channel_by_name_and_team_name(
self.team_name, message.target)["id"]
self.mm_driver.posts.create_post(options={
"channel_id": channel_id,
"message": message.text
})
class Patter(object):
def __init__(self, message, format_as_code, user, channel, verbose):
self.message = message
self.format_as_code = format_as_code
self.user = user
self.channel = channel
self.verbose = verbose
self._check_env_vars()
self.mm_client = Driver({
"url": config_vars["MATTERMOST_URL"],
"login_id": config_vars["MATTERMOST_USERNAME"],
"password": config_vars["MATTERMOST_PASSWORD"],
"scheme": "https",
"port": int(config_vars["MATTERMOST_PORT"]),
"basepath": "/api/v4",
"verify": True,
"timeout": 30,
"debug": False,
})
self.team_name = config_vars["MATTERMOST_TEAM_NAME"]
try:
self.mm_client.login()
except ConnectionError:
print("Unable to connect to the configured Mattermost server.")
raise
def send_message(self):
if self.format_as_code:
self.message = "```\n{}```".format(self.message)
self.message += "\n⁽ᵐᵉˢˢᵃᵍᵉ ᵇʳᵒᵘᵍʰᵗ ᵗᵒ ʸᵒᵘ ᵇʸ ᵖᵃᵗᵗᵉʳ⁾"
if self.channel:
self._send_message_to_channel()
if self.user:
self._send_message_to_user()
return
def _send_message_to_channel(self):
try:
channel_id = self._get_channel_id_by_name(self.channel)
except HTTPError:
raise MissingChannel("The channel \'{}\' does not exist.".format(
self.channel, ))
self.mm_client.posts.create_post(options={
"channel_id": channel_id,
"message": self.message,
})
def _send_message_to_user(self):
try:
recipient_user_id = self._get_user_id_by_name(self.user)
except HTTPError:
raise MissingUser("The user \'{}\' does not exist.".format(
self.user, ))
my_id = self.mm_client.users.get_user('me')['id']
# The Mattermost API treats direct messages the same as regular channels,
# so we need to first get a channel ID to send the direct message.
user_channel_id = self.mm_client.channels.create_direct_message_channel(
[recipient_user_id, my_id])['id']
self.mm_client.posts.create_post(options={
"channel_id": user_channel_id,
"message": self.message,
})
def _get_channel_id_by_name(self, channel_name):
"""
The Mattermost API expects a channel ID, not a channel name.
Use this function to get an ID from a channel name.
"""
channel = self.mm_client.channels.get_channel_by_name_and_team_name(
team_name=self.team_name,
channel_name=channel_name,
)
return channel["id"]
def _get_user_id_by_name(self, user_name):
"""
The Mattermost API expects a user ID, not a username.
Use this function to get an ID from a username.
"""
user = self.mm_client.users.get_user_by_username(username=user_name, )
return user["id"]
def _check_env_vars(self):
"""Check that all of the required environment variables are set. If not,
print the ones that are missing.
"""
missing_vars = list(k for k, v in config_vars.items() if v is None)
if len(missing_vars) > 0:
error_string = "\n\t".join(missing_vars)
raise MissingEnvVars(
"The following environment variables are required but not set:\n\t{}"
.format(error_string))
class MMostBot:
def __init__(self,
mail,
pswd,
url,
welcome="hello",
tags=None,
debug=False):
self.debug = debug
self.config = {
"url": url,
"login_id": mail,
"password": pswd,
"scheme": "https",
"port": 443,
"verify": True,
"debug": debug,
"welcome": welcome
}
self.driver = Driver(self.config)
self.tags = tags or []
@property
def user_id(self):
return self.driver.users.get_user(user_id='me')["id"]
def listen(self):
self.driver.login()
self.driver.init_websocket(self.event_handler)
#def event_handler(self, event):
async def event_handler(self, event):
event = json.loads(event)
event_type = event.get("event", "")
if event_type == "hello":
self.on_connect(event)
elif event_type == "status_change":
self.on_status_change(event)
elif event_type == "typing":
self.on_typing(event)
elif event_type == "posted":
self.on_message(event)
elif event_type == "channel_viewed":
self.on_viewed(event)
elif event_type == "preferences_changed":
self.on_preferences_changed(event)
elif event_type == "post_deleted":
self.on_post_deleted(event)
elif event_type == "user_added":
self.on_user_added(event)
elif event_type == "user_removed":
self.on_user_removed(event)
else:
LOG.debug(event)
def on_connect(self, event):
LOG.info("Connected")
def on_status_change(self, event):
user_id = event["data"]["user_id"]
status = event["data"]["status"]
user_data = self.driver.users.get_user(user_id=user_id)
username = user_data["username"]
email = user_data["email"]
LOG.info(username + ":" + status)
def on_typing(self, event):
user_id = event["data"]["user_id"]
channel_id = event["broadcast"]["channel_id"]
channel_data = self.driver.channels.get_channel(channel_id)
channel_name = channel_data["name"]
user_data = self.driver.users.get_user(user_id=user_id)
username = user_data["username"]
if channel_name == self.user_id + "__" + user_id:
LOG.info(username + " is typing a direct message")
else:
LOG.info(username + " is typing a message in channel: " +
channel_name)
def on_message(self, event):
post = event["data"]["post"]
post = json.loads(post)
sender = event["data"]["sender_name"]
msg = post["message"]
channel_id = post["channel_id"]
user_id = post["user_id"]
channel_data = self.driver.channels.get_channel(channel_id)
channel_name = channel_data["name"]
if channel_name == user_id + "__" + self.user_id:
# direct_message
if user_id != self.user_id:
self.on_direct_message(event)
else:
if user_id != self.user_id:
mention = False
for tag in self.tags:
if tag in msg:
mention = True
break
if mention:
self.on_mention(event)
else:
LOG.info("New message at channel: " + channel_name)
LOG.info(sender + " said: " + msg)
msg = [sender, msg, channel_name]
#mycroft.send_msg(msg)
return msg
def on_mention(self, event):
post = event["data"]["post"]
post = json.loads(post)
sender = event["data"]["sender_name"]
msg = post["message"]
channel_id = post["channel_id"]
user_id = post["user_id"]
channel_data = self.driver.channels.get_channel(channel_id)
channel_name = channel_data["name"]
for tag in self.tags:
msg = msg.replace(tag, "")
LOG.info("New mention at channel: " + channel_name)
LOG.info(sender + " said: " + msg)
self.handle_mention(msg, sender, channel_id)
def on_user_added(self, event):
user_id = event["data"]["user_id"]
channel_id = event["broadcast"]["channel_id"]
if user_id != self.user_id:
user_data = self.driver.users.get_user(user_id=user_id)
username = user_data["username"]
self.send_message(channel_id, "@" + user_id + " " + welcome)
else:
self.send_message(channel_id, "Blip Blop, I am a Bot!")
def on_user_removed(self, event):
user_id = event["broadcast"]["user_id"]
#channel_id = event["data"]["channel_id"]
#remover_id = event["data"]["remover_id"]
def on_direct_message(self, event):
post = event["data"]["post"]
post = json.loads(post)
sender = event["data"]["sender_name"]
msg = post["message"]
channel_id = post["channel_id"]
LOG.info("Direct Message from: " + sender)
LOG.info("Message: " + msg)
# echo
self.handle_direct_message(msg, sender, channel_id)
def on_viewed(self, event):
channel_id = event["data"]["channel_id"]
user_id = event["broadcast"]["user_id"]
def on_preferences_changed(self, event):
preferences = json.loads(event["data"]["preferences"])
for pref in preferences:
user_id = pref["user_id"]
category = pref["category"]
value = pref["value"]
LOG.debug(category + ":" + value)
def on_post_deleted(self, event):
msg = event["data"]["message"]
def send_message(self, channel_id, message, file_paths=None):
file_paths = file_paths or []
file_ids = []
# TODO not working
#for f in file_paths:
# file_id = self.driver.files.upload_file(
# channel_id=channel_id,
# files = {'files': (f, open(f))}
# )['file_infos'][0]['id']
# file_ids.append(file_id)
post = {'channel_id': channel_id, 'message': message}
if len(file_ids):
post["file_ids"] = file_ids
self.driver.posts.create_post(options=post)
# Relevant handlers
def handle_direct_message(self, message, sender, channel_id):
pass
def handle_mention(self, message, sender, channel_id):
pass
class Mattermost(Forum):
def __init__(self, **kwargs):
"""
Initialize Mattermost class which extends Chat ABC
Args:
**kwargs: args to pass to Chat ABC
team_channel : (String) required for posting to channel
channel_name : (String) required for posting to channel
"""
super().__init__(**kwargs)
self.inst = Driver({
'url': self.url,
'verify': False,
'token': self.api_key,
'username': self.username,
'port': kwargs.get('port', 8065)
})
self.team_name = kwargs.get("team_name", None)
self.channel_name = kwargs.get("channel_name", None)
self.filepath = kwargs.get("filepath", None)
def _upload_files(self, file_location, channel_id):
file_ids = []
for root, dirs, files in walk(file_location):
for filename in files:
#TODO add optional parameters for adjusting size. Implement file splitting
print(f"[...] Uploading {filename}")
if stat(join_abs(root, filename)).st_size / 1024**2 > 49:
print(f"[!]\tFile {filename} is to big, ignoring for now")
continue
else:
file_ids += [
self.inst.files.upload_file(
channel_id=channel_id,
files={
'files':
(filename, open(join_abs(root, filename),
'rb'))
})['file_infos'][0]['id']
]
if len(file_ids) >= 5:
self.inst.posts.create_post(
options={
'channel_id': channel_id,
'message':
f"Recon Data {datetime.datetime.now()}",
'file_ids': file_ids
})
file_ids = []
if len(file_ids) > 0:
self.inst.posts.create_post(
options={
'channel_id': channel_id,
'message': f"Recon Data {datetime.datetime.now()}",
'file_ids': file_ids
})
def upload(self, **kwargs):
"""
File upload
Args:
**kwargs:
filepath: (String) optional filepath to check for files to upload
Returns:
"""
print("[*] doing post message")
try:
self.inst.login()
team_id = self.inst.teams.get_team_by_name(self.team_name)['id']
channel_id = self.inst.channels.get_channel_by_name(
channel_name=self.channel_name, team_id=team_id)['id']
except exceptions.NoAccessTokenProvided as er:
print(f"[!] NoAccessTokenProvided {er}")
logger.exception()
except exceptions.InvalidOrMissingParameters as er:
print(f"[!] InvalidOrMissingParameters {er}")
logger.exception()
try:
if isfile(self.filepath):
file_ids = [
self.inst.files.upload_file(
channel_id=channel_id,
files={
'files': (basename(self.filepath),
open(join_abs(self.filepath), 'rb'))
})['file_infos'][0]['id']
]
self.inst.posts.create_post(
options={
'channel_id': channel_id,
'message': f"Recon Data {datetime.datetime.now()}",
'file_ids': file_ids
})
elif isdir(self.filepath):
file_location = abspath(self.filepath)
self._upload_files(file_location, channel_id)
except exceptions.ContentTooLarge as er:
print(f"[!] ContentTooLarge {er}")
logger.exception()
except exceptions.ResourceNotFound as er:
print(f"[!] ResourceNotFound {er}")
logger.exception()
except OSError as er:
print(f"[!] File not found {er}")
logger.exception()
print('blink')
for x in range(10):
GPIO.output(lights, GPIO.HIGH)
sleep(0.5)
GPIO.output(lights, GPIO.LOW)
sleep(0.5)
mm = Driver({
'url': mattermosturl,
"token": personaltoken,
'scheme': 'https',
'port': 443
})
mm.login()
async def my_event_handler(e):
message = json.loads(e)
if 'event' in message:
print('----------------------------------------------')
print(message)
if message['event'] == 'reaction_added':
reaction = json.loads(message['data']['reaction'])
post_id = reaction['post_id']
post = mm.posts.get_post(post_id)
emoji = reaction['emoji_name']
if emoji == 'stop_sign':
stop()
if emoji == 'arrow_up':
class MattermostClient:
def __init__(self, mattermost_setting, username, mattermost_user_setting, selector: MattermostChannelSelect):
self.driver = Driver({
'url': mattermost_setting['url'],
'token': mattermost_user_setting['token'],
'scheme': mattermost_setting['scheme'],
'port': mattermost_setting['port'],
'basepath': mattermost_setting['basepath'],
'timeout': mattermost_setting['timeout']
})
self.username = username
team_name = mattermost_user_setting['team_name']
self.driver.login()
self.selector = selector
self.team_id = self.driver.teams.get_team_by_name(team_name)['id']
def post(self, mail: MailModel):
try:
channel_name = self.selector.select_channel(mail)
self.__api_process(channel_name, mail)
except Exception as e:
LOGGER.error(e)
try:
self.__simple_post(mail, 'error', e)
except Exception as e2:
LOGGER.error(e2)
def error_post(self, text):
self.__simple_post(None, 'error', text)
def __api_process(self, channel_name, mail):
if channel_name == 'drops':
self.__simple_post(mail, 'drops')
return
channel_id = self.__get_channel_id_if_create_channel(channel_name)
file_ids = self.__check_if_upload_file(channel_id, mail)
self.__create_message(channel_id, mail, file_ids)
def __get_channel_id_if_create_channel(self, channel_name):
try:
channel = self.driver.channels.get_channel_by_name(self.team_id, channel_name)
return channel['id']
except ResourceNotFound:
LOGGER.info('channel does not exist and create channel')
user_id = self.driver.users.get_user_by_username(self.username)['id']
channel = self.driver.channels.create_channel(options={
'team_id': self.team_id,
'name': channel_name,
'display_name': channel_name,
'type': 'O'
})
channel_id = channel['id']
self.driver.channels.add_user(channel_id, options={
'user_id': user_id
})
return channel_id
def __create_message(self, channel_id, mail, file_ids):
message = self.__format_message(mail)
if len(message) >= MATTERMOST_POST_LIMIT_LENGTH:
file_ids.append(self.__upload_file(channel_id, 'full_body.txt', message.encode('utf-8')))
message = message[:MATTERMOST_POST_LIMIT_LENGTH]
self.__execute_post(channel_id, message, file_ids)
def __execute_post(self, channel_id, message, file_ids=[]):
self.driver.posts.create_post(options={
'channel_id': channel_id,
'message': message,
'file_ids': file_ids
})
def __format_message(self, mail):
return dedent('''
```
from: {}
date: {}
subject: {}
uid: {}
```
'''.format(mail.origin_from_, mail.date_, mail.subject_.strip(), mail.uid_)).strip() + '\n' + dedent(mail.body_)
def __check_if_upload_file(self, channel_id, mail: MailModel):
if len(mail.attachments_) <= 0:
return []
file_ids = []
for attachment in mail.attachments_:
file_ids.append(self.__upload_file(channel_id, attachment['name'], attachment['data']))
return file_ids
def __upload_file(self, channel_id, name, data):
return self.driver.files.upload_file(channel_id, {'files': (name, data)})['file_infos'][0]['id']
def __simple_post(self, mail, channel_name, error=None, plain_text=None):
channel_id = self.__get_channel_id_if_create_channel(channel_name)
if mail is None:
self.__execute_post(channel_id, plain_text)
return
message = dedent('''
```
from: {}
date: {}
subject: {}
uid: {}
```
'''.format(mail.origin_from_, mail.date_, mail.subject_.strip(), mail.uid_)).strip()
if error is not None:
message += '\n' + dedent(error)
self.__execute_post(channel_id, message)
class MattermostBackend(ErrBot):
def __init__(self, config):
super().__init__(config)
identity = config.BOT_IDENTITY
self._login = identity.get('login', None)
self._password = identity.get('password', None)
self._personal_access_token = identity.get('token', None)
self._mfa_token = identity.get('mfa_token', None)
self.team = identity.get('team')
self._scheme = identity.get('scheme', 'https')
self._port = identity.get('port', 8065)
self.cards_hook = identity.get('cards_hook', None)
self.url = identity.get('server').rstrip('/')
self.insecure = identity.get('insecure', False)
self.timeout = identity.get('timeout', DEFAULT_TIMEOUT)
self.teamid = ''
self.token = ''
self.bot_identifier = None
self.driver = None
self.md = md()
@property
def userid(self):
return "{}".format(self.bot_identifier.userid)
@property
def mode(self):
return 'mattermost'
def username_to_userid(self, name):
"""Converts a name prefixed with @ to the userid"""
name = name.lstrip('@')
user = self.driver.users.get_user_by_username(username=name)
if user is None:
raise UserDoesNotExistError("Cannot find user {}".format(name))
return user['id']
@asyncio.coroutine
def mattermost_event_handler(self, payload):
if not payload:
return
payload = json.loads(payload)
if 'event' not in payload:
log.debug("Message contains no event: {}".format(payload))
return
event_handlers = {
'posted': self._message_event_handler,
'status_change': self._status_change_event_handler,
'hello': self._hello_event_handler,
'user_added': self._room_joined_event_handler,
'user_removed': self._room_left_event_handler,
}
event = payload['event']
event_handler = event_handlers.get(event)
if event_handler is None:
log.debug("No event handler available for {}, ignoring.".format(event))
return
# noinspection PyBroadException
try:
event_handler(payload)
except Exception:
log.exception("{} event handler raised an exception".format(event))
def _room_joined_event_handler(self, message):
log.debug('User added to channel')
if message['data']['user_id'] == self.userid:
self.callback_room_joined(self)
def _room_left_event_handler(self, message):
log.debug('User removed from channel')
if message['broadcast']['user_id'] == self.userid:
self.callback_room_left(self)
def _message_event_handler(self, message):
log.debug(message)
data = message['data']
# In some cases (direct messages) team_id is an empty string
if data['team_id'] != '' and self.teamid != data['team_id']:
log.info("Message came from another team ({}), ignoring...".format(data['team_id']))
return
broadcast = message['broadcast']
if 'channel_id' in data:
channelid = data['channel_id']
elif 'channel_id' in broadcast:
channelid = broadcast['channel_id']
else:
log.error("Couldn't find a channelid for event {}".format(message))
return
channel_type = data['channel_type']
if channel_type != 'D':
channel = data['channel_name']
else:
channel = channelid
text = ''
post_id = ''
file_ids = None
userid = None
if 'post' in data:
post = json.loads(data['post'])
text = post['message']
userid = post['user_id']
if 'file_ids' in post:
file_ids = post['file_ids']
post_id = post['id']
if 'type' in post and post['type'] == 'system_add_remove':
log.info("Ignoring message from System")
return
if 'user_id' in data:
userid = data['user_id']
if not userid:
log.error('No userid in event {}'.format(message))
return
mentions = []
if 'mentions' in data:
# TODO: Only user, not channel mentions are in here at the moment
mentions = self.mentions_build_identifier(json.loads(data['mentions']))
# Thread root post id
root_id = post.get('root_id')
if root_id is '':
root_id = post_id
msg = Message(
text,
extras={
'id': post_id,
'root_id': root_id,
'mattermost_event': message,
'url': '{scheme:s}://{domain:s}:{port:s}/{teamname:s}/pl/{postid:s}'.format(
scheme=self.driver.options['scheme'],
domain=self.driver.options['url'],
port=str(self.driver.options['port']),
teamname=self.team,
postid=post_id
)
}
)
if file_ids:
msg.extras['attachments'] = file_ids
# TODO: Slack handles bots here, but I am not sure if bot users is a concept in mattermost
if channel_type == 'D':
msg.frm = MattermostPerson(self.driver, userid=userid, channelid=channelid, teamid=self.teamid)
msg.to = MattermostPerson(
self.driver, userid=self.bot_identifier.userid, channelid=channelid, teamid=self.teamid)
elif channel_type == 'O' or channel_type == 'P':
msg.frm = MattermostRoomOccupant(self.driver, userid=userid, channelid=channelid, teamid=self.teamid, bot=self)
msg.to = MattermostRoom(channel, teamid=self.teamid, bot=self)
else:
log.warning('Unknown channel type \'{}\'! Unable to handle {}.'.format(
channel_type,
channel
))
return
self.callback_message(msg)
if mentions:
self.callback_mention(msg, mentions)
def _status_change_event_handler(self, message):
"""Event handler for the 'presence_change' event"""
idd = MattermostPerson(self.driver, message['data']['user_id'])
status = message['data']['status']
if status == 'online':
status = ONLINE
elif status == 'away':
status = AWAY
else:
log.error(
"It appears the Mattermost API changed, I received an unknown status type %s" % status
)
status = ONLINE
self.callback_presence(Presence(identifier=idd, status=status))
def _hello_event_handler(self, message):
"""Event handler for the 'hello' event"""
self.connect_callback()
self.callback_presence(Presence(identifier=self.bot_identifier, status=ONLINE))
@lru_cache(1024)
def get_direct_channel(self, userid, other_user_id):
"""
Get the direct channel to another user.
If it does not exist, it will be created.
"""
try:
return self.driver.channels.create_direct_message_channel(options=[userid, other_user_id])
except (InvalidOrMissingParameters, NotEnoughPermissions):
raise RoomDoesNotExistError("Could not find Direct Channel for users with ID {} and {}".format(
userid, other_user_id
))
def build_identifier(self, txtrep):
"""
Convert a textual representation into a :class:`~MattermostPerson` or :class:`~MattermostRoom`
Supports strings with the following formats::
@username
~channelname
channelid
"""
txtrep = txtrep.strip()
if txtrep.startswith('~'):
# Channel
channelid = self.channelname_to_channelid(txtrep[1:])
if channelid is not None:
return MattermostRoom(channelid=channelid, teamid=self.teamid, bot=self)
else:
# Assuming either a channelid or a username
if txtrep.startswith('@'):
# Username
userid = self.username_to_userid(txtrep[1:])
else:
# Channelid
userid = txtrep
if userid is not None:
return MattermostPerson(
self.driver,
userid=userid,
channelid=self.get_direct_channel(self.userid, userid)['id'],
teamid=self.teamid
)
raise Exception(
'Invalid or unsupported Mattermost identifier: %s' % txtrep
)
def mentions_build_identifier(self, mentions):
identifier = []
for mention in mentions:
if mention != self.bot_identifier.userid:
identifier.append(
self.build_identifier(mention)
)
return identifier
def serve_once(self):
self.driver = Driver({
'scheme': self._scheme,
'url': self.url,
'port': self._port,
'verify': not self.insecure,
'timeout': self.timeout,
'login_id': self._login,
'password': self._password,
'token': self._personal_access_token,
'mfa_token': self._mfa_token
})
self.driver.login()
self.teamid = self.driver.teams.get_team_by_name(name=self.team)['id']
userid = self.driver.users.get_user(user_id='me')['id']
self.token = self.driver.client.token
self.bot_identifier = MattermostPerson(self.driver, userid=userid, teamid=self.teamid)
# noinspection PyBroadException
try:
loop = self.driver.init_websocket(event_handler=self.mattermost_event_handler)
self.reset_reconnection_count()
loop.run_forever()
except KeyboardInterrupt:
log.info("Interrupt received, shutting down..")
return True
except Exception:
log.exception("Error reading from RTM stream:")
finally:
log.debug("Triggering disconnect callback")
self.disconnect_callback()
def _prepare_message(self, message):
to_name = "<unknown>"
if message.is_group:
to_channel_id = message.to.id
if message.to.name:
to_name = message.to.name
else:
self.channelid_to_channelname(channelid=to_channel_id)
else:
to_name = message.to.username
if isinstance(message.to, RoomOccupant): # private to a room occupant -> this is a divert to private !
log.debug("This is a divert to private message, sending it directly to the user.")
channel = self.get_direct_channel(self.userid, self.username_to_userid(to_name))
to_channel_id = channel['id']
else:
to_channel_id = message.to.channelid
return to_name, to_channel_id
def send_message(self, message):
super().send_message(message)
try:
to_name, to_channel_id = self._prepare_message(message)
message_type = "direct" if message.is_direct else "channel"
log.debug('Sending %s message to %s (%s)' % (message_type, to_name, to_channel_id))
body = self.md.convert(message.body)
log.debug('Message size: %d' % len(body))
limit = min(self.bot_config.MESSAGE_SIZE_LIMIT, MATTERMOST_MESSAGE_LIMIT)
parts = self.prepare_message_body(body, limit)
root_id = None
if message.parent is not None:
root_id = message.parent.extras.get('root_id')
for part in parts:
self.driver.posts.create_post(options={
'channel_id': to_channel_id,
'message': part,
'root_id': root_id,
})
except (InvalidOrMissingParameters, NotEnoughPermissions):
log.exception(
"An exception occurred while trying to send the following message "
"to %s: %s" % (to_name, message.body)
)
def send_card(self, card: Card):
if isinstance(card.to, RoomOccupant):
card.to = card.to.room
to_humanreadable, to_channel_id = self._prepare_message(card)
attachment = {}
if card.summary:
attachment['pretext'] = card.summary
if card.title:
attachment['title'] = card.title
if card.link:
attachment['title_link'] = card.link
if card.image:
attachment['image_url'] = card.image
if card.thumbnail:
attachment['thumb_url'] = card.thumbnail
attachment['text'] = card.body
if card.color:
attachment['color'] = COLORS[card.color] if card.color in COLORS else card.color
if card.fields:
attachment['fields'] = [{'title': key, 'value': value, 'short': True} for key, value in card.fields]
data = {
'attachments': [attachment]
}
if card.to:
if isinstance(card.to, MattermostRoom):
data['channel'] = card.to.name
try:
log.debug('Sending data:\n%s', data)
# We need to send a webhook - mattermost has no api endpoint for attachments/cards
# For this reason, we need to build our own url, since we need /hooks and not /api/v4
# Todo: Reminder to check if this is still the case
self.driver.webhooks.call_webhook(self.cards_hook, options=data)
except (
InvalidOrMissingParameters,
NotEnoughPermissions,
ContentTooLarge,
FeatureDisabled,
NoAccessTokenProvided
):
log.exception(
"An exception occurred while trying to send a card to %s.[%s]" % (to_humanreadable, card)
)
def prepare_message_body(self, body, size_limit):
"""
Returns the parts of a message chunked and ready for sending.
This is a staticmethod for easier testing.
Args:
body (str)
size_limit (int): chunk the body into sizes capped at this maximum
Returns:
[str]
"""
fixed_format = body.startswith('```') # hack to fix the formatting
parts = list(split_string_after(body, size_limit))
if len(parts) == 1:
# If we've got an open fixed block, close it out
if parts[0].count('```') % 2 != 0:
parts[0] += '\n```\n'
else:
for i, part in enumerate(parts):
starts_with_code = part.startswith('```')
# If we're continuing a fixed block from the last part
if fixed_format and not starts_with_code:
parts[i] = '```\n' + part
# If we've got an open fixed block, close it out
if parts[i].count('```') % 2 != 0:
parts[i] += '\n```\n'
return parts
def change_presence(self, status: str=ONLINE, message: str=''):
pass # Mattermost does not have a request/websocket event to change the presence
def is_from_self(self, message: Message):
return self.bot_identifier.userid == message.frm.userid
def shutdown(self):
self.driver.logout()
super().shutdown()
def query_room(self, room):
""" Room can either be a name or a channelid """
return MattermostRoom(room, teamid=self.teamid, bot=self)
def prefix_groupchat_reply(self, message: Message, identifier):
super().prefix_groupchat_reply(message, identifier)
message.body = '@{0}: {1}'.format(identifier.nick, message.body)
def build_reply(self, message, text=None, private=False, threaded=False):
response = self.build_message(text)
response.frm = self.bot_identifier
if private:
response.to = message.frm
else:
response.to = message.frm.room if isinstance(message.frm, RoomOccupant) else message.frm
if threaded:
response.extras['root_id'] = message.extras.get('root_id')
self.driver.posts.get_post(message.extras.get('root_id'))
response.parent = message
return response
def get_public_channels(self):
channels = []
page = 0
channel_page_limit = 200
while True:
channel_list = self.driver.channels.get_public_channels(
team_id=self.teamid,
params={'page': page, 'per_page': channel_page_limit}
)
if len(channel_list) == 0:
break
else:
channels.extend(channel_list)
page += 1
return channels
def channels(self, joined_only=False):
channels = []
channels.extend(self.driver.channels.get_channels_for_user(user_id=self.userid, team_id=self.teamid))
if not joined_only:
public_channels = self.get_public_channels()
for channel in public_channels:
if channel not in channels:
channels.append(channel)
return channels
def rooms(self):
"""Return public and private channels, but no direct channels"""
rooms = self.channels(joined_only=True)
channels = [channel for channel in rooms if channel['type'] != 'D']
return [MattermostRoom(channelid=channel['id'], teamid=channel['team_id'], bot=self) for channel in channels]
def channelid_to_channelname(self, channelid):
"""Convert the channelid in the current team to the channel name"""
channel = self.driver.channels.get_channel(channel_id=channelid)
if 'name' not in channel:
raise RoomDoesNotExistError("No channel with ID {} exists in team with ID {}".format(
id, self.teamid
))
return channel['name']
def channelname_to_channelid(self, name):
"""Convert the channelname in the current team to the channel id"""
channel = self.driver.channels.get_channel_by_name(team_id=self.teamid, channel_name=name)
if 'id' not in channel:
raise RoomDoesNotExistError("No channel with name {} exists in team with ID {}".format(
name, self.teamid
))
return channel['id']
def __hash__(self):
return 0 # This is a singleton anyway
class SubscriptionBot:
""" A mattermost bot implementing a publish/subscribe mechanism. """
SUBSCRIBED_MESSAGE = "Hi there - thx for joining!"
UNSUBSCRIBED_MESSAGE = "Bye then, couch potato!"
NOT_SUBSCRIBED_MESSAGE = "Are you also trying to cancel your gym membership before even registering?"
UNKNOWN_COMMAND_TEXT = "I don't get it, want to join? Try 'subscribe' instead. 'help' may also be your friend."
HELP_TEXT = """
|Command|Description|
|:------|:----------|
|subscribe|Join the growing list of subscribers now!|
|unsubscribe|Go back to your boring office-chair-only life.|
|help|I'm quite sure, you know what this one does.|
"""
def __init__(self, username, password, scheme='https', debug=False):
self.subscriptions = set()
self.username = username
self.debug = debug
self.driver = Driver({
'url': "192.168.122.254",
'login_id': username,
'password': password,
'scheme': scheme,
'debug': debug,
})
self.driver.login()
# get userid for username since it is not automatically set to driver.client.userid ... for reasons
res = self.driver.users.get_user_by_username('bot')
self.userid = res['id']
def start_listening(self):
worker = threading.Thread(
target=SubscriptionBot._start_listening_in_thread, args=(self, ))
worker.daemon = True
worker.start()
print("Initialized bot.")
def _start_listening_in_thread(self):
# Setting event loop for thread
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.driver.init_websocket(self.websocket_handler)
@asyncio.coroutine
def websocket_handler(self, event_json):
event = json.loads(event_json)
if self.debug:
print("websocket_handler:" + json.dumps(event, indent=4))
if 'event' in event and event['event'] == 'posted':
# mentions is automatically set in direct messages
mentions = json.loads(event['data']['mentions']
) if 'mentions' in event['data'] else []
post = json.loads(event['data']['post'])
post_id = post['id']
message = post['message']
channel_id = post['channel_id']
sender_id = post['user_id']
if self.userid in mentions:
self.handle_bot_message(channel_id, post_id, sender_id,
message)
def handle_bot_message(self, channel_id, post_id, sender_id, message):
if re.match(r'(@' + self.username + ')?\s*help\s*', message):
self._show_help(channel_id, post_id)
elif re.match(r'(@' + self.username + ')?\s*subscribe\s*', message):
self._handle_subscription(sender_id, channel_id, post_id)
elif re.match(r'(@' + self.username + ')?\s*unsubscribe\s*', message):
self._handle_unsubscription(channel_id, post_id, sender_id)
else:
self._handle_unknown_command(channel_id, post_id)
def _show_help(self, channel_id, post_id):
self.driver.posts.create_post({
'channel_id': channel_id,
'message': self.HELP_TEXT,
'root_id': post_id,
})
def _handle_subscription(self, sender_id, channel_id, post_id):
self.subscriptions.add(sender_id)
if self.debug:
print(sender_id + " subscribed.")
self.driver.posts.create_post({
'channel_id': channel_id,
'message': self.SUBSCRIBED_MESSAGE,
'root_id': post_id,
})
def _handle_unsubscription(self, channel_id, post_id, sender_id):
if sender_id in self.subscriptions:
self.subscriptions.discard(sender_id)
if self.debug:
print(sender_id + " unsubscribed.")
self.driver.posts.create_post({
'channel_id': channel_id,
'message': self.UNSUBSCRIBED_MESSAGE,
'root_id': post_id,
})
else:
self.driver.posts.create_post({
'channel_id': channel_id,
'message': self.UNSUBSCRIBED_MESSAGE,
'root_id': post_id,
})
def _handle_unknown_command(self, channel_id, post_id):
self.driver.posts.create_post({
'channel_id': channel_id,
'message': self.UNKNOWN_COMMAND_TEXT,
'root_id': post_id,
})
def send_messages_to_subscribers(self, message):
for subscriber in self.subscriptions:
self._send_direct_message(subscriber, message)
def _send_direct_message(self, user_id, message, root_id=None):
res = self.driver.channels.create_direct_message_channel(
[self.userid, user_id])
channel_id = res['id']
post_options = {
'channel_id': channel_id,
'message': message,
}
if root_id:
post_options['root_id'] = root_id
self.driver.posts.create_post(post_options)
class Patter(object):
def __init__(self, message, filename, format_as_code, user, channel,
verbose):
self.message = self._format_message(message, format_as_code)
self.filename = filename
self.user = user
self.channel = channel
self.verbose = verbose
self._check_env_vars()
self.mm_client = Driver({
"url": config_vars["MATTERMOST_URL"],
"login_id": config_vars["MATTERMOST_USERNAME"],
"password": config_vars["MATTERMOST_PASSWORD"],
"scheme": "https",
"port": int(config_vars["MATTERMOST_PORT"]),
"basepath": "/api/v4",
"verify": True,
"timeout": 30,
"debug": False,
})
self.team_name = config_vars["MATTERMOST_TEAM_NAME"]
try:
self.mm_client.login()
except ConnectionError:
print("Unable to connect to the configured Mattermost server.")
raise
def send_message(self):
"""Send the message."""
channel_id = self._get_message_channel_id()
attached_file_id = None
if self.filename:
attached_file_id = self._attach_file(self.filename, channel_id)
options = {
"channel_id": channel_id,
"message": self.message,
}
if attached_file_id:
options["file_ids"] = [attached_file_id]
self.mm_client.posts.create_post(options)
def _format_message(self, message, format_as_code):
"""Adds formatting to the given message.
:param message: Message for format
:param format_as_code: Boolen if message should be formatted as code.
:returns: Formatted message.
"""
formatted_message = message
if format_as_code:
formatted_message = "```\n{}```".format(message)
formatted_message += "\n⁽ᵐᵉˢˢᵃᵍᵉ ᵇʳᵒᵘᵍʰᵗ ᵗᵒ ʸᵒᵘ ᵇʸ ᵖᵃᵗᵗᵉʳ⁾"
return formatted_message
def _get_message_channel_id(self):
"""Get the channel to send the message to.
:returns: Channel id string.
"""
if self.channel:
try:
return self._get_channel_id_by_name(self.channel)
except HTTPError:
raise MissingChannel(
"The channel \'{}\' does not exist.".format(
self.channel, ))
if self.user:
return self._get_channel_id_for_user(self.user)
def _get_channel_id_by_name(self, channel_name):
"""Use this function to get an ID from a channel name.
:param channel_name: Name of channel
:returns: Channel id string.
"""
channel = self.mm_client.channels.get_channel_by_name_and_team_name(
team_name=self.team_name,
channel_name=channel_name,
)
return channel["id"]
def _get_channel_id_for_user(self, user_name):
"""Get the channel id for a direct message with the target user.
:returns: Channel id string.
"""
try:
recipient_user_id = self._get_user_id_by_name(user_name)
except HTTPError:
raise MissingUser("The user \'{}\' does not exist.".format(
user_name, ))
my_id = self.mm_client.users.get_user("me")["id"]
# The Mattermost API treats direct messages the same as regular
# channels so we need to first get a channel ID to send the direct
# message.
user_channel = self.mm_client.channels.create_direct_message_channel(
[recipient_user_id, my_id])
return user_channel["id"]
def _get_user_id_by_name(self, user_name):
"""The Mattermost API expects a user ID, not a username.
Use this function to get an ID from a username.
:param user_name: Name of user to get user id for.
:returns: User id string.
"""
user = self.mm_client.users.get_user_by_username(username=user_name, )
return user["id"]
def _check_env_vars(self):
"""Check that all of the required environment variables are set.
If not, raise exception noting the ones that are missing.
:raises: MissingEnvVars.
"""
missing_vars = list(k for k, v in config_vars.items() if v is None)
if len(missing_vars) > 0:
error_string = "\n\t".join(missing_vars)
raise MissingEnvVars(
"The following environment variables are required but not set:\n\t{}"
.format(error_string))
def _attach_file(self, filename, channel_id):
"""Attach the given filename into the given channel.
:param filename: Name of file to attach.
:param channel_id: Id string of channel to attach file to.
:returns; Id string of file attachment.
"""
response = self.mm_client.files.upload_file(
channel_id=channel_id, files={"files": (filename, open(filename))})
try:
file_id = response["file_infos"][0]["id"]
except (KeyError, IndexError):
raise FileUploadException(
"Unable to upload file '{}'".format(filename))
return file_id
# on parcoure un set de messages et on les supprime s'ils sont à nous
# ici ce qui est degueu (entre autre) c'est que la ref à myUserID
# est déclarée en dehors de la fonction
def delete_posts(handler, msg_list):
for msg_id in msg_list:
msg = foo.posts.get_post(msg_id)
if (msg['user_id'] == myUserID):
# print(msg['message'])
print("Pouet ==> Pan ==> -=RIP=-")
foo.posts.delete_post(msg_id)
foo.login()
myuser = foo.users.get_user_by_username(myLogin)
myUserID = myuser['id']
myTeam = foo.teams.get_user_teams(myUserID)
myTeamID = myTeam[0]['id']
myChannelsList = foo.channels.get_channels_for_user(myUserID, myTeamID)
for myChannel in myChannelsList: #parcours de mes chans
myChannelID = myChannel['id']
page = 0
myChannelMessageLength = 1
# tant qu'il reste des messages dans le set de msg de la page
while (myChannelMessageLength != 0):
# provient de l'API V4, et permet d'accéder
# à des options supplémentaires
options = {'page': page, 'per_page': PER_PAGE}
class MattermostBackend(ErrBot):
def __init__(self, config):
super().__init__(config)
identity = config.BOT_IDENTITY
self._login = identity.get("login", None)
self._password = identity.get("password", None)
self._personal_access_token = identity.get("token", None)
self._mfa_token = identity.get("mfa_token", None)
self.team = identity.get("team")
self._scheme = identity.get("scheme", "https")
self._port = identity.get("port", 8065)
self.cards_hook = identity.get("cards_hook", None)
self.url = identity.get("server").rstrip("/")
self.insecure = identity.get("insecure", False)
self.timeout = identity.get("timeout", DEFAULT_TIMEOUT)
self.teamid = ""
self.token = ""
self.bot_identifier = None
self.driver = None
self.md = md()
self.event_handlers = {
"posted": [self._message_event_handler],
"status_change": [self._status_change_event_handler],
"hello": [self._hello_event_handler],
"user_added": [self._room_joined_event_handler],
"user_removed": [self._room_left_event_handler],
}
def set_message_size_limit(self, limit=16377, hard_limit=16383):
"""
Mattermost message limit is 16383 chars, need to leave some space for
backticks when messages are split
"""
super().set_message_size_limit(limit, hard_limit)
@property
def userid(self):
return "{}".format(self.bot_identifier.userid)
@property
def mode(self):
return "mattermost"
def username_to_userid(self, name):
"""Converts a name prefixed with @ to the userid"""
name = name.lstrip("@")
user = self.driver.users.get_user_by_username(username=name)
if user is None:
raise UserDoesNotExistError("Cannot find user {}".format(name))
return user["id"]
def register_handler(self, event, handler):
if event not in self.event_handlers:
self.event_handlers[event] = []
self.event_handlers[event].append(handler)
@asyncio.coroutine
def mattermost_event_handler(self, payload):
if not payload:
return
payload = json.loads(payload)
if "event" not in payload:
log.debug("Message contains no event: {}".format(payload))
return
event = payload["event"]
event_handlers = self.event_handlers.get(event)
if event_handlers is None:
log.debug(
"No event handlers available for {}, ignoring.".format(event))
return
# noinspection PyBroadException
for event_handler in event_handlers:
try:
event_handler(payload)
except Exception:
log.exception(
"{} event handler raised an exception".format(event))
def _room_joined_event_handler(self, message):
log.debug("User added to channel")
if message["data"]["user_id"] == self.userid:
self.callback_room_joined(self)
def _room_left_event_handler(self, message):
log.debug("User removed from channel")
if message["broadcast"]["user_id"] == self.userid:
self.callback_room_left(self)
def _message_event_handler(self, message):
log.debug(message)
data = message["data"]
# In some cases (direct messages) team_id is an empty string
if data["team_id"] != "" and self.teamid != data["team_id"]:
log.info("Message came from another team ({}), ignoring...".format(
data["team_id"]))
return
broadcast = message["broadcast"]
if "channel_id" in data:
channelid = data["channel_id"]
elif "channel_id" in broadcast:
channelid = broadcast["channel_id"]
else:
log.error("Couldn't find a channelid for event {}".format(message))
return
channel_type = data["channel_type"]
if channel_type != "D":
channel = data["channel_name"]
else:
channel = channelid
text = ""
post_id = ""
file_ids = None
userid = None
if "post" in data:
post = json.loads(data["post"])
text = post["message"]
userid = post["user_id"]
if "file_ids" in post:
file_ids = post["file_ids"]
post_id = post["id"]
if "type" in post and post["type"] == "system_add_remove":
log.info("Ignoring message from System")
return
if "user_id" in data:
userid = data["user_id"]
if not userid:
log.error("No userid in event {}".format(message))
return
mentions = []
if "mentions" in data:
# TODO: Only user, not channel mentions are in here at the moment
mentions = self.mentions_build_identifier(
json.loads(data["mentions"]))
# Thread root post id
root_id = post.get("root_id", "")
if root_id == "":
root_id = post_id
msg = Message(
text,
extras={
"id":
post_id,
"root_id":
root_id,
"mattermost_event":
message,
"url":
"{scheme:s}://{domain:s}:{port:s}/{teamname:s}/pl/{postid:s}".
format(
scheme=self.driver.options["scheme"],
domain=self.driver.options["url"],
port=str(self.driver.options["port"]),
teamname=self.team,
postid=post_id,
),
},
)
if file_ids:
msg.extras["attachments"] = file_ids
# TODO: Slack handles bots here, but I am not sure if bot users is a concept in mattermost
if channel_type == "D":
msg.frm = MattermostPerson(self.driver,
userid=userid,
channelid=channelid,
teamid=self.teamid)
msg.to = MattermostPerson(
self.driver,
userid=self.bot_identifier.userid,
channelid=channelid,
teamid=self.teamid,
)
elif channel_type == "O" or channel_type == "P":
msg.frm = MattermostRoomOccupant(
self.driver,
userid=userid,
channelid=channelid,
teamid=self.teamid,
bot=self,
)
msg.to = MattermostRoom(channel, teamid=self.teamid, bot=self)
else:
log.warning(
"Unknown channel type '{}'! Unable to handle {}.".format(
channel_type, channel))
return
self.callback_message(msg)
if mentions:
self.callback_mention(msg, mentions)
def _status_change_event_handler(self, message):
"""Event handler for the 'presence_change' event"""
idd = MattermostPerson(self.driver, message["data"]["user_id"])
status = message["data"]["status"]
if status == "online":
status = ONLINE
elif status == "away":
status = AWAY
else:
log.error(
"It appears the Mattermost API changed, I received an unknown status type %s"
% status)
status = ONLINE
self.callback_presence(Presence(identifier=idd, status=status))
def _hello_event_handler(self, message):
"""Event handler for the 'hello' event"""
self.connect_callback()
self.callback_presence(
Presence(identifier=self.bot_identifier, status=ONLINE))
@lru_cache(1024)
def get_direct_channel(self, userid, other_user_id):
"""
Get the direct channel to another user.
If it does not exist, it will be created.
"""
try:
return self.driver.channels.create_direct_message_channel(
options=[userid, other_user_id])
except (InvalidOrMissingParameters, NotEnoughPermissions):
raise RoomDoesNotExistError(
"Could not find Direct Channel for users with ID {} and {}".
format(userid, other_user_id))
def build_identifier(self, txtrep):
"""
Convert a textual representation into a :class:`~MattermostPerson` or :class:`~MattermostRoom`
Supports strings with the following formats::
@username
~channelname
channelid
"""
txtrep = txtrep.strip()
if txtrep.startswith("~"):
# Channel
channelid = self.channelname_to_channelid(txtrep[1:])
if channelid is not None:
return MattermostRoom(channelid=channelid,
teamid=self.teamid,
bot=self)
else:
# Assuming either a channelid or a username
if txtrep.startswith("@"):
# Username
userid = self.username_to_userid(txtrep[1:])
else:
# Channelid
userid = txtrep
if userid is not None:
return MattermostPerson(
self.driver,
userid=userid,
channelid=self.get_direct_channel(self.userid,
userid)["id"],
teamid=self.teamid,
)
raise Exception("Invalid or unsupported Mattermost identifier: %s" %
txtrep)
def mentions_build_identifier(self, mentions):
identifier = []
for mention in mentions:
if mention != self.bot_identifier.userid:
identifier.append(self.build_identifier(mention))
return identifier
def serve_once(self):
self.driver = Driver({
"scheme": self._scheme,
"url": self.url,
"port": self._port,
"verify": not self.insecure,
"timeout": self.timeout,
"login_id": self._login,
"password": self._password,
"token": self._personal_access_token,
"mfa_token": self._mfa_token,
})
self.driver.login()
self.teamid = self.driver.teams.get_team_by_name(name=self.team)["id"]
userid = self.driver.users.get_user(user_id="me")["id"]
self.token = self.driver.client.token
self.bot_identifier = MattermostPerson(self.driver,
userid=userid,
teamid=self.teamid)
# noinspection PyBroadException
try:
loop = self.driver.init_websocket(
event_handler=self.mattermost_event_handler)
self.reset_reconnection_count()
loop.run_forever()
except KeyboardInterrupt:
log.info("Interrupt received, shutting down..")
return True
except Exception:
log.exception("Error reading from RTM stream:")
finally:
log.debug("Triggering disconnect callback")
self.disconnect_callback()
def _prepare_message(self, message):
to_name = "<unknown>"
if message.is_group:
to_channel_id = message.to.id
if message.to.name:
to_name = message.to.name
else:
self.channelid_to_channelname(channelid=to_channel_id)
else:
to_name = message.to.username
if isinstance(
message.to, RoomOccupant
): # private to a room occupant -> this is a divert to private !
log.debug(
"This is a divert to private message, sending it directly to the user."
)
channel = self.get_direct_channel(
self.userid, self.username_to_userid(to_name))
to_channel_id = channel["id"]
else:
to_channel_id = message.to.channelid
return to_name, to_channel_id
def send_message(self, message):
super().send_message(message)
try:
to_name, to_channel_id = self._prepare_message(message)
message_type = "direct" if message.is_direct else "channel"
log.debug("Sending %s message to %s (%s)" %
(message_type, to_name, to_channel_id))
body = self.md.convert(message.body)
log.debug("Message size: %d" % len(body))
parts = self.prepare_message_body(body, self.message_size_limit)
root_id = None
if message.parent is not None:
root_id = message.parent.extras.get("root_id")
for part in parts:
self.driver.posts.create_post(
options={
"channel_id": to_channel_id,
"message": part,
"root_id": root_id,
})
except (InvalidOrMissingParameters, NotEnoughPermissions):
log.exception(
"An exception occurred while trying to send the following message "
"to %s: %s" % (to_name, message.body))
def send_card(self, card: Card):
if isinstance(card.to, RoomOccupant):
card.to = card.to.room
to_humanreadable, to_channel_id = self._prepare_message(card)
attachment = {}
if card.summary:
attachment["pretext"] = card.summary
if card.title:
attachment["title"] = card.title
if card.link:
attachment["title_link"] = card.link
if card.image:
attachment["image_url"] = card.image
if card.thumbnail:
attachment["thumb_url"] = card.thumbnail
attachment["text"] = card.body
if card.color:
attachment["color"] = (COLORS[card.color]
if card.color in COLORS else card.color)
if card.fields:
attachment["fields"] = [{
"title": key,
"value": value,
"short": True
} for key, value in card.fields]
data = {"attachments": [attachment]}
if card.to:
if isinstance(card.to, MattermostRoom):
data["channel"] = card.to.name
try:
log.debug("Sending data:\n%s", data)
# We need to send a webhook - mattermost has no api endpoint for attachments/cards
# For this reason, we need to build our own url, since we need /hooks and not /api/v4
# Todo: Reminder to check if this is still the case
self.driver.webhooks.call_webhook(self.cards_hook, options=data)
except (
InvalidOrMissingParameters,
NotEnoughPermissions,
ContentTooLarge,
FeatureDisabled,
NoAccessTokenProvided,
):
log.exception(
"An exception occurred while trying to send a card to %s.[%s]"
% (to_humanreadable, card))
def prepare_message_body(self, body, size_limit):
"""
Returns the parts of a message chunked and ready for sending.
This is a staticmethod for easier testing.
Args:
body (str)
size_limit (int): chunk the body into sizes capped at this maximum
Returns:
[str]
"""
fixed_format = body.startswith("```") # hack to fix the formatting
parts = list(split_string_after(body, size_limit))
if len(parts) == 1:
# If we've got an open fixed block, close it out
if parts[0].count("```") % 2 != 0:
parts[0] += "\n```\n"
else:
for i, part in enumerate(parts):
starts_with_code = part.startswith("```")
# If we're continuing a fixed block from the last part
if fixed_format and not starts_with_code:
parts[i] = "```\n" + part
# If we've got an open fixed block, close it out
if parts[i].count("```") % 2 != 0:
parts[i] += "\n```\n"
return parts
def change_presence(self, status: str = ONLINE, message: str = ""):
pass # Mattermost does not have a request/websocket event to change the presence
def is_from_self(self, message: Message):
return self.bot_identifier.userid == message.frm.userid
def shutdown(self):
self.driver.logout()
super().shutdown()
def query_room(self, room):
"""Room can either be a name or a channelid"""
return MattermostRoom(room, teamid=self.teamid, bot=self)
def prefix_groupchat_reply(self, message: Message, identifier):
super().prefix_groupchat_reply(message, identifier)
message.body = "@{0}: {1}".format(identifier.nick, message.body)
def build_reply(self, message, text=None, private=False, threaded=False):
response = self.build_message(text)
response.frm = self.bot_identifier
if private:
response.to = message.frm
else:
response.to = (message.frm.room if isinstance(
message.frm, RoomOccupant) else message.frm)
if threaded:
response.extras["root_id"] = message.extras.get("root_id")
self.driver.posts.get_post(message.extras.get("root_id"))
response.parent = message
return response
def get_public_channels(self):
channels = []
page = 0
channel_page_limit = 200
while True:
channel_list = self.driver.channels.get_public_channels(
team_id=self.teamid,
params={
"page": page,
"per_page": channel_page_limit
},
)
if len(channel_list) == 0:
break
else:
channels.extend(channel_list)
page += 1
return channels
def channels(self, joined_only=False):
channels = []
channels.extend(
self.driver.channels.get_channels_for_user(user_id=self.userid,
team_id=self.teamid))
if not joined_only:
public_channels = self.get_public_channels()
for channel in public_channels:
if channel not in channels:
channels.append(channel)
return channels
def rooms(self):
"""Return public and private channels, but no direct channels"""
rooms = self.channels(joined_only=True)
channels = [channel for channel in rooms if channel["type"] != "D"]
return [
MattermostRoom(channelid=channel["id"],
teamid=channel["team_id"],
bot=self) for channel in channels
]
def channelid_to_channelname(self, channelid):
"""Convert the channelid in the current team to the channel name"""
channel = self.driver.channels.get_channel(channel_id=channelid)
if "name" not in channel:
raise RoomDoesNotExistError(
"No channel with ID {} exists in team with ID {}".format(
id, self.teamid))
return channel["name"]
def channelname_to_channelid(self, name):
"""Convert the channelname in the current team to the channel id"""
channel = self.driver.channels.get_channel_by_name(team_id=self.teamid,
channel_name=name)
if "id" not in channel:
raise RoomDoesNotExistError(
"No channel with name {} exists in team with ID {}".format(
name, self.teamid))
return channel["id"]
def __hash__(self):
return 0 # This is a singleton anyway
class MattermostBackend():
def __init__(self):
self.url = 'mattermost.example.com'
self._login = '******'
self._scheme = 'https'
self._port = 443
self.insecure = False
self.timeout = DEFAULT_TIMEOUT
self.teamid = ''
self.token = ''
self.driver = None
# Get password from Gnome keyring, matching the stored Chromium password
self._password = Secret.password_lookup_sync(
SECRET_SCHEMA, {
'username_value': self._login,
'action_url': 'https://mattermost.example.com/login'
}, None)
@asyncio.coroutine
def mattermost_event_handler(self, payload):
if not payload:
return
payload = json.loads(payload)
if 'event' not in payload:
log.debug('Message contains no event: {}'.format(payload))
return
event_handlers = {
'posted': self._message_event_handler,
}
event = payload['event']
event_handler = event_handlers.get(event)
if event_handler is None:
log.debug(
'No event handler available for {}, ignoring.'.format(event))
return
try:
event_handler(payload)
except Exception:
log.exception(
'{} event handler raised an exception. Exiting.'.format(event))
sys.exit(1)
def _message_event_handler(self, message):
log.debug(message)
data = message['data']
broadcast = message['broadcast']
if 'channel_id' in data:
channelid = data['channel_id']
elif 'channel_id' in broadcast:
channelid = broadcast['channel_id']
else:
log.error("Couldn't find a channelid for event {}".format(message))
return
channel_type = data['channel_type']
if channel_type != 'D':
channel = data['channel_name']
if 'team_id' in data:
teamid = data['team_id']
if teamid:
team = self.driver.api['teams'].get_team(team_id=teamid)
teamname = team['display_name']
else:
channel = channelid
teamname = None
text = ''
userid = None
if 'post' in data:
post = json.loads(data['post'])
text = post['message']
userid = post['user_id']
if 'type' in post and post['type'] == 'system_add_remove':
log.info('Ignoring message from System')
return
if 'user_id' in data:
userid = data['user_id']
if not userid:
log.error('No userid in event {}'.format(message))
return
mentions = []
if 'mentions' in data:
mentions = json.loads(data['mentions'])
if mentions:
username = self.driver.api['users'].get_user(
user_id=userid)['username']
print('mentioned: ', teamname, '"', mentions, '"', username, text)
if self.userid in mentions:
if teamname:
self.notify(
'{} in {}/{}'.format(username, teamname, channel),
text)
else:
self.notify('{} in DM'.format(username), text)
log.info('"posted" event from {}: {}'.format(
self.driver.api['users'].get_user(user_id=userid)['username'],
text))
def notify(self, summary, desc=''):
self._notification = Notification(summary, desc)
def serve_once(self):
self.driver = Driver({
'scheme': self._scheme,
'url': self.url,
'port': self._port,
'verify': not self.insecure,
'timeout': self.timeout,
'login_id': self._login,
'password': self._password
})
self.driver.login()
self.userid = self.driver.api['users'].get_user(user_id='me')['id']
self.token = self.driver.client.token
try:
loop = self.driver.init_websocket(
event_handler=self.mattermost_event_handler)
loop.run_forever()
# loop.stop()
except KeyboardInterrupt:
log.info("Interrupt received, shutting down..")
Notify.uninit()
self.driver.logout()
return True
except Exception:
log.exception("Error reading from RTM stream:")
finally:
log.debug("Triggering disconnect callback")
from bot import Bot
from mattermostdriver import Driver
import asyncio
import json
import os
driver = Driver({
'url': os.getenv('MATTERMOST_URL') or 'chat.openshift.io',
'port': os.getenv('MATTERMOST_PORT') or 443,
'login_id': os.getenv('MATTERMOST_LOGIN_ID'),
'password': os.getenv('MATTERMOST_PASSWORD'),
'debug': False
})
# login to mattermost server
driver.login()
bot = Bot()
class MatterMostOutputChannel(OutputChannel):
"""Interact with the mattemost."""
@classmethod
def name(cls):
"""Every channel needs a name to identify it."""
return "mattermost_output"
def send_text_message(self, recipient_id, message):
"""Post message to user."""
driver.posts.create_post({
'channel_id': recipient_id,
'message': message
class EmojiReconciler:
"""Maintain state of custom emojis in Mattermost"""
def __init__(self, emoji_names, user):
self.user = user
self.emoji_names = emoji_names
self.mattermost = None
self.authenticate()
def authenticate(self):
"""Authenticate against the Mattermost server"""
url = urlparse(API_URL)
settings = {
"scheme": url.scheme,
"url": url.hostname,
"port": url.port,
"basepath": url.path,
"login_id": USERS[self.user]["email"],
"password": USERS[self.user]["password"],
}
self.mattermost = Mattermost(settings)
self.mattermost.login()
def create(self, name):
"""Create emojis using a specific user"""
with open(EMOJIS[name], "rb") as image:
return self.mattermost.emoji.create_custom_emoji(
name, {"image": image})
def delete(self, emoji):
"""Delete emojis using a specific user"""
self.mattermost.emoji.delete_custom_emoji(emoji["id"])
def get_actual(self):
"""Get list of existing custom emojis on Mattermost"""
emojis = []
count, previous_count = 0, 0
params = {"page": 0, "per_page": 200}
while True:
emojis += self.mattermost.emoji.get_emoji_list(params=params)
count = len(emojis)
if count - previous_count < 200:
break
params["page"] += 1
previous_count = count
return emojis
def get_expected(self):
"""Return list of desired emojis"""
return self.emoji_names
def reconcile(self):
"""Make the expected emojis match the actual emojis in Mattermost"""
actual_emojis = self.get_actual()
expected_emojis = self.get_expected()
emojis = []
for emoji in actual_emojis:
if emoji["name"] not in expected_emojis:
self.delete(emoji)
else:
emojis.append(emoji)
for name in expected_emojis:
if name not in [e["name"] for e in actual_emojis]:
emojis.append(self.create(name))
return emojis
def destroy(self):
"""Destroy all emojis on Mattermost"""
for emoji in self.get_actual():
self.delete(emoji)
return True
if event == "channel_viewed":
mark_channel_viewed(cur, conn, channel_id)
elif event == "posted":
if isinstance(message["data"]["post"], str):
message["data"]["post"] = json.loads(message["data"]["post"])
sender_id = message["data"]["post"]["user_id"]
if sender_id == user_id:
mark_channel_viewed(cur, conn, channel_id)
else:
mentions = message.get("data", {}).get("mentions", []) or []
omitted_users = message.get("broadcast", {}).get("omit_users",
[]) or []
if user_id in mentions and user_id not in omitted_users:
increment_channel_mention_count(cur, conn, channel_id)
conn.close()
with open(stdout_loc, "w+") as stdout:
with open(stderr_loc, "w+") as stderr:
with daemon.DaemonContext(stdout=stdout, stderr=stderr):
d = Driver(options=options)
d.login()
d.init_websocket(my_event_handler, websocket_cls=CustomWebsocket)
