Esempio n. 1
0
def get_http_response_string(gateway_session_id, ivr_responses, collect_input=False, hang_up=True, input_length=None):
    xml_string = ""
    for response in ivr_responses:
        text_to_say = response["text_to_say"]
        audio_file_url = response["audio_file_url"]
        
        if audio_file_url is not None:
            xml_string += "<playaudio>%s</playaudio>" % escape(audio_file_url)
        elif text_to_say is not None:
            xml_string += "<playtext>%s</playtext>" % escape(text_to_say)
    
    input_length_str = ""
    if input_length is not None:
        input_length_str = 'l="%s"' % input_length
    
    if input_length == 1:
        timeout = "3000"
    else:
        timeout = "5000"
    
    if collect_input:
        xml_string = '<collectdtmf %s o="%s">%s</collectdtmf>' % (input_length_str, timeout, xml_string)
    
    if hang_up:
        xml_string += "<hangup/>"
    
    return '<response sid="%s">%s</response>' % (gateway_session_id[7:], xml_string)
Esempio n. 2
0
def render_report_group(group, request, css_class=''):
    """Produce the HTML for a report group on a section index page"""
    if not (IPeopleSectionColumn.providedBy(group) or
            IPeopleReportGroup.providedBy(group)):
        return ''
    result = []
    title = getattr(group, 'title', '')
    if title:
        result.append('<h3>%s</h3>' % escape(group.title))
    if css_class:
        result.append('<ul class=%s>' % quoteattr(css_class))
    else:
        result.append('<ul>')
    for obj in group.values():
        if IPeopleReport.providedBy(obj):
            url = resource_url(obj, request)
            result.append('<li><a href=%s class=%s>%s</a></li>' % (
                quoteattr(url),
                quoteattr(obj.css_class),
                escape(obj.link_title)))
        elif IPeopleReportGroup.providedBy(obj):
            html = render_report_group(obj, request)
            result.append('<li>')
            result.append(html)
            result.append('</li>')
    result.append('</ul>')
    return '\n'.join(result)
Esempio n. 3
0
    def give(self, new_owner=None):
        if not new_owner:
            try:
                new_owner = self._ask_question('Give ticket to…',
                                               'Enter the username of the new owner.',
                                               'Username:'******'Owner': new_owner, 'id': self._ticket})

        if response.result == RTResult.CANT_REASSIGN:
            self._notify("Couldn't change owner",
                         "This ticket belongs to %s, not you.%s" % (
                             saxutils.escape(response.owner),
                             ' Try stealing it first.' if 'actions' not in self._notify.caps else ''),
                         gtk.STOCK_DIALOG_WARNING, [self.show, self.steal_and_give(new_owner=new_owner, partial=True)])
        elif response.result == RTResult.OWNER_CHANGED:
            self._notify('Owner changed',
                         'This ticket now belongs to %s.' % saxutils.escape(response.owner),
                         gtk.STOCK_DIALOG_INFO, [self.show])
        elif response.result == RTResult.NO_SUCH_USER:
            self._notify('No such user',
                         "The ticket's owner wasn't changed as the specified user doesn't exist.",
                         gtk.STOCK_DIALOG_WARNING, [self.show, self.give_again])
Esempio n. 4
0
def output_difference(difference, print_func, parents):
    logger.debug('html output for %s', difference.source1)
    sources = parents + [difference.source1]
    print_func(u"<div class='difference'>")
    try:
        print_func(u"<div class='diffheader'>")
        if difference.source1 == difference.source2:
            print_func(u"<div><span class='source'>%s<span>"
                       % escape(difference.source1))
        else:
            print_func(u"<div><span class='source'>%s</span> vs.</div>"
                       % escape(difference.source1))
            print_func(u"<div><span class='source'>%s</span>"
                       % escape(difference.source2))
        anchor = '/'.join(sources[1:])
        print_func(u" <a class='anchor' href='#%s' name='%s'>&para;</a>" % (anchor, anchor))
        print_func(u"</div>")
        if difference.comment:
            print_func(u"<div class='comment'>%s</div>"
                       % escape(difference.comment).replace('\n', '<br />'))
        print_func(u"</div>")
        if difference.unified_diff:
            output_unified_diff(print_func, difference.unified_diff)
        for detail in difference.details:
            output_difference(detail, print_func, sources)
    except PrintLimitReached:
        logger.debug('print limit reached')
        raise
    finally:
        print_func(u"</div>", force=True)
Esempio n. 5
0
    def get_cell_data_cb(self, column, cell, model, piter, user_data=None):
        tool = model.get_value(piter, self.TOOL_COLUMN)

        if tool == None or not isinstance(tool, Tool):
            if tool == None:
                label = _('All Languages')
            elif not isinstance(tool, GtkSource.Language):
                label = _('Plain Text')
            else:
                label = tool.get_name()

            markup = saxutils.escape(label)
            editable = False
        else:
            escaped = saxutils.escape(tool.name)

            if tool.shortcut:
                key, mods = Gtk.accelerator_parse(tool.shortcut)
                label = Gtk.accelerator_get_label(key, mods)
                markup = '%s (<b>%s</b>)' % (escaped, label)
            else:
                markup = escaped

            editable = True

        cell.set_properties(markup=markup, editable=editable)
    def _update_publish(cls, upd_root):
        subscribe_item = etree.Element('resultItem')
        subscribe_item.extend(deepcopy(upd_root))
        from_name = escape(upd_root[0].attrib['name'])
        if not from_name in cls._graph:
            cls._graph[from_name] = {'ident': upd_root[0], 'links': {}}

        if len(upd_root) == 2:
            meta_name = re.sub("{.*}", "contrail:", upd_root[1][0].tag)
            link_key = meta_name
            link_info = {'meta': upd_root[1]}
            cls._graph[from_name]['links'][link_key] = link_info
        elif len(upd_root) == 3:
            meta_name = re.sub("{.*}", "contrail:", upd_root[2][0].tag)
            to_name = escape(upd_root[1].attrib['name'])
            link_key = '%s %s' % (meta_name, to_name)
            link_info = {'meta': upd_root[2], 'other': upd_root[1]}
            cls._graph[from_name]['links'][link_key] = link_info

            # reverse mapping only for strong refs
            # currently refs from same type to each other is weak ref
            from_type = from_name.split(':')[1]
            to_type = to_name.split(':')[1]
            if not to_name in cls._graph:
                cls._graph[to_name] = {'ident': upd_root[1], 'links': {}}
            link_key = '%s %s' % (meta_name, from_name)
            link_info = {'meta': upd_root[2], 'other': upd_root[0]}
            cls._graph[to_name]['links'][link_key] = link_info
        else:
            raise Exception("Unknown ifmap update: %s" %
                            (etree.tostring(upd_root)))

        subscribe_result = etree.Element('updateResult')
        subscribe_result.append(subscribe_item)
        return subscribe_result
Esempio n. 7
0
def _get_add_xml(array_of_hash, overwrite=True):
    """ Creates add XML message to send to Solr based on the array of hashes
    (documents) provided.

    :param overwrite: Newer documents will replace previously added documents
                      with the same uniqueKey (default is True)

    """
    xml = '<add overwrite="%s">' % ('true' if overwrite else 'false')
    for doc_hash in array_of_hash:
        doc = '<doc>'
        for key, value in doc_hash.items():
            if type(value) == type(list()):
                for v in value:
                    if isinstance(v, basestring):
                        v = escape(v)
                    doc = '%s<field name="%s">%s</field>' % (doc, key, v)
            else:
                if isinstance(value, basestring):
                    value = escape(value)
                doc = '%s<field name="%s">%s</field>' % (doc, key, value)
        doc = '%s</doc>' % (doc)
        xml = '%s%s' % (xml, doc)
    xml = '%s</add>' % (xml)
    return xml
Esempio n. 8
0
    def task_label_column(self, node):
        str_format = "%s"

        if node.get_status() == Task.STA_ACTIVE:
            # we mark in bold tasks which are due today or as Now
            days_left = node.get_days_left()
            if days_left is not None and days_left <= 0:
                str_format = "<b>%s</b>"
            if self._has_hidden_subtask(node):
                str_format = "<span color='%s'>%s</span>"\
                    % (self.unactive_color, str_format)

        title = str_format % saxutils.escape(node.get_title())
        if node.get_status() == Task.STA_ACTIVE:
            count = self.mainview.node_n_children(node.get_id(),
                                                  recursive=True)
            if count != 0:
                title += " (%s)" % count
        elif node.get_status() == Task.STA_DISMISSED:
            title = "<span color='%s'>%s</span>" % (self.unactive_color, title)

        if self.config.get("contents_preview_enable"):
            excerpt = saxutils.escape(node.get_excerpt(lines=1,
                                                       strip_tags=True,
                                                       strip_subtasks=True))
            title += " <span size='small' color='%s'>%s</span>" \
                % (self.unactive_color, excerpt)
        return title
Esempio n. 9
0
def whats_this_helper(desc, include_more_link=False):
    """
    A `What's this` text construction helper. If `include_more_link` is
    True then the text will include a `more...` link.

    """
    title = desc.name
    help_url = desc.help

    if not help_url:
        help_url = "help://search?" + urlencode({"id": desc.id})

    description = desc.description
    long_description = desc.long_description

    template = ["<h3>{0}</h3>".format(escape(title))]

    if description:
        template.append("<p>{0}</p>".format(escape(description)))

    if long_description:
        template.append("<p>{0}</p>".format(escape(long_description[:100])))

    if help_url and include_more_link:
        template.append("<a href='{0}'>more...</a>".format(escape(help_url)))

    return "\n".join(template)
Esempio n. 10
0
 def append_text(self, text):
     text1, text2 = (text + '\n').split('\n', 1)
     text = self.text_markup % (self.foreground_color, escape(text1), escape(text2))
     self.text = self.text + "\n" + text
     self.message_label.set_text(self.text)
     self.message_label.set_use_markup(True)
     self.message_label.show()
Esempio n. 11
0
def tooltip_helper(desc):
    """Widget tooltip construction helper.

    """
    tooltip = []
    tooltip.append("<b>{name}</b>".format(name=escape(desc.name)))

    if desc.project_name and desc.project_name != "Orange":
        tooltip[0] += " (from {0})".format(desc.project_name)

    if desc.description:
        tooltip.append("{0}".format(
                            escape(desc.description)))

    inputs_fmt = "<li>{name}</li>"

    if desc.inputs:
        inputs = "".join(inputs_fmt.format(name=inp.name)
                         for inp in desc.inputs)
        tooltip.append("Inputs:<ul>{0}</ul>".format(inputs))
    else:
        tooltip.append("No inputs")

    if desc.outputs:
        outputs = "".join(inputs_fmt.format(name=out.name)
                          for out in desc.outputs)
        tooltip.append("Outputs:<ul>{0}</ul>".format(outputs))
    else:
        tooltip.append("No outputs")

    return "<hr/>".join(tooltip)
def message_to_xmb(message):
    """Converts a single message object to a <msg> tag in the XMB format."""
    # TODO(lschumacher) handle plurals
    message_id = message.id
    if isinstance(message_id, tuple):
        message_id = message_id[0]

    if 'python-format' in message.flags:
        xml_parts = []
        ph_index = 0
        for token in PYTHON_FORMAT_RE.split(message_id):
            if token.startswith('%(') and token.endswith(')s'):
                name = token[2:-2]
                ph_index += 1
                xml_parts.append('<ph name="%s"><ex>%s</ex>%%%d</ph>' %
                                 (name, name, ph_index))
            elif token == '%%':
                xml_parts.append('%')
            elif token:
                xml_parts.append(escape(token))
        xml_message = ''.join(xml_parts) 
    else:
        xml_message = escape(message_id)
    return '<msg desc=%s>%s</msg>' % (
        quoteattr(' '.join(message.user_comments)), xml_message)
