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
Beispiel #2
0
    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
Beispiel #3
0
    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
Beispiel #4
0
 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)
Beispiel #5
0
 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)
Beispiel #6
0
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,
    )
Beispiel #7
0
    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)
Beispiel #9
0
    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)
Beispiel #17
0
        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
Beispiel #18
0
    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)
Beispiel #19
0
    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)
Beispiel #21
0
        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
Beispiel #22
0
 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)
Beispiel #23
0
    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
Beispiel #24
0
 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)
Beispiel #25
0
    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
Beispiel #27
0
        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
Beispiel #28
0
    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)
Beispiel #29
0
    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
Beispiel #31
0
 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)
Beispiel #32
0
    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)
Beispiel #33
0
    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)
Beispiel #35
0
    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)
Beispiel #37
0
        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
Beispiel #40
0
 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)
Beispiel #41
0
    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)
Beispiel #47
0
    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)
Beispiel #49
0
    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)
Beispiel #51
0
def render_error_page(request, details_text, code=http.BAD_REQUEST):
    request.setResponseCode(code)
    return template.renderElement(request, ErrorPageElement(details_text))
Beispiel #52
0
 def render(self, request):
     return renderElement(request, self.element)
Beispiel #53
0
 def render_HTML(self, req):
     return renderElement(req, RootElement(self._client, self._now_fn))
Beispiel #54
0
 def render_POST(self, req):
     elem = UploadResultsElement(self._upload_results)
     return renderElement(req, elem)
Beispiel #55
0
 def render_GET(self, request):
     request.setHeader(b'Content-Type', b'text/html;charset=utf-8')
     return template.renderElement(request, self.__element)
Beispiel #56
0
    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')
Beispiel #57
0
 def render_HTML(self, req):
     """
     Render an HTML template describing this introducer node.
     """
     return renderElement(req, self._create_element())
Beispiel #58
0
 def _render(self, request, name, isAdmin):
     indexTemplate = IndexTemplate(name, isAdmin)
     return template.renderElement(request, indexTemplate)
Beispiel #59
0
 def render_GET(self, request):
     return template.renderElement(request, self.__element)
Beispiel #60
0
 def render_HTML(self, req):
     """
     Render an HTML template describing this node.
     """
     return renderElement(req, MoreInfoElement(self.node))