copyleftie
/
gajim-plural
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move more MUC methods into muc module

This commit is contained in:
Philipp Hörist 2018-07-21 12:21:48 +02:00
parent 37f7a80396
commit 78858f7c82
8 changed files with 244 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
gajim/command_system/implementation/standard.py
View File

@ -284,7 +284,8 @@ class StandardGroupChatCommands(CommandContainer):
@doc(_("Display or change a group chat topic"))
def topic(self, new_topic):
if new_topic:
self.connection.send_gc_subject(self.room_jid, new_topic)
self.connection.get_module('MUC').set_subject(
self.room_jid, new_topic)
else:
return self.subject
@ -314,18 +315,22 @@ class StandardGroupChatCommands(CommandContainer):
If given nickname is not found it will be treated as a JID.
"""))
def ban(self, who, reason):
def ban(self, who, reason=''):
if who in app.contacts.get_nick_list(self.account, self.room_jid):
contact = app.contacts.get_gc_contact(self.account, self.room_jid, who)
who = contact.jid
self.connection.gc_set_affiliation(self.room_jid, who, 'outcast', reason or str())
self.connection.get_module('MUC').set_affiliation(
self.room_jid,
{who: {'affiliation': 'outcast',
'reason': reason}})
@command(raw=True, empty=True)
@doc(_("Kick user by a nick from a groupchat"))
def kick(self, who, reason):
if not who in app.contacts.get_nick_list(self.account, self.room_jid):
raise CommandError(_("Nickname not found"))
self.connection.gc_set_role(self.room_jid, who, 'none', reason or str())
self.connection.get_module('MUC').set_role(
self.room_jid, who, 'none', reason or str())
@command(raw=True)
#Do not translate moderator, participant, visitor, none
@ -337,7 +342,7 @@ class StandardGroupChatCommands(CommandContainer):
raise CommandError(_("Invalid role given"))
if not who in app.contacts.get_nick_list(self.account, self.room_jid):
raise CommandError(_("Nickname not found"))
self.connection.gc_set_role(self.room_jid, who, role)
self.connection.get_module('MUC').set_role(self.room_jid, who, role)
@command(raw=True)
#Do not translate owner, admin, member, outcast, none
@ -347,11 +352,13 @@ class StandardGroupChatCommands(CommandContainer):
def affiliate(self, who, affiliation):
if affiliation not in ('owner', 'admin', 'member', 'outcast', 'none'):
raise CommandError(_("Invalid affiliation given"))
if not who in app.contacts.get_nick_list(self.account, self.room_jid):
if who not in app.contacts.get_nick_list(self.account, self.room_jid):
raise CommandError(_("Nickname not found"))
contact = app.contacts.get_gc_contact(self.account, self.room_jid, who)
self.connection.gc_set_affiliation(self.room_jid, contact.jid,
affiliation)
self.connection.get_module('MUC').set_affiliation(
self.room_jid,
{contact.jid: {'affiliation': affiliation}})
@command
@doc(_("Display names of all group chat occupants"))

97
gajim/common/connection.py
View File

@ -2143,46 +2143,6 @@ class Connection(CommonConnection, ConnectionHandlers):
chatstate=None, automatic_message=obj.automatic_message,
stanza_id=obj.stanza_id, additional_data=obj.additional_data))
def send_gc_subject(self, jid, subject):
if not app.account_is_connected(self.name):
return
msg_iq = nbxmpp.Message(jid, typ='groupchat', subject=subject)
self.connection.send(msg_iq)
def request_gc_config(self, room_jid):
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='get', queryNS=nbxmpp.NS_MUC_OWNER,
to=room_jid)
self.add_lang(iq)
self.connection.send(iq)
def cancel_gc_config(self, room_jid):
if not app.account_is_connected(self.name):
return
cancel = nbxmpp.Node(tag='x', attrs={'xmlns': nbxmpp.NS_DATA,
'type': 'cancel'})
iq = nbxmpp.Iq(typ='set',
queryNS=nbxmpp.NS_MUC_OWNER,
payload=cancel,
to=room_jid)
self.connection.send(iq)
def destroy_gc_room(self, room_jid, reason = '', jid = ''):
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='set', queryNS=nbxmpp.NS_MUC_OWNER,
to=room_jid)
destroy = iq.setQuery().setTag('destroy')
if reason:
destroy.setTagData('reason', reason)
if jid:
destroy.setAttr('jid', jid)
self.connection.send(iq)
i = 0
self.get_module('Bookmarks').bookmarks.pop(jid, None)
self.get_module('Bookmarks').store_bookmarks()
def send_gc_status(self, nick, jid, show, status, auto=False):
if not app.account_is_connected(self.name):
return
@ -2213,63 +2173,6 @@ class Connection(CommonConnection, ConnectionHandlers):
# disconnect from jabber server
self.connection.send(p)
def gc_set_role(self, room_jid, nick, role, reason=''):
"""
Role is for all the life of the room so it's based on nick
"""
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('nick', nick)
item.setAttr('role', role)
if reason:
item.addChild(name='reason', payload=reason)
self.connection.send(iq)
def gc_set_affiliation(self, room_jid, jid, affiliation, reason = ''):
"""
Affiliation is for all the life of the room so it's based on jid
"""
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('jid', jid)
item.setAttr('affiliation', affiliation)
if reason:
item.addChild(name = 'reason', payload = reason)
self.connection.send(iq)
def send_gc_affiliation_list(self, room_jid, users_dict):
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery()
for jid in users_dict:
item_tag = item.addChild('item', {'jid': jid,
'affiliation': users_dict[jid]['affiliation']})
if 'reason' in users_dict[jid] and users_dict[jid]['reason']:
item_tag.setTagData('reason', users_dict[jid]['reason'])
self.connection.send(iq)
def get_affiliation_list(self, room_jid, affiliation):
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='get', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('affiliation', affiliation)
self.connection.send(iq)
def send_gc_config(self, room_jid, form):
if not app.account_is_connected(self.name):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_OWNER)
query = iq.setQuery()
form.setAttr('type', 'submit')
query.addChild(node = form)
self.connection.send(iq)
def change_password(self, password):
if not app.account_is_connected(self.name):
return

14
gajim/common/connection_handlers.py
View File

@ -998,16 +998,6 @@ class ConnectionHandlers(ConnectionSocks5Bytestream, ConnectionDisco,
# This way we'll really remove it
app.to_be_removed[self.name].remove(jid)
def _MucOwnerCB(self, con, iq_obj):
log.debug('MucOwnerCB')
app.nec.push_incoming_event(MucOwnerReceivedEvent(None, conn=self,
stanza=iq_obj))
def _MucAdminCB(self, con, iq_obj):
log.debug('MucAdminCB')
app.nec.push_incoming_event(MucAdminReceivedEvent(None, conn=self,
stanza=iq_obj))
def _getRoster(self):
log.debug('getRosterCB')
if not self.connection:
@ -1179,10 +1169,6 @@ class ConnectionHandlers(ConnectionSocks5Bytestream, ConnectionDisco,
nbxmpp.NS_DISCO_INFO)
con.RegisterHandler('iq', self._DiscoverInfoErrorCB, 'error',
nbxmpp.NS_DISCO_INFO)
con.RegisterHandler('iq', self._MucOwnerCB, 'result',
nbxmpp.NS_MUC_OWNER)
con.RegisterHandler('iq', self._MucAdminCB, 'result',
nbxmpp.NS_MUC_ADMIN)
con.RegisterHandler('iq', self._SecLabelCB, 'result',
nbxmpp.NS_SECLABEL_CATALOG)
con.RegisterHandler('iq', self._DiscoverInfoGetCB, 'get',

42
gajim/common/connection_handlers_events.py
View File

@ -267,48 +267,6 @@ class RosterInfoEvent(nec.NetworkIncomingEvent):
def init(self):
self.avatar_sha = None
class MucOwnerReceivedEvent(nec.NetworkIncomingEvent, HelperEvent):
name = 'muc-owner-received'
base_network_events = []
def generate(self):
self.get_jid_resource()
qp = self.stanza.getQueryPayload()
self.form_node = None
for q in qp:
if q.getNamespace() == nbxmpp.NS_DATA:
self.form_node = q
self.dataform = dataforms.ExtendForm(node=self.form_node)
return True
class MucAdminReceivedEvent(nec.NetworkIncomingEvent, HelperEvent):
name = 'muc-admin-received'
base_network_events = []
def generate(self):
self.get_jid_resource()
items = self.stanza.getTag('query',
namespace=nbxmpp.NS_MUC_ADMIN).getTags('item')
self.users_dict = {}
for item in items:
if item.has_attr('jid') and item.has_attr('affiliation'):
try:
jid = helpers.parse_jid(item.getAttr('jid'))
except helpers.InvalidFormat:
log.warning('Invalid JID: %s, ignoring it' % \
item.getAttr('jid'))
continue
affiliation = item.getAttr('affiliation')
self.users_dict[jid] = {'affiliation': affiliation}
if item.has_attr('nick'):
self.users_dict[jid]['nick'] = item.getAttr('nick')
if item.has_attr('role'):
self.users_dict[jid]['role'] = item.getAttr('role')
reason = item.getTagData('reason')
if reason:
self.users_dict[jid]['reason'] = reason
return True
class IqErrorReceivedEvent(nec.NetworkIncomingEvent, HelperEvent):
name = 'iq-error-received'
base_network_events = []

160
gajim/common/modules/muc.py
View File

@ -19,6 +19,8 @@ import logging
import nbxmpp
from gajim.common import i18n
from gajim.common import dataforms
from gajim.common import app
from gajim.common import helpers
from gajim.common.nec import NetworkIncomingEvent
@ -36,6 +38,152 @@ class MUC:
('message', self._direct_invite, '', nbxmpp.NS_CONFERENCE),
]
def set_subject(self, room_jid, subject):
if not app.account_is_connected(self._account):
return
message = nbxmpp.Message(room_jid, typ='groupchat', subject=subject)
log.info('Set subject for %s', room_jid)
self._con.connection.send(message)
def request_config(self, room_jid):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='get',
queryNS=nbxmpp.NS_MUC_OWNER,
to=room_jid)
iq.setAttr('xml:lang', i18n.LANG)
log.info('Request config for %s', room_jid)
self._con.connection.SendAndCallForResponse(
iq, self._config_received)
def _config_received(self, stanza):
if not nbxmpp.isResultNode(stanza):
log.info('Error: %s', stanza.getError())
return
room_jid = stanza.getFrom().getStripped()
payload = stanza.getQueryPayload()
for form in payload:
if form.getNamespace() == nbxmpp.NS_DATA:
dataform = dataforms.ExtendForm(node=form)
log.info('Config form received for %s', room_jid)
app.nec.push_incoming_event(MucOwnerReceivedEvent(
None,
conn=self._con,
form_node=form,
dataform=dataform,
jid=room_jid))
break
def cancel_config(self, room_jid):
if not app.account_is_connected(self._account):
return
cancel = nbxmpp.Node(tag='x', attrs={'xmlns': nbxmpp.NS_DATA,
'type': 'cancel'})
iq = nbxmpp.Iq(typ='set',
queryNS=nbxmpp.NS_MUC_OWNER,
payload=cancel,
to=room_jid)
log.info('Cancel config for %s', room_jid)
self._con.connection.SendAndCallForResponse(
iq, self._default_response, {})
def destroy(self, room_jid, reason='', jid=''):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='set',
queryNS=nbxmpp.NS_MUC_OWNER,
to=room_jid)
destroy = iq.setQuery().setTag('destroy')
if reason:
destroy.setTagData('reason', reason)
if jid:
destroy.setAttr('jid', jid)
log.info('Destroy room: %s, reason: %s, alternate: %s',
room_jid, reason, jid)
self._con.connection.SendAndCallForResponse(
iq, self._default_response, {})
def set_config(self, room_jid, form):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_OWNER)
query = iq.setQuery()
form.setAttr('type', 'submit')
query.addChild(node=form)
log.info('Set config for %s', room_jid)
self._con.connection.SendAndCallForResponse(
iq, self._default_response, {})
def set_affiliation(self, room_jid, users_dict):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery()
for jid in users_dict:
affiliation = users_dict[jid].get('affiliation')
reason = users_dict[jid].get('reason') or None
item_tag = item.addChild('item', {'jid': jid,
'affiliation': affiliation})
if reason is not None:
item_tag.setTagData('reason', reason)
log.info('Set affiliation for %s: %s', room_jid, users_dict)
self._con.connection.SendAndCallForResponse(
iq, self._default_response, {})
def get_affiliation(self, room_jid, affiliation):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='get', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('affiliation', affiliation)
log.info('Get affiliation %s for %s', affiliation, room_jid)
self._con.connection.SendAndCallForResponse(
iq, self._affiliation_received)
def _affiliation_received(self, stanza):
if not nbxmpp.isResultNode(stanza):
log.info('Error: %s', stanza.getError())
return
room_jid = stanza.getFrom().getStripped()
query = stanza.getTag('query', namespace=nbxmpp.NS_MUC_ADMIN)
items = query.getTags('item')
users_dict = {}
for item in items:
try:
jid = helpers.parse_jid(item.getAttr('jid'))
except helpers.InvalidFormat:
log.warning('Invalid JID: %s, ignoring it',
item.getAttr('jid'))
continue
affiliation = item.getAttr('affiliation')
users_dict[jid] = {'affiliation': affiliation}
if item.has_attr('nick'):
users_dict[jid]['nick'] = item.getAttr('nick')
if item.has_attr('role'):
users_dict[jid]['role'] = item.getAttr('role')
reason = item.getTagData('reason')
if reason:
users_dict[jid]['reason'] = reason
log.info('Affiliations received from %s: %s', room_jid, users_dict)
app.nec.push_incoming_event(MucAdminReceivedEvent(
None, conn=self._con, room_jid=room_jid, users_dict=users_dict))
def set_role(self, room_jid, nick, role, reason=''):
if not app.account_is_connected(self._account):
return
iq = nbxmpp.Iq(typ='set', to=room_jid, queryNS=nbxmpp.NS_MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('nick', nick)
item.setAttr('role', role)
if reason:
item.addChild(name='reason', payload=reason)
log.info('Set role for %s: %s %s %s', room_jid, nick, role, reason)
self._con.connection.SendAndCallForResponse(
iq, self._default_response, {})
def _mediated_invite(self, con, stanza):
muc_user = stanza.getTag('x', namespace=nbxmpp.NS_MUC_USER)
if muc_user is None:
@ -192,6 +340,10 @@ class MUC:
message.addChild(node=x)
self._con.connection.send(message)
def _default_response(self, conn, stanza, **kwargs):
if not nbxmpp.isResultNode(stanza):
log.info('Error: %s', stanza.getError())
class GcInvitationReceived(NetworkIncomingEvent):
name = 'gc-invitation-received'
@ -201,5 +353,13 @@ class GcDeclineReceived(NetworkIncomingEvent):
name = 'gc-decline-received'
class MucAdminReceivedEvent(NetworkIncomingEvent):
name = 'muc-admin-received'
class MucOwnerReceivedEvent(NetworkIncomingEvent):
name = 'muc-owner-received'
def get_instance(*args, **kwargs):
return MUC(*args, **kwargs), 'MUC'

13
gajim/config.py
View File

@ -1644,8 +1644,8 @@ class GroupchatConfigWindow:
sw = Gtk.ScrolledWindow()
sw.add(self.affiliation_treeview[affiliation])
add_on_vbox.pack_start(sw, True, True, 0)
app.connections[self.account].get_affiliation_list(self.room_jid,
affiliation)
con = app.connections[self.account]
con.get_module('MUC').get_affiliation(self.room_jid, affiliation)
self.xml.connect_signals(self)
self.window.connect('delete-event', self.on_cancel_button_clicked)
@ -1653,7 +1653,8 @@ class GroupchatConfigWindow:
def on_cancel_button_clicked(self, *args):
if self.form:
app.connections[self.account].cancel_gc_config(self.room_jid)
con = app.connections[self.account]
con.get_module('MUC').cancel_config(self.room_jid)
self.window.destroy()
def on_cell_edited(self, cell, path, new_text):
@ -1728,7 +1729,8 @@ class GroupchatConfigWindow:
def on_ok_button_clicked(self, widget):
if self.form:
form = self.data_form_widget.data_form
app.connections[self.account].send_gc_config(self.room_jid, form)
con = app.connections[self.account]
con.get_module('MUC').set_config(self.room_jid, form)
for affiliation in self.affiliation_labels.keys():
users_dict = {}
actual_jid_list = []
@ -1751,7 +1753,8 @@ class GroupchatConfigWindow:
if jid not in actual_jid_list:
users_dict[jid] = {'affiliation': 'none'}
if users_dict:
app.connections[self.account].send_gc_affiliation_list(
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid, users_dict)
self.window.destroy()

93
gajim/groupchat_control.py
View File

@ -649,8 +649,8 @@ class GroupchatControl(ChatControlBase):
def on_ok(subject):
# Note, we don't update self.subject since we don't know whether it
# will work yet
app.connections[self.account].send_gc_subject(
self.room_jid, subject)
con = app.connections[self.account]
con.get_module('MUC').set_subject(self.room_jid, subject)
InputTextDialog(_('Changing Subject'),
_('Please specify the new subject:'), input_str=self.subject,
@ -678,11 +678,14 @@ class GroupchatControl(ChatControlBase):
try:
jid = helpers.parse_jid(jid)
except Exception:
ErrorDialog(_('Invalid group chat JID'),
_('The group chat JID has not allowed characters.'))
ErrorDialog(
_('Invalid group chat JID'),
_('The group chat JID has not allowed characters.'))
return
app.connections[self.account].destroy_gc_room(
self.room_jid, reason, jid)
con = app.connections[self.account]
con.get_module('MUC').destroy(self.room_jid, reason, jid)
con.get_module('Bookmarks').bookmarks.pop(self.room_jid, None)
con.get_module('Bookmarks').store_bookmarks()
gui_menu_builder.build_bookmark_menu(self.account)
self.force_non_minimizable = True
self.parent_win.remove_tab(self, self.parent_win.CLOSE_COMMAND)
@ -699,7 +702,8 @@ class GroupchatControl(ChatControlBase):
c = app.contacts.get_gc_contact(
self.account, self.room_jid, self.nick)
if c.affiliation == 'owner':
app.connections[self.account].request_gc_config(self.room_jid)
con = app.connections[self.account]
con.get_module('MUC').request_config(self.room_jid)
elif c.affiliation == 'admin':
if self.room_jid not in app.interface.instances[self.account][
'gc_config']:
@ -1797,8 +1801,8 @@ class GroupchatControl(ChatControlBase):
# We need to configure the room if it's a new one.
# We cannot know it's a new one. Status 201 is not
# sent by all servers.
app.connections[self.account].request_gc_config(
self.room_jid)
con = app.connections[self.account]
con.get_module('MUC').request_config(self.room_jid)
elif 'continue_tag' in app.automatic_rooms[
self.account][self.room_jid]:
# We just need to invite contacts
@ -1932,8 +1936,8 @@ class GroupchatControl(ChatControlBase):
self.draw_all_roles()
if obj.status_code and '201' in obj.status_code:
# We just created the room
app.connections[self.account].request_gc_config(
self.room_jid)
con = app.connections[self.account]
con.get_module('MUC').request_config(self.room_jid)
else:
gc_c = app.contacts.get_gc_contact(self.account,
self.room_jid, obj.nick)
@ -2382,8 +2386,8 @@ class GroupchatControl(ChatControlBase):
def on_ok(subject):
# Note, we don't update self.subject since we don't know whether it
# will work yet
app.connections[self.account].send_gc_subject(self.room_jid,
subject)
con = app.connections[self.account]
con.get_module('MUC').set_subject(self.room_jid, subject)
InputTextDialog(_('Changing Subject'),
_('Please specify the new subject:'), input_str=self.subject,
@ -2562,8 +2566,8 @@ class GroupchatControl(ChatControlBase):
Kick a user
"""
def on_ok(reason):
app.connections[self.account].gc_set_role(self.room_jid, nick,
'none', reason)
con = app.connections[self.account]
con.get_module('MUC').set_role(self.room_jid, nick, 'none', reason)
# ask for reason
InputDialog(_('Kicking %s') % nick,
@ -2828,37 +2832,40 @@ class GroupchatControl(ChatControlBase):
"""
Grant voice privilege to a user
"""
app.connections[self.account].gc_set_role(self.room_jid, nick,
'participant')
con = app.connections[self.account]
con.get_module('MUC').set_role(self.room_jid, nick, 'participant')
def revoke_voice(self, widget, nick):
"""
Revoke voice privilege to a user
"""
app.connections[self.account].gc_set_role(self.room_jid, nick,
'visitor')
con = app.connections[self.account]
con.get_module('MUC').set_role(self.room_jid, nick, 'visitor')
def grant_moderator(self, widget, nick):
"""
Grant moderator privilege to a user
"""
app.connections[self.account].gc_set_role(self.room_jid, nick,
'moderator')
con = app.connections[self.account]
con.get_module('MUC').set_role(self.room_jid, nick, 'moderator')
def revoke_moderator(self, widget, nick):
"""
Revoke moderator privilege to a user
"""
app.connections[self.account].gc_set_role(self.room_jid, nick,
'participant')
con = app.connections[self.account]
con.get_module('MUC').set_role(self.room_jid, nick, 'participant')
def ban(self, widget, jid):
"""
Ban a user
"""
def on_ok(reason):
app.connections[self.account].gc_set_affiliation(self.room_jid,
jid, 'outcast', reason)
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'outcast',
'reason': reason}})
# to ban we know the real jid. so jid is not fakejid
nick = app.get_nick_from_jid(jid)
@ -2871,43 +2878,55 @@ class GroupchatControl(ChatControlBase):
"""
Grant membership privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'member')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'member'}})
def revoke_membership(self, widget, jid):
"""
Revoke membership privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'none')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'none'}})
def grant_admin(self, widget, jid):
"""
Grant administrative privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'admin')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'admin'}})
def revoke_admin(self, widget, jid):
"""
Revoke administrative privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'member')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'member'}})
def grant_owner(self, widget, jid):
"""
Grant owner privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'owner')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'owner'}})
def revoke_owner(self, widget, jid):
"""
Revoke owner privilege to a user
"""
app.connections[self.account].gc_set_affiliation(self.room_jid, jid,
'admin')
con = app.connections[self.account]
con.get_module('MUC').set_affiliation(
self.room_jid,
{jid: {'affiliation': 'admin'}})
def on_info(self, widget, nick):
"""

