Example #1
0
    def getasyncresults(self):
        query = request.params['query']
        print "Get async: %s" % (query)
        try:
            results = query_results[query.replace(' ', '+')].tryGetResults()

            # Format nicely
            if results is None:
                print "No more results: %s" % (request.params['query'])
                ret = "<results>\n<stop/></results>"
            elif results == []:
                print "No results at this time: %s" % (request.params['query'])
                ret = "<results></results>"
            else:
                ret = "<results>\n"
                print "Got Results: %s" % (request.params['query'])
                for result in results:
                    ret += (
                        "<result><sentiment>%s</sentiment><source>%s</source><product>%s</product><cssproduct>%s</cssproduct><content>%s</content></result>\n"
                        % (result['sentiment'], result['parser'],
                           xml.escape(result['product']), "".join(
                               [productfix(c) for c in result['product']]),
                           xml.escape(
                               markupResult(result, request.params['query']))))

                ret += "</results>"

            response = Response(ret)
            response.headers['content-type'] = "text/xml"
            return response
        except KeyError:
            # Async request for a non-existant query
            return None
Example #2
0
  def getasyncresults(self):
    query = request.params['query']
    print "Get async: %s" % (query)
    try:
      results = query_results[query.replace(' ', '+')].tryGetResults()

      # Format nicely
      if results is None:
        print "No more results: %s" % (request.params['query'])
        ret = "<results>\n<stop/></results>"
      elif results == []:
        print "No results at this time: %s" % (request.params['query'])
        ret = "<results></results>"
      else:
        ret = "<results>\n"
        print "Got Results: %s" % (request.params['query'])
        for result in results:
          ret += ("<result><sentiment>%s</sentiment><source>%s</source><product>%s</product><cssproduct>%s</cssproduct><content>%s</content></result>\n"
              % (result['sentiment'],
                 result['parser'],
                 xml.escape(result['product']),
                 "".join([productfix(c) for c in result['product']]),
                 xml.escape(markupResult(result, request.params['query']))))

        ret += "</results>"

      response = Response(ret)
      response.headers['content-type'] = "text/xml"
      return response
    except KeyError:
      # Async request for a non-existant query
      return None
	def serve_tile( self, version, tile_type, zoom, tx, ty, extension):
		try:
			zoom = int(zoom)
			tx = int(tx)
			ty = int(ty)
		except:
			log.error('Incorrect request parameters')
			response.status_int = INVALID_INPUT_ERROR_CODE
			return      
		
		try:
			log.info(repr(request))
			
			raster_image, lastModified  = self.process_tile_request( version, tile_type, zoom, tx, ty, extension )

			resp = Response(body=raster_image, content_type=self.get_image_content_type(extension))
			
			if lastModified is not None:
				resp.last_modified = 1.0 * lastModified
	
			return resp 
 		
		except exc.HTTPForbidden, exp:
			error = self.formatExceptionInfo()
			log.error ("Tile request failed for a invalid values : %s; error trace %s " % (str(request), error))
			response.status_int = INVALID_INPUT_ERROR_CODE
			return      
Example #4
0
def wrap_pdf_response(pdf_data, filename):
    '''given pdf data, wrap and create a reponse '''

    res = Response(pdf_data)
    res.headers['Content-type']='application/pdf'
    res.headers['Content-Disposition']=( 'attachment; filename=%s' % filename.encode('ascii') )

    return res
Example #5
0
def wrap_pdf_response(pdf_data, filename):
    '''given pdf data, wrap and create a reponse '''

    res = Response(pdf_data)
    res.headers['Content-type'] = 'application/pdf'
    #res.headers['Content-type']='application/octet-stream'
    #res.headers['Content-type']='text/plain; charset=utf-8'
    res.headers['Content-Disposition'] = ('attachment; filename=%s' % filename)

    return res