Esempio n. 13
0
    def process(self, node):
        """ Process the given xml `node`: collect `todo` and `done` items. """
        if (
            isinstance(node, SKIPPED_ELEMENT_TYPES) or
            node.tag in SKIPPED_ELEMENTS or
            node.get("translation", "").strip() == "off" or
            node.tag == "attribute" and node.get("name") not in TRANSLATED_ATTRS
        ):
            # do not translate the contents of the node
            tail, node.tail = node.tail, None
            self.done(etree.tostring(node))
            self.todo(escape(tail or ""))
            return

        # process children nodes locally in child_trans
        child_trans = XMLTranslator(self.callback)
        child_trans.todo(escape(node.text or ""))
        for child in node:
            child_trans.process(child)

        if (child_trans.all_todo() and
                node.tag in TRANSLATED_ELEMENTS and
                not any(attr.startswith("t-") for attr in node.attrib)):
            # serialize the node element as todo
            self.todo(serialize(node.tag, node.attrib, child_trans.get_todo()),
                      child_trans.needs_trans)
        else:
            # complete translations and serialize result as done
            for attr in TRANSLATED_ATTRS:
                if node.get(attr):
                    node.set(attr, self.process_text(node.get(attr)))
            self.done(serialize(node.tag, node.attrib, child_trans.get_done()))

        # add node tail as todo
        self.todo(escape(node.tail or ""))
Esempio n. 14
0
    def get(self):
        bind_id = self.get_argument("bind_id")
        youtube_id = self.get_argument("youtube_id", "-1")
        time_watched = self.get_argument("time_watched", -1)
        logger.debug(
            "Set-top box list request received: bind_id: %s, youtube_id: %s, time_watched: %s",
            bind_id,
            youtube_id,
            time_watched,
        )

        try:
            if youtube_id != "-1" and youtube_id != "Title":
                Video.mark_watched(bind_id=bind_id, youtube_id=youtube_id, time_watched=time_watched)
        except:
            dbutils.Session.rollback()

        try:
            container = Video.get_list(bind_id=bind_id, is_stb=True)
            playback_url = fetch_yt_link(container["nowplaying"]["url"])
            playback_url = escape(playback_url + "&title=.mp4")
            container["nowplaying"]["url"] = escape(container["nowplaying"]["url"])
            container["nowplaying"]["title"] = escape(container["nowplaying"]["title"])
            container["nowplaying"]["youtube_id"] = escape(container["nowplaying"]["youtube_id"])
            container["nowplaying"]["playback_url"] = playback_url
        except:
            dbutils.Session.rollback()
            container = []
        logger.info("timewatched: %s youtube_id:%s bind_id:%s", time_watched, youtube_id, bind_id)
        #        self.content_type = 'text/xml' //HACK wtf why doesn't this work..?
        self._headers["Content-Type"] = "text/xml; charset=UTF-8"
        if container != []:
            self.write(dict2xml({"nowplaying": container["nowplaying"]}))
        dbutils.Session.remove()
        self.finish()
Esempio n. 15
0
    def _detailed_text(self, item):
        if isinstance(item, Installed):
            remote, dist = item
            if remote is None:
                description = get_dist_meta(dist).get("Description")
                description = description
            else:
                description = remote.description
        else:
            description = item[0].description

        if docutils is not None:
            try:
                html = docutils.core.publish_string(
                    trim(description),
                    writer_name="html",
                    settings_overrides={
                        "output-encoding": "utf-8",
#                         "embed-stylesheet": False,
#                         "stylesheet": [],
#                         "stylesheet_path": []
                    }
                ).decode("utf-8")

            except docutils.utils.SystemMessage:
                html = "<pre>{}<pre>".format(escape(description))
            except Exception:
                html = "<pre>{}<pre>".format(escape(description))
        else:
            html = "<pre>{}<pre>".format(escape(description))
        return html
Esempio n. 16
0
def xsams_source(source):
    """
    Yields the XML for an individual source in the XSAMS document.

    Arguments:
    source: an instance of the hitran_meta.models Source class.

    """

    yield '<Source sourceID="%s">' % (make_xsams_id('B', source.id),)
    author_list = source.authors.split(',')
    if source.note:
        yield '<Comments>%s</Comments>' % escape(source.note)
    yield '<Authors>'
    for author in author_list:
        yield '<Author><Name>%s</Name></Author>' % author
    yield '</Authors>'
    yield make_mandatory_tag('Title', escape(source.title), '[This source does'
                                        ' not have a title]')
    yield make_mandatory_tag('Category', source.source_type.xsams_category, '')
    # XXX what to do when the year is missing?
    yield make_mandatory_tag('Year', source.year, '2008')
    yield make_optional_tag('SourceName', source.journal)
    yield make_optional_tag('Volume', source.volume)
    yield make_optional_tag('PageBegin', source.page_start)
    yield make_optional_tag('PageEnd', source.page_end)
    yield make_optional_tag('ArticleNumber', source.article_number)
    yield make_optional_tag('UniformResourceIdentifier',
                            urllib.quote(source.url))
    yield make_optional_tag('DigitalObjectIdentifier', source.doi)
    yield '</Source>\n'
  def ToTagUri(self):
    """Returns a tag: URI for this entity for use in XML output.

    Foreign keys for entities may be represented in XML output as tag URIs.
    RFC 4151 describes the tag URI scheme. From http://taguri.org/:

      The tag algorithm lets people mint - create - identifiers that no one
      else using the same algorithm could ever mint. It is simple enough to do
      in your head, and the resulting identifiers can be easy to read, write,
      and remember. The identifiers conform to the URI (URL) Syntax.

    Tag URIs for entities use the app's auth domain and the date that the URI
     is generated. The namespace-specific part is <kind>[<key>].

    For example, here is the tag URI for a Kitten with the key "Fluffy" in the
    catsinsinks app:

      tag:catsinsinks.googleapps.com,2006-08-29:Kitten[Fluffy]

    Raises a BadKeyError if this entity's key is incomplete.
    """
    if not self.has_id_or_name():
      raise datastore_errors.BadKeyError(
        'ToTagUri() called for an entity with an incomplete key.')

    return u'tag:%s.%s,%s:%s[%s]' % (saxutils.escape(self.app()),
                                     os.environ['AUTH_DOMAIN'],
                                     datetime.date.today().isoformat(),
                                     saxutils.escape(self.kind()),
                                     saxutils.escape(str(self)))
Esempio n. 18
0
 def update(self, resources, locale, domain):
     """Save resources by given locale in domain file"""
     if locale == self.SOURCE_LOCALE:
         path = "values/{}.xml".format(domain)
     else:
         path = "values-{}/{}.xml".format(locale, domain)
     filename = os.path.join(self.basepath, path)
     xml = open(filename, 'w')
     # write xml header
     xml.write(XML_START)
     for resource in resources:
         if resource.is_plural:
             xml.write(
                 XML_PLURALS_START.format(resource=resource).encode("utf-8")
             )
             for (quantity, text) in resource.plurals.items():
                 # Write only nonempty plural forms
                 if text.strip():
                     xml.write(
                         XML_PLURALS_ITEM.format(
                             quantity=quantity, text=escape(text, APOS)
                         ).encode("utf-8")
                     )
             xml.write(XML_PLURALS_END)
         else:
             # quoteattr text in resource
             resource.message = escape(resource.text, APOS)
             xml.write(XML_STRING.format(resource=resource).encode("utf-8"))
     xml.write(XML_END)
     xml.close()
Esempio n. 19
0
    def new_link_item(self, source_item, source_channel,
                      sink_item, sink_channel):
        """
        Construct and return a new :class:`.LinkItem`
        """
        item = items.LinkItem()
        item.setSourceItem(source_item)
        item.setSinkItem(sink_item)

        def channel_name(channel):
            if isinstance(channel, basestring):
                return channel
            else:
                return channel.name

        source_name = channel_name(source_channel)
        sink_name = channel_name(sink_channel)

        fmt = u"<b>{0}</b>&nbsp; \u2192 &nbsp;<b>{1}</b>"
        item.setToolTip(
            fmt.format(escape(source_name),
                       escape(sink_name))
        )

        item.setSourceName(source_name)
        item.setSinkName(sink_name)
        item.setChannelNamesVisible(self.__channel_names_visible)

        return item
Esempio n. 20
0
 def branchentry(self, branch):
     # check if this branch must be checked, if not, recurse further
     if not NifSpell._branchinspect(self, branch):
         return True
     blocktype = branch.__class__.__name__
     reports = self.toaster.reports_per_blocktype.get(blocktype)
     if not reports:
         # start a new report for this block type
         row = "<tr>"
         row += "<th>%s</th>" % "file" 
         row +=  "<th>%s</th>" % "id" 
         for attr in branch._get_filtered_attribute_list(data=self.data):
             row += ("<th>%s</th>"
                     % escape(attr.displayname, self.ENTITIES))
         row += "</tr>"
         reports = [row]
         self.toaster.reports_per_blocktype[blocktype] = reports
     
     row = "<tr>"
     row += "<td>%s</td>" % escape(self.stream.name)
     row += "<td>%s</td>" % escape("0x%08X" % id(branch), self.ENTITIES)
     for attr in branch._get_filtered_attribute_list(data=self.data):
         row += ("<td>%s</td>"
                 % escape(dumpAttr(getattr(branch, "_%s_value_"
                                           % attr.name)),
                          self.ENTITIES))
     row += "</tr>"
     reports.append(row)
     # keep looking for blocks of interest
     return True
Esempio n. 21
0
def w3c_validate(filename):
    """
    For index.html, the validation URL is http://validator.w3.org/check?uri=http%3A%2F%2Fusers.nccs.gov%2F~tpb%2Ftechint_olcf%2Findex.html&charset=%28detect+automatically%29&doctype=Inline&group=0&user-agent=W3C_Validator%2F1.3
    """
    entities = {':': '%3a',
                '/': '%2F',
                '(': '%28',
                ')': '%29'}
    validator = "http://validator.w3.org"
    host = "http://users.nccs.gov/"
    path = "~tpb/techint"
    uri = xml.escape("uri=%s%s/%s" % (host, path, filename), entities)
    charset = xml.escape("charset=(detect+automatically)", entities)
    doctype = "doctype=Inline"
    group = "group=0"
    agent = xml.escape("user-agent=W3C_Validator/1.3", entities)
    
    url = "%s/check?%s&%s&%s&%s&%s" % (validator, uri, charset, doctype,
                                       group, agent)
    # print url

    page = urllib2.urlopen(url)
    text = page.readlines()
    vname = "validation_%s" % filename
    h = open(vname, 'w')
    h.writelines(text)
    h.close()
    print("Validation output is in %s" % vname)
    assess_validation(vname)
Esempio n. 22
0
def escape_html(input_file, output_file=os.getcwd() + '/'):
    f = file(input_file, 'r')
    for line in f.xreadlines():
        if output_file == os.getcwd() + '/':
            save_result_file(escape(line, html_escape_dict), output_file + input_file + '_escape')
        else:
            save_result_file(escape(line, html_escape_dict), output_file + '_escape')
