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
