def __from_xml(self, xmlnode):
"""Initialize `Register` from an XML node.
:Parameters:
- `xmlnode`: the jabber:x:register XML element.
:Types:
- `xmlnode`: `libxml2.xmlNode`"""
self.__logger.debug("Converting jabber:iq:register element from XML")
if xmlnode.type != "element":
raise ValueError, "XML node is not a jabber:iq:register element (not an element)"
ns = get_node_ns_uri(xmlnode)
if ns and ns != REGISTER_NS or xmlnode.name != "query":
raise ValueError, "XML node is not a jabber:iq:register element"
for element in xml_element_iter(xmlnode.children):
ns = get_node_ns_uri(element)
if ns == DATAFORM_NS and element.name == "x" and not self.form:
self.form = Form(element)
elif ns != REGISTER_NS:
continue
name = element.name
if name == "instructions" and not self.instructions:
self.instructions = from_utf8(element.getContent())
elif name == "registered":
self.registered = True
elif name == "remove":
self.remove = True
elif name in legacy_fields and not getattr(self, name):
value = from_utf8(element.getContent())
if value is None:
value = u""
self.__logger.debug(u"Setting legacy field %r to %r" %
(name, value))
setattr(self, name, value)
def request_instant_room(self):
"""
Request an "instant room" -- the default configuration for a MUC room.
:return: id of the request stanza.
:returntype: `unicode`
"""
if self.configured:
raise RuntimeError, "Instant room may be requested for unconfigured room only"
form = Form("submit")
return self.configure_room(form)
def build_form_inc(self, form_type, title, instructions, field_data):
form = Form(form_type)
form.title = title
form.instructions = instructions
for name, ftype, values, label, options, required, desc in field_data:
field = form.add_field(name=name,
field_type=ftype,
values=values,
label=label,
required=required,
desc=desc)
for olabel, ovalue in options:
field.add_option(ovalue, olabel)
return form
def main_menu_choice(self, response):
if response == "o":
form = self.form.make_submit()
self.form = None
self.callback(self, form)
self.callback = None
elif response == "c":
self.form = None
self.callback(self, Form("cancel"))
self.callback = None
elif response == "e":
self.clear()
self.edit_next_field(iter(self.editable_fields))
elif response in xrange(1, len(self.editable_fields) + 1):
self.clear()
self.edit_field(self.editable_fields[response - 1], self.main_menu)
else:
self.main_menu()
def build_form_direct(self, form_type, title, instructions, field_data):
fields = []
for name, ftype, values, label, options, required, desc in field_data:
foptions = []
for olabel, ovalue in options:
foptions.append(Option(ovalue, olabel))
field = Field(name=name,
field_type=ftype,
values=values,
label=label,
options=foptions,
required=required,
desc=desc)
fields.append(field)
form = Form(form_type,
title=title,
instructions=instructions,
fields=fields)
return form
def process_configuration_form_success(self, stanza):
"""
Process successful result of a room configuration form request.
:Parameters:
- `stanza`: the stanza received.
:Types:
- `stanza`: `Presence`
"""
if stanza.get_query_ns() != MUC_OWNER_NS:
raise ValueError, "Bad result namespace" # TODO: ProtocolError
query = stanza.get_query()
form = None
for el in xml_element_ns_iter(query.children, DATAFORM_NS):
form = Form(el)
break
if not form:
raise ValueError, "No form received" # TODO: ProtocolError
self.configuration_form = form
self.handler.configuration_form_received(form)
def complete_xml_element(self, xmlnode, _unused):
"""Complete the XML node with `self` content.
Should be overriden in classes derived from `StanzaPayloadObject`.
:Parameters:
- `xmlnode`: XML node with the element being built. It has already
right name and namespace, but no attributes or content.
- `_unused`: document to which the element belongs.
:Types:
- `xmlnode`: `libxml2.xmlNode`
- `_unused`: `libxml2.xmlDoc`"""
if self.possible_streams:
field = dataforms.Field(
name='stream-method',
field_type='list-single',
options=[dataforms.Option(n) for n in self.possible_streams])
f = dataforms.Form(xmlnode_or_type='form', fields=[field])
else:
f = Form(xmlnode_or_type="submit")
f.add_field(name='stream-method', value=self.selected_stream)
f.as_xml(xmlnode, _unused)
def get_form(self, form_type="form"):
"""Return Data Form for the `Register` object.
Convert legacy fields to a data form if `self.form` is `None`, return `self.form` otherwise.
:Parameters:
- `form_type`: If "form", then a form to fill-in should be
returned. If "sumbit", then a form with submitted data.
:Types:
- `form_type`: `unicode`
:return: `self.form` or a form created from the legacy fields
:returntype: `pyxmpp.jabber.dataforms.Form`"""
if self.form:
if self.form.type != form_type:
raise ValueError, "Bad form type in the jabber:iq:register element"
return self.form
form = Form(form_type, instructions=self.instructions)
form.add_field("FORM_TYPE", [u"jabber:iq:register"], "hidden")
for field in legacy_fields:
field_type, field_label = legacy_fields[field]
value = getattr(self, field)
if value is None:
continue
if form_type == "form":
if not value:
value = None
form.add_field(name=field,
field_type=field_type,
label=field_label,
value=value,
required=True)
else:
form.add_field(name=field, value=value)
return form
def parse_form(self, xml):
doc = libxml2.parseDoc(xml)
root = doc.getRootElement()
return Form(root)