Esempio n. 23
0
    def set_personal_message(self, personal_message='', current_media=None,
            signature_sound=None):
        """Sets the new personal message

            @param personal_message: the new personal message
            @type personal_message: string"""
        cm = ''
        if current_media is not None:
            cm ='\\0Music\\01\\0{0} - {1}\\0%s\\0%s\\0\\0' % \
                (xml_utils.escape(current_media[0]),
                 xml_utils.escape(current_media[1]))

        if signature_sound is not None:
            signature_sound = xml_utils.escape(signature_sound)
            ss = '<SignatureSound>%s</SignatureSound>' % signature_sound

        message = xml_utils.escape(personal_message)
        pm = '<Data>'\
                '<PSM>%s</PSM>'\
                '<CurrentMedia>%s</CurrentMedia>'\
                '<MachineGuid>%s</MachineGuid>'\
            '</Data>' % (message, cm, self._client.machine_guid.upper())
        self._send_command('UUX', payload=pm)
        self._client.profile._server_property_changed("personal-message",
                personal_message)
        if current_media is not None:
            self._client.profile._server_property_changed("current-media",
                current_media)
Esempio n. 24
0
    def as_xml (self, encoding="UTF-8"):
        """(str): str

        Return the XML representation of the collection.  The 'encoding'
        parameter will be substituted into the XML document's header,
        but it's the caller's responsibility to encode the string returned
        from this method.
        """
        from qel import QEL_HEADER, QEL_FOOTER
        s = QEL_HEADER % encoding
        if self.title:
            s += '  <title>%s</title>\n' % escape(self.title)
        if self.editor:
            s += '  <editor>%s</editor>\n' % escape(self.editor)
        if self.description:
            s += '  <description>%s</description>\n' % escape(self.description)
        if self.copyright:
            s += '  <copyright>%s</copyright>\n' % escape(self.copyright)
        if self.license:
            s += '  <license>'
            for t in self.license:
                if isinstance(t, str):
                    s += escape(t)
                else:
                    s += t.as_xml()
            s += '\n  </license>\n'
        for qt in self:
            s += qt.as_xml()
        s += QEL_FOOTER
        return s
Esempio n. 25
0
def listToRokuXml(listTag, itemTag, l):
    xml = '<' + saxutils.escape(listTag) + '>\n'
    for item in l:
        if type(item) is dict:
            xml += dictionaryToRokuXml(itemTag, item)
    xml += '</' + saxutils.escape(listTag) + '>\n'
    return xml
Esempio n. 26
0
def _build_health_report(incarnation, container_id, role_instance_id,
                         status, substatus, description):
    #Escape '&', '<' and '>'
    description = saxutils.escape(ustr(description))
    detail = u''
    if substatus is not None:
        substatus = saxutils.escape(ustr(substatus))
        detail = (u"<Details>"
                  u"<SubStatus>{0}</SubStatus>"
                  u"<Description>{1}</Description>"
                  u"</Details>").format(substatus, description)
    xml = (u"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
           u"<Health "
           u"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
           u" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
           u"<GoalStateIncarnation>{0}</GoalStateIncarnation>"
           u"<Container>"
           u"<ContainerId>{1}</ContainerId>"
           u"<RoleInstanceList>"
           u"<Role>"
           u"<InstanceId>{2}</InstanceId>"
           u"<Health>"
           u"<State>{3}</State>"
           u"{4}"
           u"</Health>"
           u"</Role>"
           u"</RoleInstanceList>"
           u"</Container>"
           u"</Health>"
           u"").format(incarnation,
                       container_id,
                       role_instance_id,
                       status,
                       detail)
    return xml
Esempio n. 27
0
    def as_xml(self):
        """Convert instance into QEL, pretty-printing it.
        """
        id = date = typ = ""
        if self.id is not None:
            id = ' id="%s"' % escape(self.id)
        if self.date is not None:
            date = ' date="%s"' % escape(self.date)
        if self.type is not None:
            typ = ','.join(self.type)
            typ = ' type="%s"' % escape(typ)

        output = "  <quotation%s%s%s>\n" % (id, date, typ)
        for paragraph in self.text:
            output += "    <p>\n"
            output += format_paragraph_as_xml(paragraph, 6*' ')
            output += "    </p>\n"

        for i in ['author', 'source']:
            value = getattr(self, i)
            if value is not None:
                output += (6*' ') + value.as_xml() + '\n'


        if self.note:
            output += "    <note>\n"
            for paragraph in self.note:
                output += "      <p>\n"
                output += format_paragraph_as_xml(paragraph, 8*' ')
                output += "      </p>\n"
            output += "    </note>\n"

        output += "  </quotation>\n"
        return output
        def html_elements(fullfilename, title, caption, identifier):

            return '<div class="item"><img class="content" src="' +\
                escape(fullfilename) + '" title="' +\
                escape(title) + '" identifier="' +\
                identifier + '"/> <div class="caption">' +\
                escape(caption) + '</div> </div>'
Esempio n. 29
0
    def on_display_text(self):
        # Now do the stuff that takes a bit longer...
        heading = self.episode.title
        subheading = _('from %s') % (self.episode.channel.title)
        description = self.episode.description

        if self.have_webkit:
            global SHOWNOTES_HTML_TEMPLATE

            # Get the description - if it looks like plaintext, replace the
            # newline characters with line breaks for the HTML view
            description = self.episode.description
            if '<' not in description:
                description = description.replace('\n', '<br>')

            args = (
                    saxutils.escape(heading),
                    saxutils.escape(subheading),
                    description,
            )
            url = os.path.dirname(self.episode.channel.url)
            self.htmlview.load_html_string(SHOWNOTES_HTML_TEMPLATE % args, url)
        else:
            self.b.create_tag('heading', scale=pango.SCALE_LARGE, weight=pango.WEIGHT_BOLD)
            self.b.create_tag('subheading', scale=pango.SCALE_SMALL)

            self.b.insert_with_tags_by_name(self.b.get_end_iter(), heading, 'heading')
            self.b.insert_at_cursor('\n')
            self.b.insert_with_tags_by_name(self.b.get_end_iter(), subheading, 'subheading')
            self.b.insert_at_cursor('\n\n')
            self.b.insert(self.b.get_end_iter(), util.remove_html_tags(description))
            self.b.place_cursor(self.b.get_start_iter())
Esempio n. 30
0
 def thank_after_registered(self, name, token, tmp_user_id, user_id, lang):
     url = u"https://sh-hringhorni.appspot.com/activate?t=" + escape(token) + u"&i=" + escape(tmp_user_id) + "&u=" + escape(user_id) + u"\n"
     body = escape(name) + u"さん、\nShourへようこそ。\n\nShourにあなたのメールアドレスが仮登録され、アカウントが発行されました。下記のURLをクリックしてアカウントを有効化してください。\n" + url + u"\nShourは、ちょっとした時間を親しい間柄の人との楽しいひと時に変える新感覚予定共有アプリです。\n\n「今度お茶しよう」\n「久しぶりに会いたいね」\n「また語りましょう」\nそんな友達との約束を、Shourで是非実現してみてください。\n\n日々の生活の中にあるスキマ時間が、シャワータイムのようなリフレッシュのひと時になるよう、Shourはお手伝いします。\n\nShour開発チーム一同\n\n※このメールに覚えがない場合、誤って送信された可能性がございます。大変お手数ですが、破棄してください。"
     if lang:
         if lang == "en":
             body = u"Hi," + escape(name) +".\nYou are the newest member of \"Shour\".\n\nClick here to verify your email address. \n" + url + u"\nWith shour, you can enjoy a pleasant time with your close friends in your spare time. Shour will help you spent refreshing moments like shower time. Please just try it! We hope you enjoy \"SHaring your hOUR\"!! \n\nDevelopment team of Shour\n\nNotice: If you do not know any idea about this email, this may be miscarriaged to wrong email address. We appologize for this inconvenience and thank you for delete this email."
     return body
Esempio n. 31
0
def setrenderer():
    # tell the controlpoint which renderer is current
    print "---- setrenderer -----------------------------------"
    print "renderertitle: " + str(request.vars.renderertitle)
    print "renderertype: " + str(request.vars.renderertype)
    print "renderertarget: " + str(request.vars.renderertarget)
    print "queuetarget: " + str(request.vars.queuetarget)
    print "queuedata: " + str(request.vars.queuedata)
    print "queuechain: " + str(request.vars.queuechain)

    ptitle = escape(request.vars.renderertitle, url_escape_entities)
    ptype = request.vars.renderertype
    ptarget = request.vars.renderertarget
    qtarget = request.vars.queuetarget
    qdata = request.vars.queuedata
    qchainparams = request.vars.queuechain

    pentry = ptype + '::' + ptitle
    print "entry: " + str(pentry)

    # get the meta data for this renderer
    datastring = urllib.urlopen('http://' + ip_address +
                                ':50101/data/rendererData?data=' +
                                pentry).read()
    datadict = unwrap_data(datastring)

    print "rendererData: " + str(datadict)
    print

    dataout = ''
    queueentry = ''
    for item in datadict:
        colonpos = item.find('::')
        id = item[:colonpos]
        text = item[colonpos + 2:]
        if id == 'QUEUE':
            # this is the queue entry name
            dataout += "update_queueentry('" + text + "');"
            queueentry = text

    # get the now playing data for this renderer
    datastring = urllib.urlopen('http://' + ip_address +
                                ':50101/data/rendererPoll?data=' +
                                pentry).read()
    datadict = unwrap_data(datastring)

    print "rendererPoll: " + str(datadict)
    print

    pollout = formatrendererstatus(datadict)

    # create queue browse script if appropriate
    queuescript = ''
    if queueentry != '':
        qentries = queueentry.split('::')
        qid = qentries[0]
        qtype = qentries[1]
        qmenu = qentries[2]
        qtext = qentries[3]
        qoption = 'tree'
        qstring = ''
        qoperator = ''
        qparams = [
            'paramtitle=' + qtext, 'paramtype=' + qtype,
            'paramtarget=' + qtarget, 'paramid=' + qid,
            'paramoption=' + qoption, 'parammenutype=' + qmenu,
            'searchstring=' + qstring, 'searchoperator=' + qoperator,
            'browsedata=' + qdata, 'chainparams=' + qchainparams
        ]
        queuescript1 = "ajax2('getdata', " + str(qparams) + ", ':eval');"
        # adjust qdata for subsequent calls - pass 0 as sequence
        qdata = '0' + qdata[1:]
        qparams = [
            'paramtitle=' + qtext, 'paramtype=' + qtype,
            'paramtarget=' + qtarget, 'paramid=' + qid,
            'paramoption=' + qoption, 'parammenutype=' + qmenu,
            'searchstring=' + qstring, 'searchoperator=' + qoperator,
            'browsedata=' + qdata, 'chainparams=' + qchainparams
        ]
        queuescript2 = "ajax2('getdata', " + str(qparams) + ", ':eval');"
        queuescript += queuescript1 + "update_queuecall(\"" + queuescript2 + "\");"
    else:
        # need to clear queue from html
        queuescript = "jQuery('#" + qtarget + "').html('');"


#    print "setrenderer return: "
#    print "dataout: " + str(dataout)
#    print "pollout: " + str(pollout)
#    print "queuescript: " + str(queuescript)

    allout = dataout + pollout + queuescript

    #    print "allout: " + str(allout)

    return allout
