def platform_css(context, view):
theme = context.get('THEME', get_active_theme_name())
prefix = 'theme/%s/' % theme
files = [{'path': prefix + filename, 'type': 'text/css' if filename.endswith('.css') else 'text/x-scss'} for filename in get_platform_css(view)]
return {'files': files}
def render_wirecloud(request, view_type=None):
if view_type is None:
if 'mode' in request.GET:
view_type = request.GET['mode']
else:
view_type = get_default_view(request)
theme = request.GET.get('theme', get_active_theme_name())
if theme not in get_available_themes():
return remove_query_parameter(request, 'theme')
context = {
'THEME': theme,
'VIEW_MODE': view_type,
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
try:
return render(request,
theme + ':wirecloud/views/%s.html' % view_type,
context=context,
content_type="application/xhtml+xml; charset=UTF-8")
except TemplateDoesNotExist:
if 'mode' in request.GET:
return remove_query_parameter(request, 'mode')
else:
view_type = get_default_view(request)
return render_wirecloud(request, view_type)
def get_platform_context_current_values(self, user):
if user.is_authenticated():
username = user.username
fullname = user.get_full_name()
avatar = 'https://www.gravatar.com/avatar/' + md5(user.email.strip(
).lower().encode('utf8')).hexdigest() + '?s=25'
else:
username = '******'
fullname = _('Anonymous')
avatar = 'https://www.gravatar.com/avatar/00000000000000000000000000000000?s=25'
return {
'language': get_language(),
'orientation': 'landscape',
'username': username,
'fullname': fullname,
'avatar': avatar,
'isanonymous': user.is_anonymous(),
'isstaff': user.is_staff,
'issuperuser': user.is_superuser,
'mode': 'unknown',
'theme': get_active_theme_name(),
'version': wirecloud.platform.__version__,
'version_hash': get_version_hash(),
}
def auto_select_workspace(request, mode=None):
if settings.ALLOW_ANONYMOUS_ACCESS is False and request.user.is_authenticated() is False:
return redirect_to_login(request.get_full_path())
_junk1, active_workspace = get_workspace_list(request.user)
if active_workspace is not None:
url = urlresolvers.reverse('wirecloud.workspace_view', kwargs={
'owner': active_workspace.workspace.creator.username,
'name': active_workspace.workspace.name,
})
if mode:
url += '?' + urlencode({'mode': mode})
return HttpResponseRedirect(url)
elif request.user.is_authenticated():
return render_wirecloud(request, mode)
else:
context = {
'THEME': get_active_theme_name(),
'VIEW_MODE': 'classic',
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
context = RequestContext(request, context)
return render(request, 'wirecloud/landing_page.html', context_instance=context, content_type="application/xhtml+xml; charset=UTF-8")
def auto_select_workspace(request, mode=None):
if settings.ALLOW_ANONYMOUS_ACCESS is False and request.user.is_authenticated() is False:
return redirect_to_login(request.get_full_path())
if request.user.is_authenticated():
url = urlresolvers.reverse('wirecloud.workspace_view', kwargs={
'owner': 'wirecloud',
'name': 'home'
})
parameters = {}
if mode:
parameters['mode'] = mode
if 'theme' in request.GET:
parameters['theme'] = request.GET['theme']
if len(parameters) > 0:
url += '?' + urlencode(parameters)
return HttpResponseRedirect(url)
else:
context = {
'THEME': get_active_theme_name(),
'VIEW_MODE': 'classic',
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
return render(request, 'wirecloud/landing_page.html', context=context, content_type="application/xhtml+xml; charset=UTF-8")
def render_wirecloud(request, view_type=None):
if view_type is None:
if 'mode' in request.GET:
view_type = request.GET['mode']
else:
view_type = get_default_view(request)
theme = request.GET.get('theme', get_active_theme_name())
if theme not in get_available_themes():
return remove_query_parameter(request, 'theme')
try:
template = get_template(theme + ':wirecloud/views/%s.html' % view_type)
except TemplateDoesNotExist:
if 'mode' in request.GET:
return remove_query_parameter(request, 'mode')
else:
view_type = get_default_view(request)
return render_wirecloud(request, view_type)
context = {
'THEME': theme,
'VIEW_MODE': view_type,
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
content = template.render(RequestContext(request, context))
return HttpResponse(content, content_type="application/xhtml+xml; charset=UTF-8")
def render_wirecloud(request, view_type=None, title=None, description=None):
if view_type is None:
if 'mode' in request.GET:
view_type = request.GET['mode']
else:
view_type = get_default_view(request)
theme = request.GET.get('theme', get_active_theme_name())
if theme not in get_available_themes():
return remove_query_parameter(request, 'theme')
context = {
'title': title,
'description': description,
'THEME': theme,
'VIEW_MODE': view_type,
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
try:
return render(request, theme + ':wirecloud/views/%s.html' % view_type, context=context, content_type="application/xhtml+xml; charset=UTF-8")
except TemplateDoesNotExist:
if 'mode' in request.GET:
return remove_query_parameter(request, 'mode')
else:
view_type = get_default_view(request)
return render_wirecloud(request, view_type, title, description)
def auto_select_workspace(request, mode=None):
if settings.ALLOW_ANONYMOUS_ACCESS is False and request.user.is_authenticated(
) is False:
return redirect_to_login(request.get_full_path())
if request.user.is_authenticated():
url = urlresolvers.reverse('wirecloud.workspace_view',
kwargs={
'owner': 'wirecloud',
'name': 'home'
})
parameters = {}
if mode:
parameters['mode'] = mode
if 'theme' in request.GET:
parameters['theme'] = request.GET['theme']
if len(parameters) > 0:
url += '?' + urlencode(parameters)
return HttpResponseRedirect(url)
else:
context = {
'THEME': get_active_theme_name(),
'VIEW_MODE': 'classic',
'WIRECLOUD_VERSION_HASH': get_version_hash()
}
return render(request,
'wirecloud/landing_page.html',
context=context,
content_type="application/xhtml+xml; charset=UTF-8")
def wirecloud_bootstrap(context, view):
current_theme = context.get('THEME', get_active_theme_name())
available_themes = [{"value": theme.name, "label": theme.label} for theme in get_available_themes(metadata=True)]
endpoints = get_wirecloud_ajax_endpoints(view)
script = 'Wirecloud.URLs = {\n'
for endpoint in endpoints:
script += ' "' + endpoint['id'] + '": '
if '%(' in endpoint['url']:
script += "new Wirecloud.Utils.Template('" + endpoint['url'] + "'),\n"
else:
script += "'" + endpoint['url'] + "',\n"
script += '};'
constants_def = get_constants()
constants = []
for constant in constants_def:
constants.append({'key': constant['key'], 'value': mark_safe(constant['value'])})
constants.append({'key': 'CURRENT_MODE', 'value': mark_safe('"' + view + '"')})
constants.append({'key': 'CURRENT_THEME', 'value': mark_safe('"' + current_theme + '"')})
constants.append({'key': 'AVAILABLE_THEMES', 'value': mark_safe(json.dumps(available_themes, cls=LazyEncoder))})
return {
'script': mark_safe(script),
'constants': constants,
}
def extra_javascripts(context, view):
theme = context.get('THEME', get_active_theme_name())
files = get_extra_javascripts(view)
header_js = 'theme/%s/js/wirecloud/ui/WirecloudHeader.js' % theme
found = finders.find(header_js)
if found:
for i, file in enumerate(files):
if file == 'js/wirecloud/ui/WirecloudHeader.js':
files[i] = header_js
return {'files': files}
def get_platform_context_current_values(self, user):
if user.is_authenticated():
username = user.username
fullname = user.get_full_name()
else:
username = '******'
fullname = _('Anonymous')
return {
'language': get_language(),
'orientation': 'landscape',
'username': username,
'fullname': fullname,
'isanonymous': user.is_anonymous(),
'isstaff': user.is_staff,
'issuperuser': user.is_superuser,
'mode': 'unknown',
'theme': get_active_theme_name(),
'version': wirecloud.platform.__version__,
'version_hash': get_version_hash(),
}
def get_platform_context_current_values(self, user):
if user.is_authenticated():
username = user.username
fullname = user.get_full_name()
else:
username = '******'
fullname = _('Anonymous')
return {
'language': get_language(),
'orientation': 'landscape',
'username': username,
'fullname': fullname,
'isanonymous': user.is_anonymous(),
'isstaff': user.is_staff,
'issuperuser': user.is_superuser,
'mode': 'unknown',
'theme': get_active_theme_name(),
'version': wirecloud.platform.__version__,
'version_hash': get_version_hash(),
}
def test_get_active_theme_name_custom_value(self):
self.assertEqual(get_active_theme_name(), "customtheme")
def active_theme(request):
return {'THEME_ACTIVE': get_active_theme_name()}
def test_get_active_theme_name_default(self):
# Emulate the user didn't define a THEME_ACTIVE setting
del settings.THEME_ACTIVE
self.assertEqual(get_active_theme_name(), "wirecloud.defaulttheme")
def test_get_active_theme_name_custom_value(self):
self.assertEqual(get_active_theme_name(), "customtheme")
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 get_context_data(self, **kwargs):
context = super(MissingWidgetCodeView, self).get_context_data(**kwargs)
theme = self.request.GET.get('theme', get_active_theme_name())
context['style'] = get_widget_platform_style(theme)
return context
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 get_context_data(self, **kwargs):
context = super(MissingWidgetCodeView, self).get_context_data(**kwargs)
theme = self.request.GET.get('theme', get_active_theme_name())
context['style'] = get_widget_platform_style(theme)
return context
def read(self, request, vendor, name, version):
resource = get_object_or_404(CatalogueResource.objects.select_related('widget__xhtml'), vendor=vendor, short_name=name, version=version)
# For now, all widgets are freely accessible/distributable
#if not resource.is_available_for(request.user):
# return build_error_response(request, 403, "Forbidden")
if resource.resource_type() != 'widget':
raise Http404()
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')
force_base = False
base_url = xhtml.url
if not base_url.startswith(('http://', 'https://')):
# Newer versions of Django urlencode urls created using reverse
# Fix double encoding
base_url = urlunquote(base_url)
base_url = get_absolute_reverse_url('wirecloud.showcase_media', args=(base_url.split('/', 3)), request=request)
force_base = True
code = xhtml.code
if not xhtml.cacheable or code == '':
try:
if xhtml.url.startswith(('http://', 'https://')):
code = download_http_content(urljoin(base_url, xhtml.url), user=request.user)
else:
code = download_local_file(os.path.join(showcase_utils.wgt_deployer.root_dir, url2pathname(xhtml.url)))
except Exception as e:
return build_response(request, 502, {'error_msg': _("(X)HTML code is not accessible"), '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()
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, process_requirements(widget_info['requirements']), force_base, 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 render(self, context):
if 'THEME' not in context:
context['THEME'] = get_active_theme_name()
return self.node.render(context)
def test_get_active_theme_name_default(self):
# Emulate the user didn't define a THEME_ACTIVE setting
del settings.THEME_ACTIVE
self.assertEqual(get_active_theme_name(), "wirecloud.defaulttheme")
