def add_interface_ngeo(
config: pyramid.config.Configurator,
route_name: str,
route: str,
renderer: str = None,
permission: str = None,
) -> None:
config.add_route(route_name, route, request_method="GET")
config.add_view(Entry,
attr="get_ngeo_index_vars",
route_name=route_name,
renderer=renderer,
permission=permission)
# Permalink theme: recover the theme for generating custom viewer.js url
config.add_route(
"{}theme".format(route_name),
"{}{}theme/{{themes}}".format(route, "" if route[-1] == "/" else "/"),
request_method="GET",
)
config.add_view(
Entry,
attr="get_ngeo_index_vars",
route_name="{}theme".format(route_name),
renderer=renderer,
permission=permission,
)
def add_interface_ngeo(
config: pyramid.config.Configurator,
route_name: str,
route: str,
renderer: Optional[str] = None,
permission: Optional[str] = None,
) -> None:
"""Add the ngeo interfaces views and routes."""
config.add_route(route_name, route, request_method="GET")
# Permalink theme: recover the theme for generating custom viewer.js url
config.add_route(
f"{route_name}theme",
f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
request_method="GET",
)
config.add_view(Entry,
attr="get_ngeo_index_vars",
route_name=route_name,
renderer=renderer,
permission=permission)
config.add_view(
Entry,
attr="get_ngeo_index_vars",
route_name=f"{route_name}theme",
renderer=renderer,
permission=permission,
)
def init(config: pyramid.config.Configurator) -> None:
base_path = _utils.get_base_path(config)
if base_path != '':
config.add_route("c2c_index", base_path, request_method=("GET", "POST"))
config.add_view(_index, route_name="c2c_index", http_cache=0)
config.add_route("c2c_index_slash", base_path + "/", request_method=("GET", "POST"))
config.add_view(_index, route_name="c2c_index_slash", http_cache=0)
def add_interface_canvas(
config: pyramid.config.Configurator,
route_name: str,
route: str,
interface_config: Dict[str, Any],
permission: Optional[str] = None,
) -> None:
"""Add the ngeo interfaces views and routes."""
renderer = f"/etc/geomapfish/interfaces/{route_name}.html.mako"
config.add_route(route_name, route, request_method="GET")
# Permalink theme: recover the theme for generating custom viewer.js URL
config.add_route(
f"{route_name}theme",
f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
request_method="GET",
)
view = partial(canvas_view, interface_config=interface_config)
view.__module__ = canvas_view.__module__
config.add_view(
view,
route_name=route_name,
renderer=renderer,
permission=permission,
)
config.add_view(
view,
route_name=f"{route_name}theme",
renderer=renderer,
permission=permission,
)
def init(config: pyramid.config.Configurator) -> None:
if os.path.isfile(VERSIONS_PATH):
versions = _read_versions()
config.add_route("c2c_versions",
_utils.get_base_path(config) + r"/versions.json",
request_method="GET")
config.add_view(lambda request: versions,
route_name="c2c_versions",
renderer="fast_json",
http_cache=0)
LOG.info("Installed the /versions.json service")
git_hash = versions['main']['git_hash']
if 'git_tag' in versions['main']:
LOG.warning("Starting version %s (%s)",
versions['main']['git_tag'], git_hash)
else:
LOG.warning("Starting version %s", git_hash)
if stats.USE_TAGS:
stats.increment_counter(['version'],
1,
tags=dict(version=git_hash))
else:
stats.increment_counter(['version', git_hash], 1)
def add_redirect(config: pyramid.config.Configurator, name: str, from_: str,
to: str) -> None:
def redirect_view(request: pyramid.request.Request) -> HTTPFound:
return HTTPFound(location=request.route_url(to))
config.add_route(name, from_, request_method="GET")
config.add_view(redirect_view, route_name=name)
def add_cors_route(config: pyramid.config.Configurator, pattern: str,
service: str) -> None:
"""Add the OPTIONS route and view need for services supporting CORS."""
def view(request: pyramid.request.Request) -> pyramid.response.Response:
return set_common_headers(request, service, Cache.PRIVATE_NO)
name = pattern + "_options"
config.add_route(name, pattern, request_method="OPTIONS")
config.add_view(view, route_name=name)
def _add_view(config: pyramid.config.Configurator, name: str, path: str,
view: Callable[[pyramid.request.Request], Any]) -> None:
config.add_route("c2c_debug_" + name,
config_utils.get_base_path(config) + r"/debug/" + path,
request_method="GET")
config.add_view(view,
route_name="c2c_debug_" + name,
renderer="fast_json",
http_cache=0)
def init(config: pyramid.config.Configurator) -> None:
config.add_route("c2c_read_stats_json",
_utils.get_base_path(config) + r"/stats.json",
request_method="GET")
memory_backend = cast(stats.MemoryBackend, stats.BACKENDS['memory'])
config.add_view(memory_backend.get_stats,
route_name="c2c_read_stats_json",
renderer="fast_json",
http_cache=0)
def _static(config: pyramid.config.Configurator):
config.add_route(name='index', path='/*subpath')
config.add_view(
request_method='GET',
route_name='index',
view=pyramid.static.static_view(
root_dir='megadloader:static/',
package_name='megadloader:static',
),
)
def _make_application(*, geoip, socket):
"""Construct a Pyramid WSGI application.
This creates a central Pyramid configurator then adds all routes, views
and Jinja2 configuration to it.
:mod:`pyramid_jinja2` is included into the configuration. The search path
for Jinja2 is set to the ``templates/`` directory. The Jinja2 syntax is
modified so that it uses square brackets instead of curly ones. E.g.
``{{foo}}`` becomes ``[[foo]]``. This applies to Jinja2 statements as
well as comments.
A route and view is added for ``/`` which serves the Angular application.
A default 'not found' view is also added which also serves the Angular
application. This is so that the Angular ``$location`` service can use
*HTML5 mode* routing. Because of this there is no guarantee that a matched
route will be set for the current request inside the entry point template.
E.g. you can't use ``request.current_route_url``.
Static views are added for the ``external``, ``scripts``, ``styles``,
``images``, ``templates`` and ``data`` directories. These are all served
directly from the route. E.g. templates are served from ``/templates/``.
The configuration for Steam OpenID authentication and the location
service is added.
:param pathlib.Path geoip: the path to the GeoIP database to use for
the location service.
:param str socket: the websocket URL the UI should connect to.
:return: a WSGI application.
"""
config = pyramid.config.Configurator(settings={
"pyramid.reload_templates": True,
})
config.include("pyramid_jinja2")
config.add_jinja2_search_path(__name__ + ":templates/")
config.add_route("main", "/")
config.add_view(route_name="main", renderer="main.jinja2")
config.add_notfound_view(_404, renderer="main.jinja2")
for static in ["external", "scripts",
"styles", "images", "templates", "data"]:
config.add_static_view(static, "{}:{}/".format(__name__, static))
_configure_authentication(config)
_configure_location(config, geoip)
config.commit()
jinja2_env = config.get_jinja2_environment()
jinja2_env.block_start_string = "[%"
jinja2_env.block_end_string = "%]"
jinja2_env.variable_start_string = "[["
jinja2_env.variable_end_string = "]]"
jinja2_env.comment_start_string = "[#"
jinja2_env.comment_end_string = "#]"
jinja2_env.globals["socket"] = socket
return config.make_wsgi_app()
def includeme(config: pyramid.config.Configurator) -> None:
for pattern, view, request_method in [
('/api/sign_in', api.sign_in, 'POST'),
('/api/sign_up', api.sign_up, 'POST'),
]:
config.add_route(pattern, pattern, request_method=request_method)
config.add_view(view,
route_name=pattern,
request_method=request_method)
config.add_view(api.error, context=Exception)
def add_admin_interface(config: pyramid.config.Configurator) -> None:
if config.get_settings().get("enable_admin_interface", False):
config.add_request_method(
lambda request: c2cgeoportal_commons.models.DBSession(),
"dbsession",
reify=True,
)
config.add_view(c2cgeoportal_geoportal.views.add_ending_slash,
route_name="admin_add_ending_slash")
config.add_route("admin_add_ending_slash",
"/admin",
request_method="GET")
config.include("c2cgeoportal_admin")
def add_getitfixed(config: pyramid.config.Configurator) -> None:
if config.get_settings()["getitfixed"].get("enabled", False):
for route_name, pattern in (
("getitfixed_add_ending_slash", "/getitfixed"),
("getitfixed_admin_add_ending_slash", "/getitfixed_admin"),
):
config.add_view(c2cgeoportal_geoportal.views.add_ending_slash,
route_name=route_name)
config.add_route(route_name, pattern, request_method="GET")
config.include("getitfixed")
# Register admin and getitfixed search paths together
Form.set_zpt_renderer(c2cgeoform.default_search_paths,
translator=translator)
def _configure_location(config, geoip):
"""Configure the location server.
This adds the ``service-location`` route and corresponding view to the
given configurator. A reified request method ``geoip`` is added which
returns a database reader for the given GeoIP database.
:param pathlib.Path geoip: the path to the GeoIP database to use for
the location service.
"""
config.add_request_method(
lambda r: geoip2.database.Reader(str(geoip)), "geoip", reify=True)
config.add_route("service-location", "/services/location")
config.add_view(_location, route_name="service-location", renderer="json")
def __init__(self, config: pyramid.config.Configurator) -> None:
config.add_route("c2c_health_check",
_utils.get_base_path(config) + r"/health_check",
request_method="GET")
config.add_view(self._view,
route_name="c2c_health_check",
renderer="fast_json",
http_cache=0)
self._checks: List[Tuple[str, Callable[[pyramid.request.Request], Any],
int]] = []
redis_url = _utils.env_or_config(config, broadcast.REDIS_ENV_KEY,
broadcast.REDIS_CONFIG_KEY)
if redis_url is not None:
self.add_redis_check(redis_url, level=2)
if version.get_version() is not None:
self.add_version_check(level=2)
def test_deprecated_ranges_in_route_predicate(self):
config = self._makeConfig()
config.add_route('foo', '/foo', accept='text/*')
config.add_view(lambda r: 'OK', route_name='foo', renderer='string')
app = self._makeTestApp(config)
res = app.get(
'/foo',
headers={'Accept': 'application/json; q=1.0, text/plain; q=0.9'},
status=200,
)
self.assertEqual(res.content_type, 'text/plain')
self.assertEqual(res.body, b'OK')
res = app.get('/foo',
headers={'Accept': 'application/json'},
status=404)
self.assertEqual(res.content_type, 'application/json')
def on_class_load(cls, config: pyramid.config.Configurator):
super(cls, cls).on_class_load(config)
# config.add_route('test_payment_form', cls.route_payment_form)
config.add_route('yandex_money_result_redirect',
cls.route_result_redirect)
settings = config.registry.settings
# ViewsPaymentTestServer.notify_url = settings.get(ViewsPaymentTestServer.__name__+'.notify_url')
# config.add_view(
# ViewsPaymentTestServer,
# attr='view_payment_form',
# route_name='test_payment_form',
# renderer='payment_systems/test_payment_form.jinja2'
# )
config.add_view(ViewsPaymentClientYandexMoney,
attr='view_result_redirect',
route_name='test_payment_notify',
renderer='string')
def __init__(self, config: pyramid.config.Configurator) -> None:
config.add_route(
"c2c_health_check", config_utils.get_base_path(config) + r"/health_check", request_method="GET"
)
config.add_view(self._view, route_name="c2c_health_check", renderer="fast_json", http_cache=0)
self._checks: List[Tuple[str, Callable[[pyramid.request.Request], Any], int]] = []
self.name = config_utils.env_or_config(
config,
redis_utils.REDIS_SENTINELS_KEY,
redis_utils.REDIS_SENTINELS_KEY_PROP,
config_utils.env_or_config(config, redis_utils.REDIS_URL_KEY, redis_utils.REDIS_URL_KEY_PROP),
)
if self.name:
self.add_redis_check(level=2)
if version.get_version() is not None:
self.add_version_check(level=2)
def on_class_load(cls, config: pyramid.config.Configurator):
super(cls, cls).on_class_load(config)
config.add_route('test_payment_form', cls.route_payment_form)
config.add_route('test_payment_notify', cls.route_payment_notify)
settings = config.registry.settings
ViewsPaymentTestServer.notify_url = settings.get(ViewsPaymentTestServer.__name__+'.notify_url')
config.add_view(
ViewsPaymentTestServer,
attr='view_payment_form',
route_name='test_payment_form',
renderer='payment_systems/test_payment_form.jinja2'
)
config.add_view(
ViewsPaymentTestClient,
attr='view_payment_client_notify',
route_name='test_payment_notify',
renderer='string'
)
def includeme(config: pyramid.config.Configurator) -> None:
"""Initialize the index page."""
base_path = config_utils.get_base_path(config)
if base_path != "":
config.add_route("c2c_index",
base_path,
request_method=("GET", "POST"))
config.add_view(_index, route_name="c2c_index", http_cache=0)
config.add_route("c2c_index_slash",
base_path + "/",
request_method=("GET", "POST"))
config.add_view(_index, route_name="c2c_index_slash", http_cache=0)
settings = config.get_settings()
auth_type_ = auth_type(settings)
if auth_type_ == AuthenticationType.SECRET:
LOG.warning(
"It is recommended to use OAuth2 with GitHub login instead of the `C2C_SECRET` because it "
"protects from brute force attacks and the access grant is personal and can be revoked."
)
if auth_type_ == AuthenticationType.GITHUB:
config.add_route("c2c_github_login",
base_path + "/github-login",
request_method=("GET", ))
config.add_view(_github_login,
route_name="c2c_github_login",
http_cache=0)
config.add_route("c2c_github_callback",
base_path + "/github-callback",
request_method=("GET", ))
config.add_view(_github_login_callback,
route_name="c2c_github_callback",
http_cache=0,
renderer="fast_json")
config.add_route("c2c_github_logout",
base_path + "/github-logout",
request_method=("GET", ))
config.add_view(_github_logout,
route_name="c2c_github_logout",
http_cache=0)
def _configure_authentication(config):
"""Configure authentication policies, routes and view.
This adds a authentication and authorisation policy to the given
configurator. In addition to this it adds a reified request method
called ``openid_consumer`` -- see :func:`_get_openid_consumer`.
For authentication two routes are added: ``authenticate-begin`` and
``authentication-complete``. These routes are bound to the views
:func:`_begin_authentication` and :func:`_complete_authentication`
respectively.
The authentication completion view will have it's renderer set to the
``authentication-complete.jinja2`` Jinja template.
Authentication it self is done through Steam's OpenID provision. The
two views added by this function implement the OpenID flow.
An additional route ``service-profile`` and corresponding view is added
that returns a JSON object that identifies the current user.
"""
# TODO: DO NOT use this factory in production!
config.set_session_factory(
pyramid.session.SignedCookieSessionFactory("coffeedenshul"))
authn_policy = pyramid.authentication.AuthTktAuthenticationPolicy(
"coffeedenshul",
hashalg="sha512",
)
authz_policy = pyramid.authorization.ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(
_get_openid_consumer,
"openid_consumer",
reify=True,
)
config.add_route("authenticate-begin", "/authenticate/begin")
config.add_route("authenticate-complete", "/authenticate/complete")
config.add_view(_begin_authentication, route_name="authenticate-begin")
config.add_view(
_complete_authentication,
route_name="authenticate-complete",
renderer="authentication-complete.jinja2",
)
config.add_route("service-profile", "/services/profile")
config.add_view(_profile, route_name="service-profile", renderer="json")
def main():
with pyramid.config.Configurator() as config:
config.add_route("hello", "/")
config.add_view(handle_edit_request, route_name="hello")
app = config.make_wsgi_app()
return app
import pyramid.config
import pyramid.response
from config import PING_MESSAGE
# noinspection PyUnusedLocal
def ping(request):
return pyramid.response.Response(PING_MESSAGE.format(app='pyramid'))
with pyramid.config.Configurator() as config:
config.add_route('ping', '/')
config.add_view(ping, route_name='ping')
app = config.make_wsgi_app()
#Use pymongo
from pymongo import MongoClient
from mongokit import Document, Connection
from bson import json_util
from pyramid.renderers import JSON
if __name__ == '__main__':
my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet')
config = Configurator(session_factory = my_session_factory)
config.include('pyramid_debugtoolbar')
config.add_settings({'mako.directories':'templates/'})
config.add_static_view(name='static', path='static')
config.add_route('home', '/')
config.add_route('about', '/about')
config.add_view(home, route_name='home')
mgconnection = MongoClient()
db = mgconnection.test
# Clear database
db.drop_collection('users')
db.drop_collection('groups')
connection = Connection()
connection.register([User,Group,SuperGroup])
group = connection.Group()
group["name"] = "sampleGroup"
group["creation_date"] = datetime.utcnow()
group.save()
def _api(config: pyramid.config.Configurator):
config.add_route('api: status', '/api/status')
config.add_view(
request_method='GET',
route_name='api: status',
view=handle_status,
renderer='json',
)
config.add_route('api: categories', '/api/categories/')
config.add_view(
request_method='GET',
route_name='api: categories',
view=handle_list_categories,
renderer='json',
)
config.add_view(
request_method='POST',
route_name='api: categories',
view=handle_create_category,
renderer='json',
)
config.add_route('api: urls', '/api/urls/')
config.add_view(
request_method='GET',
route_name='api: urls',
view=handle_get_urls,
renderer='json',
)
config.add_view(
request_method='POST',
route_name='api: urls',
view=handle_add_url,
renderer='json',
)
config.add_route('api: queue items', '/api/queue/{queue_id}')
config.add_view(
request_method='DELETE',
route_name='api: queue items',
view=handle_delete_url,
renderer='json',
)
config.add_route('api: files', '/api/files/')
config.add_view(
request_method='GET',
route_name='api: files',
view=handle_list_files,
renderer='json',
)
config.add_route('api: file', '/api/files/{file_id}')
config.add_view(
request_method='GET',
route_name='api: file',
view=handle_get_file,
renderer='json',
)
def add_static_route(name: str, attr: str, path: str,
renderer: str) -> None:
config.add_route(name, path, request_method="GET")
config.add_view(Entry, attr=attr, route_name=name, renderer=renderer)
def includeme(config: pyramid.config.Configurator) -> None:
"""
This function returns a Pyramid WSGI application.
"""
settings = config.get_settings()
config.include("c2cgeoportal_commons")
if "available_locale_names" not in settings:
settings["available_locale_names"] = available_locale_names()
call_hook(settings, "after_settings", settings)
get_user_from_request = create_get_user_from_request(settings)
config.add_request_method(get_user_from_request,
name="user",
property=True)
config.add_request_method(get_user_from_request, name="get_user")
# Configure 'locale' dir as the translation dir for c2cgeoportal app
config.add_translation_dirs("c2cgeoportal_geoportal:locale/")
config.include("c2cwsgiutils.pyramid.includeme")
health_check = HealthCheck(config)
config.registry["health_check"] = health_check
metrics_config = config.registry.settings["metrics"]
if metrics_config["memory_maps_rss"]:
add_provider(MemoryMapProvider("rss"))
if metrics_config["memory_maps_size"]:
add_provider(MemoryMapProvider("size"))
if metrics_config["memory_cache"]:
add_provider(
MemoryCacheSizeProvider(
metrics_config.get("memory_cache_all", False)))
if metrics_config["raster_data"]:
add_provider(RasterDataSizeProvider())
if metrics_config["total_python_object_memory"]:
add_provider(TotalPythonObjectMemoryProvider())
# Initialise DBSessions
init_dbsessions(settings, config, health_check)
checker.init(config, health_check)
check_collector.init(config, health_check)
# dogpile.cache configuration
if "cache" in settings:
register_backend("c2cgeoportal.hybrid",
"c2cgeoportal_geoportal.lib.caching",
"HybridRedisBackend")
register_backend("c2cgeoportal.hybridsentinel",
"c2cgeoportal_geoportal.lib.caching",
"HybridRedisSentinelBackend")
for name, cache_config in settings["cache"].items():
caching.init_region(cache_config, name)
@zope.event.classhandler.handler(InvalidateCacheEvent)
def handle(event: InvalidateCacheEvent) -> None: # pylint: disable=unused-variable
del event
caching.invalidate_region()
if caching.MEMORY_CACHE_DICT:
caching.get_region("std").delete_multi(
caching.MEMORY_CACHE_DICT.keys())
caching.MEMORY_CACHE_DICT.clear()
# Register a tween to get back the cache buster path.
if "cache_path" not in config.get_settings():
config.get_settings()["cache_path"] = ["static"]
config.add_tween(
"c2cgeoportal_geoportal.lib.cacheversion.CachebusterTween")
config.add_tween("c2cgeoportal_geoportal.lib.headers.HeadersTween")
# Bind the mako renderer to other file extensions
add_mako_renderer(config, ".html")
add_mako_renderer(config, ".js")
# Add the "geojson" renderer
config.add_renderer("geojson", GeoJSON())
# Add the "xsd" renderer
config.add_renderer("xsd", XSD(include_foreign_keys=True))
# Add the set_user_validator directive, and set a default user validator
config.add_directive("set_user_validator", set_user_validator)
config.set_user_validator(default_user_validator)
config.add_route("dynamic", "/dynamic.json", request_method="GET")
# Add routes to the mapserver proxy
config.add_route_predicate("mapserverproxy", MapserverproxyRoutePredicate)
config.add_route(
"mapserverproxy",
"/mapserv_proxy",
mapserverproxy=True,
pregenerator=C2CPregenerator(role=True),
request_method="GET",
)
config.add_route(
"mapserverproxy_post",
"/mapserv_proxy",
mapserverproxy=True,
pregenerator=C2CPregenerator(role=True),
request_method="POST",
)
add_cors_route(config, "/mapserv_proxy", "mapserver")
# Add route to the tinyows proxy
config.add_route("tinyowsproxy",
"/tinyows_proxy",
pregenerator=C2CPregenerator(role=True))
# Add routes to the entry view class
config.add_route("base", "/", static=True)
config.add_route("loginform", "/login.html", request_method="GET")
add_cors_route(config, "/login", "login")
config.add_route("login", "/login", request_method="POST")
add_cors_route(config, "/logout", "login")
config.add_route("logout", "/logout", request_method="GET")
add_cors_route(config, "/loginchangepassword", "login")
config.add_route("change_password",
"/loginchangepassword",
request_method="POST")
add_cors_route(config, "/loginresetpassword", "login")
config.add_route("loginresetpassword",
"/loginresetpassword",
request_method="POST")
add_cors_route(config, "/loginuser", "login")
config.add_route("loginuser", "/loginuser", request_method="GET")
config.add_route("testi18n", "/testi18n.html", request_method="GET")
config.add_renderer(".map", AssetRendererFactory)
config.add_renderer(".css", AssetRendererFactory)
config.add_renderer(".ico", AssetRendererFactory)
config.add_route("localejson", "/locale.json", request_method="GET")
def add_static_route(name: str, attr: str, path: str,
renderer: str) -> None:
config.add_route(name, path, request_method="GET")
config.add_view(Entry, attr=attr, route_name=name, renderer=renderer)
add_static_route("favicon", "favicon", "/favicon.ico",
"/etc/geomapfish/static/images/favicon.ico")
add_static_route("robot.txt", "robot_txt", "/robot.txt",
"/etc/geomapfish/static/robot.txt")
add_static_route("apijs", "apijs", "/api.js", "/etc/static-ngeo/api.js")
add_static_route("apijsmap", "apijsmap", "/api.js.map",
"/etc/static-ngeo/api.js.map")
add_static_route("apicss", "apicss", "/api.css",
"/etc/static-ngeo/api.css")
add_static_route("apihelp", "apihelp", "/apihelp/index.html",
"/etc/geomapfish/static/apihelp/index.html")
c2cgeoportal_geoportal.views.add_redirect(config, "apihelp_redirect",
"/apihelp.html", "apihelp")
config.add_route("themes",
"/themes",
request_method="GET",
pregenerator=C2CPregenerator(role=True))
config.add_route("invalidate", "/invalidate", request_method="GET")
# Print proxy routes
config.add_route("printproxy", "/printproxy", request_method="HEAD")
add_cors_route(config, "/printproxy/*all", "print")
config.add_route(
"printproxy_capabilities",
"/printproxy/capabilities.json",
request_method="GET",
pregenerator=C2CPregenerator(role=True),
)
config.add_route(
"printproxy_report_create",
"/printproxy/report.{format}",
request_method="POST",
header=JSON_CONTENT_TYPE,
)
config.add_route("printproxy_status",
"/printproxy/status/{ref}.json",
request_method="GET")
config.add_route("printproxy_cancel",
"/printproxy/cancel/{ref}",
request_method="DELETE")
config.add_route("printproxy_report_get",
"/printproxy/report/{ref}",
request_method="GET")
# Full-text search routes
add_cors_route(config, "/search", "fulltextsearch")
config.add_route("fulltextsearch", "/search", request_method="GET")
# Access to raster data
add_cors_route(config, "/raster", "raster")
config.add_route("raster", "/raster", request_method="GET")
add_cors_route(config, "/profile.json", "profile")
config.add_route("profile.json", "/profile.json", request_method="POST")
# Shortener
add_cors_route(config, "/short/create", "shortener")
config.add_route("shortener_create",
"/short/create",
request_method="POST")
config.add_route("shortener_get", "/s/{ref}", request_method="GET")
# Geometry processing
config.add_route("difference", "/difference", request_method="POST")
# PDF report tool
config.add_route("pdfreport",
"/pdfreport/{layername}/{ids}",
request_method="GET")
# Add routes for the "layers" web service
add_cors_route(config, "/layers/*all", "layers")
config.add_route("layers_count",
"/layers/{layer_id:\\d+}/count",
request_method="GET")
config.add_route(
"layers_metadata",
"/layers/{layer_id:\\d+}/md.xsd",
request_method="GET",
pregenerator=C2CPregenerator(role=True),
)
config.add_route("layers_read_many",
"/layers/{layer_id:\\d+,?(\\d+,)*\\d*$}",
request_method="GET") # supports URLs like /layers/1,2,3
config.add_route("layers_read_one",
"/layers/{layer_id:\\d+}/{feature_id}",
request_method="GET")
config.add_route("layers_create",
"/layers/{layer_id:\\d+}",
request_method="POST",
header=GEOJSON_CONTENT_TYPE)
config.add_route(
"layers_update",
"/layers/{layer_id:\\d+}/{feature_id}",
request_method="PUT",
header=GEOJSON_CONTENT_TYPE,
)
config.add_route("layers_delete",
"/layers/{layer_id:\\d+}/{feature_id}",
request_method="DELETE")
config.add_route(
"layers_enumerate_attribute_values",
"/layers/{layer_name}/values/{field_name}",
request_method="GET",
pregenerator=C2CPregenerator(),
)
# There is no view corresponding to that route, it is to be used from
# mako templates to get the root of the "layers" web service
config.add_route("layers_root", "/layers", request_method="HEAD")
# Resource proxy (load external url, useful when loading non https content)
config.add_route("resourceproxy", "/resourceproxy", request_method="GET")
# Dev
config.add_route("dev", "/dev/*path", request_method="GET")
# Used memory in caches
config.add_route("memory", "/memory", request_method="GET")
# Scan view decorator for adding routes
config.scan(ignore=[
"c2cgeoportal_geoportal.lib",
"c2cgeoportal_geoportal.scaffolds",
"c2cgeoportal_geoportal.scripts",
])
add_admin_interface(config)
add_getitfixed(config)
# Add the project static view with cache buster
config.add_static_view(
name="static",
path="/etc/geomapfish/static",
cache_max_age=int(config.get_settings()["default_max_age"]),
)
config.add_cache_buster("/etc/geomapfish/static", version_cache_buster)
# Add the project static view without cache buster
config.add_static_view(
name="static-ngeo",
path="/etc/static-ngeo",
cache_max_age=int(config.get_settings()["default_max_age"]),
)
# Handles the other HTTP errors raised by the views. Without that,
# the client receives a status=200 without content.
config.add_view(error_handler, context=HTTPException)
c2cwsgiutils.index.additional_title = (
'<div class="row"><div class="col-lg-3"><h2>GeoMapFish</h2></div><div class="col-lg">'
)
c2cwsgiutils.index.additional_auth.extend([
'<a href="../tiles/admin/">TileCloud chain admin</a><br>',
'<a href="../tiles/c2c/">TileCloud chain c2c tools</a><br>',
'<a href="../invalidate">Invalidate the cache</a><br>',
'<a href="../memory">Memory status</a><br>',
])
if config.get_settings().get("enable_admin_interface", False):
c2cwsgiutils.index.additional_noauth.append(
'<a href="../admin/">Admin</a><br>')
c2cwsgiutils.index.additional_noauth.append(
'</div></div><div class="row"><div class="col-lg-3"><h3>Interfaces</h3></div><div class="col-lg">'
)
c2cwsgiutils.index.additional_noauth.append(
'<a href="../">Default</a><br>')
for interface in config.get_settings().get("interfaces", []):
if not interface.get("default", False):
c2cwsgiutils.index.additional_noauth.append(
'<a href="../{interface}">{interface}</a><br>'.format(
interface=interface["name"]))
c2cwsgiutils.index.additional_noauth.append(
'<a href="../apihelp/index.html">API help</a><br>')
c2cwsgiutils.index.additional_noauth.append("</div></div><hr>")
def _configure_routes(config):
config.add_static_view(name='static', path='nerffinder:static')
config.add_route('root', '/')
config.add_view(nerffinder.views.map.map_view, route_name='root', renderer='nerffinder:templates/splash.mak')
config.add_route('map', '/map')
config.add_view(nerffinder.views.map.map_view, route_name='map', renderer='nerffinder:templates/map.mak')
config.add_route('chart', '/chart')
config.add_view(nerffinder.views.chart.chart_view, route_name='chart', renderer='nerffinder:templates/chart.mak')
config.add_route('precache', '/precache')
config.add_view(nerffinder.views.precache.precache_view, route_name='precache', renderer='nerffinder:templates/precache.mak')
config.add_route('api_gear_categories', '/api/v1/gear/categories/')
config.add_view(nerffinder.api.v1.gear.categories_view, route_name='api_gear_categories', renderer='json')
config.add_route('api_gear_locations', '/api/v1/gear/locations/')
config.add_view(nerffinder.api.v1.gear.locations_view, route_name='api_gear_locations', renderer='json')
config.add_route('api_gear_details', '/api/v1/gear/details/{id}/')
config.add_view(nerffinder.api.v1.gear.details_view, route_name='api_gear_details', renderer='json')
def __discover_routes(config):
for name, object_ in inspect.getmembers(sys.modules[__name__]):
if inspect.isfunction(object_) and hasattr(object_, 'route'):
config.add_route(name, object_.route)
config.add_view(object_, route_name=name)