Esempio n. 32
0
                        for opinions in sentence.findall('Opinions'):
                            o.write('\t\t\t\t<Opinions>\n')
                            for opinion in opinions.findall('Opinion'):
                                o.write(
                                    '\t\t\t\t\t<Opinion category="%s" polarity="%s" from="%s" to="%s"/>\n'
                                    % (fix(opinion.get('category')),
                                       opinion.get('polarity'),
                                       opinion.get('from'), opinion.get('to')))
                            o.write('\t\t\t\t</Opinions>\n')
                        o.write('\t\t\t</sentence>\n')
                o.write('\t\t</sentences>\n')
            o.write('\t</Review>\n')
        o.write('</Reviews>')


fix = lambda text: escape(text.encode('utf8')).replace('\"', '&quot;')
'''Simple fix for writing out text.'''


def load_lexicon(lex_type, b):
    '''Load each category's lexicon defined by its type.'''

    #entity lexica
    food = []
    drinks = []
    service = []
    ambience = []
    location = []
    restaurant = []

    #attribute lexica
Esempio n. 33
0
 def body(self):
     return escape(self._body)
Esempio n. 34
0
def return_document(directories, files, error, type, after_data, op, auth_add,
                    user, writer):
    writer.write("<?xml version=\"1.0\"?>\n")
    tag = "unknown"
    if op == "readdir" or op == "stat":
        tag = op
    else:
        error = "Unknown op type."
    writer.write("<myemsl-%s version=\"1.0.0\">\n" % (tag))
    if error:
        writer.write("  <error message=\"%s\"/>\n" % (saxutils.escape(error)))
    else:
        #FIXME only put this in if not already later
        #This is not right. Data seen and later != 0?
        if not after_data and type == DOCUMENT_FILTER_ARGS:
            writer.write("  <dir name=\"-later-\" type=\"%s\"/>\n" %
                         (DOCUMENT_FILTER_ARGS))
        if directories:
            for d in directories:
                tmptype = type
                if d["name"] == 'data' and type == DOCUMENT_FILTERS:
                    tmptype = DOCUMENT_DATA
                name = ""
                if op != "stat":
                    name = " name=\"%s\"" % (saxutils.escape(str(d["name"])))
                writer.write("  <dir%s type=\"%s\"/>\n" % (name, tmptype))
        if files:
            #FIXME make this configurable.
            items_per_auth_token = 100
            token_offset = 0
            auth_tokens = []
            auth_items = []
            for f in files:
                auth_str = ""
                if auth_add:
                    auth_str = " authidx=\"%s\"" % (token_offset)
                name = ""
                if op != "stat":
                    name = " name=\"%s\"" % (saxutils.escape(str(f["name"])))


#FIXME remove location once item server is fully in place.
                writer.write(
                    "  <file%s location=\"%s\" itemid=\"%s\" size=\"%s\"%s/>\n"
                    % (name, saxutils.escape(str(
                        f["location"])), f["itemid"], f["size"], auth_str))
                if auth_add:
                    auth_items.append(f["itemid"])
                    if len(auth_items) >= items_per_auth_token:
                        auth_tokens.append(
                            myemsl.token.simple_items_token_gen(
                                auth_items, person_id=user_id))
                        auth_items = []
                        token_offset += 1
            if auth_add:
                if files and len(auth_items) > 0:
                    auth_tokens.append(auth_sign(auth_items))
                writer.write("  <auth>\n")
                for t in auth_tokens:
                    writer.write("    <token>%s</token>\n" % (t))
                writer.write("  </auth>\n")
    writer.write("</myemsl-%s>\n" % (tag))
Esempio n. 35
0
    def save(self):
        """
        Saves the current BookList to the associated file.
        """
        with open(self.file, "w", encoding="utf-8") as b_f:
            b_f.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
            b_f.write('<booklist>\n')
            for name in sorted(
                    self.bookmap):  # enable a diff of archived copies
                book = self.get_book(name)
                dbname = escape(book.get_dbname())
                b_f.write('  <book name="%s" database="%s">'
                          '\n' % (escape(name), dbname))
                for item in book.get_item_list():
                    b_f.write('    <item name="%s" '
                              'trans_name="%s">\n' %
                              (item.get_name(), item.get_translated_name()))
                    options = item.option_class.handler.options_dict
                    for option_name in sorted(options.keys()):  # enable a diff
                        option_value = options[option_name]
                        if isinstance(option_value, (list, tuple)):
                            b_f.write('      <option name="%s" value="" '
                                      'length="%d">\n' %
                                      (escape(option_name),
                                       len(options[option_name])))
                            for list_index in range(len(option_value)):
                                option_type = type_name(
                                    option_value[list_index])
                                value = escape(str(option_value[list_index]))
                                value = value.replace('"', '&quot;')
                                b_f.write('        <listitem number="%d" '
                                          'type="%s" value="%s"/>\n' %
                                          (list_index, option_type, value))
                            b_f.write('      </option>\n')
                        else:
                            option_type = type_name(option_value)
                            value = escape(str(option_value))
                            value = value.replace('"', '&quot;')
                            b_f.write(
                                '      <option name="%s" type="%s" '
                                'value="%s"/>\n' %
                                (escape(option_name), option_type, value))

                    b_f.write('      <style name="%s"/>'
                              '\n' % item.get_style_name())
                    b_f.write('    </item>\n')
                if book.get_paper_name():
                    b_f.write('    <paper name="%s"/>'
                              '\n' % book.get_paper_name())
                if book.get_orientation() is not None:  # 0 is legal
                    b_f.write('    <orientation value="%s"/>'
                              '\n' % book.get_orientation())
                if book.get_paper_metric() is not None:  # 0 is legal
                    b_p_metric = book.get_paper_metric()
                    if isinstance(b_p_metric, bool):
                        b_p_metric = int(b_p_metric)
                    b_f.write('    <metric value="%s"/>' '\n' % b_p_metric)
                if book.get_custom_paper_size():
                    size = book.get_custom_paper_size()
                    b_f.write('    <size value="%f %f"/>'
                              '\n' % (size[0], size[1]))
                if book.get_margins():
                    for pos in range(len(book.get_margins())):
                        b_f.write('    <margin number="%s" '
                                  'value="%f"/>\n' %
                                  (pos, book.get_margin(pos)))
                if book.get_format_name():
                    b_f.write('    <format name="%s"/>'
                              '\n' % book.get_format_name())
                if book.get_output():
                    b_f.write('    <output name="%s"/>'
                              '\n' % escape(book.get_output()))
                b_f.write('  </book>\n')

            b_f.write('</booklist>\n')
Esempio n. 36
0
def getdata():
    # get data from the server relating to the parameter values
    print "---- getdata -----------------------------------"
    print "paramtitle: " + str(request.vars.paramtitle)
    print "paramtype: " + str(request.vars.paramtype)
    print "paramtarget: " + str(request.vars.paramtarget)
    print "paramid: " + str(request.vars.paramid)
    print "paramoption: " + str(request.vars.paramoption)
    print "parammenutype: " + str(request.vars.parammenutype)
    print "searchstring: " + str(request.vars.searchstring)
    print "searchoperator: " + str(request.vars.searchoperator)
    print "browsedata: " + str(request.vars.browsedata)
    print "chainparams: " + str(request.vars.chainparams)

    ptitle = escape(request.vars.paramtitle, url_escape_entities)
    ptype = request.vars.paramtype
    ptarget = request.vars.paramtarget
    pid = request.vars.paramid
    poption = request.vars.paramoption
    pmenu = request.vars.parammenutype
    psearch = escape(request.vars.searchstring, url_escape_entities)
    poperator = request.vars.searchoperator
    pdata = request.vars.browsedata
    pchain = request.vars.chainparams

    s_vars = True
    if 's_id' in request.vars.keys():
        ps_id = request.vars.s_id
    else:
        s_vars = False
    if 's_type' in request.vars.keys():
        ps_type = request.vars.s_type
    else:
        s_vars = False

    s_name = True
    if 'searchname' in request.vars.keys():
        searchname = request.vars.searchname
    else:
        s_name = False

    datas = pdata.split(',')
    dataseq = int(datas[0])
    datastart = int(datas[1])
    datacount = int(datas[2])

    # format request entry
    pentry = pid + '::' + ptype + '::' + pmenu + '::' + ptitle

    # append server id and type if passed
    if s_vars == True:
        pentry += '::' + ps_id + '::' + ps_type

    pentry += '::' + pdata

    # append search vars if present
    if psearch != "":
        pentry += ':::' + psearch
    if poperator != "":
        pentry += '::' + poperator
    print "entry: " + str(pentry)

    gotdata = False
    while gotdata == False:
        # get data from the server
        datastring = urllib.urlopen('http://' + ip_address +
                                    ':50101/data/getData?data=' +
                                    pentry).read()
        datadict = unwrap_data(datastring)
        # check whether we have received any data
        if datadict[0].startswith('NOTREADY'):
            time.sleep(0.3)
        else:
            gotdata = True

    # remove any message
    messagescript = ''
    message = get_message(datadict)
    if message != None:
        messagescript = 'setmessagebar("' + message + '");'

    # remove any return totals (must be present)
    messagescript = ''
    ret = get_return(datadict)
    rets = ret.split(':')
    retcount = int(rets[0])
    rettotal = int(rets[1])
    newtotal = datastart + retcount

    # special case - reset dataseq if it was called with zero
    if dataseq == 0:
        dataseq = 1

    # calc number of calls needed
    if dataseq == 1:
        recallcount = (rettotal / datacount) + 1

    # decide whether we want to separate
    chainparams = pchain.split(',')
    chainseparate = chainparams[0]
    if chainseparate == '1': separate = True
    else: separate = False
    currentletter = ''
    if separate == True:
        currentletter = chainparams[1]
        currenttarget = chainparams[2]
    if separate == True and dataseq == 1 and rettotal < 54:
        # not enough entries to separate - reset separate
        chainseparate == '0'
        separate = False

    message = "Returned " + str(newtotal) + " of " + str(rettotal)
    messagescript += 'setmessagebar("' + message + '");'

    # format the data received from the server as an unordered list
    out = ''

    firstsep = False
    if dataseq == 1:
        firstsep = True
        if separate == False:
            out += '<ul type="none" id="navigation">'

    foldercount = 0
    searchitems = []
    multipletargets = ''
    allletters = []
    lettercount = 0

    # TODO: simplify all these booleans
    prevseparate = False
    firstseparate = True

    for item in datadict:

        extraentry = None
        rementry = item
        if '::::' in rementry:
            # this entry contains extra details
            entries = rementry.split('::::')
            rementry = entries[0]
            extraentry = entries[1].split('::')
        if ':::' in rementry:
            # this entry contains search criteria
            entries = rementry.split(':::')
            rementry = entries[0]
            searchentry = entries[1].split('::')
            searchtype = searchentry[0]
            if len(searchentry) >= 2:
                searchcriteria = searchentry[1]
            else:
                searchcriteria = None
            if len(searchentry) == 3:
                searchoperators = searchentry[2]
            else:
                searchoperators = None
        # must be a base entry
        entry = rementry.split('::')

        id = entry[0]
        sid = ''
        if '|||' in id:
            entries = id.split('|||')
            id = entries[0]
            sid = entries[1]
        type = entry[1]
        menu = entry[2]
        text = entry[3]
        # TODO: fix this properly
        ctext = text.replace('&amp;colon;', ':')
        #        s_id = entry[4]
        #        s_type = entry[5]

        target = 'target' + str(id)
        atarget = '"atarget' + id + '"'
        ref = '?' + target

        if separate == True:
            newbreak = False

            # check whether we need to separate
            thisletter = ctext[:1].upper()

            if thisletter.isalpha():
                if thisletter != currentletter:
                    currentletter = thisletter
                    newbreak = True
            else:
                if currentletter == '':
                    currentletter = '#'
                    newbreak = True

