def __post_init__(self) -> None:
self._updatedAt = m.create(m.RcDatetime, self._updatedAt)
self.ts = m.try_create(m.RcDatetime, self.ts)
self.lm = m.try_create(m.RcDatetime, self.lm)
self.t = m.create(m.RoomType, self.t)
self.u = m.try_create(UserRef, self.u)
self.lastMessage = m.try_create(Message, self.lastMessage)
async def _get_or_create_public_room(master: master.Master,
roomname: str) -> m.Room:
result = (await master.rest.channels_info(channel=roomname)).json()
if not result['success']:
result = (await master.rest.channels_create(name=roomname)).json()
return m.create(m.Room, result['channel'])
async def _get_or_create_private_group(master: master.Master,
roomname: str) -> m.Room:
result = (await master.rest.groups_info(room_name=roomname)).json()
if not result['success']:
result = (await master.rest.groups_create(name=roomname)).json()
return m.create(m.Room, result['group'])
async def main() -> None:
loop = asyncio.get_event_loop()
masterbot = master.Master(c.SERVER, c.BOTNAME, c.PASSWORD, loop=loop)
# Get room info of the statusroom
await masterbot.rest.login(c.BOTNAME, c.PASSWORD)
result = (await
masterbot.rest.rooms_info(room_name=c.POLL_STATUS_ROOM)).json()
statusroom = m.create(m.Room, result['room'])
pollmanager = await pollutil.PollManager.create_pollmanager(
master=masterbot,
botname=c.BOTNAME,
statusroom=statusroom.to_roomref())
# Create commands
usage = com.Usage(master=masterbot)
ping = com.Ping(master=masterbot)
poll = com.Poll(master=masterbot, pollmanager=pollmanager)
# Add a bot reacting on direct messages
masterbot.bots.append(
bots.RoomTypeCommandBot(master=masterbot,
username=c.BOTNAME,
enable_direct_message=True,
commands=[usage, ping, poll]))
async with masterbot:
logging.info(f'{c.BOTNAME} is ready')
await masterbot.ddp.disconnection()
async def send_message(self, roomId: str, message: str) -> m.Message:
"""Send a message to a room
"""
response = await self.client.call("sendMessage", {
"rid": roomId,
"msg": message
})
return m.create(m.Message, response)
async def setup_bot() -> master.Master:
# Overwrite +1,+2,+3,ΓΌ4 emoji with custom ones
pollutil.NUMBER_EMOJI_TO_VALUE = {
':x1:': 1,
':x2:': 2,
':x3:': 3,
':x4:': 4,
}
loop = asyncio.get_event_loop()
masterbot = master.Master(c.SERVER, c.BOTNAME, c.PASSWORD, loop=loop)
await masterbot.rest.login(c.BOTNAME, c.PASSWORD)
result = (await
masterbot.rest.rooms_info(room_name=c.POLL_STATUS_ROOM)).json()
statusroom = m.create(m.Room, result['room'])
pollmanager = await pollutil.PollManager.create_pollmanager(
master=masterbot,
botname=c.BOTNAME,
statusroom=statusroom.to_roomref())
usage = com.Usage(master=masterbot)
ping = com.Ping(master=masterbot)
poll = com.Poll(master=masterbot, pollmanager=pollmanager)
notify = com.CatchAll(master=masterbot, callback=com.private_message_user)
dms = com2.Dms(master=masterbot, token=c.DMS_TOKEN)
etm = com2.Etm(master=masterbot, pollmanager=pollmanager)
food = com2.Food(master=masterbot)
birthday = com2.Birthday(master=masterbot)
# Public command bot
masterbot.bots.append(
bots.RoomTypeMentionCommandBot(master=masterbot,
username=c.BOTNAME,
enable_public_channel=True,
enable_private_groups=True,
commands=[ping, notify]))
# Direct message bot
masterbot.bots.append(
bots.RoomTypeCommandBot(
master=masterbot,
username=c.BOTNAME,
enable_direct_message=True,
commands=[usage, ping, dms, food, poll, birthday]))
# Mensa bot
masterbot.bots.append(
bots.RoomCommandBot(master=masterbot,
username=c.BOTNAME,
whitelist=[c.MENSA_ROOM],
commands=[etm],
show_usage_on_unknown=False))
return masterbot
async def login(self, username: str, password: str) -> m.LoginResult:
"""Login with the given credentials"""
response = await self._call("login", {
"user": {
"username": username
},
"password": password
})
self.logged_in = True
return m.create(m.LoginResult, response)
async def send_message(self, roomId: str, message: str) -> m.Message:
"""Send a message to a room
"""
response = await self._call("sendMessage", {
"rid": roomId,
"msg": message
})
if response is None:
raise exp.RocketClientException("Could not send message.")
return m.create(m.Message, response)
def setup_admin() -> None:
"""This function is executed before any integration test is run.
The admin is created here because the first user is by default admin
"""
global _admin_user
# This function uses the default RocketChat Client because it cannot be async and
# since this is the first function it cannot break due to the ratelimiter
rest = RocketChat()
result = rest.users_register(username='******',
name='Administrator',
email='*****@*****.**',
password='******').json()
if result['success']:
_admin_user = m.create(m.User, result['user'])
else:
rest.login(user='******', password='******')
result = rest.users_info(username='******').json()
_admin_user = m.create(m.User, result['user'])
async def room(self,
*,
room_id: Optional[str] = None,
room_name: Optional[str] = None) -> m.Room:
if room_id is not None:
if room_id not in self._roomid_cache:
try:
result = (await
self.rest.rooms_info(room_id=room_id)).json()
if 'room' in result:
room = m.create(m.Room, result['room'])
self._roomid_cache[room_id] = room
if room.name is not None:
self._roomname_cache[room.name] = room
else:
result['roomId'] = room_id
raise exp.RocketBotException(result)
except RocketConnectionException as e:
raise exp.RocketClientException(e)
return self._roomid_cache[room_id]
if room_name is not None:
if room_name not in self._roomname_cache:
try:
result = (await self.rest.rooms_info(room_name=room_name
)).json()
if 'room' in result:
room = m.create(m.Room, result['room'])
self._roomid_cache[room._id] = room
self._roomname_cache[room_name] = room
else:
result['roomName'] = room_name
raise exp.RocketBotException(result)
except RocketConnectionException as e:
raise exp.RocketClientException(e)
return self._roomname_cache[room_name]
raise exp.RocketBotException(
"You have to specify either room_id or room_name.")
async def handle(self, command: str, args: str,
message: m.Message) -> None:
"""Handle the incoming message
"""
if command == 'birthday':
if len(message.mentions) == 0:
await self.master.ddp.send_message(
message.roomid, "Please mention a user with `@user`")
return
user = message.mentions[0]
if user.username == message.created_by.username:
await self.master.ddp.send_message(
message.roomid,
"Please mention someone other than yourself")
return
result = await self.master.rest.users_list(count=0)
users = [m.create(m.User, u) for u in result.json()['users']]
username = user.name if user.name is not None else user.username
username = re.sub(r'\s', '_', username).lower()
name = f'geburtstag_{username}'
members = [
u.username for u in users if u.username != user.username
]
result = await self.master.rest.groups_create(name=name,
members=members)
if result.status_code != 200:
await self.master.ddp.send_message(message.roomid,
result.json()['error'])
return
room = m.create(m.Room, result.json()['group'])
await self.master.rest.groups_add_owner(
room_id=room._id, user_id=message.created_by._id)
async def _get_or_create_user(master: master.Master,
username: str,
displayname: str,
*,
roles: List[str] = ['user']) -> m.User:
result = (await master.rest.users_info(username=username)).json()
if not result['success']:
result = (await
master.rest.users_create(username=username,
name=displayname,
email=f'{username}@example.com',
password=username,
roles=roles)).json()
return m.create(m.User, result['user'])
def __init__(self, kwargs: Any) -> None:
self.id: str = kwargs['_id']
self.roomid: str = kwargs['rid']
self.msg: str = kwargs['msg']
self.created_at = m.create(m.RcDatetime, kwargs['ts'])
self.created_by = m.create(UserRef, kwargs['u'])
self.updated_at = m.create(m.RcDatetime, kwargs['_updatedAt'])
self.edited_at = m.try_create(m.RcDatetime, kwargs.get('editedAt'))
self.edited_by = m.try_create(m.UserRef, kwargs.get('editedBy'))
self.pinned_at = m.try_create(m.RcDatetime, kwargs.get('pinnedAt'))
self.pinned_by = m.try_create(m.UserRef, kwargs.get('pinnedBy'))
self.message_type = m.create(m.MessageType,
kwargs.get('t'),
default=m.MessageType.STANDARD_MESSAGE)
self.role_type = m.create(m.RoleType,
kwargs.get('role'),
default=m.RoleType.NONE)
self.attachments = [
m.create(Attachment, a) for a in kwargs.get('attachments', list())
]
self.channels = [
m.create(RoomRef, l) for l in kwargs.get('channels', list())
]
self.mentions = [
m.create(UserRef, u) for u in kwargs.get('mentions', list())
]
self.urls = [m.create(Link, l) for l in kwargs.get('urls', list())]
self.reactions = kwargs.get('reactions', dict())
self.file = m.try_create(File, kwargs.get('file'))
self.groupable = kwargs.get('groupable')
self.parseUrls = kwargs.get('parseUrls')
self.pinned = kwargs.get('pinned')
async def is_private_group_member(user: master.Master, groupname: str) -> bool:
result = await user.rest.groups_list()
groups = [m.create(m.Room, g) for g in result.json()['groups']]
return any([g for g in groups if g.name is not None and g.name == groupname])
def __post_init__(self) -> None:
self.ts = m.create(m.RcDatetime, self.ts)
if len(self.attachments) != 0:
self.attachments = [
m.create(Attachment, a) for a in self.attachments
]
def __post_init__(self) -> None:
self.createdAt = m.try_create(m.RcDatetime, self.createdAt)
self._updatedAt = m.try_create(m.RcDatetime, self._updatedAt)
self.lastLogin = m.try_create(m.RcDatetime, self.lastLogin)
if self.roles is not None:
self.roles = [m.create(m.RoleType, r) for r in self.roles]
def __post_init__(self) -> None:
self.messages = [
models.create(models.Message, m) for m in self.messages
]
self.firstUnread = models.create(models.Message, self.firstUnread)
def __post_init__(self) -> None:
self.update = [models.create(models.Room, r) for r in self.update]
self.remove = [models.create(models.Room, r) for r in self.remove]
def __post_init__(self) -> None:
self.tokenExpires = models.create(models.RcDatetime, self.tokenExpires)
async def get_all_rooms(self) -> List[m.Room]:
"""Get all the rooms a user belongs to.
"""
response = await self.client.call("rooms/get")
return [m.create(m.Room, r) for r in response]
def __post_init__(self) -> None:
arg0 = cast(models.Message, self.args[0]) # pylint: disable=E1136
self.message = models.create(models.Message, arg0)
if len(self.args) > 1:
arg1 = cast(models.RoomRef2, self.args[1]) # pylint: disable=E1136
self.room = models.create(models.RoomRef2, arg1)
def __post_init__(self):
self.message = models.create(models.Message, self.args[0]) # pylint: disable=E1136
if len(self.args) > 1:
self.room = models.create(models.RoomRef2, self.args[1]) # pylint: disable=E1136
