def test_mimeparser_parse_mime_type_split_type(self):
self.assertEqual(
parse_mime_type('application/xhtml;q=0.5', split_type=True),
('application', 'xhtml', {
'q': '0.5'
}))
def parse_usdl_from_url(url):
cache_key = '_usdl_info/' + url
usdl_info = cache.get(cache_key)
if usdl_info is not None:
if isinstance(usdl_info, Exception):
raise usdl_info
else:
return usdl_info
headers = {"Accept": "text/plain; application/rdf+xml; text/turtle; text/n3"}
try:
response = requests.get(url, headers=headers)
if response.status_code != 200:
raise HTTPError(response.url, response.status_code, response.reason, None, None)
content_type = parse_mime_type(response.headers.get('content-type'))[0]
parser = USDLParser(response.content, content_type)
usdl_info = parser.parse()
except (requests.ConnectionError, URLError, USDLParseException) as e:
cache.set(cache_key, e, 2 * 60 * 60)
raise
cache.set(cache_key, usdl_info)
return usdl_info
def parse_usdl_from_url(url):
cache_key = '_usdl_info/' + url
usdl_info = cache.get(cache_key)
if usdl_info is not None:
if isinstance(usdl_info, Exception):
raise usdl_info
else:
return usdl_info
headers = {
"Accept": "text/plain; application/rdf+xml; text/turtle; text/n3"
}
try:
response = requests.get(url, headers=headers)
if response.status_code != 200:
raise HTTPError(response.url, response.status_code,
response.reason, None, None)
content_type = parse_mime_type(response.headers.get('content-type'))[0]
parser = USDLParser(response.content, content_type)
usdl_info = parser.parse()
except (requests.ConnectionError, URLError, USDLParseException) as e:
cache.set(cache_key, e, 2 * 60 * 60)
raise
cache.set(cache_key, usdl_info)
return usdl_info
def get_content_type(request):
content_type_header = request.META.get('CONTENT_TYPE')
if content_type_header is not None:
try:
return mimeparser.parse_mime_type(content_type_header)
except mimeparser.InvalidMimeType:
pass
return '', {}
def get_content_type(request):
content_type_header = request.META.get('CONTENT_TYPE')
if content_type_header is not None:
try:
return mimeparser.parse_mime_type(content_type_header)
except mimeparser.InvalidMimeType:
pass
return '', {}
def test_mimeparser_parse_mime_type_split_type(self):
self.assertEqual(parse_mime_type('application/xhtml;q=0.5', split_type=True), ('application', 'xhtml', {'q': '0.5'}))
def test_mimeparser_parse_mime_type_should_accept_single_wildcard(self):
self.assertEqual(parse_mime_type('*;q=0.5'), ('*/*', {'q': '0.5'}))
def test_mimeparser_parse_mime_type(self):
self.assertEqual(parse_mime_type('application/xhtml;q=0.5'), ('application/xhtml', {'q': '0.5'}))
def _parse_widget_info(self):
# Preference info
self._info['preferences'] = []
# Platform preferences must be sorted
sorted_preferences = sorted(self._graph.objects(self._rootURI, WIRE['hasPlatformPreference']), key=lambda pref: possible_int(self._get_field(WIRE, 'index', pref, required=False)))
for preference in sorted_preferences:
var_name = self._get_field(DCTERMS, 'title', preference, required=True)
preference_info = {
'name': var_name,
'type': self._get_field(WIRE, 'type', preference, required=False),
'label': self._get_translation_field(RDFS, 'label', preference, var_name + '_label', required=False, type='vdef', variable=var_name, field='label'),
'description': self._get_translation_field(DCTERMS, 'description', preference, var_name + '_description', required=False, type='vdef', variable=var_name, field='description'),
'readonly': self._get_field(WIRE, 'readonly', preference, required=False).lower() == 'true',
'default': self._get_field(WIRE, 'default', preference, required=False),
'value': self._get_field(WIRE, 'value', preference, required=False, default=None),
'secure': self._get_field(WIRE, 'secure', preference, required=False).lower() == 'true',
}
if preference_info['type'] == 'list':
preference_info['options'] = []
sorted_options = sorted(self._graph.objects(preference, WIRE['hasOption']), key=lambda option: possible_int(self._get_field(WIRE, 'index', option, required=False)))
for option_index, option in enumerate(sorted_options):
preference_info['options'].append({
'label': self._get_translation_field(DCTERMS, 'title', option, var_name + '_option' + str(option_index) + '_label', required=False, type='upo', variable=preference_info['name'], option=option_index),
'value': self._get_field(WIRE, 'value', option, required=False),
})
self._info['preferences'].append(preference_info)
# State properties info
self._info['properties'] = []
sorted_properties = sorted(self._graph.objects(self._rootURI, WIRE['hasPlatformStateProperty']), key=lambda prop: possible_int(self._get_field(WIRE, 'index', prop, required=False)))
for prop in sorted_properties:
var_name = self._get_field(DCTERMS, 'title', prop, required=True)
self._info['properties'].append({
'name': var_name,
'type': self._get_field(WIRE, 'type', prop, required=False),
'label': self._get_translation_field(RDFS, 'label', prop, var_name + '_label', required=False, type='vdef', variable=var_name, field='label'),
'description': self._get_translation_field(DCTERMS, 'description', prop, var_name + '_description', required=False, type='vdef', variable=var_name, field='description'),
'default': self._get_field(WIRE, 'default', prop, required=False),
'secure': self._get_field(WIRE, 'secure', prop, required=False).lower() == 'true',
})
self._parse_wiring_info()
if self._info['type'] == 'widget':
# It contains the widget code
self._info['altcontents'] = []
sorted_contents = sorted(self._graph.objects(self._rootURI, USDL['utilizedResource']), key=lambda contents: possible_int(self._get_field(WIRE, 'index', contents, required=False)))
for contents_node in sorted_contents:
contents_info = {
'src': text_type(contents_node),
}
contents_info['scope'] = self._get_field(WIRE, 'contentsScope', contents_node, required=False)
contents_info['contenttype'] = 'text/html'
contents_info['charset'] = 'utf-8'
contents_format = self._get_field(DCTERMS, 'format', contents_node, required=False)
if contents_format.strip() != '':
try:
contenttype, parameters = parse_mime_type(contents_format)
except:
raise TemplateParseException('Invalid code content type: %s' % contents_format)
contents_info['contenttype'] = contenttype
if 'charset' in parameters:
contents_info['charset'] = parameters['charset'].lower()
del parameters['charset']
if len(parameters) > 0:
raise TemplateParseException('Invalid code content type: %s' % contents_format)
if contents_info['scope'] == '':
del contents_info['scope']
contents_info['useplatformstyle'] = self._get_field(WIRE, 'usePlatformStyle', contents_node, required=False).lower() == 'true'
contents_info['cacheable'] = self._get_field(WIRE, 'codeCacheable', contents_node, required=False, default='true').lower() == 'true'
self._info['contents'] = contents_info
else:
self._info['altcontents'].append(contents_info)
rendering_element = self._get_field(WIRE, 'hasPlatformRendering', self._rootURI, id_=True, required=False)
self._info['widget_width'] = self._get_field(WIRE, 'renderingWidth', rendering_element, required=False)
self._info['widget_height'] = self._get_field(WIRE, 'renderingHeight', rendering_element, required=False)
elif self._info['type'] == 'operator':
# The tamplate has 1-n javascript elements
# Javascript files must be sorted
sorted_js_files = sorted(self._graph.objects(self._rootURI, USDL['utilizedResource']), key=lambda js_file: possible_int(self._get_field(WIRE, 'index', js_file, required=True)))
self._info['js_files'] = []
for js_element in sorted_js_files:
self._info['js_files'].append(text_type(js_element))
if not len(self._info['js_files']) > 0:
raise TemplateParseException(_('Missing required field: Javascript files'))
def test_mimeparser_parse_mime_type_should_accept_single_wildcard(self):
self.assertEqual(parse_mime_type('*;q=0.5'), ('*/*', {'q': '0.5'}))
def test_mimeparser_parse_mime_type(self):
self.assertEqual(parse_mime_type('application/xhtml;q=0.5'),
('application/xhtml', {
'q': '0.5'
}))
def get_content_type(request):
content_type_header = request.META.get('CONTENT_TYPE')
if content_type_header is None:
return '', {}
else:
return mimeparser.parse_mime_type(content_type_header)
