Python utils.fix_widget_code函数代码示例

 def test_basic_xhtml(self):
     initial_code = self.read_file('test-data/xhtml2-initial.html')
     final_code = fix_widget_code(initial_code, 'http://server.com/widget', 'application/xhtml+xml', None, False) + '\n'
     expected_code = self.read_file('test-data/xhtml2-expected.html')
     self.assertEqual(final_code, expected_code)

 def test_basic_xhtml_iso8859_15(self):
     initial_code = self.read_file('test-data/xhtml2-iso8859-15-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub('><', fix_widget_code(initial_code, 'http://server.com/widget', 'application/xhtml+xml', None, 'iso-8859-15', False)) + '\n'
     expected_code = self.read_file('test-data/xhtml2-iso8859-15-expected.html')
     self.assertEqual(final_code, expected_code)

    def test_unhandled_content_type(self):

        initial_code = b'plain text'
        final_code = fix_widget_code(initial_code, 'http://server.com/widget', 'text/plain', None, 'utf-8', False, {}, False, 'classic')
        self.assertEqual(final_code, initial_code)

    def test_html_unclosed_tags(self):

        initial_code = self.read_file('test-data/html-unclosed-tags-initial.html')
        final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'http://server.com/widget', 'text/html', None, 'utf-8', False, {}, False, 'classic')) + b'\n'
        expected_code = self.read_file('test-data/html-unclosed-tags-expected.html')
        self.assertEqual(final_code, expected_code)

 def test_html_with_more_than_one_base_element(self):
     initial_code = self.read_file('test-data/xhtml4-extra-base-elements-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'text/html', None, 'utf-8', False, {}, 'classic', 'wirecloud_defaulttheme')) + b'\n'
     expected_code = self.read_file('test-data/xhtml4-expected.html')
     self.assertEqual(final_code, expected_code)

 def test_basic_xhtml(self):
     initial_code = self.read_file('test-data/xhtml2-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'http://server.com/widget', 'application/xhtml+xml', None, 'utf-8', False, {}, False, 'classic')) + b'\n'
     expected_code = self.read_file('test-data/xhtml2-expected.html')
     self.assertEqual(final_code, expected_code)

                return build_error_response(request, 502, msg)
        else:
            # Code contents comes as unicode from persistence, we need bytes
            code = code.encode(charset)

        if xhtml.cacheable and (xhtml.code == '' or xhtml.code_timestamp is None):
            xhtml.code = code.decode(charset)
            xhtml.code_timestamp = time.time() * 1000
            xhtml.save()
        elif not xhtml.cacheable and xhtml.code != '':
            xhtml.code = ''
            xhtml.code_timestamp = None
            xhtml.save()

        try:
            code = fix_widget_code(code, base_url, content_type, request, charset, xhtml.use_platform_style, force_base=force_base)
        except UnicodeEncodeError:
            msg = _('Widget code was not encoded using the specified charset (%(charset)s according to the widget descriptor file).')
            return build_error_response(request, 502, msg % {'charset': charset})

        if xhtml.cacheable:
            cache_timeout = 31536000  # 1 year
            cache_entry = {
                'code': code,
                'mimetype': '%s; charset=%s' % (content_type, charset),
                'timestamp': xhtml.code_timestamp,
                'timeout': cache_timeout,
            }
            cache.set(cache_key, cache_entry, cache_timeout)
        else:
            cache_timeout = 0

 def test_xhtml_without_head_element(self):
     initial_code = self.read_file('test-data/xhtml3-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub('><', fix_widget_code(initial_code, 'http://server.com/widget', 'application/xhtml+xml', None, False)) + '\n'
     expected_code = self.read_file('test-data/xhtml3-expected.html')
     self.assertEqual(final_code, expected_code)

    def test_unhandled_content_type(self):

        initial_code = b'plain text'
        final_code = fix_widget_code(initial_code, 'text/plain', None, 'utf-8', False, {}, 'classic', 'wirecloud.defaulttheme')
        self.assertEqual(final_code, initial_code)

 def test_basic_html(self):
     initial_code = self.read_file('test-data/xhtml1-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'text/html', None, 'utf-8', False, {}, 'classic', 'wirecloud_defaulttheme')) + b'\n'
     expected_code = self.read_file('test-data/xhtml1-expected.html')
     self.assertEqual(final_code, expected_code)

 def test_xhtml_without_head_element(self):
     initial_code = self.read_file('test-data/xhtml3-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'application/xhtml+xml', None, 'utf-8', False, {}, 'classic', 'wirecloud_defaulttheme')) + b'\n'
     expected_code = self.read_file('test-data/xhtml3-expected.html')
     self.assertEqual(final_code, expected_code)

 def test_basic_xhtml_iso8859_15(self):
     initial_code = self.read_file('test-data/xhtml2-iso8859-15-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'application/xhtml+xml', None, 'iso-8859-15', False, {}, 'classic', 'wirecloud_defaulttheme')) + b'\n'
     expected_code = self.read_file('test-data/xhtml2-iso8859-15-expected.html')
     self.assertEqual(final_code, expected_code)

 def test_basic_xhtml_compressed(self):
     initial_code = self.read_file('test-data/xhtml2-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'application/xhtml+xml', None, 'utf-8', False, {}, 'classic', 'wirecloud_defaulttheme')) + b'\n'
     final_code = self.COMPRESS_HASH_RE.sub(b'/widgetapi.js', final_code)
     expected_code = self.read_file('test-data/xhtml2-compressed-expected.html')
     self.assertEqual(final_code, expected_code)

def process_widget_code(request, resource):

    mode = request.GET.get('mode', 'classic')
    theme = request.GET.get('theme', get_active_theme_name())
    widget_info = json.loads(resource.json_description)

    # check if the xhtml code has been cached
    if widget_info['contents']['cacheable'] is True:

        cache_key = resource.widget.xhtml.get_cache_key(get_current_domain(request), mode, theme)
        cache_entry = cache.get(cache_key)
        if cache_entry is not None:
            response = HttpResponse(cache_entry['code'], content_type=cache_entry['content_type'])
            patch_cache_headers(response, cache_entry['timestamp'], cache_entry['timeout'])
            return response

    # process xhtml
    xhtml = resource.widget.xhtml
    content_type = widget_info['contents'].get('contenttype', 'text/html')
    charset = widget_info['contents'].get('charset', 'utf-8')

    code = xhtml.code
    if not xhtml.cacheable or code == '':
        try:
            code = download_local_file(os.path.join(showcase_utils.wgt_deployer.root_dir, url2pathname(xhtml.url)))

        except Exception as e:
            if isinstance(e, IOError) and e.errno == errno.ENOENT:
                return build_response(request, 404, {'error_msg': _("Widget code not found"), 'details': "%s" % e}, WIDGET_ERROR_FORMATTERS)
            else:
                return build_response(request, 500, {'error_msg': _("Error reading widget code"), 'details': "%s" % e}, WIDGET_ERROR_FORMATTERS)
    else:
        # Code contents comes as unicode from persistence, we need bytes
        code = code.encode(charset)

    if xhtml.cacheable and (xhtml.code == '' or xhtml.code_timestamp is None):
        try:
            xhtml.code = code.decode(charset)
        except UnicodeDecodeError:
            msg = _('Widget code was not encoded using the specified charset (%(charset)s as stated in the widget description file).') % {'charset': charset}
            return build_response(request, 502, {'error_msg': msg}, WIDGET_ERROR_FORMATTERS)

        xhtml.code_timestamp = time.time() * 1000
        xhtml.save()

    try:
        code = fix_widget_code(code, content_type, request, charset, xhtml.use_platform_style, process_requirements(widget_info['requirements']), mode, theme)
    except UnicodeDecodeError:
        msg = _('Widget code was not encoded using the specified charset (%(charset)s as stated in the widget description file).') % {'charset': charset}
        return build_response(request, 502, {'error_msg': msg}, WIDGET_ERROR_FORMATTERS)
    except Exception as e:
        msg = _('Error processing widget code')
        return build_response(request, 502, {'error_msg': msg, 'details':"%s" % e}, WIDGET_ERROR_FORMATTERS)

    if xhtml.cacheable:
        cache_timeout = 31536000  # 1 year
        cache_entry = {
            'code': code,
            'content_type': '%s; charset=%s' % (content_type, charset),
            'timestamp': xhtml.code_timestamp,
            'timeout': cache_timeout,
        }
        cache.set(cache_key, cache_entry, cache_timeout)
    else:
        cache_timeout = 0

    response = HttpResponse(code, content_type='%s; charset=%s' % (content_type, charset))
    patch_cache_headers(response, xhtml.code_timestamp, cache_timeout)
    return response

 def test_basic_html_iso8859_15(self):
     initial_code = self.read_file('test-data/xhtml1-iso8859-15-initial.html')
     final_code = self.XML_NORMALIZATION_RE.sub(b'><', fix_widget_code(initial_code, 'http://server.com/widget', 'text/html', None, 'iso-8859-15', False, {}, False, 'classic')) + b'\n'
     expected_code = self.read_file('test-data/xhtml1-iso8859-15-expected.html')
     self.assertEqual(final_code, expected_code)