def xhr_api(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
# Select a license based on the request form
license = _issue_license(request_form)
# Generate the HTML+RDFa for the license + provided work information
work_dict = _formatter_work_dict(request_form)
license_html = HTML_FORMATTER.format(
license, work_dict, target_lang)
def has_code(code):
return license.license_code.count(code) >= 1
ret = {
#'license': license,
'uri' : license.uri,
'libre' : license.libre,
'currency' : util.currency_symbol_from_request_form(request_form),
'license_logo': license.logo_method('88x31'),
'license_slim_logo': license.logo_method('80x15'),
'license_title': license.title(target_lang),
'license_html': license_html,
'license_code' : {
'sa' : has_code('sa'),
'nc' : has_code('nc'),
'nd' : has_code('nd'),
},
}
return Response(json.dumps(ret))
def xhr_api(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
# Select a license based on the request form
license = _issue_license(request_form)
# Generate the HTML+RDFa for the license + provided work information
work_dict = _formatter_work_dict(request_form)
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
def has_code(code):
return license.license_code.count(code) >= 1
ret = {
#'license': license,
'uri': license.uri,
'libre': license.libre,
'currency': util.currency_symbol_from_request_form(request_form),
'license_logo': license.logo_method('88x31'),
'license_slim_logo': license.logo_method('80x15'),
'license_title': license.title(target_lang),
'license_html': license_html,
'license_code': {
'sa': has_code('sa'),
'nc': has_code('nc'),
'nd': has_code('nd'),
},
}
return Response(json.dumps(ret))
def publicdomain_result(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
# make sure the user selected "confirm"
if request_form.get('understand', False) != 'confirm':
return exc.HTTPFound(
location='%s?%s' % (
'./publicdomain-3', urlencode(request.GET)))
work_info = _work_info(request_form)
license_html = PUBLICDOMAIN_HTML_FORMATTER.format(
cc.license.by_code('publicdomain'),
work_info, target_lang)
context = _base_context(request, target_lang)
context.update({
'request_form': request_form,
'license_html': license_html})
return Response(
util.render_template(
request, target_lang,
'chooser_pages/publicdomain/publicdomain-4.html', context))
def cc0_landing(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
return util.render_to_response(request, target_lang,
'chooser_pages/zero/index.html', context)
def license_catcher(request):
"""
If someone chooses something like /licenses/by/ (fails to select a
version, etc) help point them to the available licenses.
"""
target_lang = util.get_target_lang_from_request(request)
license_versions = util.catch_license_versions_from_request(request)
if not license_versions:
return exc.HTTPNotFound()
context = {'request': request,
'license_versions': reversed(license_versions),
'license_class': license_versions[0].license_class,
'page_style': 'bare',
'target_lang': target_lang}
context.update(util.rtl_context_stuff(target_lang))
# This is a helper page, but it's still for not-found situations.
# 404!
return Response(
util.render_template(
request, target_lang,
'catalog_pages/license_catcher.html', context),
status=404)
def pdmark_partner(request):
"""
Partner page for PDM
"""
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
pdm_license = cc.license.by_code('mark')
# Used for recommending CC0 in case that's more appropriate
get_params = util.publicdomain_partner_get_params(request_form)
context = _base_context(request, target_lang)
context.update(
{'request_form': request_form,
'get_params': get_params,
'exit_url': _generate_exit_url(
request_form.get('exit_url', ''),
request_form.get('referrer', ''),
pdm_license)})
return util.render_to_response(
request, target_lang,
'chooser_pages/pdmark/partner.html', context)
def cc0_waiver(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
context["country_list"] = sorted(CODE_COUNTRY_LIST, key=lambda country: country[1])
return util.render_to_response(request, target_lang, "chooser_pages/zero/waiver.html", context)
def pdmark_partner(request):
"""
Partner page for PDM
"""
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
pdm_license = cc.license.by_code("mark")
# Used for recommending CC0 in case that's more appropriate
get_params = util.publicdomain_partner_get_params(request_form)
context = _base_context(request, target_lang)
context.update(
{
"request_form": request_form,
"get_params": get_params,
"exit_url": _generate_exit_url(
request_form.get("exit_url", ""), request_form.get("referrer", ""), pdm_license
),
}
)
return util.render_to_response(request, target_lang, "chooser_pages/pdmark/partner.html", context)
def xhr_api(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
# Select a license based on the request form
license = _issue_license(request_form)
# Generate the HTML+RDFa for the license + provided work information
work_dict = _formatter_work_dict(request_form)
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
def has_code(code):
return license.license_code.count(code) >= 1
ret = {
#'license': license,
"uri": license.uri,
"libre": license.libre,
"currency": util.currency_symbol_from_request_form(request_form),
"license_logo": license.logo_method("88x31"),
"license_slim_logo": license.logo_method("80x15"),
"license_title": license.title(target_lang),
"license_html": license_html,
"license_code": {"sa": has_code("sa"), "nc": has_code("nc"), "nd": has_code("nd")},
}
return Response(json.dumps(ret))
def choose_xmp_view(request):
request_form = request.GET or request.POST
license = _issue_license(request_form)
target_lang = util.get_target_lang_from_request(request)
def attrib_or_none(field_name):
return request_form.get(field_name, u"").strip() or None
context = xmp_template.get_xmp_info(request_form, license, target_lang)
context["default_lang"] = target_lang
context["work_title"] = attrib_or_none("field_worktitle")
context["attrib_name"] = attrib_or_none("field_attribute_to_name")
context["attrib_url"] = attrib_or_none("field_attribute_to_url")
context["permissions_url"] = attrib_or_none("field_morepermissionsurl")
context["licenses"] = [
{"lang": "x-default", "notice": context["notice"]},
{"lang": target_lang, "notice": context["notice"]},
]
del context["notice"]
if target_lang != "en":
xmp_info_en = xmp_template.get_xmp_info(request_form, license, "en")
context["licenses"].append({"lang": "en", "notice": xmp_info_en["notice"]})
xmp_data = util.render_template(request, target_lang, "chooser_pages/metadata.xmp", context)
return Response(
xmp_data,
content_type="application/xmp; charset=UTF-8",
charset="UTF-8",
content_disposition='attachment; filename="CC_%s.xmp' % (license.title().strip().replace(" ", "_")),
)
def classic_chooser_view(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
gettext = context["gettext"]
available_jurisdiction_codes = [j.code for j in get_selector_jurisdictions("standard") if j.code != ""]
requested_jurisdiction = None
if request.GET.has_key("jurisdiction") and request.GET["jurisdiction"] in available_jurisdiction_codes:
requested_jurisdiction = request.GET["jurisdiction"]
# Sort the jurisdictions for the dropdown via the translated name
jurisdictions_names = [(juris, gettext(mappers.COUNTRY_MAP[juris])) for juris in available_jurisdiction_codes]
jurisdictions_names = sorted(jurisdictions_names, key=lambda juris: juris[1])
show_jurisdiction = request.GET.get("jurisdiction_choose") == "1"
context.update(
{
"jurisdictions_names": jurisdictions_names,
"show_jurisdiction": show_jurisdiction,
"requested_jurisdiction": requested_jurisdiction,
"referrer": request.headers.get("REFERER", ""),
"page_style": "2cols",
}
)
if request.GET.get("partner"):
context["pd_get_params"] = util.publicdomain_partner_get_params(request.GET)
return Response(util.render_template(request, target_lang, "chooser_pages/partner/index.html", context))
else:
return Response(util.render_template(request, target_lang, "chooser_pages/classic_chooser.html", context))
def license_catcher(request):
"""
If someone chooses something like /licenses/by/ (fails to select a
version, etc) help point them to the available licenses.
"""
target_lang = util.get_target_lang_from_request(request)
license_versions = util.catch_license_versions_from_request(request)
if not license_versions:
return exc.HTTPNotFound()
context = {
'request': request,
'license_versions': reversed(license_versions),
'license_class': license_versions[0].license_class,
'page_style': 'bare',
'target_lang': target_lang
}
context.update(util.rtl_context_stuff(target_lang))
# This is a helper page, but it's still for not-found situations.
# 404!
return Response(util.render_template(request, target_lang,
'catalog_pages/license_catcher.html',
context),
status=404)
def pdmark_partner(request):
"""
Partner page for PDM
"""
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
pdm_license = cc.license.by_code('mark')
# Used for recommending CC0 in case that's more appropriate
get_params = util.publicdomain_partner_get_params(request_form)
context = _base_context(request, target_lang)
context.update({
'request_form':
request_form,
'get_params':
get_params,
'exit_url':
_generate_exit_url(request_form.get('exit_url', ''),
request_form.get('referrer', ''), pdm_license)
})
return util.render_to_response(request, target_lang,
'chooser_pages/pdmark/partner.html',
context)
def cc0_landing(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
return util.render_to_response(
request, target_lang,
'chooser_pages/zero/index.html', context)
def pick_lang(langs=[], form_lang=None):
"""Shorthand helper function thing."""
environ = {"REQUEST_METHOD": "GET", "PATH_INFO": "/", "HTTP_ACCEPT_LANGUAGE": ", ".join(langs)}
if form_lang:
environ["QUERY_STRING"] = "lang=" + form_lang
req = Request(environ)
req.matchdict = {}
return util.get_target_lang_from_request(req, default_locale="default")
def cc0_waiver(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
context['country_list'] = CODE_COUNTRY_LIST
return util.render_to_response(request, target_lang,
'chooser_pages/zero/waiver.html', context)
def choose_results_view(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
request_form = request.GET or request.POST
# Special case: if anyone is linking to GPL/LGPL (mistake on old
# deeds), redirect them to gnu.org
if request_form.get('license_code') in ("GPL", "LGPL"):
return exc.HTTPMovedPermanently(
location='http://www.gnu.org/licenses/gpl-howto.html')
# Select a license based on the request form
license = _issue_license(request_form)
# If the request didn't have all the required information, we have no license
if not license:
return exc.HTTPBadRequest(
'Could not determine license from parameters.')
# If the license is retired, redirect to info page
if license.deprecated:
# Special case: PDCC should redirect to /publicdomain/
if license.license_code == 'publicdomain':
return exc.HTTPMovedPermanently(location="/publicdomain/")
else:
return exc.HTTPMovedPermanently(location="/retiredlicenses")
# Generate the HTML+RDFa for the license + provided work information
work_dict = _formatter_work_dict(request_form)
license_slim_logo = license.logo_method('80x15')
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
context.update({
'license': license,
'license_slim_logo': license_slim_logo,
'license_title': license.title(target_lang),
'license_html': license_html
})
if request.GET.get('partner'):
context.update({
'exit_url':
_generate_exit_url(request_form.get('exit_url', ''),
request_form.get('referrer', ''), license)
})
if request.GET.get('partner'):
return Response(
util.render_template(request, target_lang,
'chooser_pages/partner/results.html',
context))
else:
return Response(
util.render_template(request, target_lang,
'chooser_pages/results.html', context))
def cc0_confirm(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
context = _base_context(request, target_lang)
context['request_form'] = request_form
return util.render_to_response(request, target_lang,
'chooser_pages/zero/confirm.html', context)
def pdmark_landing(request):
"""
Landing page for the Public Domain Mark chooser.
"""
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
return util.render_to_response(request, target_lang,
'chooser_pages/pdmark/index.html', context)
def _base_context(request, target_lang=None):
context = {
'request': request,
'target_lang': (target_lang
or util.get_target_lang_from_request(request)),
'gettext': ugettext_for_locale(target_lang),
'active_languages': get_well_translated_langs(),
}
context.update(util.rtl_context_stuff(target_lang))
return context
def get_html(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
license = _issue_license(request_form)
work_dict = _formatter_work_dict(request_form)
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
return Response(license_html,
content_type='text/html; charset=UTF-8',
charset='UTF-8')
def pdmark_details(request):
"""
Details/user form page for the Public Domain Mark chooser.
"""
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
return util.render_to_response(request, target_lang,
'chooser_pages/pdmark/details.html',
context)
def publicdomain_confirm(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
context = _base_context(request, target_lang)
context['request_form'] = request_form
return Response(
util.render_template(request, target_lang,
'chooser_pages/publicdomain/publicdomain-3.html',
context))
def pick_lang(langs=[], form_lang=None):
"""Shorthand helper function thing."""
environ = {
"REQUEST_METHOD": "GET",
"PATH_INFO": "/",
"HTTP_ACCEPT_LANGUAGE": ", ".join(langs),
}
if form_lang:
environ["QUERY_STRING"] = "lang=" + form_lang
req = Request(environ)
req.matchdict = {}
return util.get_target_lang_from_request(req, default_locale='default')
def characteristic_view(request):
"""
Return one of the characteristic description pages.
"""
target_lang = util.get_target_lang_from_request(request)
template_name = 'characteristic/%s.html' % (
request.matchdict['characteristic'])
context = {'request': request}
context.update(util.rtl_context_stuff(target_lang))
return Response(
util.render_template(request, target_lang, template_name, context))
def work_email_popup(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
license = _issue_license(request_form)
work_dict = _formatter_work_dict(request_form)
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
context = _base_context(request, target_lang)
context.update({'license': license, 'license_html': license_html})
return util.render_to_response(request, target_lang,
'chooser_pages/htmlpopup.html', context)
def licenses_view(request):
target_lang = util.get_target_lang_from_request(request)
context = {
'active_languages': get_well_translated_langs(),
'page_style': "bare"
}
context.update(util.rtl_context_stuff(target_lang))
# Don't cache the response for internationalization reasons
response = Response(
util.render_template(request, target_lang,
'catalog_pages/licenses-index.html', context))
response.headers.add('Cache-Control', 'no-cache')
return response
def non_web_popup(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
license = _issue_license(request_form)
is_publicdomain = request_form.get('publicdomain') or request_form.get(
'pd')
context = _base_context(request, target_lang)
context.update({'license': license, 'is_publicdomain': is_publicdomain})
return util.render_to_response(request, target_lang,
'chooser_pages/nonweb_popup.html', context)
def work_email_send(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
email_addr = request_form.get('to_email', '')
license_name = request_form.get('license_name')
license_html = request_form.get('license_html')
util.send_license_info_email(license_name, license_html, email_addr,
target_lang)
context = _base_context(request, target_lang)
context['request_form'] = request_form
return util.render_to_response(request, target_lang,
'chooser_pages/emailhtml.html', context)
def cc0_results(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
## Do we confirm, understand and accept the conditions of cc0?
confirm = request_form.get('confirm', False)
understand = request_form.get('understand', False)
accept = request_form.get('waiver-affirm', False) and \
request_form.get('waiver-decline', True)
can_issue = (confirm and understand and accept)
## RDFA generation
cc0_license = cc.license.by_code('CC0')
license_html = CC0_HTML_FORMATTER.format(cc0_license, request_form,
target_lang).strip()
## Did the user request an email?
email_addr = request_form.get('email')
successful_send = False
if email_addr and request.method == 'POST':
successful_send = util.send_license_info_email(
cc0_license.title(target_lang), license_html, email_addr,
target_lang)
context = _base_context(request, target_lang)
context.update({
'request_form':
request_form,
'can_issue':
can_issue,
'rdfa':
license_html,
'email_requested':
bool(email_addr),
'email_addr':
email_addr,
'requested_send_updates':
request_form.get('send_updates', False),
'successful_send':
successful_send
})
return util.render_to_response(request, target_lang,
'chooser_pages/zero/results.html', context)
def test_get_target_lang_from_request():
def pick_lang(langs=[], form_lang=None):
"""Shorthand helper function thing."""
environ = {
"REQUEST_METHOD": "GET",
"PATH_INFO": "/",
"HTTP_ACCEPT_LANGUAGE": ", ".join(langs),
}
if form_lang:
environ["QUERY_STRING"] = "lang=" + form_lang
req = Request(environ)
req.matchdict = {}
return util.get_target_lang_from_request(req, default_locale='default')
# don't crash when the environment variables are blank
req = Request.blank("/")
lang = util.get_target_lang_from_request(req, default_locale='default')
assert lang == 'default'
# default language case
assert pick_lang() == 'default'
# amurican english
assert pick_lang(['en-us', 'en']) == 'en_US'
# spanish
assert pick_lang(['es']) == 'es'
# http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
assert pick_lang(['da, en-gb;q=0.8, en;q=0.7']) == 'da'
# moar english
assert pick_lang(['en-bs']) == 'en'
# bs
assert pick_lang(['total_bs_locale']) == 'default'
# lower upper
assert pick_lang(['es_ES']) == 'es_ES'
# lower lower
assert pick_lang(['es-es']) == 'es_ES'
# specific language request
assert pick_lang(['es', 'el'], form_lang='jp') == 'jp'
def classic_chooser_view(request):
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
gettext = context['gettext']
available_jurisdiction_codes = [
j.code for j in get_selector_jurisdictions('standard') if j.code != ''
]
requested_jurisdiction = None
if request.GET.has_key('jurisdiction') and \
request.GET['jurisdiction'] in available_jurisdiction_codes:
requested_jurisdiction = request.GET['jurisdiction']
# Sort the jurisdictions for the dropdown via the translated name
jurisdictions_names = [(juris, gettext(mappers.COUNTRY_MAP[juris]))
for juris in available_jurisdiction_codes]
jurisdictions_names = sorted(jurisdictions_names,
key=lambda juris: juris[1])
show_jurisdiction = request.GET.get('jurisdiction_choose') == '1'
context.update({
'jurisdictions_names': jurisdictions_names,
'show_jurisdiction': show_jurisdiction,
'requested_jurisdiction': requested_jurisdiction,
'referrer': request.headers.get('REFERER', ''),
'page_style': '2cols'
})
if request.GET.get('partner'):
context['pd_get_params'] = util.publicdomain_partner_get_params(
request.GET)
return Response(
util.render_template(request, target_lang,
'chooser_pages/partner/index.html', context))
else:
return Response(
util.render_template(request, target_lang,
'chooser_pages/classic_chooser.html',
context))
def pdmark_results(request):
"""
Results page for the Public Domain Mark chooser.
Includes the user's RDFa copy-paste html.
Also handles email sending if the user requests it.
"""
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
## RDFA generation
license = cc.license.by_code('mark')
license_html = PDMARK_HTML_FORMATTER.format(license, request_form,
target_lang).strip()
## Did the user request an email?
email_addr = request_form.get('email')
successful_send = False
if email_addr and request.method == 'POST':
successful_send = util.send_license_info_email(
license.title(target_lang), license_html, email_addr, target_lang)
context = _base_context(request, target_lang)
context.update({
'request_form':
request_form,
'rdfa':
license_html,
'email_requested':
bool(email_addr),
'email_addr':
email_addr,
'successful_send':
successful_send,
'requested_send_updates':
request_form.get('send_updates', False)
})
return util.render_to_response(request, target_lang,
'chooser_pages/pdmark/results.html',
context)
def choose_xmp_view(request):
request_form = request.GET or request.POST
license = _issue_license(request_form)
target_lang = util.get_target_lang_from_request(request)
def attrib_or_none(field_name):
return request_form.get(field_name, u'').strip() or None
context = xmp_template.get_xmp_info(request_form, license, target_lang)
context["default_lang"] = target_lang
context["work_title"] = attrib_or_none("field_worktitle")
context["attrib_name"] = attrib_or_none("field_attribute_to_name")
context["attrib_url"] = attrib_or_none("field_attribute_to_url")
context["permissions_url"] = attrib_or_none("field_morepermissionsurl")
context["licenses"] = [{
"lang": "x-default",
"notice": context["notice"]
}, {
"lang": target_lang,
"notice": context["notice"]
}]
del context["notice"]
if target_lang != 'en':
xmp_info_en = xmp_template.get_xmp_info(request_form, license, 'en')
context["licenses"].append({
"lang": 'en',
"notice": xmp_info_en["notice"]
})
xmp_data = util.render_template(request, target_lang,
'chooser_pages/metadata.xmp', context)
return Response(xmp_data,
content_type='application/xmp; charset=UTF-8',
charset='UTF-8',
content_disposition='attachment; filename="CC_%s.xmp' %
(license.title().strip().replace(' ', '_')))
def publicdomain_result(request):
target_lang = util.get_target_lang_from_request(request)
request_form = request.GET or request.POST
# make sure the user selected "confirm"
if request_form.get('understand', False) != 'confirm':
return exc.HTTPFound(location='%s?%s' %
('./publicdomain-3', urlencode(request.GET)))
work_info = _work_info(request_form)
license_html = PUBLICDOMAIN_HTML_FORMATTER.format(
cc.license.by_code('publicdomain'), work_info, target_lang)
context = _base_context(request, target_lang)
context.update({
'request_form': request_form,
'license_html': license_html
})
return Response(
util.render_template(request, target_lang,
'chooser_pages/publicdomain/publicdomain-4.html',
context))
def publicdomain_view(request):
target_lang = util.get_target_lang_from_request(request)
return util.render_to_response(request, target_lang,
'publicdomain/index.html', {})
def chooser_view(request):
# Preserve the old partner interface by calling the old chooser view..
if request.GET.get('partner'):
return classic_chooser_view(request)
#
# Used by the new-style chooser demos, for now.
#
target_lang = util.get_target_lang_from_request(request)
context = _base_context(request, target_lang)
request_form = request.GET or request.POST
gettext = context['gettext']
available_jurisdiction_codes = [
j.code for j in get_selector_jurisdictions('standard') if j.code != ''
]
requested_jurisdiction = None
if request.GET.has_key('jurisdiction') and \
request.GET['jurisdiction'] in available_jurisdiction_codes:
requested_jurisdiction = request.GET['jurisdiction']
# Sort the jurisdictions for the dropdown via the translated name
jurisdictions_names = [(juris, gettext(mappers.COUNTRY_MAP[juris]))
for juris in available_jurisdiction_codes]
jurisdictions_names = sorted(jurisdictions_names,
key=lambda juris: juris[1])
show_jurisdiction = request.GET.get('jurisdiction_choose') == '1'
# Select a license based on the request form
license = _issue_license(request_form)
# Sets form default values, based on the request form or lack thereof
defaults = {
"license": {
"nc": False,
"sa": False,
"nd": False,
"jurisdiction": "",
"currency": "",
},
"meta": {
"standard": "html+rdfa",
"format": "",
"title": "",
"attrib_name": "",
"attrib_url": "",
"src_url": "",
"permissions": "",
},
"out": {
"format": "html",
"badge": "normal",
},
"misc": {
"lang": "",
}
}
def equal_or_default(field, value, default=False):
if request_form.has_key(field):
return request_form[field] == value
else:
return default
def value_or_default(field, default=""):
if request_form.has_key(field):
return unquote(request_form[field]).encode("utf-8")
else:
return default
if request_form:
defaults["license"] = {
"nc": equal_or_default('field_commercial', u'n'),
"sa": equal_or_default('field_derivatives', u'sa'),
"nd": equal_or_default('field_derivatives', u'n'),
"jurisdiction": value_or_default('field_jurisdiction'),
"currency": util.currency_symbol_from_request_form(request_form),
}
defaults["meta"] = {
"standard": value_or_default("field_metadata_standard",
"html+rdfa"),
"format": value_or_default("field_format"),
"title": value_or_default("field_worktitle"),
"attrib_name": value_or_default("field_attribute_to_name"),
"attrib_url": value_or_default("field_attribute_to_url"),
"src_url": value_or_default("field_sourceurl"),
"permissions": value_or_default("field_morepermissionsurl"),
}
defaults["out"]["badge"] = value_or_default("field_iconsize", "normal")
defaults["misc"] = {
"lang": value_or_default("lang", ""),
}
# If the license is retired, redirect to info page
if license.deprecated:
# Special case: PDCC should redirect to /publicdomain/
if license.license_code == 'publicdomain':
return exc.HTTPMovedPermanently(location="/publicdomain/")
else:
return exc.HTTPMovedPermanently(location="/retiredlicenses")
# Generate the HTML+RDFa for the license + provided work information
work_dict = _formatter_work_dict(request_form)
license_norm_logo = license.logo_method('88x13')
license_slim_logo = license.logo_method('80x15')
picked_logo = {
"normal": license_norm_logo,
"small": license_slim_logo
}[defaults['out']['badge']]
license_html = HTML_FORMATTER.format(license, work_dict, target_lang)
if defaults['out']['badge'] == u"small":
license_html = license_html.replace("88x31.png", "80x15.png")
def has_code(code):
return license.license_code.count(code) >= 1
context.update({
'jurisdictions_names':
jurisdictions_names,
'show_jurisdiction':
show_jurisdiction,
'requested_jurisdiction':
requested_jurisdiction,
'referrer':
request.headers.get('REFERER', ''),
'page_style':
'2cols',
'last_query':
request.query_string,
'form':
defaults,
'currency':
util.currency_symbol_from_request_form(request_form),
'license':
license,
'license_logo':
picked_logo,
'license_norm_logo':
license_norm_logo,
'license_slim_logo':
license_slim_logo,
'license_title':
license.title(target_lang),
'license_html':
license_html,
'license_code': {
'sa': has_code('sa'),
'nc': has_code('nc'),
'nd': has_code('nd'),
},
})
return Response(
util.render_template(request, target_lang,
'chooser_pages/interactive_chooser.html',
context))
