def __init__(self,
url,
username,
password,
channel_name,
team_name,
help_text,
message_handler,
port=8065,
scheme='https',
debug=False):
self.username = username
self.help_text = help_text
self.message_handler = message_handler
self.debug = debug
self.driver = Driver({
'url': url,
'port': port,
'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(username)
self.userid = res['id']
# get channel id for name
res = self.driver.channels.get_channel_by_name_and_team_name(
team_name, channel_name)
self.channel_id = res['id']
def __init__(self, config):
self.logger = logging.getLogger('lthub.mattermost.sync')
self.config = config
self.driver = Driver({
k: config[k]
for k in config.keys() & Driver.default_options.keys()
})
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 __init__(self,
url,
token,
channel_name,
team_name,
help_text,
message_handler,
port=8065,
scheme='https',
debug=False):
self.help_text = help_text
self.message_handler = message_handler
self.debug = debug
self.driver = Driver({
'url': url,
'port': port,
'token': token,
'scheme': scheme,
'debug': debug,
})
user_result = self.driver.login()
self.username = user_result["username"]
self.userid = user_result["id"]
# get channel id for name
res = self.driver.channels.get_channel_by_name_and_team_name(
team_name, channel_name)
self.channel_id = res['id']
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")
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 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 __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,
})
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 init_mattermost_driver():
driver = Driver({
'url': webhook.url,
'scheme': webhook.scheme,
'port': webhook.port,
'verify': webhook.verify
})
return driver
def create_driver(self):
self.driver = Driver({
'url': self.host,
'login_id': self.username,
'password': self.passwd,
'scheme': 'https' if self.https else 'http',
'port': self.port
})
def __init__(self):
connection_parameters = {
'url': settings.MATTERMOST_SERVER,
'port': settings.MATTERMOST_PORT,
'username': settings.MATTERMOST_LOGIN_ID,
'token': settings.MATTERMOST_ACCESS_TOKEN
}
self.mattermost_connection = Driver(connection_parameters)
def initialize(self):
self.state = "idle"
self.mm = None
# login data
self.username = self.settings.get("username", "")
self.token = self.settings.get("token", "")
self.login_id = self.settings.get("login_id", "")
self.password = self.settings.get("password", "")
# monitoring
self.ttl = self.settings.get("ttl", 10) * 60
self.notify_on_updates = self.settings.get("notify_on_updates", False)
LOG.debug("username: {}".format(self.username))
mm_driver_config = {
'url': self.settings.get("url", "chat.mycroft.ai"),
'scheme': self.settings.get("scheme", "https"),
'port': self.settings.get("port", 443),
'verify': self.settings.get("verify", True)
}
if self.token:
mm_driver_config['token'] = self.token
elif self.login_id and self.password:
mm_driver_config['login_id'] = self.login_id
mm_driver_config['password'] = self.password
if self.username:
self.mm = Driver(mm_driver_config)
try:
self.mm.login()
self.userid = \
self.mm.users.get_user_by_username(self.username)['id']
# TODO check if user is member of several teams?
self.teamid = self.mm.teams.get_team_members_for_user(
self.userid)[0]['team_id']
LOG.debug("userid: {} teamid: {}".format(
self.userid, self.teamid))
except (mme.ResourceNotFound, mme.HTTPError,
mme.NoAccessTokenProvided, mme.NotEnoughPermissions,
mme.InvalidOrMissingParameters) as e:
LOG.debug("Exception: {}".format(e))
self.mm = None
self.speak_dialog("mattermost.error", {'exception': e})
if self.mm:
# info on all subscribed public channels as returned by MM
self.channel_subscriptions = None
self.channel_subs_ts = 0
# basic info of channels
# channel_id, display_name, (unread) msg_count, mentions
self.channel_info = None
self.channel_info_ts = 0
self.usercache = {}
self.prev_unread = 0
self.prev_mentions = 0
self.monitoring = False
# Check and then monitor for credential changes
self.settings.set_changed_callback(self.on_websettings_changed)
def upload_file(connector=Driver(), channel_id="", path=None):
if path is not None:
f = connector.files.upload_file(channel_id, {
"files": open(path, "rb"),
"filename": path
})
return f["file_infos"][0]["id"]
else:
return None
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 __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_driver():
return Driver({
'url': config.get('myvars','HOST'),
'scheme': 'http',
'port': 8065,
'basepath': '/api/v4',
'verify': True,
'token': config.get('myvars','BOTTOKEN'),
'debug': False
});
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 __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 __init__(self, mail, pswd, url, tags=None, debug=False):
self.debug = debug
self.config = {"url": url,
"login_id": mail,
"password": pswd,
"scheme": "https",
"port": 443,
"verify": True,
"debug": debug}
self.driver = Driver(self.config)
self.tags = tags or []
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 __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_message(connector=Driver(),
msg="",
channel_id="",
mention="@channel",
files=list()):
file_ids = list()
for f in files:
file_ids.append(upload_file(connector, channel_id, f))
connector.posts.create_post({
"message": mention + " " + msg,
"channel_id": channel_id,
"file_ids": file_ids
})
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)
def __init__(self):
with open('settings.yaml', "r") as file:
self.parsed_data = yaml.safe_load(file)
self.matt = Driver({
'url':
self.parsed_data["Raccooner"]["mattermost"]["general"]["url"],
'token':
self.parsed_data["Raccooner"]["mattermost"]["general"]
["access_token"],
'port':
self.parsed_data["Raccooner"]["mattermost"]["general"]["port"],
'debug':
False
})
self.matt.login() # Automatic login
self.raccoon_stats = {} # Create an empty dictionary
def __init__(self, **kwargs):
"""Initialize Mattermost class which extends Chat ABC
Args:
**kwargs (dict): args to pass to Chat ABC
team_channel (str): required for posting to channel
channel_name (str): 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 __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']
