def test_session_in_db(self):
request.app_name = "myapp"
db = DAL("sqlite:memory")
session = Session(secret="a", expiration=10, storage=DBStore(db))
request.cookies.clear()
session.on_request()
session["key"] = "value"
cookie_name = session.local.session_cookie_name
session.on_success(200)
a, b = str(
response._cookies)[len("Set-Cookie: "):].split(";")[0].split(
"=", 1)
request.cookies[a] = b
session.finalize()
self.assertIsNone(session.local)
session = Session(expiration=10, storage=DBStore(db))
request.cookies[a] = b
session.on_request()
self.assertEqual(session.get("key"), "value")
session = Session(expiration=10, storage=DBStore(db))
request.cookies[a] = "wrong_cookie"
session.on_request()
self.assertEqual(session.get("key"), None)
def test_session_in_db(self):
request.app_name = 'myapp'
db = DAL('sqlite:memory')
session = Session(secret="a", expiration=10, storage=DBStore(db))
request.cookies.clear()
session.on_request()
session['key'] = 'value'
session.on_success()
cookie_name = session.local.session_cookie_name
a, b = str(
response._cookies)[len('Set-Cookie: '):].split(';')[0].split(
'=', 1)
request.cookies[a] = b
request.cookies = response._cookies
session.local.data.clear()
session = Session(expiration=10, storage=DBStore(db))
session.on_request()
self.assertEqual(session.get('key'), 'value')
request.cookies[a] = 'wrong_cookie'
session = Session(expiration=10, storage=DBStore(db))
session.on_request()
self.assertEqual(session.get('key'), None)
def test_session_in_db(self):
request.app_name = "myapp"
db = DAL("sqlite:memory")
session = Session(secret="a", expiration=10, storage=DBStore(db))
request.cookies.clear()
session.on_request()
session["key"] = "value"
cookie_name = session.local.session_cookie_name
session.on_success(200)
a, b = str(
response._cookies)[len("Set-Cookie: "):].split(";")[0].split(
"=", 1)
request.cookies[a] = b
_before_request()
with pytest.raises(RuntimeError) as err:
session.local
self.assertTrue('py4web hint' in str(err.value))
session = Session(expiration=10, storage=DBStore(db))
request.cookies[a] = b
session.on_request()
self.assertEqual(session.get("key"), "value")
session = Session(expiration=10, storage=DBStore(db))
request.cookies[a] = "wrong_cookie"
session.on_request()
self.assertEqual(session.get("key"), None)
"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s")
for item in settings.LOGGERS:
level, filename = item.split(":", 1)
if filename in ("stdout", "stderr"):
handler = logging.StreamHandler(getattr(sys, filename))
else:
handler = logging.FileHandler(filename)
handler.setFormatter(formatter)
logger.setLevel(getattr(logging, level.upper(), "DEBUG"))
logger.addHandler(handler)
# connect to db
db = DAL(
settings.DB_URI,
folder=settings.DB_FOLDER,
pool_size=settings.DB_POOL_SIZE,
migrate=settings.DB_MIGRATE,
fake_migrate=settings.DB_FAKE_MIGRATE,
)
# define global objects that may or may not be used by th actions
cache = Cache(size=1000)
T = Translator(settings.T_FOLDER)
flash = Flash()
# pick the session type that suits you best
if settings.SESSION_TYPE == "cookies":
session = Session(secret=settings.SESSION_SECRET_KEY)
elif settings.SESSION_TYPE == "redis":
import redis
logger = logging.getLogger("geopbf")
formatter = logging.Formatter(
"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s")
for item in settings.LOGGERS:
level, filename = item.split(":", 1)
if filename in ("stdout", "stderr"):
handler = logging.StreamHandler(getattr(sys, filename))
else:
handler = logging.FileHandler(filename)
handler.setFormatter(formatter)
logger.setLevel(getattr(logging, level.upper(), "DEBUG"))
logger.addHandler(handler)
if hasattr(settings, 'DB_URI') and not settings.DB_URI is None:
from py4web import DAL
db = DAL(settings.DB_URI,
folder=settings.DB_FOLDER,
pool_size=1 if not hasattr(settings, 'DB_POOL_SIZE') else
settings.DB_POOL_SIZE,
migrate=hasattr(settings, 'DB_MIGRATE') and settings.DB_MIGRATE,
fake_migrate=hasattr(settings, 'DB_FAKE_MIGRATE')
and settings.DB_FAKE_MIGRATE,
lazy_tables=False,
check_reserved=False)
else:
db = None
"""
This file defines cache, session, and translator T object for the app
These are fixtures that every app needs so probably you will not be editing this file
"""
import os
from py4web import Session, Cache, Translator, DAL, Field
from py4web.utils.auth import Auth
from py4web.utils.tags import Tags
from py4web.utils.factories import ActionFactory
from py4web.utils.url_signer import URLSigner
from . import settings
db = DAL(settings.DB_URI,
folder=settings.DB_FOLDER,
pool_size=settings.DB_POOL_SIZE)
# define global objects that may or may not be used by th actions
cache = Cache(size=1000)
T = Translator(settings.T_FOLDER)
# pick the session type that suits you best
if settings.SESSION_TYPE == 'cookies':
session = Session(secret=settings.SESSION_SECRET_KEY)
elif settings.SESSION_TYPE == 'redis':
import redis
host, port = settings.REDIS_SERVER.split(':')
# for more options: https://github.com/andymccurdy/redis-py/blob/master/redis/client.py
conn = redis.Redis(host=host, port=int(port))
conn.set = lambda k, v, e, cs=conn.set, ct=conn.ttl: (cs(k, v), e and ct(e)
)
session = Session(secret=settings.SESSION_SECRET_KEY, storage=conn)
import copy
import multiprocessing
import os
import time
import unittest
import uuid
import mechanize
from py4web import action, DAL, Field, Session, Cache
from py4web.core import bottle, request, error404
os.environ["PY4WEB_APPS_FOLDER"] = os.path.sep.join(
os.path.normpath(__file__).split(os.path.sep)[:-2])
db = DAL("sqlite://storage_%s" % uuid.uuid4(), folder="/tmp/")
db.define_table("thing", Field("name"))
session = Session(secret="my secret")
cache = Cache()
action.app_name = "tests"
@action("index")
@cache.memoize(expiration=1)
@action.uses(db, session)
@action.requires(lambda: True)
def index():
db.thing.insert(name="test")
session["number"] = session.get("number", 0) + 1
formatter = logging.Formatter(
"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s")
for item in settings.LOGGERS:
level, filename = item.split(":", 1)
if filename in ("stdout", "stderr"):
handler = logging.StreamHandler(getattr(sys, filename))
else:
handler = logging.FileHandler(filename)
handler.setLevel(getattr(logging, level.upper(), "ERROR"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# connect to db
db = DAL(
settings.DB_URI,
folder=settings.DB_FOLDER,
pool_size=settings.DB_POOL_SIZE,
migrate_enabled=True,
)
# define global objects that may or may not be used by th actions
cache = Cache(size=1000)
T = Translator(settings.T_FOLDER)
# pick the session type that suits you best
if settings.SESSION_TYPE == "cookies":
session = Session(secret=settings.SESSION_SECRET_KEY)
elif settings.SESSION_TYPE == "redis":
import redis
host, port = settings.REDIS_SERVER.split(":")
# for more options: https://github.com/andymccurdy/redis-py/blob/master/redis/client.py
import os
from py4web import action, request, DAL, Field, Session, Cache, user_in
# define session and cache objects
session = Session(secret="some secret")
cache = Cache(size=1000)
# define database and tables
db = DAL("sqlite://storage.db",
folder=os.path.join(os.path.dirname(__file__), "databases"))
db.define_table("todo", Field("info"))
db.commit()
# example index page using session, template and vue.js
@action("index") # the function below is exposed as a GET action
@action.uses("index.html") # we use the template index.html to render it
@action.uses(session) # action needs a session object (read/write cookies)
def index():
session["counter"] = session.get("counter", 0) + 1
session["user"] = {"id": 1} # store a user in session
return dict(session=session)
# example of GET/POST/DELETE RESTful APIs
@action("api") # a GET API function
@action.uses(session) # we load the session
@action.requires(user_in(session)
) # then check we have a valid user in session
# -*- coding: utf-8 -*-
import os
from . import settings
from ..planetstore.common import logger
try:
from ..planetstore.models import db
except ImportError:
raise
from py4web import DAL
# connect to db
db = DAL(settings.DB_URI,
folder=settings.DB_FOLDER,
pool_size=settings.DB_POOL_SIZE,
lazy_tables=False,
migrate=False,
fake_migrate=False,
check_reserved=False)
from geopbf import settings as gpbfsettings
if hasattr(gpbfsettings, "SHARE_DB") and gpbfsettings.SHARE_DB:
from geopbf.pbfpp import common as pbfcommon
pbfcommon.db = db
from geopbf.pbfpp import Prototizerpp as PbfPrototizer
from kilimanjaro.frameworks.py4web.controller import WebWrapper
webWrapper = WebWrapper()
pbfWebWrapper = PbfPrototizer()
import os
from py4web import DAL, Field
# define database and tables
db = DAL('sqlite://storage.db', folder=os.path.join(os.path.dirname(__file__), 'databases'))
db.define_table(
'person',
Field('name'),
Field('job'))
db.define_table(
'superhero',
Field('name'),
Field('real_identity', 'reference person'))
db.define_table(
'superpower',
Field('description'))
db.define_table(
'tag',
Field('superhero', 'reference superhero'),
Field('superpower', 'reference superpower'),
Field('strength', 'integer'))
if not db(db.person).count():
db.person.insert(name='Clark Kent', job='Journalist')
db.person.insert(name='Peter Park', job='Photographer')
db.person.insert(name='Bruce Wayne', job='CEO')
db.superhero.insert(name='Superman', real_identity=1)
import multiprocessing
import os
import time
import unittest
import uuid
import mechanize
from py4web import action, DAL, Field, Session, Cache
from py4web.core import bottle, request, error404
os.environ['PY4WEB_APPS_FOLDER'] = os.path.sep.join(
os.path.normpath(__file__).split(os.path.sep)[:-2])
db = DAL('sqlite://storage_%s' % uuid.uuid4(), folder='/tmp/')
db.define_table('thing', Field('name'))
session = Session(secret='my secret')
cache = Cache()
action.app_name = 'tests'
@action('index')
@cache.memoize(expiration=1)
@action.uses(db, session)
@action.requires(lambda: True)
def index():
db.thing.insert(name='test')
session['number'] = session.get('number', 0) + 1
return 'ok %s %s' % (session['number'], db(db.thing).count())
import os
from py4web import action, request, DAL, Field, Session, Cache, user_in
# define session and cache objects
session = Session(secret='some secret')
cache = Cache(size=1000)
# define database and tables
db = DAL('sqlite://storage.db',
folder=os.path.join(os.path.dirname(__file__), 'databases'))
db.define_table('todo', Field('info'))
# example index page using session, template and vue.js
@action('index') # the function below is exposed as a GET action
@action.uses('index.html') # we use the template index.html to render it
@action.uses(session) # action needs a session object (read/write cookies)
def index():
session['counter'] = session.get('counter', 0) + 1
session['user'] = {'id': 1} # store a user in session
return dict(session=session)
# example of GET/POST/DELETE RESTful APIs
@action('api') # a GET API function
@action.uses(session) # we load the session
@action.requires(user_in(session)
) # then check we have a valid user in session
@action.uses(db) # all before starting a db connection
"""
This file defines cache, session, and translator T object for the app
These are fixtures that every app needs so probably you will not be editing this file
"""
import os
from py4web import Session, Cache, Translator, DAL, Field
from py4web.utils.auth import Auth
from py4web.utils.tags import Tags
from py4web.utils.factories import ActionFactory
from py4web.utils.url_signer import URLSigner
from . import settings
if os.environ.get("GAE_ENV"):
# We are on appengine
db = DAL(settings.GAE_DB_URI,
migrate_enabled=False,
pool_size=settings.DB_POOL_SIZE)
else:
# From Localhost
db = DAL(settings.TESTING_DB_URI,
folder=settings.DB_FOLDER,
pool_size=settings.DB_POOL_SIZE)
# define global objects that may or may not be used by th actions
cache = Cache(size=1000)
T = Translator(settings.T_FOLDER)
# pick the session type that suits you best
if settings.SESSION_TYPE == 'cookies':
session = Session(secret=settings.SESSION_SECRET_KEY)
elif settings.SESSION_TYPE == 'redis':