#            if newbreak == False and firstseparate == True and currenttarget != '':
            if newbreak == False and firstseparate == True:

                # this is a continuation of a previous separate - need to indent
                if currenttarget == '':
                    out = '<ul>' + out
                else:
                    out = '<li><span id="' + currenttarget + '"><ul>' + out
                firstseparate = False

            if newbreak == True:

                if firstsep == False:

                    if prevseparate == True:
                        out += '</ul>'
                        out += '</li>'
                        prevseparate = False

                    # it's possible that there isn't a preceding <li> entry in this pass (will be in a previous pass)
                    # - if so we need to add one otherwise the replace will remove the </li> we are about to add
                    # TODO: only check this once
                    if out.find('<li') == -1:
                        out = '<li><ul>' + out
                        prevseparate = True

                    out += '</ul>'
                    out += '</li>'

                else:
                    firstsep = False

                allletters.append(currentletter)
                lettercount += 1
                l_target = 'target' + '__' + str(lettercount)
                l_atarget = '"atarget' + '__' + str(lettercount) + '"'
                l_menu = 'NONE'
                l_type = 'C'
                l_text = currentletter
                l_icon = '<span class="ui-icon ui-icon-minus" style="float:left"></span>'
                #                l_play = ' class="dummy"'
                l_play = ''
                out += '<li tree="open" visited="y"' + l_play + '><span type="' + l_type + '"><a id=' + l_atarget + ' menu="' + l_menu + '" type="' + l_type + '">' + l_icon + l_text + '</a></span><span id="s' + l_target + '"></span><span id="' + l_target + '">'
                out += '<ul type="none" id="navigation">'

            else:

                l_target = 'target' + '__' + str(lettercount)

        play = ''
        search = ''
        if type == 'T':
            icon = '<span style="float:left"></span><img src="/sonospy/static/note.png">'
            play = ' class="play"'
        if type == 'N':
            icon = '<span style="float:left"></span><img src="/sonospy/static/block.png">'
            play = ' class="dummy"'
        elif type == 'C':
            #            icon = '<span class="ui-icon ui-icon-plus" style="float:left"></span><img src="">' #TODO: check whether we need a null image
            icon = '<span class="ui-icon ui-icon-plus" style="float:left"></span><span class="ui-icon ui-icon-triangle-1-ne" style="float:right"></span>'
        elif type == 'A':
            icon = '<span class="ui-icon ui-icon-plus" style="float:left"></span><img src="/sonospy/static/album.png">'
        elif type == 'B':
            icon = '<span class="ui-icon ui-icon-plus" style="float:left"></span><img src="/sonospy/static/artist.png">'
        elif type == 'S':
            icon = '<span style="float:left"></span><img src="/sonospy/static/search.png">'
            search = ' searchtype="' + searchtype + '"'
            if text != 'ALL':
                searchitems.append(id + "::" + text)
            else:
                # have a multiple search option - pass the other options through
                c = 1
                st = ''
                for si in searchitems:
                    itemname = si.split("::")[1]
                    multipletargets += '<span id="' + target + '__' + str(
                        c) + '" sname="' + itemname + '"></span>'
                    st += si + '__'
                    c += 1
                search += ' searchtype2="' + st[:-2] + '"'
            if searchcriteria != None:
                search += ' searchcriteria="' + searchcriteria + '"'
            if searchoperators != None:
                search += ' searchoperators="' + searchoperators + '"'

        extras = ''
        extracreator = ''
        extraalbum = ''
        extraart = ''
        if extraentry != None:
            for ex in extraentry:
                if ex.startswith('creator='):
                    extracreator = ex[8:]
                    extras += '<span class="extra"> [' + extracreator + ']</span>'
                elif ex.startswith('album='):
                    extraalbum = ex[6:]
                    extras += '<span class="extra"> [' + extraalbum + ']</span>'
                elif ex.startswith('art='):
                    extraart = ex[4:]
            if type == 'C':  # this works at the moment because the only container with extras is album
                insertalbum(id, ctext, extracreator, extraart, item)

        out += '<li tree="closed"' + play + search + '><span type="' + type + '"><a id=' + atarget + ' menu="' + menu + '" type="' + type + '" sid="' + sid + '">' + icon + ctext + extras + '</a></span><span id="s' + target + '"></span><span id="' + target + '"></span>' + multipletargets + '</li>'

        foldercount += 1

    # check if we received all entries
    chainscript = ''
    iconscript = ''
    if newtotal < rettotal:

        # there are more entries so we want to chain another ajax call
        # update the data values
        if (rettotal - newtotal) < datacount: datacount = rettotal - newtotal
        nextdata = str(dataseq +
                       1) + ',' + str(newtotal) + ',' + str(datacount)
        # update the target
        target_base = ptarget.split('-')[0]
        nexttarget = target_base + '-' + str(dataseq + 1)

        # check if we need to close a separate
        if separate == True:
            out += '</ul>'
            out += '</span></li>'

        # create targets for remaining calls
        if dataseq == 1:
            for call in range(recallcount):
                calltarget = target_base + '-' + str(dataseq + call + 1)
                out += '<span id="' + calltarget + '"></span>'

        # set chain params
        chainparams = chainseparate + ','
        if chainseparate == '1':
            chainparams += currentletter
            # add letter continuation target
            du = l_target.split('__')
            if len(du) == 1: cont = '1'
            else: cont = str(int(du[1]) + 1)
            chainparams += ',' + du[0] + '__' + cont

        # call again - use call that doesn't use form fields in case user is making another call
        params = [
            'paramtitle=' + ptitle, 'paramtype=' + ptype,
            'paramtarget=' + nexttarget, 'paramid=' + pid,
            'paramoption=' + poption, 'parammenutype=' + pmenu,
            'searchstring=' + psearch, 'searchoperator=' + poperator,
            'browsedata=' + nextdata, 'chainparams=' + chainparams
        ]
        chainscript += "ajax2('getdata', " + str(params) + ", ':eval');"

    else:
        # there are no more browse entries
        # finalise separator

        if separate == True:
            out += '</ul>'
            out += '</li>'
        # finalise list
        out += '</ul>'
        # create a script to post process the server data icon after updating
        if poption == 'tree':
            iconscript = "jQuery('.clicker').attr('class', 'ui-icon ui-icon-minus').removeClass('clicker');"
        elif poption == 'accord':
            iconscript = "jQuery('.clicker').removeClass('ui-icon-refresh').addClass('ui-icon-triangle-1-s').removeClass('clicker');"

    # return the scripts we want to run:
    #     set the target html to be the list
    #     call the post processing script


#    print "ptarget: " + str(ptarget)
#    print "out: " + str(out)

    height = "setheight();"

    if dataseq <= 1 or separate == False:
        # prepend name separator if specified
        if s_name:
            out = searchname + out

        return "eval('" + messagescript + "');jQuery('#" + ptarget + "').html('" + out + "');" + chainscript + iconscript + height
    else:
        return "eval('" + messagescript + "');jQuery('#" + ptarget + "').replaceWith('" + out + "');" + chainscript + iconscript + height
Esempio n. 37
0
def getrootdata():
    # get the root data for the selected UPnP server
    print "---- getrootdata -----------------------------------"
    print "paramtitle: " + str(request.vars.paramtitle)
    print "paramtype: " + str(request.vars.paramtype)
    print "paramtarget: " + str(request.vars.paramtarget)

    ptitle = escape(request.vars.paramtitle, url_escape_entities)
    ptype = request.vars.paramtype
    ptarget = request.vars.paramtarget
    pentry = ptype + '::' + ptitle
    print "entry: " + str(pentry)

    # first get all the context menus for this server
    datastring = urllib.urlopen('http://' + ip_address +
                                ':50101/data/rootMenus?data=' + pentry).read()
    datadict = unwrap_data(datastring)

    # format the menus - create Javascript functions to load them
    # (we use individual functions as only the first one works if
    # we concatenate them all together (at least in Firefox))
    # Note that the first set is not a menu but the default action(s) for double click
    menucount = int(datadict[0])
    defaultscript = ''
    defaultscriptname = ''
    menuscripts = []
    menuscripttext = ''
    i = 1
    # process default option(s)
    entrycount = int(datadict[i])
    defaultscriptname = datadict[i + 1]
    i += 2
    defaultscript += 'function ' + defaultscriptname + '() {'
    for e in range(entrycount):
        menuid = datadict[i]
        menutext = datadict[i + 1]
        i += 2
        defaultscript += 'processmenu("' + menuid + '");'
    defaultscript += '};'
    menuscripts.append(defaultscript)
    # process the menus
    for m in range(1, menucount):
        entrycount = int(datadict[i])
        menuname = datadict[i + 1]
        i += 2
        menuscripttext += 'function ' + menuname + '(id) {'
        menuscripttext += '  var menu = ['
        for e in range(entrycount):
            menuid = datadict[i]
            menutext = datadict[i + 1]
            i += 2
            if menuid == 'SEP' and menutext == 'SEP':
                menuscripttext += '    $.contextMenu.separator,'
            else:
                menuscripttext += '    { "' + menutext + '": function(menuItem,menuObject) { processmenu("' + menuid + '",menuObject.target); } },'
        menuscripttext += '  ];'
        menuscripttext += '  ret=$(id).contextMenu(menu,{beforeShow:function bs(e){return beforeshowmenu(e)},afterShow:function as(m){aftershowmenu(m)}});'
        menuscripttext += '  return ret;'
        menuscripttext += '};'
        menuscripts.append(menuscripttext)
        menuscripttext = ''
    print menuscripts

    # get root entries for this server
    datastring = urllib.urlopen('http://' + ip_address +
                                ':50101/data/rootData?data=' + pentry).read()
    datadict = unwrap_data(datastring)

    # remove any message
    messagescript = ''
    message = get_message(datadict)
    if message == None or message == '':
        message = 'Ready'
    messagescript = 'setmessagebar("' + message + '");'

    # format the root entries - create an accordion
    out = ''
    itemcount = 0
    for item in datadict:
        entry = item.split('::')
        id = entry[0]
        type = entry[1]
        menu = entry[2]
        text = entry[3]
        if itemcount > 0:
            out += '</span>'
        if itemcount == 0:
            out += '<div id="accordion">'
        itemcount += 1

        if text == 'Current Queue':
            # don't display queue
            continue

        atarget = '"atarget' + id + '"'
        target = '"target' + id + '"'
        out += '<h3 accord="closed"><a id=' + atarget + ' href="#" menu="' + menu + '" type="' + type + '">' + text + '<span class="ui-icon ui-icon-triangle-1-ne"></span></a></h3>'
        out += '<span id=' + target + '>'
    if itemcount > 0:
        out += '</span></div>'

    # create a script to load the menu scripts we just created
    callscript = ''
    for menuscript in menuscripts:
        callscript += 'var headID = document.getElementsByTagName("head")[0];'
        callscript += 'var script = document.createElement("script");'
        callscript += 'script.type = "text/javascript";'
        callscript += 'script.text = ' + menuscript + ';'
        callscript += 'headID.appendChild(script);'

    # create a script to store the default option script name
    defaultscript = 'document.forms[0].elements["defaultoptionname"].value="' + defaultscriptname + '";'

    # return the scripts we want to run:
    #     set the target html to be the accordion
    #     call the accordion creation function
    #     execute the script to load the menu creation scripts
    #     execute the script to bind the menus
    return "eval('" + messagescript + "');jQuery('#" + ptarget + "').html('" + out + "');liveaccordion();eval('" + callscript + "');eval('" + defaultscript + "');"
