def display_facet(context, flt, facet, type): facet = annotate_tags([dict(name=f[0], count=f[1]) for f in facet if f[0] != "0"], sort=True, small_size=0.7, large_size=2.0) # If the filter is grouping_pack and there are elements which do not contain the character "_" means that # these sounds do not belong to any pack (as grouping pack values should by "packId_packName" if there is a pack # or "soundId" if there is no pack assigned. We did this to be able to filter properly in the facets, as pack names # are not unique!. What we do then is filter out the facet elements where, only for the case of grouping_pack, # the element name is a single number that does not contain the character "_" filter_query = context['filter_query'] filtered_facet = [] for element in facet: if flt == "grouping_pack": if element['name'].count("_") > 0: # We also modify the dispay name to remove the id element['display_name'] = element['name'][element['name'].find("_")+1:] element['params'] = '%s %s:"%s"' % (filter_query, flt, urlquote_plus(element['name'])) filtered_facet.append(element) else: element['display_name'] = element['name'] element['params'] = '%s %s:"%s"' % (filter_query, flt, urlquote_plus(element['name'])) filtered_facet.append(element) context.update({"facet": filtered_facet, "type": type, "filter": flt}) return context
def get_url(self, query=None): """Get an URL from the query""" url = self.template if url.startswith(SEARCH_IN_PREFIX): url = url[len(SEARCH_IN_PREFIX):] url = SEARCH_IN_TEMPLATE.replace('{site}', urlquote_plus(url)) return url.replace('{q}', urlquote_plus(query) if query else '')
def _register_course_home_messages(request, course, user_access, course_start_data): """ Register messages to be shown in the course home content page. """ if user_access['is_anonymous']: CourseHomeMessages.register_info_message( request, Text(_( '{sign_in_link} or {register_link} and then enroll in this course.' )).format( sign_in_link=HTML('<a href="/login?next={current_url}">{sign_in_label}</a>').format( sign_in_label=_('Sign in'), current_url=urlquote_plus(request.path), ), register_link=HTML('<a href="/register?next={current_url}">{register_label}</a>').format( register_label=_('register'), current_url=urlquote_plus(request.path), ) ), title=Text(_('You must be enrolled in the course to see course content.')) ) if not user_access['is_anonymous'] and not user_access['is_staff'] and not user_access['is_enrolled']: CourseHomeMessages.register_info_message( request, Text(_( '{open_enroll_link}Enroll now{close_enroll_link} to access the full course.' )).format( open_enroll_link='', close_enroll_link='' ), title=Text(_('Welcome to {course_display_name}')).format( course_display_name=course.display_name ) )
def create_share(self, obj): share = Utils.create_object() share.title = obj.logo_title share.description = obj.short_description share.url = Utils.get_current_url(self.request) encoded_url = urlquote_plus(share.url) title = obj.logo_title encoded_title = urlquote_plus(title) encoded_detail = urlquote_plus(obj.short_description) url_detail = obj.short_description + '\n\n' + share.url encoded_url_detail = urlquote_plus(url_detail) share.image_url = Utils.get_url( self.request, PosterService.poster_image_url(obj) ) encoded_image_url = urlquote_plus(share.image_url) # email shouldn't encode space share.email = 'subject=%s&body=%s' % ( urlquote(title, ''), urlquote(url_detail, '') ) # share.fb = 'u=%s' % encoded_url # share.twitter = 'text=%s' % encoded_url_detail # share.google_plus = 'url=%s' % encoded_url # share.linkedin = 'url=%s&title=%s&summary=%s' % ( encoded_url, encoded_title, encoded_detail ) # share.pinterest = 'url=%s&media=%s&description=%s' % ( encoded_url, encoded_image_url, encoded_detail ) return share
def chunk_edit(request, slug, chunk): try: doc = Chunk.get(slug, chunk) except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist): raise Http404 if not doc.book.accessible(request): return HttpResponseForbidden("Not authorized.") if request.method == "POST": form = forms.ChunkForm(request.POST, instance=doc) if form.is_valid(): form.save() go_next = request.GET.get('next', None) if go_next: go_next = urlquote_plus(unquote(iri_to_uri(go_next)), safe='/?=&') else: go_next = doc.book.get_absolute_url() return http.HttpResponseRedirect(go_next) else: form = forms.ChunkForm(instance=doc) referer = request.META.get('HTTP_REFERER') if referer: parts = urlsplit(referer) parts = ['', ''] + list(parts[2:]) go_next = urlquote_plus(urlunsplit(parts)) else: go_next = '' return render(request, "catalogue/chunk_edit.html", { "chunk": doc, "form": form, "go_next": go_next, })
def create_binaries_query(self, source, version): if re.match("^[-a-zA-Z0-9+.]+$", source) is None: raise SPARQLQueryBuilderPackageNameSchemeError() self.binary_search = lambda: True # Kind of a hack :/ self._add_base_elements() sourceuri = "%s/source/%s/%s" % (RES_BASEURI, urlquote_plus(source), urlquote_plus(version)) self.helper.add_filter_regex_str_var(Variable("source"), sourceuri) return self.helper.__str__()
def configuration_context(request): # pylint: disable=unused-argument """ Configuration context for django templates. """ return { 'platform_name': configuration_helpers.get_value('platform_name', settings.PLATFORM_NAME), 'current_url': urlquote_plus(request.build_absolute_uri(request.path)), 'current_site_url': urlquote_plus(request.build_absolute_uri('/')), }
def z3988(self): contextObj = ['ctx_ver=Z39.88-2004'] current_site = Site.objects.get_current() rfr_id = current_site.domain.split('.') if len(rfr_id) > 2: rfr_id = rfr_id[-2] elif len(rfr_id) > 1: rfr_id = rfr_id[0] else: rfr_id = '' if self.book_title and not self.journal: contextObj.append('rft_val_fmt=info:ofi/fmt:kev:mtx:book') contextObj.append('rfr_id=info:sid/' + current_site.domain + ':' + rfr_id) contextObj.append('rft_id=' + urlquote_plus(self.doi)) contextObj.append('rft.btitle=' + urlquote_plus(self.title)) if self.publisher: contextObj.append('rft.pub=' + urlquote_plus(self.publisher)) else: contextObj.append('rft_val_fmt=info:ofi/fmt:kev:mtx:journal') contextObj.append('rfr_id=info:sid/' + current_site.domain + ':' + rfr_id) contextObj.append('rft_id=' + urlquote_plus(self.doi)) contextObj.append('rft.atitle=' + urlquote_plus(self.title)) if self.journal: contextObj.append('rft.jtitle=' + urlquote_plus(self.journal)) if self.volume: contextObj.append('rft.volume={0}'.format(self.volume)) if self.pages: contextObj.append('rft.pages=' + urlquote_plus(self.pages)) if self.number: contextObj.append('rft.issue={0}'.format(self.number)) if self.month: contextObj.append('rft.date={0}-{1}-1'.format(self.year, self.month)) else: contextObj.append('rft.date={0}'.format(self.year)) for author in self.authors_list: contextObj.append('rft.au=' + urlquote_plus(author)) if self.isbn: contextObj.append('rft.isbn=' + urlquote_plus(self.isbn)) if self.issn: contextObj.append('rft.issn=' + urlquote_plus(self.issn)) return '&'.join(contextObj)
def test_urlquote(self): self.assertEqual(http.urlquote('Paris & Orl\xe9ans'), 'Paris%20%26%20Orl%C3%A9ans') self.assertEqual(http.urlquote('Paris & Orl\xe9ans', safe="&"), 'Paris%20&%20Orl%C3%A9ans') self.assertEqual(http.urlunquote('Paris%20%26%20Orl%C3%A9ans'), 'Paris & Orl\xe9ans') self.assertEqual(http.urlunquote('Paris%20&%20Orl%C3%A9ans'), 'Paris & Orl\xe9ans') self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans'), 'Paris+%26+Orl%C3%A9ans') self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans', safe="&"), 'Paris+&+Orl%C3%A9ans') self.assertEqual(http.urlunquote_plus('Paris+%26+Orl%C3%A9ans'), 'Paris & Orl\xe9ans') self.assertEqual(http.urlunquote_plus('Paris+&+Orl%C3%A9ans'), 'Paris & Orl\xe9ans')
def quiz_subscribe(request): subscribe_form = forms.MultiServiceSubscribeForm(request.POST) if subscribe_form.is_valid(): name = subscribe_form.cleaned_data['name'] email = subscribe_form.cleaned_data['email'] postcode = subscribe_form.cleaned_data['postcode'] post_election_signup = PostElectionSignup( name = name, email = email, postcode = postcode, theyworkforyou = subscribe_form.cleaned_data['twfy_signup'], hearfromyourmp = subscribe_form.cleaned_data['hfymp_signup'], ) post_election_signup.put() if subscribe_form.cleaned_data['democlub_signup']: (first_name, space, last_name) = name.partition(" ") fields = { 'first_name' : first_name, 'last_name' : last_name, 'email' : email, 'postcode' : postcode } form_data = urllib.urlencode(fields) result = urlfetch.fetch(url = "http://www.democracyclub.org.uk", payload = form_data, method = urlfetch.POST) if result.status_code != 200: pass #raise Exception("Error posting to DemocracyClub") candidacy_without_response_count = request.POST.get('candidacy_without_response_count',0) seat = forms._postcode_to_constituency(postcode) democlub_redirect = subscribe_form.cleaned_data['democlub_redirect'] if democlub_redirect: democlub_hassle_url = seat.democracyclub_url() + "?email=%s&postcode=%s&name=%s" % ( urlquote_plus(email), urlquote_plus(postcode), urlquote_plus(name) ) return HttpResponseRedirect(democlub_hassle_url) # For later when we have form even if have got all candidates answers return render_to_response('quiz_subscribe_thanks.html', { 'twfy_signup': subscribe_form.cleaned_data['twfy_signup'], 'hfymp_signup': subscribe_form.cleaned_data['hfymp_signup'], 'democlub_signup': subscribe_form.cleaned_data['democlub_signup'], 'seat': seat, 'email': email, 'urlise_postcode': forms._urlise_postcode(postcode), 'name': name, 'candidacy_without_response_count':candidacy_without_response_count } ) return render_to_response('quiz_subscribe.html', { 'subscribe_form' : subscribe_form })
def google_calendarize(event): """ <a href="http://www.google.com/calendar/event? action=TEMPLATE &text=[event-title] &dates=[start-custom format='Ymd\\THi00\\Z']/[end-custom format='Ymd\\THi00\\Z'] &ctz=America/New_York &details=[description] &location=[location] &trp=false &sprop= &sprop=name:" target="_blank" rel="nofollow">Add to Google Calendar</a> https://developers.google.com/google-apps/calendar/v3/reference/events/insert """ not_valid = not len(event) not_valid &= event['status'] != 'upcoming' if not_valid: return "" start = event['timestamp'] end = start + timedelta(hours=EVENT_DURATION) tfmt = '%Y%m%dT000000' tfmt = "YYYYmMd\\THimm\\Z" # parameters params = OrderedDict() params['action'] = 'TEMPLATE' params['title'] = urlquote_plus(event['name']) # params['dates'] = "{}/{}".format(start.format(tfmt),end.format(tfmt)) params['ctz'] = start.tzinfo params['details'] = urlquote_plus(event['description']) if 'venue' in event: venue = event['venue'] location = [venue.get(key,"") for key in ('name','city','address_1')] params['location'] = urlquote_plus(", ".join(location)) params['trp'] = 'False' # properties sprop = OrderedDict() # sprop["name"] = "hello+world" # sprop['website'] = urlquote_plus(Site.objects.get_current().domain) # create link link = ["{}={}".format(k,params[k]) for k in params] for k in sprop: link.append("sprop={}:{}".format(k,sprop[k])) link = "http://www.google.com/calendar/event?"+"&".join(link) return link
def test_urlquote(self): self.assertEquals(urlquote(u'Paris & Orl\xe9ans'), u'Paris%20%26%20Orl%C3%A9ans') self.assertEquals(urlquote(u'Paris & Orl\xe9ans', safe="&"), u'Paris%20&%20Orl%C3%A9ans') self.assertEquals(urlquote_plus(u'Paris & Orl\xe9ans'), u'Paris+%26+Orl%C3%A9ans') self.assertEquals(urlquote_plus(u'Paris & Orl\xe9ans', safe="&"), u'Paris+&+Orl%C3%A9ans')
def _register_course_home_messages(request, course, user_access, course_start_data): """ Register messages to be shown in the course home content page. """ allow_anonymous = allow_public_access(course, [COURSE_VISIBILITY_PUBLIC]) if user_access['is_anonymous'] and not allow_anonymous: sign_in_or_register_text = (_(u'{sign_in_link} or {register_link} and then enroll in this course.') if not CourseMode.is_masters_only(course.id) else _(u'{sign_in_link} or {register_link}.')) CourseHomeMessages.register_info_message( request, Text(sign_in_or_register_text).format( sign_in_link=HTML(u'<a href="/login?next={current_url}">{sign_in_label}</a>').format( sign_in_label=_('Sign in'), current_url=urlquote_plus(request.path), ), register_link=HTML(u'<a href="/register?next={current_url}">{register_label}</a>').format( register_label=_('register'), current_url=urlquote_plus(request.path), ) ), title=Text(_('You must be enrolled in the course to see course content.')) ) if not user_access['is_anonymous'] and not user_access['is_staff'] and \ not user_access['is_enrolled']: title = Text(_(u'Welcome to {course_display_name}')).format( course_display_name=course.display_name ) if CourseMode.is_masters_only(course.id): # if a course is a Master's only course, we will not offer user ability to self-enroll CourseHomeMessages.register_info_message( request, Text(_('You must be enrolled in the course to see course content. ' 'Please contact your degree administrator or edX Support if you have questions.')), title=title ) elif not course.invitation_only: CourseHomeMessages.register_info_message( request, Text(_( u'{open_enroll_link}Enroll now{close_enroll_link} to access the full course.' )).format( open_enroll_link=HTML('<button class="enroll-btn btn-link">'), close_enroll_link=HTML('</button>') ), title=title ) else: CourseHomeMessages.register_info_message( request, Text(_('You must be enrolled in the course to see course content.')), )
def urlencode(query, doseq=0, safe=''): """Custom urlencode that leaves static map delimiters ("|", ",", ":") alone. Based on Django's unicode-safe version of urllib.quote_plus. """ safe = safe + '|,:' if hasattr(query, 'items'): query = query.items() return '&'.join([urlquote_plus(k, safe) + '=' + urlquote_plus(v, safe) for k, s in query for v in ((isinstance(s, basestring) and [s]) or (doseq and hasattr(s, '__len__') and s) or [s])])
def searchTweets(query): auth = tweepy.BasicAuthHandler('Bot2bud','') api = tweepy.API(auth) result = api.search(query) print result total = [] for r in result : temp = {} temp['from_user_name'] = urlquote_plus(r.from_user.encode('utf-8')).replace ("+"," ").replace("+%23","#").replace("%40","@").replace("%3A","") temp['text'] = urlquote_plus(r.text.encode('utf-8')).replace ("+"," ").replace("%23","#").replace("%40","@").replace("%3A","") print temp['from_user_name'] print temp['text'] total.append(temp) return total
def google_calendarize(evento): st = evento.fecha en = evento.fecha and evento.fecha or evento.fecha tfmt = '%Y%m%dT000000' dates = '%s%s%s' % (st.strftime(tfmt), '%2F', en.strftime(tfmt)) name = str(evento.contacto) + ": " + urlquote_plus(evento.descripcion) s = ('http://www.google.com/calendar/event?action=TEMPLATE&' + 'text=' + name + '&' + 'dates=' + dates + '&' + 'sprop=website:' + urlquote_plus(Site.objects.get_current().domain)) return s + '&trp=false'
def confirmchangepw(request): """ view to set new password when the user click on confirm link in its mail. Basically it check if the confirm key exist, then replace old password with new password and remove confirm ley from the queue. Then it redirect the user to signin page. url : /sendpw/confirm/?key """ logging.debug('') confirm_key = request.GET.get('key', '') if not confirm_key: logging.error('someone called confirm password without a key!') return HttpResponseRedirect(reverse('index')) try: uqueue = UserPasswordQueue.objects.get( confirm_key__exact=confirm_key ) except: msg = _("Could not change password. Confirmation key '%s'\ is not registered." % confirm_key) logging.error(msg) redirect = "%s?msg=%s" % ( reverse('user_sendpw'), urlquote_plus(msg)) return HttpResponseRedirect(redirect) try: user_ = User.objects.get(id=uqueue.user.id) except: msg = _("Can not change password. User don't exist anymore \ in our database.") logging.error(msg) redirect = "%s?msg=%s" % (reverse('user_sendpw'), urlquote_plus(msg)) return HttpResponseRedirect(redirect) user_.set_password(uqueue.new_password) user_.save() uqueue.delete() msg = _("Password changed for %s. You may now sign in." % user_.username) logging.debug(msg) redirect = "%s?msg=%s" % (reverse('user_signin'), urlquote_plus(msg)) return HttpResponseRedirect(redirect)
def get(self, request, *args, **kwargs): if request.GET.get('action','Submit Query') == 'Submit Query': return super(BasicFilterView,self).get(request, *args, **kwargs) else: match = urlresolvers.resolve(request.path_info) # write data into session request.session['new_search'] = { # do the whole magic within a single line (strip empty elements + action, urlencode, creating GET string "parameter" : "&".join(list( "%s=%s" % (urlquote_plus(k),urlquote_plus(v)) for k, v in request.GET.iteritems() if v and k != "action")), "view" : match.url_name, } # Redirect to edit view as this takes care of the rest return HttpResponseRedirect(urlresolvers.reverse('url.dingos.admin.edit.savedsearches'))
def check_language_name(version, ignore_statistic=False): if not ignore_statistic: fetch_count = SubtitleFetchCounters.objects.filter(video=version.language.video, date=date.today()) \ .aggregate(fetch_count=Count('count'))['fetch_count'] if fetch_count < 100: return text = '' for s in version.subtitles(): text += (' '+s.text) if len(text) >= 400: break url = u'https://ajax.googleapis.com/ajax/services/language/detect?v=1.0&q=%s' url = url % urlquote_plus(text) request = urllib2.Request(url, None) response = urllib2.urlopen(request) results = simplejson.load(response) lang = version.language if results['responseStatus'] == 200: if not results['responseData']['isReliable'] or \ (lang.language and lang.language != results['responseData']['language']): send_alarm_email(version, u'Text does not look like language labeled')
def find(self, sourcename): if re.match("^[-a-zA-Z0-9+.]+$", sourcename) is None: raise SPARQLQueryBuilderPackageNameSchemeError() sourcename = urlquote_plus(sourcename) sourceuri = RES_BASEURI + "/source/%s" % sourcename return self._fetch_seealso_uris(sourceuri)
def _find_film(title, imdb_id): """ Tries to find film profile on CSFD. If successful, returns tuple (csfd profile url, BeautifulSoup of the page), otherwise None """ search_url = SEARCH_URL % urlquote_plus(title) search_results = BeautifulSoup(urllib2.urlopen(search_url)) # TODO: we could be redirected directly to the film profile, e.g. "Megamind" films_found = search_results.find(attrs={'id': 'search-films'}) if not films_found: return links = films_found.findAll('a', 'film') if not links: return for link in links: href = link.get('href') if not href: continue url = 'http://www.csfd.cz' + href try: profile_page = BeautifulSoup(urllib2.urlopen(url)) except Exception, e: # TODO: logging print 'csfd parsing error: ', e continue imdb_link = profile_page.find('a', 'imdb') if not imdb_link: continue if imdb_id in imdb_link.get('href', ''): return url, profile_page
def run_test(self, filename, content='Lorem ipsum dolar sit amet'): content = UnicodeContentFile(content) filename = default_storage.save(filename, content) self.assert_(default_storage.exists(filename)) self.assertEqual(default_storage.size(filename), content.size) now = datetime.utcnow() delta = timedelta(minutes=5) mtime = default_storage.getmtime(filename) self.assert_(mtime > mktime((now - delta).timetuple())) self.assert_(mtime < mktime((now + delta).timetuple())) file = default_storage.open(filename) self.assertEqual(file.size, content.size) fileurl = force_unicode(file).replace('\\', '/') fileurl = urlquote_plus(fileurl, '/') if fileurl.startswith('/'): fileurl = fileurl[1:] self.assertEqual( MEDIA_URL+fileurl, default_storage.url(filename) ) file.close() default_storage.delete(filename) self.assert_(not default_storage.exists(filename))
def emailopenid_success(request, identity_url, openid_response): openid_ = from_openid_response(openid_response) user_ = request.user try: uassoc = UserAssociation.objects.get( openid_url__exact=identity_url ) except: return emailopenid_failure(request, _("No openid % associated in our database" % identity_url)) if uassoc.user.username != request.user.username: return emailopenid_failure(request, _("The openid %s isn't associated to current logged user" % identity_url)) new_email = request.session.get('new_email', '') if new_email: user_.email = new_email user_.save() del request.session['new_email'] msg = _("Email Changed.") redirect = "%s?msg=%s" % (reverse('user_account_settings'), urlquote_plus(msg)) return HttpResponseRedirect(redirect)
def changeopenid_success(request, identity_url, openid_response): openid_ = from_openid_response(openid_response) is_exist = True try: uassoc = UserAssociation.objects.get(openid_url__exact=identity_url) except: is_exist = False if not is_exist: try: uassoc = UserAssociation.objects.get(user__username__exact=request.user.username) uassoc.openid_url = identity_url uassoc.save() except: uassoc = UserAssociation(user=request.user, openid_url=identity_url) uassoc.save() elif uassoc.user.username != request.user.username: return changeopenid_failure(request, _("This OpenID is already associated with another account.")) request.session["openids"] = [] request.session["openids"].append(openid_) msg = _("OpenID %s is now associated with your account." % identity_url) redirect = "%s?msg=%s" % (reverse("user_account_settings"), urlquote_plus(msg)) return HttpResponseRedirect(redirect)
def test_sign_in_button(self): """ Verify that the sign in button will return to this page. """ url = course_home_url(self.course) response = self.client.get(url) self.assertContains(response, '/login?next={url}'.format(url=urlquote_plus(url)))
def api_reverse(view_name, kwargs={}, request=None, format=None): """ A special case of URL reversal where we know we're getting an API URL. This can be much faster than Django's built-in general purpose regex resolver. """ if request: url = '{}://{}/api/v2'.format(request.scheme, request.get_host()) else: url = '/api/v2' route_template_strings = { 'submission-detail': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}/{submission_set_name}/{submission_id}', 'submission-list': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}/{submission_set_name}', 'place-detail': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}', 'place-list': '/{owner_username}/datasets/{dataset_slug}/places', 'dataset-detail': '/{owner_username}/datasets/{dataset_slug}', 'user-detail': '/{owner_username}', 'dataset-submission-list': '/{owner_username}/datasets/{dataset_slug}/{submission_set_name}', } try: route_template_string = route_template_strings[view_name] except KeyError: raise ValueError('No API route named {} formatted.'.format(view_name)) url_params = dict([(key, urlquote_plus(val)) for key,val in kwargs.iteritems()]) url += route_template_string.format(**url_params) if format is not None: url += '.' + format return url
def changepw(request): """ change password view. url : /changepw/ template: authopenid/changepw.html """ user_ = request.user if request.POST: form = ChangepwForm(request.POST, user=user_) if form.is_valid(): user_.set_password(form.cleaned_data['password1']) user_.save() msg = _("Password changed.") redirect = "%s?msg=%s" % ( reverse('user_account_settings'), urlquote_plus(msg)) return HttpResponseRedirect(redirect) else: form = ChangepwForm(user=user_) return render('authopenid/changepw.html', {'form': form }, context_instance=RequestContext(request))
def changepw(request): """ change password view. url : /changepw/ template: authopenid/changepw.html """ logging.debug('') user_ = request.user if user_.has_usable_password(): if settings.USE_EXTERNAL_LEGACY_LOGIN == True: return HttpResponseRedirect(reverse('user_external_legacy_login_issues')) else: raise Http404 if request.POST: form = ChangePasswordForm(request.POST, user=user_) if form.is_valid(): user_.set_password(form.cleaned_data['password1']) user_.save() msg = _("Password changed.") redirect = "%s?msg=%s" % ( reverse('user_account_settings'), urlquote_plus(msg)) return HttpResponseRedirect(redirect) else: form = ChangePasswordForm(user=user_) return render_to_response('authopenid/changepw.html', {'form': form }, context_instance=RequestContext(request))
def process_request(self, request): if request.user.is_authenticated() and request.method == 'GET': if (not request.user.first_name) or (not request.user.last_name) or (not request.user.dob): path_ft = reverse('accounts:first_time') path_logout = reverse('accounts:logout') if request.path not in (path_ft, path_logout): return redirect(reverse('accounts:first_time')+"?next="+urlquote_plus(request.get_full_path()))
def object_paging(objects): marker = None if objects and not \ len(objects) < getattr(settings, 'SWIFT_PAGINATE_LIMIT', 10000): last_object = objects[-1] marker = http.urlquote_plus(last_object.name) return {'marker': marker}
def process_request(self, request): if is_public_path(request.path_info): return None if request.user.is_anonymous: return HttpResponseRedirect("%s?next=%s" % ( reverse('login'), urlquote_plus(request.path))) if (not Config.objects.get_config('completed_intro') or not request.user.userprofile.completed_intro): index_path = reverse('index') if (request.path != index_path and request.path != reverse('logout')): return HttpResponseRedirect(index_path)
def get(self, request, *args, **kwargs): def unwhitespace(val): return " ".join(val.split()) if 'ps_q' in request.GET: # Keeping Unicode in URL, replacing space with '+'. query = uri_to_iri(urlquote_plus(unwhitespace(request.GET['ps_q']))) params = {'query': query} if query else None return HttpResponseRedirect(reverse_lazy('search', kwargs=params)) query = kwargs['query'] or '' # Avoiding query=None self.query = unwhitespace(unquote_plus(query)) # Exclude places whose owner blocked unauthenticated viewing. if not request.user.is_authenticated: self.queryset = self.queryset.exclude(owner__pref__public_listing=False) return super().get(request, *args, **kwargs)
def sign_url(request): body = request.query_params if 'title' in body and 'artist_name' in body and 'key' in body: # distrust all user input - we're escaping unsafe characters title = urlquote_plus(body['title']) artist_name = urlquote_plus(body['artist_name']) key = body['key'] file_extension = os.path.splitext(key)[1] # prepare the responses content disposition header content_disposition_header = 'inline; filename={}-{}'.format( title, artist_name) # if the file to download actually has an extension, we're appending it # to the Content-Disposition header content_disposition_header += file_extension or '.file' # and request a presigned url from S3, so that the user is allowed # to download the renamed file conn = get_client() presigned_key = conn.generate_url( settings.AWS_PRESIGNED_URL_EXPIRY_TIME, 'GET', settings.AWS_STORAGE_BUCKET_NAME, key, response_headers={ 'response-content-disposition': content_disposition_header }, ) presigned_key = presigned_key.replace( 'https://{}/'.format(settings.AWS_BUCKET_DOMAIN), '') signed_url = '{}/{}'.format(get_host(secure=True), presigned_key) return Response({'signed_url': signed_url}, status=status.HTTP_200_OK) else: return Response(status=status.HTTP_400_BAD_REQUEST)
def calendar_url(context, action, service): def action_desc(action, full_url): desc = markdownify(strip_tags(action.description)) desc = Truncator(desc).words(30, html=True, truncate=' …') desc += f"<p><br><a href=\"{full_url}\">Full Event Details</a></p>" desc = urlquote_plus(desc) return desc def action_loc(action): href = HrefExtractor(action.location_link).href return urlquote_plus(href) def action_times(action, tfmt): action_start = action.when start = action_start.strftime(tfmt) end = (action_start + timedelta(hours=1)).strftime(tfmt) return (start, end) request = context['request'] abs_url = request.build_absolute_uri(action.get_absolute_url()) title = urlquote_plus(action.html_title) desc = action_desc(action, abs_url) location = action_loc(action) # Outlook and office live: #https://outlook.live.com/calendar/0/deeplink/compose?body=Join%20me%20for%20an%20incredible%20experience%2C%20etc.&enddt=2021-10-28T12%3A45%3A00%2B00%3A00&location=zoom&path=%2Fcalendar%2Faction%2Fcompose&rru=addevent&startdt=2021-10-28T12%3A15%3A00%2B00%3A00&subject=My%20amazing%20event #https://outlook.office.com/calendar/0/deeplink/compose?body=Join%20me%20for%20an%20incredible%20experience%2C%20etc.&enddt=2021-10-28T12%3A45%3A00%2B00%3A00&location=zoom&path=%2Fcalendar%2Faction%2Fcompose&rru=addevent&startdt=2021-10-28T12%3A15%3A00%2B00%3A00&subject=My%20amazing%20event if service == "Google": start, end = action_times(action, '%Y%m%dT%H%M00Z') dates = urlquote_plus(f"{start}/{end}") url = f"https://calendar.google.com/calendar/render?action=TEMPLATE&dates={dates}&location={location}&text={title}&details={desc}" return mark_safe(url) elif service == "Yahoo": start, end = action_times(action, '%Y%m%dT%H%M00Z') return f"https://calendar.yahoo.com/?v=60&view=d&type=20&title={title}&st={start}&dur=0100&desc={desc}&in_loc={location}&url={abs_url}" else: return f"/action/ics/{action.slug}"
def curation_add(request, object_id, template_name='depot/curation_edit.html'): """docstring for curation_add""" resource = get_one_or_404(Resource, id=ObjectId(object_id)) user = get_account(request.user.id) curation = get_curation_for_acct_resource(user, resource) if curation: index, cur = curation messages.warning( request, 'You already have a curation for this resource- you can edit it if you need to make changes.' ) return HttpResponseRedirect( reverse('curation', args=[resource.id, index])) if request.method == 'POST': result = request.POST.get('result', '') next = request.GET.get('next', '') if next: url = '%s#res_%s' % (next, resource.id) else: url = '' if result == 'Cancel': return HttpResponseRedirect( url or reverse('resource', args=[resource.id])) form = CurationForm(request.POST) if form.is_valid(request.user): curation = Curation(**form.cleaned_data) curation.owner = user curation.item_metadata.update(author=user) add_curation(resource, curation) # TODO: move this into resource.add_curation increment_resource_crud('curation_add', account=user) index = len(resource.curations) - 1 return HttpResponseRedirect( url or reverse('curation', args=[resource.id, index])) else: initial = {'outcome': STATUS_OK} form = CurationForm(initial=initial) template_context = { 'next': urlquote_plus(request.GET.get('next', '')), 'form': form, 'resource': resource, 'new': True } return render_to_response(template_name, template_context, RequestContext(request))
def get(self, request, *args, **kwargs): if 'ps_q' in request.GET: # Keeping Unicode in URL, replacing space with '+' query = uri_to_iri(urlquote_plus(request.GET['ps_q'])) params = {'query': query} if query else None return HttpResponseRedirect(reverse_lazy('search', kwargs=params)) query = kwargs['query'] or '' # Avoiding query=None self.query = unquote_plus(query) if self.query: try: geocoder = geopy.geocoders.OpenCage(settings.OPENCAGE_KEY, timeout=5) self.locations = geocoder.geocode(self.query, language=lang, exactly_one=False) except (GeocoderTimedOut, GeocoderServiceError) as e: self.locations = [] return super(SearchView, self).get(request, *args, **kwargs)
def google_calendarize(event): st = event.start en = event.end tfmt = '%Y%m%dT%H%M%S' dates = '%s%s%s' % (st.strftime(tfmt), '%2F', en.strftime(tfmt)) name = urlquote_plus(event.activity.name + ' - siłownia MUSCLES') s = ('http://www.google.com/calendar/event?action=TEMPLATE&' + 'text=' + name + '&' + 'dates=' + dates + '&' + 'sprop=website:' + urlquote_plus(Site.objects.get_current().domain)) if event.gym.no_local: temp = urlquote_plus(event.gym.city + ', ' + event.gym.street + ' ' + event.gym.no_building + '/' + event.gym.no_local) else: temp = urlquote_plus(event.gym.city + ', ' + event.gym.street + ' ' + event.gym.no_building) #s = s + '&location=' + urlquote_plus(event.gym.city + ' ' + event.gym.street + ' ' + event.gym.no_building + '/' + event.gym.no_local) s = s + '&location=' + temp return s + '&trp=false'
def _register_course_home_messages(request, course, user_access, course_start_data): """ Register messages to be shown in the course home content page. """ if user_access['is_anonymous']: CourseHomeMessages.register_info_message( request, Text( _('{sign_in_link} or {register_link} and then enroll in this course.' ) ).format( sign_in_link=HTML( '<a href="/login?next={current_url}">{sign_in_label}</a>'). format( sign_in_label=_('Sign in'), current_url=urlquote_plus(request.path), ), register_link=HTML( '<a href="/register?next={current_url}">{register_label}</a>' ).format( register_label=_('register'), current_url=urlquote_plus(request.path), )), title=Text( _('You must be enrolled in the course to see course content.') )) if not user_access['is_anonymous'] and not user_access[ 'is_staff'] and not user_access['is_enrolled']: CourseHomeMessages.register_info_message( request, Text( _('{open_enroll_link}Enroll now{close_enroll_link} to access the full course.' )).format(open_enroll_link='', close_enroll_link=''), title=Text(_('Welcome to {course_display_name}')).format( course_display_name=course.display_name))
def test_can_filter_by_date_after(self): # make sure event in progress at the "after" date are included response = self.client.get("/legacy/events/?after=%s" % urlquote_plus( (timezone.now() + timezone.timedelta(weeks=8, hours=1)).isoformat())) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertIn("_items", response.data) self.assertCountEqual( [item["_id"] for item in response.data["_items"]], [ str(self.amiens_2_months_event.id), str(self.marseille_3_months_event.id) ], )
def start_build(self, repo_slug, travis_config, commit_message, branch=None): """Start a build. Args: repo_slug (unicode): The "slug" for the repository based on it's location on GitHub. travis_config (unicode): The contents of the travis config to use when doing the build. commit_message (unicode): The text to use as the commit message displayed in the Travis UI. branch (unicode, optional): The branch name to use. Returns: dict: The parsed contents of the JSON response. Raises: urllib2.URLError: The HTTP request failed. """ travis_config['merge_mode'] = 'replace' request_data = { 'request': { 'message': commit_message, 'config': travis_config, }, } if branch: request_data['request']['branch'] = branch data = self._make_request('%s/repo/%s/requests' % (self.endpoint, urlquote_plus(repo_slug)), body=json.dumps(request_data), method='POST', content_type='application/json') return json.loads(data)
def resource_report(request, object_id, template_name='depot/resource_report.html'): """ View for reporting a report when a user finds a problem with it. """ resource = get_one_or_404(Resource, id=ObjectId(object_id)) reporter = get_account(request.user.id) # if 'next' in request.GET: # url = request.GET['next'] # else: # url = None # url = url or reverse('resource', args=[resource.id]) if Issue.objects(reporter=reporter, related_document=resource).count(): messages.warning(request, 'You have already reported this resource.') return HttpResponseRedirect(reverse('resource', args=[resource.id])) if request.method == 'POST': form = ResourceReportForm(request.POST) if form.is_valid(): severity = int(form.cleaned_data['severity']) message = form.cleaned_data['message'] issue = Issue(message=message, severity=severity, reporter=reporter) issue.related_document = resource issue.save() issue.notify_created() # only moderate as STATUS_BAD if SEVERITY_CRITICAL if severity == SEVERITY_CRITICAL: resource.moderate_as_bad(reporter) return HttpResponseRedirect( reverse('issue_detail', args=[issue.id])) else: form = ResourceReportForm() return render_to_response( template_name, { 'next': urlquote_plus(request.GET.get('next', '')), 'form': form, 'object': resource, }, RequestContext(request))
def safe_cache_key(value): '''Returns an md5 hexdigest of value if len(value) > 250. Replaces invalid memcache control characters with an underscore. Also adds the CACHE_MIDDLEWARE_KEY_PREFIX to your keys automatically. ''' value = urlquote_plus(value) for char in value: if ord(char) < 33: value = value.replace(char, '_') value = "%s_%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, value) if len(value) <= 250: return value return hashlib.md5(value).hexdigest()
def _update_language(self, version): language = version.language if language.is_original and not language.language: url = 'http://ajax.googleapis.com/ajax/services/language/detect?v=1.0&q=%s' text = '' for item in version.subtitles(): text += ' %s' % item.text if len(text) >= 300: break r = json.loads(urllib.urlopen(url % urlquote_plus(text)).read()) if not 'error' in r: try: SubtitleLanguage.objects.get(video=language.video, language=r['responseData']['language']) except SubtitleLanguage.DoesNotExist: language.language = r['responseData']['language'] language.save()
def get_widget_url(self): # duplicates mirosubs.widget.SubtitleDialogOpener.prototype.openDialogOrRedirect_ video = self.video video_url = video.get_video_url() config = { "videoID": video.video_id, "videoURL": video_url, "effectiveVideoURL": video_url, "languageCode": self.language, "subLanguagePK": self.pk, "originalLanguageCode": video.language } if self.is_dependent(): config['baseLanguagePK'] = self.standard_language.pk return reverse('onsite_widget') + '?config=' + urlquote_plus( json.dumps(config))
def process_request(self, request): if request.user.is_authenticated( ) and request.method == 'GET' and 'api' not in request.path and 'admin' not in request.path: #print('DEBUG: {}: {} == {}, {} == {}, {} == {}'.format(request.user, request.user.first_name, (not request.user.first_name), request.user.last_name, (not request.user.last_name), request.user.dob, (not request.user.dob) )) if (not request.user.first_name) or \ (not request.user.last_name) or \ (not request.user.dob) or \ (not request.user.residential_address) or \ (not (request.user.phone_number or request.user.mobile_number)): path_ft = reverse('first_time') path_logout = reverse('accounts:logout') request.session['new_to_wildlifecompliance'] = True if request.path not in (path_ft, path_logout): return redirect( reverse('first_time') + "?next=" + urlquote_plus(request.get_full_path()))
def test_create_coa(self): from ..api import CoaEndpoint from ..models import CoaFile from dynamicfixtures import _registered_edition_alice, _s3_bucket responses.add( responses.POST, settings.ASCRIBE_PDF_URL, json={}, status=200, content_type='application/json', ) edition = _registered_edition_alice() bucket = _s3_bucket() k = Key(bucket) k.key = edition.digital_work.key k.set_contents_from_string('white mountains') alice = edition.owner url = reverse('api:coa:coafile-list') factory = APIRequestFactory() data = { 'bitcoin_id': edition.bitcoin_id, } request = factory.post(url, data, format='json') force_authenticate(request, user=alice) view = CoaEndpoint.as_view({'post': 'create'}) response = view(request) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertIn('coa', response.data) self.assertIn('coa_file', response.data['coa']) self.assertIn('url', response.data['coa']) self.assertIn('url_safe', response.data['coa']) coa_key_prefix = edition.digital_work.key.replace( 'digitalwork', 'coa', ).rpartition('/')[0] stored_coa = (k for k in bucket.list(prefix=coa_key_prefix)).next() cloudfront_url = 'https://' + settings.AWS_CLOUDFRONT_DOMAIN coa_url = cloudfront_url + '/' + stored_coa.name coa_url_safe = cloudfront_url + '/' + urlquote_plus(stored_coa.name) self.assertEqual(response.data['coa']['coa_file'], stored_coa.name) self.assertEqual(response.data['coa']['url'], coa_url) self.assertEqual(response.data['coa']['url_safe'], coa_url_safe) coa_obj = CoaFile.objects.get() self.assertEqual(coa_obj.user, alice) self.assertEqual(coa_obj.edition, edition.pk) self.assertEqual(coa_obj.coa_file, stored_coa.name)
def test_iri_to_uri(self): cases = [ # Valid UTF-8 sequences are encoded. ('red%09rosé#red', 'red%09ros%C3%A9#red'), ('/blog/for/Jürgen Münster/', '/blog/for/J%C3%BCrgen%20M%C3%BCnster/'), ('locations/%s' % urlquote_plus('Paris & Orléans'), 'locations/Paris+%26+Orl%C3%A9ans'), # Reserved chars remain unescaped. ('%&', '%&'), ('red&♥ros%#red', 'red&%E2%99%A5ros%#red'), ] for iri, uri in cases: self.assertEqual(iri_to_uri(iri), uri) # Test idempotency. self.assertEqual(iri_to_uri(iri_to_uri(iri)), uri)
def keywords_escaped(self): return [(keyword.strip(), urlquote_plus(keyword.strip())) for keyword in self.keywords.split(',')] # class PublicationAuthorsThroughModel(OrderedModelBase): # publication = models.ForeignKey('publications.Publication', on_delete=models.CASCADE) # author = models.ForeignKey('publications.Author', on_delete=models.CASCADE) # position = models.PositiveIntegerField(_("position"), db_index=True) # order_with_respect_to = 'publication' # order_field_name = 'position' # class Meta: # ordering = ('publication', 'position')
def post(self, request): """获取提交的数据,并验证""" logger.debug('创建图形: {},操作人: {}'.format(request.POST, request.user)) next_url = urlquote_plus( request.GET.get('next', None) if request.GET. get('next', None) else reverse('influx_graph_list')) form = CreateGraphForm(request.POST) if form.is_valid(): try: graph = Graph(**form.cleaned_data) graph.save() return redirect('success', kwargs={'next': next_url}) except Exception as e: logger.error('创建图形保存数据库失败: {}'.format(e.args)) return redirect("error", next=next_url, msg=e.args) else: logger.error('表单数据验证失败.') return redirect("error", next=next_url, msg=form.errors.as_json())
def browserid_home(request): """Display the home page with a BrowserID login.""" register_form = BrowserIDRegisterForm(request.POST or None) if request.method == 'POST': # Attempting to register response = browserid_register(request, register_form) if response is not None: return response params = { 'browserid_verify': reverse('browserid.verify'), 'register_form': register_form, 'share_url': absolutify('/', https=True), 'tweet_text': urlquote_plus(TWEET_TEXT), 'browserid_no_assertion': BROWSERID_NO_ASSERTION, 'browserid_verify_fail': BROWSERID_VERIFY_FAIL } return render(request, 'shared/home/browserid.html', params)
def __call__(self, request): """ Redirects to the time zone selection vie and passes the originally requested URL to that view if the current user does not have a time zone set. :param HttpRequest request: the current request :return: redirect or None """ timezone_path = reverse('select_timezone') if (request.user.is_authenticated and not request.user.timezone and not request.path.startswith(settings.STATIC_URL) and not request.path.startswith(timezone_path)): return HttpResponseRedirect( timezone_path + '?next=' + urlquote_plus(request.get_full_path())) return self.get_response(request)
def process_request(self, request=None): ''' Process a privileged request. ''' from wildlifecompliance.helpers import is_new_to_wildlifelicensing if self.request.method == 'GET' and 'api' not in self.request.path \ and 'admin' not in self.request.path \ and self.request.user.is_authenticated(): if is_new_to_wildlifelicensing(self.request): path_ft = reverse('first_time') path_logout = reverse('accounts:logout') self.request.session['new_to_wildlifecompliance'] = True if self.request.path not in (path_ft, path_logout): return redirect( reverse('first_time') + "?next=" + urlquote_plus(self.request.get_full_path()))
def serve_file(request, att_file, forced_name=None): statobj = os.stat(att_file.path) if not was_modified_since(request.META.get('HTTP_IF_MODIFIED_SINCE'), statobj.st_mtime, statobj.st_size): return HttpResponseNotModified() content_type, encoding = mimetypes.guess_type(att_file.path) content_type = content_type or 'application/octet-stream' response = FileResponse(att_file, content_type=content_type) response["Last-Modified"] = http_date(statobj.st_mtime) if stat.S_ISREG(statobj.st_mode): response["Content-Length"] = statobj.st_size if encoding: response["Content-Encoding"] = encoding name = forced_name or att_file.name name = name.split('/')[-1] response["Content-Disposition"] = 'attachment; filename="%s"; filename*=UTF-8\'\'%s' % \ (str(name).replace('"', ''), urlquote_plus(name)) return response
def resource_list(request): """ Display all :class:`.Resource` instances to which the user has access. """ resources = auth.apply_filter(ResourceAuthorization.VIEW, request.user, ResourceContainer.active.all()) predicate_ids = request.GET.getlist('predicate') target_ids = request.GET.getlist('target') target_type_ids = request.GET.getlist('target_type') if predicate_ids and target_ids and target_type_ids: for p, t, y in zip(predicate_ids, target_ids, target_type_ids): resources = resources.filter( primary__relations_from__predicate_id=p, primary__relations_from__target_instance_id=t, primary__relations_from__target_type_id=y) # For now we use filters to achieve search functionality. At some point we # should use a real search backend. # # TODO: implement a real search backend. params = QueryDict(request.GET.urlencode(), mutable=True) if 'page' in params: del params['page'] filter_parameters = urlquote_plus(params.urlencode()) filtered_resources = ResourceContainerFilter(request.GET, queryset=resources) # The following statement results in an expensive Postgres Query. # Disable tags in this view for now. # tags = filtered_resources.qs.order_by('primary__tags__tag__id')\ # .values_list('primary__tags__tag__id', 'primary__tags__tag__name')\ # .distinct('primary__tags__tag__id') context = { 'filtered_objects': filtered_resources, # 'tags': filter(lambda tag: tag[0] is not None, tags), 'q': request.GET.get('name'), 'filter_parameters': filter_parameters, 'resource_count': filtered_resources.qs.count() } return render(request, 'resources.html', context)
def telmap_fetch_results(data, request_template): """ Performs a query to telmap server Creates a query XML and sends it to Telmap servers Returns parsed result object """ c = Context(data) t = get_template(request_template) payload = u"sid=%s&requestXML=%s" % (data['server_id'], urlquote_plus(t.render(c))) # logging.info(u"sid=%s&requestXML=%s" % (data['server_id'], t.render(c))) res = safe_fetch(u"%s?%s" % (TELMAP_XML_API_URL, payload), method="GET", notify=False) #, payload=payload) if res: cleaned_response = clean_telmap_response(res.content) return minidom.parseString(cleaned_response) else: return None
def quote_string(value): """ Due to differences between VBScript and Python %% encoding, certain substitutions must be done manually. These are required in multiple circumstances. TODO: Do these encoding issues actually harm anything? Can we get away with not manually replacing punctuation that is perfectly valid? Inputs: :value: String to be quoted :value: Quoted string """ value = urlquote_plus(value, safe='') value = value.replace('.', '%2E') value = value.replace('-', '%2D') value = value.replace('_', '%5F') return value
def get_download_file_response(self, from_share=False): obj = self.get_object() if not from_share: fileobject = obj.file filename = obj.name else: fileobject = obj.target.file filename = obj.target.name redirect = urlunquote_plus(fileobject.url).encode('utf-8') response = HttpResponse(charset='utf-8') response['Content-Length'] = fileobject.size response[ 'Content-Disposition'] = "attachment; filename=\"%s\"" % urlquote_plus( filename, safe="()/,&=@#%*") response['Content-Type'] = mimetypes.guess_type(fileobject.path)[0] response['Content-Length'] = os.path.getsize(fileobject.path) response['X-Accel-Redirect'] = redirect return response
def __call__(self, request): if is_public_path(request.path): return self.get_response(request) if request.user.is_anonymous: return HttpResponseRedirect( "%s?next=%s" % (reverse("login"), urlquote_plus(request.path))) completed_intro = Config.objects.get_config("completed_intro") if not completed_intro and not request.user.is_superuser: # Only administrators can completed the main intro, normal users # cannot complete it so to them it has been done. completed_intro = True if not completed_intro or not request.user.userprofile.completed_intro: if request.path != "/MAAS/" and request.path != reverse("logout"): return HttpResponseRedirect("/MAAS/") return self.get_response(request)
def changeemail(request): """ changeemail view. It require password or openid to allow change. url: /changeemail/ template : authopenid/changeemail.html """ msg = request.GET.get('msg', '') extension_args = {} user_ = request.user redirect_to = get_url_host(request) + reverse('user_changeemail') if request.POST: form = ChangeemailForm(request.POST, user=user_) if form.is_valid(): if not form.test_openid: user_.email = form.cleaned_data['email'] user_.save() msg = _("Email changed.") redirect = "%s?msg=%s" % (reverse('user_account_settings'), urlquote_plus(msg)) return HttpResponseRedirect(redirect) else: request.session['new_email'] = form.cleaned_data['email'] return ask_openid(request, form.cleaned_data['password'], redirect_to, on_failure=emailopenid_failure) elif not request.POST and 'openid.mode' in request.GET: return complete(request, emailopenid_success, emailopenid_failure, redirect_to) else: form = ChangeemailForm(initial={'email': user_.email}, user=user_) return render('authopenid/changeemail.html', { 'form': form, 'msg': msg }, context_instance=RequestContext(request))
def api_reverse(view_name, kwargs={}, request=None, format=None): """ A special case of URL reversal where we know we're getting an API URL. This can be much faster than Django's built-in general purpose regex resolver. """ if request: url = '{}://{}/api/v2'.format(request.scheme, request.get_host()) else: url = '/api/v2' route_template_strings = { 'submission-detail': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}/{submission_set_name}/{submission_id}', 'submission-list': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}/{submission_set_name}', 'place-detail': '/{owner_username}/datasets/{dataset_slug}/places/{place_id}', 'place-list': '/{owner_username}/datasets/{dataset_slug}/places', 'dataset-detail': '/{owner_username}/datasets/{dataset_slug}', 'user-detail': '/{owner_username}', 'dataset-submission-list': '/{owner_username}/datasets/{dataset_slug}/{submission_set_name}', } try: route_template_string = route_template_strings[view_name] except KeyError: raise ValueError('No API route named {} formatted.'.format(view_name)) url_params = dict([(key, urlquote_plus(val)) for key, val in kwargs.iteritems()]) url += route_template_string.format(**url_params) if format is not None: url += '.' + format return url