Example #6
0
def wrap_pdf_response(pdf_data, filename):
    '''given pdf data, wrap and create a reponse '''
        
    res = Response(pdf_data)
    res.headers['Content-type']='application/pdf'
    #res.headers['Content-type']='application/octet-stream'
    #res.headers['Content-type']='text/plain; charset=utf-8'
    res.headers['Content-Disposition']=( 'attachment; filename=%s' % filename )
    
    return res
Example #7
0
def mock_pylons():
    from paste.registry import Registry
    import pylons
    from pylons.util import AttribSafeContextObj
    import ckan.lib.app_globals as app_globals
    from ckan.lib.cli import MockTranslator
    from ckan.config.routing import make_map
    from pylons.controllers.util import Request, Response
    from routes.util import URLGenerator

    class TestPylonsSession(dict):
        last_accessed = None

        def save(self):
            pass

    registry = Registry()
    registry.prepare()

    context_obj = AttribSafeContextObj()
    registry.register(pylons.c, context_obj)

    app_globals_obj = app_globals.app_globals
    registry.register(pylons.g, app_globals_obj)

    request_obj = Request(dict(HTTP_HOST="nohost", REQUEST_METHOD="GET"))
    registry.register(pylons.request, request_obj)

    translator_obj = MockTranslator()
    registry.register(pylons.translator, translator_obj)

    registry.register(pylons.response, Response())
    mapper = make_map()
    registry.register(pylons.url, URLGenerator(mapper, {}))
    registry.register(pylons.session, TestPylonsSession())
Example #8
0
    def setup_class(cls):
        cls.registry = Registry()
        cls.registry.prepare()

        cls.context_obj = AttribSafeContextObj()
        cls.registry.register(pylons.c, cls.context_obj)

        cls.app_globals_obj = app_globals.Globals()
        cls.registry.register(pylons.g, cls.app_globals_obj)

        cls.request_obj = Request(dict(HTTP_HOST="nohost"))
        cls.registry.register(pylons.request, cls.request_obj)

        cls.translator_obj = MockTranslator()
        cls.registry.register(pylons.translator, cls.translator_obj)

        cls.buffet = pylons.templating.Buffet('genshi',
                                              template_root='ckan.templates')
        cls.registry.register(pylons.buffet, cls.buffet)

        cls.registry.register(pylons.response, Response())
        mapper = make_map()
        cls.registry.register(pylons.url, URLGenerator(mapper, {}))
        cls.registry.register(pylons.session, TestSession())

        # Templates often want to find out the request's routes info, so put
        # some dummy values into the routes_dict, so the templates that do
        # this don't cause an exception.
        pylons.request.environ.update({
            'pylons.routes_dict': {
                'action': 'test-action',
                'controller': 'test-package::',
            }
        })
Example #9
0
    def pdf(self, id):
        if not h.auth.authorized(
                h.auth.Or(h.auth.is_same_zookeepr_attendee(id),
                          h.auth.has_organiser_role, h.auth.has_unique_key())):
            # Raise a no_auth error
            h.auth.no_role()

        import os, tempfile, libxml2, libxslt

        c.invoice = Invoice.find_by_id(id, True)

        xml_s = render('/invoice/pdf.mako')

        xsl_f = file_paths['zk_root'] + '/zookeepr/templates/invoice/pdf.xsl'
        xsl_s = libxml2.parseFile(xsl_f)
        xsl = libxslt.parseStylesheetDoc(xsl_s)

        xml = libxml2.parseDoc(xml_s)
        svg_s = xsl.applyStylesheet(xml, None)

        (svg_fd, svg) = tempfile.mkstemp('.svg')
        xsl.saveResultToFilename(svg, svg_s, 0)

        xsl.freeStylesheet()
        xml.freeDoc()
        svg_s.freeDoc()

        (pdf_fd, pdf) = tempfile.mkstemp('.pdf')

        os.close(svg_fd)
        os.close(pdf_fd)

        os.system('inkscape -z -f %s -A %s' % (svg, pdf))

        pdf_f = file(pdf)
        res = Response(pdf_f.read())
        pdf_f.close()
        res.headers['Content-type'] = 'application/pdf'
        #res.headers['Content-type']='application/octet-stream'
        #res.headers['Content-type']='text/plain; charset=utf-8'
        filename = lca_info['event_shortname'] + '_' + str(
            c.invoice.id) + '.pdf'
        res.headers['Content-Disposition'] = ('attachment; filename=%s' %
                                              filename)

        # We should really remove the pdf file, shouldn't we.
        return res
