def get_rocket_client(self, bot=False): """ this will return a working ROCKETCHAT_API instance """ if bot: if self.bot_user_id and self.bot_user_token: rocket = RocketChat( auth_token=self.bot_user_token, user_id=self.bot_user_id, server_url=self.url, ) else: rocket = RocketChat( self.bot_user, self.bot_password, server_url=self.url ) else: if self.admin_user_id and self.admin_user_token: rocket = RocketChat( auth_token=self.admin_user_token, user_id=self.admin_user_id, server_url=self.url, ) else: rocket = RocketChat( self.admin_user, self.admin_password, server_url=self.url ) return rocket
def __init__(self, login, password): self.login = login self.rocket = RocketChat(login, password, server_url='http://178.70.22.151:3000/') self.connectMQTT() print('Bot initialized')
class TestChat(unittest.TestCase): def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) def test_chat_post_update_delete_message(self): chat_post_message = self.rocket.chat_post_message("hello", channel='GENERAL').json() self.assertEqual(chat_post_message.get('channel'), 'GENERAL') self.assertEqual(chat_post_message.get('message').get('msg'), 'hello') self.assertTrue(chat_post_message.get('success')) chat_update = self.rocket.chat_update(room_id=chat_post_message.get('channel'), msg_id=chat_post_message.get('message').get('_id'), text='hello again').json() self.assertEqual(chat_update.get('message').get('msg'), 'hello again') self.assertTrue(chat_update.get('success')) chat_delete = self.rocket.chat_delete(room_id=chat_post_message.get('channel'), msg_id=chat_post_message.get('message').get('_id')).json() self.assertTrue(chat_delete.get('success'))
def __init__(self, username="", password="", server_url="", ssl_verify=False): self.rocket = RocketChat( user=username, password=password, server_url=server_url, ssl_verify=ssl_verify, )
class Main: def __init__(self, chat_server: str): self.__rocket = RocketChat(settings.ROCKET_USERNAME, settings.ROCKET_PASSWORD, server_url=settings.ROCKET_URL) self.__connection = sqlite3.connect(settings.DB_PATH) self.__cursor = self.__connection.cursor() self.__db_api = DBApi(self.__connection, self.__cursor) self.__reader = RocketChatReader(chat_server, self.__get_channels()) def start(self) -> None: self.__reader.connect() while True: request: Message = self.__reader.get_messages_queue().get() try: message = request.get_message().split(" ") if message[0] == "$bot_api": message = [msg for msg in message if msg != ""] response = self.__db_api.process(message) self.__rocket.chat_post_message( response, room_id=request.get_channel_id(), alias='BOT NOTIFICATION') except: self.__rocket.chat_post_message( "Oops. Server error.", room_id=request.get_channel_id(), alias='BOT NOTIFICATION') def __get_channels(self) -> list: self.__cursor.execute("""SELECT name FROM channel""") return [channel[0] for channel in self.__cursor.fetchall()]
class TestPermissions(unittest.TestCase): def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) def tearDown(self): pass def test_permissions_list_all(self): permissions_list_all = self.rocket.permissions_list_all().json() self.assertTrue(permissions_list_all.get('success')) self.assertIn('update', permissions_list_all) self.assertIn('remove', permissions_list_all) def test_permissions_list_all_with_updatedSince(self): permissions_list_all = self.rocket.permissions_list_all( updatedSince='2017-11-25T15:08:17.248Z').json() self.assertTrue(permissions_list_all.get('success')) self.assertIn('update', permissions_list_all) self.assertIn('remove', permissions_list_all)
def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password)
class TestRooms(unittest.TestCase): def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) def tearDown(self): pass def test_rooms_upload(self): # ToDo: Find a better way to test that this endpoint actually works fine (when using json and not data fails # silently) rooms_upload = self.rocket.rooms_upload( 'GENERAL', file='tests/avatar.png', description='hey there').json() self.assertTrue(rooms_upload.get('success')) def test_rooms_get(self): rooms_get = self.rocket.rooms_get().json() self.assertTrue(rooms_get.get('success'))
def main(): parser = argparse.ArgumentParser() parser.add_argument("--server", required=True, type=str) parser.add_argument("--user", default="", type=str) parser.add_argument("--password", default="", type=str) parser.add_argument("--pass_file", default="", type=str) parser.add_argument("--emojipack", default="", type=str) args = parser.parse_args() username = input("Username: "******"Password: "******"Logging in...") rocket = RocketChat(username, password, server_url=args.server) authenticated_user = rocket.me().json() print("Authenticated as '{}'".format(authenticated_user["name"])) if args.emojipack: try: emojis = yaml.safe_load(get_file_or_url(args.emojipack))["emojis"] except: print("Could not load emoji pack: {}".format(args.emojipack)) return do_create_all(emojis)
def __init__(self, addr, username, password, create_test_user=True, **kwargs): SplinterTestCase.__init__(self, addr, **kwargs) self.rocket = RocketChat(username, password, server_url=addr) self.schedule_pre_test_case('login') self.schedule_pre_test_case('test_check_version') if create_test_user: self.schedule_pre_test_case('create_user') self.username = username self.password = password self._rc_version = '0.70' self.test_username = '******' self.test_full_name = 'No Name' self.test_email = '*****@*****.**' self.test_password = '******' if create_test_user: self.schedule_test_case('remove_user')
class TestSettings(unittest.TestCase): def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) def tearDown(self): pass def test_settings(self): settings = self.rocket.settings().json() self.assertTrue(settings.get('success')) settings_get = self.rocket.settings_get( _id='API_Allow_Infinite_Count').json() self.assertTrue(settings_get.get('success')) self.assertTrue(settings_get.get('value')) settings_update = self.rocket.settings_update( _id='API_Allow_Infinite_Count', value=True).json() self.assertTrue(settings_update.get('success'))
def main(): args = parse_arguments() config = yaml.load(open(args.config)) with sessions.Session() as session: rocket = RocketChat( user_id=config["user_id"], auth_token=config["auth_token"], server_url=config["server"], session=session, ) channel_dump = pd.read_csv(args.channel_dump) with open(args.input) as f: destination_channels = [channel.strip() for channel in f] destination_channels = [ channel for channel in destination_channels if channel != "" ] nonexistent_channels = set(destination_channels) - set( channel_dump["name"]) assert len( nonexistent_channels ) == 0, "Some channels not found: " + str(nonexistent_channels) channel_ids = channel_dump[channel_dump["name"].isin( destination_channels)]["_id"] for channel_name, channel in zip(destination_channels, channel_ids): if not args.test: rocket.channels_add_all(channel) print('Added all users to channel "{}"'.format(channel_name))
def test_create_necessary_rooms(self): groups = ['hr', 'leave-coordination'] rocket = RocketChat(self.username, self.password, server_url=self.addr) for name in groups: rocket.groups_create(name, members=['meeseeks'])
def find_articles( rss_url, rc_url, rc_user, rc_password, rc_channel, rc_alias='yagizo', rc_icon=':new:', database='./feed.db', enable_post=True ): con = sqlite3.connect(database) cur = con.cursor() cur.execute('CREATE TABLE IF NOT EXISTS entries (published, link, tiltle)') rocket = RocketChat(rc_user, rc_password, server_url=rc_url) feeds = feedparser.parse(rss_url) for entry in feeds.entries: d = parse(entry.published).astimezone(timezone('Asia/Tokyo')) cur.execute('SELECT count(*) FROM entries WHERE link = ?', (entry.link, )) cnt = cur.fetchone()[0] if cnt == 0: print('[{}]{} ({})'.format(d.strftime("%Y/%m/%d"), entry.title, entry.link)) cur.execute('INSERT INTO entries VALUES (?, ?, ?)', (d, entry.link, entry.title,)) msg = '*{}* {}\n{}'.format(d.strftime("%Y/%m/%d"), entry.title, entry.link) if enable_post: rocket.chat_post_message(msg, channel=rc_channel, alias=rc_alias, emoji=rc_icon) con.commit() con.close()
class TestSubscriptions(unittest.TestCase): def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) def tearDown(self): pass def test_subscriptions_get(self): subscriptions_get = self.rocket.subscriptions_get().json() self.assertTrue(subscriptions_get.get('success')) self.assertIn('update', subscriptions_get) def test_subscriptions_get_one(self): subscriptions_get_one = self.rocket.subscriptions_get_one( room_id='GENERAL').json() self.assertTrue(subscriptions_get_one.get('success')) self.assertIn('subscription', subscriptions_get_one) def test_subscriptions_unread(self): subscriptions_unread = self.rocket.subscriptions_unread( room_id='GENERAL').json() self.assertTrue(subscriptions_unread.get('success'), 'Call did not succeed')
def main(): args = parse_arguments() config = yaml.load(open(args.config), Loader=yaml.SafeLoader) with sessions.Session() as session: rocket = RocketChat( user_id=config["user_id"], auth_token=config["auth_token"], server_url=config["server"], session=session, ) channels_params = get_params(args.filter_featured, args.regexp) count = 50 # number of channels per page (default 50) channels_list: List[Dict] = [] channels_json = rocket.channels_list(count=count, **channels_params).json() channels_list.extend(channels_json["channels"]) total = channels_json["total"] print(f"Found {total} channels") for offset in tqdm(range(count, total, count)): channels_json = rocket.channels_list( offset=offset, count=count, **channels_params ).json() channels_list.extend(channels_json["channels"]) channels_df = postprocess(pd.DataFrame(channels_list)) if args.add_owners: print("Adding owners") channels_df = add_owners(channels_df, rocket) channels_df.to_csv(args.output_file, index=False)
def send(start, stop): """send expiring access chat remninders.""" if current_app.config['ROCKET_ENABLED'] != 1: print("rocket sending is disabled %s" % current_app.config['ROCKET_ENABLED']) return print("start: %s stop: %s" % (start, stop)) access = Access.query.filter( func.datetime(Access.stop) > start, func.datetime(Access.stop) < stop).all() rocket = RocketChat(current_app.config['ROCKET_USER'], current_app.config['ROCKET_PASS'], server_url=current_app.config['ROCKET_URL']) for a in access: stopdate = a.stop.strftime("%Y-%m-%d") msg = f'''Access for: @{a.user.username} \ to: {a.role.name} \ expires at: {stopdate} \ mgr: @{a.role.service.manager.username} \ please act on this as needed''' pprint( rocket.chat_post_message( msg, channel=current_app.config['ROCKET_CHANNEL']).json()) time.sleep(1)
def rocketchat_send_message(test_result, config, exitstatus): timeout = config.option.rocket_timeout report_link = config.option.rocket_report_link rocket_domain = config.option.rocket_domain channel = config.option.rocket_channel ssl_verify = config.option.ssl_verify message_prefix = config.option.rocket_message_prefix rocket_username = ( config.option.rocket_username if config.option.rocket_username else "Regression testing results" ) rocket_pass = config.option.rocket_password if int(exitstatus) == 0: color = "#56a64f" emoji = config.option.rocket_success_emoji else: color = "#ff0000" emoji = config.option.rocket_failed_emoji final_results = "Passed=%s Failed=%s Skipped=%s Error=%s XFailed=%s XPassed=%s" % ( test_result.passed, test_result.failed, test_result.skipped, test_result.error, test_result.xfailed, test_result.xpassed, ) if report_link: final_results = "<%s|%s>" % (report_link, final_results) if message_prefix: final_results = "%s: %s" % (message_prefix, final_results) # # uncomment after fix 3.11.1 rocket issue # # https://github.com/RocketChat/Rocket.Chat/issues/20556 # # results_pattern = { # "color": color, # "text": final_results, # "mrkdwn_in": [ # "text", # "pretext", # ] # } rocket_client = RocketChat( user=rocket_username, password=rocket_pass, server_url=rocket_domain, ssl_verify=ssl_verify, ) rocket_client.chat_post_message( # attachments=[results_pattern], # uncomment after fix3.11.1 rocket channel=channel, alias=rocket_username, emoji=emoji, text=final_results, timeout=timeout, )
def create_session(user=None, password=None, server_url=None): global rocket_api_session if not rocket_api_session: rocket_api_session = RocketChat(user, password, server_url) pprint(rocket_api_session.me().json()) return rocket_api_session
def __init__(self): """A RocketChat channel""" self.user = os.environ.get("ROCKETCHAT_USER") self.password = os.environ.get("ROCKETCHAT_PASS") self.url = os.environ.get("ROCKETCHAT_URL") self.service = RocketChat(self.user, self.password, server_url=self.url) self.channel = os.environ.get("ROCKETCHAT_CHANNEL", "hatchbuck") self.alias = os.environ.get("ROCKETCHAT_ALIAS", "carddav2hatchbuck")
def __init__(self, chat_server: str): self.__rocket = RocketChat(settings.ROCKET_USERNAME, settings.ROCKET_PASSWORD, server_url=settings.ROCKET_URL) self.__connection = sqlite3.connect(settings.DB_PATH) self.__cursor = self.__connection.cursor() self.__db_api = DBApi(self.__connection, self.__cursor) self.__reader = RocketChatReader(chat_server, self.__get_channels())
def loginUser(self, user_name, user_pass): rocket = RocketChat('Admin', 'chat.service', server_url=self.chat_ip_port, proxies=None) print(user_name + " " + user_pass) data = rocket.login(user_name, user_pass).json() status = data["status"] authToken = data["data"]["authToken"] print(status + " " + authToken) return (status, authToken)
def __init__(self, botname, passwd, server): self.botname = botname self.api = RocketChat(botname, passwd, server, ssl_verify=True) self.commands = [(['echo', ], self.echo), (['ping', ], self.ping)] self.auto_answers = [] self.direct_answers = [] self.unknow_command = ['command not found', ] self.lastts = {}
def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket.channels_add_owner('GENERAL', username=self.user) self.rocket = RocketChat(self.user, self.password) self.testuser = self.rocket.users_create('*****@*****.**', 'user0', 'password', 'user0').json()
def __init__(self, channel_names: List[str]): threading.Thread.__init__(self, daemon=True) self.__rocket = RocketChat(settings.ROCKET_USERNAME, settings.ROCKET_PASSWORD, server_url=settings.ROCKET_URL) self.__ws = websocket.WebSocket() self.__messages_queue = queue.Queue() self.__channel_ids = list() self.__get_channel_ids(channel_names)
def setUp(self): self.rocket = RocketChat() self.user = '******' self.password = '******' self.email = '*****@*****.**' self.rocket.users_register(email=self.email, name=self.user, password=self.password, username=self.user) self.rocket = RocketChat(self.user, self.password) self.testuser = self.rocket.users_create('*****@*****.**', 'user0', 'password', 'user0').json() self.test_group_id = self.rocket.groups_create(str(uuid.uuid1())).json().get('group').get('_id')
def user_api_rocket_chat(auth_token, user_id): """ Returns an ApirocketChat instance using the given auth_token and user_id """ url_service = get_rocket_chat_settings().get('private_url_service', None) user_api_rocket_chat = ApiRocketChat(server_url=url_service) # pylint: disable=redefined-outer-name user_api_rocket_chat.headers['X-Auth-Token'] = auth_token user_api_rocket_chat.headers['X-User-Id'] = user_id return user_api_rocket_chat
def getUserInfo(self, userID, user_name): rocket = RocketChat('Admin', 'chat.service', server_url='http://www.chat.service', proxies=None) data = rocket.users_info(userID, user_name).json() status = data["success"] uId = data['user']['_id'] email = data['user']['emails'][0]['address'] userName = data['user']['name'] userNick = data['user']['username'] return (status, uId, email, userName, userNick)
def __init__(self, botname, passwd, server, command_character=None): self.botname = botname self.api = RocketChat(user=botname, password=passwd, server_url=server) self.commands = [(['echo', ], self.echo)] self.auto_answers = [] self.direct_answers = [] self.unknow_command = ['command not found', ] self.lastts = {} self.command_character = command_character
def registerUser(self, param): email = param['email'] username = param['username'] password = param['password'] rocket = RocketChat('Admin', 'chat.service', server_url=self.chat_ip_port, proxies=None) data = rocket.users_register(email, username, password, username).json() status = data['success'] uId = data['user']['_id'] return (status, uId)
class RocketChatBot(OutputChannel): @classmethod def name(cls): return "rocketchat" def __init__(self, user, password, server_url): from rocketchat_API.rocketchat import RocketChat self.rocket = RocketChat(user, password, server_url=server_url) def send_text_message(self, recipient_id, message): """Messages handler.""" for message_part in message.split("\n\n"): self.rocket.chat_post_message(message_part, roomId=recipient_id) def send_image_url(self, recipient_id, image_url): image_attachment = [{ "image_url": image_url, "collapsed": False, }] return self.rocket.chat_post_message(None, roomId=recipient_id, attachments=image_attachment) def send_attachment(self, recipient_id, attachment, message=""): return self.rocket.chat_post_message(None, roomId=recipient_id, attachments=[attachment]) @staticmethod def _convert_to_rocket_buttons(buttons): return [{"text": b['title'], "msg": b['payload'], "type": "button", "msg_in_chat_window": True} for b in buttons] def send_text_with_buttons(self, recipient_id, message, buttons, **kwargs): # implementation is based on # https://github.com/RocketChat/Rocket.Chat/pull/11473 # should work in rocket chat >= 0.69.0 button_attachment = [ {"actions": self._convert_to_rocket_buttons(buttons)}] return self.rocket.chat_post_message(message, roomId=recipient_id, attachments=button_attachment)
class RocketChatNotificationService(BaseNotificationService): """Implement the notification service for Rocket.Chat.""" def __init__(self, url, username, password, room): """Initialize the service.""" from rocketchat_API.rocketchat import RocketChat self._room = room self._server = RocketChat(username, password, server_url=url) def send_message(self, message="", **kwargs): """Send a message to Rocket.Chat.""" data = kwargs.get(ATTR_DATA) or {} resp = self._server.chat_post_message( message, channel=self._room, **data) if resp.status_code == 200: success = resp.json()["success"] if not success: _LOGGER.error("Unable to post Rocket.Chat message") else: _LOGGER.error("Incorrect status code when posting message: %d", resp.status_code)
def __init__(self, url, username, password, room): """Initialize the service.""" from rocketchat_API.rocketchat import RocketChat self._room = room self._server = RocketChat(username, password, server_url=url)
def __init__(self, user, password, server_url): from rocketchat_API.rocketchat import RocketChat self.rocket = RocketChat(user, password, server_url=server_url)