コード例 #1
0
ファイル: ps_router.py プロジェクト: taggit/taggit.cc
class RouterApp:
    """ Route request to the matching wsgiapp. """
    def __init__(self,mode):
        self.map = Mapper()
        self.__routing_table = {}; # Maps path to app.
        self.mode = mode

    # HTTP POST json 
    # -> webob (maybe no need?)
    def __call__(self, environ, start_response):
        req = Request(environ);
#        print 'env:\n', environ
#        print 'route:\n', req.path_qs
#        print 'match:\n', self.map.match(req.path_qs)
        match = self.map.match(req.path_qs)
        if match:
            m = match['middleware']
            h = match['handler']
            o = self.__routing_table[m]
            if o is not None:
                environ['_HANDLER'] = h
                return o(environ, start_response)

        err = exc.HTTPNotFound('NO SERVICE FOUND')
        return err(environ, start_response)

    def add_route(self, pat, mid, han):
        if mid not in self.__routing_table: # middleware being SINGELTON
            self.__routing_table[mid] = \
                middleware_factory(mid,self.mode); 
        self.map.connect(pat,middleware=mid,handler=han)
コード例 #2
0
ファイル: routing.py プロジェクト: mkuai/pycloud
def make_map(config):
    """Create, configure and return the routes Mapper"""
    mapper = Mapper()
    connect = mapper.connect

    # For backwards compatibility with 0.9.7.
    mapper.explicit = False

    # Note that all of this are relative to the base path, /api.

    if 'pycloud.api.encrypted' in config and config['pycloud.api.encrypted'] == 'true':
        connect('command', '/command', controller='encrypted', action='command')
    else:
        # Service commands.
        connect('list', '/services', controller='services', action='list')
        connect('find', '/services/get', controller='services', action='find')

        # SVM commands.
        connect('startvm', '/servicevm/start', controller='servicevm', action='start')
        connect('stopvm', '/servicevm/stop', controller='servicevm', action='stop')

        # Appcommands.
        connect('getAppList', '/apps', controller='apppush', action='getList')
        connect('getApp', '/apps/get', controller='apppush', action='getApp')

        # Metadata commands.
        connect('metadata', '/system', controller='cloudlet', action='metadata')

    return mapper
コード例 #3
0
ファイル: allInOne.py プロジェクト: aishi1979/myCode
class App(object):
    def __init__(self):
        print "step in App.__init__()..."
        self.myjob = MyJob()
        self.m = Mapper()
        self.m.connect('/myjob/{action}/{id}', controller=MyJob)
        self.router = middleware.RoutesMiddleware(self.dispatch, self.m)

    @wsgify
    def dispatch(self, req):
        print "step in App.dispatch()..."
        match = req.environ['wsgiorg.routing_args'][1]
        #print "wsgiorg.routing_args|match: %s\r\n%s\r\n" % (match,req.environ['wsgiorg.routing_args'])

        if not match:
            return 'error url: %s\r\n' % req.environ['PATH_INFO']

        action = match['action']

        if hasattr(self.myjob, action):
            func = getattr(self.myjob, action)
            ret = func()
            return ret
        else:
            return "has no action:%s in %s \r\n" % (action, controller)

    @wsgify
    def __call__(self, req):
        print "step in __call__()"
        return self.router
コード例 #4
0
def get_map():
    " This function returns mapper object for dispatcher "
    map = Mapper()
    # Add routes here
    urlmap(map, [
        ('/', 'controllers#index'),
        ('/write', 'controllers#write'),
        ('/read', 'controllers#read'),        
        ('/clean', 'controllers#clean'),
        ('/reset', 'controllers#reset')
    ])

    # Old style map connecting
    #map.connect('Route_name', '/route/url', controller='controllerName',
    #action='actionName')

    if DEBUG:
        r = [Route(None, '/{path_info:.*}',
              controller='noodles.utils.static',
              action='index',
              path=os.path.join(os.getcwd(), 'static'),
              auth=True)]

        map.extend(r, '/static')

    return map
コード例 #5
0
ファイル: videoob_web.py プロジェクト: jocelynj/weboob
    def make_app(self, req):
        map = Mapper()
        map.connect("index", "/", method="index")

        results = map.routematch(environ=req.environ)
        if results:
            match, route = results
            req.urlvars = ((), match)
            kwargs = match.copy()
            method = kwargs.pop("method")
            return getattr(self, method)(req, **kwargs)
        else:
            public_path = os.path.join(os.path.dirname(__file__), "public")
            if not os.path.exists(public_path):
                return exc.HTTPNotFound()
            path = req.path
            if path.startswith("/"):
                path = path[1:]
            public_file_path = os.path.join(public_path, path)
            if os.path.exists(public_file_path):
                if path.endswith(".css"):
                    req.response.content_type = "text/css"
                elif path.endswith(".js"):
                    req.response.content_type = "text/javascript"
                return open(public_file_path, "r").read().strip()
            else:
                return exc.HTTPNotFound()
コード例 #6
0
ファイル: __init__.py プロジェクト: pawelniewie/5groszy.pl
def testManyPages():
    """
    Test: Tries to fit 100 items on 15-item pages
    """
    from routes import Mapper

    items = range(100)
    # Create routes mapper so that webhelper can create URLs
    # using routes.url_for()
    map = Mapper()
    map.connect(':controller')
    page = Page(items, current_page=0, items_per_page=15)
    assert page.current_page==1
    assert page.first_item==0
    assert page.last_item==14
    assert page.first_page==1
    assert page.last_page==7
    assert page.items_per_page==15
    assert page.item_count==100
    assert page.page_count==7
    # Test deprecated navigator()
    assert page.navigator()=='[<strong>1</strong>] <a href="/content?page_nr=2">2</a> <a href="/content?page_nr=3">3</a> .. <a href="/content?page_nr=7">7</a>'
    assert page.pager()=='<span class="pager_curpage">1</span> <a href="/content?page_nr=2" class="pager_link">2</a> <a href="/content?page_nr=3" class="pager_link">3</a> <span class="pager_dotdot">..</span> <a href="/content?page_nr=7" class="pager_link">7</a>'
    assert page.pager(separator='_')=='<span class="pager_curpage">1</span>_<a href="/content?page_nr=2" class="pager_link">2</a>_<a href="/content?page_nr=3" class="pager_link">3</a>_<span class="pager_dotdot">..</span>_<a href="/content?page_nr=7" class="pager_link">7</a>'
    assert page.pager(link_var='xy')=='<span class="pager_curpage">1</span> <a href="/content?xy=2" class="pager_link">2</a> <a href="/content?xy=3" class="pager_link">3</a> <span class="pager_dotdot">..</span> <a href="/content?xy=7" class="pager_link">7</a>'
    assert page.pager(link_attr={'style':'s1'},curpage_attr={'style':'s2'},dotdot_attr={'style':'s3'})=='<span style="s2">1</span> <a href="/content?page_nr=2" style="s1">2</a> <a href="/content?page_nr=3" style="s1">3</a> <span style="s3">..</span> <a href="/content?page_nr=7" style="s1">7</a>'
コード例 #7
0
ファイル: dispatcher.py プロジェクト: pauloalem/torneira
 def getMapper(self):
     if not self.__mapper__:
         mapper = Mapper()
         for name, route, controller, action in self.getUrls():
             mapper.connect(name, route, controller=controller, action=action)
         self.__mapper__ = mapper
     return self.__mapper__
コード例 #8
0
ファイル: cc.py プロジェクト: windskyer/mvpn
class Route(object):
    def __init__(self):
        self.map = Mapper()
        self.map.resource("server", "servers", 
                          controller="services",
                          collection={'detail': 'GET'},
                          member={'action': 'POST'})
コード例 #9
0
ファイル: api.py プロジェクト: leochencipher/router
class API(object):
    """Our REST API WSGI application."""

    def __init__(self, log):
        self.log = log
        self.mapper = Mapper()
        self.controllers = {}
        
        self.mapper.collection("routes", "route",
            path_prefix="/route", controller="route",
            collection_actions=['index', 'create'],
            member_actions=['show', 'delete'],
            member_prefix="/{route}", formatted=False)

    def add(self, name, controller):
        self.controllers[name] = controller

    def create_app(self):
        return RoutesMiddleware(
            self, self.mapper, use_method_override=False, singleton=False)

    @wsgify
    def __call__(self, request):
        # handle incoming call.  depends on the routes middleware.
        url, match = request.environ['wsgiorg.routing_args']
        if match is None or 'controller' not in match:
            raise HTTPNotFound()
        resource = self.controllers[match.pop('controller')]
        action = match.pop('action')
        return getattr(resource, action)(request, url, **match)
コード例 #10
0
    def __init__(self):
        a = Controller()
        _map = Mapper()
        """路由匹配条件1"""
        # map.connect('/images',controller=a,
        #           action='search',
        #           conditions={'method':['GET']})
        """路由匹配条件2"""
        # map.connect('name',"/{action}/{pid}",controller=a)
        """路由匹配条件3"""
        # map.resource("message","messages",controller=a,collection={'search':'GET'})
        """路由匹配条件4"""
        # map.resource('message', 'messages',controller=a,
        # collection={'list_many':'GET','create_many':'POST'},
        # member={'update_many':'POST','delete_many':'POST'})
        """路由匹配条件5"""
        _map.resource('message', 'messages', controller=a, path_prefix='/{projectid}',
                      collection={'list_many': 'GET', 'create_many': 'POST'},
                      member={'update_many': 'POST', 'delete_many': 'POST'})

        # _map.resource('type', 'types', controller=other_controller,
        #               parent_resource=dict(member_name='message',
        #                                    collection_name='messages'),
        #               path_prefix='{projectid}/%s/:%s_id' % ('nex', 'nexs'))

        self.route = middleware.RoutesMiddleware(self._dispatch, _map)
コード例 #11
0
ファイル: myapp.py プロジェクト: jonahwu/lab
class BaseApplication(object):
    special_vars = ['controller','action']
    def __init__(self, conf):
        self.mapper = Mapper()

        self.mapper.connect('/test',controller = TestController,
                                conditions = dict(method=['PUT']))
        self.mapper.connect('/test',controller = TestController,
                                conditions = dict(method=['GET']))

    def __call__(self, env, start_response):
        req = Request(env)
        return self.handle_request(req)(env, start_response)

    def handle_request(self, req):
        print 'into mapping'
        results = self.mapper.routematch(environ=req.environ)
        print 'results --- after mapping'
        print '---- show result -----'
        print results
        match, route = results
        controller = match['controller'](self)
        try:
            handler = getattr(controller, req.method)
        except AttributeError:
            return HTTPMethodNotAllowed(request = req)
        #getattr(handler, 'publicly_accessible')
        kwargs = match.copy()
        for attr in self.special_vars:
            if attr in kwargs:
                 del kwargs[attr]
        #return handler(req, **kwargs)
        return handler(req, **kwargs)
コード例 #12
0
ファイル: dispatch.py プロジェクト: TurboGears/tgext.routes
    def __init__(self, *args, **kw):
        super(RoutedController, self).__init__(*args, **kw)

        routes = []
        for name in dir(self):
            value = getattr(self.__class__, name, None)
            if value is None:
                continue

            deco = None
            if inspect.ismethod(value):  # pragma: no cover
                # PY2
                deco = Decoration.get_decoration(value.__func__)
            elif inspect.isfunction(value):  # pragma: no cover
                # PY3
                deco = Decoration.get_decoration(value)

            if deco is None:
                continue

            if hasattr(deco, '_tgext_routes'):
                routes.extend(deco._tgext_routes)

        if routes:
            instance_mapper = Mapper()
            if self.mapper is not None:
                instance_mapper.extend(self.mapper.matchlist)
            instance_mapper.extend(routes)
            self.mapper = instance_mapper
コード例 #13
0
ファイル: test_middleware.py プロジェクト: JanKanis/routes
def test_redirect_middleware():
    map = Mapper(explicit=False)
    map.minimization = True
    map.connect('myapp/*path_info', controller='myapp')
    map.redirect("faq/{section}", "/static/faq/{section}.html")
    map.redirect("home/index", "/", _redirect_code='301 Moved Permanently')
    map.create_regs(['content', 'myapp'])
    
    app = TestApp(RoutesMiddleware(simple_app, map))
    res = app.get('/')
    assert 'matchdict items are []' in res
    
    res = app.get('/faq/home')
    eq_('302 Found', res.status)
    eq_(res.headers['Location'], '/static/faq/home.html')
    
    res = app.get('/myapp/some/other/url')
    print res
    assert b"matchdict items are [('action', " + repr(u'index').encode() + \
           b"), ('controller', " + repr(u'myapp').encode() + \
           b"), ('path_info', 'some/other/url')]" in res
    assert "'SCRIPT_NAME': '/myapp'" in res
    assert "'PATH_INFO': '/some/other/url'" in res
    
    res = app.get('/home/index')
    assert '301 Moved Permanently' in res.status
    eq_(res.headers['Location'], '/')
コード例 #14
0
ファイル: app_cfg.py プロジェクト: Bitergia/allura
 def setup_routes(self):
     map = Mapper(directory=config['pylons.paths']['controllers'],
                  always_scan=config['debug'])
     # Setup a default route for the root of object dispatch
     map.connect('*url', controller=self.root_controller,
                 action='routes_placeholder')
     config['routes.map'] = map
コード例 #15
0
ファイル: multiapp.py プロジェクト: 1stvamp/gunicorn
class Application(object):
    def __init__(self):
        self.map = Mapper()
        self.map.connect('app1', '/app1url', app=app1)
        self.map.connect('app2', '/app2url', app=app2)

    def __call__(self, environ, start_response):
        match = self.map.routematch(environ=environ)
        if not match:
            return self.error404(environ, start_response)
        return match[0]['app'](environ, start_response)

    def error404(self, environ, start_response):
        html = b"""\
        <html>
          <head>
            <title>404 - Not Found</title>
          </head>
          <body>
            <h1>404 - Not Found</h1>
          </body>
        </html>
        """
        headers = [
            ('Content-Type', 'text/html'),
            ('Content-Length', str(len(html)))
        ]
        start_response('404 Not Found', headers)
        return [html]
コード例 #16
0
ファイル: application.py プロジェクト: statico/friend-rescue
 def __new__(cls, name, bases, dct):
     result = type.__new__(cls, name, bases, dct)
     if type(bases[0]) == type:
         return result
     if not hasattr(result, 'mapping'):
         raise TypeError('Route application without mapping.')
     from routes import Mapper
     mapper = Mapper()
     controllers = {}
     controller_map = {}
     for m in result.mapping:
         name = m[0].split('/', 1)[0]
         internal = str(id(m[1]))
         controllers[internal] = m[1]
         controller_map[m[1]] = internal
         kwargs = {}
         if len(m) >= 3 and not m[2] is None:
             kwargs['requirements'] = m[2]
         if len(m) == 4:
             kwargs.update(m[3])
         mapper.connect(name, m[0], controller=internal, **kwargs)
     mapper.create_regs(controllers.keys())
     result._routes_mapper = mapper
     result._routes_controllers = controllers
     result._controller_map = controller_map
     return result
コード例 #17
0
ファイル: map.py プロジェクト: antiface/python-crawler
class URLMapper():
  """ Unlike the normal routes.Mapper, URLMapper works on urls with scheme, etc...
      Except, right now it doesn't really; eventually, make this match stuff """
  def __init__(self):
    self.mapper = Mapper()
    self._add_routes()

  def _add_routes(self):
    """ override this in the subclass to add routes at create-time """
    pass

  def make_path_with_query(self, parsed):
    if parsed.query:
      return parsed.path + '/' + parsed.query
    return parsed.path

  def match(self, uri):
    parsed = urlsplit(uri, 'http')
    path = self.make_path_with_query(parsed)

    if not path:
      return None

    return self.mapper.match(path)

  def connect(self, *args, **kwargs):
    #domain = kwargs.get('domain', '_default')
    return self.mapper.connect(*args, **kwargs)
コード例 #18
0
ファイル: front.py プロジェクト: aaravindanarun/random_bits
class SensorHandler(tornado.web.RequestHandler):
    """Uses an aysnchronous call to an RPC server to calculate fib(x).
    As with examples of asynchronous HTTP calls, this request will not finish
    until the remote response is received."""
    def initialize(self,database):
        self.mapper=Mapper() 
        self.mapper.connect(None,"/{action}/{exchange}/{queue}") 
        self.mapper.connect(None,"/{action}/{exchange}/") 
        ##  need to know something about the exchanges and queues in the 
        ## broker
        #self.cl = Client('localhost:55672', 'guest', 'guest')
    
    def post(self, number=''):
	global cl
        request = self.request
        self.data = request.body
       	result = self.mapper.match(request.uri) 
	self.queue =''
	try:
		self.queue = result['queue']
	except:
		pass; 	
	self.pika_client = self.application.settings.get('pika_client')
        self.mq_ch = self.pika_client.channel
        self.corr_id = str(uuid.uuid4())
	self.exchange= result['exchange']
        try:
	    pub=self.mq_ch.basic_publish(exchange=self.exchange, routing_key=self.queue,body=self.data)
            response={"Response":"Message sent"}
            self.write(json.dumps(response))
        except:
	    response={"Reponse":"Error publishing msg to exchange"}
            self.write(json.dumps(response))
コード例 #19
0
ファイル: videoob_web.py プロジェクト: laurentb/weboob
    def make_app(self, req):
        map = Mapper()
        map.connect('index', '/', method='index')

        results = map.routematch(environ=req.environ)
        if results:
            match, route = results
            req.urlvars = ((), match)
            kwargs = match.copy()
            method = kwargs.pop('method')
            return getattr(self, method)(req, **kwargs)
        else:
            public_path = os.path.join(os.path.dirname(__file__), 'public')
            if not os.path.exists(public_path):
                return exc.HTTPNotFound()
            path = req.path
            if path.startswith('/'):
                path = path[1:]
            public_file_path = os.path.join(public_path, path)
            if os.path.exists(public_file_path):
                if path.endswith('.css'):
                    req.response.content_type = 'text/css'
                elif path.endswith('.js'):
                    req.response.content_type = 'text/javascript'
                return open(public_file_path, 'r').read().strip()
            else:
                return exc.HTTPNotFound()
コード例 #20
0
ファイル: xxx.py プロジェクト: fjrti/snippets
 def __init__(self):
     print '__init__'
     self.controller = Test()
     mapper = Mapper()
     mapper.connect('blog', '/blog/{action}/{id}', controller=Test,conditions={'method': ['GET']})
     mapper.redirect('/', '/blog/index/1')
     self.router = middleware.RoutesMiddleware(self.dispatch, mapper)
コード例 #21
0
ファイル: router.py プロジェクト: fengkaicnic/routes-test
class MyResourceRouter(object):
    
    def __init__(self):
        route_name = 'resource'
        route_path = 'resor'
        
        my_application = Application(TestAction())
        
        self.mapper = Mapper()
        self.mapper.resource(route_name, route_path, controller=my_application)
        
        self.mapper.connect('resconnct', '/getkey',
                            controller=my_application,
                            action='getkey',
                            conditions={'method':['GET']})
        
        self._router = routes.middleware.RoutesMiddleware(self._dispatch, self.mapper)
        
    @webob.dec.wsgify(RequestClass=webob.Request)  
    def __call__(self, req):
        
        print 'MyRouter is invoked'
        return self._router

    @staticmethod
    @webob.dec.wsgify(RequestClass=webob.Request)
    def _dispatch(req):
        print 'RoutesMiddleware is invoked, calling the dispatch back'
        match_dict = req.environ['wsgiorg.routing_args'][1]
        if not match_dict:
            return webob.exc.HTTPNotFound()
        app = match_dict['controller']
        return app