Example #10
0
    def setup_app_env(self, environ, start_response):
        """Setup and register all the Pylons objects with the registry
        
        After creating all the global objects for use in the request,
        :meth:`~PylonsApp.register_globals` is called to register them
        in the environment.
        
        """
        if self.log_debug:
            log.debug("Setting up Pylons stacked object globals")

        # Setup the basic pylons global objects
        req_options = self.request_options
        req = Request(environ,
                      charset=req_options['charset'],
                      unicode_errors=req_options['errors'],
                      decode_param_names=req_options['decode_param_names'])
        req.language = req_options['language']
        req.config = self.config
        req.link, req.route_dict = environ['wsgiorg.routing_args']

        response = Response(content_type=self.response_options['content_type'],
                            charset=self.response_options['charset'])
        response.headers.update(self.response_options['headers'])

        # Store a copy of the request/response in environ for faster access
        pylons_obj = PylonsContext()
        pylons_obj.config = self.config
        pylons_obj.request = req
        pylons_obj.response = response
        pylons_obj.app_globals = self.globals
        pylons_obj.h = self.helpers

        if 'routes.url' in environ:
            pylons_obj.url = environ['routes.url']

        environ['pylons.pylons'] = pylons_obj

        environ['pylons.environ_config'] = self.environ_config

        # Setup the translator object
        lang = self.config['lang']
        pylons_obj.translator = _get_translator(lang,
                                                pylons_config=self.config)

        if self.config['pylons.strict_tmpl_context']:
            tmpl_context = ContextObj()
        else:
            tmpl_context = AttribSafeContextObj()
        pylons_obj.tmpl_context = req.tmpl_context = tmpl_context

        if self._session_key in environ:
            pylons_obj.session = req.session = environ[self._session_key]
        if self._cache_key in environ:
            pylons_obj.cache = environ[self._cache_key]

        # Load the globals with the registry if around
        if 'paste.registry' in environ:
            self.register_globals(environ)
Example #11
0
def jsonrpc_error(req_id, error):
    """Generate a Response object with a JSON-RPC error body. Used to
    raise top-level pre-defined errors that happen outside the
    controller."""
    if error in _reserved_errors:
        err = _reserved_errors[error]
        return Response(body=json.dumps(
            dict(jsonrpc=JSONRPC_VERSION, id=req_id, error=err.as_dict())))
Example #12
0
def jsonrpc_error(message, code=None):
    """
    Generate a Response object with a JSON-RPC error body
    """
    from pylons.controllers.util import Response
    resp = Response(body=json.dumps(dict(id=None, result=None, error=message)),
                    status=code,
                    content_type='application/json')
    return resp
