Example #1
0
    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
Example #2
0
    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'))
Example #3
0
    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'))
Example #4
0
    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
Example #5
0
    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
Example #6
0
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
Example #7
0
    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
Example #8
0
    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'
Example #9
0
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
Example #10
0
    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'
Example #11
0
 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)
Example #12
0
    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=""')
Example #13
0
 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']
Example #14
0
 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"]
Example #15
0
    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'))
Example #16
0
    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'))
Example #17
0
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
Example #18
0
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)
Example #19
0
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)
Example #20
0
 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)
Example #21
0
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
Example #22
0
    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
Example #23
0
 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)
Example #24
0
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
Example #25
0
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
Example #26
0
    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))
Example #27
0
    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, а также специальный синтаксис,