def render_GET(self, request): try: token_list = request.args['oauth_token'] except KeyError: request.setResponseCode(400) request.write("Missing oauth token") request.finish() return server.NOT_DONE_YET token = token_list[-1] result = provider.verify_authorize_request(token) if not result: request.setResponseCode(400) request.write("Invalid oauth token") request.finish() return server.NOT_DONE_YET request_token, consumer = result session = request.getSession() if session.uid not in self.sessions: self.sessions.add(session.uid) session_info = ISessionInfo(session) session_info.request_token = request_token session_info.consumer = consumer template = AuthorizeElement(consumer) flattenString(request, template).addCallback(request.write) request.finish() return server.NOT_DONE_YET
def assertFlattensTo(self, root, target): """ Assert that a root element, when flattened, is equal to a string. """ d = flattenString(None, root) d.addCallback(lambda s: self.assertEqual(s, target)) return d
def render_POST(self, request): d = flattenString(request, PriceElement(request, self.db, self.dates, self.postcodes)) def complete_request(html): request.write(html) request.finish() d.addCallback(complete_request) return NOT_DONE_YET
def formatFailure(myFailure): """ Construct an HTML representation of the given failure. Consider using L{FailureElement} instead. @type myFailure: L{Failure<twisted.python.failure.Failure>} @rtype: L{bytes} @return: A string containing the HTML representation of the given failure. """ result = [] flattenString(None, FailureElement(myFailure)).addBoth(result.append) if isinstance(result[0], bytes): # Ensure the result string is all ASCII, for compatibility with the # default encoding expected by browsers. return result[0].decode("utf-8").encode("ascii", "xmlcharrefreplace") result[0].raiseException()
def render_GET(self, request): #print "hello handler" d = flattenString(request,"Hello World") def complete_request(html): request.write(html) request.finish() d.addCallback(complete_request) return NOT_DONE_YET
def render_GET(self, request): #print 'ElementResource' + request d = flattenString(request, PostcodeElement(request, self.db, self.dates, self.postcodes)) def complete_request(html): request.write(html) request.finish() d.addCallback(complete_request) return NOT_DONE_YET
def _renderLogin(self, request, failed=False): request.responseHeaders.setRawHeaders("authorization", ["basic"]) callback = ElementRenderedCallback(request).elementRenderedCallback request.write('<!DOCTYPE html>\n') d = flattenString(request, AppLoginElement(failed=failed)) d.addBoth(callback) return NOT_DONE_YET
def assertFlattensTo(self, root: Flattenable, target: bytes) -> Deferred[bytes]: """ Assert that a root element, when flattened, is equal to a string. """ def check(result: bytes) -> bytes: return self.assertEqual(result, target) # type: ignore[no-any-return] d: Deferred[bytes] = flattenString(None, root) d.addCallback(check) return d
def test_commentEscaping(self): """ The data in a L{Comment} is escaped and mangled in the flattened output so that the result is a legal SGML and XML comment. SGML comment syntax is complicated and hard to use. This rule is more restrictive, and more compatible: Comments start with <!-- and end with --> and never contain -- or >. Also by XML syntax, a comment may not end with '-'. @see: U{http://www.w3.org/TR/REC-xml/#sec-comments} """ def verifyComment(c): self.assertTrue( c.startswith('<!--'), "%r does not start with the comment prefix" % (c,)) self.assertTrue( c.endswith('-->'), "%r does not end with the comment suffix" % (c,)) # If it is shorter than 7, then the prefix and suffix overlap # illegally. self.assertTrue( len(c) >= 7, "%r is too short to be a legal comment" % (c,)) content = c[4:-3] self.assertNotIn('--', content) self.assertNotIn('>', content) if content: self.assertNotEqual(content[-1], '-') results = [] for c in [ '', 'foo---bar', 'foo---bar-', 'foo>bar', 'foo-->bar', '----------------', ]: d = flattenString(None, Comment(c)) d.addCallback(verifyComment) results.append(d) return gatherResults(results)
def test_commentEscaping(self): """ The data in a L{Comment} is escaped and mangled in the flattened output so that the result is a legal SGML and XML comment. SGML comment syntax is complicated and hard to use. This rule is more restrictive, and more compatible: Comments start with <!-- and end with --> and never contain -- or >. Also by XML syntax, a comment may not end with '-'. @see: U{http://www.w3.org/TR/REC-xml/#sec-comments} """ def verifyComment(c): self.assertTrue( c.startswith('<!--'), "%r does not start with the comment prefix" % (c, )) self.assertTrue(c.endswith('-->'), "%r does not end with the comment suffix" % (c, )) # If it is shorter than 7, then the prefix and suffix overlap # illegally. self.assertTrue( len(c) >= 7, "%r is too short to be a legal comment" % (c, )) content = c[4:-3] self.assertNotIn('--', content) self.assertNotIn('>', content) if content: self.assertNotEqual(content[-1], '-') results = [] for c in [ '', 'foo---bar', 'foo---bar-', 'foo>bar', 'foo-->bar', '----------------', ]: d = flattenString(None, Comment(c)) d.addCallback(verifyComment) results.append(d) return gatherResults(results)