Example #13
0
    def pdf(self, id):
        if not h.auth.authorized(h.auth.Or(h.auth.is_same_zookeepr_attendee(id), h.auth.has_organiser_role, h.auth.has_unique_key())):
            # Raise a no_auth error
            h.auth.no_role()

        import os, tempfile, libxml2, libxslt

        c.invoice = Invoice.find_by_id(id, True)

        xml_s = render('/invoice/pdf.mako')

        xsl_f = file_paths['zk_root'] + '/zookeepr/templates/invoice/pdf.xsl'
        xsl_s = libxml2.parseFile(xsl_f)
        xsl = libxslt.parseStylesheetDoc(xsl_s)

        xml = libxml2.parseDoc(xml_s)
        svg_s = xsl.applyStylesheet(xml, None)

        (svg_fd, svg) = tempfile.mkstemp('.svg')
        xsl.saveResultToFilename(svg, svg_s, 0)

        xsl.freeStylesheet()
        xml.freeDoc()
        svg_s.freeDoc()

        (pdf_fd, pdf) = tempfile.mkstemp('.pdf')

        os.close(svg_fd); os.close(pdf_fd)

        os.system('inkscape -z -f %s -A %s' % (svg, pdf))

        pdf_f = file(pdf)
        res = Response(pdf_f.read())
        pdf_f.close()
        res.headers['Content-type']='application/pdf'
        #res.headers['Content-type']='application/octet-stream'
        #res.headers['Content-type']='text/plain; charset=utf-8'
        filename = lca_info['event_shortname'] + '_' + str(c.invoice.id) + '.pdf'
        res.headers['Content-Disposition']=( 'attachment; filename=%s' % filename )

        # We should really remove the pdf file, shouldn't we.
        return res
Example #14
0
def fake_request(pylons_config,
                 server_name='mediadrop.example',
                 language='en',
                 method='GET',
                 request_uri='/',
                 post_vars=None,
                 registry=None):
    paste_registry = registry or _paste_registry(pylons.request)
    app_globals = pylons_config['pylons.app_globals']

    if post_vars and method.upper() != 'POST':
        raise ValueError(
            'You must not specify post_vars for request method %r' % method)
    wsgi_environ = create_wsgi_environ('http://%s%s' %
                                       (server_name, request_uri),
                                       method.upper(),
                                       request_body=post_vars)
    wsgi_environ['paste.registry'] = paste_registry
    request = Request(wsgi_environ, charset='utf-8')
    request.language = language
    request.settings = app_globals.settings
    register_instance(paste_registry, 'request', request)
    response = Response(content_type='application/xml', charset='utf-8')
    register_instance(paste_registry, 'response', response)
    setup_session(paste_registry, if_not_registered=True)

    routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
    register_instance(paste_registry, 'url', routes_url)

    # Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
    # mediadrop.lib.environment
    tmpl_context = AttribSafeContextObj()
    tmpl_context.paginators = Bunch()
    register_instance(paste_registry, 'tmpl_context', tmpl_context)
    # some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
    # use the '.c' alias instead.
    pylons.c = pylons.tmpl_context
    register_instance(paste_registry, 'c', tmpl_context)

    engines = create_tw_engine_manager(app_globals)
    host_framework = PylonsHostFramework(engines=engines)
    paste_registry.register(tw.framework, host_framework)
    setup_translator(language=language,
                     registry=paste_registry,
                     locale_dirs=pylons_config.get('locale_dirs'))

    wsgi_environ.update({
        'pylons.pylons': pylons,
        'paste.registry': paste_registry,
        'routes.url': routes_url,
    })
    return request
 def call_controller(self, controller_class, request, user=None):
     controller = controller_class()
     controller._py_object = pylons
     if user or not hasattr(request, 'perm'):
         self.set_authenticated_user(user, request.environ)
     self._inject_url_generator_for_request(request)
     
     response_info = dict()
     def fake_start_response(status, headers, exc_info=None):
         response_info['status'] = status
         response_info['headerlist'] = headers
     response_body_lines = controller(request.environ, fake_start_response)
     
     template_vars = None
     if isinstance(response_body_lines, dict):
         template_vars = response_body_lines
         body = None
     else:
         body = '\n'.join(response_body_lines)
     response = Response(body=body, **response_info)
     response.template_vars = template_vars
     return response
Example #16
0
 def call_controller(self, controller_class, request, user=None):
     controller = controller_class()
     controller._py_object = pylons
     if user or not hasattr(request, 'perm'):
         self.set_authenticated_user(user, request.environ)
     self._inject_url_generator_for_request(request)
     
     response_info = dict()
     def fake_start_response(status, headers, exc_info=None):
         response_info['status'] = status
         response_info['headerlist'] = headers
     response_body_lines = controller(request.environ, fake_start_response)
     
     template_vars = None
     if isinstance(response_body_lines, dict):
         template_vars = response_body_lines
         body = None
     else:
         body = '\n'.join(response_body_lines)
     response = Response(body=body, **response_info)
     response.template_vars = template_vars
     return response
