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)