def test_object_session(self):
from khufu_sqlalchemy import _DBSessionFinder
dbsession = _DBSessionFinder()
req = Mock(environ={}, context=Mock(), registry=Mock(settings={}))
self.assertEqual(dbsession(req, False), None)
marker = object()
dbsession._object_session = lambda x: marker
req = Mock(environ={}, context=Mock(), registry=Mock(settings={}))
self.assertEqual(dbsession(req, False), marker)
def test_create(self):
from khufu_sqlalchemy import dbsession, DBSESSION_FACTORY
self.assertEqual(dbsession(Mock(environ={}), create=False), None)
marker = object()
def foo():
return marker
m = Mock(environ={},
add_finished_callback=lambda x: None,
registry=Mock(settings={DBSESSION_FACTORY: foo}))
self.assertEqual(dbsession(m, create=True), marker)
def __call__(self, request):
item_label = self.model_label or \
self.model_class.__name__.decode('utf-8')
db = dbsession(request)
q = db.query(self.model_class)
if request.method == 'POST':
for x in request.POST.getall('pks'):
pk = unserialize_pk(x)
db.delete(q.get(pk))
db.flush()
start = int(request.params.get('start', 0))
table = self.model_class.__table__
total = db.query(*[x for x in table.primary_key.columns]).count()
pager = Pager(q, total=total, limit=self.limit, start=start)
header_items = [x.name.title() for x in self.schema.nodes]
items = []
for x in pager.items():
d = obj_to_dict(x, self.schema)
d['pk'] = serialize_pk(x, self.schema)
items.append(d)
res = {'items': items,
'pager': pager,
'can_add': True,
'header_items': header_items,
'item_label': item_label,
'fields': self.schema.nodes,
'request': request}
return render_to_response(self.renderer, res, request=request)
def get_form(self, request):
schema = self.schema().clone()
for x in self.excludes:
del schema[x]
inst = schema.bind(db=dbsession(request))
form = deform.Form(inst, buttons=('add',), use_ajax=True)
return form
def save(self, request, converted):
m = self.model_class(**converted)
db = dbsession(request)
db.add(m)
db.flush()
request.registry.notify(ObjectCreatedEvent(m))
request.session.flash('New %s created' % self.model_label)
return m
def get_query(self, **kwargs):
db = khufu_sqlalchemy.dbsession(self.request)
q = db.query(self.model_class)
filter_by_kwargs = dict(self.filter_by_kwargs or {})
filter_by_kwargs.update(kwargs)
if filter_by_kwargs:
q = q.filter_by(**filter_by_kwargs)
return q
def save(self, request, converted):
db = dbsession(request)
m = request.context
for k, v in converted.items():
setattr(m, k, v)
db.add(m)
db.flush()
request.registry.notify(ObjectModifiedEvent(m))
request.session.flash('%s modified' % m)
return m
def get_form(self, request):
schema = self.schema().clone()
nodes = dict([(x.name, x) for x in schema.children])
for col in self.model_class.__table__.primary_key:
if col.name in nodes:
del nodes[col.name]
schema.children[:] = nodes.values()
inst = schema.bind(db=dbsession(request))
form = deform.Form(inst, buttons=('edit',), use_ajax=True)
return form
def __getitem__(self, k):
db = khufu_sqlalchemy.dbsession(self.request)
o = db.query(self.model_class).get(self.traversal_to_pk(k))
if self.filter_by_kwargs:
for k, v in self.filter_by_kwargs.items():
if getattr(o, k, None) != v:
raise KeyError(k)
return self.wrap(o, k)
def test_context(self):
from khufu_sqlalchemy import dbsession
req = Mock(environ={}, context=Mock())
req.context.db = marker = object()
self.assertEqual(dbsession(req), marker)
def test_already_exists(self):
from khufu_sqlalchemy import dbsession, DBSESSION
marker = object()
req = Mock(environ={DBSESSION: marker})
self.assertEqual(dbsession(req), marker)
def get_form(self, request):
inst = self.schema().bind(db=dbsession(request))
form = deform.Form(inst, use_ajax=True)
return form
def __getitem__(self, k):
q = dbsession(self.request).query(Note)
try:
return q.get(int(k))
except:
raise KeyError(k)
def __init__(self, request):
self.request = request
self.db = dbsession(request)