Example #17
0
def fake_request(pylons_config,
                 server_name='mediacore.example',
                 language='en',
                 method='GET',
                 request_uri='/',
                 post_vars=None):
    app_globals = pylons_config['pylons.app_globals']
    pylons.app_globals._push_object(app_globals)

    if post_vars and method.upper() != 'POST':
        raise ValueError(
            'You must not specify post_vars for request method %r' % method)
    wsgi_environ = create_wsgi_environ('http://%s%s' %
                                       (server_name, request_uri),
                                       method.upper(),
                                       request_body=post_vars)
    request = Request(wsgi_environ, charset='utf-8')
    request.language = language
    request.settings = app_globals.settings
    pylons.request._push_object(request)
    response = Response(content_type='application/xml', charset='utf-8')
    pylons.response._push_object(response)

    session = SessionObject(wsgi_environ)
    pylons.session._push_object(session)

    routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
    pylons.url._push_object(routes_url)

    # Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
    # mediacore.lib.environment
    tmpl_context = AttribSafeContextObj()
    tmpl_context.paginators = Bunch()
    pylons.tmpl_context._push_object(tmpl_context)
    # some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
    # use the '.c' alias instead.
    pylons.c = pylons.tmpl_context

    paste_registry = Registry()
    paste_registry.prepare()
    engines = create_tw_engine_manager(app_globals)
    host_framework = PylonsHostFramework(engines=engines)
    paste_registry.register(tw.framework, host_framework)
    setup_translator(language=language, registry=paste_registry)

    wsgi_environ.update({
        'pylons.pylons': pylons,
        'paste.registry': paste_registry,
    })
    return request
Example #18
0
def fake_request(pylons_config, server_name='mediadrop.example', language='en',
                 method='GET', request_uri='/', post_vars=None):
    app_globals = pylons_config['pylons.app_globals']
    pylons.app_globals._push_object(app_globals)
    
    if post_vars and method.upper() != 'POST':
        raise ValueError('You must not specify post_vars for request method %r' % method)
    wsgi_environ = create_wsgi_environ('http://%s%s' % (server_name, request_uri),
        method.upper(), request_body=post_vars)
    request = Request(wsgi_environ, charset='utf-8')
    request.language = language
    request.settings = app_globals.settings
    pylons.request._push_object(request)
    response = Response(content_type='application/xml', charset='utf-8')
    pylons.response._push_object(response)
    
    session = SessionObject(wsgi_environ)
    pylons.session._push_object(session)

    routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
    pylons.url._push_object(routes_url)

    # TODO: Use ContextObj() for Pylons 0.10
    tmpl_context = AttribSafeContextObj()
    tmpl_context.paginators = Bunch()
    pylons.tmpl_context._push_object(tmpl_context)
    # some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
    # use the '.c' alias instead.
    pylons.c = pylons.tmpl_context
    
    paste_registry = Registry()
    paste_registry.prepare()
    engines = create_tw_engine_manager(app_globals)
    host_framework = PylonsHostFramework(engines=engines)
    paste_registry.register(tw.framework, host_framework)
    
    mediacore_i18n_path = os.path.join(os.path.dirname(mediacore.__file__), 'i18n')
    translator = Translator(language, dict(mediacore=mediacore_i18n_path))
    # not sure why but sometimes pylons.translator is not a StackedObjectProxy
    # but just a regular Translator.
    if not hasattr(pylons.translator, '_push_object'):
        pylons.translator = StackedObjectProxy()
    paste_registry.replace(pylons.translator, translator)
    
    wsgi_environ.update({
        'pylons.pylons': pylons,
        'paste.registry': paste_registry,
    })
    return request
