def index(request):
print " "
print "*******VIEWS INDEX******"
print " "
response = TemplateResponse(request, 'index.html', {} )
response.render()
return response
def post(self, *args, **kwargs):
# Get the chosen options ids.
post = self.request.POST.copy()
try:
del post["csrfmiddlewaretoken"]
except KeyError:
pass
choice_ids = map(lambda v: int(v), post.values())
# Create a new answer and add the voter and the choices.
voter = get_voter(self.request)
answer = Answer.objects.create(
gallup_id=self.kwargs["gallup_id"],
voter=voter,
client_identifier=get_client_identifier(self.request)
)
choices = Option.objects.filter(pk__in=choice_ids).all()
answer.choices.add(*choices)
context = self.get_context_data()
context["show_results"] = True
context["disabled"] = True
context["answered_options"] = choices
response = TemplateResponse(self.request, self.template_name, context)
response.set_cookie(Voter.VOTER_COOKIE, voter.voter_id)
return response
def home(request):
html = "appointment.home"
t = TemplateResponse(request, "base.html", {})
t.template_name = "index.html"
t.render()
# return HttpResponse(html)
return t
def mount_owncloud(request):
# If the request is a http post
if request.method == 'POST' and 'operation' not in request.POST:
form = OwncloudForm(request.POST)
if form.is_valid():
# Mount ownCloud
is_mounted = WebFolder.mount_owncloud(request.user, request.POST["user"], request.POST["password"])
if is_mounted:
message = "Your ownCloud directory was successfully mounted."
t = TemplateResponse(request, 'info.html',
{'message': message})
else:
message = "Mounting your ownCloud directory failed. Please try again!"
t = TemplateResponse(request, 'error.html',
{'message': message})
return HttpResponse(t.render())
else:
# The supplied form contained errors - just print them to the terminal.
print form.errors
else:
# If the request was not a POST, display the form to enter details.
form = OwncloudForm()
t = TemplateResponse(request, 'collection/mount_owncloud.html', {'form': form})
return HttpResponse(t.render())
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(self.factory.get('/'),
'first/test.html', {
'value': 123,
'fn': datetime.now,
}
)
self.assertRaises(ContentNotRenderedError,
pickle.dumps, response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(unpickled_response['content-type'], response['content-type'])
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled response doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = ('template_name', 'context_data',
'_post_render_callbacks', '_request', '_current_app')
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def productEdit(request, id):
if not request.user.is_active or not request.user.is_superuser:
raise Http404 #filter other users
try:
id = int(id)
product = models.Products.objects.get(id=id)
except:
raise Http404 #bad id or product with this id is not exist
form = None
if request.method == 'POST':
response = {}
saved = False
form = forms.ProductForm(request.POST, request.FILES, instance=product)
#check form
if form.is_valid():
form.save()
response['status'] = 'ok'
saved = True
else:
response['status'] = 'error'
context = RequestContext(request, { 'product':product, 'form':form, 'saved':saved })
response['form'] = template.loader.get_template('form.html').render(context)
response['name'] = product.name
resp = TemplateResponse(request, '')
resp.content = json.dumps(response)
return resp
#return HttpResponse(json.dumps(response))
if request.method == 'GET':
#create form
form = forms.ProductForm(instance=product)
return TemplateResponse(request, 'edit.html', {"form": form, 'product': product})
def test_pickling(self):
# Create a template response. The context is
# known to be unpickleable (e.g., a function).
response = TemplateResponse(self.factory.get('/'),
'first/test.html', {
'value': 123,
'fn': datetime.now,
})
self.assertRaises(ContentNotRenderedError,
pickle.dumps, response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEquals(unpickled_response.content, response.content)
self.assertEquals(unpickled_response['content-type'], response['content-type'])
self.assertEquals(unpickled_response.status_code, response.status_code)
# ...and the unpickled reponse doesn't have the
# template-related attributes, so it can't be re-rendered
self.assertFalse(hasattr(unpickled_response, '_request'))
self.assertFalse(hasattr(unpickled_response, 'template_name'))
self.assertFalse(hasattr(unpickled_response, 'context_data'))
self.assertFalse(hasattr(unpickled_response, '_post_render_callbacks'))
def render_article(request, article, current_language, slug):
"""
Renders an article
"""
context = {}
context['article'] = article
context['lang'] = current_language
context['current_article'] = article
context['has_change_permissions'] = article.has_change_permission(request)
response = TemplateResponse(request, article.template, context)
response.add_post_render_callback(set_page_cache)
# Add headers for X Frame Options - this really should be changed upon moving to class based views
xframe_options = article.tree.get_xframe_options()
# xframe_options can be None if there's no xframe information on the page
# (eg. a top-level page which has xframe options set to "inherit")
if xframe_options == Page.X_FRAME_OPTIONS_INHERIT or xframe_options is None:
# This is when we defer to django's own clickjacking handling
return response
# We want to prevent django setting this in their middlewear
response.xframe_options_exempt = True
if xframe_options == Page.X_FRAME_OPTIONS_ALLOW:
# Do nothing, allowed is no header.
return response
elif xframe_options == Page.X_FRAME_OPTIONS_SAMEORIGIN:
response['X-Frame-Options'] = 'SAMEORIGIN'
elif xframe_options == Page.X_FRAME_OPTIONS_DENY:
response['X-Frame-Options'] = 'DENY'
return response
def verify_attendances(request):
if 'attendance' in request.POST:
for member in request.POST.getlist('attendance'):
"""attendance = Attendance.objects.get(pk=request.POST.get('attendance'))"""
attendance = Attendance.objects.get(pk=member)
attendance.verified = True
attendance.save()
if 'delete' in request.POST:
for member in request.POST.getlist('delete'):
attendance = Attendance.objects.get(pk=member)
attendance.delete()
order_by = request.GET.get('order_by', 'user')
own_guild = request.user.userprofile.guild
general_guild = Guild.objects.filter(id = general_id)
if own_guild.abbreviation != 'TF':
guild_users = User.objects.filter(userprofile__guild = own_guild)
else:
guild_users = User.objects.filter(userprofile__is_tf = True)
unverified = Attendance.objects.filter(Q(user__in = guild_users)
& (Q(event__guild = own_guild) | Q(event__guild = general_guild))
& Q(verified = False)).order_by(order_by)
verified = Attendance.objects.filter(Q(user__in = guild_users)
& (Q(event__guild = own_guild) | Q(event__guild = general_guild))
& Q(verified = True)).order_by(order_by)
response = TemplateResponse(request, 'admin_attendances.html', {'unverified': unverified, 'verified': verified})
response.render()
return response
def html_response(request, response, content):
"""Return a html layout with sort options as the response content."""
template = TemplateResponse(request, "profile_stats.html",
{"stats": content,
"order_by": request.GET.get('profile', None)})
template.render()
return template
def view_cart(request):
if 'cart_id' in request.COOKIES:
cart_id = request.COOKIES["cart_id"]
cart, created = Cart.objects.get_or_create(id=cart_id)
else:
if request.user.is_authenticated():
cart, object = Cart.objects.get_or_create(user=request.user)
else:
cart = Cart.objects.create(user=None)
if request.is_ajax():
ret_dict = {}
ret_dict['success'] = True
ret_dict['item_type_count'] = cart.cart_products.all().count()
from shopcart.serializer import serializer
# serialized_cart = serializer(cart,datetime_format='string',output_type='dict',many=True)
# 先不返回购物车中商品信息
serialized_cart = serializer(cart, datetime_format='string', output_type='dict', many=False)
# logger.debug(serialized_cart)
ret_dict['cart'] = serialized_cart
return JsonResponse(ret_dict)
else:
ctx = {}
ctx['system_para'] = get_system_parameters()
ctx['menu_products'] = get_menu_products()
ctx['page_name'] = 'My Cart'
if request.method == 'GET':
ctx['cart'] = cart
response = TemplateResponse(request, System_Config.get_template_name() + '/cart_detail.html', ctx)
response.set_cookie('cart_id', cart.id, max_age=3600 * 24 * 365)
return response
def news(request):
try:
if request.POST.get("date_filter"):
date_filter = int(request.POST.get("date_filter"))
else:
date_filter = 10
last_date = timezone.now()-timedelta(days=date_filter)
if request.user.is_anonymous():
news = [n for n in News.objects.order_by("-date")
if (n.collection!=None and n.collection.public_access) # user news (public collection)
and (n.date>=last_date)]
else:
news = [n for n in News.objects.order_by("-date")
if ((n.collection==None and n.group==None) # general news
or (n.collection!=None and n.collection.public_access) # user news (public collection)
or (n.collection!=None and n.collection in request.user.get_all_permissible_collections()) # user news (collection)
or (n.group!=None and n.group in request.user.groups.all())) # user news (group)
and (n.date>=last_date)]
except Collection.DoesNotExist:
raise Http404
t = TemplateResponse(request, 'log/news.html',
{'news': news,
'date_filter': date_filter})
return HttpResponse(t.render())
def logout(request):
auth = request.COOKIES.get('auth')
resp = logout_exp_api(auth)
context = {'response': resp}
response = TemplateResponse(request,'logout.html', context)
response.delete_cookie('auth')
return response
def show_pad(request, group_name, pad_name):
# test if user is in group
if not request.user.groups.filter(name=group_name).exists():
return TemplateResponse(request, 'etherpad/forbidden.html', {
'group_name': group_name,
}, status=403)
ep = Etherpad()
try:
ep.create_session(request.user, group_name)
group_id = ep.get_group_id(group_name)
pad_url = '{0}/p/{1}${2}'.format(
settings.ETHERPAD_URL,
group_id,
pad_name)
cookie = ep.get_session_cookie(request.user)
except URLError:
return TemplateResponse(request, 'etherpad/server_error.html', {
}, status=500)
is_fullscreen = 'fullscreen' in request.GET
response = TemplateResponse(request, 'etherpad/pad.html', {
'pad_url': pad_url,
'group_name': group_name,
'pad_name': pad_name,
'fullscreen': is_fullscreen,
'base_template': 'base_raw.html' if is_fullscreen else 'base.html'
})
cookie_domain = '.' + request.get_host()
response.set_cookie('sessionID', cookie, domain=cookie_domain)
response['Access-Control-Allow-Origin'] = "https://ep.mafiasi.de"
return response
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(self.factory.get("/"), "first/test.html", {"value": 123, "fn": datetime.now})
self.assertRaises(ContentNotRenderedError, pickle.dumps, response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(unpickled_response["content-type"], response["content-type"])
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled response doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = ("template_name", "context_data", "_post_render_callbacks", "_request")
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def process_response(self, request, response):
if isinstance(response, HttpResponseNotAllowed):
response = TemplateResponse(request=request,
template="method_not_allowed.html",
status=405,
context={})
response.render()
return response
def preferences(request):
try:
collections = Collection.objects.all()
except Collection.DoesNotExist:
raise Http404
t = TemplateResponse(request, 'authentication/preferences.html',
{'collections': collections})
return HttpResponse(t.render())
def list_events(request):
"""
Lists all events. Available only for admins.
"""
order_by = request.GET.get('order_by', 'name')
events = Event.objects.all().order_by(order_by)
response = TemplateResponse(request, 'admin_eventlist.html', {'events': events})
response.render()
return response
def render_tariff_plan_template(upc_code):
from django.template.response import TemplateResponse
t_p = request.db_session.query(TariffPlan).\
join(CompanyUpcTariffPlan).\
filter_by(company=request.user.company).\
filter_by(upc=upc_code).first()
html = TemplateResponse(request, 'upc_detailed.html', {'upc': upc_code, 'movie': upc_code.movie, 'tariff_plan': t_p})
html.render()
return html
def unauthed(self, request):
response = TemplateResponse(
request=request,
template='aldryn_sso/basicauth_auth_required.html',
content_type='text/html',
)
response['WWW-Authenticate'] = 'Basic realm="Protected"'
response.status_code = 401
return response
def challenge(self, request):
realm = getattr(settings, 'API_AUTH_REALM', 'Restricted access')
response = TemplateResponse(
request,
'api/401.html'
)
response['WWW-Authenticate'] = 'Basic realm="%s"' % realm
response.status_code = 401
return response
def user_ranking(request):
usersGuild = User.objects.filter(Q(userprofile__guild = request.user.userprofile.guild) & Q(userprofile__role = 'user'))
#usersAll = User.objects.filter(Q(userprofile__role = 'user'))
score_list_guild = get_user_ranking(usersGuild)
score_list_guild = sorted(score_list_guild, key=lambda points: points[3], reverse=True)
#score_list_all = get_user_ranking(usersAll) This shit will likely crash the whole site
#score_list_all = sorted(score_list_all, key=lambda points: points[3], reverse=True)[:20]
response = TemplateResponse(request, 'userrank.html', {'score_list_guild': score_list_guild})
response.render()
return response
def docs_resources(request):
context = dict()
context['title'] = 'Resources'
context['resources'] = dict(
organisation = OrganisationResource.__name__,
organisation_doc = OrganisationResource.__doc__,
activity = ActivityResource.__name__,
activity_doc = ActivityResource.__doc__
)
t = TemplateResponse(request, 'documentation/resources.html', context)
return t.render()
def my_shared_folder(request, rel_path=''):
# create ownCloud directory
if "create_owncloud_dir" in request.POST:
WebFolder.create_owncloud_dir(request.user)
# class the files in categories collection, directory or file
dirs = []
files = []
owncloud = None
for item_name in WebFolder.list_dir(request.user, rel_path):
rel_item_path = os.path.join(utils.path.no_slash(rel_path), item_name)
if WebFolder.is_file(request.user, rel_item_path):
file_size = WebFolder.get_file_size(request.user, rel_item_path)
f = WebFolder.get_file(request.user, rel_item_path)
file_revision = f.revision if f else "-"
files.append({"name": item_name,
"size": utils.units.convert_data_size(file_size),
"revision": file_revision,
"part_of_collection": bool(f)})
elif WebFolder.is_dir(request.user, rel_item_path):
collection = WebFolder.get_collection(request.user, rel_item_path)
dir_size = WebFolder.get_dir_size(request.user, rel_item_path)
# ownCloud directory
if utils.path.no_slash(rel_item_path)==OWNCLOUD_DIR_NAME:
owncloud = {"name": item_name,
"size": utils.units.convert_data_size(dir_size),
"is_mounted": WebFolder.is_mounted(request.user)}
# collection
elif collection:
dirs.append({"type": "c",
"id": collection.identifier,
"name": collection.directory.name,
"size": utils.units.convert_data_size(dir_size),
"revision": collection.revision,
"access": request.user.get_permission(collection)})
# standard directory
else:
d = WebFolder.get_dir(request.user, rel_item_path)
dir_revision = d.revision if d else "-"
dirs.append({"type": "d",
"name": item_name,
"size": utils.units.convert_data_size(dir_size),
"revision": dir_revision,
"part_of_collection": bool(d)})
# call html
t = TemplateResponse(request, 'collection/my_shared_folder.html',
{'rel_path': utils.path.both_slash(rel_path),
'rel_parent_path': utils.path.no_slash(os.path.dirname(rel_path)),
'dirs': dirs,
'files': files,
'owncloud': owncloud})
return HttpResponse(t.render())
def reauth (request):
da = DriveAuth(request)
creds = da.get_credentials(check_cookie=False)
if creds is None:
return da.redirect_auth()
response = TemplateResponse(request, 'main/reauth.html', {})
expires = datetime.datetime.utcnow() + datetime.timedelta(seconds=settings.MAX_AGE)
response.set_signed_cookie(settings.USERID_COOKIE, value=da.userid, salt=settings.SALT)
return response
def IndexView(request):
template_name = 'index.html'
dict = {}
posts = lp_posts.objects.all()
options = lp_options.objects.all()
dict['posts'] = posts
t = TemplateResponse(request, 'index.html', dict)
t.render()
return t
def _create_403_response(self, request, operation, resource, authority=None, template_name=None, message=None):
template_name = template_name or '403.html'
response = TemplateResponse(request, template_name, {
'operation': operation,
'resource': resource,
'authority': authority,
'message': message,
'status_code': '403'
})
response.status_code = 403
return response
def user_info(request):
cur_user = request.user
cur_user_profile = UserProfile.objects.get(user_id = cur_user.id)
attendances = Attendance.objects.filter(user = cur_user)
points = sum([x.event.points for x in attendances])
response = TemplateResponse(request, 'user_info.html', {
'profile': cur_user_profile,
'attendances': attendances,
'user_points': points
})
response.render()
return response
def test_render_page(self):
template_string = 'url: {{ get_protected_url(page) }}'
template = engines['wagtail-env'].from_string(template_string)
page = self.make_page(path='foo', live=True)
request = self.request_for_hostname('localhost')
context = page.get_context(request)
response = TemplateResponse(request, template, context)
response.render()
self.assertEqual(response.content, 'url: /foo/')
def results_view(request):
query = request.GET.get('q', '')
results = dotgov.search(query)
context = {
'q': query,
'results': results
}
response = TemplateResponse(request, 'search/results.html', context)
return response.render()
def receive_tip_v3(request, key, txid, network):
"""Handle the receiving of a tip (the POST).
Returns:
TemplateResponse: the UI with the tip confirmed.
"""
these_tips = Tip.objects.filter(web3_type='v3', txid=txid, network=network)
tips = these_tips.filter(metadata__reference_hash_for_receipient=key) | these_tips.filter(metadata__reference_hash_for_funder=key)
tip = tips.first()
is_authed = request.user.username.lower() == tip.username.lower() or request.user.username.lower() == tip.from_username.lower()
not_mined_yet = get_web3(tip.network).eth.getBalance(Web3.toChecksumAddress(tip.metadata['address'])) == 0
did_fail = False
if not_mined_yet:
tip.update_tx_status()
did_fail = tip.tx_status in ['dropped', 'unknown', 'na', 'error']
if not request.user.is_authenticated or request.user.is_authenticated and not getattr(
request.user, 'profile', None
):
login_redirect = redirect('/login/github?next=' + request.get_full_path())
return login_redirect
if tip.receive_txid:
messages.info(request, 'This tip has been received')
elif not is_authed:
messages.error(request, f'This tip is for @{tip.username} but you are logged in as @{request.user.username}. Please logout and log back in as {tip.username}.')
elif did_fail:
messages.info(request, f'This tx {tip.txid}, failed. Please contact the sender and ask them to send the tx again.')
elif not_mined_yet:
messages.info(request, f'This tx {tip.txid}, is still mining. Please wait a moment before submitting the receive form.')
elif request.GET.get('receive_txid') and not tip.receive_txid:
params = request.GET
# db mutations
try:
if params['save_addr']:
profile = get_profile(tip.username)
if profile:
profile.preferred_payout_address = params['forwarding_address']
profile.save()
tip.receive_txid = params['receive_txid']
tip.receive_tx_status = 'pending'
tip.receive_address = params['forwarding_address']
tip.received_on = timezone.now()
tip.save()
record_user_action(tip.from_username, 'receive_tip', tip)
record_tip_activity(tip, tip.username, 'receive_tip')
messages.success(request, 'This tip has been received')
except Exception as e:
messages.error(request, str(e))
logger.exception(e)
params = {
'issueURL': request.GET.get('source'),
'class': 'receive',
'title': _('Receive Tip'),
'gas_price': round(recommend_min_gas_price_to_confirm_in_time(120), 1),
'tip': tip,
'key': key,
'is_authed': is_authed,
'disable_inputs': tip.receive_txid or not_mined_yet or not is_authed,
}
return TemplateResponse(request, 'onepager/receive.html', params)
def stock_location_list(request):
stock_locations = StockLocation.objects.all()
ctx = {'locations': stock_locations}
return TemplateResponse(request,
'dashboard/product/stock_locations/list.html', ctx)
def contribute(request):
"""Serve the contribute page"""
return TemplateResponse(request, 'help_contribute.html',
{'title': _('Contribute')})
def support(request):
"""Serve the support page"""
return TemplateResponse(request, 'help_support.html',
{'title': _('Get Support')})
def __call__(self, req, *args, **kwargs):
""" Handles the request, taking care of common things and delegating
control to the subclass for fetching this view-specific data.
"""
self.clear_user_message()
try:
super(Index, self).__call__(req, *args, **kwargs)
del self.items[:]
self.item = None
self.set_input()
return_data = {'cluster_id': self.cluster_id}
output_repeated = getattr(self.SimpleIO, 'output_repeated', False)
response = None
if self.can_invoke_admin_service():
self.before_invoke_admin_service()
response = self.invoke_admin_service()
if response.ok:
return_data[
'response_inner'] = response.inner_service_response
if output_repeated:
if isinstance(response.data, dict):
response.data.pop('_meta', None)
keys = list(iterkeys(response.data))
data = response.data[keys[0]]
else:
data = response.data
self._handle_item_list(data)
else:
self._handle_item(response.data)
else:
self.user_message = response.details
else:
logger.info(
'can_invoke_admin_service returned False, not invoking an admin service:[%s]',
self.service_name)
return_data['req'] = self.req
return_data['items'] = self.items
return_data['item'] = self.item
return_data['input'] = self.input
return_data['user_message'] = self.user_message
return_data['user_message_class'] = self.user_message_class
return_data['zato_clusters'] = req.zato.clusters
return_data['search_form'] = req.zato.search_form
return_data['meta'] = response.meta if response else {}
return_data['paginate'] = getattr(self, 'paginate', False)
view_specific = self.handle()
if view_specific:
return_data.update(view_specific)
return_data = self.handle_return_data(return_data)
logger.info('Index data for frontend `%s`', return_data)
return TemplateResponse(req,
self.get_template_name() or self.template,
return_data)
except Exception:
return HttpResponseServerError(format_exc())
def product_details(request, slug, product_id, form=None):
"""Product details page.
The following variables are available to the template:
product:
The Product instance itself.
is_visible:
Whether the product is visible to regular users (for cases when an
admin is previewing a product before publishing).
form:
The add-to-cart form.
price_range:
The PriceRange for the product including all discounts.
undiscounted_price_range:
The PriceRange excluding all discounts.
discount:
Either a Price instance equal to the discount value or None if no
discount was available.
local_price_range:
The same PriceRange from price_range represented in user's local
currency. The value will be None if exchange rate is not available or
the local currency is the same as site's default currency.
"""
products = products_with_details(user=request.user)
product = get_object_or_404(products, id=product_id)
if product.get_slug() != slug:
return HttpResponsePermanentRedirect(product.get_absolute_url())
today = datetime.date.today()
is_visible = (product.publication_date is None
or product.publication_date <= today)
if form is None:
form = handle_cart_form(request, product, create_cart=False)[0]
availability = get_availability(product,
discounts=request.discounts,
taxes=request.taxes,
local_currency=request.currency)
product_images = get_product_images(product)
variant_picker_data = get_variant_picker_data(product, request.discounts,
request.taxes,
request.currency)
product_attributes = get_product_attributes_data(product)
# show_variant_picker determines if variant picker is used or select input
show_variant_picker = all([v.attributes for v in product.variants.all()])
json_ld_data = product_json_ld(product, product_attributes)
ctx = {
'is_visible':
is_visible,
'form':
form,
'availability':
availability,
'product':
product,
'product_attributes':
product_attributes,
'product_images':
product_images,
'show_variant_picker':
show_variant_picker,
'variant_picker_data':
json.dumps(variant_picker_data, default=serialize_decimal),
'json_ld_product_data':
json.dumps(json_ld_data, default=serialize_decimal)
}
return TemplateResponse(request, 'product/details.html', ctx)
def template_response_error_handler(request, exception=None):
return TemplateResponse(request, "test_handler.html", status=403)
def whitepaper_access(request, ratelimited=False):
context = {
'active': 'whitepaper',
'title': 'Whitepaper',
'minihero': 'Whitepaper',
'suppress_logo': True,
}
if not request.POST.get('submit', False):
return TemplateResponse(request, 'whitepaper_accesscode.html', context)
if ratelimited:
context[
'msg'] = "You're ratelimited. Please contact [email protected]"
return TemplateResponse(request, 'whitepaper_accesscode.html', context)
context['accesskey'] = request.POST.get('accesskey')
context['email'] = request.POST.get('email')
access_codes = AccessCodes.objects.filter(
invitecode=request.POST.get('accesskey'))
valid_access_code = access_codes.exists()
if not valid_access_code:
context[
'msg'] = "Invalid Access Code. Please contact [email protected]"
return TemplateResponse(request, 'whitepaper_accesscode.html', context)
ac = access_codes.first()
if ac.uses >= ac.maxuses:
context[
'msg'] = "You have exceeded your maximum number of uses for this access code. Please contact [email protected]"
return TemplateResponse(request, 'whitepaper_accesscode.html', context)
valid_email = True
try:
validate_email(request.POST.get('email', False))
except Exception as e:
valid_email = False
if not request.POST.get('email', False) or not valid_email:
context['msg'] = "Invalid Email. Please contact [email protected]"
return TemplateResponse(request, 'whitepaper_accesscode.html', context)
ip = get_ip(request)
wa = WhitepaperAccess.objects.create(
invitecode=request.POST.get('accesskey', False),
email=request.POST.get('email', False),
ip=ip,
)
send_mail(settings.CONTACT_EMAIL, settings.CONTACT_EMAIL,
"New Whitepaper Generated", str(wa))
# bottom watermark
packet1 = StringIO.StringIO()
can = canvas.Canvas(packet1, pagesize=letter)
grey = Color(22 / 255, 6 / 255, 62 / 255, alpha=0.3)
can.setFillColor(grey)
can.setFontSize(8)
lim = 30
email__etc = wa.email if len(wa.email) < lim else wa.email[0:lim] + "..."
msg = "Generated for access code {} by email {} at {} via ip: {}. https://gitcoin.co/whitepaper".format(
wa.invitecode, email__etc, wa.created_on.strftime("%Y-%m-%d %H:%M"),
wa.ip)
charlength = 3.5
width = len(msg) * charlength
left = (600 - width) / 2
can.drawString(left, 7, msg)
can.save()
# middle watermark
packet2 = StringIO.StringIO()
can = canvas.Canvas(packet2, pagesize=letter)
grey = Color(22 / 255, 6 / 255, 62 / 255, alpha=0.02)
can.setFillColor(grey)
can.setFontSize(100)
msg = "WP{}".format(str(wa.pk).zfill(5))
charlength = 55
width = len(msg) * charlength
left = (600 - width) / 2
can.rotate(45)
can.drawString(320, 50, msg)
can.save()
# move to the beginning of the StringIO buffer
path_to_file = 'assets/other/wp.pdf'
new_pdf1 = PdfFileReader(packet1)
new_pdf2 = PdfFileReader(packet2)
# read your existing PDF
existing_pdf = PdfFileReader(file(path_to_file, "rb"))
output = PdfFileWriter()
# add the "watermark" (which is the new pdf) on the existing page
try:
for i in range(0, 50):
page = existing_pdf.getPage(i)
page.mergePage(new_pdf1.getPage(0))
if i != 0:
page.mergePage(new_pdf2.getPage(0))
output.addPage(page)
except Exception as e:
print(e)
# finally, write "output" to a real file
outputfile = "output/whitepaper_{}.pdf".format(wa.pk)
outputStream = file(outputfile, "wb")
output.write(outputStream)
outputStream.close()
filename = outputfile
wrapper = FileWrapper(file(filename))
response = HttpResponse(wrapper, content_type='application/pdf')
response['Content-Length'] = os.path.getsize(filename)
return response
def update_images(modeladmin, request, queryset):
"""
ENG: Update images for multiple entities
RUS: Обновление картинок для нескольких объектов
"""
CHUNK_SIZE = getattr(settings, 'EDW_UPDATE_IMAGES_ACTION_CHUNK_SIZE', 100)
opts = modeladmin.model._meta
app_label = opts.app_label
if request.POST.get('post'):
form = EntitiesUpdateImagesAdminForm(request.POST)
if form.is_valid():
to_set = form.cleaned_data['to_set']
to_set_order = form.cleaned_data['to_set_order']
to_unset = form.cleaned_data['to_unset']
n = queryset.count()
if n and (to_set or to_unset):
i = 0
tasks = []
languages = getattr(settings, 'LANGUAGES', ())
while i < n:
chunk = queryset[i:i + CHUNK_SIZE]
for obj in chunk:
obj_display = force_text(obj)
modeladmin.log_change(request, obj, obj_display)
entities_ids = []
for entity in chunk:
entities_ids.append(entity.id)
app_label = entity._meta.app_label.lower()
keys = [
EntityCommonSerializer.
HTML_SNIPPET_CACHE_KEY_PATTERN.format(
entity.id, app_label, label,
entity.entity_model, 'media', language[0])
for label in ('summary', 'detail')
for language in languages
]
cache.delete_many(keys)
tasks.append(
update_entities_images.si(
entities_ids,
[j.id for j in to_set] if to_set else None,
to_set_order if to_set_order else 0,
[j.id for j in to_unset] if to_unset else None))
i += CHUNK_SIZE
chain(reduce(OR, tasks)).apply_async()
modeladmin.message_user(
request,
_("Successfully proceed %(count)d %(items)s.") % {
"count": n,
"items": model_ngettext(modeladmin.opts, n)
})
# Return None to display the change list page again.
return None
else:
form = EntitiesUpdateImagesAdminForm()
if len(queryset) == 1:
objects_name = force_text(opts.verbose_name)
else:
objects_name = force_text(opts.verbose_name_plural)
title = _("Update images for multiple entities")
context = {
"title": title,
'form': form,
"objects_name": objects_name,
'queryset': queryset,
"opts": opts,
"app_label": app_label,
'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
'media': modeladmin.media,
'action': 'update_images',
}
# Display the confirmation page
kwargs = {}
return TemplateResponse(request,
"edw/admin/entities/actions/update_images.html",
context, **kwargs)
def index(request):
context = {}
return TemplateResponse(request, "index.html", context=context)
def user_change_password(self, request, id, form_url=''):
user = self.get_object(request, unquote(id))
if not self.has_change_permission(request, user):
raise PermissionDenied
if user is None:
raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {
'name': self.model._meta.verbose_name,
'key': escape(id),
})
if request.method == 'POST':
form = self.change_password_form(user, request.POST)
if form.is_valid():
form.save()
change_message = self.construct_change_message(request, form, None)
self.log_change(request, user, change_message)
msg = gettext('Password changed successfully.')
messages.success(request, msg)
update_session_auth_hash(request, form.user)
return HttpResponseRedirect(
reverse(
'%s:%s_%s_change' % (
self.admin_site.name,
user._meta.app_label,
user._meta.model_name,
),
args=(user.pk,),
)
)
else:
form = self.change_password_form(user)
fieldsets = [(None, {'fields': list(form.base_fields)})]
adminForm = admin.helpers.AdminForm(form, fieldsets, {})
context = {
'title': _('Change password: %s') % escape(user.get_username()),
'adminForm': adminForm,
'form_url': form_url,
'form': form,
'is_popup': (IS_POPUP_VAR in request.POST or
IS_POPUP_VAR in request.GET),
'add': True,
'change': False,
'has_delete_permission': False,
'has_change_permission': True,
'has_absolute_url': False,
'opts': self.model._meta,
'original': user,
'save_as': False,
'show_save': True,
**self.admin_site.each_context(request),
}
request.current_app = self.admin_site.name
return TemplateResponse(
request,
self.change_user_password_template or
'admin/auth/user/change_password.html',
context,
)
def search(request):
pages = all_pages = Page.objects.all().prefetch_related('content_type').specific()
q = MATCH_ALL
content_types = []
pagination_query_params = QueryDict({}, mutable=True)
ordering = None
if 'ordering' in request.GET:
if request.GET['ordering'] in ['title', '-title', 'latest_revision_created_at', '-latest_revision_created_at', 'live', '-live']:
ordering = request.GET['ordering']
if ordering == 'title':
pages = pages.order_by('title')
elif ordering == '-title':
pages = pages.order_by('-title')
if ordering == 'latest_revision_created_at':
pages = pages.order_by('latest_revision_created_at')
elif ordering == '-latest_revision_created_at':
pages = pages.order_by('-latest_revision_created_at')
if ordering == 'live':
pages = pages.order_by('live')
elif ordering == '-live':
pages = pages.order_by('-live')
if 'content_type' in request.GET:
pagination_query_params['content_type'] = request.GET['content_type']
try:
app_label, model_name = request.GET['content_type'].split('.')
except ValueError:
raise Http404
try:
selected_content_type = ContentType.objects.get_by_natural_key(app_label, model_name)
except ContentType.DoesNotExist:
raise Http404
pages = pages.filter(content_type=selected_content_type)
else:
selected_content_type = None
if 'q' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
q = form.cleaned_data['q']
pagination_query_params['q'] = q
# Parse query
filters, query = parse_query_string(q, operator='and', zero_terms=MATCH_ALL)
# Live filter
live_filter = filters.get('live') or filters.get('published')
live_filter = live_filter and live_filter.lower()
if live_filter in ['yes', 'true']:
all_pages = all_pages.filter(live=True)
pages = pages.filter(live=True)
elif live_filter in ['no', 'false']:
all_pages = all_pages.filter(live=False)
pages = pages.filter(live=False)
# Search
all_pages = all_pages.search(query, order_by_relevance=not ordering)
pages = pages.search(query, order_by_relevance=not ordering)
# Facets
if pages.supports_facet:
content_types = [
(ContentType.objects.get(id=content_type_id), count)
for content_type_id, count in all_pages.facet('content_type_id').items()
]
else:
form = SearchForm()
paginator = Paginator(pages, per_page=20)
pages = paginator.get_page(request.GET.get('p'))
if request.is_ajax():
return TemplateResponse(request, "wagtailadmin/pages/search_results.html", {
'pages': pages,
'all_pages': all_pages,
'query_string': q,
'content_types': content_types,
'selected_content_type': selected_content_type,
'ordering': ordering,
'pagination_query_params': pagination_query_params.urlencode(),
})
else:
return TemplateResponse(request, "wagtailadmin/pages/search.html", {
'search_form': form,
'pages': pages,
'all_pages': all_pages,
'query_string': q,
'content_types': content_types,
'selected_content_type': selected_content_type,
'ordering': ordering,
'pagination_query_params': pagination_query_params.urlencode(),
})
def job_settings(request):
"""Display and save user's Account settings.
Returns:
TemplateResponse: The user's Account settings template response.
"""
msg = ''
profile, es, user, is_logged_in = settings_helper_get_auth(request)
if not user or not profile or not is_logged_in:
login_redirect = redirect('/login/github?next=' +
request.get_full_path())
return login_redirect
if request.POST:
if 'preferred_payout_address' in request.POST.keys():
profile.preferred_payout_address = request.POST.get(
'preferred_payout_address', '')
profile.save()
msg = _('Updated your Address')
elif request.POST.get('disconnect', False):
profile.github_access_token = ''
profile = record_form_submission(request, profile,
'account-disconnect')
profile.email = ''
profile.save()
create_user_action(profile.user, 'account_disconnected', request)
messages.success(
request, _('Your account has been disconnected from Github'))
logout_redirect = redirect(reverse('logout') + '?next=/')
return logout_redirect
elif request.POST.get('delete', False):
# remove profile
profile.hide_profile = True
profile = record_form_submission(request, profile,
'account-delete')
profile.email = ''
profile.save()
# remove email
try:
client = MailChimp(mc_user=settings.MAILCHIMP_USER,
mc_api=settings.MAILCHIMP_API_KEY)
result = client.search_members.get(query=es.email)
subscriber_hash = result['exact_matches']['members'][0]['id']
client.lists.members.delete(
list_id=settings.MAILCHIMP_LIST_ID,
subscriber_hash=subscriber_hash,
)
except Exception as e:
logger.exception(e)
if es:
es.delete()
request.user.delete()
AccountDeletionRequest.objects.create(handle=profile.handle,
profile={
'ip': get_ip(request),
})
profile.delete()
messages.success(request, _('Your account has been deleted.'))
logout_redirect = redirect(reverse('logout') + '?next=/')
return logout_redirect
else:
msg = _('Error: did not understand your request')
context = {
'is_logged_in': is_logged_in,
'nav': 'internal',
'active': '/settings/job',
'title': _('Job Settings'),
'navs': get_settings_navs(request),
'es': es,
'profile': profile,
'msg': msg,
}
return TemplateResponse(request, 'settings/job.html', context)
def user_info(request):
print("I am from user info view")
context = {'name': 'Rahul'}
return TemplateResponse(request, 'blog/user.html', context)
def get(self, request):
if request.is_ajax():
return TemplateResponse(request, 'controlPanel/index_pjax.html')
else:
return render(request, 'controlPanel/index.html')
def edit(request, poll_pk):
from ..models import Poll
model = Poll
poll = get_object_or_404(Poll, pk=poll_pk)
permission = get_permission_name('change', model)
if not request.user.has_perm(permission):
return permission_denied(request)
instance = poll
for fn in hooks.get_hooks('before_edit_snippet'):
result = fn(request, instance)
if hasattr(result, 'status_code'):
return result
edit_handler = get_poll_edit_handler(Poll)
edit_handler = edit_handler.bind_to(instance=instance, request=request)
form_class = edit_handler.get_form_class()
if request.method == 'POST':
form = form_class(request.POST, request.FILES, instance=instance)
if form.is_valid():
form.save()
messages.success(
request,
_("%(snippet_type)s '%(instance)s' updated.") % {
'snippet_type': capfirst(model._meta.verbose_name),
'instance': instance
},
buttons=[
messages.button(
reverse('wagtailpolls_edit', args=(poll, )), _('Edit'))
])
for fn in hooks.get_hooks('after_edit_snippet'):
result = fn(request, instance)
if hasattr(result, 'status_code'):
return result
return redirect('wagtailpolls_index')
else:
messages.validation_error(
request, _("The snippet could not be saved due to errors."),
form)
else:
form = form_class(instance=instance)
edit_handler = edit_handler.bind_to(form=form)
return TemplateResponse(
request, 'wagtailpolls/edit.html', {
'modal_opts': model._meta,
'instance': instance,
'poll': instance,
'edit_handler': edit_handler,
'form': form
})
def _get_wait_page(self):
response = TemplateResponse(self.request, self.get_template_names(),
self.get_context_data())
response[constants.wait_page_http_header] = (
constants.get_param_truth_value)
return response
def get(self, request):
if request.is_ajax():
return TemplateResponse(
request, 'controlPanel/userManage/authManage_pjax.html')
else:
return render(request, 'controlPanel/userManage/authManage.html')
def post(self, request, *args, **kwargs):
"""
Perform a dry_run of the import to make sure the import will not
result in errors. If there where no error, save the user
uploaded file to a local temp file that will be used by
'process_import' for the actual import.
"""
if not (self.has_change_permission() and self.has_add_permission()):
raise PermissionDenied
resource = self.get_import_resource_class()(**self.get_import_resource_kwargs(request, *args, **kwargs))
context = super(ImportView, self).get_context()
import_formats = self.get_import_formats()
form = ImportForm(import_formats,
request.POST or None,
request.FILES or None)
if request.POST and form.is_valid():
input_format = import_formats[
int(form.cleaned_data['input_format'])
]()
import_file = form.cleaned_data['import_file']
# first always write the uploaded file to disk as it may be a
# memory file or else based on settings upload handlers
tmp_storage = self.get_tmp_storage_class()()
data = bytes()
for chunk in import_file.chunks():
data += chunk
tmp_storage.save(data, input_format.get_read_mode())
# then read the file, using the proper format-specific mode
# warning, big files may exceed memory
try:
data = tmp_storage.read(input_format.get_read_mode())
if not input_format.is_binary() and self.from_encoding:
data = force_text(data, self.from_encoding)
dataset = input_format.create_dataset(data)
except UnicodeDecodeError as e:
return HttpResponse(_(u"<h1>Imported file has a wrong encoding: %s</h1>" % e))
except Exception as e:
return HttpResponse(_(u"<h1>%s encountered while trying to read file: %s</h1>" % (type(e).__name__,
import_file.name)))
result = resource.import_data(dataset, dry_run=True,
raise_errors=False,
file_name=import_file.name,
user=request.user)
context['result'] = result
if not result.has_errors():
context['confirm_form'] = ConfirmImportForm(initial={
'import_file_name': tmp_storage.name,
'original_file_name': import_file.name,
'input_format': form.cleaned_data['input_format'],
})
context['title'] = _("Import") + ' ' + self.opts.verbose_name
context['form'] = form
context['opts'] = self.model._meta
context['fields'] = [f.column_name for f in resource.get_user_visible_fields()]
request.current_app = self.admin_site.name
return TemplateResponse(request, [self.import_template_name],
context)
def home(request):
webpage_schema = get_webpage_schema(request)
return TemplateResponse(
request, 'home.html', {
'parent': None,
'webpage_schema': json.dumps(webpage_schema)})
def template_response(self, template, context):
return TemplateResponse(self.request, template, context, current_app=self.admin_site.name)
def styleguide(request):
return TemplateResponse(request, 'styleguide.html')
def project(request):
context = {}
context['projects'] = Project.objects.all()
return TemplateResponse(request, "frontend/project/list.html", context)
def handle_404(request, exception=None):
return TemplateResponse(request, '404.html', status=404)
def get(self, request):
return TemplateResponse(request, self.template_name, {'form': self.form_class})
def email_settings(request, key):
"""Display email settings.
Args:
key (str): The private key to lookup email subscriber data.
TODO:
* Remove all ES.priv_key lookups and use request.user only.
* Remove settings_helper_get_auth usage.
Returns:
TemplateResponse: The email settings view populated with ES data.
"""
profile, es, __, __ = settings_helper_get_auth(request, key)
if not request.user.is_authenticated and (not es and key) or (
request.user.is_authenticated
and not hasattr(request.user, 'profile')):
return redirect('/login/github?next=' + request.get_full_path())
# handle 'noinput' case
email = ''
level = ''
msg = ''
if request.POST and request.POST.get('submit'):
email = request.POST.get('email')
level = request.POST.get('level')
preferred_language = request.POST.get('preferred_language')
validation_passed = True
try:
validate_email(email)
except Exception as e:
print(e)
validation_passed = False
msg = _('Invalid Email')
if preferred_language:
if preferred_language not in [i[0] for i in settings.LANGUAGES]:
msg = _('Unknown language')
validation_passed = False
if validation_passed:
if profile:
profile.pref_lang_code = preferred_language
profile.save()
request.session[LANGUAGE_SESSION_KEY] = preferred_language
translation.activate(preferred_language)
if es:
key = get_or_save_email_subscriber(email, 'settings')
es.preferences['level'] = level
es.email = email
form = dict(request.POST)
# form was not sending falses, so default them if not there
for email_tuple in ALL_EMAILS:
key = email_tuple[0]
if key not in form.keys():
form[key] = False
es.build_email_preferences(form)
es = record_form_submission(request, es, 'email')
ip = get_ip(request)
es.active = level != 'nothing'
es.newsletter = level in ['regular', 'lite1']
if not es.metadata.get('ip', False):
es.metadata['ip'] = [ip]
else:
es.metadata['ip'].append(ip)
es.save()
msg = _('Updated your preferences.')
pref_lang = 'en' if not profile else profile.get_profile_preferred_language(
)
context = {
'nav':
'internal',
'active':
'/settings/email',
'title':
_('Email Settings'),
'es':
es,
'suppression_preferences':
json.dumps(
es.preferences.get('suppression_preferences', {}) if es else {}),
'msg':
msg,
'email_types':
ALL_EMAILS,
'navs':
get_settings_navs(request),
'preferred_language':
pref_lang
}
return TemplateResponse(request, 'settings/email.html', context)
def feedback(request):
"""Serve the feedback page"""
return TemplateResponse(request, 'help_feedback.html',
{'title': _('Submit Feedback')})
def blog_post(request, blog_slug, post_slug):
context = {
'post': get_object_or_404(Post, slug=post_slug, blog__slug=blog_slug),
}
return TemplateResponse(request, 'blog_post.html', context)
def graph_table(request):
"""Generate graph table page
:param request:
:return:
"""
hostnames = [h.strip() for h in request.GET.getlist('hostname', []) if h]
object_ids = [o.strip() for o in request.GET.getlist('object_id', []) if o]
if len(hostnames) == 0 and len(object_ids) == 0:
return HttpResponseBadRequest('No hostname or object_id provided')
# For convenience we will cache the servers in a dictionary.
servers = {s['hostname']: s for s in
Query({'hostname': Any(*hostnames)}, None)}
servers.update({s['hostname']: s for s in
Query({'object_id': Any(*object_ids)}, None)})
if len(servers) != len(hostnames) + len(object_ids):
messages.error(
request,
'One or more objects with hostname: {} or object_ids: {} does not '
'exist'.format(','.join(hostnames), ','.join(object_ids)))
# Find the collections which are related with all of the hostnames.
# If there are two collections with same match, use only the one which
# is not an overview.
collections = []
for collection in Collection.objects.order_by('overview', 'sort_order'):
if any(collection.name == c.name for c in collections):
continue
for hostname in servers.keys():
if GRAPHITE_ATTRIBUTE_ID not in servers[hostname]:
break # The server hasn't got this attribute at all.
value = servers[hostname][GRAPHITE_ATTRIBUTE_ID]
assert isinstance(value, MultiAttr)
if not any(collection.name == v for v in value):
break # The server hasn't got this attribute value.
else:
collections.append(collection)
# Prepare the graph descriptions
descriptions = []
for collection in collections:
for template in collection.template_set.all():
descriptions += (
[(template.name, template.description)] * len(servers.keys())
)
# Prepare the graph tables for all hosts
graph_tables = []
for hostname in servers.keys():
graph_table = []
if request.GET.get('action') == 'Submit':
custom_params = request.GET.urlencode()
for collection in collections:
column = collection.graph_column(
servers[hostname], custom_params
)
graph_table += [(k, [('Custom', v)]) for k, v in column]
else:
for collection in collections:
graph_table += collection.graph_table(servers[hostname])
graph_tables.append(graph_table)
if len(servers) > 1:
# Add hostname to the titles
for order, hostname in enumerate(servers.keys()):
graph_tables[order] = [(k + ' on ' + hostname, v) for k, v in
graph_tables[order]]
# Combine them
graph_table = []
for combined_tables in zip(*graph_tables):
graph_table += list(combined_tables)
return TemplateResponse(request, 'graphite/graph_table.html', {
'hostnames': servers.keys(),
'descriptions': descriptions,
'graph_table': graph_table,
'link': request.get_full_path(),
'from': request.GET.get('from', '-24h'),
'until': request.GET.get('until', 'now'),
})
def leaderboard(request, key=''):
"""Display the leaderboard for top earning or paying profiles.
Args:
key (str): The leaderboard display type. Defaults to: quarterly_earners.
Returns:
TemplateResponse: The leaderboard template response.
"""
if not key:
key = 'quarterly_earners'
keyword_search = request.GET.get('keyword')
limit = request.GET.get('limit', 25)
titles = {
'quarterly_payers': _('Top Payers'),
'quarterly_earners': _('Top Earners'),
'quarterly_orgs': _('Top Orgs'),
'quarterly_tokens': _('Top Tokens'),
'quarterly_keywords': _('Top Keywords'),
'quarterly_kudos': _('Top Kudos'),
'quarterly_cities': _('Top Cities'),
'quarterly_countries': _('Top Countries'),
'quarterly_continents': _('Top Continents'),
# 'weekly_fulfilled': 'Weekly Leaderboard: Fulfilled Funded Issues',
# 'weekly_all': 'Weekly Leaderboard: All Funded Issues',
# 'monthly_fulfilled': 'Monthly Leaderboard',
# 'monthly_all': 'Monthly Leaderboard: All Funded Issues',
# 'yearly_fulfilled': 'Yearly Leaderboard: Fulfilled Funded Issues',
# 'yearly_all': 'Yearly Leaderboard: All Funded Issues',
# 'all_fulfilled': 'All-Time Leaderboard: Fulfilled Funded Issues',
# 'all_all': 'All-Time Leaderboard: All Funded Issues',
# TODO - also include options for weekly, yearly, and all cadences of earning
}
if settings.ENV != 'prod':
# TODO (mbeacom): Re-enable this on live following a fix for leaderboards by location.
titles['quarterly_cities'] = _('Top Cities')
titles['quarterly_countries'] = _('Top Countries')
titles['quarterly_continents'] = _('Top Continents')
if key not in titles.keys():
raise Http404
title = titles[key]
if keyword_search:
ranks = LeaderboardRank.objects.filter(
active=True,
leaderboard=key,
tech_keywords__icontains=keyword_search)
else:
ranks = LeaderboardRank.objects.filter(active=True, leaderboard=key)
amount = ranks.values_list('amount').annotate(
Max('amount')).order_by('-amount')
items = ranks.order_by('-amount')
top_earners = ''
technologies = set()
for profile_keywords in ranks.values_list('tech_keywords'):
for techs in profile_keywords:
for tech in techs:
technologies.add(tech)
if amount:
amount_max = amount[0][0]
top_earners = ranks.order_by('-amount')[0:5].values_list(
'github_username', flat=True)
top_earners = ['@' + username for username in top_earners]
top_earners = f'The top earners of this period are {", ".join(top_earners)}'
else:
amount_max = 0
profile_keys = [
'_tokens', '_keywords', '_cities', '_countries', '_continents'
]
is_linked_to_profile = any(sub in key for sub in profile_keys)
context = {
'items': items[0:limit],
'titles': titles,
'selected': title,
'is_linked_to_profile': is_linked_to_profile,
'title': f'Leaderboard: {title}',
'card_title': f'Leaderboard: {title}',
'card_desc':
f'See the most valued members in the Gitcoin community recently . {top_earners}',
'action_past_tense':
'Transacted' if 'submitted' in key else 'bountied',
'amount_max': amount_max,
'podium_items': items[:5] if items else [],
'technologies': technologies,
'active': 'leaderboard'
}
return TemplateResponse(request, 'leaderboard.html', context)
