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 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()]
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,
)
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
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 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 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)
class TestIMs(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)
# Register DM recipient
self.recipient_user = '******'
self.recipient_password = '******'
self.recipient_email = '*****@*****.**'
self.rocket.users_register(email=self.recipient_email,
name=self.recipient_user,
password=self.recipient_password,
username=self.recipient_user)
self.rocket = RocketChat(self.user, self.password)
def tearDown(self):
pass
def test_im_create(self):
im_create = self.rocket.im_create(self.recipient_user).json()
self.assertTrue(im_create.get('success'))
def test_im_send(self):
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_send = self.rocket.chat_post_message(room_id=room_id,
text='test').json()
self.assertTrue(im_send.get('success'))
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)
def handle(self, *args, **kwargs):
rocket = RocketChat(settings.ROCKET_USERNAME, settings.ROCKET_PASSWORD, server_url=settings.SERVER_URL, proxies=settings.PROXY_DICT)
channel_names = ["random", "lessons", "python", "django", "react"]
user_infos = [
("*****@*****.**", "Tom Rock", "Aa123456", "tom"),
("*****@*****.**", "Harry Rock", "Aa123456", "harry"),
("*****@*****.**", "Angelina Rock", "Aa123456", "angelina"),
("*****@*****.**", "Jerry Rock", "Aa123456", "jerry"),
]
for channel in channel_names:
rocket.channels_create(name = channel)
rocket.chat_post_message("Hello World!", channel= channel)
for user in user_infos:
rocket.users_create(email= user[0], name = user[1], password = user[2], username = user[3])
self.stdout.write(self.style.SUCCESS('5 channels, 5 messages and four users were created with success!'))
def post_rocketchat_message(config_file, msg):
# get config from file
r_cfg = get_config(config_file)
# Authentification
rocket = RocketChat(r_cfg['username'], r_cfg['password'], server_url=r_cfg['server_url'])
# post message
r = rocket.chat_post_message(msg, channel=r_cfg['channel'])
def post_rocketchat_message(config_file, msg):
# get config from file
r_cfg = get_config(config_file)
# Authentification
rocket = RocketChat(r_cfg['username'], r_cfg['password'], server_url=r_cfg['server_url'])
# post message
r = rocket.chat_post_message(msg, channel=r_cfg['channel'])
logging.info("response status code: %s" % r.status_code)
def check_merged_requests_for_upvotes(channels_name: str, projects: dict):
rocket = RocketChat(settings.ROCKET_USERNAME, settings.ROCKET_PASSWORD, server_url=settings.ROCKET_URL)
request_params = {"private_token": settings.GITLAB_TOKEN, "state": "merged",
"created_after": datetime.date.today() - datetime.timedelta(days=1)}
for project_id, approvers_number in projects.items():
url = f"{settings.GITLAB_URL}projects/{project_id}/merge_requests"
merge_requests = requests.get(url, params=request_params).json()
channel_message = f"Unapproved MRs:\n"
flag = False
for merge_request in merge_requests:
if merge_request.get('upvotes') < approvers_number:
flag = True
channel_message += merge_request.get('web_url') + '\n'
if flag:
rocket.chat_post_message(channel_message, channel=channels_name, alias='BOT NOTIFICATION')
else:
continue
class NotificationService:
"""
An alerting service for unresolvable import or merge issues.
"""
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 send_message(self, message):
"""Send a message to the RocketChat channel"""
response = self.service.chat_post_message(
message, channel=self.channel, alias=self.alias
)
logging.debug(response.json())
class RocketChatNotificationService(BaseNotificationService):
"""Implement the notification service for Rocket.Chat."""
def __init__(self, url, username, password, room):
"""Initialize the service."""
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 == HTTPStatus.OK:
if not resp.json()["success"]:
_LOGGER.error("Unable to post Rocket.Chat message")
else:
_LOGGER.error("Incorrect status code when posting message: %d",
resp.status_code)
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)
elif "Mostly cloudy" in message:
icon = ":white_sun_cloud: "
elif "Mostly clear" in message:
icon = ":white_sun_cloud:"
elif "thunderstorms" in message:
icon = ":cloud_lightning:"
elif "showers" in message:
icon = ":cloud_rain:"
else:
icon = ":sunny:"
# Add the thunderstorm cloud to the message as well
if "thunderstorms" in message:
message = message + " " + ":cloud_lightning:"
# Set the argument for the name to send rocket chat message or not
if argument == "morning":
timerun = ["Today", "Tonight"]
elif argument == "afternoon":
timerun = ["Tonight", "This Afternoon"]
elif argument == "tonight":
timerun = ["Tonight"]
else:
timerun = ""
if name in timerun:
# Send Rocket.chat Message.
rocket.chat_post_message(message,
channel='GENERAL',
alias='%s' % name,
emoji='%s' % icon).json()
count = count + 1
sys.exit()
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, settings, since=None):
if since is None:
hist = self.rocket.channels_history(settings['channel'],
count=10000).json()
msgs = hist['messages']
else:
old = dt.strftime(since, settings["parseDate"])
hist = self.rocket.channels_history(settings['channel'],
count=10000,
oldest=old).json()
msgs = hist['messages']
return msgs
def _retrieve_userlist(self):
count = 0
users = []
stop = False
while not stop:
req = self.rocket.users_list(count=50, offset=count).json()
count += 50
stop = count > req['total']
users.extend(req['users'])
return users
def get_name_from_id(self, id):
users = self._retrieve_userlist()
for user in users:
if user['_id'] == _id:
if 'username' in user:
return user['username']
elif 'name' in user:
return user['name']
else:
return user['_id']
return ""
def get_id_from_name(self, username):
users = self._retrieve_userlist()
for user in users:
if 'username' in user:
_username = user['username']
elif 'name' in user:
_username = user['name']
else:
_username = user['_id']
if _username == username:
return user['_id']
return ""
def get_active_users(self, settings, since, pic=False):
users = []
msgs = self._retrieve_msgs(settings, since)
for msg in msgs:
if not pic or (("attachments" in msg) and
(msg["attachments"] is not None) and
(len(msg["attachments"]) > 0) and
("image_url" in msg["attachments"][0])):
user = msg["u"]["username"]
if user not in users:
users.append(user)
return users
def get_image_list(self, settings, since):
imgs = []
msgs = self._retrieve_msgs(settings, since)
for msg in msgs:
if (("attachments" in msg) and (msg["attachments"] is not None)
and (len(msg["attachments"]) > 0)
and ("image_url" in msg["attachments"][0])):
user = msg["u"]["username"]
url = msg["attachments"][0]["image_url"]
date = dt.strptime(msg["ts"], settings["parseDate"])
imgs.append(dict(user=user, url=url, date=date))
return imgs
def check_special_string(self, settings, since, string, name=""):
dates = []
msgs = self._retrieve_msgs(settings, since)
for msg in msgs:
if string in msg['msg'] and (name == ""
or msg['u']['username'] == name):
date = dt.strptime(msg["ts"], settings["parseDate"])
dates.append(dict(fullstring=msg['msg'], date=date))
return dates
def get_raw_msgs(self, settings, since):
rmsgs = []
msgs = self._retrieve_msgs(settings, since)
for msg in msgs:
url = ""
if (("attachments" in msg) and (msg["attachments"] is not None)
and (len(msg["attachments"]) > 0)
and ("image_url" in msg["attachments"][0])):
url = msg["attachments"][0]["image_url"]
date = dt.strptime(msg["ts"], settings["parseDate"])
rmsg = msg['msg']
user = msg['user']
rmsgs.append(dict(user=user, date=date, msg=rmsg, url=url))
return rmsgs
def print_scores(self, settings, scores, to_chat=False):
url = ""
alias = ""
print("avatar: " + url + " alias: " + alias)
pprint(scores)
# Make the scoreboard and send it if required
out = "Tableau des scores : \n"
for name in scores:
out += name + " a totalisé " + str(
scores[name]['score']) + " points\n"
print(out)
if to_chat:
self.rocket.chat_post_message(out,
room_id=settings['channel'],
avatar=url,
alias=alias)
def handle(self, *args, **options):
proxyDict = {}
rocket = RocketChat(
settings.ROCKET_CHAT_LOGIN,
settings.ROCKET_CHAT_PASSWORD,
server_url=settings.ROCKET_CHAT_URL,
proxies=proxyDict
)
template = textwrap.dedent(
"""
Hello {name} :) !
I would like to let you know, that you are added as a team-member to {project_plular} which {project_be} listed now on brand new [SteemProjects.com](https://SteemProjects.com/) :) List of all your known project user will be able to find on your profile page: {profile_page}
What is a SteemProjects? If you are familiar with SteemTools, then think about it as better version of it :) Big difference is that SteemProjects is a community driven website. **You as a project member can add/modify information about your projects**.
SteemProjects is now in pre-release stage. It is now time to make sure, that all your Steem-related projects are added to database and are in the good shape. Here is a list of all your project which I know about:
"""
)
accounts = []
for account in Account.objects.filter(account_type__name='STEEM'):
if not account.profile:
accounts.append((account,))
else:
accounts.append(list(account.profile.account_set.all()))
for accounts_tuple in accounts:
membership = TeamMembership.objects.filter(account__in=accounts_tuple)
if not membership.exists():
continue
steem_name = accounts_tuple[0].name if not accounts_tuple[0].profile else accounts_tuple[0].profile.steem_account.name
chat_user_info = rocket.users_info(username=steem_name).json()
if not chat_user_info['success']:
print("User {} do not have account on steemit.chat".format(steem_name))
continue
else:
print ("User {} - ok".format(steem_name))
many_projects = membership.count() > 1
message = template.format(
name=steem_name,
profile_page="{}/@{}".format(settings.SITE_URL, steem_name),
project_plular="{} projects".format(membership.count()) if many_projects else "a project",
project_be="are" if many_projects else "is",
)
for tm in membership:
message += " - [{}]({})\n".format(
tm.project.name,
"{}{}".format(settings.SITE_URL, tm.project.get_absolute_url())
)
message += textwrap.dedent("""
Before editing a project or adding a new one, please read the instruction first: [{instruction_title}]({instruction_url}) - otherwise a result might be far from perfect.
In case of any question, don't hesitate to ask me! :)
""".format(
instruction_title='Tutorial: How to add/edit a project on SteemProjects.com',
instruction_url='https://steemit.com/utopian-io/@noisy/pre-release-tutorial-how-to-add-edit-a-project-on-steemprojects-com',
)
)
print("-" * 60)
print(message)
print("-" * 60)
ans = input('##### Send PM to @{}? [y/n/q]: '.format(steem_name))
if ans.lower() == 'y':
res = rocket.chat_post_message(text=message, channel="@{}".format(steem_name))
print(str(res.json()))
elif ans.lower() == 'q':
return
from rocketchat_API.rocketchat import RocketChat
###VARIABLES THAT YOU NEED TO SET MANUALLY IF NOT ON HEROKU#####
try:
SERVER_URL = os.environ['SERVER_URL']
BOT_USERNAME = os.environ['BOT_USERNAME']
BOT_PASS = os.environ['BOT_PASS']
MESSAGE = os.environ['WELCOME_MESSAGE']
except:
SERVER_URL = 'Manually set SERVER_URL if youre not running through heroku or have not set vars in ENV'
BOT_USERNAME = '******'
BOT_PASS = '******'
MESSAGE = 'Manually set the MESSAGE if youre not running through heroku or have not set vars in ENV'
###############################################################
rocket = RocketChat(BOT_USERNAME, BOT_PASS, server_url=SERVER_URL)
rocket.chat_post_message('good news everyone: I came to live!',
channel='GENERAL')
class RocketChatBot(OutputChannel):
@classmethod
def name(cls) -> Text:
return "rocketchat"
def __init__(self, user, password, server_url) -> None:
from rocketchat_API.rocketchat import RocketChat
self.rocket = RocketChat(user, password, server_url=server_url)
@staticmethod
def _convert_to_rocket_buttons(buttons: List[Dict]) -> List[Dict]:
return [{
"text": b["title"],
"msg": b["payload"],
"type": "button",
"msg_in_chat_window": True,
} for b in buttons]
async def send_text_message(self, recipient_id: Text, text: Text,
**kwargs: Any) -> None:
"""Send message to output channel"""
for message_part in text.split("\n\n"):
self.rocket.chat_post_message(message_part, room_id=recipient_id)
async def send_image_url(self, recipient_id: Text, image: Text,
**kwargs: Any) -> None:
image_attachment = [{"image_url": image, "collapsed": False}]
return self.rocket.chat_post_message(None,
room_id=recipient_id,
attachments=image_attachment)
async def send_attachment(self, recipient_id: Text, attachment: Text,
**kwargs: Any) -> None:
return self.rocket.chat_post_message(None,
room_id=recipient_id,
attachments=[attachment])
async def send_text_with_buttons(
self,
recipient_id: Text,
text: Text,
buttons: List[Dict[Text, Any]],
**kwargs: Any,
) -> None:
# 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(text,
room_id=recipient_id,
attachments=button_attachment)
async def send_elements(self, recipient_id: Text,
elements: Iterable[Dict[Text, Any]],
**kwargs: Any) -> None:
return self.rocket.chat_post_message(None,
room_id=recipient_id,
attachments=elements)
async def send_custom_json(self, recipient_id: Text,
json_message: Dict[Text,
Any], **kwargs: Any) -> None:
text = json_message.pop("text")
if json_message.get("channel"):
if json_message.get("room_id"):
logger.warning(
"Only one of `channel` or `room_id` can be passed to a RocketChat "
"message post. Defaulting to `channel`.")
del json_message["room_id"]
return self.rocket.chat_post_message(text, **json_message)
else:
json_message.setdefault("room_id", recipient_id)
return self.rocket.chat_post_message(text, **json_message)
import win32com.client
import re
from rocketchat_API.rocketchat import RocketChat
rocket = RocketChat('botname',
'botpassword',
server_url="https://rockertchaturl.com")
outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
folder = outlook.Folders("*****@*****.**")
inbox = folder.Folders("Inbox")
msg = inbox.Items
msg.sort("[ReceivedTime]", False)
msgs = msg.GetLast()
body = msgs.Body
links = re.findall(r'(https?://\S+)', body)
link = links[1]
link = link[:-1]
msg = "!parts \"" + link + "\""
rocket.chat_post_message(msg, channel="parts",
alias="INCOMING PARTS REQUEST").json()
def notify(title, message, url, username, password, room, retcode=None):
rocket = RocketChat(username, password, server_url=url)
msg = "**{}:** {}".format(title, message)
rocket.chat_post_message(msg, channel=room)
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'))
msg_id = chat_post_message.get('message').get('_id')
chat_get_message = self.rocket.chat_get_message(msg_id=msg_id).json()
self.assertEqual(chat_get_message.get('message').get('_id'), msg_id)
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 test_chat_post_react(self):
self.skipTest("Still not added but already documented endpoint")
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_react = self.rocket.chat_react(msg_id=message_id).json()
self.assertTrue(chat_react.get('success'))
def test_post_pin_unpin(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_pin_message = self.rocket.chat_pin_message(message_id).json()
self.assertTrue(chat_pin_message.get('success'))
self.assertEqual(
chat_pin_message.get('message').get('t'), 'message_pinned')
chat_unpin_message = self.rocket.chat_unpin_message(message_id).json()
self.assertTrue(chat_unpin_message.get('success'))
def test_post_star_unstar(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_star_message = self.rocket.chat_star_message(message_id).json()
self.assertTrue(chat_star_message.get('success'))
chat_unstar_message = self.rocket.chat_unstar_message(
message_id).json()
self.assertTrue(chat_unstar_message.get('success'))
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())
fields.append({"short": True, "title": "Pixiv ID", "value": image['pixiv_id']})
if image['tag_string_general'] != "":
fields.append({"short": False, "title": "Tags", "value": image['tag_string_general']})
print("Posting image #{} to channel {}".format(image['id'], CONFIG['rocketchat_channel']))
source_url = None
if source_url is None and image["pixiv_id"] not in ["", '""', "null", None]:
source_url = PIXIV_POST_URL.format(id=image['pixiv_id'])
if source_url is None and ("http://" in image["source"] or "https://" in image["source"]):
source_url = image["source"]
if source_url is None:
source_url = DANBOORU_POST_URL.format(id=image['id'])
rating = " ".join(filter(lambda x: "rating:" in x, CONFIG['tags']))
if not rating:
rating = "rating:{}".format(get_image_rating(image["rating"]))
res = rocketchat.chat_post_message(text=None, channel=CONFIG['rocketchat_channel'], attachments=[
{
"title": "Danbooru #{} - {}".format(image['id'], rating),
"title_link": source_url,
"image_url": image_url,
"fields": fields
}
])
if res.status_code != 200:
print("Posting failed! Error {}".format(res.status_code))
print(res.json())
else:
print("Done!")
class RocketChatBot(object):
USE_BUTTONS = False
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.unknown_command = [
'command not found',
]
self.handle_unknown = None
self.lastts = {}
self.command_character = command_character
self.conversations = {}
self.button_variants = {}
self.personal_ids: set = set()
def echo(self, message: Message):
self.send_message('@' + message.user.username + ' : ' + message.text,
message.chat.id)
def get_status(self, auser):
return self.api.users_get_presence(username=auser)
def send_photo(self, chat_id, file, *args, **kwargs):
self.api.rooms_upload(rid=chat_id, file=file, *args, **kwargs)
def send_chat_action(self, *args, **kwargs):
# No such methods in Rocket.Chat
pass
def post_new_message(self, obj):
response = self.api.call_api_post("chat.postMessage", **obj)
print(response)
def send_message(self, channel_id, msg, reply_markup=None):
attachments, msg = self.get_attachments(reply_markup, channel_id, msg)
# pprint(attachments)
response = self.api.chat_post_message(channel=channel_id,
text=msg,
attachments=attachments)
if response.status_code // 100 > 2:
logging.error(response.json().get(
"error", "Error in sending message: {}".format(response.text)))
def get_attachments(self, reply_markup, user_id, msg):
if reply_markup is None:
return None, msg
if self.USE_BUTTONS:
return reply_markup.to_json(), msg
else:
msg += reply_markup.get_text()
self.button_variants.update({user_id: reply_markup.get_variants()})
return None, msg
def reply_to(self, message: Message, *args, **kwargs):
return self.send_message(message.chat.id, *args, **kwargs)
def register_next_step_handler(self, message: Message, f: Callable, *args,
**kwargs):
self.conversations.update({message.from_user.id: (f, args, kwargs)})
def get_user(self, username: str):
return self.api.users_info(username=username)
def add_dm_handler(self, command, action):
self.commands.append((command, action))
def add_auto_answer(self, triggers, answers):
self.auto_answers.append((triggers, answers))
def add_direct_answer(self, triggers, answers):
self.direct_answers.append((triggers, answers))
def set_unknown_handler(self, action):
self.handle_unknown = action
def handle_command_character_message(self, message, channel_id):
msg = message['msg'].lstrip(self.command_character)
command = msg.split()[0].lower()
arguments = " ".join(msg.split()[1:])
user = message['u']['username']
attachments = message['attachments']
pass_message = Message(message_id=message["_id"],
text=msg,
chat=Chat(chat_id=channel_id),
user=User.from_message(message),
attachments=attachments,
json=message)
for cmd_list in self.commands:
if command.lower() in cmd_list[0]:
cmd_list[1](pass_message)
return
if not self.handle_auto_answer(message, self.direct_answers,
channel_id):
self.send_message('@' + user + ' :' + choice(self.unknown_command),
channel_id)
def handle_direct_message(self, message, channel_id):
msg = message['msg'].partition('@' + self.botname)[2].strip() if message["msg"].startswith('@' + self.botname) \
else message["msg"].strip()
if len(msg) > 0:
command = msg.split()[0].lower()
# arguments = " ".join(msg.split()[1:])
user = User.from_message(message)
attachments = message['attachments']
pass_message = Message(message_id=message["_id"],
text=msg,
chat=Chat(chat_id=channel_id),
user=user,
attachments=attachments,
json=message)
conversation = self.conversations.get(user.id)
variants = self.button_variants.get(channel_id)
pass_message.text = variants.get(
pass_message.text,
pass_message.text) if variants else pass_message.text
if conversation is not None:
# Зарегистрирован следующий шаг
f, args, kwargs = conversation
self.conversations.pop(user.id)
f(pass_message, *args, **kwargs)
else:
# Следующий шаг не найден, обработка как обычно
for cmd_list in self.commands:
if command.lower() in cmd_list[0]:
cmd_list[1](pass_message)
return
if not self.handle_auto_answer(message, self.direct_answers,
channel_id):
if self.handle_unknown is not None:
self.handle_unknown(pass_message)
else:
self.send_message(
'@' + user.username + ' :' +
choice(self.unknown_command), channel_id)
else:
user = User.from_message(message)
attachments = message['attachments']
pass_message = Message(message_id=message["_id"],
text=msg,
chat=Chat(chat_id=channel_id),
user=user,
attachments=attachments,
json=message)
self.handle_unknown(pass_message)
def handle_auto_answer(self, message, answers, channel_id):
for kind in answers:
for k in kind[0]:
if k in message['msg'].lower():
self.send_message(
choice(kind[1]) + ' @' + message['u']['username'],
channel_id)
return True
return False
def handle_messages(self, messages, channel_id):
for message in messages['messages']:
if message['u']['username'] != self.botname:
pprint(message)
pprint(channel_id)
if message['u']['username'] == 'rocket.cat':
pass
# continue
Thread(target=self.handle_direct_message,
args=(message, channel_id)).start()
# if message['msg'].startswith('@' + self.botname) or channel_id in self.personal_ids:
# Thread(target=self.handle_direct_message, args=(message, channel_id)).start()
# elif self.command_character is not None and message['msg'].startswith(self.command_character):
# Thread(target=self.handle_command_character_message, args=(message, channel_id)).start()
# elif 'mentions' not in message or message.get('mentions') == []:
# Thread(target=self.handle_auto_answer, args=(message, self.auto_answers, channel_id)).start()
def load_ts(self, channel_id, messages):
if len(messages) > 0:
self.lastts[channel_id] = messages[0]['ts']
else:
self.lastts[channel_id] = ''
def load_channel_ts(self, channel_id):
self.load_ts(channel_id,
self.api.channels_history(channel_id).json()['messages'])
def load_group_ts(self, channel_id):
self.load_ts(channel_id,
self.api.groups_history(channel_id).json()['messages'])
def load_im_ts(self, channel_id):
response = self.api.im_history(channel_id).json()
if response.get('success'):
self.load_ts(channel_id,
self.api.im_history(channel_id).json()['messages'])
def process_messages(self, messages, channel_id):
try:
if "success" in messages:
if messages['success'] == False:
raise RuntimeError(messages['error'])
if len(messages['messages']) > 0:
self.lastts[channel_id] = messages['messages'][0]['ts']
self.handle_messages(messages, channel_id)
except Exception as e:
pprint(e)
def process_channel(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.channels_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def process_group(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.groups_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def process_im(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.im_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def run(self):
for channel in self.api.channels_list_joined().json().get('channels'):
self.load_channel_ts(channel.get('_id'))
for group in self.api.groups_list().json().get('groups'):
self.load_group_ts(group.get('_id'))
for im in self.api.im_list().json().get('ims'):
self.load_im_ts(im.get('_id'))
while 1:
for channel in self.api.channels_list_joined().json().get(
'channels'):
Thread(target=self.process_channel,
args=(channel.get('_id'), )).start()
for group in self.api.groups_list().json().get('groups'):
Thread(target=self.process_group,
args=(group.get('_id'), )).start()
for im in self.api.im_list().json().get('ims'):
if self.botname in im.get("usernames"):
self.personal_ids.add(im.get('_id'))
Thread(target=self.process_im, args=(im.get('_id'), )).start()
sleep(1)
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'))
with self.assertRaises(RocketMissingParamException):
self.rocket.chat_post_message(text='text')
msg_id = chat_post_message.get('message').get('_id')
chat_get_message = self.rocket.chat_get_message(msg_id=msg_id).json()
self.assertEqual(chat_get_message.get('message').get('_id'), msg_id)
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 test_chat_post_react(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_react = self.rocket.chat_react(msg_id=message_id).json()
self.assertTrue(chat_react.get('success'))
def test_post_pin_unpin(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_pin_message = self.rocket.chat_pin_message(message_id).json()
self.assertTrue(chat_pin_message.get('success'))
self.assertEqual(
chat_pin_message.get('message').get('t'), 'message_pinned')
chat_unpin_message = self.rocket.chat_unpin_message(message_id).json()
self.assertTrue(chat_unpin_message.get('success'))
def test_post_star_unstar(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_star_message = self.rocket.chat_star_message(message_id).json()
self.assertTrue(chat_star_message.get('success'))
chat_unstar_message = self.rocket.chat_unstar_message(
message_id).json()
self.assertTrue(chat_unstar_message.get('success'))
def test_chat_search(self):
chat_search = self.rocket.chat_search(room_id='GENERAL',
search_text='hello').json()
self.assertTrue(chat_search.get('success'))
def test_chat_get_message_read_receipts(self):
message_id = self.rocket.chat_post_message(
"hello", channel='GENERAL').json().get('message').get('_id')
chat_get_message_read_receipts = self.rocket.chat_get_message_read_receipts(
message_id=message_id).json()
self.assertTrue(chat_get_message_read_receipts.get('success'))
self.assertIn('receipts', chat_get_message_read_receipts)
from requests import sessions
from pprint import pprint
import requests
from rocketchat_API.rocketchat import RocketChat
rocket = RocketChat('username', 'password', server_url='rocket.chat:port')
url = 'https://icanhazdadjoke.com/slack'
headers = {'user-agent': 'My Library (Link to your github here)'}
response = requests.get(url, headers=headers)
results = response.json()
rocket.chat_post_message(results['attachments'][0]['text'],
channel='GENERAL',
alias='DAD JOKES!',
emoji=':joy:').json()
class TestIMs(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)
# Register DM recipient
self.recipient_user = '******'
self.recipient_password = '******'
self.recipient_email = '*****@*****.**'
self.rocket.users_register(email=self.recipient_email,
name=self.recipient_user,
password=self.recipient_password,
username=self.recipient_user)
self.rocket = RocketChat(self.user, self.password)
def tearDown(self):
pass
def test_im_create(self):
im_create = self.rocket.im_create(self.recipient_user).json()
self.assertTrue(im_create.get('success'))
def test_im_send(self):
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_send = self.rocket.chat_post_message(room_id=room_id,
text='test').json()
self.assertTrue(im_send.get('success'))
def test_im_list(self):
self.rocket.im_create(self.recipient_user)
im_list = self.rocket.im_list().json()
self.assertTrue(im_list.get('success'))
def test_im_close_open(self):
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_close = self.rocket.im_close(room_id).json()
self.assertTrue(im_close.get('success'))
im_open = self.rocket.im_open(room_id).json()
self.assertTrue(im_open.get('success'))
def test_im_set_topic(self):
topic = 'this is my new topic'
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_set_topic = self.rocket.im_set_topic(room_id, topic).json()
self.assertTrue(im_set_topic.get('success'))
self.assertEqual(im_set_topic.get('topic'), topic,
'Topic set does not match topic returned')
def test_im_list_everyone(self):
im_list_everyone = self.rocket.im_list_everyone().json()
self.assertTrue(im_list_everyone.get('success'))
def test_im_history(self):
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_history = self.rocket.im_history(room_id).json()
self.assertTrue(im_history.get('success'))
def test_im_messages_others(self):
# ToDo: Try changing the access configuration so endpoint can be successfully tested
im_create = self.rocket.im_create(self.recipient_user).json()
room_id = im_create.get('room').get('_id')
im_messages_others = self.rocket.im_messages_others(room_id).json()
self.assertFalse(im_messages_others.get('success'))
def test_im_files(self):
im_create = self.rocket.im_create(self.recipient_user).json()
self.assertTrue(im_create.get('success'))
im_files = self.rocket.im_files(
room_id=im_create.get('room').get('_id')).json()
self.assertTrue(im_files.get('success'))
im_files = self.rocket.im_files(user_name=self.recipient_user).json()
self.assertTrue(im_files.get('success'))
with self.assertRaises(RocketMissingParamException):
self.rocket.im_files()
def test_im_counters(self):
im_create = self.rocket.im_create(self.recipient_user).json()
self.assertTrue(im_create.get('success'))
im_counters = self.rocket.im_counters(
room_id=im_create.get('room').get('_id')).json()
self.assertTrue(im_counters.get('success'))
im_counters = self.rocket.im_counters(
user_name=self.rocket.me().json().get('_id')).json()
self.assertTrue(im_counters.get('success'))
with self.assertRaises(RocketMissingParamException):
self.rocket.im_counters()
class RocketChatBot(object):
def __init__(self, botname, passwd, server):
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 = {}
def echo(self, msg, user, channel_id):
self.send_message('@' + user + ' : ' + msg, channel_id)
def get_status(self, auser):
return self.api.users_get_presence(username=auser)
def send_message(self, msg, channel_id):
self.api.chat_post_message(channel=channel_id, text=msg)
def add_dm_handler(self, command, action):
self.commands.append((command, action))
def add_auto_answer(self, triggers, answers):
self.auto_answers.append((triggers, answers))
def add_direct_answer(self, triggers, answers):
self.direct_answers.append((triggers, answers))
def handle_direct_message(self, message, channel_id):
msg = message['msg'].lstrip('@' + self.botname).strip()
if len(msg) > 0:
command = msg.split()[0].lower()
arguments = " ".join(msg.split()[1:])
user = message['u']['username']
for cmd_list in self.commands:
if command.lower() in cmd_list[0]:
cmd_list[1](arguments, user, channel_id)
return
if not self.handle_auto_answer(message, self.direct_answers,
channel_id):
self.send_message(
'@' + user + ' :' + choice(self.unknow_command),
channel_id)
else:
self.send_message('Here I am', channel_id)
def handle_auto_answer(self, message, answers, channel_id):
for kind in answers:
for k in kind[0]:
if k in message['msg'].lower():
self.send_message(
choice(kind[1]) + ' @' + message['u']['username'],
channel_id)
return True
return False
def handle_messages(self, messages, channel_id):
for message in messages['messages']:
if message['u']['username'] != self.botname:
pprint(message)
if message['u']['username'] == 'rocket.cat':
continue
if message['msg'].startswith('@' + self.botname):
Thread(target=self.handle_direct_message,
args=(message, channel_id)).start()
elif 'mentions' not in message or message.get(
'mentions') == []:
Thread(target=self.handle_auto_answer,
args=(message, self.auto_answers,
channel_id)).start()
def load_ts(self, channel_id, messages):
if len(messages) > 0:
self.lastts[channel_id] = messages[0]['ts']
else:
self.lastts[channel_id] = ''
def load_channel_ts(self, channel_id):
self.load_ts(channel_id,
self.api.channels_history(channel_id).json()['messages'])
def load_group_ts(self, channel_id):
self.load_ts(channel_id,
self.api.groups_history(channel_id).json()['messages'])
def load_im_ts(self, channel_id):
response = self.api.im_history(channel_id).json()
if response.get('success'):
self.load_ts(channel_id,
self.api.im_history(channel_id).json()['messages'])
def process_messages(self, messages, channel_id):
try:
if "success" in messages:
if messages['success'] == False:
raise RuntimeError(messages['error'])
if len(messages['messages']) > 0:
self.lastts[channel_id] = messages['messages'][0]['ts']
self.handle_messages(messages, channel_id)
except Exception as e:
pprint(e)
def process_channel(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.channels_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def process_group(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.groups_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def process_im(self, channel_id):
if channel_id not in self.lastts:
self.lastts[channel_id] = ''
self.process_messages(
self.api.im_history(channel_id,
oldest=self.lastts[channel_id]).json(),
channel_id)
def run(self):
for channel in self.api.channels_list_joined().json().get('channels'):
self.load_channel_ts(channel.get('_id'))
for group in self.api.groups_list().json().get('groups'):
self.load_group_ts(group.get('_id'))
for im in self.api.im_list().json().get('ims'):
self.load_im_ts(im.get('_id'))
while 1:
for channel in self.api.channels_list_joined().json().get(
'channels'):
Thread(target=self.process_channel,
args=(channel.get('_id'), )).start()
for group in self.api.groups_list().json().get('groups'):
Thread(target=self.process_group,
args=(group.get('_id'), )).start()
for im in self.api.im_list().json().get('ims'):
Thread(target=self.process_im, args=(im.get('_id'), )).start()
sleep(1)
