def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: if (response.streaming or response.has_header('Content-Encoding') or not self._accepts_brotli_encoding(request) or len(response.content) < MIN_LEN_FOR_RESPONSE_TO_PROCESS): # --------- # 1) brotlipy doesn't support streaming compression, see: https://github.com/google/brotli/issues/191 # 2) Avoid brotli if we've already got a content-encoding. # 3) Client doesn't support brotli # 4) It's not worth attempting to compress really short responses. # This was taken from django GZipMiddleware. # --------- return response patch_vary_headers(response, ('Accept-Encoding', )) compressed_content = brotli.compress(response.content) # Return the compressed content only if it's actually shorter. if len(compressed_content) >= len(response.content): return response response.content = compressed_content response['Content-Length'] = str(len(response.content)) if response.has_header('ETag'): response['ETag'] = re.sub(r"\"$", r";br\"", response['ETag']) response['Content-Encoding'] = 'br' return response
def test_drop_vary_headers(self): response = HttpResponse() self.assertFalse(response.has_header('Vary')) patch_vary_headers(response, ['Cookie']) self.assertTrue(response.has_header('Vary')) self.assertEqual(response['Vary'], 'Cookie') patch_vary_headers(response, ['Nomnomnom']) self.assertEqual(response['Vary'], 'Cookie, Nomnomnom') drop_vary_headers(response, ['Cookie']) self.assertEqual(response['Vary'], 'Nomnomnom') drop_vary_headers(response, ['Nomnomnom']) self.assertFalse(response.has_header('Vary'))
def __call__(self, request): django_response = HttpResponse() def start_response(status, headers): status, reason = status.split(' ', 1) django_response.status_code = int(status) for header, value in headers: django_response[header] = value environ = request.META.copy() environ['wsgi.input'] = request environ['wsgi.multithread'] = False response = WsgiApplication.__call__(self, environ, start_response) #TODO: можно сказать, что это костыль, без него не работает. #Может быть когда то spyne научится делать это сам, как надо sopa клиенту qiwi data = (u"".join(response))\ .replace('tns:updateBillResult', 'updateBillResult') if self.debug_mode is None: self.debug_mode = bool(settings.DEBUG) if self.debug_mode: logger = logging.getLogger(LOGGER_NAME) logger.debug(u'soap response content: {0}'.format(data)) django_response.content = data if django_response.has_header('Content-Length'): django_response['Content-Length'] = len(data) return django_response
def process_response( self, request: HttpRequest, response: HttpResponse ) -> HttpResponse: if ( response.has_header("Content-Encoding") or not self._accepts_brotli_encoding(request) or ( not response.streaming and len(response.content) < MIN_LEN_FOR_RESPONSE_TO_PROCESS ) ): # --------- # 1) brotlipy doesn't support streaming compression, see: https://github.com/google/brotli/issues/191 # 2) Avoid brotli if we've already got a content-encoding. # 3) Client doesn't support brotli # 4) It's not worth attempting to compress really short responses. # This was taken from django GZipMiddleware. # --------- return response patch_vary_headers(response, ("Accept-Encoding",)) if response.streaming: compressed_content = self.compress_stream(response.streaming_content) response.streaming_content = compressed_content # Delete the `Content-Length` header for streaming content, because # we won't know the compressed size until we stream it. del response["Content-Length"] else: compressed_content = brotli.compress(response.content) # Return the compressed content only if it's actually shorter. if len(compressed_content) >= len(response.content): return response response.content = compressed_content response["Content-Length"] = str(len(compressed_content)) if response.has_header("ETag"): response["ETag"] = re.sub(r"\"$", r";br\"", response["ETag"]) response["Content-Encoding"] = "br" return response
def main_document_view(request, urn=None, wiki_page=None, wiki_revision=None): """Dispatches the appropriate view for a resource/page """ requested_view = request.GET.get('view', None) resource_database = get_resource_database() if requested_view == 'raw': etag = __handle_etag(request, ['raw', urn], weak=False) # fixme: we may also want to set last-modified, expires, max-age try: data_iterator = resource_database[urn] except KeyError: raise Http404 response = HttpResponse(list(data_iterator), # see django #6527 content_type='application/octet-stream') response["ETag"] = etag return response if request.method == "GET": unvaried_etag = [urn, bool(wiki_page), request.META.get("QUERY_STRING", "")] varied_etag = unvaried_etag + [request.LANGUAGE_CODE, bool(request.is_secure()), request.META.get("HTTP_COOKIE", "")] unvaried_etag = __handle_etag(request, unvaried_etag) varied_etag = __handle_etag(request, varied_etag) try: resource = resource_database.get_resource_object(urn) except KeyError: raise Http404("resource does not exist") except UnexpectedHeader as e: raise Http404(str(e)) request.ductus = DuctusRequestInfo(resource, requested_view, wiki_page, wiki_revision) try: f = registered_views[resource.fqn][requested_view] except KeyError: try: f = registered_views[None][requested_view] except KeyError: return query_string_not_found(request) if not f.meets_requirements(request.ductus): return query_string_not_found(request) response = f(request) if request.method == "GET" and not response.has_header("ETag"): if getattr(response, "_unvarying", False): response["ETag"] = unvaried_etag else: vary_headers = set([h.strip().lower() for h in response.get("Vary", "").split(',') if h]) if vary_headers.issubset(set(['cookie', 'accept-language'])): response["ETag"] = varied_etag return response
def dispatch(self, request, *args, **kwargs): if request.method not in self.unauthenticated_methods: if not ( can(request, 'modify_data') and (request.method == 'DELETE' or request.META.get('CONTENT_TYPE').strip().startswith('application/json')) ): resp = HttpResponse("You need to be logged in to do that.", content_type='text/plain') resp.status_code = 401 return resp request.pretty_print = bool(request.GET.get('indent')) request.response_format = self.determine_response_format(request) request.response_version = self.determine_response_version(request) request.html_response = (request.response_format == 'text/html') if request.html_response: if request.COOKIES.get('open511_browser_format') == 'json': request.response_format = 'application/json' else: request.response_format = 'application/xml' request.pretty_print = True request.accept_language = self.determine_accept_language(request) try: result = super(APIView, self).dispatch(request, *args, **kwargs) except BadRequest as e: return HttpResponseBadRequest(unicode(e)) if isinstance(result, HttpResponse): return result self.remove_unselected_fields(request, result) if request.response_format == 'application/xml': resp = self.render_xml(request, result) elif request.response_format == 'application/json': resp = self.render_json(request, result) else: resp = HttpResponse('This API can only return data in XML or JSON.', status=406) if request.html_response: resp = self.render_api_browser(request, resp.content) # Set response headers if 'HTTP_ORIGIN' in request.META and request.method == 'GET': # Allow cross-domain requests resp['Access-Control-Allow-Origin'] = '*' if not resp.has_header('Expires'): resp['Expires'] = http_date(time.time()) patch_vary_headers(resp, ['Accept', 'Accept-Language', 'Open511-Version']) return resp
def test_vary_not_applied_outside_api(self): request = self.request_factory.get('/somewhere') request.is_api = False response = HttpResponse() APIRequestMiddleware().process_response(request, response) assert not response.has_header('Vary') response['Vary'] = 'Foo, Bar' APIRequestMiddleware().process_response(request, response) assert response['Vary'] == 'Foo, Bar'
def default_index(request): response = HttpResponse('this girl seems sad') print(response.content) response.write('<br/>') response.write('<h1>Do not be sad</h1>') print(response.charset) # utf8 response.status_code = 404 print(response.reason_phrase) # 200 response.status_code = 200 print(response.reason_phrase) print(response.closed) response = HttpResponse('国不破,山河犹在', content_type='text/html', status=220, reason='ok', charset='gb2312') print(response.status_code) print(response.reason_phrase) response['girl_name'] = 'alice' response.__setitem__('girl_sex', 'girl') response.__delitem__('girl_sex') print('response.__getitem__=', response.__getitem__('girl_name')) if response.has_header("this has header"): print("this header is not exists") elif response.has_header('girl_name'): print("response['girl_name']=", response['girl_name']) else: print("no no no no n o") response.setdefault('girl_sex', 'girl') response.set_cookie('login_user', 'zkq111', max_age=20, expires=timezone.now() + datetime.timedelta(days=1)) response.set_cookie('login_user_2', 'zkq222', expires=timezone.now() + datetime.timedelta(days=1)) request.session['user_login'] = '******' print(request.session['user_login']) print(request.COOKIES.get('sessionid')) print(request.COOKIES) return response
def test_vary_not_applied_outside_api(self): request = mock.Mock() request.is_api = False response = HttpResponse() APIRequestMiddleware().process_response(request, response) assert not response.has_header('Vary') response['Vary'] = 'Foo, Bar' APIRequestMiddleware().process_response(request, response) assert response['Vary'] == 'Foo, Bar'
def generate_stats(self, request: HttpRequest, response: HttpResponse): content_type = "" if response.has_header("Content-Type"): content_type = response["Content-Type"] if (content_type.startswith("text/html") and ((200 <= response.status_code < 300) or response.status_code >= 400) and isinstance(response, HttpResponse)): content_text = response.content open_graph_data = self.get_data(content_text) self.record_stats(open_graph_data)
def test_p3p_response_header(self): request = self.rf.get('/') response = HttpResponse("Example response") self.assertEqual( P3PMiddleware().process_response(request, response), response ) self.assertTrue(response.has_header('P3P')) self.assertEqual(response.get('P3P'), 'CP=""')
def test_headers(self): response = HttpResponse() response['X-Foo'] = 'bar' self.assertEqual(response['X-Foo'], 'bar') self.assertEqual(response.headers['X-Foo'], 'bar') self.assertIn('X-Foo', response) self.assertIs(response.has_header('X-Foo'), True) del response['X-Foo'] self.assertNotIn('X-Foo', response) self.assertNotIn('X-Foo', response.headers) # del doesn't raise a KeyError on nonexistent headers. del response['X-Foo']
def test_headers(self): response = HttpResponse() response["X-Foo"] = "bar" self.assertEqual(response["X-Foo"], "bar") self.assertEqual(response.headers["X-Foo"], "bar") self.assertIn("X-Foo", response) self.assertIs(response.has_header("X-Foo"), True) del response["X-Foo"] self.assertNotIn("X-Foo", response) self.assertNotIn("X-Foo", response.headers) # del doesn't raise a KeyError on nonexistent headers. del response["X-Foo"]
def test_non_interference(self): "CORS Middleware shouldn't touch responses outside of its mimetypes" cors = CORSMiddleware() request = HttpRequest() request.path = "/cicero" response = HttpResponse('Lorem ipsum dolor sit amet', mimetype='text/html') cors.process_response(request, response) self.assertFalse(response.has_header('access-control-allow-origin'))
def homePageViewWithArg(request, path): response = HttpResponse(request.body, content_type=request.content_type) status_code = 200 if 'return-status' in request.headers: status_code = int(request.headers['return-status']) for header in request.headers: if not response.has_header(header) and header not in blacklistHeaders: response[header] = request.headers[header] response.status_code = status_code return response
def protected_file(request): if request.user.is_authenticated: url = request.path.replace('/users/avatars', '/protected') print(url) response = HttpResponse(status=200) response['X-Accel-Redirect'] = url print(response.has_header('X-Accel-Redirect')) if 'Expires' in request.GET.keys(): response['X-Accel-Expires'] = request.GET['Expires'] response['Content-type'] = '' return response else: return HttpResponse('<h1>File not found</h1>', status=404)
def get_response(request): """Return information about HttpResponse object.""" a_dict = {} m_dict = {} context = {} response = HttpResponse() # Attributes: response.content = "some content" a_dict["content"] = response.content a_dict["charset"] = response.charset a_dict["status_code"] = response.status_code a_dict["reason_phrese"] = response.reason_phrase a_dict["streaming"] = response.streaming a_dict["closed"] = response.closed # Methods: m_dict["__setitem__(header, value)"] = response.__setitem__("test", "Test") m_dict["__getitem__(header)"] = response.__getitem__("test") m_dict["__delitem__(header)"] = response.__delitem__("test") m_dict["has_header(header)"] = response.has_header("test") m_dict["setdefault(headre, value)"] = response.setdefault("t", "test") m_dict["set_cookie(key, value='', max_age=None,\ expres=None, path='/', domain=None,\ secure=False, httponly=False,\ samesite=None)"] = response.set_cookie("some", "foo") m_dict["set_signed_cookie(key, value='', max_age=None,\ expres=None, path='/', domain=None,\ secure=False, httponly=False,\ samesite=None)"] = response.set_signed_cookie("foo", "foo") m_dict["delete_cookie(key, path='/', domain=None)"] =\ response.delete_cookie("foo") m_dict["close()"] = response.close() m_dict["write(content)"] = response.write("<p>CONTENT</p>") m_dict["flush()"] = response.flush() m_dict["tell()"] = response.tell() m_dict["getvalue()"] = response.getvalue() m_dict["readable()"] = response.readable() m_dict["seekable()"] = response.seekable() m_dict["writable()"] = response.writable() m_dict["writelines(lines)"] = response.writelines([" one", " two", " three"]) m_dict["lines"] = response.getvalue() context["a_dict"] = a_dict context["m_dict"] = m_dict return render(request, "response_object/response.html", context)
def generate_stats(self, request: HttpRequest, response: HttpResponse): content_type = "" if response.has_header("Content-Type"): content_type = response["Content-Type"] if (not content_type.startswith("text/html") or not isinstance(response, HttpResponse) or response.status_code < 200 or (300 <= response.status_code < 400)): return response_headers = {} for header in CHECKED_HTTP_HEADERS: if header in response: response_headers[header] = response[header] parser = HeaderHTMLParser() try: parser.feed(response.content.decode()) scripts_attributes = parser.scripts_attributes html_headers = parser.headers http_ws_resources = parser.http_ws_resources cookies_l = [] cookies = response.cookies # type: SimpleCookie for name, values in cookies.items(): cookies_l.append({ "name": name, "expires": values["expires"], "path": values["path"], "comment": values["comment"], "domain": values["domain"], "max-age": values["max-age"], "secure": values["secure"], "version": values["version"], "httponly": values["httponly"], "samesite": values["samesite"], }) except AssertionError: scripts_attributes = None html_headers = None http_ws_resources = None cookies_l = None values = { "cookies": cookies_l, "html_headers": html_headers, "response_headers": response_headers, "content_type": content_type, "scripts_attributes": scripts_attributes, "http_ws_resources": http_ws_resources, "is_secure": request.is_secure(), } self.record_stats(values)
def hello(request): response = HttpResponse() # response 常见方法 response.write("Welcome to Django1!") response.write("Welcome to Django2!") response.writelines( ["Welcome to Django3!", "Welcome to Django4!", "Welcome to Django5!"]) print(response.getvalue()) print(response.writable()) response.__setitem__("age", "30") print(response.has_header("age")) print(response.__getitem__("age")) print(response.get("age")) response.__delitem__("age") response['address'] = "北京" print(response.get("address")) return response
def __call__(self, request): # wrap the soaplib response into a Django response object django_response = HttpResponse() def start_response(status, headers): status, reason = status.split(' ', 1) django_response.status_code = int(status) for header, value in headers: django_response[header] = value response = super(QiwiSoapApp, self).__call__(request.META, start_response) content = '\n'.join(response) # MAGIC BEGIN, DO NOT TOUCH! :( django_response.content = content.replace('s0:updateBillResult', 'updateBillResult') if django_response.has_header('Content-Length'): django_response['Content-Length'] = len(django_response.content) # MAGIC END return django_response
def generate_stats(self, request: HttpRequest, response: HttpResponse): content_type = "" if response.has_header("Content-Type"): content_type = response["Content-Type"] if ( content_type.startswith("text/html") and ((100 <= response.status_code < 300) or response.status_code >= 400) and isinstance(response, HttpResponse) ): content_text = response.content nu_messages = self.validate(content_text, content_type=content_type) for m in nu_messages["messages"]: if "extract" in m: m["extract"] = m["extract"].strip() values = { "content_text": content_text, "content_type": content_type, "nu_messages": nu_messages, } self.record_stats(values)
def gzip_compressor(request): plugins = split_commas(request.GET.get("plugins", "")) languages = split_commas(request.GET.get("languages", "")) themes = split_commas(request.GET.get("themes", "")) files = split_commas(request.GET.get("files", "")) source = request.GET.get("src", "") == "true" isJS = request.GET.get("js", "") == "true" compress = request.GET.get("compress", "true") == "true" content = [] response = HttpResponse() response["Content-Type"] = "text/javascript" if not isJS: response.write( render_to_string("tinymce/tiny_mce_gzip.js", {"base_url": tinymce.settings.JS_BASE_URL})) return response patch_vary_headers(response, ["Accept-Encoding"]) now = datetime.utcnow() response["Date"] = now.strftime("%a, %d %b %Y %H:%M:%S GMT") cacheKey = "|".join(plugins + languages + themes) cacheData = cache.get(cacheKey) if cacheData is not None: if "ETag" in cacheData: if_none_match = request.META.get("HTTP_IF_NONE_MATCH") if if_none_match == cacheData["ETag"]: response.status_code = 304 response.content = "" response["Content-Length"] = "0" return response if "Last-Modified" in cacheData: if_modified_since = request.META.get("HTTP_IF_MODIFIED_SINCE") if if_modified_since == cacheData["Last-Modified"]: response.status_code = 304 response.content = "" response["Content-Length"] = "0" return response tinyMCEPreInit = { "base": tinymce.settings.JS_BASE_URL, "suffix": "", } content.append("var tinyMCEPreInit={};".format(json.dumps(tinyMCEPreInit))) # Add core files = ["tinymce"] # Add core languages for lang in languages: files.append("langs/{}".format(lang)) # Add plugins for plugin in plugins: files.append("plugins/{}/plugin".format(plugin)) for lang in languages: files.append("plugins/{}/langs/{}".format(plugin, lang)) # Add themes for theme in themes: files.append("themes/{}/theme".format(theme)) for lang in languages: files.append("themes/{}/langs/{}".format(theme, lang)) for f in files: # Check for unsafe characters if not safe_filename_re.match(f): continue content.append(get_file_contents(f, source=source)) # Restore loading functions content.append( 'tinymce.each("{}".split(",")'.format(",".join(files)) + ', function(f){tinymce.ScriptLoader.markDone(tinyMCE.baseURL+"/"+f+".js");});' ) unicode_content = [] for i, c in enumerate(content): try: unicode_content.append(c.decode("latin-1")) except AttributeError: # python 3 way unicode_content.append(smart_text(c)) except UnicodeDecodeError: try: unicode_content.append(c.decode("utf-8")) except Exception: print("{} is nor latin-1 nor utf-8.".format(files[i])) raise # Compress if compress: content = compress_string(b"".join( [c.encode("utf-8") for c in unicode_content])) response["Content-Encoding"] = "gzip" response["Content-Length"] = str(len(content)) response.write(content) timeout = 3600 * 24 * 10 patch_response_headers(response, timeout) if not response.has_header("Last-Modified"): response["Last-Modified"] = http_date() cache.set( cacheKey, { "Last-Modified": response["Last-Modified"], "ETag": response.get("ETag", "") }, ) return response
def gzip_compressor(request): plugins = split_commas(request.GET.get('plugins', '')) languages = split_commas(request.GET.get('languages', '')) themes = split_commas(request.GET.get('themes', '')) isJS = request.GET.get('js', '') == 'true' compress = request.GET.get('compress', 'true') == 'true' suffix = request.GET.get('suffix', '') == '_src' and '_src' or '' content = [] response = HttpResponse() response['Content-Type'] = 'text/javascript' if not isJS: response.write(render_to_string('tinymce/tiny_mce_gzip.js', { 'base_url': tinymce.settings.JS_BASE_URL, })) return response patch_vary_headers(response, ['Accept-Encoding']) now = datetime.utcnow() response['Date'] = now.strftime('%a, %d %b %Y %H:%M:%S GMT') cacheKey = '|'.join(plugins + languages + themes) cacheData = cache.get(cacheKey) if cacheData is not None: if 'ETag' in cacheData: if_none_match = request.META.get('HTTP_IF_NONE_MATCH') if if_none_match == cacheData['ETag']: response.status_code = 304 response.content = '' response['Content-Length'] = '0' return response if 'Last-Modified' in cacheData: if_modified_since = request.META.get('HTTP_IF_MODIFIED_SINCE') if if_modified_since == cacheData['Last-Modified']: response.status_code = 304 response.content = '' response['Content-Length'] = '0' return response tinyMCEPreInit = { 'base': tinymce.settings.JS_BASE_URL, 'suffix': '', } content.append('var tinyMCEPreInit={!s};'.format( json.dumps(tinyMCEPreInit) )) # Add core files = ['tiny_mce'] # Add core languages for lang in languages: files.append('langs/{!s}'.format(lang)) # Add plugins for plugin in plugins: files.append('plugins/{!s}/editor_plugin{!s}'.format(plugin, suffix)) for lang in languages: files.append('plugins/{!s}/langs/{!s}'.format(plugin, lang)) # Add themes for theme in themes: files.append('themes/{!s}/editor_template{!s}'.format(theme, suffix)) for lang in languages: files.append('themes/{!s}/langs/{!s}'.format(theme, lang)) for f in files: # Check for unsafe characters if not safe_filename_re.match(f): continue content.append(get_file_contents('{!s}.js'.format(f))) # Restore loading functions content.append('tinymce.each("{!s}".split(","), function(f){{' 'tinymce.ScriptLoader.markDone(tinyMCE.baseURL+' '"/"+f+".js");}});'.format(','.join(files))) unicode_content = [] for i, c in enumerate(content): try: unicode_content.append(c.decode('latin-1')) except AttributeError: # python 3 way unicode_content.append(smart_text(c)) except UnicodeDecodeError: try: unicode_content.append(c.decode('utf-8')) except Exception: print('{!s} is nor latin-1 nor utf-8.'.format(files[i])) raise # Compress if compress: content = compress_string(b''.join([c.encode('utf-8') for c in unicode_content])) response['Content-Encoding'] = 'gzip' response['Content-Length'] = str(len(content)) response.write(content) timeout = 3600 * 24 * 10 patch_response_headers(response, timeout) if not response.has_header('Last-Modified'): # Last-Modified not set since Django 1.11 response['Last-Modified'] = http_date() cache.set(cacheKey, { 'Last-Modified': response['Last-Modified'], 'ETag': response.get('ETag', ''), }) return response
def explore(self, request, id, *args): opts = self.model._meta app_label = opts.app_label response = HttpResponse() repo = get_object_or_404(Repository, pk=id) if not self.has_view_permission(request, repo): raise PermissionDenied hgr = HgRequestWrapper( request, response, script_name=repo.get_admin_explore_url(), ) hgr.set_user(request.user.username) """ Run the `hgwebdir` method from Mercurial directly, with our incognito request wrapper, output will be buffered. Wrapped in a try:except: since `hgweb` *can* crash. Mercurial now sends the content through as a generator. We need to iterate over the output in order to get all of the content """ template_dir = os.path.join(os.path.dirname(__file__), 'templates') hgserve = hgweb(str(repo.location)) hgserve.reponame = repo.slug # TODO: A more flexible way to get the default template path of mercurial hgserve.templatepath = (template_dir, '/usr/share/mercurial/templates') hgserve.repo.ui.setconfig('web', 'description', smart_str(repo.description)) hgserve.repo.ui.setconfig('web', 'name', smart_str(hgserve.reponame)) # encode('utf-8') FIX "decoding Unicode is not supported" exception on mercurial hgserve.repo.ui.setconfig('web', 'contact', smart_str(repo.owner.get_full_name())) hgserve.repo.ui.setconfig('web', 'allow_archive', repo.allow_archive) hgserve.repo.ui.setconfig('web', 'style', 'monoblue_plain') hgserve.repo.ui.setconfig('web', 'baseurl', repo.get_admin_explore_url()) hgserve.repo.ui.setconfig('web', 'staticurl', STATIC_URL) try: response.write(''.join([each for each in hgserve.run_wsgi(hgr)])) except KeyError: response['content-type'] = 'text/html' response.write('hgweb crashed.') # if hgweb crashed you can do what you like, throw a 404 or continue on # hgweb tends to throw these on invalid requests..? pass context = { 'app_label': app_label, 'opts': opts, 'has_change_permission': self.has_change_permission(request, repo), 'original': repo, 'content': response.content, 'reponame' : hgserve.reponame, 'static_url' : STATIC_URL, 'slugpath': request.path.replace(repo.get_admin_explore_url(), '') or 'summary', 'is_root': request.path == repo.get_admin_explore_url(), } """ In cases of downloading raw files or tarballs, we don't want to pass the output to our template, so instead we just return it as-is. """ if response.has_header('content-type'): if not response['content-type'].startswith("text/html"): return response """ Otherwise, send the content on to the template, for any kind of custom layout you want around it. """ return render_to_response("admin/hgwebproxy/repository/explore.html", context, RequestContext(request))
html = "<html><body>It is now %s.</body></html>" % now return HttpResponse(html) """ HttpResponse - объект формирующий тело ответа. Содержит атрибуты: content, тело ответа. content_type — тип MIME, тип данных, которые мы будут возвращены. status — это статус http ответа, например, ok(200), not found(404), bad request и так далее. reason — указывается если необходимо как-то предопределить ответ status reason в http, иначе он берется из статуса http ответа. И charset — это собственная кодировка, с которой будут переданы данные клиенту. HttpResponse это словарь, которому можно присваивать некие ключь/значение. """ response = HttpResponse() response['Age'] = 120 del response['Age'] response.has_header('Age') # проверка наличия заголовка response.set_cookie(key, value, ..., httponly) # установка кукис response.delete_cookies(key, ..., value) # удаление кукис response.write('<p>Необходимо что то дописать</p>') """Декораторы применяются по принципам синтаксиса пайтон. Станадртные декораторы: @reuire_http_method(request_method_list) # проверяет допустимость метода @require_GET() # разрешает обработку только гет запросов @require_POST() # пост запросов """ # endregion ------------------------------------------------------------------- # region #* Шаблонизация. Синтаксис шаблонов. Струкутра проекта """ Шаблонизация — необходимый способ динамической генерации HTML для формирования HTTP ответа. Наиболее распространенный подход основан на шаблонах. Шаблон содержит статический части html, а также специальный синтаксис,