def moveFriendToGroup(self, dbID, include=None, exclude=None):
error = self.__checkCooldown(CLIENT_ACTION_ID.CHANGE_GROUP)
if error:
return (False, error)
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if not contact:
return (False,
ClientContactError(
CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
if contact.getItemType() != XMPP_ITEM_TYPE.ROSTER_ITEM:
return (False,
ClientContactError(CONTACT_ERROR_ID.ROSTER_ITEM_NOT_FOUND,
contact.getFullName()))
groups = contact.getGroups()
if include:
if not self.usersStorage.isGroupExists(include):
return (False,
ClientContactError(CONTACT_ERROR_ID.GROUP_NOT_FOUND,
include))
groups.add(include)
if exclude:
if not self.usersStorage.isGroupExists(exclude):
return (False,
ClientContactError(CONTACT_ERROR_ID.GROUP_NOT_FOUND,
exclude))
groups.discard(exclude)
jid = contact.getJID()
self.__cooldown.process(CLIENT_ACTION_ID.CHANGE_GROUP)
return self.__addTasks(
CLIENT_ACTION_ID.CHANGE_GROUP, jid,
roster_tasks.ChangeRosterItemGroupsTask(
jid, contact.getName(), groups,
{exclude} if exclude else None))
def removeIgnored(self, dbID):
error = self._checkCooldown(CLIENT_ACTION_ID.REMOVE_IGNORED)
if error:
return (False, error)
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if not contact:
return (False,
ClientContactError(
CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
itemType = contact.getItemType()
if itemType not in XMPP_ITEM_TYPE.PERSISTENT_BLOCKING_LIST:
return (False,
ClientContactError(CONTACT_ERROR_ID.BLOCK_ITEM_NOT_FOUND,
contact.getFullName()))
jid = contact.getJID()
tasks = [block_tasks.RemoveBlockItemTask(jid, contact.getName())]
if itemType == XMPP_ITEM_TYPE.ROSTER_BLOCK_ITEM:
tasks.append(
roster_tasks.RemoveRosterItemTask(
jid,
contact.getName(),
groups=contact.getItem().getRosterGroups()))
if note_tasks.canNoteAutoDelete(contact):
tasks.append(note_tasks.RemoveNoteTask(jid))
self.__cooldown.process(CLIENT_ACTION_ID.REMOVE_IGNORED)
return self.__addTasks(CLIENT_ACTION_ID.REMOVE_IGNORED, jid, *tasks)
def removeFriend(self, dbID, shadowMode=False):
error = self._checkCooldown(CLIENT_ACTION_ID.REMOVE_FRIEND)
if error and not shadowMode:
return (False, error)
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if not contact:
return (False,
ClientContactError(
CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
if contact.getItemType() not in XMPP_ITEM_TYPE.ROSTER_ITEMS:
return (False,
ClientContactError(CONTACT_ERROR_ID.ROSTER_ITEM_NOT_FOUND,
contact.getFullName()))
jid = contact.getJID()
tasks = [
roster_tasks.RemoveRosterItemTask(jid,
contact.getName(),
groups=contact.getGroups())
]
if note_tasks.canNoteAutoDelete(contact):
tasks.append(note_tasks.RemoveNoteTask(jid))
if not shadowMode:
self.__cooldown.process(CLIENT_ACTION_ID.REMOVE_FRIEND)
return self.__addTasks(CLIENT_ACTION_ID.REMOVE_FRIEND, jid, shadowMode,
*tasks)
def addFriend(self, dbID, name, group=None, shadowMode=False):
error = self._checkCooldown(CLIENT_ACTION_ID.ADD_FRIEND)
if error and not shadowMode:
return (False, error)
else:
if group:
if not self.usersStorage.isGroupExists(group):
return (False, ClientContactError(CONTACT_ERROR_ID.GROUP_NOT_FOUND, group))
groups = {group}
else:
groups = None
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
tasks, itemType = [], XMPP_ITEM_TYPE.EMPTY_ITEM
if contact:
if contact.isCurrentPlayer():
return (False, ClientActionError(CLIENT_ACTION_ID.ADD_FRIEND, CLIENT_ERROR_ID.GENERIC))
jid = contact.getJID()
itemType = contact.getItemType()
if itemType in XMPP_ITEM_TYPE.ROSTER_ITEMS:
return (False, ClientContactError(CONTACT_ERROR_ID.ROSTER_ITEM_EXISTS, contact.getFullName()))
subTo = contact.getSubscription()[0]
else:
jid = makeContactJID(dbID)
subTo = _SUB.OFF
result, error = self.__subsRestrictions.canAddFriends()
if not result:
return (False, error)
if itemType == XMPP_ITEM_TYPE.BLOCK_ITEM:
tasks.append(block_tasks.RemoveBlockItemTask(jid, name))
tasks.append(roster_tasks.AddRosterItemTask(jid, name, groups))
elif itemType == XMPP_ITEM_TYPE.ROSTER_BLOCK_ITEM:
tasks.append(block_tasks.RemoveBlockItemTask(jid, name))
task, exclude = None, set()
rosterGroups = contact.getItem().getRosterGroups()
for rosterGroup in rosterGroups:
if self.usersStorage.isGroupEmpty(rosterGroup):
exclude.add(rosterGroup)
if groups:
if groups != exclude:
task = roster_tasks.ChangeRosterItemGroupsTask(jid, name, groups, exclude)
elif rosterGroups:
task = roster_tasks.ChangeRosterItemGroupsTask(jid, name, set(), exclude)
if task:
tasks.append(task)
elif itemType in XMPP_ITEM_TYPE.SUB_PENDING_ITEMS:
tasks.append(sub_tasks.ApproveSubscriptionTask(jid, name))
if groups:
tasks.append(roster_tasks.ChangeRosterItemGroupsTask(jid, name, groups))
else:
tasks.append(roster_tasks.AddRosterItemTask(jid, name, groups))
if subTo == _SUB.OFF:
tasks.append(sub_tasks.AskSubscriptionTask(jid))
if not shadowMode:
self.__cooldown.process(CLIENT_ACTION_ID.ADD_FRIEND)
return self.__addTasks(CLIENT_ACTION_ID.ADD_FRIEND, jid, shadowMode, *tasks)
def unsetMuted(self, dbID):
contact = self.usersStorage.getUser(dbID)
if not contact:
return (False, ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
elif not contact.isMuted():
return (False, ClientContactError(CONTACT_ERROR_ID.MUTED_ITEM_NOT_FOUND, contact.getFullName()))
else:
contact.removeTags({USER_TAG.MUTED})
g_messengerEvents.users.onUserActionReceived(USER_ACTION_ID.MUTE_UNSET, contact, False)
return (True, None)
def validateRosterItemGroup(name):
if not name:
return ('', ClientContactError(CONTACT_ERROR_ID.GROUP_EMPTY))
else:
try:
name = ResourcePrep.prepare(name)
except XmppStringPrepError:
return ('', ClientContactError(CONTACT_ERROR_ID.GROUP_INVALID_NAME, name))
length = len(name)
return (name.encode('utf-8'), ClientIntLimitError(LIMIT_ERROR_ID.GROUP_INVALID_LENGTH, CONTACT_LIMIT.GROUP_MAX_LENGTH, CONTACT_LIMIT.GROUP_MIN_LENGTH)) if CONTACT_LIMIT.GROUP_MIN_LENGTH > length or CONTACT_LIMIT.GROUP_MAX_LENGTH < length else (name.encode('utf-8'), None)
def removeNote(self, dbID):
error = self._checkCooldown(CLIENT_ACTION_ID.REMOVE_NOTE)
if error:
return (False, error)
contact = self.usersStorage.getUser(dbID)
if not contact or not contact.getTags():
return (False, ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
if not contact.getNote():
return (False, ClientContactError(CONTACT_ERROR_ID.NOTE_NOT_FOUND, name=contact.getFullName()))
jid = makeContactJID(dbID)
self.__cooldown.process(CLIENT_ACTION_ID.REMOVE_NOTE)
return self.__addTasks(CLIENT_ACTION_ID.SET_NOTE, jid, note_tasks.RemoveNoteTask(jid))
def unsetMuted(self, dbID):
error = self._checkCooldown(CLIENT_ACTION_ID.UNSET_MUTE)
if error:
return (False, error)
else:
contact = self.usersStorage.getUser(dbID)
if not contact:
return (False, ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
if not contact.isMuted():
return (False, ClientContactError(CONTACT_ERROR_ID.MUTED_ITEM_NOT_FOUND, contact.getFullName()))
contact.removeTags({USER_TAG.MUTED})
g_messengerEvents.users.onUserActionReceived(USER_ACTION_ID.MUTE_UNSET, contact)
self.__cooldown.process(CLIENT_ACTION_ID.UNSET_MUTE)
return (True, None)
def requestFriendship(self, dbID):
error = self._checkCooldown(CLIENT_ACTION_ID.RQ_FRIENDSHIP)
if error:
return (False, error)
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if not contact or contact.isCurrentPlayer():
return (False, ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
itemType = contact.getItemType()
if itemType == XMPP_ITEM_TYPE.BLOCK_ITEM:
return (False, ClientContactError(CONTACT_ERROR_ID.BLOCK_ITEM_EXISTS, contact.getFullName()))
if itemType not in XMPP_ITEM_TYPE.ROSTER_ITEMS:
return (False, ClientContactError(CONTACT_ERROR_ID.ROSTER_ITEM_NOT_FOUND, contact.getFullName()))
jid = contact.getJID()
self.__cooldown.process(CLIENT_ACTION_ID.RQ_FRIENDSHIP)
return self.__addTasks(CLIENT_ACTION_ID.RQ_FRIENDSHIP, jid, sub_tasks.AskSubscriptionTask(jid))
def addIgnored(self, dbID, name):
error = self._checkCooldown(CLIENT_ACTION_ID.ADD_IGNORED)
if error:
return (False, error)
tasks, itemType = [], XMPP_ITEM_TYPE.EMPTY_ITEM
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if contact:
if contact.isCurrentPlayer():
return (False,
ClientActionError(CLIENT_ACTION_ID.ADD_IGNORED,
CLIENT_ERROR_ID.GENERIC))
itemType = contact.getItemType()
if itemType in XMPP_ITEM_TYPE.BLOCK_ITEMS:
return (False,
ClientContactError(CONTACT_ERROR_ID.BLOCK_ITEM_EXISTS,
contact.getFullName()))
length = self.usersStorage.getCount(
ItemsFindCriteria(XMPP_ITEM_TYPE.PERSISTENT_BLOCKING_LIST))
if length >= CONTACT_LIMIT.BLOCK_MAX_COUNT:
return (False,
ClientIntLimitError(LIMIT_ERROR_ID.MAX_BLOCK_ITEMS,
CONTACT_LIMIT.BLOCK_MAX_COUNT))
if contact:
jid = contact.getJID()
if itemType in XMPP_ITEM_TYPE.SUB_PENDING_ITEMS:
tasks.append(sub_tasks.CancelSubscriptionTask(jid))
else:
jid = makeContactJID(dbID)
tasks.append(block_tasks.AddBlockItemTask(jid, name))
if itemType in XMPP_ITEM_TYPE.ROSTER_ITEMS:
groups = contact.getGroups()
if groups:
tasks.append(roster_tasks.EmptyGroupsTask(jid, groups=groups))
self.__cooldown.process(CLIENT_ACTION_ID.ADD_IGNORED)
return self.__addTasks(CLIENT_ACTION_ID.ADD_IGNORED, jid, *tasks)
def __removeTmpIgnored(self, dbID, forced = False):
if not forced:
error = self._checkCooldown(CLIENT_ACTION_ID.REMOVE_IGNORED)
if error:
return (False, error)
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if not contact:
return (False, ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
itemType = contact.getItemType()
if itemType not in XMPP_ITEM_TYPE.TMP_BLOCKING_LIST:
return (False, ClientContactError(CONTACT_ERROR_ID.BLOCK_ITEM_NOT_FOUND, contact.getFullName()))
jid = contact.getJID()
tasks = [block_tasks.RemoveTmpBlockItemTask(jid, contact.getName())]
if not forced:
self.__cooldown.process(CLIENT_ACTION_ID.REMOVE_IGNORED)
return self.__addTasks(CLIENT_ACTION_ID.REMOVE_IGNORED, jid, *tasks)
def validateContactNote(note):
if not note:
return ('', ClientContactError(CONTACT_ERROR_ID.NOTE_EMPTY))
if len(unicode_from_utf8(note)[0]) not in xrange(
CONTACT_LIMIT.NOTE_MIN_CHARS_COUNT,
CONTACT_LIMIT.NOTE_MAX_CHARS_COUNT + 1):
return (note,
ClientIntLimitError(LIMIT_ERROR_ID.NOTE_INVALID_LENGTH,
CONTACT_LIMIT.NOTE_MIN_CHARS_COUNT,
CONTACT_LIMIT.NOTE_MAX_CHARS_COUNT))
return (note, None)
def canCancelFriendship(self, contact):
if not contact:
return (False,
ClientContactError(
CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
tags = contact.getTags()
if USER_TAG.SUB_APPROVED in tags:
return (False,
ClientContactError(CONTACT_ERROR_ID.FRIENDSHIP_APPROVED,
contact.getFullName()))
if USER_TAG.SUB_FROM in tags:
return (False,
ClientContactError(CONTACT_ERROR_ID.FRIENDSHIP_APPROVED,
contact.getFullName()))
if USER_TAG.SUB_IN_PROCESS in tags:
return (False,
ClientContactError(CONTACT_ERROR_ID.FRIENDSHIP_RQ_PROCESS,
contact.getFullName()))
if USER_TAG.SUB_CANCELED in tags:
return (False,
ClientContactError(CONTACT_ERROR_ID.FRIENDSHIP_CANCELED,
contact.getFullName()))
if contact.getItemType() == XMPP_ITEM_TYPE.ROSTER_ITEM:
return (False,
ClientContactError(CONTACT_ERROR_ID.ROSTER_ITEM_EXISTS,
contact.getFullName()))
return (True, None)
def canApproveFriendship(self, contact):
if not contact:
return (False,
ClientContactError(
CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
tags = contact.getTags()
if USER_TAG.SUB_APPROVED in tags:
return (False,
ClientContactError(CONTACT_ERROR_ID.FRIENDSHIP_APPROVED,
contact.getFullName()))
if contact.getItemType() == XMPP_ITEM_TYPE.ROSTER_ITEM:
if USER_TAG.SUB_FROM in contact.getTags():
return (False,
ClientContactError(
CONTACT_ERROR_ID.FRIENDSHIP_APPROVED,
contact.getFullName()))
else:
return (True, None)
if contact.getItemType() == XMPP_ITEM_TYPE.SUB_PENDING:
if USER_TAG.SUB_IN_PROCESS in tags:
return (False,
ClientContactError(
CONTACT_ERROR_ID.FRIENDSHIP_RQ_PROCESS,
contact.getFullName()))
if USER_TAG.SUB_CANCELED in tags:
return (False,
ClientContactError(
CONTACT_ERROR_ID.FRIENDSHIP_CANCELED,
contact.getFullName()))
result, error = self.canAddFriends()
if not result:
return (False, error)
return (True, None)
return (False,
ClientContactError(CONTACT_ERROR_ID.CONTACT_ITEM_NOT_FOUND))
def addGroup(self, name):
error = self._checkCooldown(CLIENT_ACTION_ID.ADD_GROUP)
if error:
return (False, error)
elif self.usersStorage.isGroupExists(name):
return (False, ClientContactError(CONTACT_ERROR_ID.GROUP_EXISTS, name))
elif len(self.usersStorage.getGroups()) >= CONTACT_LIMIT.GROUPS_MAX_COUNT:
return (False, ClientIntLimitError(LIMIT_ERROR_ID.MAX_GROUP, CONTACT_LIMIT.GROUPS_MAX_COUNT))
else:
self.usersStorage.addEmptyGroup(name)
g_messengerEvents.users.onEmptyGroupsChanged({name}, None)
self.__cooldown.process(CLIENT_ACTION_ID.ADD_GROUP)
return (True, None)
def renameGroup(self, oldName, newName):
error = self._checkCooldown(CLIENT_ACTION_ID.CHANGE_GROUP)
if error:
return (False, error)
elif self.usersStorage.isGroupExists(newName):
return (False, ClientContactError(CONTACT_ERROR_ID.GROUP_EXISTS))
elif newName == oldName:
return (False, ClientActionError(CLIENT_ACTION_ID.CHANGE_GROUP, CLIENT_ERROR_ID.GENERIC))
elif self.usersStorage.isGroupEmpty(oldName):
self.usersStorage.changeEmptyGroup(oldName, newName)
g_messengerEvents.users.onEmptyGroupsChanged({newName}, {oldName})
return (True, None)
else:
task = self.__makeChangeGroupsChain(oldName, newName)
self.__cooldown.process(CLIENT_ACTION_ID.CHANGE_GROUP)
return self.__addTasks(CLIENT_ACTION_ID.CHANGE_GROUP, task.getJID(), task)
def removeGroup(self, name, isForced = False):
error = self._checkCooldown(CLIENT_ACTION_ID.CHANGE_GROUP)
if error:
return (False, error)
elif not self.usersStorage.isGroupExists(name):
return (False, ClientContactError(CONTACT_ERROR_ID.GROUP_NOT_FOUND, name))
elif self.usersStorage.isGroupEmpty(name):
self.usersStorage.changeEmptyGroup(name)
g_messengerEvents.users.onEmptyGroupsChanged(None, {name})
return (True, None)
else:
if isForced:
task = self.__makeRemoveItemsByGroupChain(name)
else:
task = self.__makeChangeGroupsChain(name)
self.__cooldown.process(CLIENT_ACTION_ID.CHANGE_GROUP)
return self.__addTasks(CLIENT_ACTION_ID.CHANGE_GROUP, task.getJID(), task)
def addTmpIgnored(self, dbID, name):
error = self._checkCooldown(CLIENT_ACTION_ID.ADD_IGNORED)
if error:
return (False, error)
tasks, itemType = [], XMPP_ITEM_TYPE.EMPTY_ITEM
contact = self.usersStorage.getUser(dbID, PROTO_TYPE.XMPP)
if contact:
if contact.isCurrentPlayer():
return (False, ClientActionError(CLIENT_ACTION_ID.ADD_IGNORED, CLIENT_ERROR_ID.GENERIC))
itemType = contact.getItemType()
if itemType in XMPP_ITEM_TYPE.BLOCK_ITEMS:
return (False, ClientContactError(CONTACT_ERROR_ID.BLOCK_ITEM_EXISTS, contact.getFullName()))
if contact:
jid = contact.getJID()
else:
jid = makeContactJID(dbID)
tasks.append(block_tasks.AddTmpBlockItemTask(jid, name))
self.__cooldown.process(CLIENT_ACTION_ID.ADD_IGNORED)
return self.__addTasks(CLIENT_ACTION_ID.ADD_IGNORED, jid, *tasks)