コード例 #1
0
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)
コード例 #2
0
class ChatManager(object):
    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,
        )

    def create_user(self, user, password):
        # Create the user's account on RocketChat
        if not self.rocket:
            return
        account = self.rocket.users_create(user.email, user.name, password,
                                           user.handle.replace(" ",
                                                               "_")).json()
        self.create_team(user.team, account)

    def create_team(self, team, account):
        # Create a private team group
        if options.teams:
            group = self.has_group(team)
            if not group:
                groups = self.rocket.groups_create(
                    team.name.replace(" ", "_").lower()).json()
                group = groups["group"]
            self.rocket.groups_invite(group["_id"], account["user"]["_id"])

    def has_group(self, team):
        if not team:
            return False
        privaterooms = self.rocket.groups_list().json()
        if "groups" in privaterooms:
            for group in privaterooms["groups"]:
                if group["name"] == team.name.replace(" ", "_").lower():
                    return group
        return False

    def post_message(self, message, channel=None):
        # Send a global message
        if not channel:
            default_channel = self.get_default_channel()
            if default_channel:
                channel = "#%s" % default_channel
        if channel:
            self.rocket.chat_post_message(channel=channel, text=message)

    def get_default_channel(self):
        # Get the default channel
        channels = self.rocket.channels_list().json()
        if "channels" in channels:
            for channel in channels["channels"]:
                if channel["default"]:
                    return channel["name"]
        return None
コード例 #3
0
ファイル: views.py プロジェクト: kopuskopecik/django-projects
def home(request):
    rocket = RocketChat(settings.ROCKET_USERNAME,
                        settings.ROCKET_PASSWORD,
                        server_url=settings.SERVER_URL,
                        proxies=settings.PROXY_DICT)  # Login the system

    channels = []  # To record channels' info
    channel_list = rocket.channels_list().json()["channels"]
    for channel in channel_list:
        channels.append(
            (channel["name"], rocket.channels_history(
                room_id=channel["_id"]).json()["messages"][::-1]))

    messages_list = rocket.im_list().json()["ims"]
    messages_list = [i for i in messages_list if i["msgs"] > 0]
    message_contents = []
    for message in messages_list:
        message_contents.append(
            (message["usernames"][1], rocket.im_history(
                room_id=message["_id"]).json()["messages"][::-1]))

    me = rocket.me().json()  # Information about me like name, username, avatar

    context = {
        "messages_list": messages_list,
        "message_contents": message_contents,
        "channel_list": channel_list,
        "me": me,
        'channels': channels,
    }

    message = request.GET.get('message')  # receiving messages in the channels
    channel = request.GET.get("channel")
    if message and channel:
        rocket.chat_post_message(message, channel=channel)
        return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

    direct_message = request.GET.get(
        'direct')  # receiving messages in the direct chatting
    username = request.GET.get("username")
    if direct_message and username:
        print("burası çalıştı mı")
        rocket.chat_post_message(direct_message, channel=username)
        return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

    return render(request, 'home.html', context)
コード例 #4
0
class RocketComm:
	rocket = None

	def __init__(self, config):
		self.user = config['user']
		self.password = config['pass']
		self.URL = config['type'] + '://' + config['host']

	def login(self):
		self.rocket = RocketChat(self.user, self.password, self.URL)

	def logout(self):
		self.rocket.logout()

	def _retrieve_msgs(self, chn):
		hist = self.rocket.channels_history(chn, count=10000).json()
		msgs = hist['messages']

		return msgs
		
	def retrieve_channel_list(self):
		ids = []
	
		list = self.rocket.channels_list(count=10000).json()
		
		for chn in list["channels"]:
			id = chn['_id']
			ids.append(id)
			
		return ids

	def get_emotes(self, chn):
		emotes = []

		msgs = self._retrieve_msgs(chn)
		p = re.compile(":\w+?:") #emotes tracker
		
		for msg in msgs:
			rmsg = msg['msg']
			emote = p.findall(rmsg)
			emotes.extend(emote)

		return set(emotes)
コード例 #5
0
def get_channel_id(channel):
    tries = 0
    while True:
        tries += 1

        try:
            rocket = RocketChat(BOTNAME, PASSWORD, server_url=URL)
        except requests.exceptions.ConnectionError as e:
            log.error("Unable to connect to the RocketChat server: %s", e)
        except Exception as e:
            log.error("Unknown error occured: %s", e)
        else:
            break

        interval = tries * RECONNECT_INTERVAL
        print(f"Reconnecting in {interval} seconds...")
        time.sleep(interval)

    channels = rocket.channels_list().json()['channels']
    for c in channels:
        if c['name'] == channel:
            return c['_id']