コード例 #22
0
ファイル: routing.py プロジェクト: geonetix/eencms
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False

    mc = map.connect

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    mc('/error/{action}', controller='error')
    mc('/error/{action}/{id}', controller='error')

    # Home
    mc('/', controller='home', action='index')

    # very custom
    mc('/{id}-{title}', controller='page', action='view')

    mc('/cms', controller='mgmt', action='index')
    mc('/cms/{action}', controller='mgmt')
    mc('/cms/{action}/{id}', controller='mgmt')

    mc('/nieuws', controller='news', action='list')
    mc('/nieuws/{id}/{title}', controller='news', action='view')

    mc('/resource/{action}/{id}/{name}', controller='fetch')

    # Default fallbacks (cms, other pages)
    mc('/{controller}', action='index')
    mc('/{controller}/{action}')
    mc('/{controller}/{action}/{id}')

    return map
コード例 #23
0
ファイル: routing.py プロジェクト: mkuai/pycloud
def make_map(config):
    """Create, configure and return the routes Mapper"""
    mapper = Mapper()
    connect = mapper.connect

    # For backwards compatibility with 0.9.7.
    mapper.explicit = False

    # Note that all of these paths are relative to the base path, /manager. 
    connect('/', controller='services', action='index')
    connect('/home', controller='home', action='index')
    connect('/home/state', controller='home', action='state')

    connect('/auth/signin', controller='auth', action='signin')
    connect('/auth/signin_form', controller='auth', action='signin_form')
    connect('/auth/signout', controller='auth', action='signout')
    
    connect('/services', controller='services', action='listServices')
    connect('/services/removeService/{id}', controller='services', action='removeService')
    
    connect('/instances', controller='instances', action='index')
    connect('/instances/startInstance/{id}', controller='instances', action='startInstance')
    connect('/instances/stopInstance/{id}', controller='instances', action='stopInstance')
    connect('/instances/migrate/{id}', controller='instances', action='migrateInstance')
    connect('/instances/receiveMigratedSVMMetadata', controller='instances', action='receiveMigratedSVMMetadata')
    connect('/instances/receiveMigratedSVMDiskFile', controller='instances', action='receiveMigratedSVMDiskFile')
    connect('/instances/resumeMigratedSVM', controller='instances', action='resumeMigratedSVM')
    connect('/instances/getMigrationInfo/{id}', controller='instances', action='getMigrationInfo')
    connect('/instances/svmList', controller='instances', action='svmList')

    connect('add_service', '/service/add', controller='modify', action='index')
    connect('/service/createSVM', controller='modify', action='createSVM')
    connect('/service/saveNewSVM', controller='modify', action='saveNewSVM')
    connect('/service/openSVM/{id}', controller='modify', action='openSVM')
    connect('/service/edit/{id}', controller='modify', action='index')
    connect('/service/saveSVM', controller='modify', action='saveInstanceToRoot')
    connect('/service/getImageInfo', controller='modify', action='getImageInfo')

    connect('/apps', controller='apps', action='index')
    connect('/apps/list', controller='apps', action='list')
    connect('/apps/get', controller='apps', action='get_data')
    connect('/apps/add', controller='apps', action='add')
    connect('/apps/edit', controller='apps', action='edit')
    connect('/apps/remove', controller='apps', action='remove')

    connect('export_service', '/service/exportsvm/{sid}', controller='export', action='export_svm')
    connect('import_service', '/service/importsvm', controller='import', action='import')

    connect('list_devices', '/devices', controller='devices', action='list')
    connect('clear', '/devices/clear', controller='devices', action='clear')
    connect('bootrstrap', '/devices/bootstrap', controller='devices', action='bootstrap')
    connect('available_devices', '/devices/available', controller='pairing', action='available')
    connect('pair_device', '/devices/pair/{id}', controller='pairing', action='pair')
    connect('authorize_device', '/devices/authorize/{did}', controller='devices', action='authorize')
    connect('unpair_device', '/devices/unpair/{id}', controller='devices', action='unpair')
    connect('revoke_auth', '/devices/revoke/{id}', controller='devices', action='revoke')
    connect('reauthorize', '/devices/reauthorize/{id}', controller='devices', action='reauthorize')

    return mapper
コード例 #24
0
def get_mapper():
    global __mapper__
    if not __mapper__:
        mapper = Mapper()
        for name, route, controller, action, module in rotas:
            mapper.connect(name, route, controller="%s.%s" % (module, controller), action=action)
        __mapper__ = mapper
    return __mapper__
コード例 #25
0
ファイル: routing.py プロジェクト: GitReadysoft/mediadrop
def create_mapper(config, controller_scan=controller_scan):
    """Create, configure and return the routes Mapper"""
    map = Mapper(
        controller_scan=controller_scan, directory=config["pylons.paths"]["controllers"], always_scan=config["debug"]
    )
    map.explicit = False
    map.minimization = True  # TODO: Rework routes so we can set this to False
    return map
コード例 #26
0
ファイル: test_upnp.py プロジェクト: provegard/pyupnp
def _test_StreamingServer():
    expected_id = 'test'
    headers = {
        #'TimeSeekRange.dlna.org': 'npt=30.000-',
        'TimeSeekRange.dlna.org': 'npt=20.000-50.000',
        #'Range': 'bytes=5-',
        'Connection': 'close',
    }
    duration = '00:01:00'
    content_length = 64 * 1024
    interface = '192.168.0.103'

    class StreamingServerStub(ByteSeekMixin, TimeSeekMixin, StreamingServer):
        def get_content(self, id, environ):
            eq_(expected_id, id)
            #raise ValueError(repr(environ))
            for k in headers:
                eq_(headers[k], environ['HTTP_' + k.upper()])
            return ContentStub(content_length,
                               'video/mpeg',
                               'DLNA.ORG_PN=MPEG_PS_NTSC;DLNA.ORG_OP=11')

    from twisted.web import client

    class HTTPPageGetter(client.HTTPPageGetter):
        handleStatus_206 = lambda self: self.handleStatus_200()

    class HTTPClientFactory(client.HTTPClientFactory):
        protocol = HTTPPageGetter

    def getPageFactory(url, *args, **kwargs):
        scheme, host, port, path = client._parse(url)
        factory = HTTPClientFactory(url, *args, **kwargs)
        reactor.connectTCP(host, port, factory)
        return factory

    app = StreamingServerStub('test')

    mapper = Mapper()
    mapper.connect(':id', controller='mt', action='get')
    app = RoutesMiddleware(app, mapper)

    tpool = ThreadPool()
    tpool.start()
    resource = upnp.WSGIResource(reactor, tpool, app)
    port = reactor.listenTCP(0, server.Site(resource), interface=interface)

    port_num = port.socket.getsockname()[1]
    url = 'http://%s:%i/%s?duration=%s' % (interface, port_num, expected_id, duration)
    factory = getPageFactory(url, headers=headers)
    def check_result(contents):
        raise ValueError('expected: %d, actual: %d' % (content_length, len(contents)))
        #raise ValueError(repr(factory.response_headers))
        eq_(content_length, len(contents))
    factory.deferred.addCallback(check_result)

    reactor.callLater(5, reactor.stop)
    reactor.run()
コード例 #27
0
    def test_resources_with_collection_action(self):
        member_name = "message" 
        collection_name = "messages"

        mapper = Mapper()
        mapper.resource(member_name, collection_name, collection={"rss": "GET"})
        environ = {"REQUEST_METHOD":"GET"}
        match_dict = mapper.match("/messages/rss", environ)
        self.assertDictEqual(match_dict, {'action': u'rss', 'controller': u'messages'})
コード例 #28
0
    def test_resources_with_member_action(self):
        member_name = "message" 
        collection_name = "messages"

        mapper = Mapper()
        mapper.resource(member_name, collection_name, member={'mark':'POST'})
        environ = {"REQUEST_METHOD":"POST"}
        match_dict = mapper.match("/messages/123/mark", environ)
        self.assertDictEqual(match_dict, {'action': u'mark', 'controller': u'messages', 'id': u'123'})
コード例 #29
0
    def test_resources_with_path_prefix(self):
        member_name = "message" 
        collection_name = "messages"

        mapper = Mapper()
        mapper.resource(member_name, collection_name, path_prefix="/category/{category_id}")
        environ = {"REQUEST_METHOD":"GET"}
        match_dict = mapper.match("/category/123/messages/456", environ)
        self.assertDictEqual(match_dict, {'action': u'show', 'controller': u'messages', 'category_id': u'123', 'id': u'456'})
コード例 #30
0
ファイル: test2.py プロジェクト: itnihao/lab
 def __init__(self):
     self.controller = controller()
     self.controller2 = controller2()
     m = Mapper()
     m.connect('blog', '/blog/{action}/{id}', controller=controller,
               conditions={'method': ['GET']})
     m.connect('haha', '/haha/{action}/{id}', controller=controller2,
               conditions={'method': ['GET']})
     self.router = middleware.RoutesMiddleware(self.dispatch, m)
コード例 #31
0
def test_redirect_middleware():
    map = Mapper(explicit=False)
    map.minimization = True
    map.connect('myapp/*path_info', controller='myapp')
    map.redirect("faq/{section}", "/static/faq/{section}.html")
    map.redirect("home/index", "/", _redirect_code='301 Moved Permanently')
    map.create_regs(['content', 'myapp'])

    app = TestApp(RoutesMiddleware(simple_app, map))
    res = app.get('/')
    assert 'matchdict items are []' in res

    res = app.get('/faq/home')
    eq_('302 Found', res.status)
    eq_(res.headers['Location'], '/static/faq/home.html')

    res = app.get('/myapp/some/other/url')
    print res
    assert b"matchdict items are [('action', " + repr(u'index').encode() + \
           b"), ('controller', " + repr(u'myapp').encode() + \
           b"), ('path_info', 'some/other/url')]" in res
    assert "'SCRIPT_NAME': '/myapp'" in res
    assert "'PATH_INFO': '/some/other/url'" in res

    res = app.get('/home/index')
    assert '301 Moved Permanently' in res.status
    eq_(res.headers['Location'], '/')
コード例 #32
0
ファイル: routing.py プロジェクト: mcginty/Notifox
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # Page section
    map.connect('/', controller='index', action='index')
    map.connect('/add', controller='page', action='add')
    map.connect('/selected', controller='page', action='selected')
    map.connect('/selected/', controller='page', action='selected')

    # Auth section
    map.connect('/register',
                controller='auth',
                action='register_post',
                conditions=dict(method=['POST']))
    map.connect('/register', controller='auth', action='register')
    map.connect('/register/', controller='auth', action='register')

    map.connect('/login',
                controller='auth',
                action='login_post',
                conditions=dict(method=['POST']))
    map.connect('/login', controller='auth', action='login')
    map.connect('/login/', controller='auth', action='login')
    map.connect('/logout', controller='auth', action='logout')

    #map.connect('/{controller}', action='index')
    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')

    return map
コード例 #33
0
def create_routes_router(uri_data):
    endpoint = Endpoint("routes")
    router = Mapper()
    # static routes
    for u in uri_data.get_static_uris():
        router.connect(None, u, controller=endpoint)

    # zero variable
    template = uri_data.get_zero_var_uri(ParamFormat.ROUTES)
    router.connect(None, template, controller=endpoint)
    # one variable
    template = uri_data.get_one_var_uri(ParamFormat.ROUTES)
    router.connect(None, template, controller=endpoint)
    # two variables
    template = uri_data.get_two_var_uri(ParamFormat.ROUTES)
    router.connect(None, template, controller=endpoint)
    # three variables
    template = uri_data.get_three_var_uri(ParamFormat.ROUTES)
    router.connect(None, template, controller=endpoint)
    # done
    return router
コード例 #34
0
ファイル: wsgi.py プロジェクト: c65sdn/faucet
 def __init__(self, **config):
     self.config = config
     self.mapper = Mapper()
     self.registory = {}
     self._wsmanager = WebSocketManager()
     super().__init__()
