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))