コード例 #6
0
        "label": "democratie",
        "backgroundColor": getColor(),
        "data": messagesDataTsunamy['democraty']
    }, {
        "label": "ecologie",
        "backgroundColor": getColor(),
        "data": messagesDataTsunamy['ecology']
    }, {
        "label": "technologie",
        "backgroundColor": getColor(),
        "data": messagesDataTsunamy['technology']
    }]
}

while True:
    channels = rocket.channels_list(offset=index).json()
    totalChannels = channels['total']

    for channel in channels['channels']:
        dataMess = []
        dataUsers = []
        pprint(channel['name'])
        begin = date - monthdelta(12)
        end = begin + monthdelta(1)

        tsunamy = getTsunamy(channel)

        for id in range(0, 12):
            labels[id] = begin.strftime("%b %Y")
            begindate = begin.isoformat()
            enddate = end.isoformat()
コード例 #7
0
class TestChannels(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.channels_add_owner('GENERAL', username=self.user)
        self.rocket = RocketChat(self.user, self.password)

        testuser = self.rocket.users_info(username='******').json()
        if not testuser.get('success'):
            testuser = self.rocket.users_create('*****@*****.**',
                                                'testuser1', 'password',
                                                'testuser1').json()
            if not testuser.get('success'):
                self.fail("can't create test user")

        self.testuser_id = testuser.get('user').get('_id')

    def tearDown(self):
        self.rocket.users_delete(self.testuser_id)

    def test_channels_list(self):
        channels_list = self.rocket.channels_list().json()
        self.assertTrue(channels_list.get('success'))
        self.assertIn('channels', channels_list)

    def test_channels_list_joined(self):
        channels_list_joined = self.rocket.channels_list_joined().json()
        self.assertTrue(channels_list_joined.get('success'))
        self.assertIn('channels', channels_list_joined)

    def test_channels_info(self):
        channels_info = self.rocket.channels_info(room_id='GENERAL').json()
        self.assertTrue(channels_info.get('success'))
        self.assertIn('channel', channels_info)
        self.assertEqual(channels_info.get('channel').get('_id'), 'GENERAL')
        channel_name = channels_info.get('channel').get('name')
        channels_info = self.rocket.channels_info(channel=channel_name).json()
        self.assertTrue(channels_info.get('success'))
        self.assertIn('channel', channels_info)
        self.assertEqual(channels_info.get('channel').get('_id'), 'GENERAL')
        self.assertEqual(
            channels_info.get('channel').get('name'), channel_name)

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_info()

    def test_channels_history(self):
        channels_history = self.rocket.channels_history(
            room_id='GENERAL').json()
        self.assertTrue(channels_history.get('success'))
        self.assertIn('messages', channels_history)

    def test_channels_add_all(self):
        channels_add_all = self.rocket.channels_add_all('GENERAL').json()
        self.assertTrue(channels_add_all.get('success'))

    def test_channels_add_and_remove_moderator(self):
        me = self.rocket.me().json()
        channels_add_moderator = self.rocket.channels_add_moderator(
            'GENERAL', me.get('_id')).json()
        self.assertTrue(channels_add_moderator.get('success'))
        channels_remove_moderator = self.rocket.channels_remove_moderator(
            'GENERAL', me.get('_id')).json()
        self.assertTrue(channels_remove_moderator.get('success'))

    def test_channels_add_and_remove_owner(self):
        channels_add_owner = self.rocket.channels_add_owner(
            'GENERAL', user_id=self.testuser_id).json()
        self.assertTrue(channels_add_owner.get('success'),
                        channels_add_owner.get('error'))
        channels_remove_owner = self.rocket.channels_remove_owner(
            'GENERAL', user_id=self.testuser_id).json()
        self.assertTrue(channels_remove_owner.get('success'),
                        channels_remove_owner.get('error'))

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_add_owner(room_id='GENERAL')

    def test_channels_archive_unarchive(self):
        channels_archive = self.rocket.channels_archive('GENERAL').json()
        self.assertTrue(channels_archive.get('success'))
        channels_unarchive = self.rocket.channels_unarchive('GENERAL').json()
        self.assertTrue(channels_unarchive.get('success'))

    def test_channels_close_open(self):
        channels_close = self.rocket.channels_close('GENERAL').json()
        self.assertTrue(channels_close.get('success'))
        channels_open = self.rocket.channels_open('GENERAL').json()
        self.assertTrue(channels_open.get('success'))

    def test_channels_create_delete(self):
        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.assertTrue(channels_create.get('success'))
        self.assertEqual(name, channels_create.get('channel').get('name'))
        channels_delete = self.rocket.channels_delete(channel=name).json()
        self.assertTrue(channels_delete.get('success'))
        channels_create = self.rocket.channels_create(name).json()
        self.assertTrue(channels_create.get('success'))
        room_id = channels_create.get('channel').get('_id')
        channels_delete = self.rocket.channels_delete(room_id=room_id).json()
        self.assertTrue(channels_delete.get('success'))

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_delete()

    def test_channels_get_integrations(self):
        channels_get_integrations = self.rocket.channels_get_integrations(
            room_id='GENERAL').json()
        self.assertTrue(channels_get_integrations.get('success'))

    def test_channels_invite(self):
        channels_invite = self.rocket.channels_invite('GENERAL',
                                                      self.testuser_id).json()
        self.assertTrue(channels_invite.get('success'))

    def test_channels_kick(self):
        channels_kick = self.rocket.channels_kick('GENERAL',
                                                  self.testuser_id).json()
        self.assertTrue(channels_kick.get('success'))

    def test_channels_leave(self):
        channels_leave = self.rocket.channels_leave('GENERAL').json()
        self.assertFalse(channels_leave.get('success'))
        self.assertEqual(channels_leave.get('errorType'),
                         'error-you-are-last-owner')

        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.rocket.channels_invite(
            room_id=channels_create.get('channel').get('_id'),
            user_id=self.testuser_id)
        self.rocket.channels_add_owner(
            channels_create.get('channel').get('_id'),
            user_id=self.testuser_id).json()
        channels_leave = self.rocket.channels_leave(
            channels_create.get('channel').get('_id')).json()
        self.assertTrue(channels_leave.get('success'))

    def test_channels_rename(self):
        name = str(uuid.uuid1())
        name2 = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        channels_rename = self.rocket.channels_rename(
            room_id=channels_create.get('channel').get('_id'),
            name=name2).json()
        self.assertTrue(channels_rename.get('success'))
        self.assertEqual(channels_rename.get('channel').get('name'), name2)

    def test_channels_set_description(self):
        description = str(uuid.uuid1())
        channels_set_description = self.rocket.channels_set_description(
            'GENERAL', description).json()
        self.assertTrue(channels_set_description.get('success'))
        self.assertEqual(channels_set_description.get('description'),
                         description, 'Description does not match')

    def test_channels_set_join_code(self):
        join_code = str(uuid.uuid1())
        channels_set_join_code = self.rocket.channels_set_join_code(
            'GENERAL', join_code).json()
        self.assertTrue(channels_set_join_code.get('success'))

    def test_channels_set_read_only(self):
        channels_set_read_only = self.rocket.channels_set_read_only(
            'GENERAL', True).json()
        self.assertTrue(channels_set_read_only.get('success'))
        channels_set_read_only = self.rocket.channels_set_read_only(
            'GENERAL', False).json()
        self.assertTrue(channels_set_read_only.get('success'))

    def test_channels_set_topic(self):
        topic = str(uuid.uuid1())
        channels_set_topic = self.rocket.channels_set_topic('GENERAL',
                                                            topic).json()
        self.assertTrue(channels_set_topic.get('success'))
        self.assertEqual(channels_set_topic.get('topic'), topic,
                         'Topic does not match')

    def test_channels_set_type(self):
        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.assertTrue(channels_create.get('success'))

        channels_set_type = self.rocket.channels_set_type(
            channels_create.get('channel').get('_id'), 'p').json()
        self.assertTrue(channels_set_type.get('success'))
        self.assertTrue(channels_set_type.get('channel').get('t'), 'p')

        channels_set_type = self.rocket.channels_set_type(
            channels_create.get('channel').get('_id'), 'c').json()
        # should fail because this is no more a channel
        self.assertFalse(channels_set_type.get('success'))

    def test_channels_set_announcement(self):
        announcement = str(uuid.uuid1())
        channels_set_announcement = self.rocket.channels_set_announcement(
            'GENERAL', announcement).json()
        self.assertTrue(channels_set_announcement.get('success'))
        self.assertEqual(channels_set_announcement.get('announcement'),
                         announcement, 'Topic does not match')

    def test_channels_set_custom_fields(self):
        cf = {'key': 'value'}
        channels_set_custom_fields = self.rocket.channels_set_custom_fields(
            'GENERAL', cf).json()
        self.assertTrue(channels_set_custom_fields.get('success'))
        self.assertEqual(cf,
                         channels_set_custom_fields['channel']['customFields'])

    def test_channels_members(self):
        channels_members = self.rocket.channels_members(
            room_id='GENERAL').json()
        self.assertTrue(channels_members.get('success'))
        channels_members = self.rocket.channels_members(
            channel='general').json()
        self.assertTrue(channels_members.get('success'))

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_members()

    def test_channels_roles(self):
        channels_roles = self.rocket.channels_roles(room_id='GENERAL').json()
        self.assertTrue(channels_roles.get('success'))
        self.assertIsNotNone(channels_roles.get('roles'))
        channels_roles = self.rocket.channels_roles(room_name='general').json()
        self.assertTrue(channels_roles.get('success'))
        self.assertIsNotNone(channels_roles.get('roles'))

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_roles()

    def test_channels_files(self):
        channels_files = self.rocket.channels_files(room_id='GENERAL').json()
        self.assertTrue(channels_files.get('success'))

        channels_files = self.rocket.channels_files(room_name='general').json()
        self.assertTrue(channels_files.get('success'))

        with self.assertRaises(RocketMissingParamException):
            self.rocket.channels_files()

    def test_channels_get_all_user_mentions_by_channel(self):
        channels_get_all_user_mentions_by_channel = self.rocket.channels_get_all_user_mentions_by_channel(
            room_id='GENERAL').json()
        self.assertTrue(
            channels_get_all_user_mentions_by_channel.get('success'))
コード例 #8
0
ファイル: rchat.py プロジェクト: curiousrohan/gsoc2018
from rocketchat_API.rocketchat import RocketChat
import csv
import collections
import re
from pprint import pprint
from nltk.tag import StanfordNERTagger

channel_id = 'po5DghjugqfxwLahN'  #Channel ID for gsoc2018
user = ''  #Insert username here
password = ''  #Insert password here
url = 'http://www.clips.uantwerpen.be:3001/'

rocket = RocketChat(user, password, server_url=url)

#Storing all usernames from the channel in unames
channel_data = (rocket.channels_list().json())
for data in channel_data['channels']:
    if (data['_id'] == channel_id):
        unames = (data['usernames'])
#print(unames)
#Pulling all messages from the start of session in 1st March 2018 15:30 IST
data = rocket.channels_history(channel_id,
                               oldest='2018-03-01T10:02:30.156Z',
                               count=2000).json()

count = 0
datalist = []
for msgs in data['messages']:
    if (msgs['msg'] not in unames):  #Not considering channel join messages
        count += 1
        datalist.append(msgs['msg'])
コード例 #9
0
class TestChannels(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.channels_add_owner('GENERAL', username=self.user)
        self.rocket = RocketChat(self.user, self.password)
        self.testuser = self.rocket.users_create('*****@*****.**',
                                                 'testuser1', 'password',
                                                 'testuser1').json()
        if not self.testuser.get('success'):
            user_id = self.rocket.users_info(
                username='******').json().get('user').get('_id')
            self.rocket.users_delete(user_id)
            self.testuser = self.rocket.users_create('*****@*****.**',
                                                     'testuser1', 'password',
                                                     'testuser1').json()

    def tearDown(self):
        self.rocket.users_delete(self.testuser.get('user').get('_id'))

    def test_channels_list(self):
        channels_list = self.rocket.channels_list().json()
        self.assertTrue(channels_list.get('success'))
        self.assertIn('channels', channels_list)

    def test_channels_list_joined(self):
        channels_list_joined = self.rocket.channels_list_joined().json()
        self.assertTrue(channels_list_joined.get('success'))
        self.assertIn('channels', channels_list_joined)

    def test_channels_info(self):
        channels_info = self.rocket.channels_info(room_id='GENERAL').json()
        self.assertTrue(channels_info.get('success'))
        self.assertIn('channel', channels_info)
        self.assertEqual(channels_info.get('channel').get('_id'), 'GENERAL')

    def test_channels_history(self):
        channels_history = self.rocket.channels_history(
            room_id='GENERAL').json()
        self.assertTrue(channels_history.get('success'))
        self.assertIn('messages', channels_history)

    def test_channels_add_all(self):
        channels_add_all = self.rocket.channels_add_all('GENERAL').json()
        self.assertTrue(channels_add_all.get('success'))

    def test_channels_add_and_remove_moderator(self):
        me = self.rocket.me().json()
        channels_add_moderator = self.rocket.channels_add_moderator(
            'GENERAL', me.get('_id')).json()
        self.assertTrue(channels_add_moderator.get('success'))
        channels_remove_moderator = self.rocket.channels_remove_moderator(
            'GENERAL', me.get('_id')).json()
        self.assertTrue(channels_remove_moderator.get('success'))

    def test_channels_add_and_remove_owner(self):
        channels_add_owner = self.rocket.channels_add_owner(
            'GENERAL', user_id=self.testuser.get('user').get('_id')).json()
        self.assertTrue(channels_add_owner.get('success'),
                        channels_add_owner.get('error'))
        channels_remove_owner = self.rocket.channels_remove_owner(
            'GENERAL', user_id=self.testuser.get('user').get('_id')).json()
        self.assertTrue(channels_remove_owner.get('success'),
                        channels_remove_owner.get('error'))

    def test_channels_archive_unarchive(self):
        channels_archive = self.rocket.channels_archive('GENERAL').json()
        self.assertTrue(channels_archive.get('success'))
        channels_unarchive = self.rocket.channels_unarchive('GENERAL').json()
        self.assertTrue(channels_unarchive.get('success'))

    def test_channels_close_open(self):
        channels_close = self.rocket.channels_close('GENERAL').json()
        self.assertTrue(channels_close.get('success'))
        channels_open = self.rocket.channels_open('GENERAL').json()
        self.assertTrue(channels_open.get('success'))

    def test_channels_create(self):
        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.assertTrue(channels_create.get('success'))
        self.assertEqual(name, channels_create.get('channel').get('name'))

    def test_channels_get_integrations(self):
        channels_get_integrations = self.rocket.channels_get_integrations(
            room_id='GENERAL').json()
        self.assertTrue(channels_get_integrations.get('success'))

    def test_channels_invite(self):
        channels_invite = self.rocket.channels_invite(
            'GENERAL',
            self.testuser.get('user').get('_id')).json()
        self.assertTrue(channels_invite.get('success'))
        self.assertIn(
            self.testuser.get('user').get('username'),
            channels_invite.get('channel').get('usernames'))

    def test_channels_kick(self):
        channels_kick = self.rocket.channels_kick(
            'GENERAL',
            self.testuser.get('user').get('_id')).json()
        self.assertTrue(channels_kick.get('success'))
        self.assertNotIn(
            self.testuser.get('user').get('username'),
            channels_kick.get('channel').get('usernames'))

    def test_channels_leave(self):
        channels_leave = self.rocket.channels_leave('GENERAL').json()
        self.assertFalse(channels_leave.get('success'))
        self.assertEqual(channels_leave.get('errorType'),
                         'error-you-are-last-owner')

        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.rocket.channels_invite(
            room_id=channels_create.get('channel').get('_id'),
            user_id=self.testuser.get('user').get('_id'))
        self.rocket.channels_add_owner(
            channels_create.get('channel').get('_id'),
            user_id=self.testuser.get('user').get('_id')).json()
        channels_leave = self.rocket.channels_leave(
            channels_create.get('channel').get('_id')).json()
        self.assertTrue(channels_leave.get('success'))

    def test_channels_rename(self):
        name = str(uuid.uuid1())
        name2 = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        channels_rename = self.rocket.channels_rename(
            room_id=channels_create.get('channel').get('_id'),
            name=name2).json()
        self.assertTrue(channels_rename.get('success'))
        self.assertEqual(channels_rename.get('channel').get('name'), name2)

    def test_channels_set_description(self):
        description = str(uuid.uuid1())
        channels_set_description = self.rocket.channels_set_description(
            'GENERAL', description).json()
        self.assertTrue(channels_set_description.get('success'))
        self.assertEqual(channels_set_description.get('description'),
                         description, 'Description does not match')

    def test_channels_set_join_code(self):
        join_code = str(uuid.uuid1())
        channels_set_join_code = self.rocket.channels_set_join_code(
            'GENERAL', join_code).json()
        self.assertTrue(channels_set_join_code.get('success'))

    def test_channels_set_read_only(self):
        channels_set_read_only = self.rocket.channels_set_read_only(
            'GENERAL', True).json()
        self.assertTrue(channels_set_read_only.get('success'))
        channels_set_read_only = self.rocket.channels_set_read_only(
            'GENERAL', False).json()
        self.assertTrue(channels_set_read_only.get('success'))

    def test_channels_set_topic(self):
        topic = str(uuid.uuid1())
        channels_set_topic = self.rocket.channels_set_topic('GENERAL',
                                                            topic).json()
        self.assertTrue(channels_set_topic.get('success'))
        self.assertEqual(channels_set_topic.get('topic'), topic,
                         'Topic does not match')

    def test_channels_set_type(self):
        name = str(uuid.uuid1())
        channels_create = self.rocket.channels_create(name).json()
        self.assertTrue(channels_create.get('success'))

        channels_set_type = self.rocket.channels_set_type(
            channels_create.get('channel').get('_id'), 'p').json()
        self.assertTrue(channels_set_type.get('success'))
        self.assertTrue(channels_set_type.get('channel').get('t'), 'p')

        channels_set_type = self.rocket.channels_set_type(
            channels_create.get('channel').get('_id'), 'c').json()
        self.assertFalse(channels_set_type.get(
            'success'))  # should fail because this is no more a channel
コード例 #10
0
ファイル: app.py プロジェクト: tingyuan1437/flask-server-test
def sendMessage(mes,cha="integration_test"):
    rocket = RocketChat('aw5p', '@lexis1437', server_url='https://chat.newegg.org')
    pprint(rocket.me().json())
    pprint(rocket.channels_list().json())
    pprint(rocket.chat_post_message(mes, channel=cha, alias='AlertBot').json())
コード例 #11
0
    except json.JSONDecodeError as e:
        print("History file is corrupted! Please remove it or fix it.")
        sys.exit(4)

    RATE_LIMIT = CONFIG['rate_limit_ms'] / 1000
    HEADERS['X-Auth-Token'] = CONFIG['auth_token']
    HEADERS['X-User-Id'] = CONFIG['user_id']

    with sessions.Session() as session:
        print("Connecting to rocket.chat instance...")
        print("Rate limiter is set to {} seconds".format(RATE_LIMIT))
        ROCKET = RocketChat(user_id=CONFIG['user_id'],
                            auth_token=CONFIG['auth_token'],
                            server_url=CONFIG['server'],
                            session=session)
        CHANNELS = ROCKET.channels_list().json()['channels']
        time.sleep(RATE_LIMIT)

        for channel in CONFIG['channels']:
            print("Dumping channel {}...".format(channel['name']))
            channel_id = get_channel_id(channel['name'])
            if channel_id is None:
                print("Channel {} not found!".format(channel['name']))
                continue

            if not os.path.exists(channel['directory']):
                os.makedirs(channel['directory'])

            if not os.path.isdir(channel['directory']):
                print(
                    "Directory specified for channel {} ({}) is not a directory!"
コード例 #12
0
import datetime
from rocketchat_API.rocketchat import RocketChat

from sendmail.utils import get_config

config = get_config()
rocket_user = config['rocket_chat']['user']
rocket_pass = config['rocket_chat']['pass']
server_url = config['rocket_chat']['server_url']
rocket = RocketChat(rocket_user, rocket_pass, server_url=server_url)
channels = rocket.channels_list().json()['channels']

room_id_map = {}
for channel in channels:
    room_id_map[channel['name']] = channel['_id']


def get_sql(room_name):
    room_id = room_id_map[room_name]
    messages = rocket.channels_history(room_id=room_id,
                                       count=20).json()['messages']
    messages = list(filter(lambda msg: 't' not in msg, messages))
    index = next(i for i, m in enumerate(messages) if is_separate(m))
    if index == 0:
        return None
    messages = messages[:index]
    return build_sql(messages)


def add_separate_message(room_name, mail_version):
    room_id = room_id_map[room_name]
コード例 #13
0
from pprint import pprint
from rocketchat_API.rocketchat import RocketChat

rocket = RocketChat('StrangerCalling',
                    'user password',
                    server_url='http://192.168.86.120:3000')
pprint(rocket.me().json())
pprint(rocket.channels_list().json())
pprint(
    rocket.chat_post_message('good news everyone!', channel='GENERAL').json())
pprint(rocket.channels_history('GENERAL', count=5).json())

#Code from https://pypi.org/project/rocketchat-API/