コード例 #35
0
def make_map(config):
    """Create, configure and return the routes Mapper"""
    rmap = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    rmap.minimization = False
    rmap.explicit = False

    from rhodecode.lib.utils import is_valid_repo
    from rhodecode.lib.utils import is_valid_repos_group

    def check_repo(environ, match_dict):
        """
        check for valid repository for proper 404 handling

        :param environ:
        :param match_dict:
        """
        from rhodecode.model.db import Repository
        repo_name = match_dict.get('repo_name')

        if match_dict.get('f_path'):
            #fix for multiple initial slashes that causes errors
            match_dict['f_path'] = match_dict['f_path'].lstrip('/')

        try:
            by_id = repo_name.split('_')
            if len(by_id) == 2 and by_id[1].isdigit() and by_id[0] == '':
                repo_name = Repository.get(by_id[1]).repo_name
                match_dict['repo_name'] = repo_name
        except Exception:
            pass

        return is_valid_repo(repo_name, config['base_path'])

    def check_group(environ, match_dict):
        """
        check for valid repository group for proper 404 handling

        :param environ:
        :param match_dict:
        """
        repos_group_name = match_dict.get('group_name')
        return is_valid_repos_group(repos_group_name, config['base_path'])

    def check_group_skip_path(environ, match_dict):
        """
        check for valid repository group for proper 404 handling, but skips
        verification of existing path

        :param environ:
        :param match_dict:
        """
        repos_group_name = match_dict.get('group_name')
        return is_valid_repos_group(repos_group_name, config['base_path'],
                                    skip_path_check=True)

    def check_user_group(environ, match_dict):
        """
        check for valid user group for proper 404 handling

        :param environ:
        :param match_dict:
        """
        return True

    def check_int(environ, match_dict):
        return match_dict.get('id').isdigit()

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    rmap.connect('/error/{action}', controller='error')
    rmap.connect('/error/{action}/{id}', controller='error')

    #==========================================================================
    # CUSTOM ROUTES HERE
    #==========================================================================

    #MAIN PAGE
    rmap.connect('home', '/', controller='home', action='index')
    rmap.connect('repo_switcher', '/repos', controller='home',
                 action='repo_switcher')
    rmap.connect('branch_tag_switcher', '/branches-tags/{repo_name:.*?}',
                 controller='home', action='branch_tag_switcher')
    rmap.connect('rst_help',
                 "http://docutils.sourceforge.net/docs/user/rst/quickref.html",
                 _static=True)
    rmap.connect('rhodecode_official', "http://rhodecode.org", _static=True)

    #ADMIN REPOSITORY REST ROUTES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/repos') as m:
        m.connect("repos", "/repos",
             action="create", conditions=dict(method=["POST"]))
        m.connect("repos", "/repos",
             action="index", conditions=dict(method=["GET"]))
        m.connect("formatted_repos", "/repos.{format}",
             action="index",
            conditions=dict(method=["GET"]))
        m.connect("new_repo", "/create_repository",
                  action="create_repository", conditions=dict(method=["GET"]))
        m.connect("/repos/{repo_name:.*?}",
             action="update", conditions=dict(method=["PUT"],
                                              function=check_repo))
        m.connect("/repos/{repo_name:.*?}",
             action="delete", conditions=dict(method=["DELETE"],
                                              function=check_repo))
        m.connect("formatted_edit_repo", "/repos/{repo_name:.*?}.{format}/edit",
             action="edit", conditions=dict(method=["GET"],
                                            function=check_repo))
        m.connect("repo", "/repos/{repo_name:.*?}",
             action="show", conditions=dict(method=["GET"],
                                            function=check_repo))
        m.connect("formatted_repo", "/repos/{repo_name:.*?}.{format}",
             action="show", conditions=dict(method=["GET"],
                                            function=check_repo))
        #add repo perm member
        m.connect('set_repo_perm_member',
                  "/repos/{repo_name:.*?}/grant_perm",
                  action="set_repo_perm_member",
                  conditions=dict(method=["POST"], function=check_repo))

        #ajax delete repo perm user
        m.connect('delete_repo_perm_member',
                  "/repos/{repo_name:.*?}/revoke_perm",
                  action="delete_repo_perm_member",
                  conditions=dict(method=["DELETE"], function=check_repo))

        #settings actions
        m.connect('repo_stats', "/repos_stats/{repo_name:.*?}",
                  action="repo_stats", conditions=dict(method=["DELETE"],
                                                       function=check_repo))
        m.connect('repo_cache', "/repos_cache/{repo_name:.*?}",
                  action="repo_cache", conditions=dict(method=["DELETE"],
                                                       function=check_repo))
        m.connect('repo_public_journal', "/repos_public_journal/{repo_name:.*?}",
                  action="repo_public_journal", conditions=dict(method=["PUT"],
                                                        function=check_repo))
        m.connect('repo_pull', "/repo_pull/{repo_name:.*?}",
                  action="repo_pull", conditions=dict(method=["PUT"],
                                                      function=check_repo))
        m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*?}",
                  action="repo_as_fork", conditions=dict(method=["PUT"],
                                                      function=check_repo))
        m.connect('repo_locking', "/repo_locking/{repo_name:.*?}",
                  action="repo_locking", conditions=dict(method=["PUT"],
                                                      function=check_repo))
        m.connect('toggle_locking', "/locking_toggle/{repo_name:.*?}",
                  action="toggle_locking", conditions=dict(method=["GET"],
                                                      function=check_repo))

        #repo fields
        m.connect('create_repo_fields', "/repo_fields/{repo_name:.*?}/new",
                  action="create_repo_field", conditions=dict(method=["PUT"],
                                                      function=check_repo))

        m.connect('delete_repo_fields', "/repo_fields/{repo_name:.*?}/{field_id}",
                  action="delete_repo_field", conditions=dict(method=["DELETE"],
                                                      function=check_repo))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/repos_groups') as m:
        m.connect("repos_groups", "/repos_groups",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("repos_groups", "/repos_groups",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("formatted_repos_groups", "/repos_groups.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("new_repos_group", "/repos_groups/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_new_repos_group", "/repos_groups/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("update_repos_group", "/repos_groups/{group_name:.*?}",
                  action="update", conditions=dict(method=["PUT"],
                                                   function=check_group))
        #add repo group perm member
        m.connect('set_repo_group_perm_member',
                  "/repos_groups/{group_name:.*?}/grant_perm",
                  action="set_repo_group_perm_member",
                  conditions=dict(method=["POST"], function=check_group))

        #ajax delete repo group perm
        m.connect('delete_repo_group_perm_member',
                  "/repos_groups/{group_name:.*?}/revoke_perm",
                  action="delete_repo_group_perm_member",
                  conditions=dict(method=["DELETE"], function=check_group))

        m.connect("delete_repos_group", "/repos_groups/{group_name:.*?}",
                  action="delete", conditions=dict(method=["DELETE"],
                                                   function=check_group_skip_path))
        m.connect("edit_repos_group", "/repos_groups/{group_name:.*?}/edit",
                  action="edit", conditions=dict(method=["GET"],
                                                 function=check_group))
        m.connect("formatted_edit_repos_group",
                  "/repos_groups/{group_name:.*?}.{format}/edit",
                  action="edit", conditions=dict(method=["GET"],
                                                 function=check_group))
        m.connect("repos_group", "/repos_groups/{group_name:.*?}",
                  action="show", conditions=dict(method=["GET"],
                                                 function=check_group))
        m.connect("formatted_repos_group", "/repos_groups/{group_name:.*?}.{format}",
                  action="show", conditions=dict(method=["GET"],
                                                 function=check_group))

    #ADMIN USER REST ROUTES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/users') as m:
        m.connect("users", "/users",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("users", "/users",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("formatted_users", "/users.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("new_user", "/users/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_new_user", "/users/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("update_user", "/users/{id}",
                  action="update", conditions=dict(method=["PUT"]))
        m.connect("delete_user", "/users/{id}",
                  action="delete", conditions=dict(method=["DELETE"]))
        m.connect("edit_user", "/users/{id}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("formatted_edit_user",
                  "/users/{id}.{format}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("user", "/users/{id}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_user", "/users/{id}.{format}",
                  action="show", conditions=dict(method=["GET"]))

        #EXTRAS USER ROUTES
        m.connect("user_perm", "/users_perm/{id}",
                  action="update_perm", conditions=dict(method=["PUT"]))
        m.connect("user_emails", "/users_emails/{id}",
                  action="add_email", conditions=dict(method=["PUT"]))
        m.connect("user_emails_delete", "/users_emails/{id}",
                  action="delete_email", conditions=dict(method=["DELETE"]))
        m.connect("user_ips", "/users_ips/{id}",
                  action="add_ip", conditions=dict(method=["PUT"]))
        m.connect("user_ips_delete", "/users_ips/{id}",
                  action="delete_ip", conditions=dict(method=["DELETE"]))

    #ADMIN USER GROUPS REST ROUTES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/users_groups') as m:
        m.connect("users_groups", "/users_groups",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("users_groups", "/users_groups",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("formatted_users_groups", "/users_groups.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("new_users_group", "/users_groups/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_new_users_group", "/users_groups/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("update_users_group", "/users_groups/{id}",
                  action="update", conditions=dict(method=["PUT"]))
        m.connect("delete_users_group", "/users_groups/{id}",
                  action="delete", conditions=dict(method=["DELETE"]))
        m.connect("edit_users_group", "/users_groups/{id}/edit",
                  action="edit", conditions=dict(method=["GET"]),
                  function=check_user_group)
        m.connect("formatted_edit_users_group",
                  "/users_groups/{id}.{format}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("users_group", "/users_groups/{id}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_users_group", "/users_groups/{id}.{format}",
                  action="show", conditions=dict(method=["GET"]))

        #EXTRAS USER ROUTES
        # update
        m.connect("users_group_perm", "/users_groups/{id}/update_global_perm",
                  action="update_perm", conditions=dict(method=["PUT"]))

        #add user group perm member
        m.connect('set_user_group_perm_member', "/users_groups/{id}/grant_perm",
             action="set_user_group_perm_member",
             conditions=dict(method=["POST"]))

        #ajax delete user group perm
        m.connect('delete_user_group_perm_member', "/users_groups/{id}/revoke_perm",
             action="delete_user_group_perm_member",
             conditions=dict(method=["DELETE"]))

    #ADMIN GROUP REST ROUTES
    rmap.resource('group', 'groups',
                  controller='admin/groups', path_prefix=ADMIN_PREFIX)

    #ADMIN PERMISSIONS REST ROUTES
    rmap.resource('permission', 'permissions',
                  controller='admin/permissions', path_prefix=ADMIN_PREFIX)

    #ADMIN DEFAULTS REST ROUTES
    rmap.resource('default', 'defaults',
                  controller='admin/defaults', path_prefix=ADMIN_PREFIX)

    ##ADMIN LDAP SETTINGS
    rmap.connect('ldap_settings', '%s/ldap' % ADMIN_PREFIX,
                 controller='admin/ldap_settings', action='ldap_settings',
                 conditions=dict(method=["POST"]))

    rmap.connect('ldap_home', '%s/ldap' % ADMIN_PREFIX,
                 controller='admin/ldap_settings')

    #ADMIN SETTINGS REST ROUTES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/settings') as m:
        m.connect("admin_settings", "/settings",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("admin_settings", "/settings",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("formatted_admin_settings", "/settings.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("admin_new_setting", "/settings/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_admin_new_setting", "/settings/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("/settings/{setting_id}",
                  action="update", conditions=dict(method=["PUT"]))
        m.connect("/settings/{setting_id}",
                  action="delete", conditions=dict(method=["DELETE"]))
        m.connect("admin_edit_setting", "/settings/{setting_id}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("formatted_admin_edit_setting",
                  "/settings/{setting_id}.{format}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("admin_setting", "/settings/{setting_id}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_admin_setting", "/settings/{setting_id}.{format}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("admin_settings_my_account", "/my_account",
                  action="my_account", conditions=dict(method=["GET"]))
        m.connect("admin_settings_my_account_update", "/my_account_update",
                  action="my_account_update", conditions=dict(method=["PUT"]))
        m.connect("admin_settings_my_repos", "/my_account/repos",
                  action="my_account_my_repos", conditions=dict(method=["GET"]))
        m.connect("admin_settings_my_pullrequests", "/my_account/pull_requests",
                  action="my_account_my_pullrequests", conditions=dict(method=["GET"]))

    #NOTIFICATION REST ROUTES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/notifications') as m:
        m.connect("notifications", "/notifications",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("notifications", "/notifications",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("notifications_mark_all_read", "/notifications/mark_all_read",
                  action="mark_all_read", conditions=dict(method=["GET"]))
        m.connect("formatted_notifications", "/notifications.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("new_notification", "/notifications/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_new_notification", "/notifications/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("/notifications/{notification_id}",
                  action="update", conditions=dict(method=["PUT"]))
        m.connect("/notifications/{notification_id}",
                  action="delete", conditions=dict(method=["DELETE"]))
        m.connect("edit_notification", "/notifications/{notification_id}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("formatted_edit_notification",
                  "/notifications/{notification_id}.{format}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("notification", "/notifications/{notification_id}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",
                  action="show", conditions=dict(method=["GET"]))

    #ADMIN GIST
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/gists') as m:
        m.connect("gists", "/gists",
                  action="create", conditions=dict(method=["POST"]))
        m.connect("gists", "/gists",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("new_gist", "/gists/new",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_new_gist", "/gists/new.{format}",
                  action="new", conditions=dict(method=["GET"]))
        m.connect("formatted_gists", "/gists.{format}",
                  action="index", conditions=dict(method=["GET"]))
        m.connect("/gists/{gist_id}",
                  action="update", conditions=dict(method=["PUT"]))
        m.connect("/gists/{gist_id}",
                  action="delete", conditions=dict(method=["DELETE"]))
        m.connect("edit_gist", "/gists/{gist_id}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("formatted_edit_gist",
                  "/gists/{gist_id}/{format}/edit",
                  action="edit", conditions=dict(method=["GET"]))
        m.connect("gist", "/gists/{gist_id}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_gist", "/gists/{gist_id}/{format}",
                  action="show", conditions=dict(method=["GET"]))
        m.connect("formatted_gist_file", "/gists/{gist_id}/{format}/{revision}/{f_path:.*}",
                  action="show", conditions=dict(method=["GET"]))

    #ADMIN MAIN PAGES
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='admin/admin') as m:
        m.connect('admin_home', '', action='index')
        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
                  action='add_repo')
    #==========================================================================
    # API V2
    #==========================================================================
    with rmap.submapper(path_prefix=ADMIN_PREFIX,
                        controller='api/api') as m:
        m.connect('api', '/api')

    #USER JOURNAL
    rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,
                 controller='journal', action='index')
    rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,
                 controller='journal', action='journal_rss')
    rmap.connect('journal_atom', '%s/journal/atom' % ADMIN_PREFIX,
                 controller='journal', action='journal_atom')

    rmap.connect('public_journal', '%s/public_journal' % ADMIN_PREFIX,
                 controller='journal', action="public_journal")

    rmap.connect('public_journal_rss', '%s/public_journal/rss' % ADMIN_PREFIX,
                 controller='journal', action="public_journal_rss")

    rmap.connect('public_journal_rss_old', '%s/public_journal_rss' % ADMIN_PREFIX,
                 controller='journal', action="public_journal_rss")

    rmap.connect('public_journal_atom',
                 '%s/public_journal/atom' % ADMIN_PREFIX, controller='journal',
                 action="public_journal_atom")

    rmap.connect('public_journal_atom_old',
                 '%s/public_journal_atom' % ADMIN_PREFIX, controller='journal',
                 action="public_journal_atom")

    rmap.connect('toggle_following', '%s/toggle_following' % ADMIN_PREFIX,
                 controller='journal', action='toggle_following',
                 conditions=dict(method=["POST"]))

    #SEARCH
    rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)
    rmap.connect('search_repo_admin', '%s/search/{repo_name:.*}' % ADMIN_PREFIX,
                 controller='search',
                 conditions=dict(function=check_repo))
    rmap.connect('search_repo', '/{repo_name:.*?}/search',
                 controller='search',
                 conditions=dict(function=check_repo),
                 )

    #LOGIN/LOGOUT/REGISTER/SIGN IN
    rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')
    rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',
                 action='logout')

    rmap.connect('register', '%s/register' % ADMIN_PREFIX, controller='login',
                 action='register')

    rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,
                 controller='login', action='password_reset')

    rmap.connect('reset_password_confirmation',
                 '%s/password_reset_confirmation' % ADMIN_PREFIX,
                 controller='login', action='password_reset_confirmation')

    #FEEDS
    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',
                controller='feed', action='rss',
                conditions=dict(function=check_repo))

    rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',
                controller='feed', action='atom',
                conditions=dict(function=check_repo))

    #==========================================================================
    # REPOSITORY ROUTES
    #==========================================================================
    rmap.connect('summary_home', '/{repo_name:.*?}',
                controller='summary',
                conditions=dict(function=check_repo))

    rmap.connect('repo_size', '/{repo_name:.*?}/repo_size',
                controller='summary', action='repo_size',
                conditions=dict(function=check_repo))

    rmap.connect('repos_group_home', '/{group_name:.*}',
                controller='admin/repos_groups', action="show_by_name",
                conditions=dict(function=check_group))

    rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision}',
                controller='changeset', revision='tip',
                conditions=dict(function=check_repo))

    # no longer user, but kept for routes to work
    rmap.connect("_edit_repo", "/{repo_name:.*?}/edit",
                 controller='admin/repos', action="edit",
                 conditions=dict(method=["GET"], function=check_repo)
                 )

    rmap.connect("edit_repo", "/{repo_name:.*?}/settings",
                 controller='admin/repos', action="edit",
                 conditions=dict(method=["GET"], function=check_repo)
                 )

    #still working url for backward compat.
    rmap.connect('raw_changeset_home_depraced',
                 '/{repo_name:.*?}/raw-changeset/{revision}',
                 controller='changeset', action='changeset_raw',
                 revision='tip', conditions=dict(function=check_repo))

    ## new URLs
    rmap.connect('changeset_raw_home',
                 '/{repo_name:.*?}/changeset-diff/{revision}',
                 controller='changeset', action='changeset_raw',
                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_patch_home',
                 '/{repo_name:.*?}/changeset-patch/{revision}',
                 controller='changeset', action='changeset_patch',
                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_download_home',
                 '/{repo_name:.*?}/changeset-download/{revision}',
                 controller='changeset', action='changeset_download',
                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',
                 '/{repo_name:.*?}/changeset/{revision}/comment',
                controller='changeset', revision='tip', action='comment',
                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_preview',
                 '/{repo_name:.*?}/changeset/comment/preview',
                controller='changeset', action='preview_comment',
                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('changeset_comment_delete',
                 '/{repo_name:.*?}/changeset/comment/{comment_id}/delete',
                controller='changeset', action='delete_comment',
                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',
                 controller='changeset', action='changeset_info')

    rmap.connect('compare_url',
                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref:.*?}...{other_ref_type}@{other_ref:.*?}',
                 controller='compare', action='index',
                 conditions=dict(function=check_repo),
                 requirements=dict(
                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',
                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')
                 )

    rmap.connect('pullrequest_home',
                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',
                 action='index', conditions=dict(function=check_repo,
                                                 method=["GET"]))

    rmap.connect('pullrequest',
                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',
                 action='create', conditions=dict(function=check_repo,
                                                  method=["POST"]))

    rmap.connect('pullrequest_show',
                 '/{repo_name:.*?}/pull-request/{pull_request_id}',
                 controller='pullrequests',
                 action='show', conditions=dict(function=check_repo,
                                                method=["GET"]))
    rmap.connect('pullrequest_update',
                 '/{repo_name:.*?}/pull-request/{pull_request_id}',
                 controller='pullrequests',
                 action='update', conditions=dict(function=check_repo,
                                                method=["PUT"]))
    rmap.connect('pullrequest_delete',
                 '/{repo_name:.*?}/pull-request/{pull_request_id}',
                 controller='pullrequests',
                 action='delete', conditions=dict(function=check_repo,
                                                method=["DELETE"]))

    rmap.connect('pullrequest_show_all',
                 '/{repo_name:.*?}/pull-request',
                 controller='pullrequests',
                 action='show_all', conditions=dict(function=check_repo,
                                                method=["GET"]))

    rmap.connect('pullrequest_comment',
                 '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',
                 controller='pullrequests',
                 action='comment', conditions=dict(function=check_repo,
                                                method=["POST"]))

    rmap.connect('pullrequest_comment_delete',
                 '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',
                controller='pullrequests', action='delete_comment',
                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('summary_home_summary', '/{repo_name:.*?}/summary',
                controller='summary', conditions=dict(function=check_repo))

    rmap.connect('branches_home', '/{repo_name:.*?}/branches',
                controller='branches', conditions=dict(function=check_repo))

    rmap.connect('tags_home', '/{repo_name:.*?}/tags',
                controller='tags', conditions=dict(function=check_repo))

    rmap.connect('bookmarks_home', '/{repo_name:.*?}/bookmarks',
                controller='bookmarks', conditions=dict(function=check_repo))

    rmap.connect('changelog_home', '/{repo_name:.*?}/changelog',
                controller='changelog', conditions=dict(function=check_repo))

    rmap.connect('changelog_summary_home', '/{repo_name:.*?}/changelog_summary',
                controller='changelog', action='changelog_summary',
                conditions=dict(function=check_repo))

    rmap.connect('changelog_file_home', '/{repo_name:.*?}/changelog/{revision}/{f_path:.*}',
                controller='changelog', f_path=None,
                conditions=dict(function=check_repo))

    rmap.connect('changelog_details', '/{repo_name:.*?}/changelog_details/{cs}',
                controller='changelog', action='changelog_details',
                conditions=dict(function=check_repo))

    rmap.connect('files_home', '/{repo_name:.*?}/files/{revision}/{f_path:.*}',
                controller='files', revision='tip', f_path='',
                conditions=dict(function=check_repo))

    rmap.connect('files_home_nopath', '/{repo_name:.*?}/files/{revision}',
                controller='files', revision='tip', f_path='',
                conditions=dict(function=check_repo))

    rmap.connect('files_history_home',
                 '/{repo_name:.*?}/history/{revision}/{f_path:.*}',
                 controller='files', action='history', revision='tip', f_path='',
                 conditions=dict(function=check_repo))

    rmap.connect('files_diff_home', '/{repo_name:.*?}/diff/{f_path:.*}',
                controller='files', action='diff', revision='tip', f_path='',
                conditions=dict(function=check_repo))

    rmap.connect('files_diff_2way_home', '/{repo_name:.*?}/diff-2way/{f_path:.*}',
                controller='files', action='diff_2way', revision='tip', f_path='',
                conditions=dict(function=check_repo))

    rmap.connect('files_rawfile_home',
                 '/{repo_name:.*?}/rawfile/{revision}/{f_path:.*}',
                 controller='files', action='rawfile', revision='tip',
                 f_path='', conditions=dict(function=check_repo))

    rmap.connect('files_raw_home',
                 '/{repo_name:.*?}/raw/{revision}/{f_path:.*}',
                 controller='files', action='raw', revision='tip', f_path='',
                 conditions=dict(function=check_repo))

    rmap.connect('files_annotate_home',
                 '/{repo_name:.*?}/annotate/{revision}/{f_path:.*}',
                 controller='files', action='index', revision='tip',
                 f_path='', annotate=True, conditions=dict(function=check_repo))

    rmap.connect('files_edit_home',
                 '/{repo_name:.*?}/edit/{revision}/{f_path:.*}',
                 controller='files', action='edit', revision='tip',
                 f_path='', conditions=dict(function=check_repo))

    rmap.connect('files_add_home',
                 '/{repo_name:.*?}/add/{revision}/{f_path:.*}',
                 controller='files', action='add', revision='tip',
                 f_path='', conditions=dict(function=check_repo))

    rmap.connect('files_archive_home', '/{repo_name:.*?}/archive/{fname}',
                controller='files', action='archivefile',
                conditions=dict(function=check_repo))

    rmap.connect('files_nodelist_home',
                 '/{repo_name:.*?}/nodelist/{revision}/{f_path:.*}',
                controller='files', action='nodelist',
                conditions=dict(function=check_repo))

    rmap.connect('repo_fork_create_home', '/{repo_name:.*?}/fork',
                controller='forks', action='fork_create',
                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('repo_fork_home', '/{repo_name:.*?}/fork',
                controller='forks', action='fork',
                conditions=dict(function=check_repo))

    rmap.connect('repo_forks_home', '/{repo_name:.*?}/forks',
                 controller='forks', action='forks',
                 conditions=dict(function=check_repo))

    rmap.connect('repo_followers_home', '/{repo_name:.*?}/followers',
                 controller='followers', action='followers',
                 conditions=dict(function=check_repo))

    return rmap
コード例 #36
0
import traceback
from routes import Mapper
from urllib.parse import urlparse, parse_qs

getMap = Mapper()
postMap = Mapper()
putMap = Mapper()
deleteMap = Mapper()

def executeController(map, requestHandler):
    try:
        parsedPath = urlparse(requestHandler.path)
        contentLength = int(requestHandler.headers.get('content-length', 0))

        body = requestHandler.rfile.read(contentLength).decode('utf-8')

        result = map.match(parsedPath.path)
        if (result == None):
            return None

        function = result['controller']

        request = Request(
            args = result,
            query = parse_qs(parsedPath.query),
            headers = requestHandler.headers,
            body = body
        )

        return function(request)
    except BaseException:
コード例 #37
0
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE

    map.connect('/map', controller="uifunc", action="index")
    map.connect('/about', controller="uifunc", action="about")
    map.connect('/about/goals', controller="uifunc", action="goals")
    map.connect('/docs', controller="uifunc", action="userDocs")
    map.connect('/docs/developer', controller="uifunc", action="devDocs")

    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')

    return map
コード例 #38
0
 def __init__(self):
     self.mapper = Mapper()
     self.add_routes()
     self.router = middleware.RoutesMiddleware(self._dispatch, self.mapper)
コード例 #39
0
 def __init__(self):
     self._loop_control = False
     self._mapper = Mapper()
コード例 #40
0
ファイル: routing.py プロジェクト: leojpod/reddit
def make_map():
    map = Mapper()
    mc = map.connect

    for plugin in reversed(config['r2.plugins']):
        plugin.add_routes(mc)

    mc('/admin/', controller='awards')

    mc('/login', controller='forms', action='login')
    mc('/register', controller='forms', action='register')
    mc('/logout', controller='forms', action='logout')
    mc('/verify', controller='forms', action='verify')
    mc('/adminon', controller='forms', action='adminon')
    mc('/adminoff', controller='forms', action='adminoff')
    mc('/submit', controller='front', action='submit')

    mc('/over18', controller='post', action='over18')

    mc('/search', controller='front', action='search')

    mc('/rules', controller='front', action='rules')
    mc('/sup', controller='front', action='sup')
    mc('/traffic', controller='front', action='site_traffic')
    mc('/traffic/languages/:langcode',
       controller='front',
       action='lang_traffic',
       langcode='')
    mc('/traffic/adverts/:code',
       controller='front',
       action='advert_traffic',
       code='')
    mc('/traffic/subreddits/report',
       controller='front',
       action='subreddit_traffic_report')
    mc('/account-activity', controller='front', action='account_activity')

    mc('/about/message/:where', controller='message', action='listing')
    mc('/about/log', controller='front', action='moderationlog')
    mc('/about/sidebar', controller='front', action='sidebar')
    mc('/about', controller='front', action='about')
    mc('/about/flair', controller='front', action='flairlisting')
    mc('/about/:location',
       controller='front',
       action='spamlisting',
       requirements=dict(location='reports|spam|modqueue|unmoderated'))
    mc('/about/:location',
       controller='front',
       action='editreddit',
       location='about')

    mc('/subreddits/create', controller='front', action='newreddit')
    mc('/subreddits/search', controller='front', action='search_reddits')
    mc('/subreddits/login', controller='forms', action='login')
    mc('/subreddits/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned"))

    mc('/subreddits/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    # These routes are kept for backwards-compatibility reasons
    # Using the above /subreddits/ ones instead is preferable
    mc('/reddits/create', controller='front', action='newreddit')
    mc('/reddits/search', controller='front', action='search_reddits')
    mc('/reddits/login', controller='forms', action='login')
    mc('/reddits/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned"))

    mc('/reddits/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    mc('/buttons', controller='buttons', action='button_demo_page')

    #/button.js and buttonlite.js - the embeds
    mc('/button', controller='buttons', action='button_embed')
    mc('/buttonlite', controller='buttons', action='button_lite')

    mc('/widget', controller='buttons', action='widget_demo_page')
    mc('/bookmarklets', controller='buttons', action='bookmarklets')

    mc('/awards', controller='front', action='awards')
    mc('/awards/confirm/:code',
       controller='front',
       action='confirm_award_claim')
    mc('/awards/claim/:code', controller='front', action='claim_award')
    mc('/awards/received', controller='front', action='received_award')

    mc('/i18n',
       controller='redirect',
       action='redirect',
       dest='http://www.reddit.com/r/i18n')
    mc('/feedback', controller='feedback', action='feedback')
    mc('/ad_inq', controller='feedback', action='ad_inq')

    mc('/admin/awards', controller='awards')
    mc('/admin/awards/:awardcn/:action',
       controller='awards',
       requirements=dict(action="give|winners"))

    mc('/admin/errors', controller='errorlog')

    mc('/user/:username/about',
       controller='user',
       action='about',
       where='overview')
    mc('/user/:username/:where',
       controller='user',
       action='listing',
       where='overview')
    mc('/u/:username', controller='redirect', action='user_redirect')

    # preserve timereddit URLs from 4/1/2012
    mc('/t/:timereddit', controller='redirect', action='timereddit_redirect')
    mc('/t/:timereddit/*rest',
       controller='redirect',
       action='timereddit_redirect')

    mc('/prefs/:location',
       controller='forms',
       action='prefs',
       location='options')

    mc('/info/0:article/*rest',
       controller='front',
       action='oldinfo',
       dest='comments',
       type='ancient')
    mc('/info/:article/:dest/:comment',
       controller='front',
       action='oldinfo',
       type='old',
       dest='comments',
       comment=None)

    mc("/comments/gilded",
       controller="redirect",
       action="gilded_comments",
       conditions={"function": not_in_sr})
    mc("/comments/gilded", action="listing", controller="gilded")

    mc('/related/:article/:title',
       controller='front',
       action='related',
       title=None)
    mc('/details/:article/:title',
       controller='front',
       action='details',
       title=None)
    mc('/traffic/:link/:campaign',
       controller='front',
       action='traffic',
       campaign=None)
    mc('/comments/:article/:title/:comment',
       controller='front',
       action='comments',
       title=None,
       comment=None)
    mc('/duplicates/:article/:title',
       controller='front',
       action='duplicates',
       title=None)

    mc('/mail/optout', controller='forms', action='optout')
    mc('/mail/optin', controller='forms', action='optin')
    mc('/stylesheet', controller='front', action='stylesheet')
    mc('/frame', controller='front', action='frame')
    mc('/framebuster/:blah', controller='front', action='framebuster')
    mc('/framebuster/:what/:blah', controller='front', action='framebuster')

    mc('/admin/promoted', controller='promote', action='admin')
    mc('/promoted/edit_promo/:link', controller='promote', action='edit_promo')
    mc(
        '/promoted/edit_promo_cpm/:link',  # development only
        controller='promote',
        action='edit_promo_cpm')
    mc(
        '/promoted/edit_promo/pc/:campaign',
        controller='promote',  # admin only
        action='edit_promo_campaign')
    mc('/promoted/pay/:link/:campaign', controller='promote', action='pay')
    mc('/promoted/graph', controller='promote', action='graph')
    mc('/promoted/admin/graph', controller='promote', action='admingraph')
    mc('/promoted/inventory/:sr_name',
       controller='promote',
       action='inventory')

    mc('/promoted/:action',
       controller='promote',
       requirements=dict(action="edit_promo|new_promo|roadblock"))
    mc('/promoted/report', controller='promote', action='report')
    mc('/promoted/:sort/:sr',
       controller='promote',
       action='listing',
       requirements=dict(sort='live_promos'))
    mc('/promoted/:sort', controller='promote', action="listing")
    mc('/promoted/', controller='promoted', action="listing", sort="")

    mc('/health', controller='health', action='health')
    mc('/health/ads', controller='health', action='promohealth')

    mc('/', controller='hot', action='listing')

    mc('/:controller',
       action='listing',
       requirements=dict(controller="hot|new|rising|randomrising|comments"))
    mc('/saved', controller='user', action='saved_redirect')

    mc('/by_id/:names', controller='byId', action='listing')

    mc('/:sort',
       controller='browse',
       sort='top',
       action='listing',
       requirements=dict(sort='top|controversial'))

    mc('/message/compose', controller='message', action='compose')
    mc('/message/messages/:mid',
       controller='message',
       action='listing',
       where="messages")
    mc('/message/:where', controller='message', action='listing')
    mc('/message/moderator/:subwhere',
       controller='message',
       action='listing',
       where='moderator')

    mc('/thanks', controller='forms', action="claim", secret='')
    mc('/thanks/:secret', controller='forms', action="claim")

    mc('/gold', controller='forms', action="gold")
    mc('/gold/creditgild/:passthrough',
       controller='forms',
       action='creditgild')
    mc('/gold/about', controller='front', action='gold_info')
    mc('/gold/thanks', controller='front', action='goldthanks')

    mc('/password', controller='forms', action="password")
    mc('/:action',
       controller='front',
       requirements=dict(action="random|framebuster|selfserviceoatmeal"))
    mc('/:action', controller='embed', requirements=dict(action="blog"))
    mc('/help/gold',
       controller='redirect',
       action='redirect',
       dest='/gold/about')

    mc('/help/:page',
       controller='policies',
       action='policy_page',
       conditions={'function': not_in_sr},
       requirements={'page': 'privacypolicy|useragreement'})

    mc('/wiki/create/*page', controller='wiki', action='wiki_create')
    mc('/wiki/edit/*page', controller='wiki', action='wiki_revise')
    mc('/wiki/revisions', controller='wiki', action='wiki_recent')
    mc('/wiki/revisions/*page', controller='wiki', action='wiki_revisions')
    mc('/wiki/settings/*page', controller='wiki', action='wiki_settings')
    mc('/wiki/discussions/*page', controller='wiki', action='wiki_discussions')
    mc('/wiki/pages', controller='wiki', action='wiki_listing')

    mc('/api/wiki/create', controller='wikiapi', action='wiki_create')
    mc('/api/wiki/edit', controller='wikiapi', action='wiki_edit')
    mc('/api/wiki/hide', controller='wikiapi', action='wiki_revision_hide')
    mc('/api/wiki/revert', controller='wikiapi', action='wiki_revision_revert')
    mc('/api/wiki/alloweditor/:act',
       controller='wikiapi',
       requirements=dict(act="del|add"),
       action='wiki_allow_editor')

    mc('/wiki/*page', controller='wiki', action='wiki_page')
    mc('/wiki/', controller='wiki', action='wiki_page')

    mc('/:action', controller='wiki', requirements=dict(action="help|faq"))
    mc('/help/*page', controller='wiki', action='wiki_redirect')
    mc('/w/*page', controller='wiki', action='wiki_redirect')

    mc('/goto', controller='toolbar', action='goto')
    mc('/tb/:id', controller='toolbar', action='tb')
    mc('/toolbar/:action',
       controller='toolbar',
       requirements=dict(action="toolbar|inner|login"))
    mc('/toolbar/comments/:id', controller='toolbar', action='comments')

    mc('/c/:comment_id', controller='front', action='comment_by_id')

    mc('/s/*rest', controller='toolbar', action='s')
    # additional toolbar-related rules just above the catchall

    mc('/d/:what', controller='api', action='bookmarklet')

    mc('/resetpassword/:key', controller='forms', action='resetpassword')
    mc('/verification/:key', controller='forms', action='verify_email')
    mc('/resetpassword', controller='forms', action='resetpassword')

    mc('/post/:action/:url_user',
       controller='post',
       requirements=dict(action="login|reg"))
    mc('/post/:action',
       controller='post',
       requirements=dict(action="options|over18|unlogged_options|optout"
                         "|optin|login|reg"))

    mc('/api', controller='redirect', action='redirect', dest='/dev/api')
    mc('/api/distinguish/:how', controller='api', action="distinguish")
    # wherever this is, google has to agree.
    mc('/api/gcheckout', controller='ipn', action='gcheckout')
    mc('/api/spendcreddits', controller='ipn', action="spendcreddits")
    mc('/api/stripecharge/gold', controller='stripe', action='goldcharge')
    mc('/api/stripewebhook/gold/:secret',
       controller='stripe',
       action='goldwebhook')
    mc('/api/coinbasewebhook/gold/:secret',
       controller='coinbase',
       action='goldwebhook')
    mc('/api/rgwebhook/gold/:secret',
       controller='redditgifts',
       action='goldwebhook')
    mc('/api/ipn/:secret', controller='ipn', action='ipn')
    mc('/ipn/:secret', controller='ipn', action='ipn')
    mc('/api/:action/:url_user',
       controller='api',
       requirements=dict(action="login|register"))
    mc('/api/gadget/click/:ids',
       controller='api',
       action='gadget',
       type='click')
    mc('/api/gadget/:type', controller='api', action='gadget')
    mc('/api/:action',
       controller='promote',
       requirements=dict(action=("promote|unpromote|edit_promo|link_thumb|"
                                 "freebie|promote_note|update_pay|refund|"
                                 "traffic_viewer|rm_traffic_viewer|"
                                 "edit_campaign|delete_campaign|meta_promo|"
                                 "add_roadblock|rm_roadblock")))
    mc('/api/:action',
       controller='apiminimal',
       requirements=dict(action="new_captcha"))
    mc('/api/:action', controller='api')

    mc("/api/v1/:action",
       controller="oauth2frontend",
       requirements=dict(action="authorize"))
    mc("/api/v1/:action",
       controller="oauth2access",
       requirements=dict(action="access_token"))
    mc("/api/v1/:action", controller="apiv1")

    mc('/dev', controller='redirect', action='redirect', dest='/dev/api')
    mc('/dev/api', controller='apidocs', action='docs')
    mc('/dev/api/:mode',
       controller='apidocs',
       action='docs',
       requirements=dict(mode="oauth"))

    mc("/button_info", controller="api", action="info", limit=1)

    mc('/captcha/:iden', controller='captcha', action='captchaimg')

    mc('/mediaembed/:link', controller="mediaembed", action="mediaembed")

    mc('/doquery', controller='query', action='doquery')

    mc('/code',
       controller='redirect',
       action='redirect',
       dest='http://github.com/reddit/')

    mc('/socialite',
       controller='redirect',
       action='redirect',
       dest='https://addons.mozilla.org/firefox/addon/socialite/')

    mc('/mobile',
       controller='redirect',
       action='redirect',
       dest='http://m.reddit.com/')

    mc('/authorize_embed', controller='front', action='authorize_embed')

    # Used for showing ads
    mc("/ads/", controller="ad", action="ad")

    mc("/try", controller="forms", action="try_compact")

    # This route handles displaying the error page and
    # graphics used in the 404/500
    # error pages. It should likely stay at the top
    # to ensure that the error page is
    # displayed properly.
    mc('/error/document/:id', controller='error', action="document")

    # these should be near the buttom, because they should only kick
    # in if everything else fails. It's the attempted catch-all
    # reddit.com/http://... and reddit.com/34fr, but these redirect to
    # the less-guessy versions at /s/ and /tb/
    mc('/:linkoid',
       controller='toolbar',
       action='linkoid',
       requirements=dict(linkoid='[0-9a-z]{1,6}'))
    mc('/:urloid',
       controller='toolbar',
       action='urloid',
       requirements=dict(urloid=r'(\w+\.\w{2,}|https?).*'))

    mc("/*url", controller='front', action='catchall')

    return map
コード例 #41
0
ファイル: routing.py プロジェクト: govtmirror/ckan
def make_map():
    """Create, configure and return the routes Mapper"""
    # import controllers here rather than at root level because
    # pylons config is initialised by this point.

    # Helpers to reduce code clutter
    GET = dict(method=['GET'])
    PUT = dict(method=['PUT'])
    POST = dict(method=['POST'])
    DELETE = dict(method=['DELETE'])
    GET_POST = dict(method=['GET', 'POST'])
    PUT_POST = dict(method=['PUT', 'POST'])
    PUT_POST_DELETE = dict(method=['PUT', 'POST', 'DELETE'])
    OPTIONS = dict(method=['OPTIONS'])

    from ckan.lib.plugins import register_package_plugins
    from ckan.lib.plugins import register_group_plugins

    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = True

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved.
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    map.connect('*url',
                controller='home',
                action='cors_options',
                conditions=OPTIONS)

    # CUSTOM ROUTES HERE
    for plugin in routing_plugins:
        map = plugin.before_map(map)

    map.connect('home', '/', controller='home', action='index')
    map.connect('about', '/about', controller='home', action='about')

    # CKAN API versioned.
    register_list = [
        'package', 'dataset', 'resource', 'tag', 'group', 'related',
        'revision', 'licenses', 'rating', 'user', 'activity'
    ]
    register_list_str = '|'.join(register_list)

    # /api ver 3 or none
    with SubMapper(map,
                   controller='api',
                   path_prefix='/api{ver:/3|}',
                   ver='/3') as m:
        m.connect('/action/{logic_function}',
                  action='action',
                  conditions=GET_POST)

    # /api ver 1, 2, 3 or none
    with SubMapper(map,
                   controller='api',
                   path_prefix='/api{ver:/1|/2|/3|}',
                   ver='/1') as m:
        m.connect('', action='get_api')
        m.connect('/search/{register}', action='search')

    # /api ver 1, 2 or none
    with SubMapper(map,
                   controller='api',
                   path_prefix='/api{ver:/1|/2|}',
                   ver='/1') as m:
        m.connect('/tag_counts', action='tag_counts')
        m.connect('/rest', action='index')
        m.connect('/qos/throughput/', action='throughput', conditions=GET)

    # /api/rest ver 1, 2 or none
    with SubMapper(map,
                   controller='api',
                   path_prefix='/api{ver:/1|/2|}',
                   ver='/1',
                   requirements=dict(register=register_list_str)) as m:

        m.connect('/rest/{register}', action='list', conditions=GET)
        m.connect('/rest/{register}', action='create', conditions=POST)
        m.connect('/rest/{register}/{id}', action='show', conditions=GET)
        m.connect('/rest/{register}/{id}', action='update', conditions=PUT)
        m.connect('/rest/{register}/{id}', action='update', conditions=POST)
        m.connect('/rest/{register}/{id}', action='delete', conditions=DELETE)
        m.connect('/rest/{register}/{id}/:subregister',
                  action='list',
                  conditions=GET)
        m.connect('/rest/{register}/{id}/:subregister',
                  action='create',
                  conditions=POST)
        m.connect('/rest/{register}/{id}/:subregister/{id2}',
                  action='create',
                  conditions=POST)
        m.connect('/rest/{register}/{id}/:subregister/{id2}',
                  action='show',
                  conditions=GET)
        m.connect('/rest/{register}/{id}/:subregister/{id2}',
                  action='update',
                  conditions=PUT)
        m.connect('/rest/{register}/{id}/:subregister/{id2}',
                  action='delete',
                  conditions=DELETE)

    # /api/util ver 1, 2 or none
    with SubMapper(map,
                   controller='api',
                   path_prefix='/api{ver:/1|/2|}',
                   ver='/1') as m:
        m.connect('/util/user/autocomplete', action='user_autocomplete')
        m.connect('/util/is_slug_valid',
                  action='is_slug_valid',
                  conditions=GET)
        m.connect('/util/dataset/autocomplete',
                  action='dataset_autocomplete',
                  conditions=GET)
        m.connect('/util/tag/autocomplete',
                  action='tag_autocomplete',
                  conditions=GET)
        m.connect('/util/resource/format_autocomplete',
                  action='format_autocomplete',
                  conditions=GET)
        m.connect('/util/resource/format_icon',
                  action='format_icon',
                  conditions=GET)
        m.connect('/util/group/autocomplete', action='group_autocomplete')
        m.connect('/util/markdown', action='markdown')
        m.connect('/util/dataset/munge_name', action='munge_package_name')
        m.connect('/util/dataset/munge_title_to_name',
                  action='munge_title_to_package_name')
        m.connect('/util/tag/munge', action='munge_tag')
        m.connect('/util/status', action='status')
        m.connect('/util/snippet/{snippet_path:.*}', action='snippet')
        m.connect('/i18n/{lang}', action='i18n_js_translations')

    ###########
    ## /END API
    ###########

    ## Webstore
    if config.get('ckan.datastore.enabled', False):
        with SubMapper(map, controller='datastore') as m:
            m.connect('datastore_read',
                      '/api/data/{id}{url:(/.*)?}',
                      action='read',
                      url='',
                      conditions=GET)
            m.connect('datastore_write',
                      '/api/data/{id}{url:(/.*)?}',
                      action='write',
                      url='',
                      conditions=PUT_POST_DELETE)
            m.connect('datastore_read_shortcut',
                      '/dataset/{dataset}/resource/{id}/api{url:(/.*)?}',
                      action='read',
                      url='',
                      conditions=GET)
            m.connect('datastore_write_shortcut',
                      '/dataset/{dataset}/resource/{id}/api{url:(/.*)?}',
                      action='write',
                      url='',
                      conditions=PUT_POST_DELETE)

    map.redirect('/packages', '/dataset')
    map.redirect('/packages/{url:.*}', '/dataset/{url}')
    map.redirect('/package', '/dataset')
    map.redirect('/package/{url:.*}', '/dataset/{url}')

    ##to get back formalchemy uncomment these lines
    ##map.connect('/package/new', controller='package_formalchemy', action='new')
    ##map.connect('/package/edit/{id}', controller='package_formalchemy', action='edit')

    with SubMapper(map, controller='related') as m:
        m.connect('related_new', '/dataset/{id}/related/new', action='new')
        m.connect('related_edit',
                  '/dataset/{id}/related/edit/{related_id}',
                  action='edit')
        m.connect('related_delete',
                  '/dataset/{id}/related/delete/{related_id}',
                  action='delete')
        m.connect('related_list', '/dataset/{id}/related', action='list')
        m.connect('related_read', '/apps/{id}', action='read')
        m.connect('related_dashboard', '/apps', action='dashboard')

    with SubMapper(map, controller='package') as m:
        m.connect('/dataset', action='search')
        m.connect(
            '/dataset/{action}',
            requirements=dict(
                action='|'.join(['list', 'new', 'autocomplete', 'search'])))

        m.connect('/dataset/{action}/{id}/{revision}',
                  action='read_ajax',
                  requirements=dict(action='|'.join([
                      'read',
                      'edit',
                      'authz',
                      'history',
                  ])))
        m.connect('/dataset/{action}/{id}',
                  requirements=dict(action='|'.join([
                      'edit',
                      'new_metadata',
                      'new_resource',
                      'authz',
                      'history',
                      'read_ajax',
                      'history_ajax',
                      'followers',
                      'delete',
                      'api_data',
                  ])))
        m.connect('/dataset/{id}.{format}', action='read')
        m.connect('/dataset/{id}', action='read')
        m.connect('/dataset/{id}/resource/{resource_id}',
                  action='resource_read')
        m.connect('/dataset/{id}/resource_delete/{resource_id}',
                  action='resource_delete')
        m.connect('/dataset/{id}/resource_edit/{resource_id}',
                  action='resource_edit')
        m.connect('/dataset/{id}/resource/{resource_id}/download',
                  action='resource_download')
        m.connect('/dataset/{id}/resource/{resource_id}/embed',
                  action='resource_embedded_dataviewer')
        m.connect('/dataset/{id}/resource/{resource_id}/viewer',
                  action='resource_embedded_dataviewer',
                  width="960",
                  height="800")
        m.connect(
            '/dataset/{id}/resource/{resource_id}/preview/{preview_type}',
            action='resource_datapreview')

    # group
    map.redirect('/groups', '/group')
    map.redirect('/groups/{url:.*}', '/group/{url}')

    ##to get back formalchemy uncomment these lines
    ##map.connect('/group/new', controller='group_formalchemy', action='new')
    ##map.connect('/group/edit/{id}', controller='group_formalchemy', action='edit')

    # These named routes are used for custom group forms which will use the
    # names below based on the group.type ('group' is the default type)
    with SubMapper(map, controller='group') as m:
        m.connect('group_index', '/group', action='index')
        m.connect('group_list', '/group/list', action='list')
        m.connect('group_new', '/group/new', action='new')
        m.connect('group_action',
                  '/group/{action}/{id}',
                  requirements=dict(
                      action='|'.join(['edit', 'authz', 'delete', 'history'])))
        m.connect('group_read', '/group/{id}', action='read')

    register_package_plugins(map)
    register_group_plugins(map)

    # tags
    map.redirect('/tags', '/tag')
    map.redirect('/tags/{url:.*}', '/tag/{url}')
    map.redirect('/tag/read/{url:.*}',
                 '/tag/{url}',
                 _redirect_code='301 Moved Permanently')
    map.connect('/tag', controller='tag', action='index')
    map.connect('/tag/{id}', controller='tag', action='read')
    # users
    map.redirect('/users/{url:.*}', '/user/{url}')
    map.redirect('/user/', '/user')
    with SubMapper(map, controller='user') as m:
        m.connect('/user/edit', action='edit')
        # Note: openid users have slashes in their ids, so need the wildcard
        # in the route.
        m.connect('/user/dashboard', action='dashboard')
        m.connect('/user/followers/{id:.*}', action='followers')
        m.connect('/user/edit/{id:.*}', action='edit')
        m.connect('/user/reset/{id:.*}', action='perform_reset')
        m.connect('/user/register', action='register')
        m.connect('/user/login', action='login')
        m.connect('/user/_logout', action='logout')
        m.connect('/user/logged_in', action='logged_in')
        m.connect('/user/logged_out', action='logged_out')
        m.connect('/user/logged_out_redirect', action='logged_out_page')
        m.connect('/user/reset', action='request_reset')
        m.connect('/user/me', action='me')
        m.connect('/user/set_lang/{lang}', action='set_lang')
        m.connect('/user/{id:.*}', action='read')
        m.connect('/user', action='index')

    with SubMapper(map, controller='revision') as m:
        m.connect('/revision', action='index')
        m.connect('/revision/edit/{id}', action='edit')
        m.connect('/revision/diff/{id}', action='diff')
        m.connect('/revision/list', action='list')
        m.connect('/revision/{id}', action='read')

    # feeds
    with SubMapper(map, controller='feed') as m:
        m.connect('/feeds/group/{id}.atom', action='group')
        m.connect('/feeds/tag/{id}.atom', action='tag')
        m.connect('/feeds/dataset.atom', action='general')
        m.connect('/feeds/custom.atom', action='custom')

    map.connect('ckanadmin_index',
                '/ckan-admin',
                controller='admin',
                action='index')
    map.connect('ckanadmin', '/ckan-admin/{action}', controller='admin')

    # Storage routes
    with SubMapper(
            map,
            controller='ckan.controllers.storage:StorageAPIController') as m:
        m.connect('storage_api', '/api/storage', action='index')
        m.connect('storage_api_set_metadata',
                  '/api/storage/metadata/{label:.*}',
                  action='set_metadata',
                  conditions=PUT_POST)
        m.connect('storage_api_get_metadata',
                  '/api/storage/metadata/{label:.*}',
                  action='get_metadata',
                  conditions=GET)
        m.connect('storage_api_auth_request',
                  '/api/storage/auth/request/{label:.*}',
                  action='auth_request')
        m.connect('storage_api_auth_form',
                  '/api/storage/auth/form/{label:.*}',
                  action='auth_form')

    with SubMapper(
            map, controller='ckan.controllers.storage:StorageController') as m:
        m.connect('storage_upload', '/storage/upload', action='upload')
        m.connect('storage_upload_handle',
                  '/storage/upload_handle',
                  action='upload_handle')
        m.connect('storage_upload_success',
                  '/storage/upload/success',
                  action='success')
        m.connect('storage_upload_success_empty',
                  '/storage/upload/success_empty',
                  action='success_empty')
        m.connect('storage_file', '/storage/f/{label:.*}', action='file')

    with SubMapper(map, controller='util') as m:
        m.connect('/i18n/strings_{lang}.js', action='i18n_js_strings')
        m.connect('/util/redirect', action='redirect')
        m.connect('/testing/primer', action='primer')
        m.connect('/testing/markup', action='markup')

    for plugin in routing_plugins:
        map = plugin.after_map(map)

    # sometimes we get requests for favicon.ico we should redirect to
    # the real favicon location.
    map.redirect('/favicon.ico', config.get('ckan.favicon'))

    map.redirect('/*(url)/', '/{url}', _redirect_code='301 Moved Permanently')
    map.connect('/*url', controller='template', action='view')

    return map
コード例 #42
0
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE

    map.connect('home', '/', controller='news', action='index', title='index')
    map.connect('home',
                '/index',
                controller='news',
                action='index',
                title='index')
    map.connect('article',
                '/news/{title}',
                controller='news',
                action='article')
    map.connect('newshome', '/News', controller='news', action='news')
    map.connect('photo',
                '/Photo-Gallery/{title}',
                controller='news',
                action='photo')

    map.connect('/{title}', controller='news', action='show')

    return map
コード例 #43
0
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False
    map.sub_domains = True
    map.sub_domains_ignore = ["www", None]

    has_subdomain = dict(sub_domain=True)
    no_subdomain = dict(sub_domain=False)

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # Web API
    # Wraps a safe subset of adroll.api for public consumption.
    map.connect('/api/v{version}/{module}/{function}/{id}',
                version=1,
                controller='api',
                action='dispatch')
    map.connect('/api/v{version}/{module}/{function}',
                version=1,
                controller='api',
                action='dispatch')
    map.connect('/api/v{version}/{module}',
                version=1,
                controller='api',
                action='dispatch')

    # Shortened webservice routes.  Meant to be accessed from api.adroll.com per documentation.
    map.connect('/v1/{module}/{function}/{id}',
                version=1,
                controller='api',
                action='dispatch',
                sub_domain='api')
    map.connect('/v1/{module}/{function}',
                version=1,
                controller='api',
                action='dispatch',
                sub_domain='api')
    map.connect('/v1/{module}',
                version=1,
                controller='api',
                action='dispatch',
                sub_domain='api')

    # NO subdomain
    map.connect('/',
                controller='index',
                action='index',
                conditions=no_subdomain)

    map.connect('/login',
                controller='auth',
                action='login',
                conditions=no_subdomain)
    map.connect('/register',
                controller='auth',
                action='register',
                conditions=no_subdomain)

    map.connect('/create',
                controller='organization/create',
                action='index',
                conditions=no_subdomain)

    map.connect('/invite/{id}',
                controller='invite',
                action='index',
                conditions=no_subdomain)

    # in the application with subdomain
    map.connect('/',
                controller='organization/home',
                action='index',
                conditions=has_subdomain)

    map.connect('/pending',
                controller='organization/auth',
                action='pending',
                conditions=has_subdomain)
    map.connect('/login',
                controller='organization/auth',
                action='login',
                conditions=has_subdomain)
    map.connect('/register',
                controller='organization/auth',
                action='register',
                conditions=has_subdomain)

    #TODO, figure out way to not have to have two for trailing slash or not.
    map.connect('/project/{slug}',
                controller='organization/project',
                action='view',
                conditions=has_subdomain)
    map.connect('/project/{slug}/',
                controller='organization/project',
                action='view',
                conditions=has_subdomain)
    map.connect('/project/{slug}/{path:.*}',
                controller='organization/project',
                action='view',
                conditions=has_subdomain)

    map.connect('/file/delete/{id}',
                controller='organization/file',
                action='delete',
                conditions=has_subdomain)
    map.connect('/file/change/{change}',
                controller='organization/file',
                action='change',
                conditions=has_subdomain)
    map.connect('/file/{project}/{file}',
                controller='organization/file',
                action='view',
                conditions=has_subdomain)

    map.connect('/psettings/{slug}',
                controller='organization/project',
                action='settings_index',
                conditions=has_subdomain)
    map.connect('/psettings/{slug}/general',
                controller='organization/project',
                action='settings_general',
                conditions=has_subdomain)
    map.connect('/psettings/{slug}/users',
                controller='organization/project',
                action='settings_users',
                conditions=has_subdomain)

    map.connect('/projects',
                controller='organization/home',
                action='index',
                conditions=has_subdomain)
    map.connect('/projects/{action}',
                controller='organization/project',
                action='index',
                conditions=has_subdomain)
    map.connect('/projects/{action}/{slug}',
                controller='organization/project',
                action='index',
                conditions=has_subdomain)

    map.connect('/settings',
                controller='organization/settings',
                action='users',
                conditions=has_subdomain)
    map.connect('/settings/{action}',
                controller='organization/settings',
                action='users',
                conditions=has_subdomain)

    #dont care on subdomain
    map.connect('/admin', controller='admin/search', action='index')

    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')

    return map
コード例 #44
0
ファイル: routing.py プロジェクト: mohseenrm/pylons
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE

    map.connect('/', controller='hello', action='index')
    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')

    return map
コード例 #45
0
from routes import Mapper

map = Mapper()
print map

map.connect('name', '/blog/{id}', controller='main', action='index')
result = map.match('/blog/1')
print result
コード例 #46
0
ファイル: routing.py プロジェクト: whatisaphone/lesswrong
def make_map(global_conf={}, app_conf={}):
    map = Mapper()
    mc = map.connect

    admin_routes.add(mc)

    mc('/login', controller='front', action='login')
    mc('/logout', controller='front', action='logout')
    mc('/adminon', controller='front', action='adminon')
    mc('/adminoff', controller='front', action='adminoff')
    mc('/submit', controller='front', action='submit')

    mc('/imagebrowser', controller='front', action='imagebrowser')
    mc('/imagebrowser/:article', controller='front', action='imagebrowser')

    mc('/validuser', controller='front', action='validuser')

    mc('/over18', controller='post', action='over18')

    mc('/search/results', controller='front', action='search_results')

    mc('/about/:location',
       controller='front',
       action='editreddit',
       location='about')

    mc('/categories/create', controller='front', action='newreddit')
    mc('/categories/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned"))

    mc('/categories/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    #mc('/stats', controller='front', action='stats')

    mc('/user/:username/:where',
       controller='user',
       action='listing',
       where='profile')

    mc('/prefs/:location',
       controller='front',
       action='prefs',
       location='options')

    mc('/related/:article/:title',
       controller='front',
       action='related',
       title=None)
    mc('/lw/:article/:title/:comment',
       controller='front',
       action='comments',
       title=None,
       comment=None)
    mc('/edit/:article', controller='front', action="editarticle")

    mc('/stylesheet', controller='front', action='stylesheet')

    mc('/', controller='promoted', action='listing')

    for name, page in allWikiPagesCached.items():
        if page.has_key('route'):
            mc("/wiki/" + page['route'],
               controller='wikipage',
               action='wikipage',
               name=name)

    mc('/invalidate_cache', controller='wikipage', action='invalidate_cache')

    listing_controllers = "hot|saved|toplinks|topcomments|new|recommended|randomrising|comments|blessed|recentposts|edits|promoted"

    mc('/:controller',
       action='listing',
       requirements=dict(controller=listing_controllers))

    # Can't use map.resource because the version of the Routing module we're
    # using doesn't support the controller_action kw arg
    #map.resource('meetup', 'meetups', collection_actions=['create', 'new'])
    mc('/meetups/create', action='create', controller='meetups')
    mc('/meetups', action='listing', controller='meetupslisting')
    mc('/meetups/new', action='new', controller='meetups')
    mc('/meetups/:id/edit', action='edit', controller='meetups')
    mc('/meetups/:id/update', action='update', controller='meetups')
    mc('/meetups/:id', action='show', controller='meetups')

    mc('/tag/:tag', controller='tag', action='listing', where='tag')

    mc('/by_id/:names', controller='byId', action='listing')

    mc('/:sort',
       controller='browse',
       sort='top',
       action='listing',
       requirements=dict(sort='top|controversial'))

    mc('/message/compose', controller='message', action='compose')
    mc('/message/:where', controller='message', action='listing')

    mc('/:action',
       controller='front',
       requirements=dict(action="password|random|framebuster"))
    mc('/:action', controller='embed', requirements=dict(action="help|blog"))

    mc('/:action',
       controller='toolbar',
       requirements=dict(action="goto|toolbar"))

    mc('/resetpassword/:key', controller='front', action='resetpassword')
    mc('/resetpassword', controller='front', action='resetpassword')

    mc('/post/:action',
       controller='post',
       requirements=dict(action="options|over18|optout|optin|login|reg"))

    mc('/api/:action', controller='api')

    mc('/captcha/:iden', controller='captcha', action='captchaimg')

    mc('/doquery', controller='query', action='doquery')

    mc('/code',
       controller='redirect',
       action='redirect',
       dest='http://code.google.com/p/lesswrong/')

    mc('/about-less-wrong', controller='front', action='about')
    mc('/issues', controller='front', action='issues')

    # Google webmaster tools verification page
    mc('/googlea26ba8329f727095.html', controller='front', action='blank')

    # This route handles displaying the error page and
    # graphics used in the 404/500
    # error pages. It should likely stay at the top
    # to ensure that the error page is
    # displayed properly.
    mc('/error/document/:id', controller='error', action="document")

    mc("/*url", controller='front', action='catchall')

    return map
コード例 #47
0
def make_map(config):
    """Create, configure and return the routes Mapper"""
    from pylons import config as c
    c.update(config)
    from lr.model import LRNode

    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])

    def mapResource(config_key, member_name, collection_name):
        try:
            service_doc_id = config[config_key]
            service_doc = h.getServiceDocument(service_doc_id)
            if service_doc is not None and service_doc["active"]:
                map.resource(member_name, collection_name)
                if member_name == 'swordservice':
                    map.connect("/swordpub",
                                controller='swordservice',
                                action='create')
                log.info(
                    "Enabling service route for: {0} member: {1} collection: {2}"
                    .format(service_doc_id, member_name, collection_name))
            else:
                log.info(
                    "Service route for {0} is disabled".format(service_doc_id))
        except:
            log.exception(
                "Exception caught: Not enabling service route for config: {0} member: {1} collection: {2}"
                .format(config_key, member_name, collection_name))

    map.resource('filter',
                 'filters',
                 controller='contrib/filters',
                 path_prefix='/contrib',
                 name_prefix='contrib_')
    mapResource('lr.status.docid', 'status', 'status')
    mapResource('lr.distribute.docid', 'distribute', 'distribute')
    if not LRNode.nodeDescription.gateway_node:
        mapResource('lr.publish.docid', 'publish', 'publish')
        mapResource('lr.obtain.docid', 'obtain', 'obtain')
        mapResource('lr.description.docid', 'description', 'description')
        mapResource('lr.services.docid', 'services', 'services')
        mapResource('lr.policy.docid', 'policy', 'policy')
        mapResource('lr.harvest.docid', 'harvest', 'harvest')
        # Value added services
        mapResource('lr.oaipmh.docid', 'OAI-PMH', 'OAI-PMH')
        mapResource('lr.slice.docid', 'slice', 'slice')
        mapResource('lr.sword.docid', 'swordservice', 'swordservice')
    map.minimization = False
    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE
    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')
    return map
コード例 #48
0
 def initialize(self, database):
     self.mapper = Mapper()
     self.mapper.connect(None, "/{action_type}/{queue}")
コード例 #49
0
ファイル: routing.py プロジェクト: empyrical/reddit
def make_map():
    map = Mapper()
    mc = map.connect

    for plugin in reversed(config['r2.plugins']):
        plugin.add_routes(mc)

    mc('/admin/', controller='awards')

    mc('/robots.txt', controller='robots', action='robots')
    mc('/crossdomain', controller='robots', action='crossdomain')

    mc('/login', controller='forms', action='login')
    mc('/register', controller='forms', action='register')
    mc('/logout', controller='forms', action='logout')
    mc('/verify', controller='forms', action='verify')
    mc('/adminon', controller='forms', action='adminon')
    mc('/adminoff', controller='forms', action='adminoff')
    mc('/submit', controller='front', action='submit')

    mc('/over18', controller='post', action='over18')

    mc('/rules', controller='front', action='rules')
    mc('/sup', controller='front', action='sup')
    mc('/traffic', controller='front', action='site_traffic')
    mc('/traffic/languages/:langcode',
       controller='front',
       action='lang_traffic',
       langcode='')
    mc('/traffic/adverts/:code',
       controller='front',
       action='advert_traffic',
       code='')
    mc('/traffic/subreddits/report',
       controller='front',
       action='subreddit_traffic_report')
    mc('/account-activity', controller='front', action='account_activity')

    mc('/subreddits/create', controller='front', action='newreddit')
    mc('/subreddits/search', controller='front', action='search_reddits')
    mc('/subreddits/login', controller='forms', action='login')
    mc('/subreddits/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned|employee|gold"))
    # If no subreddit is specified, might as well show a list of 'em.
    mc('/r', controller='redirect', action='redirect', dest='/subreddits')

    mc('/subreddits/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    # These routes are kept for backwards-compatibility reasons
    # Using the above /subreddits/ ones instead is preferable
    mc('/reddits/create', controller='front', action='newreddit')
    mc('/reddits/search', controller='front', action='search_reddits')
    mc('/reddits/login', controller='forms', action='login')
    mc('/reddits/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned"))

    mc('/reddits/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    mc('/buttons', controller='buttons', action='button_demo_page')

    #/button.js and buttonlite.js - the embeds
    mc('/button', controller='buttons', action='button_embed')
    mc('/buttonlite', controller='buttons', action='button_lite')

    mc('/widget', controller='buttons', action='widget_demo_page')
    mc('/bookmarklets', controller='buttons', action='bookmarklets')

    mc('/awards', controller='front', action='awards')
    mc('/awards/confirm/:code',
       controller='front',
       action='confirm_award_claim')
    mc('/awards/claim/:code', controller='front', action='claim_award')
    mc('/awards/received', controller='front', action='received_award')

    mc('/i18n',
       controller='redirect',
       action='redirect',
       dest='http://www.reddit.com/r/i18n')
    mc('/feedback', controller='redirect', action='redirect', dest='/contact')
    mc('/contact', controller='front', action='contact_us')
    mc('/jobs',
       controller='redirect',
       action='redirect',
       dest='https://jobs.lever.co/reddit')

    mc('/admin/awards', controller='awards')
    mc('/admin/awards/:awardcn/:action',
       controller='awards',
       requirements=dict(action="give|winners"))

    mc('/admin/creddits', controller='admintool', action='creddits')
    mc('/admin/gold', controller='admintool', action='gold')

    mc('/admin/errors', controller='errorlog')

    # Username-relative userpage redirects
    mc('/user/me', controller='user', action='rel_user_redirect')
    mc('/user/me/*rest', controller='user', action='rel_user_redirect')

    mc('/user/:username/about',
       controller='user',
       action='about',
       where='overview')
    mc('/user/:username/:where',
       controller='user',
       action='listing',
       where='overview')
    mc('/user/:username/saved/:category',
       controller='user',
       action='listing',
       where='saved')

    multi_prefixes = (
        partial_connect(mc, path_prefix='/user/:username/m/:multipath'),
        partial_connect(mc, path_prefix='/me/m/:multipath', my_multi=True),
        partial_connect(mc, path_prefix='/me/f/:filtername'),
    )

    for connect in multi_prefixes:
        connect('/', controller='hot', action='listing')
        connect('/submit', controller='front', action='submit')
        connect('/:sort',
                controller='browse',
                sort='top',
                action='listing',
                requirements=dict(sort='top|controversial'))
        connect(
            '/:controller',
            action='listing',
            requirements=dict(controller="hot|new|rising|randomrising|ads"))

    mc('/user/:username/:where/:show', controller='user', action='listing')

    mc('/explore', controller='front', action='explore')
    mc('/api/recommend/feedback', controller='api', action='rec_feedback')

    mc('/about/sidebar', controller='front', action='sidebar')
    mc('/about/sticky', controller='front', action='sticky')
    mc('/about/flair', controller='front', action='flairlisting')
    mc('/about', controller='front', action='about')
    for connect in (mc, ) + multi_prefixes:
        connect('/about/message/:where',
                controller='message',
                action='listing')
        connect('/about/log', controller='front', action='moderationlog')
        connect('/about/:location',
                controller='front',
                action='spamlisting',
                requirements=dict(
                    location='reports|spam|modqueue|unmoderated|edited'))
        connect(
            '/about/:where',
            controller='userlistlisting',
            requirements=dict(
                where=
                'contributors|banned|wikibanned|wikicontributors|moderators'),
            action='listing')
        connect('/about/:location',
                controller='front',
                action='editreddit',
                requirements=dict(location='edit|stylesheet|traffic|about'))
        connect('/comments', controller='comments', action='listing')
        connect('/comments/gilded', action='listing', controller='gilded')
        connect('/gilded', action='listing', controller='gilded')
        connect('/search', controller='front', action='search')

    mc('/u/:username', controller='redirect', action='user_redirect')
    mc('/u/:username/*rest', controller='redirect', action='user_redirect')

    # preserve timereddit URLs from 4/1/2012
    mc('/t/:timereddit', controller='redirect', action='timereddit_redirect')
    mc('/t/:timereddit/*rest',
       controller='redirect',
       action='timereddit_redirect')

    # /prefs/friends is also aliased to /api/v1/me/friends
    mc('/prefs/:where',
       controller='userlistlisting',
       action='user_prefs',
       requirements=dict(where='blocked|friends'))
    mc('/prefs/:location',
       controller='forms',
       action='prefs',
       location='options')

    mc('/info/0:article/*rest',
       controller='front',
       action='oldinfo',
       dest='comments',
       type='ancient')
    mc('/info/:article/:dest/:comment',
       controller='front',
       action='oldinfo',
       type='old',
       dest='comments',
       comment=None)

    mc('/related/:article/:title',
       controller='front',
       action='related',
       title=None)
    mc('/details/:article/:title',
       controller='front',
       action='details',
       title=None)
    mc('/traffic/:link/:campaign',
       controller='front',
       action='traffic',
       campaign=None)
    mc('/comments/:article/:title/:comment',
       controller='front',
       action='comments',
       title=None,
       comment=None)
    mc('/duplicates/:article/:title',
       controller='front',
       action='duplicates',
       title=None)

    mc('/mail/optout', controller='forms', action='optout')
    mc('/mail/optin', controller='forms', action='optin')
    mc('/stylesheet', controller='front', action='stylesheet')
    mc('/frame', controller='front', action='frame')
    mc('/framebuster/:blah', controller='front', action='framebuster')
    mc('/framebuster/:what/:blah', controller='front', action='framebuster')

    # sponsor endpoints
    mc('/sponsor/report', controller='sponsor', action='report')
    mc('/sponsor/inventory', controller='sponsor', action='promote_inventory')
    mc('/sponsor/roadblock', controller='sponsor', action="roadblock")
    mc('/sponsor/lookup_user', controller='sponsor', action="lookup_user")

    # sponsor listings
    mc('/sponsor/promoted/:sort',
       controller='sponsorlisting',
       action='listing',
       requirements=dict(sort="future_promos|pending_promos|unpaid_promos|"
                         "rejected_promos|live_promos|underdelivered|"
                         "reported|house|fraud|all"))
    mc('/sponsor', controller='sponsorlisting', action="listing", sort="all")
    mc('/sponsor/promoted/',
       controller='sponsorlisting',
       action="listing",
       sort="all")
    mc('/sponsor/promoted/live_promos/:sr',
       controller='sponsorlisting',
       sort='live_promos',
       action='listing')

    # listings of user's promos
    mc('/promoted/:sort',
       controller='promotelisting',
       action="listing",
       requirements=dict(sort="future_promos|pending_promos|unpaid_promos|"
                         "rejected_promos|live_promos|all"))
    mc('/promoted/', controller='promotelisting', action="listing", sort="all")

    # editing endpoints
    mc('/promoted/new_promo', controller='promote', action='new_promo')
    mc('/promoted/edit_promo/:link', controller='promote', action='edit_promo')
    mc('/promoted/pay/:link/:campaign', controller='promote', action='pay')
    mc('/promoted/refund/:link/:campaign',
       controller='promote',
       action='refund')

    mc('/health', controller='health', action='health')
    mc('/health/ads', controller='health', action='promohealth')
    mc('/health/caches', controller='health', action='cachehealth')

    mc('/', controller='hot', action='listing')

    mc('/:controller',
       action='listing',
       requirements=dict(controller="hot|new|rising|randomrising|ads"))
    mc('/saved', controller='user', action='saved_redirect')

    mc('/by_id/:names', controller='byId', action='listing')

    mc('/:sort',
       controller='browse',
       sort='top',
       action='listing',
       requirements=dict(sort='top|controversial'))

    mc('/message/compose', controller='message', action='compose')
    mc('/message/messages/:mid',
       controller='message',
       action='listing',
       where="messages")
    mc('/message/:where', controller='message', action='listing')
    mc('/message/moderator/:subwhere',
       controller='message',
       action='listing',
       where='moderator')

    mc('/thanks', controller='forms', action="claim", secret='')
    mc('/thanks/:secret', controller='forms', action="claim")

    mc('/gold', controller='forms', action="gold", is_payment=False)
    mc('/gold/payment', controller='forms', action="gold", is_payment=True)
    mc('/gold/creditgild/:passthrough',
       controller='forms',
       action='creditgild')
    mc('/gold/thanks', controller='front', action='goldthanks')
    mc('/gold/subscription', controller='forms', action='subscription')
    mc('/gilding', controller='front', action='gilding')
    mc('/creddits',
       controller='redirect',
       action='redirect',
       dest='/gold?goldtype=creddits')

    mc('/password', controller='forms', action="password")
    mc('/:action',
       controller='front',
       requirements=dict(action="random|framebuster"))
    mc('/:action', controller='embed', requirements=dict(action="blog"))
    mc('/help/gold',
       controller='redirect',
       action='redirect',
       dest='/gold/about')

    mc('/help/:page',
       controller='policies',
       action='policy_page',
       conditions={'function': not_in_sr},
       requirements={'page': 'privacypolicy|useragreement'})

    mc('/wiki/create/*page', controller='wiki', action='wiki_create')
    mc('/wiki/edit/*page', controller='wiki', action='wiki_revise')
    mc('/wiki/revisions', controller='wiki', action='wiki_recent')
    mc('/wiki/revisions/*page', controller='wiki', action='wiki_revisions')
    mc('/wiki/settings/*page', controller='wiki', action='wiki_settings')
    mc('/wiki/discussions/*page', controller='wiki', action='wiki_discussions')
    mc('/wiki/pages', controller='wiki', action='wiki_listing')

    mc('/api/wiki/edit', controller='wikiapi', action='wiki_edit')
    mc('/api/wiki/hide', controller='wikiapi', action='wiki_revision_hide')
    mc('/api/wiki/delete', controller='wikiapi', action='wiki_revision_delete')
    mc('/api/wiki/revert', controller='wikiapi', action='wiki_revision_revert')
    mc('/api/wiki/alloweditor/:act',
       controller='wikiapi',
       requirements=dict(act="del|add"),
       action='wiki_allow_editor')

    mc('/wiki/*page', controller='wiki', action='wiki_page')
    mc('/wiki/', controller='wiki', action='wiki_page')

    mc('/:action', controller='wiki', requirements=dict(action="help|faq"))
    mc('/help/*page', controller='wiki', action='wiki_redirect')
    mc('/w/*page', controller='wiki', action='wiki_redirect')

    mc('/goto', controller='toolbar', action='goto')
    mc('/tb/:id', controller='toolbar', action='tb')
    mc('/toolbar/:action',
       controller='toolbar',
       requirements=dict(action="toolbar|inner|login"))
    mc('/toolbar/comments/:id', controller='toolbar', action='comments')

    mc('/c/:comment_id', controller='front', action='comment_by_id')

    mc('/s/*urloid', controller='toolbar', action='s')
    # additional toolbar-related rules just above the catchall

    mc('/resetpassword/:key', controller='forms', action='resetpassword')
    mc('/verification/:key', controller='forms', action='verify_email')
    mc('/resetpassword', controller='forms', action='resetpassword')

    mc('/modify_hsts_grant', controller='front', action='modify_hsts_grant')

    mc('/post/:action/:url_user',
       controller='post',
       requirements=dict(action="login|reg"))
    mc('/post/:action',
       controller='post',
       requirements=dict(action="options|over18|unlogged_options|optout"
                         "|optin|login|reg|explore_settings"))

    mc('/api', controller='redirect', action='redirect', dest='/dev/api')
    mc('/api/distinguish/:how', controller='api', action="distinguish")
    mc('/api/spendcreddits', controller='ipn', action="spendcreddits")
    mc('/api/stripecharge/gold', controller='stripe', action='goldcharge')
    mc('/api/modify_subscription',
       controller='stripe',
       action='modify_subscription')
    mc('/api/cancel_subscription',
       controller='stripe',
       action='cancel_subscription')
    mc('/api/stripewebhook/gold/:secret',
       controller='stripe',
       action='goldwebhook')
    mc('/api/coinbasewebhook/gold/:secret',
       controller='coinbase',
       action='goldwebhook')
    mc('/api/rgwebhook/gold/:secret',
       controller='redditgifts',
       action='goldwebhook')
    mc('/api/ipn/:secret', controller='ipn', action='ipn')
    mc('/ipn/:secret', controller='ipn', action='ipn')
    mc('/api/:action/:url_user',
       controller='api',
       requirements=dict(action="login|register"))
    mc('/api/gadget/click/:ids',
       controller='api',
       action='gadget',
       type='click')
    mc('/api/gadget/:type', controller='api', action='gadget')
    mc('/api/:action',
       controller='promoteapi',
       requirements=dict(action=("promote|unpromote|edit_promo|link_thumb|"
                                 "freebie|promote_note|update_pay|"
                                 "edit_campaign|delete_campaign|"
                                 "add_roadblock|rm_roadblock|check_inventory|"
                                 "refund_campaign|terminate_campaign|"
                                 "review_fraud|create_promo")))
    mc('/api/:action',
       controller='apiminimal',
       requirements=dict(action="new_captcha"))
    mc('/api/:type',
       controller='api',
       requirements=dict(type='wikibannednote|bannednote'),
       action='relnote')

    # Route /api/multi here to prioritize it over the /api/:action rule
    mc("/api/multi",
       controller="multiapi",
       action="multi",
       conditions={"method": ["POST"]})

    mc('/api/:action', controller='api')

    mc('/api/recommend/sr/:srnames',
       controller='api',
       action='subreddit_recommendations')

    mc('/api/server_seconds_visibility',
       controller='api',
       action='server_seconds_visibility')

    mc("/api/multi/mine", controller="multiapi", action="my_multis")
    mc("/api/multi/user/:username",
       controller="multiapi",
       action="list_multis")
    mc("/api/multi/copy", controller="multiapi", action="multi_copy")
    mc("/api/multi/rename", controller="multiapi", action="multi_rename")
    mc("/api/multi/*multipath/r/:srname",
       controller="multiapi",
       action="multi_subreddit")
    mc("/api/multi/*multipath/description",
       controller="multiapi",
       action="multi_description")
    mc("/api/multi/*multipath", controller="multiapi", action="multi")
    mc("/api/filter/*multipath/r/:srname",
       controller="multiapi",
       action="multi_subreddit")
    mc("/api/filter/*multipath", controller="multiapi", action="multi")

    mc("/api/v1/:action",
       controller="oauth2frontend",
       requirements=dict(action="authorize"))
    mc("/api/v1/:action",
       controller="oauth2access",
       requirements=dict(action="access_token|revoke_token"))
    mc("/api/v1/user/:username/trophies",
       controller="apiv1user",
       action="usertrophies")
    mc("/api/v1/:action", controller="apiv1user")
    # Same controller/action as /prefs/friends
    mc("/api/v1/me/:where",
       controller="userlistlisting",
       action="user_prefs",
       requirements=dict(where="friends"))
    mc("/api/v1/me/:action", controller="apiv1user")
    mc("/api/v1/me/:action/:username", controller="apiv1user")

    mc("/api/v1/gold/gild/:fullname", controller="apiv1gold", action="gild")
    mc("/api/v1/gold/give/:username", controller="apiv1gold", action="give")

    mc('/dev', controller='redirect', action='redirect', dest='/dev/api')
    mc('/dev/api', controller='apidocs', action='docs')
    mc('/dev/api/:mode',
       controller='apidocs',
       action='docs',
       requirements=dict(mode="oauth"))

    mc("/button_info", controller="api", action="url_info", limit=1)

    mc('/captcha/:iden', controller='captcha', action='captchaimg')

    mc('/mediaembed/:link/:credentials',
       controller="mediaembed",
       action="mediaembed",
       credentials=None)

    mc('/code',
       controller='redirect',
       action='redirect',
       dest='http://github.com/reddit/')

    mc('/socialite',
       controller='redirect',
       action='redirect',
       dest='https://addons.mozilla.org/firefox/addon/socialite/')

    mc('/mobile',
       controller='redirect',
       action='redirect',
       dest='http://m.reddit.com/')

    mc('/authorize_embed', controller='front', action='authorize_embed')

    # Used for showing ads
    mc("/ads/", controller="ad", action="ad")

    mc("/try", controller="forms", action="try_compact")

    mc("/web/timings", controller="weblog", action="timings")

    mc("/web/log/:level",
       controller="weblog",
       action="message",
       requirements=dict(level="error"))

    # This route handles displaying the error page and
    # graphics used in the 404/500
    # error pages. It should likely stay at the top
    # to ensure that the error page is
    # displayed properly.
    mc('/error/document/:id', controller='error', action="document")

    # these should be near the buttom, because they should only kick
    # in if everything else fails. It's the attempted catch-all
    # reddit.com/http://... and reddit.com/34fr, but these redirect to
    # the less-guessy versions at /s/ and /tb/
    mc('/:linkoid',
       controller='toolbar',
       action='linkoid',
       requirements=dict(linkoid='[0-9a-z]{1,6}'))
    mc('/:urloid',
       controller='toolbar',
       action='s',
       requirements=dict(urloid=r'(\w+\.\w{2,}|https?).*'))

    mc("/*url", controller='front', action='catchall')

    return map
コード例 #50
0
 def initialize(self, database):
     self.mapper = Mapper()
     self.mapper.connect(None, "/{action}/{exchange}/{queue}")
     self.mapper.connect(None, "/{action}/{exchange}/")
     print 'fdd'
コード例 #51
0
ファイル: routing.py プロジェクト: kevinmangan/reddit
def make_map(global_conf={}, app_conf={}):
    map = Mapper()
    mc = map.connect

    admin_routes.add(mc)

    mc('/login', controller='forms', action='login')
    mc('/register', controller='forms', action='register')
    mc('/logout', controller='forms', action='logout')
    mc('/verify', controller='forms', action='verify')
    mc('/adminon', controller='forms', action='adminon')
    mc('/adminoff', controller='forms', action='adminoff')
    mc('/submit', controller='front', action='submit')
    mc('/validuser', controller='forms', action='validuser')

    mc('/over18', controller='post', action='over18')

    mc('/search', controller='front', action='search')

    mc('/sup', controller='front', action='sup')
    mc('/traffic', controller='front', action='site_traffic')
    mc('/account-activity', controller='front', action='account_activity')

    mc('/about/message/:where', controller='message', action='listing')
    mc('/about/log', controller='front', action='moderationlog')
    mc('/about/:location',
       controller='front',
       action='editreddit',
       location='about')

    mc('/reddits/create', controller='front', action='newreddit')
    mc('/reddits/search', controller='front', action='search_reddits')
    mc('/reddits/login', controller='forms', action='login')
    mc('/reddits/:where',
       controller='reddits',
       action='listing',
       where='popular',
       requirements=dict(where="popular|new|banned"))

    mc('/reddits/mine/:where',
       controller='myreddits',
       action='listing',
       where='subscriber',
       requirements=dict(where='subscriber|contributor|moderator'))

    mc('/buttons', controller='buttons', action='button_demo_page')
    mc('/upgradebuttons', controller='buttons', action='upgrade_buttons')
    #the frame
    mc('/button_content', controller='buttons', action='button_content')
    #/button.js and buttonlite.js - the embeds
    mc('/button', controller='buttonjs', action='button_embed')
    mc('/buttonlite', controller='buttons', action='button_lite')

    mc('/widget', controller='buttons', action='widget_demo_page')
    mc('/bookmarklets', controller='buttons', action='bookmarklets')
    mc('/iphonebookmarklet', controller='buttons', action='iphonebookmarklets')

    mc('/awards', controller='front', action='awards')

    mc('/i18n',
       controller='redirect',
       action='redirect',
       dest='http://www.reddit.com/r/i18n')
    mc('/feedback', controller='feedback', action='feedback')
    mc('/ad_inq', controller='feedback', action='ad_inq')

    mc('/admin/usage', controller='usage')

    # Used for editing ads
    mc('/admin/ads', controller='ads')
    mc('/admin/ads/:adcn/:action',
       controller='ads',
       requirements=dict(action="assign|srs"))

    mc('/admin/awards', controller='awards')
    mc('/admin/awards/:awardcn/:action',
       controller='awards',
       requirements=dict(action="give|winners"))

    mc('/admin/errors', controller='errorlog')

    mc('/admin/:action', controller='admin')

    mc('/user/:username/about',
       controller='user',
       action='about',
       where='overview')
    mc('/user/:username/:where',
       controller='user',
       action='listing',
       where='overview')

    mc('/prefs/:location',
       controller='forms',
       action='prefs',
       location='options')

    mc('/depmod', controller='forms', action='depmod')

    mc('/info/0:article/*rest',
       controller='front',
       action='oldinfo',
       dest='comments',
       type='ancient')
    mc('/info/:article/:dest/:comment',
       controller='front',
       action='oldinfo',
       type='old',
       dest='comments',
       comment=None)

    mc('/related/:article/:title',
       controller='front',
       action='related',
       title=None)
    mc('/details/:article/:title',
       controller='front',
       action='details',
       title=None)
    mc('/traffic/:article/:title',
       controller='front',
       action='traffic',
       title=None)
    mc('/comments/:article/:title/:comment',
       controller='front',
       action='comments',
       title=None,
       comment=None)
    mc('/duplicates/:article/:title',
       controller='front',
       action='duplicates',
       title=None)

    mc('/mail/optout', controller='forms', action='optout')
    mc('/mail/optin', controller='forms', action='optin')
    mc('/stylesheet', controller='front', action='stylesheet')
    mc('/frame', controller='front', action='frame')
    mc('/framebuster/:blah', controller='front', action='framebuster')
    mc('/framebuster/:what/:blah', controller='front', action='framebuster')

    mc('/promoted/edit_promo/:link', controller='promote', action='edit_promo')
    mc('/promoted/pay/:link/:indx', controller='promote', action='pay')
    mc('/promoted/graph', controller='promote', action='graph')
    mc('/promoted/:action',
       controller='promote',
       requirements=dict(action="edit_promo|new_promo|roadblock"))
    mc('/promoted/:sort', controller='promote', action="listing")
    mc('/promoted/', controller='promoted', action="listing", sort="")

    mc('/health', controller='health', action='health')

    mc('/', controller='hot', action='listing')

    listing_controllers = "hot|saved|new|randomrising|comments"

    mc('/:controller',
       action='listing',
       requirements=dict(controller=listing_controllers))

    mc('/by_id/:names', controller='byId', action='listing')

    mc('/:sort',
       controller='browse',
       sort='top',
       action='listing',
       requirements=dict(sort='top|controversial'))

    mc('/message/compose', controller='message', action='compose')
    mc('/message/messages/:mid',
       controller='message',
       action='listing',
       where="messages")
    mc('/message/:where', controller='message', action='listing')
    mc('/message/moderator/:subwhere',
       controller='message',
       action='listing',
       where='moderator')

    mc('/thanks', controller='forms', action="thanks", secret='')
    mc('/thanks/:secret', controller='forms', action="thanks")

    mc('/gold', controller='forms', action="gold")

    mc('/password', controller='forms', action="password")
    mc('/:action',
       controller='front',
       requirements=dict(action="random|framebuster|selfserviceoatmeal"))
    mc('/:action',
       controller='embed',
       requirements=dict(action="help|blog|faq"))
    mc('/help/*anything', controller='embed', action='help')

    mc('/goto', controller='toolbar', action='goto')
    mc('/tb/:id', controller='toolbar', action='tb')
    mc('/toolbar/:action',
       controller='toolbar',
       requirements=dict(action="toolbar|inner|login"))
    mc('/toolbar/comments/:id', controller='toolbar', action='comments')

    mc('/c/:comment_id', controller='front', action='comment_by_id')

    mc('/s/*rest', controller='toolbar', action='s')
    # additional toolbar-related rules just above the catchall

    mc('/d/:what', controller='api', action='bookmarklet')

    mc('/resetpassword/:key', controller='forms', action='resetpassword')
    mc('/verification/:key', controller='forms', action='verify_email')
    mc('/resetpassword', controller='forms', action='resetpassword')

    mc('/post/:action/:url_user',
       controller='post',
       requirements=dict(action="login|reg"))
    mc('/post/:action',
       controller='post',
       requirements=dict(
           action="options|over18|unlogged_options|optout|optin|login|reg"))

    mc('/api/distinguish/:how', controller='api', action="distinguish")
    # wherever this is, google has to agree.
    mc('/api/gcheckout', controller='ipn', action='gcheckout')
    mc('/api/spendcreddits', controller='ipn', action="spendcreddits")
    mc('/api/ipn/:secret', controller='ipn', action='ipn')
    mc('/ipn/:secret', controller='ipn', action='ipn')
    mc('/api/:action/:url_user',
       controller='api',
       requirements=dict(action="login|register"))
    mc('/api/gadget/click/:ids',
       controller='api',
       action='gadget',
       type='click')
    mc('/api/gadget/:type', controller='api', action='gadget')
    mc('/api/:action',
       controller='promote',
       requirements=dict(
           action=
           "promote|unpromote|edit_promo|link_thumb|freebie|promote_note|update_pay|refund|traffic_viewer|rm_traffic_viewer|edit_campaign|delete_campaign|meta_promo|add_roadblock|rm_roadblock"
       ))
    mc('/api/:action',
       controller='apiminimal',
       requirements=dict(action="new_captcha"))
    mc('/api/:action', controller='api')

    mc("/api/v1/:action",
       controller="oauth2frontend",
       requirements=dict(action="authorize"))
    mc("/api/v1/:action",
       controller="oauth2access",
       requirements=dict(action="access_token"))
    mc("/api/v1/:action", controller="apiv1")

    mc("/button_info", controller="api", action="info", limit=1)

    mc('/captcha/:iden', controller='captcha', action='captchaimg')

    mc('/mediaembed/:link', controller="mediaembed", action="mediaembed")

    mc('/doquery', controller='query', action='doquery')

    mc('/store',
       controller='redirect',
       action='redirect',
       dest='http://store.reddit.com/index.html')

    mc('/code',
       controller='redirect',
       action='redirect',
       dest='http://github.com/reddit/')

    mc('/mobile',
       controller='redirect',
       action='redirect',
       dest='http://m.reddit.com/')

    mc('/authorize_embed', controller='front', action='authorize_embed')

    # Used for showing ads
    mc("/ads/", controller="ad", action="ad")
    mc("/ads/r/:reddit_name/:keyword",
       controller="ad",
       action="ad",
       keyword=None)
    mc("/ads/:codename", controller="ad", action="ad_by_codename")

    mc("/try", controller="forms", action="try_compact")
    mc('/comscore-iframe/', controller='mediaembed', action='comscore')
    mc('/comscore-iframe/*url', controller='mediaembed', action='comscore')

    # This route handles displaying the error page and
    # graphics used in the 404/500
    # error pages. It should likely stay at the top
    # to ensure that the error page is
    # displayed properly.
    mc('/error/document/:id', controller='error', action="document")

    # these should be near the buttom, because they should only kick
    # in if everything else fails. It's the attempted catch-all
    # reddit.com/http://... and reddit.com/34fr, but these redirect to
    # the less-guessy versions at /s/ and /tb/
    mc('/:linkoid',
       controller='toolbar',
       action='linkoid',
       requirements=dict(linkoid='[0-9a-z]{1,6}'))
    mc('/:urloid',
       controller='toolbar',
       action='urloid',
       requirements=dict(urloid=r'(\w+\.\w{2,}|https?).*'))

    mc("/*url", controller='front', action='catchall')

    return map
コード例 #52
0
from routes import Mapper

from cc.engine.licenses import routing as licenses_routing
from cc.engine.chooser import routing as chooser_routing
from cc.engine.characteristic import routing as characteristic_routing

mapping = Mapper()
mapping.minimization = False
mapping.connect("index", "/", controller="cc.engine.views:root_view")

mapping.connect('/publicdomain/',
                controller="cc.engine.licenses.views:publicdomain_view")

mapping.extend(licenses_routing.licenses_routes, '/licenses')
mapping.extend(licenses_routing.cc0_routes, '/publicdomain/zero')
mapping.extend(licenses_routing.mark_routes, '/publicdomain/mark')
mapping.extend(chooser_routing.chooser_routes, '/choose')
mapping.extend(characteristic_routing.characteristic_routes, '/characteristic')

mapping.connect('/license/work-html-popup',
                controller="cc.engine.views:work_html_redirect")

mapping.connect('/license/{remaining_url:.*}',
                controller="cc.engine.views:license_redirect")
コード例 #53
0
ファイル: wsgi.py プロジェクト: c65sdn/faucet
class WSGIApplication:
    def __init__(self, **config):
        self.config = config
        self.mapper = Mapper()
        self.registory = {}
        self._wsmanager = WebSocketManager()
        super().__init__()

    def _match(self, req):
        # Note: Invoke the new API, first. If the arguments unmatched,
        # invoke the old API.
        try:
            return self.mapper.match(environ=req.environ)
        except TypeError:
            self.mapper.environ = req.environ
            return self.mapper.match(req.path_info)

    @wsgify_hack
    def __call__(self, req, start_response):
        match = self._match(req)

        if not match:
            return webob.exc.HTTPNotFound()

        req.start_response = start_response
        req.urlvars = match
        link = URLGenerator(self.mapper, req.environ)

        data = None
        name = match['controller'].__name__
        if name in self.registory:
            data = self.registory[name]

        controller = match['controller'](req, link, data, **self.config)
        controller.parent = self
        return controller(req)

    def register(self, controller, data=None):
        def _target_filter(attr):
            if not inspect.ismethod(attr) and not inspect.isfunction(attr):
                return False
            if not hasattr(attr, 'routing_info'):
                return False
            return True

        methods = inspect.getmembers(controller, _target_filter)
        for method_name, method in methods:
            routing_info = getattr(method, 'routing_info')
            name = routing_info['name']
            path = routing_info['path']
            conditions = {}
            if routing_info.get('methods'):
                conditions['method'] = routing_info['methods']
            requirements = routing_info.get('requirements') or {}
            self.mapper.connect(name,
                                path,
                                controller=controller,
                                requirements=requirements,
                                action=method_name,
                                conditions=conditions)
        if data:
            self.registory[controller.__name__] = data

    @property
    def websocketmanager(self):
        return self._wsmanager
コード例 #54
0
ファイル: index.py プロジェクト: lautiamkok/python-wsgi
import os
import MySQLdb
import jinja2

# Setup a mapper
from routes import Mapper

map = Mapper()
#map.resource("user", "users")

map.connect("add user",
            "/user",
            controller="addUser",
            action="add",
            conditions=dict(method=["GET"]))

map.connect("post user",
            "/user",
            controller="postUser",
            action="post",
            conditions=dict(method=["POST"]))

map.connect("update user",
            "/user/{id}",
            controller="updateUser",
            action="update",
            conditions=dict(method=["GET"]))

map.connect("put user",
            "/user/{id}",
            controller="putUser",
コード例 #55
0
def make_map(
    global_conf,
    app_conf,
):
    '''
    Create, configure and return the routes Mapper
    There are the three main controllers:
        /admin
        /validate
        /system
    '''
    routeMap = Mapper(directory=config['pylons.paths']['controllers'],
                      always_scan=config['debug'])
    routeMap.minimization = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved

    routeMap.connect('/error/{action}', controller='error')
    routeMap.connect('/error/{action}/{id}', controller='error')

    # routeMap.connect('/{controller}/{action}')
    # routeMap.connect('/{controller}/{action}/{id}')

    # the first / - default will be taken!!

    # in case of selfservice, we route the default / to selfservice
    selfservice = app_conf.get('service.selfservice', 'True') == 'True'
    if selfservice:
        routeMap.connect('/selfservice/custom-style.css',
                         controller='selfservice',
                         action='custom_style')
        routeMap.connect('/selfservice',
                         controller='selfservice',
                         action='index')
        routeMap.connect('/', controller='selfservice', action='index')
        for cont in ['selfservice', 'account']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of support for a remote selfservice, we have to enable this hook
    userservice = app_conf.get('service.userservice', 'True') == 'True'
    if userservice:
        routeMap.connect('/userservice',
                         controller='userservice',
                         action='index')
        for cont in ['userservice']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of manage, we route the default / to manage
    manage = app_conf.get('service.manage', 'True') == 'True'
    if manage:
        routeMap.connect('/manage/custom-style.css',
                         controller='manage',
                         action='custom_style')
        routeMap.connect('/admin', controller='admin', action='show')
        routeMap.connect('/system', controller='system', action='getConfig')
        routeMap.connect('/manage/', controller='manage', action='index')
        routeMap.connect('/', controller='manage', action='index')

        for cont in ['admin', 'system', 'manage', 'audit', 'auth']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of validate, we route the default / to validate
    validate = app_conf.get('service.validate', 'True') == 'True'
    if validate:
        routeMap.connect('/validate', controller='validate', action='check')
        routeMap.connect('/', controller='validate', action='check')
        for cont in ['validate']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of validate, we route the default / to validate
    validate = app_conf.get('service.ocra', 'True') == 'True'
    if validate:
        routeMap.connect('/ocra', controller='ocra', action='checkstatus')
        for cont in ['ocra']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    openid = app_conf.get('service.openid', 'True') == 'True'
    if openid:
        # the default openid will be the status
        routeMap.connect('/openid/', controller='openid', action='status')
        for cont in ['openid']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # linotpGetotp.active
    getotp = global_conf.get('linotpGetotp.active', 'True') == 'True'
    if getotp:
        for cont in ['gettoken']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # linotp.selfTest
    self_test = global_conf.get('linotp.selfTest', 'True') == 'True'
    if self_test:
        for cont in ['testing']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    return routeMap
コード例 #56
0
 def __init__(self, **config):
     self.config = config
     self.mapper = Mapper()
     self.registory = {}
     super(WSGIApplication, self).__init__()
コード例 #57
0
ファイル: routing.py プロジェクト: fuseki/ole
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'],
                 always_scan=config['debug'])
    map.minimization = False
    map.explicit = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE    
    map.connect("/areas/count", controller="areas", action="count")
    map.resource("area", "areas")
    
    map.connect("/lines/count", controller="lines", action="count")
    map.resource("line", "lines")
    
    map.connect("/points/count", controller="points", action="count")
    map.resource("point", "points")

    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')
    
    return map
コード例 #58
0
ファイル: routing.py プロジェクト: alkadis/vcv
def make_map(config):
    """Create, configure and return the routes Mapper"""
    map = Mapper(directory=config['pylons.paths']['controllers'])
    map.minimization = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved
    map.connect('/error/{action}', controller='error')
    map.connect('/error/{action}/{id}', controller='error')

    # CUSTOM ROUTES HERE
    map.connect('/', controller='root', action='index')
    map.connect('/index{.format}', controller='root', action='index')

    map.connect('/openid/{action}', controller='openidauth')
    map.connect('/twitter/{action}', controller='twitteroauth')

    map.connect('/oembed{.format}', controller='oembed', action='oembed',
                conditions=dict(method=['GET']))

    map.connect('/user/all', controller='user',
                action='all', conditions=dict(method=['GET']))
    map.connect('/user/{id}/badges{.format}', controller='user',
                action='edit_badges', conditions=dict(method=['GET']))
    map.connect('/user/{id}/badges{.format}', controller='user',
                action='update_badges', conditions=dict(method=['POST']))
    # Old dashboard
    map.connect('/user/{id}/dashboard', controller='user',
                action='legacy_dashboard')
    map.connect('/user/{id}/dashboard_proposals', controller='user',
                action='legacy_dashboard_proposals')
    map.connect('/user/{id}/dashboard_pages', controller='user',
                action='legacy_dashboard_pages')

    # New event stream dashboard
    map.connect('/user/dashboard', controller='user',
                action='dashboard')
    map.connect('/user/dashboard/contributions', controller='user',
                action='dashboard_contributions')
    map.connect('/user/dashboard/votes', controller='user',
                action='dashboard_votes')
    map.connect('/user/dashboard/delegations', controller='user',
                action='dashboard_delegations')
    map.connect('/user/dashboard/messages', controller='user',
                action='dashboard_messages')
    map.connect('/welcome/{id}/{token}', controller='user',
                action='welcome')

    # avatar
    map.connect('/user/{id}_{x}x{y}.png',
                controller='user', action='avatar')
    map.connect('/user/{id}_{y}.png',
                controller='user', action='avatar')

    map.resource('user', 'user', member={'votes': 'GET',
                                         'delegations': 'GET',
                                         'instances': 'GET',
                                         'about': 'GET',
                                         'latest_events': 'GET',
                                         'latest_contributions': 'GET',
                                         'latest_milestones': 'GET',
                                         'latest_votes': 'GET',
                                         'latest_delegations': 'GET',
                                         'watchlist': 'GET',
                                         'groupmod': 'GET',
                                         'ban': 'GET',
                                         'unban': 'GET',
                                         'ask_delete': 'GET',
                                         'revert': 'GET',
                                         'reset': 'GET',
                                         'activate': 'GET',
                                         'ask_activate': 'GET',
                                         'pending_activate': 'GET',
                                         'resend': 'GET',
                                         'set_password': '******',
                                         'generate_welcome_link': 'POST'},
                 collection={'complete': 'GET',
                             'filter': 'GET',
                             # provide user-independent URLs to user settings
                             'redirect_settings': 'GET',
                             'redirect_settings_login': '******',
                             'redirect_settings_notifications': 'GET',
                             'redirect_settings_advanced': 'GET',
                             'redirect_settings_optional': 'GET',
                             })

    # TODO work this into a complete subcontroller.
    map.connect('/user/{id}/message.{format}', controller='message',
                action='create',
                conditions=dict(method=['POST', 'PUT']))
    map.connect('/user/{id}/message', controller='message', action='create',
                conditions=dict(method=['POST', 'PUT']))
    map.connect('/user/{id}/message/new.{format}', controller='message',
                action='new',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/message/new', controller='message', action='new',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings{.format}',
                controller='user', action='settings_personal',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings{.format}',
                controller='user', action='settings_personal_update',
                conditions=dict(method=['PUT']))
    map.connect('/user/{id}/settings/login{.format}',
                controller='user', action='settings_login',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings/login{.format}',
                controller='user', action='settings_login_update',
                conditions=dict(method=['PUT']))
    map.connect('/user/{id}/settings/notifications{.format}',
                controller='user', action='settings_notifications',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings/notifications{.format}',
                controller='user', action='settings_notifications_update',
                conditions=dict(method=['PUT']))
    map.connect('/user/{id}/settings/advanced{.format}',
                controller='user', action='settings_advanced',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings/advanced{.format}',
                controller='user', action='settings_advanced_update',
                conditions=dict(method=['PUT']))
    map.connect('/user/{id}/settings/optional{.format}',
                controller='user', action='settings_optional',
                conditions=dict(method=['GET']))
    map.connect('/user/{id}/settings/optional{.format}',
                controller='user', action='settings_optional_update',
                conditions=dict(method=['PUT']))

    map.connect('/message/new', controller='massmessage', action='new')
    map.connect('/message/preview', controller='massmessage', action='preview')
    map.connect('/message/create', controller='massmessage', action='create')
    map.connect('/message/{id}', controller='message', action='show')

    map.connect('/register', controller='user', action='new')
    map.connect('/login', controller='user', action='login')
    map.connect('/logout', controller='user', action='logout')
    map.connect('/post_logout', controller='user', action='post_logout')
    map.connect('/post_login', controller='user', action='post_login')
    map.connect('/perform_login', controller='user', action='perform_login')
    map.connect('/reset', controller='user', action='reset_form',
                conditions=dict(method=['GET']))
    map.connect('/reset', controller='user', action='reset_request',
                conditions=dict(method=['POST']))

    # map.connect('/proposal/{id}/badges', controller='proposal',
    #             action='badges', conditions=dict(method=['GET']))
    # map.connect('/proposal/{id}/badges', controller='proposal',
    #             action='update_badges', conditions=dict(method=['POST']))

    map.resource('proposal', 'proposal', member={'delegations': 'GET',
                                                 'activity': 'GET',
                                                 'ask_delete': 'GET',
                                                 'ask_adopt': 'GET',
                                                 'adopt': 'POST',
                                                 'badges': 'GET',
                                                 'update_badges': 'POST',
                                                 'comments': 'GET',
                                                 'history': 'GET'},
                 collection={'filter': 'GET'})
    map.connect('/proposal/{proposal_id}/{selection_id}/details{.format}',
                controller='selection',
                action='details')

    map.connect('/proposal/{proposal_id}/message/new{.format}',
                controller='massmessage',
                action='new_proposal', conditions=dict(method=['GET']))
    map.connect('/proposal/{proposal_id}/message{.format}',
                controller='massmessage',
                action='create_proposal', conditions=dict(method=['POST']))

    map.resource('implementation', 'implementation', controller='selection',
                 member={'ask_delete': 'GET'},
                 collection={'include': 'GET',
                             'propose': 'GET'},
                 parent_resource=dict(member_name='proposal',
                                      collection_name='proposal'))

    map.connect('/page/{id}_{x}x{y}.png', controller='page',
                action='logo')
    map.connect('/page/{id}_{y}.png', controller='page',
                action='logo')

    map.connect('/page/diff', controller='page', action='diff',
                conditions=dict(method=['GET']))

    map.connect('/page/{id}/amendment{.format}',
                controller='page',
                action='show', amendment=True,
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{page}/amendment{.format}',
                controller='proposal',
                action='create', amendment=True,
                conditions=dict(method=['POST'])
                )
    map.connect('/page/{page}/amendment/new{.format}',
                controller='proposal',
                action='new', amendment=True,
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{id}/amendment/{variant}{.format}',
                controller='page',
                action='show', amendment=True,
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{page}/amendment/{id}{.format}',
                controller='proposal',
                action='update',
                conditions=dict(method=['PUT'])
                )
    map.connect('/page/{page}/amendment/{id}{.format}',
                controller='proposal',
                action='delete',
                conditions=dict(method=['DELETE'])
                )
    map.connect('/page/{page}/amendment/{id}/edit{.format}',
                controller='proposal',
                action='edit',
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{page}/amendment/{id}/ask_delete{.format}',
                controller='proposal',
                action='ask_delete',
                conditions=dict(method=['GET']),
                )

    map.connect('/page/{id}/{variant}/history{.format}',
                controller='page',
                action='history',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/history{.format}',
                controller='page',
                action='history',
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{id}/comments{.format}',
                controller='page',
                action='comments',
                conditions=dict(method=['GET']),
                )
    map.connect('/page/{id}/{variant}/branch',
                controller='page',
                action='edit',
                branch=True,
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant}/ask_purge',
                controller='page', action='ask_purge',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant}/purge',
                controller='page',
                action='purge',
                conditions=dict(method=['POST', 'DELETE']))
    map.connect('/page/{id};{text}/ask_purge_history',
                controller='page', action='ask_purge_history',
                conditions=dict(method=['GET']))
    map.connect('/page/{id};{text}/purge_history',
                controller='page',
                action='purge_history',
                conditions=dict(method=['POST', 'DELETE']))
    map.connect('/page/{id}/{variant}/edit.{format}',
                controller='page',
                action='edit',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant}/edit', controller='page', action='edit',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/edit.{format}', controller='page', action='edit',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/branch', controller='page', action='edit',
                branch=True,
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/edit', controller='page', action='edit',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/ask_delete{.format}', controller='page',
                action='ask_delete',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant};{text}.{format}', controller='page',
                action='show',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant};{text}/branch', controller='page',
                action='edit', branch=True,
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant};{text}', controller='page',
                action='show',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant}.{format}', controller='page',
                action='show',
                conditions=dict(method=['GET']))
    map.connect('/page/{id}/{variant}', controller='page', action='show',
                conditions=dict(method=['GET']))
    map.connect('/page/{id};{text}.{format}', controller='page', action='show',
                conditions=dict(method=['GET']))
    map.connect('/page/{id};{text}/branch', controller='page', action='edit',
                branch=True,
                conditions=dict(method=['GET']))
    map.connect('/page/{id};{text}', controller='page', action='show',
                conditions=dict(method=['GET']))

    map.resource('page', 'page', member={'ask_delete': 'GET'})

    # map.connect('/adopted', controller='proposal', action='adopted')

    map.resource('comment', 'comment', member={'history': 'GET',
                                               'revert': 'GET',
                                               'purge_history': 'GET',
                                               'ask_delete': 'GET'})

    map.connect('/comment/form/edit/{id}', controller='comment',
                action='edit_form')
    map.connect('/comment/form/create/{topic}', controller='comment',
                action='create_form', variant=None)
    map.connect('/comment/form/reply/{id}', controller='comment',
                action='reply_form')

    map.resource('milestone', 'milestone', member={'ask_delete': 'GET'})

    map.connect('/poll/{id}/rate{.format}', controller='poll', action='rate',
                conditions=dict(method=['GET', 'POST']))

    map.connect('/poll/{id}/widget{.format}', controller='poll',
                action='widget', conditions=dict(method=['GET', 'POST']))

    map.connect('/poll/{id}/vote{.format}', controller='poll', action='vote',
                conditions=dict(method=['GET', 'POST']))

    map.resource('poll', 'poll', member={'votes': 'GET',
                                         'ask_delete': 'GET',
                                         'widget': 'GET'})

    map.connect('/badge{.format}', controller='badge', action='index',
                conditions=dict(method=['GET']))
    map.connect('/badge/{badge_type}{.format}', controller='badge',
                action='index_type', conditions=dict(method=['GET']))
    map.connect('/badge/{badge_type}/add{.format}', controller='badge',
                action='add', conditions=dict(method=['GET']))
    map.connect('/badge/{badge_type}/add{.format}', controller='badge',
                action='create', conditions=dict(method=['POST']))
    map.connect('/badge/edit/{id}{.format}', controller='badge',
                action="edit", conditions=dict(method=['GET']))
    map.connect('/badge/edit/{id}{.format}',
                controller='badge', action="update",
                conditions=dict(method=['POST']))
    map.connect('/badge/delete/{id}{.format}',
                controller='badge', action="ask_delete",
                conditions=dict(method=['GET']))
    map.connect('/badge/delete/{id}{.format}',
                controller='badge', action="delete",
                conditions=dict(method=['POST']))

    # category image
    map.connect('/category/{id}_{x}x{y}.png', controller='category',
                action='image')
    map.connect('/category/{id}_{y}.png', controller='category',
                action='image')

    map.connect('/category{.format}', controller='category', action='index',
                conditions=dict(method=['GET']))
    map.connect('/category/{id}{.format}', controller='category',
                action='show', conditions=dict(method=['GET']))
    map.connect('/category/{id}/description{.format}', controller='category',
                action='description', conditions=dict(method=['GET']))
    map.connect('/category/{id}/events{.format}', controller='category',
                action='events', conditions=dict(method=['GET']))
    map.connect('/category/{id}/milestones{.format}', controller='category',
                action='milestones', conditions=dict(method=['GET']))

    # not using REST since tags may contain dots, thus failing format
    # detection.
    map.connect('/tag', controller='tag', action='index',
                conditions=dict(method=['GET']))
    map.connect('/tag', controller='tag', action='create',
                conditions=dict(method=['POST']))
    map.connect('/tag/autocomplete', controller='tag', action='autocomplete')
    map.connect('/untag', controller='tag', action='untag')
    map.connect('/untag_all', controller='tag', action='untag_all')
    map.connect('/tag/{id}', controller='tag', action='show')

    map.resource('delegation', 'delegation')
    # map.resource('delegations', 'delegation')

    map.connect('/d/{id}', controller='root', action='dispatch_delegateable')
    map.connect('/sitemap.xml', controller='root', action='sitemap_xml')
    map.connect('/robots.txt', controller='root', action='robots_txt')
    map.connect('/feed.rss', controller='root', action='index', format='rss')
    map.connect('/tutorials', controller='root', action='tutorials')

    map.connect('/search/filter', controller='search', action='filter')
    map.connect('/search{.format}', controller='search', action='query')

    map.connect('/abuse/report', controller='abuse', action='report')
    map.connect('/abuse/new', controller='abuse', action='new')

    map.connect('/instance/{id}_{x}x{y}.png',
                controller='instance', action='icon')
    map.connect('/instance/{id}_{y}.png',
                controller='instance', action='icon')
    map.connect('/instance/{id}/settings{.format}',
                controller='instance', action='settings_legacy',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/overview{.format}',
                controller='instance', action='settings_overview',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/overview{.format}',
                controller='instance', action='settings_overview_update',
                conditions=dict(method=['PUT']))
    map.connect('/instance/{id}/settings/general{.format}',
                controller='instance', action='settings_general',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/general{.format}',
                controller='instance', action='settings_general_update',
                conditions=dict(method=['PUT']))
    map.connect('/instance/{id}/settings/process{.format}',
                controller='instance', action='settings_process',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/process{.format}',
                controller='instance', action='settings_process_update',
                conditions=dict(method=['PUT']))
    map.connect('/instance/{id}/settings/members{.format}',
                controller='instance', action='settings_members',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/members{.format}',
                controller='instance', action='settings_members_update',
                conditions=dict(method=['PUT']))
    map.connect('/instance/{id}/settings/advanced{.format}',
                controller='instance', action='settings_advanced',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/advanced{.format}',
                controller='instance', action='settings_advanced_update',
                conditions=dict(method=['PUT']))
    map.connect('/instance/{id}/settings/{part}/{badge_type}/add{.format}',
                controller='instance',
                action='settings_badges_add', conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/{part}/{badge_type}/add{.format}',
                controller='instance',
                action='settings_badges_create',
                conditions=dict(method=['POST']))
    map.connect('/instance/{id}/settings/{part}/edit/{badge_id}{.format}',
                controller='instance',
                action="settings_badges_edit", conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/{part}/edit/{badge_id}{.format}',
                controller='instance', action="settings_badges_update",
                conditions=dict(method=['POST']))
    map.connect('/instance/{id}/settings/{part}/delete/{badge_id}{.format}',
                controller='instance', action="settings_badges_ask_delete",
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/{part}/delete/{badge_id}{.format}',
                controller='instance', action="settings_badges_delete",
                conditions=dict(method=['POST']))
    map.connect('/instance/{id}/message/new{.format}',
                controller='massmessage', action='new',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/message{.format}',
                controller='massmessage', action='create',
                conditions=dict(method=['POST']))
    map.connect('/instance/{id}/message/preview{.format}',
                controller='massmessage', action='preview',
                conditions=dict(method=['POST']))
    map.connect('/instance/{id}/members_import{.format}',
                controller='instance', action='members_import',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/members_import{.format}',
                controller='instance', action='members_import_save',
                conditions=dict(method=['PUT', 'POST']))
    map.connect('/instance/{id}/settings/presets{.format}',
                controller='instance', action='settings_presets',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/settings/presets{.format}',
                controller='instance', action='settings_presets_update',
                conditions=dict(method=['PUT', 'POST']))
    map.connect('/instance/{id}/presets{.format}',
                controller='instance', action='presets',
                conditions=dict(method=['GET']))
    map.connect('/instance/{id}/presets{.format}',
                controller='instance', action='presets_update',
                conditions=dict(method=['POST']))

    map.resource('instance', 'instance', member={'join': 'GET',
                                                 'ask_join': 'GET',
                                                 'leave': 'POST',
                                                 'filter': 'GET',
                                                 'ask_leave': 'GET',
                                                 'ask_delete': 'GET',
                                                 'style': 'GET',
                                                 'badges': 'GET',
                                                 'update_badges': 'POST',
                                                 'activity': 'GET'})

    map.connect('/stats/', controller='stats')

    map.connect('/admin', controller='admin', action="index")
    map.connect('/admin/users/import{.format}', controller='admin',
                action="user_import", conditions=dict(method=['POST']))
    map.connect('/admin/users/import{.format}', controller='admin',
                action="user_import_form", conditions=dict(method=['GET']))
    map.connect('/admin/export',
                controller='admin', action='export_dialog')
    map.connect('/admin/export/do',
                controller='admin', action='export_do')
    map.connect('/admin/import{.format}',
                controller='admin', action='import_dialog')
    map.connect('/admin/import/do',
                controller='admin', action='import_do')
    map.connect('/admin/treatment/',
                controller='treatment', action='index',
                conditions={'method': 'GET'},)
    map.connect('/admin/treatment/',
                controller='treatment', action='create',
                conditions={'method': 'POST'},)
    map.connect('/admin/treatment/{key}/assign',
                controller='treatment', action='assign',
                conditions={'method': 'POST'},)
    map.connect('/admin/treatment/{key}/assigned',
                controller='treatment', action='assigned')

    map.connect('/static{.format}', controller='static', action='index',
                conditions=dict(method=['GET', 'HEAD']))
    map.connect('/static{.format}', controller='static', action='make_new',
                conditions=dict(method=['POST']))
    map.connect('/static/new{.format}', controller='static', action='new')
    map.connect('/static/edit/{lang}/*key',
                controller='static', action='edit',
                conditions=dict(method=['GET', 'HEAD']))
    map.connect('/static/edit/{lang}/*(key){.format}',
                controller='static', action='update',
                conditions=dict(method=['POST']))
    map.connect('/static/*(key){.format}', controller='static',
                action='serve')
    map.connect('/outgoing_link/{url_enc}', controller='redirect',
                action='outgoing_link',
                conditions=dict(method=['GET', 'HEAD']))

    map.connect('/event/all{.format}', controller='event', action='all')
    map.connect('/event/carousel{.format}', controller='event',
                action='carousel')

    map.connect('/{controller}/{action}')
    map.connect('/{controller}/{action}/{id}')

    return map
class WebMapper(object):
    """
    Loads the AST, link routes and run the post- and pre-conditions
    """
    def __init__(self, dsl):
        sys.path.insert(0, os.getcwd())  # why ?
        self.mapper = Mapper()
        self.globs = dsl.globs
        self.types = dsl.types
        self.context = dsl.context
        self._hooks = {}
        self.options = {}
        self.root = dsl.root
        self.root_path = dsl.root_path

    def add(self, name, args):
        if name in self._hooks:
            raise NameError('%r already defined.' % name)

        params = {}
        for arg in args:
            if arg.type == 'assign':
                left = arg.left
                right = arg.right
                if isinstance(left, basestring):    # XXX meh
                    params[left] = right
                else:
                    name_ = left.value
                    if isinstance(right, list):
                        params[name_] = arg.right
                    else:
                        params[name_] = arg.right.value
            else:
                raise NotImplementedError(arg)

        use = params.get('use', 'redbarrel.util.dummy')

        if 'url' in params:
            url = params.get('url', '/')
            if self.root_path:
                if url != '/':
                    url = self.root_path + url
                else:
                    url = self.root_path

            try:
                function = resolve_runner(use, self.root, url)
            except ImportError:
                # let's try in the context
                # # XXX ugly, need isolation
                function = None

                for lib in self.context.libraries:
                    for callable in lib.dir():
                        name_ = '%s.%s' % (lib.name, callable)
                        if name_ == use:
                            function = lib.namespace[callable]
                            break

                if function is None:
                    logger.info(" => Error on %r" % name)
                    raise

            params['func'] = function

            conditions = {}
            oldname = name
            params['name'] = name


            if 'method' in params:
                conditions['method'] = [str(method)
                            for method in params['method']]
                self.mapper.connect(None, url, action=name,
                                    conditions=conditions)

            self._hooks[name] = WebHook(params, self.types)
            logger.info(" => %r hooked for %r" % (oldname, url))

        else:
            logger.info(" => %r incomplete, ignoring" % name)

    def set_options(self, options):
        for option in options:
            if option.type == 'assign':
                left = option.left
                right = option.right

                if isinstance(left, basestring):    # XXX meh
                    self.options[left] = right
                else:
                    self.options[left.value] = right.value
            else:
                raise NotImplementedError(option)

    def __call__(self, request):
        # finding a match
        match = self.mapper.routematch(environ=request.environ)
        if match is None:
            return HTTPNotFound()
        match, __ = match
        hook = self._hooks.get(match['action'])

        if hook is None:
            raise HTTPNotFound('Unknown URL %r' % request.path_info)

        hook.preconditions(request, self.globs)

        function = hook['func']

        # the GET mapping is filled on GET and DELETE requests
        if request.method in ('GET', 'DELETE'):
            params = dict(request.GET)
        else:
            params = {}

        request.match = match

        try:
            result = function(self.globs, request, **params)
        except BackendError:
            err = traceback.format_exc()
            logger.error(err)
            raise HTTPServiceUnavailable(retry_after=self.retry_after)

        if isinstance(result, basestring):
            response = getattr(request, 'response', None)
            if response is None:
                response = Response(result)
            elif isinstance(result, str):
                response.body = result
            else:
                # if it's not str it's unicode, which really shouldn't happen
                response.body = result.encode('utf-8')
        else:
            # result is already a Response
            response = result

        hook.postconditions(response, request, self.globs)
        return response
コード例 #60
0
ファイル: routing.py プロジェクト: yueguangguang/LinOTP
def make_map(global_conf, app_conf,):
    """
    Create, configure and return the routes Mapper
    There are the three main controllers:
        /admin
        /validate
        /system
    """
    routeMap = Mapper(directory=config['pylons.paths']['controllers'],
                      always_scan=config['debug'])
    routeMap.minimization = False

    # The ErrorController route (handles 404/500 error pages); it should
    # likely stay at the top, ensuring it can always be resolved

    routeMap.connect('/error/{action}', controller='error')
    routeMap.connect('/error/{action}/{id}', controller='error')

    # check if we are in migration mode -
    # ! this will disable all other controllers !
    migrate = app_conf.get('service.migrate', 'False') == 'True'

    if migrate:
        for cont in ['migrate']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

        return routeMap

    # the first / - default will be taken!!
    # in case of selfservice, we route the default / to selfservice
    selfservice = app_conf.get('service.selfservice', 'True') == 'True'
    if selfservice:
        routeMap.connect(
            '/selfservice/custom-style.css', controller='selfservice', action='custom_style')
        routeMap.connect('/selfservice', controller='selfservice', action='index')
        routeMap.connect('/', controller='selfservice', action='index')
        for cont in ['selfservice', 'account']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of support for a remote selfservice, we have to enable this hook
    userservice = app_conf.get('service.userservice', 'True') == 'True'
    if userservice:
        routeMap.connect('/userservice', controller='userservice', action='index')
        for cont in ['userservice']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of support for monitoring, we have to enable this hook
    monitoring = app_conf.get('service.monitoring', 'True') == 'True'
    if monitoring:
        routeMap.connect('/monitoring', controller='monitoring', action='config')
        for cont in ['monitoring']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of support for reporting, we have to enable this hook
    reporting = app_conf.get('service.reporting', 'True') == 'True'
    if reporting:
        routeMap.connect('/reporting', controller='reporting')
        for cont in ['reporting']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of manage, we route the default / to manage
    manage = app_conf.get('service.manage', 'True') == 'True'
    if manage:
        routeMap.connect('/manage/custom-style.css', controller='manage', action='custom_style')
        routeMap.connect('/admin', controller='admin', action='show')
        routeMap.connect('/system', controller='system', action='getConfig')
        routeMap.connect('/manage/', controller='manage', action='index')
        routeMap.connect('/', controller='manage', action='index')

        for cont in ['admin', 'system', 'manage', 'audit', 'auth']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of validate, we route the default / to validate
    validate = app_conf.get('service.validate', 'True') == 'True'
    if validate:
        routeMap.connect('/validate', controller='validate', action='check')
        routeMap.connect('/', controller='validate', action='check')
        for cont in ['validate']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # ocra
    ocra = app_conf.get('service.ocra', 'True') == 'True'
    if ocra:
        routeMap.connect('/ocra', controller='ocra', action='checkstatus')
        for cont in ['ocra']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    openid = app_conf.get('service.openid', 'True') == 'True'
    if openid:
        # the default openid will be the status
        routeMap.connect('/openid/', controller='openid', action='status')
        for cont in ['openid']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # controller to get otp values
    # fallback for the getotp is the global linotpGetopt, but as all services
    # are in the app section, the app section one should be prefered
    getotp = (app_conf.get('service.getotp',
                           global_conf.get('linotpGetotp.active', 'False'))
              == 'True')
    if getotp:
        for cont in ['gettoken']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # in case of u2f, we allow routes of type /u2f/realm/action
    u2f = app_conf.get('service.u2f', 'True') == 'True'
    if u2f:
        for cont in ['u2f']:
            routeMap.connect('/%s/{realm}/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}' % cont, controller=cont)

    # testing - for test setup: http sms provider callback
    self_test = app_conf.get('service.testing', 'False') == 'True'
    if self_test:
        for cont in ['testing']:
            routeMap.connect('/%s/{action}' % cont, controller=cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # linotp tools
    tools = global_conf.get('linotp.tools', 'True') == 'True'
    if tools:
        for cont in ['tools']:
            routeMap.connect('/%s/{action}' % cont, controller = cont)
            routeMap.connect('/%s/{action}/{id}' % cont, controller=cont)

    # check if the maintenance controller is activated
    maintenance = app_conf.get('service.maintenance', 'False') == 'True'
    if maintenance:
        routeMap.connect('/maintenance/{action}', controller='maintenance')

    return routeMap