def process(self, *args, **data):
"""Process method parameters
This style of calling collections is useful when you want to
make your collection available as an attribute of a Dispatcher.
"""
route = args
request = context.request
self.user = request.user
self.request = request
self.route = route
logger = logging.getLogger(__name__)
logger.debug('Collection process called')
if self.store is None:
if self.model is None:
self.model = CollectionModel
self.model.collection_url = self.url
self.store = EntityStore(
request.site.db,
self.model,
self.item_name + '_collection'
)
else:
self.store = EntityStore(
request.site.db,
self.model,
)
return (
self.controller(self)(*route, **request.data) or
self.view(self)(*route, **request.data)
)
def handle(self, route, request):
"""handle a request"""
self.user = request.user
self.request = request
self.route = route
logger = logging.getLogger(__name__)
logger.debug('Collection handler called')
if self.store is None:
if self.model is None:
self.model = CollectionModel
self.model.collection_url = self.url
self.store = EntityStore(
request.site.db,
self.model,
self.item_name + '_collection'
)
else:
self.store = EntityStore(
request.site.db,
self.model,
)
return (
self.controller(self)(*route, **request.data) or
self.view(self)(*route, **request.data)
)
def handle(self, route, request):
"""handle a request"""
def get_model(url):
class CustomCollectionModel(CollectionModel):
url = property(lambda self: '/'.join([url, self.key]))
return CustomCollectionModel
logger = logging.getLogger(__name__)
logger.debug('Collection handler called')
# store some handy references in case the View
# or Controller need them.
self.user = request.user
self.request = request
self.route = route
self.store = self.store or (EntityStore(
request.site.db,
self.model or get_model(self.url),
self.item_name + '_collection',
))
return (self.controller(self)(*route, **request.data)
or self.view(self)(*route, **request.data))
def setUp(self):
self.db = setup_test()
self.db.autocommit(1)
self.people = EntityStore(self.db, Person)
self.joe_id = self.people.put(Person(name='Joe', age=50))
self.sam_id = self.people.put(Person(name='Sam', age=25))
self.people.put(Person(name='Ann', age=30))
self.id_name = '_id'
def entity(self, name):
items = EntityStore(self.model.site.db, MyModel, kind=name)
if len(items) == 1:
footer_name = 'record'
else:
footer_name = 'records'
footer = len(items) and '%s %s' % (len(items), footer_name) or ''
return page(browse(items, footer=footer), title='Entity: ' + name)
def topics(self):
cmd = """
select distinct value
from attributes
where kind=%s and attribute="topic"
order by value
"""
kind = EntityStore(self.db, Message).kind
return [a for a, in self.db(cmd, kind)]
def stats(self):
cmd = """
select value, count(*) as count
from attributes
where kind=%s and attribute="topic"
group by value
"""
kind = EntityStore(self.db, Message).kind
return self.db(cmd, kind)
def entity(self, name, limit=20):
items = EntityStore(self.model.site.db, MyModel, kind=name)
limit = int(limit)
count = len(items)
if count == 1:
footer_name = 'record'
else:
footer_name = 'records'
footer = count and '%s %s' % (count, footer_name) or ''
if count > limit:
items = items[-limit:] # most recent 100
return page(browse(items, footer=footer), title='Entity: ' + name)
def setUp(self):
params = dict(
host='database',
user='******',
passwd='password',
db='test',
)
self.db = Database(MySQLdb.Connect, **params)
self.db.autocommit(1)
self.people = EntityStore(self.db, Person)
self.joe_id = self.people.put(Person(name='Joe', age=50))
self.sam_id = self.people.put(Person(name='Sam', age=25))
self.people.put(Person(name='Ann', age=30))
def __init__(self, name, newest=None, db=None):
self.name = name
self.db = db
self.messages = EntityStore(db, Message)
self.newest = newest is not None and newest or self.last() or -1
def __str__(self):
return str(EntityStore(self.db, Message))
def clear(self):
return EntityStore(self.db, Message).zap()
def get_tokens():
return EntityStore(context.site.db, ForgotToken)
def test_empty(self):
empty_store = EntityStore(self.db, 'none_of_these')
self.assertEqual(type(empty_store.all()), EntityList)
self.assertEqual(str(empty_store), 'Empty list')
def setup(self,
instance_path=None,
server=request.server,
timer=SystemTimer(timeit.default_timer())):
"""set up the system"""
if instance_path is None:
instance_path = Instance('system').path
self.debugging = True
self.timer = timer
self.start_time = timer.start_time
self.lib_path = os.path.split(os.path.abspath(__file__))[0]
if not os.path.exists(os.path.join(instance_path, 'dz.conf')):
msg = 'instance missing %s' % os.path.abspath(instance_path)
raise Exception(msg)
self.instance_path = os.path.abspath(instance_path)
if '.' not in sys.path:
sys.path.insert(0, '.')
# system config file
self.config = config = cfg.Config(instance_path, server)
# connect to the database and stores
db_engine = config.get('database', 'engine', 'mysql')
db_host = config.get('database', 'dbhost', 'database')
db_name = config.get('database', 'dbname', 'zoomdev')
db_user = config.get('database', 'dbuser', 'testuser')
db_pass = config.get('database', 'dbpass', 'password')
# legacy database module
self.database = old_database(
db_engine,
db_host,
db_name,
db_user,
db_pass,
)
# database module
db_params = dict(
engine=db_engine,
host=db_host,
db=db_name,
user=db_user,
)
if db_pass:
db_params['passwd'] = db_pass
# pylint: disable=invalid-name, star-args
self.db = new_db(**db_params)
self.db_debug = config.get('database', 'debug', '0') not in NEGATIVE
self.db.debug = self.db_debug
self.database.debug = self.db_debug
# message queues
from zoom.queues import Queues
self.queues = Queues(self.db)
from zoom.store import EntityStore
settings_store = EntityStore(self.database, settings.SystemSettings)
self.settings = settings.Settings(settings_store, config, 'system')
if not os.path.exists(config.sites_path):
raise Exception('sites missing %s' % config.sites_path)
self.debugging = config.get('errors', 'debugging', '0') == '1'
self.request = request
self.server = server
self.server_name = server # deprecated
# get current site directory
self.root = request.instance
self.uri = config.get('site', 'uri', '/')
if self.uri[-1] == '/':
self.uri = self.uri[:-1]
# get site info
self.site = Site(
name='',
theme='',
home=os.path.join(config.sites_path, server),
data_path=os.path.join(config.sites_path, server,
config.get('data', 'path', 'data')),
url=self.uri,
tracking_id=config.get('site', 'tracking_id', ''),
)
# csrf validation
self.csrf_validation = (
config.get('site', 'csrf_validation', True) not in
['0', 'False', 'off', 'no', True]
)
# secure cookies
self.secure_cookies = (
config.get('sessions', 'secure_cookies', False) not in
['0', 'False', 'off', 'no', False]
)
# users and groups
self.guest = config.get('users', 'default', 'guest')
self.administrator_group = \
system.config.get('users', 'administrator_group', 'administrators')
self.manager_group = config.get('users', 'manager_group', 'managers')
self.managers = config.get('users', 'managers', 'managers')
self.developers = config.get('users', 'developers', 'developers')
self.administrators = \
config.get('users', 'administrators', 'administrators')
# apps
self.index = config.get('apps', 'index', 'index')
self.home = config.get('apps', 'home', 'home')
# background processing
self.background = config.get('background', 'run', True) not in NEGATIVE
# users (experimental)
self.users = UserStore(self.db)
# email settings
self.from_addr = system.config.get('mail', 'from_addr')
self.mail_delivery = system.config.get('mail', 'delivery', 'immediate')
# load theme
self.themes_path = existing(config.get(
'theme',
'path',
os.path.join(self.root, 'themes'))
)
self.theme = (
self.themes_path and
self.settings.get('theme_name') or
config.get('theme', 'name', 'default')
)
self.set_theme(self.theme)
self.app = NoApp()
self.site_name = ''
self.warnings = []
self.errors = []
self.messages = []
self.styles = OrderedSet()
self.css = OrderedSet()
self.libs = OrderedSet()
self.js = OrderedSet()
self.head = OrderedSet()
self.tail = OrderedSet()
self.helpers = {}
self.show_errors = config.get('error', 'users', '0') == '1'
self.profile = config.get('system', 'profile', '0') == '1'
self.track_visits = config.get(
'system',
'track_visits',
'0').lower() in POSITIVE
self.logging = config.get(
'log',
'logging',
True) not in ['0', 'False', 'off', 'no', False]
self.session = zoom.session.Session(self)
self.session.load_session()
self.is_setup = True
def get_mail_store(site):
"""returns the mail store"""
return EntityStore(site.db, SystemMail)
def test_kind(self):
self.assertEqual(self.people.kind, 'person')
self.assertEqual(EntityStore(self.db, TestPerson).kind, 'test_person')
