def oauth_discovery(request):
endpoints = {
'flows': ["Authorization Code Grant"],
'auth_endpoint': get_absolute_reverse_url('oauth2provider.auth', request),
'token_endpoint': get_absolute_reverse_url('oauth2provider.token', request),
'default_redirect_uri': get_absolute_reverse_url('oauth.default_redirect_uri', request),
'version': '2.0',
}
return HttpResponse(json.dumps(endpoints, sort_keys=True), content_type='application/json; charset=UTF-8')
def read(self, request, vendor, name, version):
operator = get_object_or_404(CatalogueResource, type=2, vendor=vendor, short_name=name, version=version)
# For now, all operators are freely accessible/distributable
# if not operator.is_available_for(request.user):
# return HttpResponseForbidden()
mode = request.GET.get('mode', 'classic')
key = get_operator_cache_key(operator, get_current_domain(request), mode)
cached_response = cache.get(key)
if cached_response is None:
options = operator.json_description
js_files = options['js_files']
base_url = get_absolute_reverse_url('wirecloud.showcase_media', kwargs={
'vendor': operator.vendor,
'name': operator.short_name,
'version': operator.version,
'file_path': operator.template_uri
}, request=request)
xhtml = generate_xhtml_operator_code(js_files, base_url, request, process_requirements(options['requirements']), mode)
cache_timeout = 31536000 # 1 year
cached_response = CacheableData(xhtml, timeout=cache_timeout, content_type='application/xhtml+xml; charset=UTF-8')
cache.set(key, cached_response, cache_timeout)
return cached_response.get_response()
def read(self, request, vendor, name, version):
operator = get_object_or_404(CatalogueResource, type=2, vendor=vendor, short_name=name, version=version)
if not operator.is_available_for(request.user):
return HttpResponseForbidden()
key = '_operator/' + operator.local_uri_part
cached_response = cache.get(key)
if cached_response is None:
options = json.loads(operator.json_description)
js_files = options['js_files']
base_url = operator.template_uri
if not base_url.startswith(('http://', 'https://')):
base_url = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': operator.vendor,
'name': operator.short_name,
'version': operator.version,
'file_path': operator.template_uri
}, request=request)
xhtml = generate_xhtml_operator_code(js_files, base_url, request)
cache_timeout = 31536000 # 1 year
cached_response = CacheableData(xhtml, timeout=cache_timeout, mimetype='application/xhtml+xml; charset=UTF-8')
cache.set(key, cached_response, cache_timeout)
return cached_response.get_response()
def get_resource_data(untranslated_resource, user, request=None):
"""Gets all the information related to the given widget."""
resource = untranslated_resource.get_translated_model()
resource_info = untranslated_resource.get_processed_info(request)
if urlparse(resource.template_uri).scheme == '':
template_uri = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'file_path': resource.template_uri
}, request=request)
else:
template_uri = resource.template_uri
if resource.display_name and resource.display_name != "":
displayName = resource.display_name
else:
displayName = resource.short_name
data_events = get_event_data(widget_id=resource.pk)
data_slots = get_slot_data(widget_id=resource.pk)
uploader = None
if resource.creator is not None:
uploader = resource.creator.get_full_name()
if uploader.strip() == '':
uploader = resource.creator.username
cdate = resource.creation_date
creation_timestamp = time.mktime(cdate.timetuple()) * 1e3 + cdate.microsecond / 1e3
return {
'id': resource.pk,
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'type': resource.resource_type(),
'packaged': resource.fromWGT,
'date': creation_timestamp,
'uploader': uploader,
'permissions' : {
'uninstall': resource.public is False and resource.users.filter(pk=user.pk).exists(),
},
'authors': resource.author,
'displayName': displayName,
'description': resource.description,
'mail': resource.mail,
'uriImage': urljoin(template_uri, resource.image_uri),
'uriWiki': urljoin(template_uri, resource.wiki_page_uri),
'uriTemplate': template_uri,
'license': resource_info['license'],
'licenseurl': resource_info['licenseurl'],
'outputs': [d for d in data_events],
'inputs': [d for d in data_slots],
}
def setUpClass(cls):
super(BasicViewsAPI, cls).setUpClass()
factory = RequestFactory()
request = factory.get(reverse('login'))
if django.VERSION[1] >= 9:
# Django 1.9 doesn't force the use of absolute urls for the location header
# https://docs.djangoproject.com/en/1.9/releases/1.9/#http-redirects-no-longer-forced-to-absolute-uris
cls.login_url = reverse('login')
else:
cls.login_url = get_absolute_reverse_url('login', request=request)
def render(self, context):
base_url = get_absolute_reverse_url('wirecloud.root', context['request'])
if base_url.endswith('/'):
base_url = base_url[:-1]
value = self.condition.resolve(context)
if value.startswith(base_url + '/') or value == base_url:
return self.nodelist.render(context)
else:
return ''
def setUpClass(cls):
super(BasicViewsAPI, cls).setUpClass()
factory = RequestFactory()
request = factory.get(reverse('login'))
if django.VERSION[1] >= 9:
# Django 1.9 doesn't force the use of absolute urls for the location header
# https://docs.djangoproject.com/en/1.9/releases/1.9/#http-redirects-no-longer-forced-to-absolute-uris
cls.login_url = reverse('login')
else:
cls.login_url = get_absolute_reverse_url('login', request=request)
def get_resource_data(untranslated_resource, user, request=None):
"""Gets all the information related to the given widget."""
resource = untranslated_resource.get_translated_model()
if urlparse(resource.template_uri).scheme == '':
template_uri = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'file_path': resource.template_uri
}, request=request)
else:
template_uri = resource.template_uri
if resource.display_name and resource.display_name != "":
displayName = resource.display_name
else:
displayName = resource.short_name
data_tags = get_tag_data(widget_id=resource.pk, user_id=user.id)
data_events = get_event_data(widget_id=resource.pk)
data_slots = get_slot_data(widget_id=resource.pk)
uploader = None
if resource.creator is not None:
uploader = resource.creator.get_full_name()
if uploader.strip() == '':
uploader = resource.creator.username
cdate = resource.creation_date
creation_timestamp = time.mktime(cdate.timetuple()) * 1e3 + cdate.microsecond / 1e3
return {
'id': resource.pk,
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'type': resource.resource_type(),
'packaged': resource.fromWGT,
'date': creation_timestamp,
'uploader': uploader,
'added_by_user': user.is_superuser or resource.creator == user,
'author': resource.author,
'displayName': displayName,
'description': resource.description,
'mail': resource.mail,
'uriImage': urljoin(template_uri, resource.image_uri),
'uriWiki': urljoin(template_uri, resource.wiki_page_uri),
'uriTemplate': template_uri,
'ieCompatible': resource.ie_compatible,
'tags': [d for d in data_tags],
'outputs': [d for d in data_events],
'inputs': [d for d in data_slots],
'votes': get_vote_data(widget=resource, user=user),
}
def oauth_discovery(request):
keycloak_auth_backend = build_simple_backend()
endpoints = {
'flows': ["Authorization Code Grant", "Resource Owner Password Credentials Grant"],
'auth_endpoint': keycloak_auth_backend.AUTHORIZATION_URL,
'token_endpoint': keycloak_auth_backend.ACCESS_TOKEN_URL,
'default_redirect_uri': get_absolute_reverse_url('oauth.default_redirect_uri', request),
'version': '2.0',
}
return HttpResponse(json.dumps(endpoints, sort_keys=True), content_type='application/json; charset=UTF-8')
def get_template_url(vendor, name, version, url, request=None):
if urlparse(url).scheme == '':
template_url = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': vendor,
'name': name,
'version': version,
'file_path': url
}, request=request)
else:
template_url = url
return template_url
def get_template_url(vendor, name, version, url, request=None, url_pattern_name='wirecloud_catalogue.media'):
if urlparse(url).scheme == '':
template_url = get_absolute_reverse_url(url_pattern_name, kwargs={
'vendor': vendor,
'name': name,
'version': version,
'file_path': url
}, request=request)
else:
template_url = url
return template_url
def oauth_discovery(request):
from social_auth.backends import get_backends
fiware_auth_backend = get_backends()['fiware']
endpoints = {
'auth_endpoint': fiware_auth_backend.AUTHORIZATION_URL,
'token_endpoint': fiware_auth_backend.ACCESS_TOKEN_URL,
'default_redirect_uri': get_absolute_reverse_url('oauth.default_redirect_uri', request),
'version': '2.0',
}
return HttpResponse(json.dumps(endpoints), content_type='application/json; charset=UTF-8')
def get_processed_info(self, request=None):
if urlparse(self.template_uri).scheme == '':
template_uri = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': self.vendor,
'name': self.short_name,
'version': self.version,
'file_path': self.template_uri
}, request=request)
else:
template_uri = self.template_uri
parser = TemplateParser(self.json_description, base=template_uri)
return parser.get_resource_processed_info()
def start_purchase(request, market_user, market_name, store):
adaptor = get_market_adaptor(market_user, market_name)
user_data = get_market_user_data(request.user, market_user, market_name)
data = simplejson.loads(request.raw_post_data)
redirect_uri = get_absolute_reverse_url('wirecloud.fiware.store_redirect_uri', request)
try:
result = adaptor.start_purchase(store, data['offering_url'], redirect_uri, **user_data)
except:
return HttpResponse(status=502)
return HttpResponse(simplejson.dumps(result), mimetype='application/json; chaset=UTF-8')
def oauth_discovery(request):
from social.apps.django_app.utils import BACKENDS
from social.backends.utils import get_backend
fiware_auth_backend = get_backend(BACKENDS, 'fiware')
endpoints = {
'flows': ["Authorization Code Grant", "Resource Owner Password Credentials Grant"],
'auth_endpoint': fiware_auth_backend.AUTHORIZATION_URL,
'token_endpoint': fiware_auth_backend.ACCESS_TOKEN_URL,
'default_redirect_uri': get_absolute_reverse_url('oauth.default_redirect_uri', request),
'version': '2.0',
}
return HttpResponse(json.dumps(endpoints), content_type='application/json; charset=UTF-8')
def oauth_discovery(request):
from social.apps.django_app.utils import BACKENDS
from social.backends.utils import get_backend
fiware_auth_backend = get_backend(BACKENDS, 'fiware')
endpoints = {
'flows': ["Authorization Code Grant", "Resource Owner Password Credentials Grant"],
'auth_endpoint': fiware_auth_backend.AUTHORIZATION_URL,
'token_endpoint': fiware_auth_backend.ACCESS_TOKEN_URL,
'default_redirect_uri': get_absolute_reverse_url('oauth.default_redirect_uri', request),
'version': '2.0',
}
return HttpResponse(json.dumps(endpoints, sort_keys=True), content_type='application/json; charset=UTF-8')
def read(self, request, vendor, name, version):
widget = get_object_or_404(
Widget, resource__vendor=vendor, resource__short_name=name, resource__version=version
)
if not widget.is_available_for(request.user):
raise Http403()
# check if the xhtml code has been cached
if widget.xhtml.cacheable:
cache_key = widget.xhtml.get_cache_key(get_current_domain(request))
cache_entry = cache.get(cache_key)
if cache_entry is not None:
response = HttpResponse(cache_entry["code"], mimetype="%s; charset=UTF-8" % cache_entry["content_type"])
patch_cache_headers(response, cache_entry["timestamp"], cache_entry["timeout"])
return response
# process xhtml
xhtml = widget.xhtml
content_type = xhtml.content_type
if not content_type:
content_type = "text/html"
force_base = False
base_url = xhtml.url
if not base_url.startswith(("http://", "https://")):
base_url = get_absolute_reverse_url(
"wirecloud_showcase.media", args=(base_url.split("/", 4)), request=request
)
force_base = True
code = xhtml.code
if not xhtml.cacheable or code == "":
try:
if xhtml.url.startswith(("http://", "https://")):
code = downloader.download_http_content(urljoin(base_url, xhtml.url), user=request.user)
else:
code = downloader.download_http_content(
"file://" + os.path.join(showcase_utils.wgt_deployer.root_dir, xhtml.url), user=request.user
)
except Exception, e:
# FIXME: Send the error or use the cached original code?
msg = _("XHTML code is not accessible: %(errorMsg)s") % {"errorMsg": e.message}
return HttpResponse(get_xml_error_response(msg), mimetype="application/xml; charset=UTF-8")
def read(self, request, vendor, name, version):
operator = get_object_or_404(CatalogueResource,
type=2,
vendor=vendor,
short_name=name,
version=version)
# For now, all operators are freely accessible/distributable
#if not operator.is_available_for(request.user):
# return HttpResponseForbidden()
mode = request.GET.get('mode', 'classic')
key = get_operator_cache_key(operator, get_current_domain(request),
mode)
cached_response = cache.get(key)
if cached_response is None:
options = json.loads(operator.json_description)
js_files = options['js_files']
base_url = operator.template_uri
if not base_url.startswith(('http://', 'https://')):
base_url = get_absolute_reverse_url('wirecloud.showcase_media',
kwargs={
'vendor':
operator.vendor,
'name':
operator.short_name,
'version':
operator.version,
'file_path':
operator.template_uri
},
request=request)
xhtml = generate_xhtml_operator_code(
js_files, base_url, request,
process_requirements(options['requirements']), mode)
cache_timeout = 31536000 # 1 year
cached_response = CacheableData(
xhtml,
timeout=cache_timeout,
content_type='application/xhtml+xml; charset=UTF-8')
cache.set(key, cached_response, cache_timeout)
return cached_response.get_response()
def process(self, request, market_user, market_name, store):
adaptor = get_market_adaptor(market_user, market_name)
user_data = get_market_user_data(request.user, market_user, market_name)
data = parse_json_request(request)
redirect_uri = get_absolute_reverse_url('wirecloud.fiware.store_redirect_uri', request)
try:
result = adaptor.start_purchase(store, data['offering_url'], redirect_uri, **user_data)
except HTTPError as e:
details = "%s" % e
return build_error_response(request, 502, "Unexpected response", details=details)
except (ConnectionError, ConnectTimeout):
return build_error_response(request, 504, "Connection Error")
return HttpResponse(json.dumps(result), content_type='application/json; chaset=UTF-8')
def read(self, request, vendor, name, version):
operator = get_object_or_404(CatalogueResource, type=2, vendor=vendor, short_name=name, version=version)
options = json.loads(operator.json_description)
js_files = options['js_files']
base_url = operator.template_uri
if not base_url.startswith(('http://', 'https://')):
base_url = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': operator.vendor,
'name': operator.short_name,
'version': operator.version,
'file_path': operator.template_uri
}, request=request)
xhtml = generate_xhtml_operator_code(js_files, base_url, request)
return HttpResponse(xhtml, mimetype='application/xhtml+xml; charset=UTF-8')
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)
if not resource.is_available_for(request.user):
raise Http403()
if resource.resource_type() != 'widget':
raise Http404()
widget_info = json.loads(resource.json_description)
# check if the xhtml code has been cached
if widget_info['code_cacheable'] is True:
cache_key = resource.widget.xhtml.get_cache_key(get_current_domain(request))
cache_entry = cache.get(cache_key)
if cache_entry is not None:
response = HttpResponse(cache_entry['code'], mimetype=cache_entry['mimetype'])
patch_cache_headers(response, cache_entry['timestamp'], cache_entry['timeout'])
return response
# process xhtml
xhtml = resource.widget.xhtml
content_type = widget_info.get('code_content_type', 'text/html')
charset = widget_info.get('code_charset', 'utf-8')
force_base = False
base_url = xhtml.url
if not base_url.startswith(('http://', 'https://')):
base_url = get_absolute_reverse_url('wirecloud_showcase.media', args=(base_url.split('/', 4)), request=request)
force_base = True
code = xhtml.code
if not xhtml.cacheable or code == '':
try:
if xhtml.url.startswith(('http://', 'https://')):
code = downloader.download_http_content(urljoin(base_url, xhtml.url), user=request.user)
else:
code = downloader.download_http_content('file://' + os.path.join(showcase_utils.wgt_deployer.root_dir, url2pathname(xhtml.url)), user=request.user)
except Exception, e:
msg = _("XHTML code is not accessible: %(errorMsg)s") % {'errorMsg': e.message}
return build_error_response(request, 502, msg)
def logout(request):
external_domain = 'HTTP_ORIGIN' in request.META
# Check if the logout request is originated in a different domain
if external_domain:
origin = request.META['HTTP_ORIGIN']
if origin not in ALLOWED_ORIGINS:
return build_error_response(request, 403, '')
# Force not redirect by using next_page=None
response = wirecloud_logout(request, next_page=None)
response['Access-Control-Allow-Origin'] = origin
response['Access-Control-Allow-Credentials'] = 'true'
return response
elif callable(
request.user.is_authenticated) and request.user.is_authenticated(
) or request.user.is_authenticated is True:
backend = build_backend()
next_page = str(
getattr(settings, 'LOGOUT_REDIRECT_URL',
get_absolute_reverse_url('wirecloud.root', request)))
if REDIRECT_FIELD_NAME in request.GET:
url_next_page = request.GET.get(REDIRECT_FIELD_NAME)
url_is_safe = is_safe_url(
url=url_next_page,
allowed_hosts={request.get_host()},
require_https=request.is_secure(),
)
if url_is_safe:
next_page = url_next_page
keycloak_logout_url = backend.end_session_url(
) + '?redirect_uri=' + quote(request.build_absolute_uri(next_page))
request.GET = {}
return wirecloud_logout(request, next_page=keycloak_logout_url)
else:
return wirecloud_logout(request)
def process(self, request, market_user, market_name, store):
adaptor = get_market_adaptor(market_user, market_name)
user_data = get_market_user_data(request.user, market_user,
market_name)
data = parse_json_request(request)
redirect_uri = get_absolute_reverse_url(
'wirecloud.fiware.store_redirect_uri', request)
try:
result = adaptor.start_purchase(store, data['offering_url'],
redirect_uri, **user_data)
except HTTPError as e:
details = "%s" % e
return build_error_response(request,
502,
"Unexpected response",
details=details)
except (ConnectionError, ConnectTimeout):
return build_error_response(request, 504, "Connection Error")
return HttpResponse(json.dumps(result),
content_type='application/json; chaset=UTF-8')
def get_resource_data(resource, user, request=None):
"""Gets all the information related to the given resource."""
resource_info = resource.get_processed_info(request)
template_uri = get_absolute_reverse_url(
"wirecloud_catalogue.media",
kwargs={
"vendor": resource.vendor,
"name": resource.short_name,
"version": resource.version,
"file_path": resource.template_uri,
},
request=request,
)
wgt_path = os.path.join(
wgt_deployer.get_base_dir(resource.vendor, resource.short_name, resource.version), resource.template_uri
)
size = os.path.getsize(wgt_path)
cdate = resource.creation_date
creation_timestamp = time.mktime(cdate.timetuple()) * 1e3 + cdate.microsecond / 1e3
longdescription = resource_info["longdescription"]
if longdescription != "":
longdescription_relative_path = url2pathname(longdescription)
longdescription_base_url = force_trailing_slash(
urljoin(
resource.get_template_url(request=request, for_base=True),
pathname2url(os.path.dirname(longdescription_relative_path)),
)
)
longdescription_path = os.path.join(
wgt_deployer.get_base_dir(resource.vendor, resource.short_name, resource.version),
longdescription_relative_path,
)
(filename_root, filename_ext) = os.path.splitext(longdescription_path)
localized_longdescription_path = filename_root + "." + get_language() + filename_ext
try:
description_code = download_local_file(localized_longdescription_path)
longdescription = clean_html(
markdown.markdown(description_code, output_format="xhtml5"), base_url=longdescription_base_url
)
except:
try:
description_code = download_local_file(longdescription_path)
longdescription = clean_html(
markdown.markdown(description_code, output_format="xhtml5"), base_url=longdescription_base_url
)
except:
longdescription = resource_info["description"]
else:
longdescription = resource_info["description"]
return {
"id": resource.pk,
"vendor": resource.vendor,
"name": resource.short_name,
"version": resource.version,
"type": resource_info["type"],
"date": creation_timestamp,
"permissions": {
"delete": user.is_superuser,
"uninstall": resource.public is False and resource.users.filter(pk=user.pk).exists(),
},
"authors": resource_info["authors"],
"contributors": resource_info["contributors"],
"title": resource_info["title"],
"description": resource_info["description"],
"longdescription": longdescription,
"email": resource_info["email"],
"image": resource_info["image"],
"homepage": resource_info["homepage"],
"doc": resource_info["doc"],
"changelog": resource_info["changelog"],
"size": size,
"uriTemplate": template_uri,
"license": resource_info["license"],
"licenseurl": resource_info["licenseurl"],
"issuetracker": resource_info["issuetracker"],
}
def get_resource_data(resource, user, request=None):
"""Gets all the information related to the given resource."""
resource_info = resource.get_processed_info(request)
template_uri = get_absolute_reverse_url('wirecloud_catalogue.media',
kwargs={
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'file_path':
resource.template_uri
},
request=request)
wgt_path = os.path.join(
wgt_deployer.get_base_dir(resource.vendor, resource.short_name,
resource.version), resource.template_uri)
size = os.path.getsize(wgt_path)
cdate = resource.creation_date
creation_timestamp = time.mktime(
cdate.timetuple()) * 1e3 + cdate.microsecond / 1e3
longdescription = resource_info['longdescription']
if longdescription != '':
longdescription_relative_path = url2pathname(longdescription)
longdescription_base_url = force_trailing_slash(
urljoin(
resource.get_template_url(request=request, for_base=True),
pathname2url(os.path.dirname(longdescription_relative_path))))
longdescription_path = os.path.join(
wgt_deployer.get_base_dir(resource.vendor, resource.short_name,
resource.version),
longdescription_relative_path)
(filename_root, filename_ext) = os.path.splitext(longdescription_path)
localized_longdescription_path = filename_root + '.' + get_language(
) + filename_ext
try:
description_code = download_local_file(
localized_longdescription_path).decode('utf-8')
longdescription = clean_html(markdown.markdown(
description_code, output_format='xhtml5'),
base_url=longdescription_base_url)
except Exception:
try:
description_code = download_local_file(
longdescription_path).decode('utf-8')
longdescription = clean_html(markdown.markdown(
description_code, output_format='xhtml5'),
base_url=longdescription_base_url)
except Exception:
longdescription = resource_info['description']
else:
longdescription = resource_info['description']
return {
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'type': resource_info['type'],
'date': creation_timestamp,
'permissions': {
'delete':
user.is_superuser,
'uninstall':
resource.public is False
and resource.users.filter(pk=user.pk).exists(),
},
'authors': resource_info['authors'],
'contributors': resource_info['contributors'],
'title': resource_info['title'],
'description': resource_info['description'],
'longdescription': longdescription,
'email': resource_info['email'],
'image': resource_info['image'],
'homepage': resource_info['homepage'],
'doc': resource_info['doc'],
'changelog': resource_info['changelog'],
'size': size,
'uriTemplate': template_uri,
'license': resource_info['license'],
'licenseurl': resource_info['licenseurl'],
'issuetracker': resource_info['issuetracker'],
}
def setUpClass(cls):
super(BasicViewsAPI, cls).setUpClass()
factory = RequestFactory()
request = factory.get(reverse('login'))
cls.login_url = get_absolute_reverse_url('login', request=request)
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')
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)
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)
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 setUpClass(cls):
super(BasicViewsAPI, cls).setUpClass()
factory = RequestFactory()
request = factory.get(reverse('login'))
cls.login_url = get_absolute_reverse_url('login', request=request)
def get_widget_data(widget, request=None):
base_url = widget.xhtml.url
if not base_url.startswith(('http://', 'https://')):
base_url = get_absolute_reverse_url('wirecloud_showcase.media', args=(base_url.split('/', 4)), request=request)
twidget = widget.resource.get_translated_model()
data_ret = {}
data_variabledef = VariableDef.objects.filter(widget=widget)
data_vars = {}
for var in data_variabledef:
tvar = var.get_translated_model()
data_var = {}
data_var['aspect'] = var.aspect
data_var['name'] = var.name
data_var['type'] = var.type
data_var['label'] = tvar.label
data_var['description'] = tvar.description
if var.aspect == 'PREF':
data_var['default_value'] = tvar.default_value
if var.type == 'L':
options = UserPrefOption.objects.filter(variableDef=var)
value_options = []
for option in options:
toption = option.get_translated_model()
value_options.append([toption.value, toption.name])
data_var['value_options'] = value_options
elif var.aspect == 'SLOT':
data_var['action_label'] = tvar.action_label
if var.aspect in ('PREF', 'PROP', 'EVEN', 'SLOT'):
data_var['order'] = var.order
if var.aspect == 'PREF' or var.aspect == 'PROP':
data_var['secure'] = var.secure
elif var.aspect == 'GCTX' or var.aspect == 'ECTX':
data_var['concept'] = var.contextoption_set.all().values('concept')[0]['concept']
elif var.aspect == 'EVEN' or var.aspect == 'SLOT':
data_var['friend_code'] = var.friend_code
data_vars[var.name] = data_var
data_ret['vendor'] = widget.resource.vendor
data_ret['name'] = widget.resource.short_name
data_ret['version'] = widget.resource.version
data_ret['uri'] = widget.uri
if twidget.display_name and twidget.display_name != "":
data_ret['displayName'] = twidget.display_name
else:
data_ret['displayName'] = widget.resource.short_name
data_ret['description'] = twidget.description
data_ret['wikiURI'] = urljoin(base_url, twidget.wiki_page_uri)
data_ret['imageURI'] = urljoin(base_url, twidget.image_uri)
data_ret['iPhoneImageURI'] = urljoin(base_url, twidget.iphone_image_uri)
data_ret['mail'] = widget.resource.mail
data_ret['size'] = {}
data_ret['size']['width'] = widget.width
data_ret['size']['height'] = widget.height
data_ret['variables'] = data_vars
data_ret['code_content_type'] = widget.xhtml.content_type
return data_ret
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')
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)
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('/', 4)), 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)
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_resource_data(resource, user, request=None):
"""Gets all the information related to the given resource."""
resource_info = resource.get_processed_info(request)
template_uri = get_absolute_reverse_url('wirecloud_catalogue.media', kwargs={
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'file_path': resource.template_uri
}, request=request)
wgt_path = os.path.join(wgt_deployer.get_base_dir(resource.vendor, resource.short_name, resource.version), resource.template_uri)
size = os.path.getsize(wgt_path)
cdate = resource.creation_date
creation_timestamp = time.mktime(cdate.timetuple()) * 1e3 + cdate.microsecond / 1e3
longdescription = resource_info['longdescription']
if longdescription != '':
longdescription_relative_path = url2pathname(longdescription)
longdescription_base_url = force_trailing_slash(urljoin(resource.get_template_url(request=request, for_base=True), pathname2url(os.path.dirname(longdescription_relative_path))))
longdescription_path = os.path.join(wgt_deployer.get_base_dir(resource.vendor, resource.short_name, resource.version), longdescription_relative_path)
(filename_root, filename_ext) = os.path.splitext(longdescription_path)
localized_longdescription_path = filename_root + '.' + get_language() + filename_ext
try:
description_code = download_local_file(localized_longdescription_path).decode('utf-8')
longdescription = clean_html(markdown.markdown(description_code, output_format='xhtml5'), base_url=longdescription_base_url)
except:
try:
description_code = download_local_file(longdescription_path).decode('utf-8')
longdescription = clean_html(markdown.markdown(description_code, output_format='xhtml5'), base_url=longdescription_base_url)
except:
longdescription = resource_info['description']
else:
longdescription = resource_info['description']
return {
'id': resource.pk,
'vendor': resource.vendor,
'name': resource.short_name,
'version': resource.version,
'type': resource_info['type'],
'date': creation_timestamp,
'permissions': {
'delete': user.is_superuser,
'uninstall': resource.public is False and resource.users.filter(pk=user.pk).exists(),
},
'authors': resource_info['authors'],
'contributors': resource_info['contributors'],
'title': resource_info['title'],
'description': resource_info['description'],
'longdescription': longdescription,
'email': resource_info['email'],
'image': resource_info['image'],
'homepage': resource_info['homepage'],
'doc': resource_info['doc'],
'changelog': resource_info['changelog'],
'size': size,
'uriTemplate': template_uri,
'license': resource_info['license'],
'licenseurl': resource_info['licenseurl'],
'issuetracker': resource_info['issuetracker'],
}
def get_template_url(self, request=None):
return get_absolute_reverse_url('wirecloud_showcase.mashup_template', request, args=(self.id,))