Esempio n. 38
0
def account_listing_response(account,
                             req,
                             response_content_type,
                             broker=None,
                             limit='',
                             marker='',
                             end_marker='',
                             prefix='',
                             delimiter=''):
    if broker is None:
        broker = FakeAccountBroker()

    info = broker.get_info()
    resp_headers = {
        'X-Account-Container-Count': info['container_count'],
        'X-Account-Object-Count': info['object_count'],
        'X-Account-Bytes-Used': info['bytes_used'],
        'X-Timestamp': info['created_at'],
        'X-PUT-Timestamp': info['put_timestamp']
    }
    resp_headers.update(
        (key, value)
        for key, (value, timestamp) in broker.metadata.iteritems()
        if value != '')

    account_list = broker.list_containers_iter(limit, marker, end_marker,
                                               prefix, delimiter)
    if response_content_type == 'application/json':
        data = []
        for (name, object_count, bytes_used, is_subdir) in account_list:
            if is_subdir:
                data.append({'subdir': name})
            else:
                data.append({
                    'name': name,
                    'count': object_count,
                    'bytes': bytes_used
                })
        account_list = json.dumps(data)
    elif response_content_type.endswith('/xml'):
        output_list = [
            '<?xml version="1.0" encoding="UTF-8"?>',
            '<account name=%s>' % saxutils.quoteattr(account)
        ]
        for (name, object_count, bytes_used, is_subdir) in account_list:
            if is_subdir:
                output_list.append('<subdir name=%s />' %
                                   saxutils.quoteattr(name))
            else:
                item = '<container><name>%s</name><count>%s</count>' \
                       '<bytes>%s</bytes></container>' % \
                       (saxutils.escape(name), object_count, bytes_used)
                output_list.append(item)
        output_list.append('</account>')
        account_list = '\n'.join(output_list)
    else:
        if not account_list:
            resp = HTTPNoContent(request=req, headers=resp_headers)
            resp.content_type = response_content_type
            resp.charset = 'utf-8'
            return resp
        account_list = '\n'.join(r[0] for r in account_list) + '\n'
    ret = HTTPOk(body=account_list, request=req, headers=resp_headers)
    ret.content_type = response_content_type
    ret.charset = 'utf-8'
    return ret
Esempio n. 39
0
def xhtml_escape(value):
    """Escapes a string so it is valid within XML or XHTML.

    """
    return saxutils.escape(value, {'"': '&quot;', "'": '&apos;'})
Esempio n. 40
0
        if i[0] not in checkpnfs: continue
    if mdebug: l.write("%sLooking at %s\n" % (spaces, i[2]))
    if i[2] not in dirs:
        if debug: spaces += ' '
        mycont = search_parent(i)
        if debug: spaces = spaces[0:-1]
        if debug:
            l.write(spaces + dirs[i[2]][0] + i[1] + ' ' + str(i[3]) + '\n')
        if not mycont: continue
    if pat and pat not in dirs[i[2]][0]: continue
    if ascii: entry = '%s %s' % (i[0], dirs[i[2]][0] + '/' + i[1])
    else: entry = '<entry name="%s">' % (dirs[i[2]][0] + '/' + i[1])
    for j in xrange(3, len(i)):
        if ascii: entry += ' %s' % str(i[j])
        else:
            entry += '<%s>%s</%s>' % (xmltag[j - 3], escape(str(
                i[j])), xmltag[j - 3])
    if ascii: entry += '\n'
    else: entry += '</entry>\n'
    f.write(entry)
#  if not ascii:
#      f.write('<entry name="%s"><%s>%s</%s></entry>\n' %(dirs[i[2]][0]+'/'+i[1],xmltag,escape(str(i[3])),xmltag))
#  else:
#      f.write('%s %s %s\n' %(i[0],dirs[i[2]][0]+'/'+i[1],str(i[3])))

if not ascii:  # again for syncat xml output
    f.write(""" </entry-set>
</dump>
</cat> 
""")

#Close all
Esempio n. 41
0
def _sentence_gen(sentences):
    for sentence in enumerate(sentences):
        yield (sentence[0], escape(_force_unicode(sentence[1])))
Esempio n. 42
0
def send_payload(url, user, passwords):
    prefix = "<?xml version=\"1.0\"?><methodCall><methodName>system.multicall</methodName><params><param><value><array><data>"
    payload = ""
    suffix = "</data></array></value></param></params></methodCall>"

    for password in passwords:
        payload += "<value><struct><member><name>methodName</name><value><string>wp.getUsersBlogs</string></value></member><member><name>params</name>"
        payload += "<value><array><data><value><array><data><value><string>" + user + "</string></value><value><string>" + escape(
            password) + "</string></value>"
        payload += "</data></array></value></data></array></value></member></struct></value>"

    data = prefix + payload + suffix
    headers = {"Content-Type": "application/xml"}
    r = requests.post(url, data=data, headers=headers)
    r.encoding = 'UTF-8'
    #print(r.text)
    return r.text
Esempio n. 43
0
def build_wxsfile_file_section(root, files, NAME, VERSION, VENDOR,
                               filename_set, id_set):
    """ Builds the Component sections of the wxs file with their included files.

    Files need to be specified in 8.3 format and in the long name format, long
    filenames will be converted automatically.

    Features are specficied with the 'X_MSI_FEATURE' or 'DOC' FileTag.
    """
    root = create_default_directory_layout(root, NAME, VERSION, VENDOR,
                                           filename_set)
    components = create_feature_dict(files)
    factory = Document()

    def get_directory(node, dir):
        """ Returns the node under the given node representing the directory.

        Returns the component node if dir is None or empty.
        """
        if dir == '' or not dir:
            return node

        Directory = node
        dir_parts = dir.split(os.path.sep)

        # to make sure that our directory ids are unique, the parent folders are
        # consecutively added to upper_dir
        upper_dir = ''

        # walk down the xml tree finding parts of the directory
        dir_parts = [d for d in dir_parts if d != '']
        for d in dir_parts[:]:
            already_created = [
                c for c in Directory.childNodes if c.nodeName == 'Directory'
                and c.attributes['LongName'].value == escape(d)
            ]

            if already_created:
                Directory = already_created[0]
                dir_parts.remove(d)
                upper_dir += d
            else:
                break

        for d in dir_parts:
            nDirectory = factory.createElement('Directory')
            nDirectory.attributes['LongName'] = escape(d)
            nDirectory.attributes['Name'] = escape(
                gen_dos_short_file_name(d, filename_set))
            upper_dir += d
            nDirectory.attributes['Id'] = convert_to_id(upper_dir, id_set)

            Directory.childNodes.append(nDirectory)
            Directory = nDirectory

        return Directory

    for file in files:
        drive, path = os.path.splitdrive(file.PACKAGING_INSTALL_LOCATION)
        filename = os.path.basename(path)
        dirname = os.path.dirname(path)

        h = {
            # tagname                   : default value
            'PACKAGING_X_MSI_VITAL':
            'yes',
            'PACKAGING_X_MSI_FILEID':
            convert_to_id(filename, id_set),
            'PACKAGING_X_MSI_LONGNAME':
            filename,
            'PACKAGING_X_MSI_SHORTNAME':
            gen_dos_short_file_name(filename, filename_set),
            'PACKAGING_X_MSI_SOURCE':
            file.get_path(),
        }

        # fill in the default tags given above.
        for k, v in [(k, v) for (k, v) in h.items() if not hasattr(file, k)]:
            setattr(file, k, v)

        File = factory.createElement('File')
        File.attributes['LongName'] = escape(file.PACKAGING_X_MSI_LONGNAME)
        File.attributes['Name'] = escape(file.PACKAGING_X_MSI_SHORTNAME)
        File.attributes['Source'] = escape(file.PACKAGING_X_MSI_SOURCE)
        File.attributes['Id'] = escape(file.PACKAGING_X_MSI_FILEID)
        File.attributes['Vital'] = escape(file.PACKAGING_X_MSI_VITAL)

        # create the <Component> Tag under which this file should appear
        Component = factory.createElement('Component')
        Component.attributes['DiskId'] = '1'
        Component.attributes['Id'] = convert_to_id(filename, id_set)

        # hang the component node under the root node and the file node
        # under the component node.
        Directory = get_directory(root, dirname)
        Directory.childNodes.append(Component)
        Component.childNodes.append(File)
Esempio n. 44
0
f.write("  <!-- ..................................................... -->\n")
f.write("\n")

if langid:
    f.write(
        "  <!-- This contains the LangID and should be translated to reflect the correct LangID. -->\n"
    )
    f.write(
        "  <!-- Supported language and codepage codes can be found here: https://msdn.microsoft.com/en-us/goglobal/bb964664.aspx -->\n"
    )
    f.write("  <String Id=\"" + langid + "\">" + str(langIdAuto) +
            "</String>\n")
    f.write("\n")

for entry in po:
    if entry.comment != "":
        f.write("\n")
        f.write("  <!--" + entry.comment.replace('\n', ' -->\n  <!--') +
                " -->\n")
    if entry.msgstr != "":
        translation = escape(entry.msgstr)
    else:
        translation = escape(entry.msgid)
    translation = "&#13;&#10;".join(translation.split("\n")).replace(
        '\r', '').encode("utf-8")
    f.write("  <String Id=\"" + entry.msgctxt.encode("utf-8") + "\">" +
            translation + "</String>\n")

f.write("</WixLocalization>\n")
f.close
Esempio n. 45
0
 def get_shadow_div(basename, content):
     return (u'<div class="shadow_file"'
             'style="display:none" basename="{}">'
             '{}</div>').format(basename, escape(content))
Esempio n. 46
0
 def body(self):
     return escape(self._body).replace('"', "&quot;").replace("\r", "&#xD;")
