def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
settings = config.get_settings()
settings.update(yaml.load(file(settings.get("app.cfg"))))
add_mako_renderer(config, ".html")
add_mako_renderer(config, ".js")
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
dbreflection.init(engine)
config.set_authorization_policy(ACLAuthorizationPolicy())
config.add_request_method(
_create_get_user_from_request(settings),
name="user",
property=True
)
authtkt_authentication_policy = AuthTktAuthenticationPolicy(
settings.get('authtkt')['secret'],
cookie_name=settings.get('authtkt')['cookie_name'],
hashalg='sha512'
)
remote_user_authentication_policy = RemoteUserAuthenticationPolicy()
policies = [remote_user_authentication_policy, authtkt_authentication_policy]
authentication_policy = MultiAuthenticationPolicy(policies)
config.set_authentication_policy(authentication_policy)
config.include('pyramid_mako')
config.include(pyramid_tm.includeme)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('viewer', '/viewer.js')
config.add_route('image_proxy', '/img/{type}/{id}')
config.add_route('pdf_proxy', '/pdf/{type}/{id}.pdf')
# historic parcels
config.add_route('historic_parcel_get', '/historic_parcel/{id}')
config.add_route('historic_parcel', '/historic_parcel')
config.add_route('historic_parcel_doc', '/historic_parcel_doc')
# print proxy routes
config.add_route('printproxy', '/printproxy')
config.add_route('printproxy_info', '/printproxy/info.json')
config.add_route('printproxy_create', '/printproxy/create.json')
config.add_route('printproxy_get', '/printproxy/{file}.printout')
# mutation
config.add_route('mutation_list', '/mutation/list')
config.scan()
return config.make_wsgi_app()
def initialized(ev):
PTAH = ptah.get_settings(ptah.CFG_ID_PTAH, ev.registry)
# mail
PTAH['Mailer'] = DummyMailer()
PTAH['full_email_address'] = formataddr(
(PTAH['email_from_name'], PTAH['email_from_address']))
# sqla
SQLA = ptah.get_settings(ptah.CFG_ID_SQLA, ev.registry)
url = SQLA['url']
if url:
engine_args = {}
if SQLA['cache']:
cache = {}
engine_args['execution_options'] = \
{'compiled_cache': cache}
SQLA['sqlalchemy_cache'] = cache
try:
engine = sqlahelper.get_engine()
except: # pragma: no cover
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': url}, 'sqlalchemy.', **engine_args)
sqlahelper.add_engine(engine)
# ptah manage
if PTAH['manage']:
ev.config.add_route(
'ptah-manage', '/ptah-manage/*traverse',
factory=ptah.manage.PtahManageRoute, use_global_views=True)
ptah.manage.set_access_manager(
ptah.manage.PtahAccessManager())
def setUpCommon():
import c2cgeoportal
c2cgeoportal.schema = 'main'
c2cgeoportal.srid = 21781
c2cgeoportal.caching.init_region({'backend': 'dogpile.cache.memory'})
# if test.in does not exist (because the z3c.recipe.filetemplate
# part hasn't been executed) then db_url is None
if db_url is None: # pragma: nocover
return
# verify that we have a working database connection before going
# forward
from sqlalchemy import create_engine
from sqlalchemy.exc import OperationalError
engine = create_engine(db_url)
try:
engine.connect()
except OperationalError: # pragma: nocover
return
import sqlahelper
sqlahelper.add_engine(engine)
from c2cgeoportal.models import Base
Base.metadata.create_all()
def create_engine(create_engine_dotted, dburl):
if create_engine_dotted:
return import_symbol(create_engine_dotted)(dburl)
else:
engine = sa.create_engine(dburl)
sqlahelper.add_engine(engine)
return engine
def test1(self):
import transaction
Base = sqlahelper.get_base()
class Person(Base):
__tablename__ = "people"
id = sa.Column(sa.Integer, primary_key=True)
first_name = sa.Column(sa.Unicode(100), nullable=False)
last_name = sa.Column(sa.Unicode(100), nullable=False)
engine = sa.create_engine(self.db1.url)
sqlahelper.add_engine(engine)
Base.metadata.create_all()
fred = Person(id=1, first_name=u"Fred", last_name=u"Flintstone")
wilma = Person(id=2, first_name=u"Wilma", last_name=u"Flintstone")
barney = Person(id=3, first_name=u"Barney", last_name=u"Rubble")
betty = Person(id=4, first_name=u"Betty", last_name=u"Rubble")
Session = sqlahelper.get_session()
sess = Session()
sess.add_all([fred, wilma, barney, betty])
transaction.commit()
sess.expunge_all()
del fred, wilma, barney, betty
# Can we get back a record?
barney2 = sess.query(Person).get(3)
self.assertEqual(barney2.id, 3)
self.assertEqual(barney2.first_name, u"Barney")
self.assertEqual(barney2.last_name, u"Rubble")
sa.select([Person.first_name])
# Can we iterate the first names in reverse alphabetical order?
q = sess.query(Person.first_name).order_by(Person.first_name.desc())
result = [x.first_name for x in q]
control = [u"Wilma", u"Fred", u"Betty", u"Barney"]
self.assertEqual(result, control)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
dbreflection.init(engine)
settings.setdefault('mako.directories', 'historic_cadastre:templates')
settings.setdefault('reload_templates', True)
config = Configurator(settings=settings)
config.add_renderer('.html', mako_renderer_factory)
config.add_renderer('.js', mako_renderer_factory)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('viewer', '/viewer.js')
config.add_route('image_proxy', '/img/{type}/{id}')
config.add_route('pdf_proxy', '/pdf/{type}/{id}')
# print proxy routes
config.add_route('printproxy', '/printproxy')
config.add_route('printproxy_info', '/printproxy/info.json')
config.add_route('printproxy_create', '/printproxy/create.json')
config.add_route('printproxy_get', '/printproxy/{file}.printout')
# mutation
config.add_route('mutation_list', '/mutation/list')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
for p in ['rte', 'enedis', 'ogm']:
PROFILES[settings['profile.%s' % p]] = p
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.include('pyramid_mako')
# initialize database
engine = sqlalchemy.engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
# add the "geojson" renderer
config.add_renderer(name='csv', factory='cables.renderers.CSVRenderer')
# add routes to the entry view class
config.add_route('export_zonessensibles', '/export/zonessensibles')
config.add_route('export_communes', '/export/communes')
config.add_route('export_departements', '/export/departements')
config.add_route('profile', '/profile')
config.scan()
# add the static view (for static resources)
config.add_static_view('static', 'cables:static')
return config.make_wsgi_app()
def setUpCommon():
import c2cgeoportal
c2cgeoportal.schema = 'main'
c2cgeoportal.srid = 21781
c2cgeoportal.caching.init_region({'backend': 'dogpile.cache.memory'})
# if test.in does not exist (because the z3c.recipe.filetemplate
# part hasn't been executed) then db_url is None
if db_url is None: # pragma: nocover
return
# verify that we have a working database connection before going
# forward
from sqlalchemy import create_engine
from sqlalchemy.exc import OperationalError
engine = create_engine(db_url)
try:
engine.connect()
except OperationalError: # pragma: nocover
return
import sqlahelper
sqlahelper.add_engine(engine)
from c2cgeoportal.models import Base
Base.metadata.create_all()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
settings = config.get_settings()
settings.update(yaml.load(file(settings.get("app.cfg"))))
add_mako_renderer(config, ".html")
add_mako_renderer(config, ".js")
config.include("pyramid_mako")
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
config.include(pyramid_tm.includeme)
dbreflection.init(engine)
config.include('.routes')
config.scan()
return config.make_wsgi_app()
def test1(self):
import transaction
Base = sqlahelper.get_base()
class Person(Base):
__tablename__ = "people"
id = sa.Column(sa.Integer, primary_key=True)
first_name = sa.Column(sa.Unicode(100), nullable=False)
last_name = sa.Column(sa.Unicode(100), nullable=False)
engine = sa.create_engine(self.db1.url)
sqlahelper.add_engine(engine)
Base.metadata.create_all()
fred = Person(id=1, first_name=u"Fred", last_name=u"Flintstone")
wilma = Person(id=2, first_name=u"Wilma", last_name=u"Flintstone")
barney = Person(id=3, first_name=u"Barney", last_name=u"Rubble")
betty = Person(id=4, first_name=u"Betty", last_name=u"Rubble")
Session = sqlahelper.get_session()
sess = Session()
sess.add_all([fred, wilma, barney, betty])
transaction.commit()
sess.expunge_all()
del fred, wilma, barney, betty
# Can we get back a record?
barney2 = sess.query(Person).get(3)
self.assertEqual(barney2.id, 3)
self.assertEqual(barney2.first_name, u"Barney")
self.assertEqual(barney2.last_name, u"Rubble")
sa.select([Person.first_name])
# Can we iterate the first names in reverse alphabetical order?
q = sess.query(Person.first_name).order_by(Person.first_name.desc())
result = [x.first_name for x in q]
control = [u"Wilma", u"Fred", u"Betty", u"Barney"]
self.assertEqual(result, control)
def test_add_engine_twice(self):
db1 = sa.create_engine(self.db1.url)
db2 = sa.create_engine(self.db2.url)
sqlahelper.add_engine(db1)
self.assertIs(sqlahelper.get_session().bind, db1)
sqlahelper.add_engine(db2)
self.assertIs(sqlahelper.get_session().bind, db2)
self.assertIs(sqlahelper.get_session().bind, sqlahelper.sessions.default.registry.registry.value.bind)
def setUp(self):
try:
engine = sqlahelper.get_engine()
except: # pragma: no cover
engine = sqlalchemy.engine_from_config({"sqlalchemy.url": "sqlite://"})
sqlahelper.add_engine(engine)
self._setup_pyramid()
def test_add_engine_twice(self):
db1 = sa.create_engine(self.db1.url)
db2 = sa.create_engine(self.db2.url)
sqlahelper.add_engine(db1)
self.assertIs(sqlahelper.get_session().bind, db1)
sqlahelper.add_engine(db2)
self.assertIs(sqlahelper.get_session().bind, db2)
self.assertIs(sqlahelper.get_session().bind, sqlahelper.sessions.default.registry.registry.value.bind)
def main(global_config, **settings):
engine = engine_from_config(settings)
sqlahelper.add_engine(engine)
config = Configurator(settings=settings,
root_factory='.models.ShirlyResource')
config.add_subscriber(add_renderer_globals, 'pyramid.events.BeforeRender')
config.include('.')
config.scan()
return config.make_wsgi_app()
def init_engine(config):
engine = create_engine(
config['uri'],
echo=config['echo'],
pool_recycle=config['pool_recycle'],
convert_unicode=True
)
add_engine(engine)
def init_engine(config):
engine = create_engine(
config.get('SQLALCHEMY_DATABASE_URI'),
echo=config.get('SQLALCHEMY_ECHO'),
pool_recycle=config.get('SQLALCHEMY_POOL_RECYCLE'),
convert_unicode=True
)
add_engine(engine)
def loginchange(self):
new_password = self.request.params.get('newPassword', None)
new_password_confirm = self.request.params.get('confirmNewPassword',
None)
if new_password is None or new_password_confirm is None:
raise HTTPBadRequest(
'"newPassword" and "confirmNewPassword" should be \
available in request params')
# check if loggedin
if not self.request.user:
raise HTTPUnauthorized('bad credentials')
if new_password != new_password_confirm:
raise HTTPBadRequest("the new password and the new password \
confirmation don't match")
u = self.request.user
u._set_password(new_password)
u.is_password_changed = True
DBSession.flush()
log.info("password changed for user: %s" % self.request.user.username)
# handle replication
if 'auth_replication_enabled' in self.request.registry.settings and \
self.request.registry.settings['auth_replication_enabled'] == \
'true': # pragma: no cover
try:
log.debug(
"trying to find if engine set for replication exists")
engine = sqlahelper.get_engine('replication')
except RuntimeError:
log.debug("engine for replication doesn't exist yet, trying \
to create")
engine = engine_from_config(self.request.registry.settings,
'sqlalchemy_replication.')
sqlahelper.add_engine(engine, 'replication')
DBSession2 = scoped_session(sessionmaker(bind=engine))
dbuser_r = DBSession2.query(User).filter(
User.id == self.request.user.id)
result = dbuser_r.all()
if len(result) == 0:
msg = 'user not found in replication target database: %s' \
% self.request.user.username
log.exception(msg)
return HTTPBadRequest(msg) # pragma nocover
else:
u_r = dbuser_r.all()[0]
u_r._set_password(new_password)
u_r.is_password_changed = True
DBSession2.commit()
log.info("password changed in replication target database \
for user: %s" % self.request.user.username)
return Response('true', cache_control="no-cache")
def setUp(self):
try:
engine = sqlahelper.get_engine()
except:
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': 'sqlite://'})
sqlahelper.add_engine(engine)
self._setup_pyramid()
self._setup_ptah()
def setup_source_engines():
for source_name, source_data in config['SOURCES'].items():
if source_data['TYPE'] == 'DB':
db_connection = config['DATABASES'][source_data['CONNECTION']]
current_db_url = db_url.format(
NAME=source_data['DATABASE'],
**db_connection
)
engine = sqlalchemy.create_engine(current_db_url)
sqlahelper.add_engine(engine, source_name)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(
settings,
'sqlalchemy.',
convert_unicode=False,
encoding='utf-8'
)
sqlahelper.add_engine(engine)
settings.setdefault('mako.directories','crdppf:templates')
settings.setdefault('reload_templates',True)
my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet',2400)
config = Configurator(settings=settings, session_factory = my_session_factory)
config.include(papyrus.includeme)
config.add_renderer('.js', mako_renderer_factory)
config.add_renderer('geojson', GeoJSON())
config.set_request_property(read_tile_date, name='tile_date', reify=True)
config.add_static_view('static', 'crdppf:static', cache_max_age=3600)
# ROUTES
config.add_route('home', '/')
config.add_route('images', '/static/images/')
config.add_route('create_extract', 'create_extract')
config.add_route('get_features', 'get_features')
config.add_route('set_language', 'set_language')
config.add_route('get_language', 'get_language')
config.add_route('get_translation_dictionary', 'get_translation_dictionary')
config.add_route('get_interface_config', 'get_interface_config')
config.add_route('get_baselayers_config', 'get_baselayers_config')
config.add_route('test', 'test')
config.add_route('formulaire_reglements', 'formulaire_reglements')
config.add_route('getCadastreList', 'getCadastreList')
config.add_route('getTopicsList', 'getTopicsList')
config.add_route('createNewDocEntry', 'createNewDocEntry')
config.add_route('getLegalDocuments', 'getLegalDocuments')
config.add_route('map', 'map')
config.add_route('globalsjs', '/globals.js')
config.add_route('ogcproxy', '/ogcproxy')
# VIEWS
config.add_view('crdppf.views.entry.Entry', route_name = 'home')
config.add_view('crdppf.views.entry.Entry', route_name = 'images')
config.add_view('crdppf.views.entry.Entry', route_name='formulaire_reglements')
config.add_view('crdppf.views.entry.Entry', route_name='test')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings)
sqlahelper.add_engine(engine)
config = Configurator(settings=settings)
config.include('.fainit')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.scan()
return config.make_wsgi_app()
def test_multiple_engines(self):
default = sa.create_engine(self.db1.url)
stats = sa.create_engine(self.db2.url)
sqlahelper.add_engine(default)
sqlahelper.add_engine(stats, "stats")
# Can we retrieve the engines?
self.assertIs(sqlahelper.get_engine(), default)
self.assertIs(sqlahelper.get_engine("default"), default)
self.assertIs(sqlahelper.get_engine("stats"), stats)
# Are the session binding and base binding set correctly?
self.assertIs(sqlahelper.get_session().bind, default)
self.assertIs(sqlahelper.get_base().metadata.bind, default)
def test_multiple_engines(self):
default = sa.create_engine(self.db1.url)
stats = sa.create_engine(self.db2.url)
sqlahelper.add_engine(default)
sqlahelper.add_engine(stats, "stats")
# Can we retrieve the engines?
self.assertIs(sqlahelper.get_engine(), default)
self.assertIs(sqlahelper.get_engine("default"), default)
self.assertIs(sqlahelper.get_engine("stats"), stats)
# Are the session binding and base binding set correctly?
self.assertIs(sqlahelper.get_session().bind, default)
self.assertIs(sqlahelper.get_base().metadata.bind, default)
def test_multiple_engines_without_default(self):
db1 = sa.create_engine(self.db1.url)
db2 = sa.create_engine(self.db2.url)
sqlahelper.add_engine(db1, "db1")
sqlahelper.add_engine(db2, "db2")
# Can we retrieve the engines?
self.assertIs(sqlahelper.get_engine("db1"), db1)
self.assertIs(sqlahelper.get_engine("db2"), db2)
# There should be no default engine
self.assertIsNone(sqlahelper.get_session().bind)
self.assertIsNone(sqlahelper.get_base().metadata.bind)
self.assertIsNone(sqlahelper.get_engine())
def loginchange(self):
new_password = self.request.params.get('newPassword', None)
new_password_confirm = self.request.params.get('confirmNewPassword', None)
if new_password is None or new_password_confirm is None:
raise HTTPBadRequest('"newPassword" and "confirmNewPassword" should be \
available in request params')
# check if loggedin
if not self.request.user:
raise HTTPUnauthorized('bad credentials')
if new_password != new_password_confirm:
raise HTTPBadRequest("the new password and the new password \
confirmation don't match")
u = self.request.user
u._set_password(new_password)
u.is_password_changed = True
DBSession.flush()
log.info("password changed for user: %s" % self.request.user.username)
# handle replication
if 'auth_replication_enabled' in self.request.registry.settings and \
self.request.registry.settings['auth_replication_enabled'] == \
'true': # pragma: no cover
try:
log.debug("trying to find if engine set for replication exists")
engine = sqlahelper.get_engine('replication')
except RuntimeError:
log.debug("engine for replication doesn't exist yet, trying \
to create")
engine = engine_from_config(
self.request.registry.settings,
'sqlalchemy_replication.')
sqlahelper.add_engine(engine, 'replication')
DBSession2 = scoped_session(sessionmaker(bind=engine))
dbuser_r = DBSession2.query(User).filter(User.id == self.request.user.id)
result = dbuser_r.all()
if len(result) == 0:
msg = 'user not found in replication target database: %s' \
% self.request.user.username
log.exception(msg)
return HTTPBadRequest(msg) # pragma nocover
else:
u_r = dbuser_r.all()[0]
u_r._set_password(new_password)
u_r.is_password_changed = True
DBSession2.commit()
log.info("password changed in replication target database \
for user: %s" % self.request.user.username)
return Response('true', cache_control="no-cache")
def test_multiple_engines_without_default(self):
db1 = sa.create_engine(self.db1.url)
db2 = sa.create_engine(self.db2.url)
sqlahelper.add_engine(db1, "db1")
sqlahelper.add_engine(db2, "db2")
# Can we retrieve the engines?
self.assertIs(sqlahelper.get_engine("db1"), db1)
self.assertIs(sqlahelper.get_engine("db2"), db2)
# There should be no default engine
self.assertIsNone(sqlahelper.get_session().bind)
self.assertIsNone(sqlahelper.get_base().metadata.bind)
self.assertIsNone(sqlahelper.get_engine())
def includeme(config):
settings = config.registry.settings
# add default values for some global settings
templates_dir = list(filter(
None, settings.get('templates_dir', '').splitlines()))
templates_dir.append('pygall:templates')
settings['mako.directories'] = templates_dir
if 'photos_dir' not in settings:
settings['photos_dir'] = 'photos'
if 'upload_dir' not in settings:
settings['upload_dir'] = 'upload'
allow_cdn = asbool(settings.get('allow_cdn', 'false'))
settings['allow_cdn'] = allow_cdn
ip.set_dest_dir(settings['photos_dir'])
mkdir_p(settings['upload_dir'])
init_security(settings)
init_resources(settings)
authentication_policy = AuthTktAuthenticationPolicy(
settings['authtkt_secret'], callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
config.add_settings(settings)
config.set_root_factory(RootFactory)
config.set_locale_negotiator(default_locale_negotiator)
config.set_authentication_policy(authentication_policy)
config.set_authorization_policy(authorization_policy)
# initialize database
engine = sqlalchemy.engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
config.include(pyramid_tm.includeme)
# formalchemy
config.include('pyramid_formalchemy')
config.include('fa.jquery')
config.formalchemy_admin('admin', package='pygall',
view='fa.jquery.pyramid.ModelView', factory=FAModelsFactory)
# i18n
config.add_translation_dirs('pygall:locale')
# bind the mako renderer to other file extensions
config.add_renderer('.mako', mako_renderer_factory)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.include(add_routes)
config.include(add_views)
config.scan('pygall')
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
add_engine(engine)
session = get_session()
Base.metadata.create_all(engine)
with transaction.manager:
model = MyModel(name='one', value=1)
session.add(model)
def setUp(self):
if self._init_sqla:
try:
engine = sqlahelper.get_engine()
except: # pragma: no cover
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': 'sqlite://'})
sqlahelper.add_engine(engine)
self.init_pyramid()
if self._init_ptah: # pragma: no cover
self.init_ptah()
def sqla_initializing(ev):
url = SQLA.url
if url:
engine_args = {}
if SQLA.cache:
engine_args['execution_options'] = \
{'compiled_cache': SQL_compiled_cache}
try:
engine = sqlahelper.get_engine()
except:
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': url}, 'sqlalchemy.', **engine_args)
sqlahelper.add_engine(engine)
def setUp(self):
if self._init_sqla:
try:
engine = sqlahelper.get_engine()
except: # pragma: no cover
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': 'sqlite://'})
sqlahelper.add_engine(engine)
self.init_pyramid()
if self._init_ptah: # pragma: no cover
self.init_ptah()
def initializing(ev):
# auth
if not SECURITY.secret:
SECURITY.secret = uuid.uuid4().get_hex()
pname = SECURITY.policy
if pname not in ('', 'no-policy'):
policyFactory, attrs, kw = types[pname]
settings = []
for attr in attrs:
settings.append(SECURITY.get(attr))
kwargs = {'wild_domain': False}
for attr in kw:
kwargs[attr] = SECURITY.get(attr)
policy = policyFactory(*settings, **kwargs)
config.registry.registerUtility(policy, IAuthenticationPolicy)
if SECURITY.authorization:
config.registry.registerUtility(
ACLAuthorizationPolicy(), IAuthorizationPolicy)
# mail
smtp_mailer = SMTPMailer(
hostname = MAIL.host,
port = MAIL.port,
username = MAIL.username or None,
password = MAIL.password or None,
no_tls = MAIL.no_tls,
force_tls = MAIL.force_tls,
debug_smtp = MAIL.debug)
MAIL.Mailer = DirectMailDelivery(smtp_mailer)
MAIL.full_from_address = formataddr((MAIL.from_name, MAIL.from_address))
# sqla
url = SQLA.url
if url:
engine_args = {}
if SQLA.cache:
engine_args['execution_options'] = \
{'compiled_cache': SQL_compiled_cache}
try:
engine = sqlahelper.get_engine()
except:
engine = sqlalchemy.engine_from_config(
{'sqlalchemy.url': url}, 'sqlalchemy.', **engine_args)
sqlahelper.add_engine(engine)
def setUp(self):
self.config = testing.setUp()
from sqlalchemy import create_engine
from sqlahelper import add_engine, get_session
engine = create_engine('sqlite://')
add_engine(engine)
from .models import (
Base,
MyModel,
)
self.session = get_session()
Base.metadata.create_all(engine)
self.session = get_session()
self.model = MyModel(name='one', value=55)
self.session.add(self.model)
def load_database(database=settings.DATABASE):
engine = sqlalchemy.engine_from_config(database, prefix='')
sqlahelper.add_engine(engine)
tlogger.info("database set up: %s" % engine)
for package in settings.INSTALLED_APPS:
try:
importlib.import_module(package + ".models")
except ImportError:
result = "failed"
else:
result = "done"
finally:
tlogger.debug("loading models: %s.models.. %s" % (package, result))
Base = sqlahelper.get_base()
tlogger.info('creating database tables')
Base.metadata.create_all(engine)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
add_engine(engine)
authentication_policy = WhoV2AuthenticationPolicy(settings['who.url'], 'auth_tkt')
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings)
config.set_authentication_policy(authentication_policy)
config.set_authorization_policy(authorization_policy)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/', factory=find_object)
config.add_route('remember', '/remember')
config.add_route('forget', '/forget')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings)
sqlahelper.add_engine(engine)
settings = get_makopath()
config = Configurator(root_factory=Root,
settings=settings,
session_factory=my_session_factory)
config.include('pyramid_tm')
config.add_route('home', '/')
config.add_route('deposit', '/deposit')
config.add_route('withdraw', '/withdraw')
config.add_static_view('static', 'bankaccount:static')
config.scan('.views')
return config.make_wsgi_app()
def set_up_common():
c2cgeoportal.schema = "main"
c2cgeoportal.srid = 21781
functionality.FUNCTIONALITIES_TYPES = None
# if test.in does not exist (because the z3c.recipe.filetemplate
# part hasn"t been executed) then db_url is None
if db_url is None: # pragma: no cover
return
# verify that we have a working database connection before going
# forward
from sqlalchemy import create_engine
from sqlalchemy.exc import OperationalError
engine = create_engine(db_url)
try:
engine.connect()
except OperationalError: # pragma: no cover
return
import sqlahelper
sqlahelper.add_engine(engine)
import alembic.config
import sys
sys.argv = [
"alembic", "-c", "c2cgeoportal/tests/functional/alembic.ini",
"upgrade", "head"
]
try:
alembic.config.main()
except SystemExit: # alembic call the exit method!
pass
sys.argv = [
"alembic", "-c", "c2cgeoportal/tests/functional/alembic_static.ini",
"upgrade", "head"
]
try:
alembic.config.main()
except SystemExit: # alembic call the exit method!
pass
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(
settings,
'sqlalchemy.')
sqlahelper.add_engine(engine)
dbreflection.init(engine)
settings.setdefault('mako.directories','las_extractor:templates')
settings.setdefault('reload_templates',True)
settings.update(yaml.load(file(settings.get('app.cfg'))))
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_subscriber('las_extractor.i18n.add_renderer_globals',
'pyramid.events.BeforeRender')
config.add_subscriber('las_extractor.i18n.add_localizer',
'pyramid.events.NewRequest')
config.add_translation_dirs('las_extractor:locale/')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('lidar_profile', '/lidar/profile')
config.add_route('lidar_csv', '/lidar/lidarprofil.csv')
config.add_route('lidar_kml', '/lidar/kml')
config.add_route('lidar_shp', '/lidar/shp.zip')
config.add_route('lidar','/lidar')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
dbreflection.init(engine)
settings.setdefault('mako.directories', 'las_extractor:templates')
settings.setdefault('reload_templates', True)
settings.update(yaml.load(file(settings.get('app.cfg'))))
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_subscriber('las_extractor.i18n.add_renderer_globals',
'pyramid.events.BeforeRender')
config.add_subscriber('las_extractor.i18n.add_localizer',
'pyramid.events.NewRequest')
config.add_translation_dirs('las_extractor:locale/')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('lidar_profile', '/lidar/profile')
config.add_route('lidar_csv', '/lidar/lidarprofil.csv')
config.add_route('lidar_kml', '/lidar/kml')
config.add_route('lidar_shp', '/lidar/shp.zip')
config.add_route('lidar', '/lidar')
config.scan()
return config.make_wsgi_app()
def set_up_common():
c2cgeoportal.schema = "main"
c2cgeoportal.srid = 21781
functionality.FUNCTIONALITIES_TYPES = None
# if test.in does not exist (because the z3c.recipe.filetemplate
# part hasn"t been executed) then db_url is None
if db_url is None: # pragma: no cover
return
# verify that we have a working database connection before going
# forward
from sqlalchemy import create_engine
from sqlalchemy.exc import OperationalError
engine = create_engine(db_url)
try:
engine.connect()
except OperationalError: # pragma: no cover
return
import sqlahelper
sqlahelper.add_engine(engine)
import alembic.config
import sys
sys.argv = [
"alembic", "-c", "c2cgeoportal/tests/functional/alembic.ini", "upgrade", "head"
]
try:
alembic.config.main()
except SystemExit: # alembic call the exit method!
pass
sys.argv = [
"alembic", "-c", "c2cgeoportal/tests/functional/alembic_static.ini", "upgrade", "head"
]
try:
alembic.config.main()
except SystemExit: # alembic call the exit method!
pass
def main():
if len(sys.argv) != 2:
sys.exit("Usage: python -m drkpr.scripts.create_db INI_FILE")
ini_file = sys.argv[1]
logging.config.fileConfig(ini_file)
log = logging.getLogger(__name__)
app = get_app(ini_file, "myapp")
settings = app.registry.settings
engine = sqlalchemy.engine_from_config(settings,
prefix="sqlalchemy.",
pool_recycle=3600,
convert_unicode=True)
sqlahelper.add_engine(engine)
Base = sqlahelper.get_base()
Session = sqlahelper.get_session()
log.info("Create testing user accounts ...")
random.seed("whatever")
for i in range(0, 100):
sur_name = sur_names[random.randint(0, len(sur_names) - 1)]
given_name = given_names[random.randint(0, len(given_names) - 1)]
username = "******" % (sur_name, given_name)
try:
q = Session.query(model.DKUser)
r = q.get(username)
if not r:
user = model.DKUser()
user.username = username
user.roles = ":".join(["", model.ROLE_USER, ""])
user.passwd = hashlib.md5("cpksecurity").hexdigest()
user.master_email = "*****@*****.**" % username
user.actived = True
Session.add(user)
log.info(" Account '%s' setup complete." % username)
else:
log.info("Account '%s' already setup." % username)
except Exception, e:
print e
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(
settings,
'sqlalchemy.')
sqlahelper.add_engine(engine)
dbreflection.init(engine)
settings.setdefault('mako.directories','historic_cadastre:templates')
settings.setdefault('reload_templates',True)
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_mako_renderer('.html')
config.add_mako_renderer('.js')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('viewer', '/viewer.js')
config.add_route('image_proxy','/img/{type}/{id}')
config.add_route('pdf_proxy','/pdf/{type}/{id}')
# print proxy routes
config.add_route('printproxy', '/printproxy')
config.add_route('printproxy_info', '/printproxy/info.json')
config.add_route('printproxy_create', '/printproxy/create.json')
config.add_route('printproxy_get', '/printproxy/{file}.printout')
# mutation
config.add_route('mutation_list', '/mutation/list')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
"""
This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.include('pyramid_tm')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('view_wiki', '/')
config.add_route('view_page', '/{pagename}')
config.add_route('add_page', '/add_page/{pagename}')
config.add_route('edit_page', '/{pagename}/edit_page')
config.scan()
# sqlalchemyを有効に
engine = engine_from_config(settings)
sqlahelper.add_engine(engine)
return config.make_wsgi_app()
def main():
if len(sys.argv) != 2:
sys.exit("Usage: python -m drkpr.scripts.create_db INI_FILE")
ini_file = sys.argv[1]
logging.config.fileConfig(ini_file)
log = logging.getLogger(__name__)
app = get_app(ini_file, "myapp")
settings = app.registry.settings
engine = sqlalchemy.engine_from_config(settings, prefix="sqlalchemy.",
pool_recycle=3600, convert_unicode=True)
sqlahelper.add_engine(engine)
Base = sqlahelper.get_base()
Session = sqlahelper.get_session()
log.info("Create testing user accounts ...")
random.seed("whatever")
for i in range(0,100):
sur_name = sur_names[random.randint(0, len(sur_names)-1)]
given_name = given_names[random.randint(0, len(given_names)-1)]
username = "******" % (sur_name, given_name)
try:
q = Session.query(model.DKUser)
r = q.get(username)
if not r:
user = model.DKUser()
user.username = username
user.roles = ":".join(["", model.ROLE_USER, ""])
user.passwd = hashlib.md5("cpksecurity").hexdigest()
user.master_email = "*****@*****.**" % username
user.actived = True
Session.add(user)
log.info(" Account '%s' setup complete." % username)
else:
log.info("Account '%s' already setup." % username)
except Exception, e:
print e
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Here you can insert any code to modify the ``settings`` dict.
# You can:
# * Add additional keys to serve as constants or "global variables" in the
# application.
# * Set default values for settings that may have been omitted.
# * Override settings that you don't want the user to change.
# * Raise an exception if a setting is missing or invalid.
# * Convert values from strings to their intended type.
# Create the Pyramid Configurator.
config = Configurator(settings=settings)
config.include("pyramid_handlers")
config.include("akhet")
# Initialize database
engine = sqlalchemy.engine_from_config(settings, prefix="sqlalchemy.")
sqlahelper.add_engine(engine)
config.include("pyramid_tm")
# Configure Beaker sessions and caching
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
pyramid_beaker.set_cache_regions_from_settings(settings)
# Configure Babel
config.add_translation_dirs("drkpr:locale")
# Configure renderers and event subscribers
config.add_renderer(".html", "pyramid.mako_templating.renderer_factory")
config.add_subscriber("drkpr.subscribers.create_url_generator",
"pyramid.events.ContextFound")
config.add_subscriber("drkpr.subscribers.add_renderer_globals",
"pyramid.events.BeforeRender")
config.add_subscriber('drkpr.subscribers.add_localizer',
'pyramid.events.NewRequest')
# Set up view handlers
config.include("drkpr.handlers")
# Set up other routes and views
# ** If you have non-handler views, create create a ``drkpr.views``
# ** module for them and uncomment the next line.
#
#config.scan("drkpr.views")
# Mount a static view overlay onto "/". This will serve, e.g.:
# ** "/robots.txt" from "drkpr/static/robots.txt" and
# ** "/images/logo.png" from "drkpr/static/images/logo.png".
#
config.add_static_route("drkpr", "static", cache_max_age=3600)
# Mount a static subdirectory onto a URL path segment.
# ** This not necessary when using add_static_route above, but it's the
# ** standard Pyramid way to serve static files under a URL prefix (but
# ** not top-level URLs such as "/robots.txt"). It can also serve files from
# ** third-party packages, or point to an external HTTP server (a static
# ** media server).
# ** The first commented example serves URLs under "/static" from the
# ** "drkpr/static" directory. The second serves URLs under
# ** "/deform" from the third-party ``deform`` distribution.
#
config.add_static_view("static", "drkpr:static")
#config.add_static_view("deform", "deform:static")
return config.make_wsgi_app()
def main():
if len(sys.argv) != 2:
sys.exit("Usage: python -m drkpr.scripts.create_db INI_FILE")
ini_file = sys.argv[1]
logging.config.fileConfig(ini_file)
log = logging.getLogger(__name__)
app = get_app(ini_file, "myapp")
settings = app.registry.settings
engine = sqlalchemy.engine_from_config(settings,
prefix="sqlalchemy.",
pool_recycle=3600,
convert_unicode=True)
sqlahelper.add_engine(engine)
Base = sqlahelper.get_base()
Session = sqlahelper.get_session()
# Create the tables if they don't already exist
log.info("Initialize database ...")
Base.metadata.create_all(bind=Session.bind, checkfirst=True)
#create default privileges
log.info("Populate default privileges ...")
log.info("nothing here...")
log.info("Populate default privileges done.")
#create default roles
log.info("Populate default roles ...")
q = Session.query(model.DKRole)
if not q.all():
records = [
model.DKRole(model.ROLE_SYSADMIN),
model.DKRole(model.ROLE_USER),
]
Session.add_all(records)
log.info("Populate default roles done.")
else:
log.info("Roles already exist.")
log.info("Populate default roles done.")
#create default system parameters
log.info("Populate default system parameters ...")
q = Session.query(model.DKSystem)
if not q.all():
records = [
model.DKSystem("master_key_status", model.SS_SERVICE_NO_KEY),
model.DKSystem("service_key_gen_status",
model.SS_SERVICE_NOT_AVAIL),
model.DKSystem("service_key_revoke_status",
model.SS_SERVICE_NOT_AVAIL),
]
Session.add_all(records)
log.info("Populate default system parameters done.")
else:
log.info("System parameters exists.")
#create default admin account
log.info("Create default admin account ...")
q = Session.query(model.DKUser)
r = q.get("sysadmin")
if not r:
user = model.DKUser()
user.username = "******"
user.roles = ":".join(["", model.ROLE_SYSADMIN, ""])
user.passwd = hashlib.md5("sysadmin").hexdigest()
user.master_email = "*****@*****.**"
user.actived = True
Session.add(user)
log.info("Admin account setup complete.")
else:
log.info("Admin account already setup.")
transaction.commit()
def includeme(config):
""" This function returns a Pyramid WSGI application.
"""
# update the settings object from the YAML application config file
settings = config.get_settings()
settings.update(c2c.template.get_config(settings.get("app.cfg")))
call_hook(settings, "after_settings", settings)
config.add_request_method(_create_get_user_from_request(settings),
name="user",
property=True)
# configure 'locale' dir as the translation dir for c2cgeoportal app
config.add_translation_dirs("c2cgeoportal:locale/")
# initialize database
engine = sqlalchemy.engine_from_config(settings, "sqlalchemy.")
sqlahelper.add_engine(engine)
config.include(pyramid_tm.includeme)
config.include("pyramid_closure")
if "sqlalchemy_slave.url" in settings and \
settings["sqlalchemy.url"] != settings["sqlalchemy_slave.url"]: # pragma: nocover
# Setup a slave DB connection and add a tween to switch between it and the default one.
log.info("Using a slave DB for reading")
engine_slave = sqlalchemy.engine_from_config(config.get_settings(),
"sqlalchemy_slave.")
sqlahelper.add_engine(engine_slave, name="slave")
config.add_tween("c2cgeoportal.models.db_chooser_tween_factory",
over="pyramid_tm.tm_tween_factory")
# initialize the dbreflection module
dbreflection.init(engine)
# dogpile.cache configuration
caching.init_region(settings["cache"])
caching.invalidate_region()
# Register a tween to get back the cache buster path.
config.add_tween("c2cgeoportal.lib.cacheversion.CachebusterTween")
# bind the mako renderer to other file extensions
add_mako_renderer(config, ".html")
add_mako_renderer(config, ".js")
config.include("pyramid_chameleon")
# add the "geojson" renderer
config.add_renderer("geojson", GeoJSON())
# add decimal json renderer
config.add_renderer("decimaljson", DecimalJSON())
# add the "xsd" renderer
config.add_renderer(
"xsd", XSD(sequence_callback=dbreflection._xsd_sequence_callback))
# 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)
if settings.get("ogcproxy_enable", False): # pragma: no cover
# add an OGCProxy view
config.add_route_predicate("ogc_server", OgcproxyRoutePredicate)
config.add_route("ogcproxy", "/ogcproxy", ogc_server=True)
config.add_view("papyrus_ogcproxy.views:ogcproxy",
route_name="ogcproxy")
# add routes to the mapserver proxy
config.add_route_predicate("mapserverproxy", MapserverproxyRoutePredicate)
config.add_route(
"mapserverproxy",
"/mapserv_proxy",
mapserverproxy=True,
pregenerator=C2CPregenerator(role=True),
)
# add route to the tinyows proxy
config.add_route(
"tinyowsproxy",
"/tinyows_proxy",
pregenerator=C2CPregenerator(role=True),
)
# add routes to csv view
config.add_route("csvecho", "/csv", request_method="POST")
# add route to the export GPX/KML view
config.add_route("exportgpxkml", "/exportgpxkml")
# add routes to the echo service
config.add_route("echo", "/echo", request_method="POST")
# 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, "/loginchange", "login")
config.add_route("loginchange", "/loginchange", 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_route("apijs", "/api.js", request_method="GET")
config.add_route("xapijs", "/xapi.js", request_method="GET")
config.add_route("apihelp", "/apihelp.html", request_method="GET")
config.add_route("xapihelp", "/xapihelp.html", request_method="GET")
config.add_route(
"themes",
"/themes",
request_method="GET",
pregenerator=C2CPregenerator(role=True),
)
config.add_route("invalidate", "/invalidate", request_method="GET")
# checker routes, Checkers are web services to test and assess that
# the application is correctly functioning.
# These web services are used by tools like (nagios).
config.add_route("checker_routes", "/checker_routes", request_method="GET")
config.add_route("checker_lang_files",
"/checker_lang_files",
request_method="GET")
config.add_route("checker_pdf3", "/checker_pdf3", request_method="GET")
config.add_route("checker_fts", "/checker_fts", request_method="GET")
config.add_route("checker_theme_errors",
"/checker_theme_errors",
request_method="GET")
config.add_route("checker_phantomjs",
"/checker_phantomjs",
request_method="GET")
# collector
config.add_route("check_collector",
"/check_collector",
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, "/fulltextsearch", "fulltextsearch")
config.add_route("fulltextsearch", "/fulltextsearch")
# Access to raster data
add_cors_route(config, "/raster", "raster")
config.add_route("raster", "/raster", request_method="GET")
add_cors_route(config, "/profile.{ext}", "profile")
config.add_route("profile.csv", "/profile.csv", request_method="POST")
config.add_route("profile.json", "/profile.json", request_method="POST")
# shortener
add_cors_route(config, "/short/create", "shortner")
config.add_route("shortener_create",
"/short/create",
request_method="POST")
config.add_route("shortener_get", "/short/{ref}", request_method="GET")
# Geometry processing
config.add_route("difference", "/difference", request_method="POST")
# PDF report tool
config.add_route("pdfreport",
"/pdfreport/{layername}/{id}",
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=JSON_CONTENT_TYPE)
config.add_route("layers_update",
"/layers/{layer_id:\\d+}/{feature_id}",
request_method="PUT",
header=JSON_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's 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")
# pyramid_formalchemy's configuration
config.include("pyramid_formalchemy")
config.include("fa.jquery")
# define the srid, schema and parentschema
# as global variables to be usable in the model
c2cgeoportal.srid = settings["srid"]
c2cgeoportal.schema = settings["schema"]
c2cgeoportal.parentschema = settings["parentschema"]
c2cgeoportal.formalchemy_default_zoom = get_setting(
settings, ("admin_interface", "map_zoom"),
c2cgeoportal.formalchemy_default_zoom)
c2cgeoportal.formalchemy_default_x = get_setting(
settings, ("admin_interface", "map_x"),
c2cgeoportal.formalchemy_default_x)
c2cgeoportal.formalchemy_default_y = get_setting(
settings, ("admin_interface", "map_y"),
c2cgeoportal.formalchemy_default_y)
c2cgeoportal.formalchemy_available_functionalities = get_setting(
settings, ("admin_interface", "available_functionalities"),
c2cgeoportal.formalchemy_available_functionalities)
c2cgeoportal.formalchemy_available_metadata = get_setting(
settings, ("admin_interface", "available_metadata"),
c2cgeoportal.formalchemy_available_metadata)
c2cgeoportal.formalchemy_available_metadata = [
e if isinstance(e, basestring) else e.get("name")
for e in c2cgeoportal.formalchemy_available_metadata
]
config.add_route("checker_all", "/checker_all", request_method="GET")
config.add_route("version_json", "/version.json", request_method="GET")
stats.init(config)
# scan view decorator for adding routes
config.scan(ignore=["c2cgeoportal.tests", "c2cgeoportal.scripts"])
if "subdomains" in settings: # pragma: no cover
config.registry.registerUtility(MultiDomainStaticURLInfo(),
IStaticURLInfo)
# add the static view (for static resources)
_add_static_view(config, "static", "c2cgeoportal:static")
_add_static_view(config, "project", "c2cgeoportal:project")
add_admin_interface(config)
add_static_view(config)
# 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)
_log_versions(settings)
import os
import oedialect # noqa pylint: disable=unused-import
from configobj import ConfigObj
from sqlalchemy import create_engine
import sqlahelper
from wam import settings # pylint: disable=import-error
# add local config file
fred_config = ConfigObj(
os.path.join(settings.BASE_DIR, 'WAM_APP_FRED', 'config', 'fred_app.cfg'))
OEP_ACCESS = fred_config['WAM_APP_FRED']['OEP_ACCESS']
LOCAL_TESTING = fred_config['WAM_APP_FRED'].as_bool('LOCAL_TESTING')
wam_config = settings.config['DATABASES'][OEP_ACCESS]
# ##########################################SQLAlchemy ENGINE#######################################
if not LOCAL_TESTING:
# db connection string for sqlalchemy-engine
if OEP_ACCESS == 'OEP':
DB_URL = '{ENGINE}://{USER}:{PASSWORD}@{HOST}:{PORT}/{NAME}'.format(
**wam_config)
elif OEP_ACCESS == 'OEP_DIALECT':
DB_URL = '{ENGINE}://{USER}:{TOKEN}@{HOST}'.format(**wam_config)
engine = create_engine(DB_URL)
sqlahelper.add_engine(engine, 'oep_engine')
# ##################################################################################################
def setUp(self):
from pyramid.config import Configurator
self.engine = sqlahelper.add_engine(url="sqlite://")
self.session = sqlahelper.get_session()()
self.config = Configurator(autocommit=True)
self.config.begin()
pgstats = {}
for pgstat in session.query(PlayerGameStat).\
filter(PlayerGameStat.game_id == game.game_id).\
all():
pgstats[pgstat.player_id] = pgstat
for pid in elo_deltas.keys():
try:
pgstats[pid].ts_delta = elo_deltas[pid]
session.add(pgstats[pid])
except:
log.debug(
"Unable to save Elo delta value for player_id {0}".format(pid))
#"""
# setup the database engine
engine = create_engine(
"postgresql+psycopg2://xonstat:xonstat@localhost:5432/xonstatdb")
sqlahelper.add_engine(engine)
initialize_db(engine)
DBSession = sessionmaker(bind=engine)
session = DBSession()
games = session.query(Game).filter(Game.game_type_cd == 'ctf').order_by(
Game.start_dt).all()
#games = session.query(Game).filter(Game.match_id == '25c731c1-0909-41bc-aea6-ec1882b34ffc').all()
for game in games:
log.debug("processing game " + str(game.game_id))
process_ratings(game, session)
session.commit()
#"""
def includeme(config):
""" This function returns a Pyramid WSGI application.
"""
# update the settings object from the YAML application config file
settings = config.get_settings()
settings.update(yaml.load(file(settings.get("app.cfg"))))
global srid
global schema
global parentschema
global formalchemy_language
global formalchemy_default_zoom
global formalchemy_default_x
global formalchemy_default_y
global formalchemy_available_functionalities
global formalchemy_available_metadata
config.add_request_method(_create_get_user_from_request(settings),
name="user",
property=True)
# configure 'locale' dir as the translation dir for c2cgeoportal app
config.add_translation_dirs("c2cgeoportal:locale/")
# initialize database
engine = sqlalchemy.engine_from_config(settings, "sqlalchemy.")
sqlahelper.add_engine(engine)
config.include(pyramid_tm.includeme)
config.include("pyramid_closure")
# initialize the dbreflection module
dbreflection.init(engine)
# dogpile.cache configuration
caching.init_region(settings["cache"])
caching.invalidate_region()
# bind the mako renderer to other file extensions
add_mako_renderer(config, ".html")
add_mako_renderer(config, ".js")
config.include("pyramid_chameleon")
# add the "geojson" renderer
config.add_renderer("geojson", GeoJSON())
# add decimal json renderer
config.add_renderer("decimaljson", DecimalJSON())
# add the "xsd" renderer
config.add_renderer(
"xsd", XSD(sequence_callback=dbreflection._xsd_sequence_callback))
# 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)
if settings.get("ogcproxy_enable", True):
# add an OGCProxy view
config.add_route("ogcproxy",
"/ogcproxy",
custom_predicates=(ogcproxy_route_predicate, ))
config.add_view("papyrus_ogcproxy.views:ogcproxy",
route_name="ogcproxy")
# add routes to the mapserver proxy
config.add_route(
"mapserverproxy",
"/mapserv_proxy",
custom_predicates=(mapserverproxy_route_predicate, ),
pregenerator=C2CPregenerator(role=True),
)
# add route to the tinyows proxy
config.add_route(
"tinyowsproxy",
"/tinyows_proxy",
pregenerator=C2CPregenerator(role=True),
)
# add routes to csv view
config.add_route("csvecho", "/csv", request_method="POST")
# add route to the export GPX/KML view
config.add_route("exportgpxkml", "/exportgpxkml")
# add routes to the echo service
config.add_route("echo", "/echo", request_method="POST")
# add routes to the entry view class
config.add_route("loginform", "/login.html", request_method="GET")
add_cors_route(config, "/login", "login")
config.add_route("login", "/login", request_method=("GET", "POST"))
add_cors_route(config, "/logout", "login")
config.add_route("logout", "/logout", request_method="GET")
add_cors_route(config, "/loginchange", "login")
config.add_route("loginchange", "/loginchange", request_method="POST")
add_cors_route(config, "/loginresetpassword", "login")
config.add_route("loginresetpassword",
"/loginresetpassword",
request_method="GET")
config.add_route("testi18n", "/testi18n.html", request_method="GET")
config.add_route("apijs", "/api.js", request_method="GET")
config.add_route("xapijs", "/xapi.js", request_method="GET")
config.add_route("apihelp", "/apihelp.html", request_method="GET")
config.add_route("xapihelp", "/xapihelp.html", request_method="GET")
config.add_route(
"themes",
"/themes",
request_method="GET",
pregenerator=C2CPregenerator(role=True),
)
config.add_route("invalidate", "/invalidate", request_method="GET")
# checker routes, Checkers are web services to test and assess that
# the application is correctly functioning.
# These web services are used by tools like (nagios).
config.add_route("checker_main", "/checker_main", request_method="GET")
config.add_route("checker_viewer", "/checker_viewer", request_method="GET")
config.add_route("checker_edit", "/checker_edit", request_method="GET")
config.add_route("checker_edit_js",
"/checker_edit_js",
request_method="GET")
config.add_route("checker_api", "/checker_api", request_method="GET")
config.add_route("checker_xapi", "/checker_xapi", request_method="GET")
config.add_route("checker_lang_files",
"/checker_lang_files",
request_method="GET")
config.add_route(
"checker_printcapabilities",
"/checker_printcapabilities",
request_method="GET",
)
config.add_route("checker_pdf", "/checker_pdf", request_method="GET")
config.add_route(
"checker_print3capabilities",
"/checker_print3capabilities",
request_method="GET",
)
config.add_route("checker_pdf3", "/checker_pdf3", request_method="GET")
config.add_route("checker_fts", "/checker_fts", request_method="GET")
config.add_route("checker_wmscapabilities",
"/checker_wmscapabilities",
request_method="GET")
config.add_route("checker_wfscapabilities",
"/checker_wfscapabilities",
request_method="GET")
config.add_route("checker_theme_errors",
"/checker_theme_errors",
request_method="GET")
# collector
config.add_route("check_collector",
"/check_collector",
request_method="GET")
# print proxy routes
config.add_route("printproxy", "/printproxy", request_method="HEAD")
config.add_route(
"printproxy_info",
"/printproxy/info.json",
request_method="GET",
pregenerator=C2CPregenerator(role=True),
)
config.add_route(
"printproxy_create",
"/printproxy/create.json",
request_method="POST",
)
config.add_route(
"printproxy_get",
"/printproxy/{file}.printout",
request_method="GET",
)
# V3
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, "/fulltextsearch", "fulltextsearch")
config.add_route("fulltextsearch", "/fulltextsearch")
# Access to raster data
add_cors_route(config, "/raster", "raster")
config.add_route("raster", "/raster", request_method="GET")
add_cors_route(config, "/profile.{ext}", "profile")
config.add_route("profile.csv", "/profile.csv", request_method="POST")
config.add_route("profile.json", "/profile.json", request_method="POST")
# shortener
config.add_route("shortener_create",
"/short/create",
request_method="POST")
config.add_route("shortener_get", "/short/{ref}", request_method="GET")
# Geometry processing
config.add_route("difference", "/difference", request_method="POST")
# PDF report tool
config.add_route("pdfreport",
"/pdfreport/{layername}/{id}",
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=JSON_CONTENT_TYPE)
config.add_route("layers_update",
"/layers/{layer_id:\\d+}/{feature_id}",
request_method="PUT",
header=JSON_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's 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")
# pyramid_formalchemy's configuration
config.include("pyramid_formalchemy")
config.include("fa.jquery")
# define the srid, schema and parentschema
# as global variables to be usable in the model
srid = settings["srid"]
schema = settings["schema"]
parentschema = settings["parentschema"]
formalchemy_default_zoom = get_setting(settings,
("admin_interface", "map_zoom"),
formalchemy_default_zoom)
formalchemy_default_x = get_setting(settings, ("admin_interface", "map_x"),
formalchemy_default_x)
formalchemy_default_y = get_setting(settings, ("admin_interface", "map_y"),
formalchemy_default_y)
formalchemy_available_functionalities = get_setting(
settings, ("admin_interface", "available_functionalities"),
formalchemy_available_functionalities)
formalchemy_available_metadata = get_setting(
settings, ("admin_interface", "available_metadata"),
formalchemy_available_metadata)
config.add_route("checker_all", "/checker_all", request_method="GET")
# scan view decorator for adding routes
config.scan(ignore="c2cgeoportal.tests")
config.registry.registerUtility(MultiDomainStaticURLInfo(), IStaticURLInfo)
# add the static view (for static resources)
_add_static_view(config, "static", "c2cgeoportal:static")
_add_static_view(config, "project", "c2cgeoportal:project")
add_admin_interface(config)
add_static_view(config)
# 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)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(
root_factory=Root,
settings=settings,
locale_negotiator=locale_negotiator,
authentication_policy=create_authentication(settings))
# overwrite print routes
config.add_route("lux_printproxy_report_create",
"/printproxy/report.{format}",
request_method="POST")
config.add_route("lux_printproxy_report_get",
"/printproxy/report/{ref}",
request_method="GET")
config.add_route("lux_printproxy_report_cancel",
"/printproxy/cancel/{ref}",
request_method="DELETE")
# mymaps routes
config.add_route("mymaps", "/mymaps", request_method="HEAD")
config.add_route("mymaps_image", "/", request_method="HEAD")
config.add_route("mymaps_getcategories",
"mymaps/categories",
request_method="GET")
config.add_route("mymaps_getmaps", "/mymaps/maps", request_method="GET")
config.add_route("mymaps_features",
"/mymaps/features/{map_id}",
request_method="GET")
config.add_route("mymaps_map_info",
"/mymaps/map_info/{map_id}",
request_method="GET")
config.add_route("mymaps_create", "/mymaps/create", request_method="POST")
config.add_route("mymaps_rate", "/mymaps/rate/{map_id}")
config.add_route("mymaps_update",
"/mymaps/update/{map_id}",
request_method="PUT")
config.add_route("mymaps_map",
"/mymaps/map/{map_id}",
request_method="GET")
config.add_route("mymaps_comment",
"/mymaps/comment/{map_id}",
request_method="POST")
config.add_route("mymaps_upload_image",
"/mymaps/upload_image",
request_method="POST")
config.add_route("mymaps_upload_symbol",
"/mymaps/upload_symbol",
request_method="POST")
config.add_route("mymaps_get_image",
"/mymaps/images/{filename}",
request_method="GET")
config.add_route("mymaps_get_symbol",
"/mymaps/symbol/{symbol_id}",
request_method="GET")
config.add_route("mymaps_get_symbols",
"/mymaps/symbols",
request_method="GET")
config.add_route("mymaps_delete",
"/mymaps/delete/{map_id}",
request_method="DELETE")
config.add_route("mymaps_delete_all_features",
"/mymaps/delete_all_features/{map_id}",
request_method="DELETE")
config.add_route("mymaps_delete_feature",
"/mymaps/delete_feature/{feature_id}",
request_method="DELETE")
config.add_route("mymaps_save_feature",
"/mymaps/save_feature/{map_id}",
request_method="POST")
config.add_route("mymaps_save_features",
"/mymaps/save_features/{map_id}",
request_method="POST")
config.add_route("mymaps_copy",
"/mymaps/copy/{map_id}",
request_method="POST")
config.add_route("exportgpxkml",
"/mymaps/exportgpxkml",
request_method="POST")
# geocoder routes
config.add_route("reverse_geocode", "/geocode/reverse")
# pag routes
config.add_route("pag_url", "/pag")
# pag routes
config.add_route("pag_report", "/pag/report/{oid}.pdf")
config.add_route("pag_files", "/pag/files/{_file}")
config.include('c2cgeoportal')
config.include('pyramid_closure')
config.add_translation_dirs('geoportailv3:locale/')
# initialize database
engines = config.get_settings()['sqlalchemy_engines']
if engines:
for engine in engines:
sqlahelper.add_engine(sqlalchemy.create_engine(engines[engine]),
name=engine)
from geoportailv3.views.authentication import ldap_user_validator, \
get_user_from_request
ldap_settings = config.get_settings()['ldap']
if ldap_settings:
config.include('pyramid_ldap')
"""Config the ldap connection.
"""
config.ldap_setup(
ldap_settings['url'],
ldap_settings['bind'],
ldap_settings['passwd'],
)
config.ldap_set_login_query(
ldap_settings['base_dn'],
filter_tmpl='(login=%(login)s)',
scope=ldap.SCOPE_SUBTREE,
)
config.set_request_property(get_user_from_request,
name='user',
reify=True)
set_user_validator(config, ldap_user_validator)
json_renderer = JSON()
json_renderer.add_adapter(datetime.date, datetime_adapter)
json_renderer.add_adapter(datetime.datetime, datetime_adapter)
json_renderer.add_adapter(Decimal, decimal_adapter)
config.add_renderer('json', json_renderer)
mail_config = config.get_settings()['turbomail']
if mail_config:
interface.start(mail_config)
# scan view decorator for adding routes
config.scan()
# add the interfaces
add_interface(config, interface_type=INTERFACE_TYPE_NGEO_CATALOGUE)
config.add_route("echocsv", "/profile/echocsv", request_method="POST")
config.add_route('getuserinfo', '/getuserinfo')
config.add_route('wms', '/ogcproxywms')
config.add_route('download_sketch', '/downloadsketch')
config.add_route('download_measurement', '/downloadmeasurement')
config.add_route('qr', '/qr')
config.add_route('getfeatureinfo', '/getfeatureinfo')
config.add_route('getpoitemplate', '/getpoitemplate')
config.add_route('getremotetemplate', '/getremotetemplate')
config.add_route('isthemeprivate', '/isthemeprivate')
return config.make_wsgi_app()
def includeme(config):
""" This function returns a Pyramid WSGI application.
"""
settings = config.get_settings()
yaml_config = yaml.load(file(settings.get("app.cfg")))
settings.update(yaml_config)
my_session_factory = SignedCookieSessionFactory(
yaml_config['authtkt_secret'],
cookie_name=yaml_config['authtkt_cookie_name'],
timeout=8200
)
config.set_session_factory(my_session_factory)
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
global db_config
db_config = yaml.load(file(settings.get('database.cfg')))['db_config']
settings.update(yaml.load(file(settings.get('pdf.cfg'))))
config.include(papyrus.includeme)
config.include('pyramid_mako')
# bind the mako renderer to other file extensions
add_mako_renderer(config, ".js")
config.add_renderer('geojson', GeoJSON())
# add app configuration from db
read_app_config(settings)
specific_tmp_path = os.path.join(settings['specific_root_dir'], 'templates')
specific_static_path = os.path.join(settings['specific_root_dir'], 'static')
settings.setdefault('mako.directories',['crdppf:templates', specific_tmp_path])
settings.setdefault('reload_templates',True)
# add the static view (for static resources)
config.add_static_view('static', 'crdppf:static',cache_max_age=3600)
config.add_static_view('proj', 'crdppfportal:static', cache_max_age=3600)
# ROUTES
config.add_route('home', '/')
config.add_route('images', '/static/images/')
config.add_route('create_extract', 'create_extract')
config.add_route('get_features', 'get_features')
config.add_route('get_property', 'property/get')
config.add_route('set_language', 'set_language')
config.add_route('get_language', 'get_language')
config.add_route('get_translation_dictionary', 'get_translation_dictionary')
config.add_route('get_translations_list', 'get_translations_list')
config.add_route('get_interface_config', 'get_interface_config')
config.add_route('get_baselayers_config', 'get_baselayers_config')
config.add_route('test', 'test')
config.add_route('formulaire_reglements', 'formulaire_reglements')
config.add_route('getTownList', 'getTownList')
config.add_route('getTopicsList', 'getTopicsList')
config.add_route('createNewDocEntry', 'createNewDocEntry')
config.add_route('document_ref', 'getDocumentReferences')
config.add_route('legal_documents', 'getLegalDocuments')
config.add_route('map', 'map')
config.add_route('configpanel', 'configpanel')
config.add_route('initjs', '/init.js')
config.add_route('globalsjs', '/globals.js')
config.add_route('ogcproxy', '/ogcproxy')
# CLIENT VIEWS
config.add_view('crdppf.views.entry.Entry', route_name = 'images')
config.add_view('crdppf.views.entry.Entry', route_name='test')
# Print proxy routes
config.add_route('printproxy_report_get', '/printproxy/report/{ref}')
config.add_route('printproxy_status', '/printproxy/status/{ref}.json')
config.add_route('printproxy_report_create', '/printproxy/report/{type_}/{id}')
#~ # ADMIN VIEWS
#~ config.add_view('crdppf.views.administration.Config', route_name='configpanel')
#~ config.add_view('crdppf.views.administration.Config', route_name='formulaire_reglements')
config.add_route('catchall_static', '/*subpath')
config.add_view('crdppf.static.static_view', route_name='catchall_static')
config.scan()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# setup the database engine
engine = engine_from_config(settings, 'sqlalchemy.', pool_size=5)
sqlahelper.add_engine(engine)
# initialize database structures
initialize_db(engine)
# set up beaker cache
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=ACLFactory)
# mako for templating
config.include('pyramid_mako')
# Mozilla Persona as the login verifier. It defines default
# authentication and authorization policies.
config.include('pyramid_persona')
# override the authn policy to provide a callback
secret = settings.get('persona.secret', None)
authn_policy = AuthTktAuthenticationPolicy(secret,
callback=groupfinder,
hashalg='sha512')
config.set_authentication_policy(authn_policy)
# for json-encoded responses
config.add_renderer('jsonp', JSONP(param_name='callback'))
# for static assets
config.add_static_view('static', 'xonstat:static')
# robots
config.add_route("robots", "robots.txt")
config.add_view(robots, route_name="robots")
# for 404s
config.add_view(notfound, context=HTTPNotFound, renderer="404.mako")
# ROOT ROUTE
config.add_route("main_index", "/")
config.add_view(main_index,
route_name="main_index",
renderer="main_index.mako")
# MAIN SUBMISSION ROUTE
config.add_route("submit_stats", "stats/submit")
config.add_view(submit_stats, route_name="submit_stats")
# PLAYER ROUTES
config.add_route("player_game_index", "/player/{player_id:\d+}/games")
config.add_view(player_game_index,
route_name="player_game_index",
renderer="player_game_index.mako")
config.add_route("player_game_index_json",
"/player/{player_id:\d+}/games.json")
config.add_view(player_game_index_json,
route_name="player_game_index_json",
renderer="jsonp")
config.add_route("player_info", "/player/{id:\d+}")
config.add_view(player_info,
route_name="player_info",
renderer="player_info.mako")
config.add_route("player_info_json", "/player/{id:\d+}.json")
config.add_view(player_info_json,
route_name="player_info_json",
renderer="jsonp")
config.add_route("player_hashkey_info_text", "/player/me")
config.add_view(player_hashkey_info_text,
route_name="player_hashkey_info_text",
renderer="player_hashkey_info_text.mako")
config.add_route("player_hashkey_info_json", "/player/me.json")
config.add_view(player_hashkey_info_json,
route_name="player_hashkey_info_json",
renderer="jsonp")
config.add_route("player_elo_info_text", "/player/{hashkey}/elo.txt")
config.add_view(player_elo_info_text,
route_name="player_elo_info_text",
renderer="player_elo_info_text.mako")
config.add_route("players_elo", "/elo/{hashkeys}")
config.add_view(players_elo, route_name="players_elo", renderer="jsonp")
# FIXME - needs an additional method to convert to JSON
config.add_route("player_elo_info_json", "/player/{hashkey}/elo.json")
config.add_view(player_elo_info_json,
route_name="player_elo_info_json",
renderer="jsonp")
config.add_route("player_accuracy", "/player/{id:\d+}/accuracy")
config.add_view(player_accuracy_json,
route_name="player_accuracy",
renderer="jsonp")
config.add_route("player_index", "/players")
config.add_view(player_index,
route_name="player_index",
renderer="player_index.mako")
config.add_route("player_index_json", "/players.json")
config.add_view(player_index_json,
route_name="player_index_json",
renderer="jsonp")
config.add_route("player_captimes", "/player/{player_id:\d+}/captimes")
config.add_view(player_captimes,
route_name="player_captimes",
renderer="player_captimes.mako")
config.add_route("player_captimes_json",
"/player/{player_id:\d+}/captimes.json")
config.add_view(player_captimes_json,
route_name="player_captimes_json",
renderer="jsonp")
config.add_route("player_weaponstats_data_json",
"/player/{id:\d+}/weaponstats.json")
config.add_view(player_weaponstats_data_json,
route_name="player_weaponstats_data_json",
renderer="jsonp")
config.add_route("top_players_by_time", "/topactive")
config.add_view(top_players_by_time,
route_name="top_players_by_time",
renderer="top_players_by_time.mako")
config.add_route("top_servers_by_players", "/topservers")
config.add_view(top_servers_by_players,
route_name="top_servers_by_players",
renderer="top_servers_by_players.mako")
config.add_route("top_maps_by_times_played", "/topmaps")
config.add_view(top_maps_by_times_played,
route_name="top_maps_by_times_played",
renderer="top_maps_by_times_played.mako")
# GAME ROUTES
config.add_route("game_info", "/game/{id:\d+}")
config.add_view(game_info,
route_name="game_info",
renderer="game_info.mako")
config.add_route("game_info_json", "/game/{id:\d+}.json")
config.add_view(game_info_json,
route_name="game_info_json",
renderer="jsonp")
config.add_route("rank_index",
"/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race}")
config.add_view(rank_index,
route_name="rank_index",
renderer="rank_index.mako")
config.add_route("rank_index_json",
"/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race}.json")
config.add_view(rank_index_json,
route_name="rank_index_json",
renderer="jsonp")
config.add_route("game_index", "/games")
config.add_view(game_finder,
route_name="game_index",
renderer="game_finder.mako")
# SERVER ROUTES
config.add_route("server_index", "/servers")
config.add_view(server_index,
route_name="server_index",
renderer="server_index.mako")
config.add_route("server_index_json", "/servers.json")
config.add_view(server_index_json,
route_name="server_index_json",
renderer="jsonp")
config.add_route("server_game_index",
"/server/{server_id:\d+}/games/page/{page:\d+}")
config.add_view(server_game_index,
route_name="server_game_index",
renderer="server_game_index.mako")
config.add_route("server_game_index_json",
"/server/{server_id:\d+}/games.json")
config.add_view(server_game_index_json,
route_name="server_game_index_json",
renderer="jsonp")
config.add_route("server_info", "/server/{id:\d+}")
config.add_view(server_info,
route_name="server_info",
renderer="server_info.mako")
config.add_route("server_info_json", "/server/{id:\d+}.json")
config.add_view(server_info_json,
route_name="server_info_json",
renderer="jsonp")
# MAP ROUTES
config.add_route("map_index", "/maps")
config.add_view(map_index,
route_name="map_index",
renderer="map_index.mako")
config.add_route("map_index_json", "/maps.json")
config.add_view(map_index_json,
route_name="map_index_json",
renderer="jsonp")
config.add_route("map_info", "/map/{id:\d+}")
config.add_view(map_info, route_name="map_info", renderer="map_info.mako")
config.add_route("map_info_json", "/map/{id:\d+}.json")
config.add_view(map_info_json,
route_name="map_info_json",
renderer="jsonp")
config.add_route("map_captimes", "/map/{id:\d+}/captimes")
config.add_view(map_captimes,
route_name="map_captimes",
renderer="map_captimes.mako")
config.add_route("map_captimes_json", "/map/{id:\d+}/captimes.json")
config.add_view(map_captimes_json,
route_name="map_captimes_json",
renderer="jsonp")
# SEARCH ROUTES
config.add_route("search", "search")
config.add_view(search, route_name="search", renderer="search.mako")
config.add_route("search_json", "search.json")
config.add_view(search_json, route_name="search_json", renderer="jsonp")
# ADMIN ROUTES
config.add_forbidden_view(forbidden, renderer="forbidden.mako")
config.add_route("login", "/login")
config.add_view(login,
route_name="login",
check_csrf=True,
renderer="json")
config.add_route("merge", "/admin/merge")
config.add_view(merge,
route_name="merge",
renderer="merge.mako",
permission="merge")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.scan('raggregate.models')
engine = engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
initialize_sql(engine)
session_factory = pyramid_beaker.session_factory_from_settings(settings)
template_static_asset = "{0}/static".format(settings['mako.directories'])
settings['template_static_asset'] = template_static_asset
config = Configurator(settings=settings)
config.include('pyramid_tm')
if 'solr.address' in settings:
import sunburnt
solr_conn = sunburnt.SolrInterface(settings['solr.address'])
config.registry.solr_conn = solr_conn
if 'twitter.app_key' in settings and 'twitter.app_secret' in settings:
from twython import Twython
app_twit = Twython(settings['twitter.app_key'],
settings['twitter.app_secret'])
config.registry.app_twit = app_twit
config.set_session_factory(session_factory)
# @TODO: the name "mako.directories" implies this could be a list
# right now we don't care. Someone should fix this.
config.add_static_view('static', template_static_asset)
config.add_static_view('user_imgs', settings['user.picture_upload_package'])
config.add_static_view('section_imgs', settings['section.picture_upload_package'])
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('list', '/list')
config.add_route('post', '/post')
config.add_route('new_page', '/new_page')
config.add_route('new_post', '/new_post')
config.add_route('ban', '/ban')
config.add_route('vote', '/vote/{way}')
config.add_route('full', '/full/{sub_id}')
config.add_route('epistle', '/messages/{box}')
config.add_route('follow', '/follow')
config.add_route('save', '/save')
config.add_route('notify', '/notify')
config.add_route('search', '/search')
config.add_route('twit_sign', '/twit_sign')
config.add_route('user_info', '/user_info')
config.add_route('user_preferences', '/user_preferences')
config.add_route('buttons', '/buttons')
config.add_route('favicon', '/favicon.ico')
config.add_route('atom_story', '/atom_story.xml')
config.add_route('atom_self_story', '/atom_self_story.xml')
config.add_route('atom_combined', '/atom_combined.xml')
config.add_route('atom_comment', '/atom_comment.xml')
config.add_route('section', '/section')
config.add_route('motd', '/motd')
config.add_route('sublist', '/sublist/{sub_title}')
config.add_route('sublistc', '/sublist_create')
config.add_route('lost_password', '/lost_password')
config.add_subscriber(subscribers.ban, NewResponse)
config.add_subscriber(subscribers.user_session_handler, BeforeRender)
config.add_subscriber(subscribers.clear_per_request_session, NewRequest)
config.add_subscriber(subscribers.clean_inputs, NewRequest)
config.scan('raggregate.views')
pyramid_beaker.set_cache_regions_from_settings(settings)
return config.make_wsgi_app()
def includeme(config):
""" This function returns a Pyramid WSGI application.
"""
# update the settings object from the YAML application config file
settings = config.get_settings()
settings.update(yaml.load(file(settings.get('app.cfg'))))
global srid
global schema
global parentschema
global formalchemy_language
global formalchemy_default_zoom
global formalchemy_default_x
global formalchemy_default_y
global formalchemy_available_functionalities
config.set_request_property(
get_user_from_request, name='user', reify=True)
# configure 'locale' dir as the translation dir for c2cgeoportal app
config.add_translation_dirs('c2cgeoportal:locale/')
# initialize database
engine = sqlalchemy.engine_from_config(
config.get_settings(),
'sqlalchemy.')
sqlahelper.add_engine(engine)
config.include(pyramid_tm.includeme)
# initialize the dbreflection module
dbreflection.init(engine)
# dogpile.cache configuration
caching.init_region(settings['cache'])
caching.invalidate_region()
# bind the mako renderer to other file extensions
config.add_renderer('.html', mako_renderer_factory)
config.add_renderer('.js', mako_renderer_factory)
# add the "geojson" renderer
config.add_renderer('geojson', GeoJSON())
# add decimal json renderer
config.add_renderer('decimaljson', DecimalJSON())
# add the "xsd" renderer
config.add_renderer('xsd', XSD(
sequence_callback=dbreflection._xsd_sequence_callback))
# 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)
# add an OGCProxy view
config.add_route(
'ogcproxy', '/ogcproxy',
custom_predicates=(ogcproxy_route_predicate,))
config.add_view('papyrus_ogcproxy.views:ogcproxy', route_name='ogcproxy')
# add routes to the mapserver proxy
config.add_route(
'mapserverproxy', '/mapserv_proxy',
custom_predicates=(mapserverproxy_route_predicate,),
pregenerator=MultiDomainPregenerator())
# add routes to csv view
config.add_route('csvecho', '/csv')
# add routes to the echo service
config.add_route('echo', '/echo')
# add routes to the entry view class
config.add_route('home', '/')
config.add_route('viewer', '/viewer.js')
config.add_route('edit', '/edit')
config.add_route('edit.js', '/edit.js')
config.add_route('routing', '/routing')
config.add_route('routing.js', '/routing.js')
config.add_route('loginform', '/login.html')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('loginchange', '/loginchange')
config.add_route('testi18n', '/testi18n.html')
config.add_route('apijs', '/api.js')
config.add_route('xapijs', '/xapi.js')
config.add_route('apihelp', '/apihelp.html')
config.add_route('xapihelp', '/xapihelp.html')
config.add_route('themes', '/themes')
# permalink theme: recover the theme for generating custom viewer.js url
config.add_route('permalinktheme', '/theme/*themes')
# checker routes, Checkers are web services to test and assess that
# the application is correctly functioning.
# These web services are used by tools like (nagios).
config.add_route('checker_main', '/checker_main')
config.add_route('checker_viewer', '/checker_viewer')
config.add_route('checker_edit', '/checker_edit')
config.add_route('checker_edit_js', '/checker_edit_js')
config.add_route('checker_api', '/checker_api')
config.add_route('checker_xapi', '/checker_xapi')
config.add_route('checker_printcapabilities', '/checker_printcapabilities')
config.add_route('checker_pdf', '/checker_pdf')
config.add_route('checker_fts', '/checker_fts')
config.add_route('checker_wmscapabilities', '/checker_wmscapabilities')
config.add_route('checker_wfscapabilities', '/checker_wfscapabilities')
# collector
config.add_route('check_collector', '/check_collector')
# print proxy routes
config.add_route('printproxy', '/printproxy')
config.add_route('printproxy_info', '/printproxy/info.json')
config.add_route('printproxy_create', '/printproxy/create.json')
config.add_route('printproxy_get', '/printproxy/{file}.printout')
# full text search routes
config.add_route('fulltextsearch', '/fulltextsearch')
# Access to raster data
config.add_route('raster', '/raster')
config.add_route('profile.csv', '/profile.csv')
config.add_route('profile.json', '/profile.json')
# shortener
config.add_route('shortener_create', '/short/create')
config.add_route('shortener_get', '/short/{ref}')
# add routes for the "layers" web service
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')
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')
config.add_route(
'layers_update', '/layers/{layer_id:\\d+}/{feature_id}',
request_method='PUT')
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')
# there's 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/')
# pyramid_formalchemy's configuration
config.include('pyramid_formalchemy')
config.include('fa.jquery')
# define the srid, schema and parentschema
# as global variables to be usable in the model
srid = config.get_settings()['srid']
schema = config.get_settings()['schema']
parentschema = config.get_settings()['parentschema']
settings = config.get_settings()
formalchemy_default_zoom = get_setting(
settings,
('admin_interface', 'map_zoom'), formalchemy_default_zoom)
formalchemy_default_x = get_setting(
settings,
('admin_interface', 'map_x'), formalchemy_default_x)
formalchemy_default_y = get_setting(
settings,
('admin_interface', 'map_y'), formalchemy_default_y)
formalchemy_available_functionalities = get_setting(
settings,
('admin_interface', 'available_functionalities'),
formalchemy_available_functionalities)
# scan view decorator for adding routes
config.scan(ignore='c2cgeoportal.tests')
config.registry.registerUtility(
MultiDomainStaticURLInfo(), IStaticURLInfo)
# add the static view (for static resources)
config.add_static_view(
'static', 'c2cgeoportal:static',
cache_max_age=int(settings["default_max_age"])
)
def test_one_engine(self):
e = sa.create_engine(self.db1.url)
sqlahelper.add_engine(e)
retrieved = sqlahelper.get_engine()
self.assertIs(retrieved, e)
