class MockAbstractObject(AbstractObject):
field1 = Field()
field2 = Field()
field3: Field = Field().with_api_name("id")
field4: Field = Field().with_api_name("foo.bar")
def __init__(self, gmi: GMI) -> None:
self.gmi = gmi
self.fields_loaded = False
def on_fields_loaded(self) -> None:
self.fields_loaded = True
class MockAbstractObject(AbstractObject):
field1 = Field()
field2 = Field(handler=int)
field3 = Field(api_name='id')
field4 = Field(api_name='foo.bar')
def __init__(self, gmi):
self.gmi = gmi
self.fields_loaded = False
def on_fields_loaded(self):
self.fields_loaded = True
class User(AbstractObject, RetrievableObject):
user_id: str = Field().with_type(str)
phone_number: str = Field().with_type(str)
image_url: str = Field().with_type(str)
name: str = Field().with_type(str)
created_at: int = Field().with_type(int)
updated_at: int = Field().with_type(int)
email: str = Field().with_type(str)
sms: bool = Field().with_type(bool)
def __init__(self, gmi: "GMI") -> None:
self.gmi = gmi
def save(self) -> None:
new_data = UserUpdateRequest(
self.gmi, self.image_url, self.name, self.email
).result
self._refresh_from_other(new_data)
def refresh(self) -> None:
new_data = UserMeRequest(self.gmi).result
self._refresh_from_other(new_data)
@classmethod
def get(cls, gmi: "GMI") -> "User": # type: ignore
user = cls(gmi)
user.refresh()
return user
def enable_sms(self, duration: int, registration_id: str) -> None:
SmsCreateRequest(self.gmi, duration, registration_id)
def disable_sms(self) -> None:
SmsDeleteRequest(self.gmi)
class User(AbstractObject, RetrievableObject):
user_id = Field()
phone_number = Field()
image_url = Field()
name = Field()
created_at = Field()
updated_at = Field()
email = Field()
sms = Field()
def __init__(self, gmi):
self.gmi = gmi
def save(self):
new_data = UserUpdateRequest(self.gmi, self.image_url, self.name, self.email).result
self._refresh_from_other(new_data)
def refresh(self):
new_data = UserMeRequest(self.gmi).result
self._refresh_from_other(new_data)
@classmethod
def get(cls, gmi):
user = cls(gmi)
user.refresh()
return user
def enable_sms(self, duration, registration_id):
SmsCreateRequest(self.gmi, duration, registration_id)
def disable_sms(self):
SmsDeleteRequest(self.gmi)
class TestField(TestCase):
def setUp(self) -> None:
self.name_api_field = "test"
self.name_varname = "varname"
self.basic_field = Field()
self.api_field = Field().with_api_name(self.name_api_field)
def test_basic_field(self) -> None:
self.basic_field.with_field_name(self.name_varname)
self.assertEqual(self.basic_field.name, self.name_varname)
self.assertEqual(self.basic_field.api_name, self.name_varname)
def test_api_field(self) -> None:
self.api_field.with_field_name(self.name_varname)
self.assertEqual(self.api_field.name, self.name_varname)
self.assertEqual(self.api_field.api_name, self.name_api_field)
class Chat(AbstractObject):
created_at: int = Field().with_type(int)
updated_at: int = Field().with_type(int)
messages_count: int = Field().with_type(int)
last_message_raw: JsonType = Field().with_api_name("last_message").with_type(
JsonType
)
other_user_raw: JsonType = Field().with_api_name("other_user").with_type(JsonType)
last_message: Optional["DirectMessage"] = None
other_user: "******" = None # type: ignore
def __init__(self, gmi: "GMI") -> None:
self.gmi = gmi
self.messages = ChatMessagesManager(self)
@staticmethod
def get_all(gmi: "GMI") -> List["Chat"]:
return DirectMessageChatsRequest(gmi).result
def get(self, other_user_id: str) -> List["DirectMessage"]:
return DirectMessageIndexRequest(self.gmi, other_user_id).result
def post(self, message: "ComplexMessage") -> "DirectMessage":
text, attachments = smart_split_complex_message(message)
return DirectMessageCreateRequest(
self.gmi,
self.gmi.user.get().user_id,
self.other_user.user_id,
text,
attachments,
).result
def on_fields_loaded(self) -> None:
self.last_message = DirectMessage.from_json(self.gmi, self.last_message_raw)
self.other_user = DirectMessageUser.from_json(self.gmi, self.other_user_raw)
def __str__(self) -> str:
return "Chat with " + str(self.other_user)
def __repr__(self) -> str:
return "C:" + str(self.other_user)
class DirectMessageUser(AbstractObject):
def save(self) -> None:
raise InvalidOperationException("This operation is not permitted")
@staticmethod
def get(gmi: "GMI", *args: Any) -> None:
raise InvalidOperationException("This operation does not make sense")
def refresh(self) -> None:
raise InvalidOperationException("This operation is non-trivial to implement")
avatar_url: str = Field() # type: ignore
user_id: str = Field() # type: ignore
name: str = Field() # type: ignore
def __init__(self, gmi: "GMI") -> None:
self.gmi = gmi
def __str__(self) -> str:
return str(self.name)
class Block(AbstractObject):
user_id: str = Field().with_type(str)
blocked_user_id: str = Field().with_type(str)
def __init__(self, gmi: "GMI") -> None:
self.gmi = gmi
def get_all(self, user_id: str) -> List["Block"]:
return BlockIndexRequest(self.gmi, user_id).result
@staticmethod
def block_exists(gmi: "GMI", user_id: str, other_user_id: str) -> bool:
return BlockBetweenRequest(gmi, user_id, other_user_id).result
@staticmethod
def block(gmi: "GMI", user_id: str, other_user_id: str) -> None:
BlockCreateRequest(gmi, user_id, other_user_id)
@staticmethod
def unblock(gmi: "GMI", user_id: str, other_user_id: str) -> None:
BlockUnblockRequest(gmi, user_id, other_user_id)
def setUp(self):
self.name_api_field = 'test'
self.name_varname = 'varname'
self.basic_field = Field()
self.api_field = Field(api_name=self.name_api_field)
self.handler_field = Field(handler=int)
class TestField(TestCase):
def setUp(self):
self.name_api_field = 'test'
self.name_varname = 'varname'
self.basic_field = Field()
self.api_field = Field(api_name=self.name_api_field)
self.handler_field = Field(handler=int)
def test_basic_field(self):
self.basic_field.set_name(self.name_varname)
self.assertEqual(self.basic_field.name, self.name_varname)
self.assertEqual(self.basic_field.api_name, self.name_varname)
self.assertEqual(self.basic_field.handler, str)
def test_api_field(self):
self.api_field.set_name(self.name_varname)
self.assertEqual(self.api_field.name, self.name_varname)
self.assertEqual(self.api_field.api_name, self.name_api_field)
self.assertEqual(self.api_field.handler, str)
def test_handler_field(self):
self.handler_field.set_name(self.name_varname)
self.assertEqual(self.handler_field.name, self.name_varname)
self.assertEqual(self.handler_field.api_name, self.name_varname)
self.assertEqual(self.handler_field.handler, int)
class Block(AbstractObject):
user_id = Field()
blocked_user_id = Field()
created_at = Field()
def __init__(self, gmi):
self.gmi = gmi
def get_all(self, user_id):
return BlockIndexRequest(self.gmi, user_id).result
@staticmethod
def block_exists(gmi, user_id, other_user_id):
return BlockBetweenRequest(gmi, user_id, other_user_id).result
@staticmethod
def block(gmi, user_id, other_user_id):
BlockCreateRequest(gmi, user_id, other_user_id)
@staticmethod
def unblock(gmi, user_id, other_user_id):
BlockUnblockRequest(gmi, user_id, other_user_id)
class Chat(AbstractObject):
created_at = Field()
updated_at = Field()
messages_count = Field()
last_message_raw = Field(api_name='last_message', handler=dict)
other_user_raw = Field(api_name='other_user', handler=dict)
last_message = None
other_user = None
def __init__(self, gmi):
self.gmi = gmi
self.messages = ChatMessagesManager(self)
@staticmethod
def get_all(gmi):
return DirectMessageChatsRequest(gmi).result
def get(self, other_user_id):
return DirectMessageIndexRequest(self.gmi, other_user_id).result
def post(self, message):
text, attachments = smart_split_complex_message(message)
return DirectMessageCreateRequest(self.gmi,
self.gmi.user.get().user_id,
self.other_user.user_id, text,
attachments).result
def on_fields_loaded(self):
self.last_message = DirectMessage.from_json(self.gmi,
self.last_message_raw)
self.other_user = DirectMessageUser.from_json(self.gmi,
self.other_user_raw)
def __str__(self):
return "Chat with " + str(self.other_user)
def __repr__(self):
return "C:" + str(self.other_user)
class Member(AbstractObject, RetrievableObject):
member_id = Field(api_name='id')
user_id = Field()
nickname = Field()
muted = Field()
image_url = Field()
autokicked = Field()
phone_number = Field()
email = Field()
def __init__(self, gmi, group_id, nickname=None, user_id=None, phone_number=None, email=None):
self.gmi = gmi
self.group_id = group_id
self.nickname = nickname
self.user_id = user_id
self.phone_number = phone_number
self.email = email
def save(self):
if self.member_id is None:
if self.user_id is not None:
MembersAddRequest(self.gmi, self.group_id, self.nickname, user_id=self.user_id)
elif self.phone_number is not None:
MembersAddRequest(self.gmi, self.group_id, self.nickname, phone_number=self.phone_number)
elif self.email is not None:
MembersAddRequest(self.gmi, self.group_id, self.nickname, email=self.email)
else:
raise ValueError('Please define one of user_id, phone_number, email before saving')
else: # Only works for current user
new_data = MembersUpdateRequest(self.gmi, self.group_id, self.nickname).result
self._refresh_from_other(new_data)
def refresh(self):
raise InvalidOperationException('Nontrivial to implement')
@staticmethod
def get(gmi, member_id):
raise InvalidOperationException('Nontrivial to implement')
def __str__(self):
return self.nickname
def __repr__(self):
return str(self)
class Group(AbstractObject, RetrievableObject):
group_id = Field(api_name='id')
name = Field()
type = Field()
description = Field()
image_url = Field()
creator_user_id = Field()
created_at = Field()
updated_at = Field()
share_url = Field()
members_raw = Field(api_name='members', handler=None)
messages_count_raw = Field(api_name='messages.count', handler=None)
messages_last_message_id_raw = Field(api_name='messages.last_message_id',
handler=None)
messages_last_message_created_at_raw = Field(
api_name='messages.last_message_created_at', handler=None)
def __init__(self, gmi, name=None, description=None, image_url=None):
super().__init__()
self.gmi = gmi
self.messages = GroupMessagesManager(self)
self.name = name
self.description = description
self.image_url = image_url
self.members = []
@property
def bots(self):
return self.gmi.bots.filter(group_id=self.group_id)
def on_fields_loaded(self):
self.members = []
for member_json in self.members_raw:
self.members.append(
Member.from_json(self.gmi, member_json, self.group_id))
self.messages.count = self.messages_count_raw
self.messages.last_id = self.messages_last_message_id_raw
self.messages.last_created_at = self.messages_last_message_created_at_raw
def save(self):
if self.group_id is None:
new_data = GroupsCreateRequest(self.gmi, self.name,
self.description,
self.image_url).result
else:
new_data = GroupsUpdateRequest(self.gmi, self.group_id, self.name,
self.description,
self.image_url).result
self._refresh_from_other(new_data)
def delete(self):
if self.group_id is None:
raise InvalidOperationException(
'Cannot destroy a group that isn\'t saved!')
else:
GroupsDestroyRequest(self.gmi, self.group_id)
def refresh(self):
if self.group_id is None:
raise InvalidOperationException(
'Must have an id to perform this operation')
else:
new_data = GroupsShowRequest(self.gmi,
group_id=self.group_id).result
self._refresh_from_other(new_data)
def member_add(self, name, user_id):
MembersAddRequest(self.gmi, self.group_id, name, user_id=user_id)
def member_rm(self, member_id):
MembersRemoveRequest(self.gmi, self.group_id, member_id)
def post(self, message):
text, attachments = smart_split_complex_message(message)
obj = Message(self.gmi, self.group_id, str(datetime.now()), text,
attachments)
obj.save()
return obj
@staticmethod
def get(gmi, group_id):
return GroupsShowRequest(gmi, group_id).result
@staticmethod
def get_all(gmi):
return GroupsIndexRequest(gmi, per_page=100).result
@staticmethod
def get_former(gmi):
return GroupsFormerRequest(gmi).result
@staticmethod
def join(gmi, group_id, share_token):
return GroupsJoinRequest(gmi, group_id, share_token).result
@staticmethod
def rejoin(gmi, group_id):
return GroupsRejoinRequest(gmi, group_id).result
def change_owner(self, owner_id):
return GroupsChangeOwnersRequest(self.gmi, [{
'group_id': self.group_id,
'owner_id': owner_id
}]).result
def __str__(self):
return self.name
def __repr__(self):
return str(self)
class Message(AbstractObject, RetrievableObject):
message_id = Field(api_name='id')
source_guid = Field()
created_at = Field()
user_id = Field()
group_id = Field()
name = Field()
avatar_url = Field()
text = Field()
system = Field()
favorited_by = Field(handler=None)
attachments = Field(handler=None)
sender_type = Field()
sender_id = Field()
def __init__(self,
gmi,
group_id=None,
source_guid=None,
text=None,
attachments=list()):
self.gmi = gmi
self.group_id = group_id
self.source_guid = source_guid
self.text = text
self.attachments = attachments
self.message_id = None
def save(self):
if self.message_id:
raise InvalidOperationException(
"You cannot change a message that has already been sent")
else:
new_data = MessagesCreateRequest(self.gmi, self.group_id,
self.source_guid, self.text,
self.attachments).result
self._refresh_from_other(new_data)
def refresh(self):
if self.message_id:
new_data = MessagesShowRequest(self.gmi, self.group_id,
self.message_id).result
self._refresh_from_other(new_data)
else:
raise InvalidOperationException(
"Must have a message_id to pull data from the server")
def on_fields_loaded(self):
if self.text is None:
self.text = ""
from lowerpines.message import ComplexMessage, RefAttach
self.complex_text = ComplexMessage('')
doing_mentions = False
for attachment in self.attachments:
if attachment['type'] == 'mentions':
doing_mentions = True
prev_index = 0
for i in range(len(self.text)):
for loci, user_id in zip(attachment['loci'],
attachment['user_ids']):
if loci[0] == i:
self.complex_text += self.text[prev_index:loci[0]] + \
RefAttach(user_id, self.text[loci[0]:loci[0] + loci[1]])
prev_index = loci[0] + loci[1]
self.complex_text = self.complex_text + self.text[prev_index:]
if not doing_mentions:
self.complex_text = ComplexMessage(self.text)
def __repr__(self):
return str(self)
def __str__(self):
return self.text
@staticmethod
def get(gmi, group_id, message_id):
return MessagesShowRequest(gmi, group_id, message_id).result
def like(self):
LikeCreateRequest(self.gmi, self.group_id, self.message_id)
def unlike(self):
LikeDestroyRequest(self.gmi, self.group_id, self.message_id)
class Group(AbstractObject, RetrievableObject):
group_id: str = Field().with_api_name("id").with_type(str)
name: str = Field().with_type(str)
type: str = Field().with_type(str)
description: Optional[str] = Field().with_type(str)
image_url: Optional[str] = Field().with_type(str)
creator_user_id: str = Field().with_type(str)
created_at: int = Field().with_type(int)
updated_at: int = Field().with_type(int)
share_url: Optional[str] = Field().with_type(str)
share_qr_code_url: Optional[str] = Field().with_type(str)
office_mode: bool = Field().with_type(bool)
phone_number: Optional[str] = Field().with_type(str)
members: List[Member]
members_raw: List[JsonType] = Field().with_api_name("members").with_type(
List[JsonType])
messages_count_raw: int = Field().with_api_name(
"messages.count").with_type(int)
messages_last_message_id_raw: Optional[str] = Field().with_api_name(
"messages.last_message_id").with_type(str)
messages_last_message_created_at_raw: Optional[int] = Field(
).with_api_name("messages.last_message_created_at").with_type(int)
def __init__(
self,
gmi: "GMI",
name: Optional[str] = None,
description: Optional[str] = None,
image_url: Optional[str] = None,
) -> None:
super().__init__(gmi)
self.gmi = gmi
self.messages = GroupMessagesManager(self)
self.name = name # type: ignore
self.description = description
self.image_url = image_url
self.members = []
@property
def bots(self) -> "AbstractManager[Bot]":
return self.gmi.bots.filter(group_id=self.group_id)
def on_fields_loaded(self) -> None:
self.members = []
for member_json in self.members_raw:
self.members.append(
Member.from_json(self.gmi, member_json, self.group_id))
self.messages.count = self.messages_count_raw
self.messages.last_id = self.messages_last_message_id_raw
self.messages.last_created_at = self.messages_last_message_created_at_raw
def save(self) -> None:
if self.group_id is None:
new_data = GroupsCreateRequest(self.gmi, self.name,
self.description,
self.image_url).result
else:
new_data = GroupsUpdateRequest(self.gmi, self.group_id, self.name,
self.description,
self.image_url).result
self._refresh_from_other(new_data)
def delete(self) -> None:
if self.group_id is None:
raise InvalidOperationException(
"Cannot destroy a group that isn't saved!")
else:
GroupsDestroyRequest(self.gmi, self.group_id)
def refresh(self) -> None:
if self.group_id is None:
raise InvalidOperationException(
"Must have an id to perform this operation")
else:
new_data = GroupsShowRequest(self.gmi,
group_id=self.group_id).result
self._refresh_from_other(new_data)
def member_add(self, name: str, user_id: str) -> None:
MembersAddRequest(self.gmi, self.group_id, name, user_id=user_id)
def member_rm(self, member_id: str) -> None:
MembersRemoveRequest(self.gmi, self.group_id, member_id)
def post(self, message: Union["ComplexMessage", str]) -> Message:
text, attachments = smart_split_complex_message(message)
obj = Message(self.gmi, self.group_id, str(datetime.now()), text,
attachments)
obj.save()
return obj
@staticmethod
def get(gmi: "GMI", group_id: str) -> "Group": # type: ignore
return GroupsShowRequest(gmi, group_id).result
@staticmethod
def get_all(gmi: "GMI") -> List["Group"]:
return GroupsIndexRequest(gmi, per_page=100).result
@staticmethod
def get_former(gmi: "GMI") -> List["Group"]:
return GroupsFormerRequest(gmi).result
@staticmethod
def join(gmi: "GMI", group_id: str, share_token: str) -> "Group":
return GroupsJoinRequest(gmi, group_id, share_token).result
@staticmethod
def rejoin(gmi: "GMI", group_id: str) -> "Group":
return GroupsRejoinRequest(gmi, group_id).result
def change_owner(self, owner_id: str) -> JsonType:
return GroupsChangeOwnersRequest(self.gmi, self.group_id,
owner_id).result
def __str__(self) -> str:
return self.name
def __repr__(self) -> str:
return str(self)
class Message(AbstractObject, RetrievableObject):
message_id: Optional[str] = Field().with_api_name("id").with_type(str)
source_guid: str = Field().with_type(str)
created_at: int = Field().with_type(int)
user_id: str = Field().with_type(str)
group_id: str = Field().with_type(str)
name: str = Field().with_type(str)
avatar_url: Optional[str] = Field().with_type(str)
text: str = Field().with_type(str)
system: bool = Field().with_type(bool)
favorited_by: List[str] = Field().with_type(List[str])
attachments: List[AttachmentType] = Field().with_type(List[AttachmentType])
sender_type: Optional[str] = Field().with_type(str)
sender_id: str = Field().with_type(str)
complex_text: Optional["ComplexMessage"] = None
def __init__(
self,
gmi: "GMI",
group_id: Optional[str] = None,
source_guid: Optional[str] = None,
text: Optional[str] = None,
attachments: Optional[List[AttachmentType]] = None,
) -> None:
self.gmi = gmi
self.group_id = group_id # type: ignore
self.source_guid = source_guid # type: ignore
self.text = text # type: ignore
self.attachments = attachments or []
self.message_id = None
def save(self) -> None:
if self.message_id:
raise InvalidOperationException(
"You cannot change a message that has already been sent")
else:
new_data = MessagesCreateRequest(self.gmi, self.group_id,
self.source_guid, self.text,
self.attachments).result
self._refresh_from_other(new_data)
def refresh(self) -> None:
message_id = self.message_id
if message_id:
new_data = MessagesShowRequest(self.gmi, self.group_id,
message_id).result
self._refresh_from_other(new_data)
else:
raise InvalidOperationException(
"Must have a message_id to pull data from the server")
def on_fields_loaded(self) -> None:
if self.text is None:
self.text = ""
from lowerpines.message import ComplexMessage, RefAttach # noqa: F811
self.complex_text = ComplexMessage("")
doing_mentions = False
for attachment in self.attachments:
if attachment["type"] == "mentions":
doing_mentions = True
prev_index = 0
for i in range(len(self.text)):
for loci, user_id in zip(attachment["loci"],
attachment["user_ids"]):
if loci[0] == i:
self.complex_text += self.text[
prev_index:loci[0]] + RefAttach(
user_id,
self.text[loci[0]:loci[0] + loci[1]])
prev_index = loci[0] + loci[1]
self.complex_text = self.complex_text + self.text[prev_index:]
if not doing_mentions:
self.complex_text = ComplexMessage(self.text)
def __repr__(self) -> str:
return str(self)
def __str__(self) -> str:
return self.text
@staticmethod
def get(gmi: "GMI", group_id: str,
message_id: str) -> "Message": # type: ignore
return MessagesShowRequest(gmi, group_id, message_id).result
def like(self) -> None:
message_id = self.message_id
if message_id is None:
raise ValueError("Message must be saved before it can be liked")
LikeCreateRequest(self.gmi, self.group_id, message_id)
def unlike(self) -> None:
message_id = self.message_id
if message_id is None:
raise ValueError("Message must be saved before it can be unliked")
LikeDestroyRequest(self.gmi, self.group_id, message_id)
class Bot(AbstractObject, RetrievableObject):
bot_id: str = Field().with_type(str)
group_id: str = Field().with_type(str)
name: str = Field().with_type(str)
avatar_url: Optional[str] = Field().with_type(str)
callback_url: Optional[str] = Field().with_type(str)
dm_notification: Optional[bool] = Field().with_type(bool)
def __init__(
self,
gmi: "GMI",
group_id: Optional[str] = None,
name: Optional[str] = None,
avatar_url: Optional[str] = None,
callback_url: Optional[str] = None,
dm_notification: Optional[bool] = None,
) -> None:
self.gmi = gmi
self.group_id = group_id # type: ignore
self.name = name # type: ignore
self.avatar_url = avatar_url
self.callback_url = callback_url
self.dm_notification = dm_notification
@property
def group(self) -> "Group":
return self.gmi.groups.get(group_id=self.group_id)
def save(self) -> None:
if self.bot_id is None:
new_data = BotCreateRequest(
self.gmi,
self.group_id,
self.name,
self.callback_url,
self.avatar_url,
self.dm_notification,
).result
self._refresh_from_other(new_data)
else:
BotUpdateRequest(
self.gmi,
self.bot_id,
self.group_id,
self.name,
self.callback_url,
self.avatar_url,
self.dm_notification,
)
def delete(self) -> None:
if self.bot_id is None:
raise InvalidOperationException(
"Cannot destroy a bot that isn't saved!")
else:
BotDestroyRequest(self.gmi, self.bot_id)
def refresh(self) -> None:
if self.bot_id is None:
raise InvalidOperationException("This operation is not permitted")
else:
raise InvalidOperationException("This is non trivial to implement")
def post(self, message: Union["ComplexMessage", str]) -> None:
text, attachments = smart_split_complex_message(message)
BotPostRequest(self.gmi, self.bot_id, text, attachments)
@staticmethod
def get_all(gmi: "GMI") -> List["Bot"]:
return BotIndexRequest(gmi).result
@staticmethod
def get(gmi: "GMI", bot_id: str) -> None: # type: ignore
raise InvalidOperationException("This is non trivial to implement")
def __str__(self) -> str:
return self.name + ":" + self.group_id
class Member(AbstractObject, RetrievableObject):
member_id: str = Field().with_api_name("id").with_type(str)
user_id: str = Field().with_type(str)
nickname: str = Field().with_type(str)
muted: bool = Field().with_type(bool)
image_url: Optional[str] = Field().with_type(str)
autokicked: bool = Field().with_type(bool)
app_installed: bool = Field().with_type(bool)
guid: str = Field().with_type(str)
phone_number: str = Field().with_type(str)
email: str = Field().with_type(str)
def __init__(
self,
gmi: "GMI",
group_id: str,
nickname: Optional[str] = None,
user_id: Optional[str] = None,
phone_number: Optional[str] = None,
email: Optional[str] = None,
) -> None:
self.gmi = gmi
self.group_id = group_id # type: ignore
self.nickname = nickname # type: ignore
self.user_id = user_id # type: ignore
self.phone_number = phone_number # type: ignore
self.email = email # type: ignore
def save(self) -> None:
if self.member_id is None:
if self.user_id is not None:
MembersAddRequest(self.gmi,
self.group_id,
self.nickname,
user_id=self.user_id)
elif self.phone_number is not None:
MembersAddRequest(
self.gmi,
self.group_id,
self.nickname,
phone_number=self.phone_number,
)
elif self.email is not None:
MembersAddRequest(self.gmi,
self.group_id,
self.nickname,
email=self.email)
else:
raise ValueError(
"Please define one of user_id, phone_number, email before saving"
)
else: # Only works for current user
new_data = MembersUpdateRequest(self.gmi, self.group_id,
self.nickname).result
self._refresh_from_other(new_data)
def refresh(self) -> None:
raise InvalidOperationException("Nontrivial to implement")
@staticmethod
def get(gmi: "GMI", member_id: str) -> None: # type: ignore
raise InvalidOperationException("Nontrivial to implement")
def __str__(self) -> str:
return self.nickname
def __repr__(self) -> str:
return str(self)
class MockAbstractObjectTypeObject(metaclass=AbstractObjectType):
field1 = Field()
field2 = Field(handler=int)
field3 = Field(api_name='id')
class MockAbstractObjectTypeObject(metaclass=AbstractObjectType):
_fields: List[Field] = []
field1 = Field()
field2: Field = Field().with_api_name("id")
def setUp(self) -> None:
self.name_api_field = "test"
self.name_varname = "varname"
self.basic_field = Field()
self.api_field = Field().with_api_name(self.name_api_field)
class DirectMessage(AbstractObject):
@staticmethod
def get(gmi: "GMI", *args: Any) -> None:
raise InvalidOperationException("This is non-trivial to implement")
def refresh(self) -> None:
raise InvalidOperationException("This is non-trivial to implement")
attachments: List[AttachmentType] = Field().with_type(List[AttachmentType])
avatar_url: str = Field().with_type(str)
conversation_id: str = Field().with_type(str)
created_at: str = Field().with_type(str)
favorited_by: str = Field().with_type(str)
direct_message_id: str = Field().with_api_name("id").with_type(str)
name: str = Field().with_type(str)
recipient_id: str = Field().with_type(str)
sender_id: str = Field().with_type(str)
sender_type: str = Field().with_type(str)
source_guid: str = Field().with_type(str)
text: str = Field().with_type(str)
user_id: str = Field().with_type(str)
def __init__(
self,
gmi: "GMI",
source_guid: Optional[str] = None,
recipient_id: Optional[str] = None,
text: Optional[str] = None,
attachments: Optional[List[AttachmentType]] = None,
) -> None:
self.gmi = gmi # type: ignore
self.source_guid = source_guid # type: ignore
self.recipient_id = recipient_id # type: ignore
self.text = text # type: ignore
self.attachments = attachments or []
def save(self) -> None:
if self.direct_message_id == "":
new_data = DirectMessageCreateRequest(
self.gmi,
self.source_guid,
self.recipient_id,
self.text,
self.attachments,
).result
self._refresh_from_other(new_data)
else:
raise InvalidOperationException(
"You cannot change a message that has already been sent"
)
def __str__(self) -> str:
return self.text
def __repr__(self) -> str:
return "M:" + str(self)
class Bot(AbstractObject, RetrievableObject):
bot_id = Field(handler=None)
group_id = Field()
name = Field()
avatar_url = Field()
callback_url = Field()
dm_notification = Field()
def __init__(self,
gmi,
group_id=None,
name=None,
avatar_url=None,
callback_url=None,
dm_notification=None):
self.gmi = gmi
self.group_id = group_id
self.name = name
self.avatar_url = avatar_url
self.callback_url = callback_url
self.dm_notification = dm_notification
@property
def group(self):
return self.gmi.groups.get(group_id=self.group_id)
def save(self):
if self.bot_id is None:
new_data = BotCreateRequest(self.gmi, self.group_id, self.name,
self.callback_url, self.avatar_url,
self.dm_notification).result
self._refresh_from_other(new_data)
else:
BotsUpdateRequest(self.gmi, self.bot_id, self.group_id, self.name,
self.callback_url, self.avatar_url,
self.dm_notification)
def delete(self):
if self.bot_id is None:
raise InvalidOperationException(
'Cannot destroy a bot that isn\'t saved!')
else:
BotDestroyRequest(self.gmi, self.bot_id)
def refresh(self):
if self.bot_id is None:
raise InvalidOperationException('This operation is not permitted')
else:
raise InvalidOperationException('This is non trivial to implement')
def post(self, text):
text, attachments = smart_split_complex_message(text)
BotPostRequest(self.gmi, self.bot_id, text, attachments)
@staticmethod
def get_all(gmi):
return BotIndexRequest(gmi).result
@staticmethod
def get(gmi, bot_id):
pass
def __str__(self):
return self.name + ':' + self.group_id