Example #19
0
    def __call__(self, environ, start_response):
        registry = environ['paste.registry']
        py_obj = PylonsContext()
        environ_config = environ.setdefault('pylons.environ_config', {})
        if self.setup_cache:
            py_obj.cache = environ['beaker.cache']
            registry.register(pylons.cache, environ['beaker.cache'])
            environ_config['cache'] = 'beaker.cache'
        if self.setup_session:
            py_obj.session = environ['beaker.session']
            registry.register(pylons.session, environ['beaker.session'])
            environ_config['session'] = 'beaker.session'
        if self.setup_g:
            py_obj.g = py_obj.app_globals = self.g
            registry.register(pylons.g, self.g)
            registry.register(pylons.app_globals, self.g)
        translator = gettext.NullTranslations()
        py_obj.translator = translator
        registry.register(pylons.translator, translator)

        # Update the environ
        req = Request(
            environ,
            charset=request_defaults['charset'],
            unicode_errors=request_defaults['errors'],
            decode_param_names=request_defaults['decode_param_names'])
        req.language = request_defaults['language']

        response = Response(content_type=response_defaults['content_type'],
                            charset=response_defaults['charset'])
        response.headers.update(response_defaults['headers'])

        environ.update(self.environ)
        py_obj.config = pylons.config._current_obj()
        py_obj.request = req
        py_obj.response = response
        py_obj.c = ContextObj()
        environ['pylons.pylons'] = py_obj
        registry.register(pylons.request, req)
        registry.register(pylons.response, response)
        if 'routes.url' in environ:
            registry.register(pylons.url, environ['routes.url'])
        return self.app(environ, start_response)
    def __call__(self, environ, start_response):
        status, headers, app_iter, exc_info = call_wsgi_application(
            self.app, environ, catch_exc_info=True)
        if status[:3] in self.errors and \
            'pylons.status_code_redirect' not in environ and self.error_path:
            # Create a response object
            environ['pylons.original_response'] = Response(status=status,
                                                           headerlist=headers,
                                                           app_iter=app_iter)
            environ['pylons.original_request'] = Request(environ)

            # Create a new environ to avoid touching the original request data
            new_environ = environ.copy()
            new_environ['PATH_INFO'] = self.error_path

            newstatus, headers, app_iter, exc_info = call_wsgi_application(
                self.app, new_environ, catch_exc_info=True)
        start_response(status, headers, exc_info)
        return app_iter
Example #21
0
    def setup_class(cls):
        cls.registry = Registry()
        cls.registry.prepare()

        cls.context_obj = AttribSafeContextObj()
        cls.registry.register(pylons.c, cls.context_obj)

        cls.app_globals_obj = app_globals.Globals()
        cls.registry.register(pylons.g, cls.app_globals_obj)

        cls.request_obj = Request(dict(HTTP_HOST="nohost"))
        cls.registry.register(pylons.request, cls.request_obj)

        cls.translator_obj = MockTranslator()
        cls.registry.register(pylons.translator, cls.translator_obj)

        cls.buffet = pylons.templating.Buffet('genshi',
                                              template_root='ckan.templates')
        cls.registry.register(pylons.buffet, cls.buffet)

        cls.registry.register(pylons.response, Response())
        mapper = make_map()
        cls.registry.register(pylons.url, URLGenerator(mapper, {}))
        cls.registry.register(pylons.session, TestSession())
Example #22
0
def xmlrpc_fault(code, message):
    """Convienence method to return a Pylons response XMLRPC Fault"""
    fault = xmlrpclib.Fault(code, message)
    return Response(body=xmlrpclib.dumps(fault, methodresponse=True))
Example #23
0
 def __init__(self, *args, **kwargs):
     warnings.warn(response_warning, DeprecationWarning, 2)
     PylonsResponse.__init__(self, *args, **kwargs)
Example #24
0
 def __init__(self, *args, **kwargs):
     warnings.warn(response_warning, DeprecationWarning, 2)
     PylonsResponse.__init__(self, *args, **kwargs)