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 index(request): print " " print "*******VIEWS INDEX******" print " " response = TemplateResponse(request, 'index.html', {} ) response.render() return response
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 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 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 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 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 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 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 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 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 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 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_template_response(self): msg = ( "TemplateResponse's template argument cannot be a " "django.template.Template anymore. It may be a backend-specific " "template like those created by get_template()." ) with warnings.catch_warnings(record=True) as warns: warnings.simplefilter("always") response = TemplateResponse(HttpRequest(), Template("foo")) response.render() self.assertEqual(response.content, b"foo") self.assertEqual(len(warns), 1) self.assertEqual(str(warns[0].message), msg)
def list_users(request): """ Lists all users. Available only for admins. """ order_by = request.GET.get('order_by', 'username') users = User.objects.all().order_by(order_by) if check_moderator: users = User.objects.filter(userprofile__guild = request.user.userprofile.guild).order_by(order_by) if check_admin: users = User.objects.all().order_by(order_by) response = TemplateResponse(request, 'userlist.html', {'users': users}) response.render() return response
def maillist_maintain_ajax(request, list_id): data = request.GET order_column = data.get('order[0][column]', '') order_dir = data.get('order[0][dir]', '') search = data.get('search[value]', '') colums = ['id', 'id', 'address', 'permit', 'update_time'] lists = ExtListMember.objects.filter(list_id=list_id) lobj = ExtList.objects.get(id=list_id) if search: lists = lists.filter(address__icontains=search) if order_column and int(order_column) < len(colums): if order_dir == 'desc': lists = lists.order_by('-%s' % colums[int(order_column)]) else: lists = lists.order_by('%s' % colums[int(order_column)]) try: length = int(data.get('length', 1)) except ValueError: length = 1 try: start_num = int(data.get('start', '0')) page = start_num / length + 1 except ValueError: start_num = 0 page = 1 count = lists.count() if start_num >= count: page = 1 paginator = Paginator(lists, length) try: lists = paginator.page(page) except (EmptyPage, InvalidPage): lists = paginator.page(paginator.num_pages) rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []} re_str = '<td.*?>(.*?)</td>' number = length * (page - 1) + 1 for d in lists.object_list: t = TemplateResponse(request, 'maillist/maillist_maintain_ajax.html', {'d': d, 'number': number, 'lobj': lobj,}) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) number += 1 return HttpResponse(json.dumps(rs), content_type="application/json")
def get_js_hierarchy(request, who_url, obj_self, obj_parent, level=2, obj_visited=set(), show_inactive_user=False): """ Recursively go through obj_self... """ relationships = [] # used by the Google JavaScript ldap_objects = [] if level <= 0 or obj_self in obj_visited: return relationships, ldap_objects if not show_inactive_user and not obj_self.is_active: # if flag is to not show inactive and user is not active, skip return relationships, ldap_objects ldap_obj_dict = obj_self.__dict__ ldap_obj_dict['username'] = obj_self.username ldap_obj_dict['photo_url'] = obj_self.photo_url _template = TemplateResponse(request, APP_NAME + '/person.html', {'ldap_obj': ldap_obj_dict, 'who_url': who_url}) _template.render() relationships.append(({ 'v': obj_self.mail, 'f': _template.content }, obj_parent.mail if obj_parent else '', obj_self.mail)) ldap_objects.append(obj_self) obj_visited.add(obj_self) for report_obj in obj_self.reports: _relationship, _ldap_objects = get_js_hierarchy(request, who_url, report_obj, obj_self, level - 1, obj_visited, show_inactive_user) relationships.extend(_relationship) ldap_objects.extend(_ldap_objects) return relationships, ldap_objects
def ajax_reviewrule_list(request): data = request.GET order_column = data.get('order[0][column]', '') order_dir = data.get('order[0][dir]', '') search = data.get('search[value]', '') colums = ['id', 'id', 'review', 'name', 'workmode', 'cond_logic', 'pre_action', 'target_dept', 'sequence', 'disabled'] lists = ReviewRule.objects.all() if search: lists = lists.filter(name__icontains=search) if order_column and int(order_column) < len(colums): if order_dir == 'desc': lists = lists.order_by('-%s' % colums[int(order_column)]) else: lists = lists.order_by('%s' % colums[int(order_column)]) try: length = int(data.get('length', 1)) except ValueError: length = 1 try: start_num = int(data.get('start', '0')) page = start_num / length + 1 except ValueError: start_num = 0 page = 1 count = lists.count() if start_num >= count: page = 1 paginator = Paginator(lists, length) try: lists = paginator.page(page) except (EmptyPage, InvalidPage): lists = paginator.page(paginator.num_pages) rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []} re_str = '<td.*?>(.*?)</td>' number = length * (page-1) + 1 for d in lists.object_list: t = TemplateResponse(request, 'review/ajax_reviewrule.html', {'d': d, 'number': number}) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) number += 1 return HttpResponse(json.dumps(rs), content_type="application/json")
def perfil(request): profile = Profile.objects.get(user_id=request.user.id) alertas = AvisoPorEmail.objects.filter(user_alerta=request.user.id) if request.method == 'POST': pais = request.POST.get('pais') email = request.POST.get('email') telefone = request.POST.get('telefone') profissao = request.POST.get('profissao') organizacao = request.POST.get('organizacao') first_name = request.POST.get('first_name') last_name = request.POST.get('last_name') user = request.user if User.objects.filter(email=email).exists(): messages.error(request, 'E-mail já cadastrado.') else: user.email = email user.first_name = first_name user.last_name = last_name profile.telefone = telefone profile.organizacao = organizacao profile.pais = pais user.save() profile.save() html = TemplateResponse(request, 'app2/perfil.html', { 'profile': profile, 'alertas': alertas }) return HttpResponse(html.render())
def submissionIndex(request, rpk): '''Make a new Submission for Report/Template selected''' scope = 'submission' form = SubmissionForm(rpk, request.POST or None, request.FILES or None) if request.method == 'POST': if form.is_valid(): cxt = check_quality(request, request.FILES['upload'], form.cleaned_data['template']) if cxt: obj = form.save(commit=False) obj.report_id = rpk obj.name = request.FILES['upload'].name obj.submitted_by = request.user if cxt['clean'] == 'false': obj.is_clean = False obj.upload.delete(save=False) else: obj.is_clean = True request.session['analysis'] = cxt obj.save() return redirect('porter:result', rpk=rpk) else: messages.error(request, 'Please submit a valid xlsx or csv file') html = TemplateResponse(request, 'porter/submit.html', { 'form': form, 'scope': scope }) return HttpResponse(html.render())
def dayofweeklist(request): try: logger.info("/todos/dayofweeklist") c = {} c.update(csrf(request)) if request.user.is_superuser: response = TemplateResponse(request, 'todos/admin_dayofweeklist.html', c) else: response = TemplateResponse(request, 'todos/dayofweeklist.html', c) response.render() return response except Exception as e: logger.error(traceback.format_exc()) return ErrClass('UNKNWON_ERROR').response()
def get_ruta(request, video): #ejemplo global array ruta, distancia, MA = rutaRecoleccion(array) mr = [] #Calcula todas las posibles rutas y la que tiene la menor distancia mejorR, mejorD = mejorRuta(MA) print(mejorR, mejorD) error = round(abs(mejorD - distancia) * 100 / mejorD, 1) for e in MA: mr.append([round(elem, 1) for elem in e]) distancia = round(distancia, 1) context = { 'vector': str(array), 'ruta': str(ruta), 'distancia': distancia, 'video': video, 'MatAdy': mr, 'mejorRuta': mejorR, 'mejorDistancia': mejorD, 'error': error } html = TemplateResponse(request, 'ruta.html', context) return HttpResponse(html.render())
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 resultIndex(request, rpk): '''Result page showing analysis of data quality''' scope = 'result' df_meta, df_report = None, None if 'analysis' in request.session: cxt = request.session['analysis'] clean, df_meta, df_report = cxt['clean'], cxt['df_meta'], cxt[ 'df_report'] if clean == 'true': messages.success( request, 'SUCCESS: Uploaded data passes all quality checks. Thank you!') elif clean == 'false': messages.error( request, 'ERROR: Quality check for submission failed, please correct accordingly and resubmit' ) del request.session['analysis'] else: messages.error(request, 'SYSTEM ERROR: No valid submission found') return redirect('porter:submission', rpk=rpk) html = TemplateResponse(request, 'porter/result.html', { 'scope': scope, 'df_meta': df_meta, 'df_report': df_report }) return HttpResponse(html.render())
def job_list(request): context = {} context['jobs'] = JobList.objects.all() print(context) html = TemplateResponse(request, 'joblist.html', context) return HttpResponse(html.render())
def products_list(request): context = {} context['products'] = Product.objects.all() html = TemplateResponse(request, 'adding_to_cart.html', context) return HttpResponse(html.render())
def show(request, slug): slideshow = get_object_or_404(Slideshow, slug=slug) options = slideshow.user.profile.options if options is None: options = {} try: options.update(slideshow.options) except TypeError: pass engine = options.get('engine', 'remark').replace( '../', '') # TODO get from site wide config if engine == 'cleaver': slides, cleaver_options = slideshow.parse_cleaver_slides() default_cleaver_options = { 'controls': True, 'progress': True, 'encoding': 'utf-8' } options = {**default_cleaver_options, **options, **cleaver_options} if options['author']: t = TemplateResponse(request, f'{engine}/author.html', {'author': options['author']}) t.render() slides.append({ 'classes': 'hidden', 'content': t.rendered_content, }) slideshow.slides = slides slideshow.options = options try: engine_options = options[engine] except KeyError: engine_options = {} return render(request, f'{engine}/show.html', { 'slideshow': slideshow, 'options': json.dumps(engine_options), })
def check_upc_price_plan(request, upc): upc_obj = request.db_session.query(UPC).filter_by(upc=upc).first() if upc_obj.tariff_plan: return JsonResponse(json_response_content('success', 'Tariff plan is assigned')) else: from django.template.response import TemplateResponse tariff_plans = request.db_session.query(TariffPlan)\ .filter(TariffPlan.company_id == request.user.company_id)\ .all() response = json_response_content('warning', 'Please assign tariff plan before going on.') html = TemplateResponse(request, 'modals/add_disk_priceplan_issue.html', {'upc': upc_obj, 'tariffPlans': tariff_plans}) html.render() response['data'] = { 'modal_html': html.content } return JsonResponse(response)
def noteDetailView(request, pk): note_obj = Notes.objects.filter(pk=pk).first() if not note_obj or note_obj.user != request.user: response = TemplateResponse(request, 'notes/403.html', {}) response.render() return HttpResponseForbidden(response) tag_list = concatTags(note_obj) print(tag_list) context = { 'note_id': note_obj.id, 'title': note_obj.title, 'last_modified': note_obj.last_modified, 'note_text': note_obj.note_text, 'tags': tag_list } return render(request, 'notes/notes_detail.html', context=context)
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 editar_alerta(request, id): editar = AvisoPorEmail.objects.get(id=id) alertas = AvisoPorEmail.objects.filter(user_alerta=request.user.id) igual = False if request.method == 'POST': nome = request.POST.get('nome_alerta') frequencia = request.POST.get('frequencia') busca_global = request.POST.get('busca_global') idiomas = request.POST.get('idiomas') autor = request.POST.get('autor') titulo_e_resumo = request.POST.get('titulo_e_resumo') opcao_titulo_resumo = request.POST.get('titulo_resumo') button_autores = request.POST.get('tipoAutores') button_titulo_e_resumo = request.POST.get('tipoTituloResumo') if busca_global or idiomas or autor or titulo_e_resumo: for alerta in alertas: if alerta.busca_global == busca_global and alerta.idiomas == idiomas and alerta.titulo_e_resumo == titulo_e_resumo and alerta.autor == autor: if alerta.opcao_titulo_resumo == opcao_titulo_resumo or ( alerta.opcao_titulo_resumo != opcao_titulo_resumo and alerta.titulo_e_resumo == "" and titulo_e_resumo == ""): if alerta.button_titulo_e_resumo == button_titulo_e_resumo or ( alerta.button_titulo_e_resumo != button_titulo_e_resumo and alerta.titulo_e_resumo == "" and titulo_e_resumo == ""): if alerta.button_autores == button_autores or ( alerta.button_autores != button_autores and alerta.autor == "" and autor == ""): if alerta.id != editar.id: igual = True else: if nome == alerta.nome and frequencia == alerta.frequencia: igual = True if not igual: editar.nome = nome editar.frequencia = frequencia editar.busca_global = busca_global editar.idiomas = idiomas editar.autor = autor editar.titulo_e_resumo = titulo_e_resumo editar.opcao_titulo_resumo = opcao_titulo_resumo editar.button_autores = button_autores editar.button_titulo_e_resumo = button_titulo_e_resumo editar.save() return redirect('/cadastro/meus-alertas') else: messages.error( request, 'Esse alerta já foi criado. Verifique seus alertas.') else: messages.error(request, 'Alerta vazio. Preencha pelo menos um campo.') html = TemplateResponse(request, 'app2/meus_alertas.html', {'alerta': editar}) return HttpResponse(html.render())
def department_member_ajax(request, dpt_id): data = request.GET order_column = data.get('order[0][column]', '') order_dir = data.get('order[0][dir]', '') search = data.get('search[value]', '') obj = Department.objects.get(id=dpt_id) colums = ['id', 'id'] lists = DepartmentMember.objects.filter(dept_id=dpt_id) if lists.exists() and order_column and int(order_column) < len(colums): if order_dir == 'desc': lists = lists.order_by('-%s' % colums[int(order_column)]) else: lists = lists.order_by('%s' % colums[int(order_column)]) try: length = int(data.get('length', 1)) except ValueError: length = 1 try: start_num = int(data.get('start', '0')) page = start_num / length + 1 except ValueError: start_num = 0 page = 1 count = lists.count() if start_num >= count: page = 1 paginator = Paginator(lists, length) try: lists = paginator.page(page) except (EmptyPage, InvalidPage): lists = paginator.page(paginator.num_pages) rs = {"sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": []} re_str = '<td.*?>(.*?)</td>' number = length * (page - 1) + 1 for d in lists.object_list: mailobj = Mailbox.objects.filter(id=d.mailbox_id).first() t = TemplateResponse(request, 'dpt/dpt_mem_ajax.html', {'d': d, 'number': number, 'mailobj': mailobj}) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) number += 1 return HttpResponse(json.dumps(rs), content_type="application/json")
def index(request): # news = News.objects.order_by('-pub_date')[:4] last_session = CourseSession.objects.order_by('-pub_date').last() video = Video.objects.order_by('-pub_date')[:5] poster = Poster.objects.order_by('-pub_date')[:4] event = Course.objects.order_by('-pub_date')[0] events = Course.objects.order_by('-pub_date')[:4] t = TemplateResponse( request, 'home.html', { 'last_session': last_session, 'posters': poster, 'videos': video, 'events': events, 'event': event }) t.render() return HttpResponse(t)
def game(request): gameID = request.GET['gameID'] owned = False currentuser = request.user purchased = Purchased.objects.filter(owner__id=currentuser.id) game = Games.objects.get(id=gameID) scorelist = [] for entry in purchased: if game == entry.game: owned = True break pid = "{}:{}".format(currentuser.id, game.id) checksumstr = "pid={}&sid={}&amount={}&token={}".format(pid, "GameshopAAC", game.price, "c858a84d04755915ded5daba44a3644f") m = md5(checksumstr.encode("ascii")) checksum = m.hexdigest() response = TemplateResponse(request, 'game.html', {'game': game, 'owned': owned, 'checksum':checksum, 'pid':pid}) response.render() return response
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 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 login(request, template_name='login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=StrictAuthenticationForm, current_app=None, extra_context=None): """ Displays the login form and handles the login action. This view is the same as the Django 1.6 login view but uses the StrictAuthenticationForm """ redirect_to = request.POST.get(redirect_field_name, request.GET.get(redirect_field_name, '')) if request.method == "POST": form = authentication_form(request, data=request.POST) if form.is_valid(): # Ensure the user-originating redirection url is safe. if not is_safe_url(url=redirect_to, host=request.get_host()): redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL) # Okay, security check complete. Log the user in. auth_login(request, form.get_user()) return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) current_site = get_current_site(request) context = { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, } if extra_context is not None: context.update(extra_context) response = TemplateResponse(request, template_name, context) # current_app=current_app) response.render() return response
def ajax_get_mails(request): data = request.GET mails = get_all_data(data, user=request.user) try: length = int(data.get('length', 1)) except ValueError: length = 1 try: page = int(data.get('start', '0')) / length + 1 except ValueError: page = 1 try: count = mails.count() except: count = len(mails) paginator = Paginator(mails, length) try: mails = paginator.page(page) except (EmptyPage, InvalidPage): mails = paginator.page(paginator.num_pages) rs = { "sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": [] } re_str = '<td.*?>(.*?)</td>' for m in mails.object_list: t = TemplateResponse(request, 'collect_mail/ajax_get_mails.html', { 'm': m, 'date': m.get_date() }) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) return HttpResponse(json.dumps(rs, ensure_ascii=False), content_type="application/json")
def page_to_html(page, language=None, encoding='utf-8'): # generate request request = CMSRequestFactory().request() request.current_page = page # generate request context context = RequestContext(request) context['lang'] = language or app_settings.DEFAULT_LANGUAGE context['current_page'] = page # generate template response template_name = get_template_from_request(request, page) response = TemplateResponse(request, template_name, context) response.render() # generate html html = response.content.decode(encoding) return html
def render(self, request, templates, context, tz=None, **kwargs): logger.debug( "{app}.render: {request.path}".format( app=self.__class__.__name__, request=request ) ) context.update({"application": self}) kwargs.setdefault("context", context) response = TemplateResponse(request, templates, **kwargs) response.current_app = self.current_app if tz is not None: with timezone.override(tz): response.render() if not request.user.is_anonymous: patch_cache_control(response, private=True) return response
def get_video(request, n): #numero de elementos global array, real #Para el video de 3 if n == "3": array = [[36.498141627543035, 18.134324942062158], [100.33624093043105, 30.837831651842286], [119.65437940140836, 15.18749713897705]] real = [[33, 22.2], [77, 30.5], [94, 16]] #Para el de 3 elif n == "5": array = [[29.51785714285714, 19.596770501905876], [48.30952380952381, 9.848212242126465], [65.27771335807051, 26.63414075897961], [87.63265306122445, 13.806815580888228], [103.59226190476184, 30.837831651842286]] real = [[31, 21.5], [46, 10.8], [60, 27.8], [83, 16], [99, 32.2]] elif n == "6": array = [[5.35066526610644, 16.651682821552411], [26.588662790697676, 18.999997174298311], [41.14233193277305, 22.9245239833616], [63.77083333333323, 24.83783165184227], [76.67867772108823, 25.928565979003906], [100.29501488095215, 24.837831651842286]] real = [[5, 17.8], [26, 20.6], [40.7, 24.8], [60.7, 26.7], [80.7, 27.3], [100.6, 26.4]] elif n == "8": array = [[5.545454545454547, 17.525770836269736], [20.1375, 18.13432494206214], [40.07675438596492, 13.499997456868483], [50.92538759689921, 27.3749942779541], [73.93311403508767, 21.112672832650208], [88.74621212121211, 30.153840285081102], [100.38541666666673, 10.878046919659877], [112.77559523809535, 19.285710652669273]] real = [[5, 17.3], [20.7, 21], [40.3, 13.8], [50.7, 27.3], [73, 20.5], [88, 28], [100.5, 11.5], [112, 25.5]] #calculo de error promErrorDist = 0 promErrorAng = 0 for i in range(len(real)): promErrorAng += round(abs(real[i][0] - array[i][0]) * 100 / real[i][0]) promErrorDist += round( abs(real[i][1] - array[i][1]) * 100 / real[i][1]) promErrorDist = promErrorDist / (i + 1) promErrorAng = promErrorAng / (i + 1) promErrorDist = round(promErrorDist, 2) promErrorAng = round(promErrorAng, 2) context = {'n': n, 'ea': promErrorAng, 'ed': promErrorDist} html = TemplateResponse(request, 'video.html', context) return HttpResponse(html.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 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 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 ajax_mailLogActiveUserStat(request): last_time = time.time() flag, lists, condition, start_num, page, length, showmax = mailLogActiveSearch( request) #print "mailLogActiveSearch: ",condition #last_time = count_time(last_time) MB = 1024 * 1024.0 count = len(lists) if showmax > 0 and count > showmax: count = showmax if start_num >= count: page = 1 paginator = Paginator(lists, length) #print "mailLogActiveSearch Paginator" #last_time = count_time(last_time) try: page_lists = paginator.page(page) except (EmptyPage, InvalidPage): page_lists = paginator.page(paginator.num_pages) rs = { "sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": [] } re_str = '<td.*?>(.*?)</td>' number = length * (page - 1) + 1 for d in page_lists.object_list: data = mailLogActiveStatSingle(flag, lists, d, condition) #print "mailLogActiveStatSingle: ",d #last_time = count_time(last_time) data["number"] = number t = TemplateResponse(request, 'maillog/ajax_active_user.html', data) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) number += 1 return HttpResponse(json.dumps(rs), content_type="application/json")
def retrieve_new_collections(request): post = request.POST chosen_filters = [] collections = [] retrieve = False error_msg = "" # click tab retrieve new collections if not post: chosen_filters = [(0, enum.Tag.TITLE, "")] # add filter elif "add_filter" in post: nr_filters = int(post["nr_filters"]) chosen_filters = [] for i in range(nr_filters): chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)])) chosen_filters.append((nr_filters, enum.Tag.TITLE, "")) # remove filter elif "remove_filter" in post: nr = int(post["remove_filter"]) nr_filters = int(post["nr_filters"]) chosen_filters = [] for i in range(nr_filters): if i < nr: chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)])) elif i > nr: chosen_filters.append((i-1, post["filter"+str(i)], post["query"+str(i)])) # retrieve collections elif "retrieve" in post: try: retrieve = True nr_filters = int(post["nr_filters"]) chosen_filters = [] for i in range(nr_filters): chosen_filters.append((i, post["filter"+str(i)], post["query"+str(i)])) collections = Collection.retrieve_collections(request.user, [(k,v) for (_,k,v) in chosen_filters]) except CannotParseStringToDateException as exc: error_msg = "Incorrect date: " + exc.date else: pass t = TemplateResponse(request, 'collection/retrieve_new_collections.html', {'filter_choices': [t for t in enum.Tag.CHOICES_B], 'chosen_filters': chosen_filters, 'collections': collections, 'error_msg': error_msg, 'retrieve': retrieve}) return HttpResponse(t.render())
def ajax_get_notices(request): data = request.GET notices = get_notices(data, request.user) try: length = int(data.get('length', 1)) except ValueError: length = 1 try: page = int(data.get('start', '0')) / length + 1 except ValueError: page = 1 count = len(notices) paginator = Paginator(notices, length) try: notices = paginator.page(page) except (EmptyPage, InvalidPage): notices = paginator.page(paginator.num_pages) rs = { "sEcho": 0, "iTotalRecords": count, "iTotalDisplayRecords": count, "aaData": [] } re_str = '<td.*?>(.*?)</td>' for n in notices.object_list: t = TemplateResponse(request, 'core/ajax_get_notices.html', { 'n': n, 'type': type }) t.render() rs["aaData"].append(re.findall(re_str, t.content, re.DOTALL)) return HttpResponse(json.dumps(rs, ensure_ascii=False), content_type="application/json")
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, }, ) with 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.headers["content-type"], response.headers["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 simple_upload(request): html = TemplateResponse(request, 'upload_category.html') if request.method == 'POST': category_resource = CategoryResource dataset = Dataset() new_categories = request.FILES['myfile'] imported_data = dataset.load(new_categories.read()) result = category_resource.import_data(imported_data, dry_run=True) if not result.has_errors(): category_resource.import_data(imported_data, dry_run=False) return HttpResponse(html.render())
def ajax_get_maillist_trigger(request): data = request.GET list_id = int(data.get('list_id', 0)) task_id = data.get('task_id', None) cr = connections['mm-pool'].cursor() tablename = 'ml_subscriber_' + str(request.user.id) sql = "SELECT COUNT(1) FROM %s WHERE list_id=%d;" % (tablename, list_id) cr.execute(sql) data = cr.fetchone() count = data[0] if data else 0 # 获取 关联的触发器 html = '' trigger_ids = [] if task_id: task_obj = SendTask.objects.filter(id=task_id).first() trigger_ids = task_obj.trigger_set.filter(status='enable').values_list("id", flat=True) lists = Trigger.getTriggerBylist(request.user.id, list_id, type='open') if lists: t = TemplateResponse(request, 'task/trigger.html', {'lists': lists, 'task_id': task_id, 'trigger_ids': trigger_ids,}) t.render() html = t.content return HttpResponse(json.dumps({'count': count, 'html': html}), content_type="application/json")
def list_user_events(request): order_by_events = request.GET.get('order_by_events', 'guild') user = request.user if user.profile.is_tf == 1: tf = 14 else: tf = 20 # ??? events = Event.objects.filter(Q(guild__id = user.profile.guild_id) | Q(guild__id = general_id) | Q(guild__id = tf)).order_by(order_by_events) attendances = Attendance.objects.filter(Q(user__id = request.user.pk)) for event in events: event.times_attended = attendances.filter(event=event.pk).count() # check if event is attended more than it's allowed amount and disable attending it if so event.disabled = event.times_attended >= event.repeats response = TemplateResponse(request, 'eventlist.html', { 'events': events, 'order_by_events': order_by_events }) response.render() return response
def profile(request, username): if request.user.username == username: if request.method == "POST": u_form = UserUpdateForm(request.POST, instance=request.user) p_form = ProfileUpdateForm(request.POST, request.FILES, instance=request.user.profile) if u_form.is_valid() and p_form.is_valid(): u_form.save() p_form.save() messages.success( request, 'Your profile has successfully been updated.') return redirect('/profile/{}'.format(request.user.username)) else: u_form = UserUpdateForm(instance=request.user) p_form = ProfileUpdateForm(instance=request.user.profile) context = {'u_form': u_form, 'p_form': p_form, 'title': 'Profile'} return render(request, 'users/profile.html', context=context) response = TemplateResponse(request, 'notes/403.html', {}) response.render() return HttpResponseForbidden(response)
def ajax_get_maillistcount_and_triggers(request): data = request.GET list_ids = data.get('list_ids', "0") task_id = data.get('task_id', None) lists = MailList.objects.filter( Q(customer=request.user) | Q(sub_share_maillist__user=request.user)).filter( id__in=map(int, list_ids.split(","))).values_list("id", "customer_id", "count_real") count = 0 index = 0 html = '' user_ids = defaultdict(list) for list_id, customer_id, count_real in lists: user_ids[customer_id].append(list_id) index += 1 count += count_real # cr = connections['mm-pool'].cursor() # for customer_id, listids in user_ids.items(): # tablename = 'ml_subscriber_' + str(customer_id) # sql = "SELECT COUNT(1) FROM {} WHERE list_id IN ({});".format(tablename, ",".join(map(str, listids))) # cr.execute(sql) # data = cr.fetchone() # c = data[0] if data else 0 # MailList # count += c # index += 1 if index==1 and user_ids.keys()[0] == request.user.id: # 获取 关联的触发器 trigger_ids = [] if task_id: task_obj = SendTask.objects.filter(id=task_id).first() trigger_ids = task_obj.trigger_set.filter(status='enable').values_list("id", flat=True) lists = Trigger.getTriggerBylistids(request.user.id, list_ids.split(","), type='open') if lists: t = TemplateResponse(request, 'task/trigger.html', {'lists': lists, 'task_id': task_id, 'trigger_ids': trigger_ids,}) t.render() html = t.content return HttpResponse(json.dumps({'count': count, 'html': html}), content_type="application/json")
def reportsetIndex(request, pk=None): '''Reportset organizes both Templates and Reports, under a Group/Account''' scope = 'reportset' instance = get_object_or_404(ReportSet, pk=pk) if pk else None form = ReportSetForm(request.user, request.POST or None, instance=instance) if form.is_valid(): obj = form.save(commit=False) if not pk: obj.create_by = request.user obj.save() html = TemplateResponse(request, 'porter/create.html', { 'form': form, 'scope': scope }) return HttpResponse(html.render())
def submit_login(request): if request.method == "POST": username = request.POST['username'] password = request.POST['password'] user = authenticate(username=username, password=password) if user is not None: login(request, user) return redirect('/cadastro/') else: messages.error(request, 'Usuário/Senha inválidos. Favor tentar novamente.') html = TemplateResponse(request, 'app2/login.html') return HttpResponse(html.render())
def unsupported(request): if hasattr(settings, "BADBROWSER_SUGGEST"): suggest = settings.BADBROWSER_SUGGEST else: suggest = ("firefox",) if hasattr(settings, "BADBROWSER_BASE_TEMPLATE"): base_template = settings.BADBROWSER_BASE_TEMPLATE else: base_template = "badbrowser/base.html" t = TemplateResponse(request, 'badbrowser/unsupported.html', { "next": request.path, "suggest": suggest, "base_template": base_template }) return t.render()
def manage_my_collections(request): try: collections = request.user.subscriptions.all() except Collection.DoesNotExist: raise Http404 cols = [] for c in collections: cols.append({"id": c.identifier, "name": c.name, "abstract": c.abstract, "revision": c.revision, "access": request.user.get_permission(c)}) t = TemplateResponse(request, 'collection/manage_my_collections.html', {'collections': cols}) return HttpResponse(t.render())
def public_folder(request, rel_path=''): # class the files in categories collection, directory or file dirs = [] files = [] for item_name in PublicFolder.list_dir(rel_path): rel_item_path = os.path.join(utils.path.no_slash(rel_path), item_name) if PublicFolder.is_file(rel_item_path): file_size = PublicFolder.get_file_size(rel_item_path) f = PublicFolder.get_file(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 PublicFolder.is_dir(rel_item_path): collection = PublicFolder.get_collection(rel_item_path) dir_size = PublicFolder.get_dir_size(rel_item_path) # collection if collection: dirs.append({"type": "c", "id": collection.identifier, "name": collection.directory.name, "size": utils.units.convert_data_size(dir_size), "revision": collection.revision}) # standard directory else: d = PublicFolder.get_dir(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/public_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}) return HttpResponse(t.render())