Esempio n. 47
0
def main():

    street_view_url = None
    try:
        p = os.path.dirname(os.path.realpath(__file__))
        f = open("%s/../setup/webroot_guid.txt" % p, "r")
        street_view_url = f.readline().strip() + "/web_data/street_views/"
    except:
        logging.debug(
            "Warning: Couldn't determind streetview webserver folder")

    print "Content-type: xml\n\n"
    MaltegoXML_in = sys.stdin.read()
    if MaltegoXML_in <> '':
        m = MaltegoMsg(MaltegoXML_in)

        logging.debug(MaltegoXML_in)

        cursor = stawk_db.dbconnect()
        TRX = MaltegoTransform()

        ssid = m.Value

        try:
            cursor.execute(
                "SELECT gps_lat,gps_long,country,code,address FROM wigle WHERE overflow = 0 AND ssid=%s LIMIT 500",
                (ssid)
            )  #Can be useful to LIMIT 5, or some such. Make sure to do the same in fetchClientsFromCountry.py
            #cursor.execute("SELECT gps_lat,gps_long,country,code,address FROM wigle WHERE overflow = 0 AND ssid=%s",(ssid))
            results = cursor.fetchall()
            for row in results:
                # How to Unicode, plox?
                lat = row[0]
                long = row[1]
                #			country=row[2].decode('raw_unicode_escape').encode('ascii','xmlcharrefreplace')
                #			code=row[3].decode('raw_unicode_escape').encode('ascii','xmlcharrefreplace')
                #			address=row[4].decode('utf-8').encode('ascii','xmlcharrefreplace')
                country = row[2].encode('utf8', 'xmlcharrefreplace')
                code = row[3].encode('utf8', 'xmlcharrefreplace')
                address = row[4].encode('utf8', 'xmlcharrefreplace')

                #NewEnt=TRX.addEntity("snoopy.ssidLocation",country)
                NewEnt = TRX.addEntity("maltego.Location", country)
                NewEnt.addAdditionalFields("latitude", "latitude", "strict",
                                           lat)
                NewEnt.addAdditionalFields("longitude", "longitude", "strict",
                                           long)
                NewEnt.addAdditionalFields("country", "Country", "strict",
                                           country)
                NewEnt.addAdditionalFields("countrycode", "Country Code",
                                           "strict", code)
                #	       		NewEnt.addAdditionalFields("streetaddress", "Street Address", "strict", "<![CDATA[" + address + "]]>")
                NewEnt.addAdditionalFields("streetaddress", "Street Address",
                                           "strict", address)
                NewEnt.addAdditionalFields(
                    "googleMap", "Google map", "nostrict",
                    escape("http://maps.google.com/maps?t=h&q=%s,%s" %
                           (lat, long)))

                logging.debug(street_view_url)
                if (street_view_url != None):
                    NewEnt.addAdditionalFields(
                        "streetview", "streetview", "strict",
                        "%s/%s,%s.jpg" % (street_view_url, lat, long))
                    NewEnt.setIconURL("%s/%s,%s.jpg" %
                                      (street_view_url, lat, long))

        except Exception, e:
            logging.debug(e)

        logging.debug(TRX)
        TRX.returnOutput()
Esempio n. 48
0
rmtree(source_locale_dir)

# update install.rdf
proj_dir = pj(os.path.split(os.path.abspath(__file__))[0], '..')
chromium_manifest = pj(proj_dir, 'platform', 'chromium', 'manifest.json')

with open(chromium_manifest, encoding='utf-8') as m:
    manifest = json.load(m)

# https://developer.mozilla.org/en-US/Add-ons/AMO/Policy/Maintenance#How_do_I_submit_a_Beta_add-on.3F
# "To create a beta channel [...] '(a|alpha|b|beta|pre|rc)\d*$' "
if sys.argv[2]:
    manifest['version'] += sys.argv[2]

manifest['homepage'] = 'https://github.com/gorhill/uMatrix'
manifest['description'] = escape(descriptions['en'])
del descriptions['en']
manifest['localized'] = []

t = '    '
t3 = 3 * t