10
gajim/gui_interface.py
View File

@ -606,14 +606,14 @@ class Interface:
f.value = True
elif f.var == 'public_list':
f.value = False
obj.conn.send_gc_config(obj.jid, obj.dataform.get_purged())
obj.conn.get_module('MUC').set_config(obj.jid, obj.dataform.get_purged())
user_list = {}
for jid in app.automatic_rooms[account][obj.jid]['invities']:
user_list[jid] = {'affiliation': 'member'}
obj.conn.send_gc_affiliation_list(obj.jid, user_list)
obj.conn.get_module('MUC').set_affiliation(obj.jid, user_list)
else:
# use default configuration
obj.conn.send_gc_config(obj.jid, obj.form_node)
obj.conn.get_module('MUC').set_config(obj.jid, obj.form_node)
# invite contacts
# check if it is necessary to add <continue />
continue_tag = False
@ -637,8 +637,8 @@ class Interface:
def handle_event_gc_affiliation(self, obj):
#('GC_AFFILIATION', account, (room_jid, users_dict))
account = obj.conn.name
if obj.jid in self.instances[account]['gc_config']:
self.instances[account]['gc_config'][obj.jid].\
if obj.room_jid in self.instances[account]['gc_config']:
self.instances[account]['gc_config'][obj.room_jid].\
affiliation_list_received(obj.users_dict)
def handle_event_gc_decline(self, obj):