def test_insert_after_sort( self ):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.model.party import Person
self.person_proxy.sort( 1, Qt.AscendingOrder )
# check the query
self.assertTrue( self.person_proxy.columnCount() > 0 )
rowcount = self.person_proxy.rowCount()
self.assertTrue( rowcount > 0 )
# check the sorting
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data1 > data0 )
self.person_proxy.sort( 1, Qt.DescendingOrder )
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data0 > data1 )
# insert a new object
person = Person()
self.person_proxy.append_object( person )
new_rowcount = self.person_proxy.rowCount()
self.assertTrue( new_rowcount > rowcount )
new_row = new_rowcount - 1
self.assertEqual( person, self.person_proxy._get_object( new_row ) )
# fill in the required fields
self.assertFalse( self.person_admin.is_persistent( person ) )
self._set_data( new_row, 0, 'Foo' )
self._set_data( new_row, 1, 'Bar' )
self.assertEqual( person.first_name, 'Foo' )
self.assertEqual( person.last_name, 'Bar' )
self._load_data()
self.assertEqual( self._data( new_row, 0 ), 'Foo' )
self.assertEqual( self._data( new_row, 1 ), 'Bar' )
self.assertTrue( self.person_admin.is_persistent( person ) )
# create a related proxy (eg, to display a form view)
related_proxy = QueryTableProxy(
self.person_admin,
self.person_proxy.get_query_getter(),
self.person_admin.get_columns,
max_number_of_rows = 1,
cache_collection_proxy = self.person_proxy
)
self.assertEqual( new_rowcount, related_proxy.rowCount() )
self._load_data( related_proxy )
self.assertEqual( self._data( new_row, 0, related_proxy ), 'Foo' )
def test_drag_and_drop( self ):
from camelot.view.proxy.queryproxy import QueryTableProxy
class DropAction( Action ):
pass
mime_data = QtCore.QMimeData()
admin = self.context.admin
admin.drop_action = DropAction()
proxy = QueryTableProxy( admin, admin.get_query, admin.get_columns )
proxy.dropMimeData( mime_data,
Qt.MoveAction,
-1,
-1,
QtCore.QModelIndex() )
def test_drag_and_drop( self ):
from camelot.view.proxy.queryproxy import QueryTableProxy
class DropAction( Action ):
pass
mime_data = QtCore.QMimeData()
admin = self.context.admin
admin.drop_action = DropAction()
proxy = QueryTableProxy( admin, admin.get_query, admin.get_columns )
proxy.dropMimeData( mime_data,
Qt.MoveAction,
-1,
-1,
QtCore.QModelIndex() )
def render(self, gui_context):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.view.proxy.collection_proxy import CollectionProxy
from camelot.view.controls.formview import FormView
if self.objects is None:
related_model = gui_context.item_view.model()
#
# depending on the type of related model, create a new model
#
row = gui_context.item_view.currentIndex().row()
if isinstance(related_model, QueryTableProxy):
# here the query and the cache are passed to the proxy
# constructor to prevent an additional query when a
# form is opened to look for an object that was in the list
model = QueryTableProxy(
gui_context.admin,
query=related_model.get_query(),
max_number_of_rows=1,
cache_collection_proxy=related_model,
)
else:
# no cache or sorting information is transferred
model = CollectionProxy(
gui_context.admin,
max_number_of_rows=1,
)
# get the unsorted row
row = related_model.map_to_source(row)
model.set_value(related_model.get_value())
else:
row = self.row
model = CollectionProxy(self.admin, max_number_of_rows=10)
model.set_value(self.objects)
model.set_columns(self._columns)
form = FormView(title=self.title,
admin=self.admin,
model=model,
columns=self._columns,
form_display=self._form_display,
index=row)
form.set_actions(self.actions)
form.set_toolbar_actions(self.top_toolbar_actions)
return form
def test_insert_after_sort(self):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.model.party import Person
self.proxy.sort(1, Qt.AscendingOrder)
# check the query
self.assertTrue(self.proxy.columnCount() > 0)
rowcount = self.proxy.rowCount()
self.assertTrue(rowcount > 0)
# check the sorting
self._load_data()
data0 = self._data(0, 1)
data1 = self._data(1, 1)
self.assertTrue(data1 > data0)
self.proxy.sort(1, Qt.DescendingOrder)
self._load_data()
data0 = self._data(0, 1)
data1 = self._data(1, 1)
self.assertTrue(data0 > data1)
# insert a new object
person = Person()
self.proxy.append_object(person)
new_rowcount = self.proxy.rowCount()
self.assertTrue(new_rowcount > rowcount)
new_row = new_rowcount - 1
self.assertEqual(person, self.proxy._get_object(new_row))
# fill in the required fields
self.assertFalse(self.person_admin.is_persistent(person))
self._set_data(new_row, 0, 'Foo')
self._set_data(new_row, 1, 'Bar')
self.assertEqual(person.first_name, 'Foo')
self.assertEqual(person.last_name, 'Bar')
self._load_data()
self.assertEqual(self._data(new_row, 0), 'Foo')
self.assertEqual(self._data(new_row, 1), 'Bar')
self.assertTrue(self.person_admin.is_persistent(person))
# create a related proxy (eg, to display a form view)
related_proxy = QueryTableProxy(self.person_admin,
self.proxy.get_query_getter(),
self.person_admin.get_columns,
max_number_of_rows=1,
cache_collection_proxy=self.proxy)
self.assertEqual(new_rowcount, related_proxy.rowCount())
self._load_data(related_proxy)
self.assertEqual(self._data(new_row, 0, related_proxy), 'Foo')
def setUp(self):
super( QueryProxyCase, self ).setUp()
from camelot_example.fixtures import load_movie_fixtures
from camelot.model.party import Person
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.admin.application_admin import ApplicationAdmin
load_movie_fixtures()
self.app_admin = ApplicationAdmin()
self.person_admin = self.app_admin.get_related_admin( Person )
Person.query.count
self.person_proxy = QueryTableProxy( self.person_admin,
query_getter = lambda:Person.query,
columns_getter = self.person_admin.get_columns )
def openForm(index):
model = QueryTableProxy(
tableview.admin,
tableview._table_model.get_query_getter(),
tableview.admin.get_fields,
max_number_of_rows=1,
cache_collection_proxy=tableview._table_model)
title = ''
formview = tableview.admin.create_form_view(title,
model,
index,
parent=None)
show_top_level(formview, tableview)
def gui_run(self, gui_context):
from camelot.view.workspace import show_top_level
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.view.proxy.collection_proxy import CollectionProxy
related_model = gui_context.item_view.model()
#
# depending on the type of related model, create a new model
#
row = gui_context.item_view.currentIndex().row()
if isinstance(related_model, QueryTableProxy):
model = QueryTableProxy(
gui_context.admin,
related_model.get_query_getter(),
gui_context.admin.get_fields,
max_number_of_rows=1,
cache_collection_proxy=related_model,
)
else:
# no cache or sorting information is transferred
model = CollectionProxy(
gui_context.admin,
related_model.get_collection,
gui_context.admin.get_fields,
max_number_of_rows=1,
)
# get the unsorted row
row = related_model.map_to_source(row)
formview = gui_context.admin.create_form_view(
u' ',
model,
row,
)
# make sure there is no 'pythonw' window title in windows for a
# second
formview.setWindowTitle(u' ')
show_top_level(formview, gui_context.item_view)
class QueryProxyCase( ModelThreadTestCase ):
"""Test the functionality of the QueryProxy to perform CRUD operations on
stand alone data"""
def setUp(self):
super( QueryProxyCase, self ).setUp()
from camelot_example.fixtures import load_movie_fixtures
from camelot.model.party import Person
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.admin.application_admin import ApplicationAdmin
load_movie_fixtures()
self.app_admin = ApplicationAdmin()
self.person_admin = self.app_admin.get_related_admin( Person )
Person.query.count
self.person_proxy = QueryTableProxy( self.person_admin,
query_getter = lambda:Person.query,
columns_getter = self.person_admin.get_columns )
def _load_data( self, proxy = None ):
"""Trigger the loading of data by the proxy"""
if proxy == None:
proxy = self.person_proxy
for row in range( proxy.rowCount() ):
self._data( row, 0, proxy )
self.process()
def _data( self, row, column, proxy = None ):
"""Get data from the proxy"""
if proxy == None:
proxy = self.person_proxy
index = proxy.index( row, column )
return variant_to_pyobject( proxy.data( index ) )
def _set_data( self, row, column, value ):
"""Set data to the proxy"""
index = self.person_proxy.index( row, column )
return self.person_proxy.setData( index, lambda:value )
def test_insert_after_sort( self ):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.model.party import Person
self.person_proxy.sort( 1, Qt.AscendingOrder )
# check the query
self.assertTrue( self.person_proxy.columnCount() > 0 )
rowcount = self.person_proxy.rowCount()
self.assertTrue( rowcount > 0 )
# check the sorting
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data1 > data0 )
self.person_proxy.sort( 1, Qt.DescendingOrder )
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data0 > data1 )
# insert a new object
person = Person()
self.person_proxy.append_object( person )
new_rowcount = self.person_proxy.rowCount()
self.assertTrue( new_rowcount > rowcount )
new_row = new_rowcount - 1
self.assertEqual( person, self.person_proxy._get_object( new_row ) )
# fill in the required fields
self.assertFalse( self.person_admin.is_persistent( person ) )
self._set_data( new_row, 0, 'Foo' )
self._set_data( new_row, 1, 'Bar' )
self.assertEqual( person.first_name, 'Foo' )
self.assertEqual( person.last_name, 'Bar' )
self._load_data()
self.assertEqual( self._data( new_row, 0 ), 'Foo' )
self.assertEqual( self._data( new_row, 1 ), 'Bar' )
self.assertTrue( self.person_admin.is_persistent( person ) )
# create a related proxy (eg, to display a form view)
related_proxy = QueryTableProxy(
self.person_admin,
self.person_proxy.get_query_getter(),
self.person_admin.get_columns,
max_number_of_rows = 1,
cache_collection_proxy = self.person_proxy
)
self.assertEqual( new_rowcount, related_proxy.rowCount() )
self._load_data( related_proxy )
self.assertEqual( self._data( new_row, 0, related_proxy ), 'Foo' )
def setUp(self):
super(QueryProxyCase, self).setUp()
self.proxy = QueryTableProxy(
self.person_admin,
query_getter=lambda: Person.query,
columns_getter=self.person_admin.get_columns)
class QueryProxyCase(ProxyCase):
"""Test the functionality of the QueryProxy to perform CRUD operations on
stand alone data"""
def setUp(self):
super(QueryProxyCase, self).setUp()
self.proxy = QueryTableProxy(
self.person_admin,
query_getter=lambda: Person.query,
columns_getter=self.person_admin.get_columns)
def test_insert_after_sort(self):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.model.party import Person
self.proxy.sort(1, Qt.AscendingOrder)
# check the query
self.assertTrue(self.proxy.columnCount() > 0)
rowcount = self.proxy.rowCount()
self.assertTrue(rowcount > 0)
# check the sorting
self._load_data()
data0 = self._data(0, 1)
data1 = self._data(1, 1)
self.assertTrue(data1 > data0)
self.proxy.sort(1, Qt.DescendingOrder)
self._load_data()
data0 = self._data(0, 1)
data1 = self._data(1, 1)
self.assertTrue(data0 > data1)
# insert a new object
person = Person()
self.proxy.append_object(person)
new_rowcount = self.proxy.rowCount()
self.assertTrue(new_rowcount > rowcount)
new_row = new_rowcount - 1
self.assertEqual(person, self.proxy._get_object(new_row))
# fill in the required fields
self.assertFalse(self.person_admin.is_persistent(person))
self._set_data(new_row, 0, 'Foo')
self._set_data(new_row, 1, 'Bar')
self.assertEqual(person.first_name, 'Foo')
self.assertEqual(person.last_name, 'Bar')
self._load_data()
self.assertEqual(self._data(new_row, 0), 'Foo')
self.assertEqual(self._data(new_row, 1), 'Bar')
self.assertTrue(self.person_admin.is_persistent(person))
# create a related proxy (eg, to display a form view)
related_proxy = QueryTableProxy(self.person_admin,
self.proxy.get_query_getter(),
self.person_admin.get_columns,
max_number_of_rows=1,
cache_collection_proxy=self.proxy)
self.assertEqual(new_rowcount, related_proxy.rowCount())
self._load_data(related_proxy)
self.assertEqual(self._data(new_row, 0, related_proxy), 'Foo')
def test_get_object(self):
#
# verify that get_object retruns None when the requested row
# is out of range
#
self.assertFalse(self.proxy._get_object(-1))
rows = self.proxy.rowCount()
self.assertTrue(rows > 1)
self.assertTrue(self.proxy._get_object(0))
self.assertTrue(self.proxy._get_object(rows - 1))
self.assertFalse(self.proxy._get_object(rows))
self.assertFalse(self.proxy._get_object(rows + 1))
def setUp(self):
super( QueryProxyCase, self ).setUp()
self.proxy = QueryTableProxy( self.person_admin,
query_getter = lambda:Person.query,
columns_getter = self.person_admin.get_columns )
class QueryProxyCase( ProxyCase ):
"""Test the functionality of the QueryProxy to perform CRUD operations on
stand alone data"""
def setUp(self):
super( QueryProxyCase, self ).setUp()
self.proxy = QueryTableProxy( self.person_admin,
query_getter = lambda:Person.query,
columns_getter = self.person_admin.get_columns )
def test_insert_after_sort( self ):
from camelot.view.proxy.queryproxy import QueryTableProxy
from camelot.model.party import Person
self.proxy.sort( 1, Qt.AscendingOrder )
# check the query
self.assertTrue( self.proxy.columnCount() > 0 )
rowcount = self.proxy.rowCount()
self.assertTrue( rowcount > 0 )
# check the sorting
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data1 > data0 )
self.proxy.sort( 1, Qt.DescendingOrder )
self._load_data()
data0 = self._data( 0, 1 )
data1 = self._data( 1, 1 )
self.assertTrue( data0 > data1 )
# insert a new object
person = Person()
self.proxy.append_object( person )
new_rowcount = self.proxy.rowCount()
self.assertTrue( new_rowcount > rowcount )
new_row = new_rowcount - 1
self.assertEqual( person, self.proxy._get_object( new_row ) )
# fill in the required fields
self.assertFalse( self.person_admin.is_persistent( person ) )
self._set_data( new_row, 0, 'Foo' )
self._set_data( new_row, 1, 'Bar' )
self.assertEqual( person.first_name, 'Foo' )
self.assertEqual( person.last_name, 'Bar' )
self._load_data()
self.assertEqual( self._data( new_row, 0 ), 'Foo' )
self.assertEqual( self._data( new_row, 1 ), 'Bar' )
self.assertTrue( self.person_admin.is_persistent( person ) )
# create a related proxy (eg, to display a form view)
related_proxy = QueryTableProxy(
self.person_admin,
self.proxy.get_query_getter(),
self.person_admin.get_columns,
max_number_of_rows = 1,
cache_collection_proxy = self.proxy
)
self.assertEqual( new_rowcount, related_proxy.rowCount() )
self._load_data( related_proxy )
self.assertEqual( self._data( new_row, 0, related_proxy ), 'Foo' )
def test_get_object( self ):
#
# verify that get_object retruns None when the requested row
# is out of range
#
self.assertFalse( self.proxy._get_object( -1 ) )
rows = self.proxy.rowCount()
self.assertTrue( rows > 1 )
self.assertTrue( self.proxy._get_object( 0 ) )
self.assertTrue( self.proxy._get_object( rows - 1 ) )
self.assertFalse( self.proxy._get_object( rows ) )
self.assertFalse( self.proxy._get_object( rows + 1 ) )