for alpha2 in descriptions:
    if alpha2 == 'en':
        continue

    manifest['localized'].append(
        '\n' + t * 2 + '<localized><r:Description>\n' + t3 + '<locale>' +
        alpha2 + '</locale>\n' + t3 + '<name>' + manifest['name'] +
        '</name>\n' + t3 + '<description>' + escape(descriptions[alpha2]) +
        '</description>\n' + t3 + '<creator>' + manifest['author'] +
Esempio n. 49
0
def attrs_s(attrs):
    """ This generate the XML attributes from an element attribute list """
    l = ['']
    for i in range(0,len(attrs), 2):
        l.append('%s="%s"' % (attrs[i], escape(attrs[i+1])))
    return ' '.join(l)
Esempio n. 50
0
    def run(self):
        shadow_files_divs = ""
        extra_attribs = ""
        argument_list = []
        force_no_buttons = False
        is_lab = False

        def get_shadow_div(basename, content):
            return (u'<div class="shadow_file"'
                    'style="display:none" basename="{}">'
                    '{}</div>').format(basename, escape(content))

        if self.arguments:
            argument_list = self.arguments[0].split(' ')

        if 'no_button' in argument_list or (
                'class' in self.options and
            ('ada-nocheck' in self.options['class']
             or 'ada-syntax-only' in self.options['class'])):
            force_no_buttons = True

        # look for lab=my_lab_name
        lab_matches = [
            LAB_REGEX.match(line) for line in argument_list
            if LAB_REGEX.match(line)
        ]
        if len(lab_matches) == 1:
            extra_attribs += ' lab="True"'
            extra_attribs += ' lab_name={}'.format(lab_matches[0].group(1))
            is_lab = True
        elif len(lab_matches) > 1:
            raise self.error("malformed lab directive")

        # Make sure code-config exists in the document
        if not codeconfig_found:
            print(self.lineno, dir(self))
            raise self.error("you need to add a :code-config: role")

        if is_lab:
            # look for lab io start block
            io_start_matches = [
                i for i, line in enumerate(self.content)
                if LAB_IO_START_REGEX.match(line)
            ]

            # look for lab io end block
            io_end_matches = [
                i for i, line in enumerate(self.content)
                if LAB_IO_END_REGEX.match(line)
            ]

            # check for correct formation of lab io block
            if len(io_start_matches) == 1 and len(
                    io_end_matches
            ) == 1 and io_start_matches[0] < io_end_matches[0]:
                io_content = self.content[io_start_matches[0] +
                                          1:io_end_matches[0]]

                # create shadow file from io blocks
                new_file = "\n".join(io_content)
                shadow_files_divs += get_shadow_div(LABIO_FILENAME, new_file)

                # remove io block lines from self.content
                # The following does not work for some odd reason so we will have to copy the list
                # del self.content[io_start_matches[0] : (io_end_matches[0] + 1)]
                chop_contents = self.content[:io_start_matches[
                    0]] + self.content[io_end_matches[0] + 1:]
            else:
                raise self.error(
                    "malformed lab io block: io_start={} io_end={}".format(
                        io_start_matches, io_end_matches))
        else:
            chop_contents = self.content

        # chop contents into files
        try:
            # chop source files
            if 'manual_chop' in argument_list:
                files = c_chop(chop_contents)
            elif 'c' in argument_list:
                files = c_chop(chop_contents)
            else:
                files = real_gnatchop(chop_contents)
        except subprocess.CalledProcessError:
            raise self.error("could not gnatchop example")

        if config.accumulate_code:
            # We are accumulating code: store the new code in the
            # accumulated_files
            global accumulated_files
            for f in files:
                accumulated_files[f[0]] = f[1]

        try:
            if config.accumulate_code:
                editor_files = set([f[0] for f in files])
                for k, v in accumulated_files.items():
                    if k not in editor_files:
                        shadow_files_divs += get_shadow_div(k, v)

            divs = "\n".join([
                u'<div class="file" basename="{}">{}</div>'.format(
                    f[0], escape(f[1])) for f in files
            ])

            nodes_latex = []

            # Attemping to detect HTML or Latex output by checking for 'html' in tags
            if 'html' not in self.state.state_machine.document.settings.env.app.tags.tags:
                for f in files:
                    # Based on sphinx/directives/code.py

                    container_node = nodes.container(
                        '',
                        literal_block=True,
                        classes=['literal-block-wrapper'])

                    literal = nodes.literal_block('', f[1], format='latex')
                    literal['language'] = self.arguments[0].split(' ')[0]
                    literal['linenos'] = 'linenos' in self.options or \
                        'lineno-start' in self.options
                    literal['source'] = f[0]

                    caption = nodes.caption('', f[0])
                    caption.source = literal.source
                    caption.line = literal.line

                    container_node += caption
                    container_node += literal

                    nodes_latex.append(container_node)

        except Exception:
            # If we have an exception here, it's probably a codec error
            print(files)
            raise

        if not force_no_buttons:
            for x in (config.buttons | set(
                    filter(lambda y: y.endswith('_button'), argument_list))):
                extra_attribs += ' {}="True"'.format(x)

        return [
            nodes.raw('',
                      template.format(server_url=WIDGETS_SERVER_URL,
                                      files_divs=divs,
                                      shadow_files_divs=shadow_files_divs,
                                      extra_attribs=extra_attribs),
                      format='html')
        ] + nodes_latex
Esempio n. 51
0
  sys.exit(1)

archive.extractall()
archive.close()

if ext == "whl" or ext == "egg":
  src_dir = tmp_dir + "/" + mod
else:
  src_dir = tmp_dir + "/%s-%s/%s" % (mod, ver, mod)



addon = ADDON_XML % {
  'modname': mod,
  'version': ver,
  'modauthor': escape(metadata['info']['author']),
  'xbmc_python_ver': XBMC_PYTHON_VER,
  'summary': escape(metadata['info']['summary']),
  'description': escape(metadata['info']['description']),
  'source_url': escape(metadata['info']['package_url']),
  'author_email': escape(metadata['info']['author_email']),
  'website': escape(metadata['info']['package_url'])
}

os.chdir(BASE_PATH)

plugin_dir = 'script.module.python-%s' % mod

if os.path.exists(plugin_dir):
  shutil.rmtree(plugin_dir)
Esempio n. 52
0
def xml_write_simple_tag(f, name, val, indent=1):
    f.write('{}<{}>{}</{}>\n'.format(' ' * indent, name, escape(str(val)),
                                     name))
Esempio n. 53
0
 def __init__(self, text, **kwargs):
     super().__init__(**kwargs)
     self.escapedText = xml.escape(text)
Esempio n. 54
0
 def literal_element_char(self, data):
     self.current.object += escape(data)
Esempio n. 55
0
  def authz(self):
    authz_request = cherrypy.request.body.read()
    xmldoc = xml.dom.minidom.parseString(authz_request)

    if self.debug_flag:
      log('-----------  AUTHZ BEGIN  -----------')
      log('AUTHZ Request: %s' % xmldoc.toprettyxml())

    now = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
    # The request should look something like
    #    request = ("<soapenv:Envelope xmlns:soapenv=\
    #        "http://schemas.xmlsoap.org/soap/envelope/\"
    #               "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"
    #               "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
    #               "<soapenv:Body>"
    #               "<samlp:AuthzDecisionQuery ID=
    #                    \"dbppegngllhegcobmfponljblmfhjjiglbkbmmco\"
    #               "IssueInstant=\"2008-07-09T15:22:55Z\""
    #               "Resource=\"secure.yourdomain.com/protected/page2.html\"
    #                        Version=\"2.0\"
    #               "xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\""
    #               "xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\">"
    #               "<saml:Issuer>google.com</saml:Issuer>"
    #               "<saml:Subject>"
    #               "<saml:NameID>user1</saml:NameID>"
    #               "</saml:Subject>"
    #               "<saml:Action Namespace=\"urn:oasis:names:tc:SAML:1.0:
    #                        action:ghpp\">GET</saml:Action>"
    #               "</samlp:AuthzDecisionQuery>"
    #               "<samlp:AuthzDecisionQuery ID=
    #                    \"eeppegngllhegcobmfabcnljblmfhrrniglbkbeed\"
    #               "IssueInstant=\"2008-07-09T15:22:55Z\""
    #               "Resource=\"secure.yourdomain.com/protected/page3.html\"
    #                        Version=\"2.0\"
    #               "xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\""
    #               "xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\">"
    #               "<saml:Issuer>google.com</saml:Issuer>"
    #               "<saml:Subject>"
    #               "<saml:NameID>user1</saml:NameID>"
    #               "</saml:Subject>"
    #               "<saml:Action Namespace=\"urn:oasis:names:tc:SAML:1.0:
    #                        action:ghpp\">GET</saml:Action>"
    #               "</samlp:AuthzDecisionQuery>"
    #               "</soapenv:Body>"
    #               "</soapenv:Envelope>")

    saml_id = None
    resource = None
    username = None

    # parse out the SAML AuthzRequest
    # If we don't know *for sure* if a user is allowed or not, send back an
    # indeterminate.  if the URL does *not* exist in the built in self.authz_db,
    # then we don't know if the user is allowed
    # or not for sure, then send back an Indeterminate.

    # GSA 6.0+ can request batch authorization where there can be multiple
    # samlp:AuthzDecisionQuery  in one request for several URLs
    # which means we have to responde back in one response for each request.

    # If we're using the internal authz system, parse out the inbound
    # request for the URI and use that to check against the local authz db

    (spprefix, sprefix, samlp) = self.get_saml_namespace(xmldoc, 'AuthzDecisionQuery')
    log('using prefix: %s and %s' % (spprefix, sprefix))

    response = ('<soapenv:Envelope '
                'xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">'
                '<soapenv:Body>')

    for node in samlp:
      if (node.nodeName == "%s:AuthzDecisionQuery" % spprefix):
        saml_id = node.attributes["ID"].value
        resource = node.attributes["Resource"].value
        samlName = node.getElementsByTagName("%s:NameID" % sprefix)
        for n_issuer in samlName:
          cnode= n_issuer.childNodes[0]
          if cnode.nodeType == node.TEXT_NODE:
            username = cnode.nodeValue
        # the SAML response and assertion are unique random ID numbers
        # back in the sring with the decision.
        rand_id_saml_resp = self.getrandom_samlID()
        rand_id_saml_assert = self.getrandom_samlID()

        decision = self.authz_backend.authorize(username, resource)

        if self.debug_flag:
          log ('authz ID: %s' %(saml_id))
          log ('authz Resource: %s' %(resource))
          log ('authz samlName %s' %(username))
          log ('authz decision for resource %s [%s]' % (resource, decision))

        response = response + ('<samlp:Response '
             'xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" '
             'xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" '
             'ID="%s" Version="2.0" IssueInstant="%s">'
             '<samlp:Status><samlp:StatusCode '
             'Value="urn:oasis:names:tc:SAML:2.0:status:Success"/>'
             '</samlp:Status><saml:Assertion Version="2.0" '
             'ID="%s" IssueInstant="%s">'
             '<saml:Issuer>%s</saml:Issuer><saml:Subject>'
             '<saml:NameID>%s</saml:NameID></saml:Subject>'
             '<saml:AuthzDecisionStatement Resource="%s" '
             'Decision="%s"><saml:Action '
             'Namespace="urn:oasis:names:tc:SAML:1.0:action:ghpp">'
             'GET</saml:Action></saml:AuthzDecisionStatement>'
             '</saml:Assertion></samlp:Response>') % (rand_id_saml_resp,now,
                                                      rand_id_saml_assert,
                                                      now, self.saml_issuer, username,
                                                      escape(resource), decision)

    response += '</soapenv:Body></soapenv:Envelope>'

    if self.debug_flag:
      xmldoc = xml.dom.minidom.parseString(response)
      log('authz response %s' %(xmldoc.toprettyxml()))
      log('-----------  AUTHZ END  -----------')

    return response
Esempio n. 56
0
 def task_title_column(self, node):
     return saxutils.escape(node.get_title())
Esempio n. 57
0
def _createReport(ttrs, timetaken, log, server, hostname):
    # import additional libraries here to speed up normal tests
    import httplib
    import urllib
    from urlparse import urlparse
    from xml.sax.saxutils import escape
    import codecs
    from xml.etree import ElementTree as etree
    timestamp = int(time.time())
    result = {'timestamp': timestamp}
    result['timetaken'] = timetaken
    if log:
        try:
            data = codecs.open(log, 'r', encoding='UTF-8').read()
            result['install_log'] = escape(data)
        except:
            print("Cannot open log file %s" % log)
    # get ObsPy module versions
    result['obspy'] = {}
    tests = 0
    errors = 0
    failures = 0
    skipped = 0
    try:
        installed = get_git_version()
    except:
        installed = ''
    result['obspy']['installed'] = installed
    for module in sorted(ALL_MODULES):
        result['obspy'][module] = {}
        if module not in ttrs:
            continue
        result['obspy'][module]['installed'] = installed
        # test results
        ttr = ttrs[module]
        result['obspy'][module]['timetaken'] = ttr.__dict__['timetaken']
        result['obspy'][module]['tested'] = True
        result['obspy'][module]['tests'] = ttr.testsRun
        # skipped is not supported for Python < 2.7
        try:
            skipped += len(ttr.skipped)
            result['obspy'][module]['skipped'] = len(ttr.skipped)
        except AttributeError:
            skipped = ''
            result['obspy'][module]['skipped'] = ''
        tests += ttr.testsRun
        # depending on module type either use failure (network related modules)
        # or errors (all others)
        result['obspy'][module]['errors'] = {}
        result['obspy'][module]['failures'] = {}
        if module in NETWORK_MODULES:
            for _, text in ttr.errors:
                result['obspy'][module]['failures']['f%s' % (failures)] = text
                failures += 1
            for _, text in ttr.failures:
                result['obspy'][module]['failures']['f%s' % (failures)] = text
                failures += 1
        else:
            for _, text in ttr.errors:
                result['obspy'][module]['errors']['f%s' % (errors)] = text
                errors += 1
            for _, text in ttr.failures:
                result['obspy'][module]['errors']['f%s' % (errors)] = text
                errors += 1
    # get dependencies
    result['dependencies'] = {}
    for module in DEPENDENCIES:
        temp = module.split('.')
        try:
            mod = __import__(module, fromlist=temp[1:])
            if module == '_omnipy':
                result['dependencies'][module] = mod.coreVersion()
            else:
                result['dependencies'][module] = mod.__version__
        except:
            result['dependencies'][module] = ''
    # get system / environment settings
    result['platform'] = {}
    for func in [
            'system', 'release', 'version', 'machine', 'processor',
            'python_version', 'python_implementation', 'python_compiler',
            'architecture'
    ]:
        try:
            temp = getattr(platform, func)()
            if isinstance(temp, tuple):
                temp = temp[0]
            result['platform'][func] = temp
        except:
            result['platform'][func] = ''
    # set node name to hostname if set
    result['platform']['node'] = hostname
    # post only the first part of the node name (only applies to MacOS X)
    try:
        result['platform']['node'] = result['platform']['node'].split('.')[0]
    except:
        pass
    # test results
    result['tests'] = tests
    result['errors'] = errors
    result['failures'] = failures
    result['skipped'] = skipped

    # generate XML document
    def _dict2xml(doc, result):
        for key, value in result.iteritems():
            key = key.split('(')[0].strip()
            if isinstance(value, dict):
                child = etree.SubElement(doc, key)
                _dict2xml(child, value)
            elif value is not None:
                if isinstance(value, unicode):
                    etree.SubElement(doc, key).text = value
                elif isinstance(value, str):
                    etree.SubElement(doc, key).text = unicode(value, 'utf-8')
                else:
                    etree.SubElement(doc, key).text = str(value)
            else:
                etree.SubElement(doc, key)

    root = etree.Element("report")
    _dict2xml(root, result)
    xml_doc = etree.tostring(root)
    print
    # send result to report server
    params = urllib.urlencode({
        'timestamp':
        timestamp,
        'system':
        result['platform']['system'],
        'python_version':
        result['platform']['python_version'],
        'architecture':
        result['platform']['architecture'],
        'tests':
        tests,
        'failures':
        failures,
        'errors':
        errors,
        'modules':
        len(ttrs),
        'xml':
        xml_doc
    })
    headers = {
        "Content-type": "application/x-www-form-urlencoded",
        "Accept": "text/plain"
    }
    conn = httplib.HTTPConnection(server)
    conn.request("POST", "/", params, headers)
    # get the response
    response = conn.getresponse()
    # handle redirect
    if response.status == 301:
        o = urlparse(response.msg['location'])
        conn = httplib.HTTPConnection(o.netloc)
        conn.request("POST", o.path, params, headers)
        # get the response
        response = conn.getresponse()
    # handle errors
    if response.status == 200:
        print("Test report has been sent to %s. Thank you!" % (server))
    else:
        print("Error: Could not sent a test report to %s." % (server))
        print(response.reason)
Esempio n. 58
0
    def characters(self, ch):
        if self._in_entity: return
	elif not self._in_cdata: ch = escape(ch)
        self._out.write('%s%s%s' % (
            self._o_d[_TEXT][0], ch.encode(self._cod), self._o_d[_TEXT][1]))
Esempio n. 59
0
def upload_ea(
    jamf_url, enc_creds, ea_name, script_path, verbosity, cli_custom_keys, obj_id=None,
):
    """Update extension attribute metadata."""

    # import script from file and replace any keys in the script
    with open(script_path, "r") as file:
        script_contents = file.read()

    # substitute user-assignable keys
    # pylint is incorrectly stating that 'verbosity' has no value. So...
    # pylint: disable=no-value-for-parameter
    script_contents = actions.substitute_assignable_keys(
        script_contents, cli_custom_keys, verbosity
    )

    # XML-escape the script
    script_contents_escaped = escape(script_contents)

    # build the object
    ea_data = (
        "<computer_extension_attribute>"
        + "<name>{}</name>".format(ea_name)
        + "<enabled>true</enabled>"
        + "<description/>"
        + "<data_type>String</data_type>"
        + "<input_type>"
        + "  <type>script</type>"
        + "  <platform>Mac</platform>"
        + "  <script>{}</script>".format(script_contents_escaped)
        + "</input_type>"
        + "<inventory_display>Extension Attributes</inventory_display>"
        + "<recon_display>Extension Attributes</recon_display>"
        + "</computer_extension_attribute>"
    )

    # if we find an object ID we put, if not, we post
    if obj_id:
        url = "{}/JSSResource/computerextensionattributes/id/{}".format(
            jamf_url, obj_id
        )
    else:
        url = "{}/JSSResource/computerextensionattributes/id/0".format(jamf_url)

    if verbosity > 2:
        print("Extension Attribute data:")
        print(ea_data)

    print("Uploading Extension Attribute..")

    #  write the template to temp file
    template_xml = curl.write_temp_file(ea_data)

    count = 0
    while True:
        count += 1
        if verbosity > 1:
            print("Extension Attribute upload attempt {}".format(count))
        method = "PUT" if obj_id else "POST"
        r = curl.request(method, url, enc_creds, verbosity, template_xml)
        # check HTTP response
        if curl.status_check(r, "Extension Attribute", ea_name) == "break":
            break
        if count > 5:
            print("ERROR: Extension Attribute upload did not succeed after 5 attempts")
            print("\nHTTP POST Response Code: {}".format(r.status_code))
            break
        sleep(10)

    if verbosity > 1:
        api_get.get_headers(r)

    # clean up temp files
    if os.path.exists(template_xml):
        os.remove(template_xml)
 def html_escape(self, text):
     return escape(text)