def test_nonDefaultDoctype(self): """ L{renderElement} will write the doctype string specified by the doctype keyword argument. """ element = TestElement() d = self.request.notifyFinish() def check(_): self.assertEqual( "".join(self.request.written), ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"' ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' '<p>Hello, world.</p>')) d.addCallback(check) renderElement( self.request, element, doctype=( '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"' ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')) return d
def test_simpleFailureWithTraceback(self): """ L{renderElement} will render a traceback when rendering of the element fails and our site is configured to display tracebacks. """ logObserver = EventLoggingObserver.createWithCleanup( self, globalLogPublisher ) self.request.site.displayTracebacks = True element = FailingElement() d = self.request.notifyFinish() def check(_): self.assertEquals(1, len(logObserver)) f = logObserver[0]["log_failure"] self.assertIsInstance(f.value, FlattenerError) flushed = self.flushLoggedErrors(FlattenerError) self.assertEqual(len(flushed), 1) self.assertEqual( b"".join(self.request.written), b"<!DOCTYPE html>\n<p>I failed.</p>") self.assertTrue(self.request.finished) d.addCallback(check) renderElement(self.request, element, _failElement=TestFailureElement) return d
def test_nonDefaultDoctype(self): """ L{renderElement} will write the doctype string specified by the doctype keyword argument. """ element = TestElement() d = self.request.notifyFinish() def check(_): self.assertEqual( b"".join(self.request.written), (b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"' b' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' b'<p>Hello, world.</p>')) d.addCallback(check) renderElement( self.request, element, doctype=( b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"' b' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')) return d
def _showDirectory(self, request, dirinfo): children = dirinfo[1]['children'] body = tags.ul(*[ tags.li(tags.a(name + ('/' if info[0] == 'dirnode' else ''), href='/' + info[1]['ro_uri'])) for name, info in children.iteritems() ]) renderElement(request, body)
def _showDirectory(self, request, dirinfo): children = dirinfo[1]['children'] body = tags.ul(*[ tags.li( tags.a(name + ('/' if info[0] == 'dirnode' else ''), href='/' + info[1]['ro_uri'])) for name, info in children.iteritems() ]) renderElement(request, body)
def _renderHTTP_exception(request, failure): try: text, code = humanize_failure(failure) except: log.msg("exception in humanize_failure") log.msg("argument was %s" % (failure, )) log.err() text = str(failure) code = None if code is not None: return _renderHTTP_exception_simple(request, text, code) accept = request.getHeader("accept") if not accept: accept = "*/*" if "*/*" in accept or "text/*" in accept or "text/html" in accept: request.setResponseCode(http.INTERNAL_SERVER_ERROR) return template.renderElement( request, tags.html( tags.head(tags.title(u"Exception"), ), tags.body(FailureElement(failure), ), ), ) # use plain text traceback = failure.getTraceback() return _renderHTTP_exception_simple( request, traceback, http.INTERNAL_SERVER_ERROR, )
def render_POST(self, request): uri = request.args.get('uri', []) if not uri or not tahoeRegex.match(uri[0]): return self.render_GET(request) ext = request.args.get('ext', []) b64uri = base64.urlsafe_b64encode(uri[0]) extension = '' if ext and ext[0]: extension = '.' + ext[0].lstrip('.') if uri[0] not in self.shortdb: while True: short = crockford.b32encode(os.urandom(9)).lower() if short not in self.shortdb: break self.shortdb[short] = uri[0] self.shortdb[uri[0]] = short self.shortdb.sync() else: short = self.shortdb[uri[0]] if request.args.get('api', []): return '/' + short + extension body = tags.p( tags.a('long url', href=b64uri + extension), '; ', tags.a('medium url', href='/' + uri[0] + extension), '; ', tags.a('short url', href=short + extension)) return renderElement(request, body)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() if session_user['id'] == 0: return redirectTo('../', request) sessionResponse = SessionManager(request).getSessionResponse() session_user['page'] = 'lend' session_transaction = SessionManager(request).getSessionTransaction() if not session_transaction.get('amount'): session_transaction['amount'] = 1 session_user['page'] = 'lend' Page = pages.Lend('Smart Property Group - Lend', 'lend') Page.session_user = session_user Page.sessionResponse = sessionResponse Page.session_transaction = session_transaction print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssessionResponse: %s%s" % (config.color.BLUE, sessionResponse, config.color.ENDC) print "%ssession_transaction: %s%s" % (config.color.BLUE, session_transaction, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render(self, format, kind=None, buffer=None): # Variable aliases bucket = self.bucket df = self.dataframe # Compute group name for HDF5 and NetCDF formats # TODO: Optionally prefix with "realm" from "bucket.tdata" group_name = bucket.title.short if format == 'xlsx': # Ensure that datetimes are timezone unaware before writing to Excel. make_timezone_unaware(df) # http://pandas.pydata.org/pandas-docs/stable/io.html#io-excel-writer # https://stackoverflow.com/questions/28058563/write-to-stringio-object-using-pandas-excelwriter with pandas.ExcelWriter('temp.xlsx', engine='xlsxwriter') as excel_writer: excel_writer.book.filename = buffer df.to_excel(excel_writer, sheet_name=bucket.title.compact[:31], index=False) elif format in ['hdf', 'hdf5', 'h5']: # Create index from "time" column df = dataframe_index_and_sort(df, 'time') # http://pandas.pydata.org/pandas-docs/stable/io.html#hdf5-pytables t = tempfile.NamedTemporaryFile(suffix='.hdf5') try: df.to_hdf(t.name, group_name, format='table', data_columns=True, index=False) buffer.write(t.read()) except Exception as ex: return self.request.error_response(bucket, with_traceback=True) elif format in ['nc', 'cdf']: # Create index from "time" column df = dataframe_index_and_sort(df, 'time') # http://xarray.pydata.org/ # http://xarray.pydata.org/en/stable/io.html#netcdf t = tempfile.NamedTemporaryFile(suffix='.nc') try: #df.to_xarray().to_netcdf(path=t.name, group=group_name) #df.to_xarray().to_netcdf(path=t.name, format='NETCDF4', engine='h5netcdf', group=group_name) df.to_xarray().to_netcdf(path=t.name, format='NETCDF4', engine='netcdf4', group=group_name) buffer.write(t.read()) except Exception as ex: return self.request.error_response(bucket, with_traceback=True) elif format in ['dt', 'datatables']: # https://datatables.net/ # Compute data_uri, forward "from" and "to" parameters data_uri = get_data_uri(bucket, 'data.html') # Render HTML snippet containing DataTable widget page = DatatablesPage(data_uri=data_uri, bucket=bucket) bucket.request.setHeader('Content-Type', 'text/html; charset=utf-8') return renderElement(bucket.request, page)
def render(self, request): session_transaction = SessionManager(request).getSessionTransaction() #transactionId = session_transaction['id'] if session_transaction['id'] == 0: return redirectTo('../', request) #lenderId = session_transaction['lenderId'] #transaction = db.query(Transaction).filter(Transaction.id == transactionId).first() session_user = SessionManager(request).getSessionUser() session_user['page'] = 'receipt' Page = pages.Receipt('Smart Property Group - Receipt', 'receipt') Page.session_user = session_user Page.session_transaction = session_transaction print "%ssession_user: %s%s" % (config.color.YELLOW, session_user, config.color.ENDC) print "%ssession_transaction: %s%s" % (config.color.YELLOW, session_transaction, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() if session_user['id'] == 0: return redirectTo('../', request) sessionResponse = SessionManager(request).getSessionResponse() sessionProperty = SessionManager(request).getSessionProperty() try: status = request.args.get('status')[0] except: status = 'pending' Page = pages.Orders('Orders', 'orders', status) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssessionProperty: %s%s" % (config.color.BLUE, sessionProperty, config.color.ENDC) print "%ssessionResponse: %s%s" % (config.color.BLUE, sessionResponse, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def test_simpleFailure(self): """ L{renderElement} handles failures by writing a minimal error message to the request and finishing it. """ element = FailingElement() d = self.request.notifyFinish() def check(_): flushed = self.flushLoggedErrors(FlattenerError) self.assertEqual(len(flushed), 1) self.assertEqual( "".join(self.request.written), ('<!DOCTYPE html>\n' '<div style="font-size:800%;' 'background-color:#FFF;' 'color:#F00' '">An error occurred while rendering the response.</div>')) self.assertTrue(self.request.finished) d.addCallback(check) self.assertIdentical(NOT_DONE_YET, renderElement(self.request, element)) return d
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).get_session_user() session_user['page'] = 'transactions' if session_user['id'] == 0: return redirectTo('../', request) session_response = SessionManager(request).get_session_response() filters = {} try: filters['status'] = request.args.get('status')[0] except: filters['status'] = 'open' try: filters['kind'] = request.args.get('kind')[0] except: filters['kind'] = 'promoter' Page = pages.Transactions('%s Transactions' % config.company_name, 'transactions', filters) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssession_response: %s%s" % (config.color.BLUE, session_response, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def wrapper(self, request, *args, **kwargs): response = f(self, request, *args, **kwargs) if IRenderable.providedBy(response): return renderElement(request, response) return response
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).get_session_user() session_user['action'] = 'summary_bids' if session_user['level'] != 0: return redirectTo('../', request) session_response = SessionManager(request).get_session_response() filters = {} try: filters['status'] = request.args.get('status')[0] except: filters['status'] = 'active' Page = pages.SummaryBids('%s Summary Bids' % config.company_name, 'summary_bids', filters) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssession_response: %s%s" % (config.color.BLUE, session_response, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() if session_user['id'] == 0: return redirectTo('../', request) sessionResponse = SessionManager(request).getSessionResponse() try: status = request.args.get('status')[0] except: status = 'pending' filters = {'status': status} Page = pages.SummaryTransactions('Summary Transactions', 'summaryTransactions', filters) Page.session_user = session_user Page.sessionResponse = sessionResponse print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssessionResponse: %s%s" % (config.color.BLUE, sessionResponse, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def process(r): """ Recursively go through r and any child Resources until something returns an IRenderable, then render it and let the result of that bubble back up. """ if IResource.providedBy(r): request.render(getChildForRequest(r, request)) return _StandInResource if IRenderable.providedBy(r): renderElement(request, r) return _StandInResource return r
def render_POST(self, request): uri = request.args.get('uri', []) if not uri or not tahoeRegex.match(uri[0]): return self.render_GET(request) ext = request.args.get('ext', []) b64uri = base64.urlsafe_b64encode(uri[0]) extension = '' if ext and ext[0]: extension = '.' + ext[0].lstrip('.') if uri[0] not in self.shortdb: while True: short = crockford.b32encode(os.urandom(9)).lower() if short not in self.shortdb: break self.shortdb[short] = uri[0] self.shortdb[uri[0]] = short self.shortdb.sync() else: short = self.shortdb[uri[0]] if request.args.get('api', []): return '/' + short + extension body = tags.p(tags.a('long url', href=b64uri + extension), '; ', tags.a('medium url', href='/' + uri[0] + extension), '; ', tags.a('short url', href=short + extension)) return renderElement(request, body)
def test_simpleFailure(self): """ L{renderElement} handles failures by writing a minimal error message to the request and finishing it. """ element = FailingElement() d = self.request.notifyFinish() def check(_): flushed = self.flushLoggedErrors(FlattenerError) self.assertEqual(len(flushed), 1) self.assertEqual( b"".join(self.request.written), (b'<!DOCTYPE html>\n' b'<div style="font-size:800%;' b'background-color:#FFF;' b'color:#F00' b'">An error occurred while rendering the response.</div>')) self.assertTrue(self.request.finished) d.addCallback(check) self.assertIdentical(NOT_DONE_YET, renderElement(self.request, element)) return d
def render_GET(self, request): email = self.getRequestEmail(request) request.setHeader('content-type', 'text/html; charset=utf-8') element = tags.html( htmlHead, tags.body(tags.form( tags.fieldset( tags.div( tags.label('Cert e-mail'), tags.label('Username', for_='username'), tags.label('Password', for_='password'), tags.label('Site', for_='site', class_='last'), id='names', ), tags.div( tags.input(disabled='true', value=email), tags.input(name='username', type='text'), tags.input(name='password', type='password'), tags.input(name='site', type='url', class_='last'), id='fields', ), ), tags.button('Generate', type='submit'), action='', method='POST', )), ) return renderElement(request, element)
def render_GET(self, request): accept = request.getHeader('Accept') if accept is not None and b'application/json' in accept: # TODO: Implement or obtain correct Accept interpretation request.setHeader(b'Content-Type', b'application/json') return serialize(self.__describe_block()).encode('utf-8') else: request.setHeader(b'Content-Type', b'text/html;charset=utf-8') return template.renderElement(request, self.__element)
def wrapper(self: Any, request: IRequest, *args: Any, **kwargs: Any) -> KleinRenderable: response = f(self, request, *args, **kwargs) if IRenderable.providedBy(response): return renderElement(request, response) return response
def test_noneDoctype(self) -> Deferred[None]: """ L{renderElement} will not write out a doctype if the doctype keyword argument is L{None}. """ element = TestElement() d = self.request.notifyFinish() def check(_: object) -> None: self.assertEqual(b"".join(self.request.written), b"<p>Hello, world.</p>") d.addCallback(check) renderElement(self.request, element, doctype=None) return d
def wrapper( self: Any, request: IRequest, *args: Any, **kwargs: Any ) -> KleinRenderable: response = f(self, request, *args, **kwargs) if IRenderable.providedBy(response): return renderElement(request, response) return response
def process(r: object) -> Any: """ Recursively go through r and any child Resources until something returns an IRenderable, then render it and let the result of that bubble back up. """ if isinstance(r, Response): r = r._applyToRequest(request) if IResource.providedBy(r): request.render(getChildForRequest(r, request)) return StandInResource if IRenderable.providedBy(r): renderElement(request, r) return StandInResource return r
def render(self, format, kind=None, buffer=None): # Variable aliases bucket = self.bucket df = self.dataframe # Compute group name for HDF5 and NetCDF formats # TODO: Optionally prefix with "realm" from "bucket.tdata" group_name = bucket.title.short if format == 'xlsx': # http://pandas.pydata.org/pandas-docs/stable/io.html#io-excel-writer # https://stackoverflow.com/questions/28058563/write-to-stringio-object-using-pandas-excelwriter with pandas.ExcelWriter('temp.xlsx', engine='xlsxwriter') as excel_writer: excel_writer.book.filename = buffer df.to_excel(excel_writer, sheet_name=bucket.title.compact[:31], index=False) elif format in ['hdf', 'hdf5', 'h5']: # Create index from "time" column df = dataframe_index_and_sort(df, 'time') # http://pandas.pydata.org/pandas-docs/stable/io.html#hdf5-pytables t = tempfile.NamedTemporaryFile(suffix='.hdf5') try: df.to_hdf(t.name, group_name, format='table', data_columns=True, index=False) buffer.write(t.read()) except Exception as ex: return self.request.error_response(bucket, with_traceback=True) elif format in ['nc', 'cdf']: # Create index from "time" column df = dataframe_index_and_sort(df, 'time') # http://xarray.pydata.org/ # http://xarray.pydata.org/en/stable/io.html#netcdf t = tempfile.NamedTemporaryFile(suffix='.nc') try: #df.to_xarray().to_netcdf(path=t.name, group=group_name) #df.to_xarray().to_netcdf(path=t.name, format='NETCDF4', engine='h5netcdf', group=group_name) df.to_xarray().to_netcdf(path=t.name, format='NETCDF4', engine='netcdf4', group=group_name) buffer.write(t.read()) except Exception as ex: return self.request.error_response(bucket, with_traceback=True) elif format in ['dt', 'datatables']: # https://datatables.net/ # Compute data_uri, forward "from" and "to" parameters data_uri = get_data_uri(bucket, 'data.html') # Render HTML snippet containing DataTable widget page = DatatablesPage(data_uri=data_uri, bucket=bucket) bucket.request.setHeader('Content-Type', 'text/html; charset=utf-8') return renderElement(bucket.request, page)
def test_noneDoctype(self): """ L{renderElement} will not write out a doctype if the doctype keyword argument is C{None}. """ element = TestElement() d = self.request.notifyFinish() def check(_): self.assertEqual("".join(self.request.written), '<p>Hello, world.</p>') d.addCallback(check) renderElement(self.request, element, doctype=None) return d
def test_noneDoctype(self): """ L{renderElement} will not write out a doctype if the doctype keyword argument is L{None}. """ element = TestElement() d = self.request.notifyFinish() def check(_): self.assertEqual( b"".join(self.request.written), b'<p>Hello, world.</p>') d.addCallback(check) renderElement(self.request, element, doctype=None) return d
def render_GET(self, request): body = tags.form( tags.label('Tahoe URI', for_='uri'), ' ', tags.input(id='uri', type='text', name='uri'), tags.br(), tags.label('Extension', for_='ext'), ' ', tags.input(id='ext', type='text', name='ext'), tags.br(), tags.input(type='submit', value='Convert to HTTP URL'), action='', method='POST') return renderElement(request, body)
def render_GET(self, request): applications = [] for app in self.registry.applications.values(): link = tags.a(tags.tt(app.name), ' at ', tags.tt(app.path.path), href=app.name) applications.append(tags.li(link)) body = tags.body( tags.p('Here are your applications:'), tags.ul(*applications)) return renderElement(request, body)
def render_GET(self, request): requestRecievedTime = datetime.datetime.now() dict = decode_request_args(request.args) uid = dict.get("uid")[0] template = dict.get("template")[0] bite = Bite(uid=uid, template=template, access_time=requestRecievedTime) session.add(bite) session.commit() logging.info( "Request received; uid: %s, template: %s, access_time: %s", uid, template, str(requestRecievedTime)) request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8") renderElement(request, ScholarshipPage()) return NOT_DONE_YET
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).get_session_user() session_user['page'] = 'faq' Page = pages.Faq('%s FAQ' % config.company_name, 'faq', {}) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.YELLOW, session_user, config.color.ENDC) request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render_GET(self, request): applications = [] for app in self.registry.applications.values(): link = tags.a(tags.tt(app.name), ' at ', tags.tt(app.path.path), href=app.name) applications.append(tags.li(link)) body = tags.body(tags.p('Here are your applications:'), tags.ul(*applications)) return renderElement(request, body)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() session_user['page'] = 'legal' Page = pages.Legal('Legal', 'legal') Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.YELLOW, session_user, config.color.ENDC) request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def notAuthenticatedError(app: Any, request: IRequest, failure: Failure) -> KleinRenderable: """ Not authenticated. """ requestedWith = request.getHeader("X-Requested-With") if requestedWith is not None: if requestedWith == "XMLHttpRequest": return forbiddenResponse(request) element = redirect(request, URLs.login, origin="o") return renderElement(request, element)
def notAuthenticatedError( app: Any, request: IRequest, failure: Failure ) -> KleinRenderable: """ Not authenticated. """ requestedWith = request.getHeader("X-Requested-With") if requestedWith is not None: if requestedWith == "XMLHttpRequest": return forbiddenResponse(request) element = redirect(request, URLs.login, origin="o") return renderElement(request, element)
def test_simpleFailureWithTraceback(self): """ L{renderElement} will render a traceback when rendering of the element fails and our site is configured to display tracebacks. """ self.request.site.displayTracebacks = True element = FailingElement() d = self.request.notifyFinish() def check(_): flushed = self.flushLoggedErrors(FlattenerError) self.assertEqual(len(flushed), 1) self.assertEqual(b"".join(self.request.written), b"<!DOCTYPE html>\n<p>I failed.</p>") self.assertTrue(self.request.finished) d.addCallback(check) renderElement(self.request, element, _failElement=TestFailureElement) return d
def render_GET(self, request): body = tags.form(tags.label('Tahoe URI', for_='uri'), ' ', tags.input(id='uri', type='text', name='uri'), tags.br(), tags.label('Extension', for_='ext'), ' ', tags.input(id='ext', type='text', name='ext'), tags.br(), tags.input(type='submit', value='Convert to HTTP URL'), action='', method='POST') return renderElement(request, body)
def render(self, request): if request.method != 'GET': raise error.UnsupportedMethod() try: description = self.verifier.getInfoNode(request) except NotImplementedError: description = self.verifier.__class__.__name__ request.setHeader('Content-Type', 'text/plain') if not isinstance(description, types.StringTypes): if not renderElement or\ not iweb.IRenderable.providedBy(description): description = str(description) else: return renderElement(request, description) return description
def test_simpleFailureWithTraceback(self): """ L{renderElement} will render a traceback when rendering of the element fails and our site is configured to display tracebacks. """ self.request.site.displayTracebacks = True element = FailingElement() d = self.request.notifyFinish() def check(_): flushed = self.flushLoggedErrors(FlattenerError) self.assertEqual(len(flushed), 1) self.assertEqual( "".join(self.request.written), "<!DOCTYPE html>\n<p>I failed.</p>") self.assertTrue(self.request.finished) d.addCallback(check) renderElement(self.request, element, _failElement=TestFailureElement) return d
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).get_session_user() session_user['page'] = 'account' if session_user['id'] == 0: return redirectTo('../', request) Page = pages.Account('%s Account' % config.company_name, 'account') Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.YELLOW, session_user, config.color.ENDC) request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render_POST(self, request): request.setHeader('content-type', 'text/html; charset=utf-8') app = self.getApplication(request) password = app.config.generate_for_site( request.args['username'][0], request.args['password'][0], request.args['site'][0]) element = tags.html( htmlHead, tags.body(tags.div( tags.input( size='1', value=password, onFocus=selectJS, onMouseUp='return false', ), ), class_='center'), ), return renderElement(request, element)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() session_user['page'] = 'market' if session_user['id'] == 0: return redirectTo('../', request) try: status = request.args.get('status')[0] except: status = 'pending' Page = pages.Assets('Assets', 'assets', status) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) return renderElement(request, Page)
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() if session_user['id'] == 0: return redirectTo('../', request) sessionResponse = SessionManager(request).getSessionResponse() session_user['page'] = 'profile' Page = pages.Profile('Profile', 'profile') Page.sessionResponse = sessionResponse Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssessionResponse: %s%s" % (config.color.BLUE, sessionResponse, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render_POST(self, request): "Perform the actual search." channels = self.unprefixedChannels if 'channel' in request.args: channels.intersection_update(request.args.pop('channel')) queryArgs = dict( (k, v[0].decode('utf-8', 'replace')) for k, v in request.args.iteritems() if k in ('actor', 'formatted') and any(v)) if not queryArgs or not channels: return self.render_GET(request) q = query.And([ query.Or([query.Term('channel', channel.decode('utf-8', 'replace')) for channel in channels]), query.And([QueryParser(k, schema=whooshSchema).parse(v) for k, v in queryArgs.iteritems()]), ]) request.setHeader('content-type', 'text/html; charset=utf-8') with self.elastircFactory.writer.searcher() as s: results = s.search(q) return template.renderElement(request, ElastircSearchResultsTemplate(results))
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() userType = session_user['type'] if userType != 0: return redirectTo('../', request) try: status = request.args.get('status')[0] except: status = 'verified' filters = {'status': status} Page = pages.SummaryUsers('User Summary', 'summaryUsers', filters) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.YELLOW, session_user, config.color.ENDC) request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def test_simpleRender(self): """ L{renderElement} returns NOT_DONE_YET and eventually writes the rendered L{Element} to the request before finishing the request. """ element = TestElement() d = self.request.notifyFinish() def check(_): self.assertEqual("".join(self.request.written), "<!DOCTYPE html>\n" "<p>Hello, world.</p>") self.assertTrue(self.request.finished) d.addCallback(check) self.assertIdentical(NOT_DONE_YET, renderElement(self.request, element)) return d
def render(self, request): print '%srequest.args: %s%s' % (config.color.RED, request.args, config.color.ENDC) session_user = SessionManager(request).getSessionUser() userType = session_user['type'] if userType != 0: return redirectTo('../', request) sessionResponse = SessionManager(request).getSessionResponse() sessionProperty = SessionManager(request).getSessionProperty() try: status = request.args.get('status')[0] except: status = 'pending' try: action = request.args.get('action')[0] except: action = '' if not action: Page = pages.SummaryProperties('Property Summary', 'summaryProperties', status) Page.session_user = session_user print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) if action == 'add': Page = pages.AddProperty('Add Property', 'addProperty') Page.session_user = session_user Page.sessionResponse = sessionResponse Page.sessionProperty = sessionProperty print "%ssession_user: %s%s" % (config.color.BLUE, session_user, config.color.ENDC) print "%ssessionProperty: %s%s" % (config.color.BLUE, sessionProperty, config.color.ENDC) print "%ssessionResponse: %s%s" % (config.color.BLUE, sessionResponse, config.color.ENDC) SessionManager(request).clearSessionResponse() request.write('<!DOCTYPE html>\n') return renderElement(request, Page)
def render_error_page(request, details_text, code=http.BAD_REQUEST): request.setResponseCode(code) return template.renderElement(request, ErrorPageElement(details_text))
def render(self, request): return renderElement(request, self.element)
def render_HTML(self, req): return renderElement(req, RootElement(self._client, self._now_fn))
def render_POST(self, req): elem = UploadResultsElement(self._upload_results) return renderElement(req, elem)
def render_GET(self, request): request.setHeader(b'Content-Type', b'text/html;charset=utf-8') return template.renderElement(request, self.__element)
def render_html(self, kind): """ Render HTML-based timeseries plots for dygraphs, Bokeh and Vega. """ # Variable aliases bucket = self.bucket df = self.dataframe if kind == 'dygraphs': # http://dygraphs.com/ # Compute data_uri, forward "from" and "to" parameters data_uri = get_data_uri(bucket, 'data.csv', {'pad': 'true'}) # Render HTML snippet containing dygraphs widget page = DygraphsPage(data_uri=data_uri, bucket=bucket) bucket.request.setHeader('Content-Type', 'text/html; charset=utf-8') return renderElement(bucket.request, page) elif kind == 'bokeh': # http://bokeh.pydata.org/ from bokeh.io import save from bokeh.charts import TimeSeries, vplot # Propagate non-null values forward or backward, otherwise # Bokeh would not plot the sparse data frame properly. # With time series data, using pad/ffill is extremely common so that the “last known value” is available at every time point. # http://pandas.pydata.org/pandas-docs/stable/missing_data.html#filling-missing-values-fillna df.fillna(method='pad', inplace=True) # Plot using matplotlib # http://bokeh.pydata.org/en/latest/docs/user_guide/compat.html#userguide-compat # https://github.com/bokeh/bokeh/tree/master/examples/compat/ # https://github.com/bokeh/bokeh/blob/master/examples/compat/pandas_dataframe.py # https://github.com/bokeh/bokeh/blob/master/examples/compat/ggplot_line.py #df.plot() #what = mpl.to_bokeh() # Plot using Bokeh TimeSeries # http://bokeh.pydata.org/en/latest/docs/reference/charts.html#timeseries # http://bokeh.pydata.org/en/0.11.1/docs/user_guide/styling.html#location linegraph = TimeSeries(df, x='time', title=bucket.title.human, legend="top_left", width=800) # Plot TimeSeries object what = vplot(linegraph) # Render using Bokeh t = tempfile.NamedTemporaryFile(suffix='.html', delete=False) save(what, filename=t.name, title=bucket.title.human) # Forward html to http response bucket.request.setHeader('Content-Type', 'text/html; charset=utf-8') return t.read() elif kind == 'vega': # https://github.com/wrobstory/vincent # Compute data_uri, forward "from" and "to" parameters data_uri = get_data_uri(bucket, 'data.vega.json', { 'pad': 'true', 'backfill': 'true' }) template = Template( str(resource_string('kotori.io.export', 'vega_template.html'))) bucket.request.setHeader('Content-Type', 'text/html; charset=utf-8') response = template.substitute(path=data_uri, title=bucket.title.human) return response.encode('utf-8')
def render_HTML(self, req): """ Render an HTML template describing this introducer node. """ return renderElement(req, self._create_element())
def _render(self, request, name, isAdmin): indexTemplate = IndexTemplate(name, isAdmin) return template.renderElement(request, indexTemplate)
def render_GET(self, request): return template.renderElement(request, self.__element)
def render_HTML(self, req): """ Render an HTML template describing this node. """ return renderElement(req, MoreInfoElement(self.node))