class FreezeTableWidget(QTableView):
def __init__(self, table_data, headers, parent=None, *args):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(table_data, headers, parent)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(Qt.StrongFocus | Qt.TabFocus
| Qt.ClickFocus)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
self.set_style()
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers)
self.set_size()
self.signals()
def set_size(self):
"""
Sets the size and size policy of the tables.
:return:
:rtype:
"""
size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumSize(QSize(55, 75))
self.setMaximumSize(QSize(5550, 5555))
self.SelectionMode(QAbstractItemView.SelectColumns)
# set column width to fit contents
self.frozen_table_view.resizeColumnsToContents()
# set row height
self.frozen_table_view.resizeRowsToContents()
def signals(self):
"""
Connects signals of the tables.
"""
# Connect the headers and scrollbars of
# both tableviews together
self.horizontalHeader().sectionResized.connect(
self.update_section_width)
self.verticalHeader().sectionResized.connect(
self.update_section_height)
self.frozen_table_view.verticalScrollBar(). \
valueChanged.connect(
self.verticalScrollBar().setValue
)
self.verticalScrollBar().valueChanged.connect(
self.frozen_table_view.verticalScrollBar().setValue)
def set_column_width(self):
"""
Sets the column width of the frozen QTableView.
"""
# Set the width of columns
columns_count = self.table_model.columnCount(self)
for col in range(columns_count):
if col == 0:
# Set the size
self.horizontalHeader().resizeSection(col, 60)
# Fix width
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
# Width of a fixed column - as in the main widget
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
elif col == 1:
self.horizontalHeader().resizeSection(col, 150)
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
else:
self.horizontalHeader().resizeSection(col, 150)
# Hide unnecessary columns in the
# widget fixed columns
self.frozen_table_view.setColumnHidden(col, True)
def set_style(self):
"""
Sets the style of the frozen table.
"""
# Style frozentable view
self.frozen_table_view.setStyleSheet('''
#frozen_table{
border-top:none;
}
''')
self.shadow = QGraphicsDropShadowEffect(self)
self.shadow.setBlurRadius(5)
self.shadow.setOffset(2)
self.shadow.setYOffset(0)
self.frozen_table_view.setGraphicsEffect(self.shadow)
def add_widgets(self, str_type_id, insert_row):
"""
Adds widget delete into the frozen table.
:param str_type_id: The STR type id of the tenure type combobox
:type str_type_id: Integer
:param insert_row: The row number the widgets to be added.
:type insert_row: Integer
"""
delegate = STRTypeDelegate(str_type_id)
# Set delegate to add combobox under
# social tenure type column
self.frozen_table_view.setItemDelegate(delegate)
self.frozen_table_view.setItemDelegateForColumn(0, delegate)
index = self.frozen_table_view.model().index(insert_row, 0,
QModelIndex())
self.frozen_table_view.model().setData(index, '', Qt.EditRole)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 0))
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 1))
def update_section_width(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column width and geometry.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
if logicalIndex == 0 or logicalIndex == 1:
self.frozen_table_view.setColumnWidth(logicalIndex, newSize)
self.update_frozen_table_geometry()
def update_section_height(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column height.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
self.frozen_table_view.setRowHeight(logicalIndex, newSize)
def resizeEvent(self, event):
"""
Handles the resize event of the frozen table view.
It updates the frozen table view geometry on resize of table.
:param event: The event
:type event: QEvent
"""
QTableView.resizeEvent(self, event)
try:
self.update_frozen_table_geometry()
except Exception as log:
LOGGER.debug(str(log))
def scrollTo(self, index, hint):
"""
Scrolls the view if necessary to ensure that the item at index is
visible. The view will try to position the item according to the
given hint.
:param index: The scroll index
:type index: QModelIndex
:param hint: The scroll hint
:type hint: Integer
"""
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def update_frozen_table_geometry(self):
"""
Updates the frozen table view geometry.
"""
if self.verticalHeader().isVisible():
self.frozen_table_view.setGeometry(
self.verticalHeader().width() + self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
else:
self.frozen_table_view.setGeometry(
self.frameWidth(), self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
def move_cursor(self, cursor_action, modifiers):
"""
Override function for correct left to scroll the keyboard.
Returns a QModelIndex object pointing to the next object in the
table view, based on the given cursorAction and keyboard modifiers
specified by modifiers.
:param cursor_action: The cursor action
:type cursor_action: Integer
:param modifiers: Qt.KeyboardModifier value.
:type modifiers: Object
:return: The current cursor position.
:rtype: QModelIndex
"""
current = QTableView.move_cursor(self, cursor_action, modifiers)
if cursor_action == self.MoveLeft and current.column() > 1 and \
self.visualRect(current).topLeft().x() < \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1)):
new_value = self.horizontalScrollBar().value() + \
self.visualRect(current).topLeft().x() - \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1))
self.horizontalScrollBar().setValue(new_value)
return current
def _init_fk_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
self._entity_attrs[:] = []
if self._dbmodel is None:
msg = QApplication.translate(
'ForeignKeyMapper', 'The data model for '
'the entity could '
'not be loaded, '
'please contact '
'your database '
'administrator.')
QMessageBox.critical(
self, QApplication.translate('EntityBrowser',
'Entity Browser'), msg)
return
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
# Iterate entity column and assert if they exist
for c in self._entity.columns.values():
# Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.header()
self._headers.append(header)
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
col_name = c.name
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
# Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
try:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
except WidgetException as we:
msg = QApplication.translate(
'ForeignKeyMapper', 'Error in creating column:')
msg = '{0} {1}:{2}\n{3}'.format(
msg, self._entity.name, c.name, str(we))
QMessageBox.critical(
self,
QApplication.translate('ForeignKeyMapper',
'Widget Creation Error'),
msg)
# Set searchable columns
if c.searchable:
self._searchable_columns[header] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'ForeignKeyMapper',
'The following columns have been defined in the '
'configuration but are missing in corresponding '
'database table, please re-run the configuration wizard '
'to create them.\n{0}'.format('\n'.join(missing_columns)))
QMessageBox.warning(
self,
QApplication.translate('ForeignKeyMapper', 'Entity Browser'),
msg)
self._tableModel = BaseSTDMTableModel([], self._headers, self)
self._tbFKEntity.setModel(self._tableModel)
# First (id) column will always be hidden
self._tbFKEntity.hideColumn(0)
self._tbFKEntity.horizontalHeader().setSectionResizeMode(
QHeaderView.Interactive)
self._tbFKEntity.horizontalHeader().setStretchLastSection(True)
self._tbFKEntity.verticalHeader().setVisible(True)
def __init__(
self, table_data, headers, parent=None, *args
):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(
table_data, headers, parent
)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(
Qt.StrongFocus | Qt.TabFocus | Qt.ClickFocus
)
# The user can not resize columns
self.frozen_table_view.horizontalHeader(). \
setSectionResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader(). \
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers
)
self.set_size()
self.signals()
def _initializeData(self, filtered_records=None):
'''
Set table model and load data into it.
'''
if self._dbmodel is None:
msg = QApplication.translate(
'EntityBrowser',
'The data model for the entity could not be loaded, \n'
'please contact your database administrator.')
QMessageBox.critical(
self, QApplication.translate('EntityBrowser',
'Entity Browser'), msg)
else:
self._init_entity_columns()
# Load entity data. There might be a better way in future in order
# to ensure that there is a balance between user data discovery
# experience and performance.
if filtered_records is not None:
self.current_records = filtered_records.rowcount
numRecords = self.recomputeRecordCount(init_data=True)
# Load progress dialog
progressLabel = QApplication.translate("EntityBrowser",
"Fetching Records...")
progressDialog = QProgressDialog(progressLabel, None, 0,
numRecords, self)
QApplication.processEvents()
progressDialog.show()
progressDialog.setValue(0)
# Add records to nested list for enumeration in table model
load_data = True
if self.plugin is not None:
if self._entity.name in self.plugin.entity_table_model.keys():
if filtered_records is None:
self._tableModel = self.plugin.entity_table_model[
self._entity.name]
if isinstance(self._parent, EntityEditorDialog):
load_data = True
if load_data:
# Only one filter is possible.
if len(self.filtered_records) > 0:
entity_records = self.filtered_records
else:
entity_cls = self._dbmodel()
entity_records = entity_cls.queryObject().filter().limit(
self.record_limit).all()
# if self._tableModel is None:
entity_records_collection = []
for i, er in enumerate(entity_records):
if i == self.record_limit:
break
QApplication.processEvents()
entity_row_info = []
progressDialog.setValue(i)
try:
for attr in self._entity_attrs:
attr_val = getattr(er, attr)
# Check if there are display formatters and apply if
# one exists for the given attribute.
if attr_val is not None: # No need of formatter for None value
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(
attr_val)
entity_row_info.append(attr_val)
except Exception as ex:
QMessageBox.critical(
self,
QApplication.translate('EntityBrowser',
'Loading Records'),
unicode(ex.message))
return
entity_records_collection.append(entity_row_info)
self._tableModel = BaseSTDMTableModel(
entity_records_collection, self._headers, self)
if self.plugin is not None:
self.plugin.entity_table_model[self._entity.name] = \
self._tableModel
# Add filter columns
for header, info in self._searchable_columns.iteritems():
column_name, index = info['name'], info['header_index']
if column_name != 'id':
self.cboFilterColumn.addItem(header, info)
#Use sortfilter proxy model for the view
self._proxyModel = VerticalHeaderSortFilterProxyModel()
self._proxyModel.setDynamicSortFilter(True)
self._proxyModel.setSourceModel(self._tableModel)
self._proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
#USe first column in the combo for filtering
if self.cboFilterColumn.count() > 0:
self.set_proxy_model_filter_column(0)
self.tbEntity.setModel(self._proxyModel)
if numRecords < self.record_limit:
self.tbEntity.setSortingEnabled(True)
self.tbEntity.sortByColumn(1, Qt.AscendingOrder)
#First (ID) column will always be hidden
self.tbEntity.hideColumn(0)
self.tbEntity.horizontalHeader().setResizeMode(
QHeaderView.Interactive)
self.tbEntity.resizeColumnsToContents()
#Connect signals
self.connect(self.cboFilterColumn,
SIGNAL('currentIndexChanged (int)'),
self.onFilterColumnChanged)
self.connect(self.txtFilterPattern,
SIGNAL('textChanged(const QString&)'),
self.onFilterRegExpChanged)
#Select record with the given ID if specified
if not self._select_item is None:
self._select_record(self._select_item)
if numRecords > 0:
# Set maximum value of the progress dialog
progressDialog.setValue(numRecords)
else:
progressDialog.hide()
class ForeignKeyMapper(QWidget):
"""
Widget for selecting database records through an entity browser or
using an ExpressionBuilder for filtering records.
"""
# Custom signals
beforeEntityAdded = pyqtSignal("PyQt_PyObject")
afterEntityAdded = pyqtSignal("PyQt_PyObject", int)
entityRemoved = pyqtSignal("PyQt_PyObject")
deletedRows = pyqtSignal(list)
def __init__(self,
entity,
parent=None,
notification_bar=None,
enable_list=True,
can_filter=False,
plugin=None):
QWidget.__init__(self, parent)
self.current_profile = current_profile()
self._tbFKEntity = QTableView(self)
self._tbFKEntity.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._tbFKEntity.setAlternatingRowColors(True)
self._tbFKEntity.setSelectionBehavior(QAbstractItemView.SelectRows)
self.plugin = plugin
self._add_entity_btn = QToolButton(self)
self._add_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper", "Add"))
self._add_entity_btn.setIcon(GuiUtils.get_icon("add.png"))
self._add_entity_btn.clicked.connect(self.onAddEntity)
self._edit_entity_btn = QToolButton(self)
self._edit_entity_btn.setVisible(False)
self._edit_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper", "Edit"))
self._edit_entity_btn.setIcon(GuiUtils.get_icon("edit.png"))
self._filter_entity_btn = QToolButton(self)
self._filter_entity_btn.setVisible(False)
self._filter_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper", "Select by expression"))
self._filter_entity_btn.setIcon(GuiUtils.get_icon("filter.png"))
self._filter_entity_btn.clicked.connect(self.onFilterEntity)
self._delete_entity_btn = QToolButton(self)
self._delete_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper", "Remove"))
self._delete_entity_btn.setIcon(GuiUtils.get_icon("remove.png"))
self._delete_entity_btn.clicked.connect(self.onRemoveEntity)
layout = QVBoxLayout(self)
layout.setSpacing(4)
layout.setMargin(5)
self.grid_layout = QGridLayout()
self.grid_layout.setHorizontalSpacing(5)
self.grid_layout.addWidget(self._add_entity_btn, 0, 0, 1, 1)
self.grid_layout.addWidget(self._filter_entity_btn, 0, 1, 1, 1)
self.grid_layout.addWidget(self._edit_entity_btn, 0, 2, 1, 1)
self.grid_layout.addWidget(self._delete_entity_btn, 0, 3, 1, 1)
self.grid_layout.setColumnStretch(4, 5)
layout.addLayout(self.grid_layout)
layout.addWidget(self._tbFKEntity)
self.social_tenure = self.current_profile.social_tenure
self._tableModel = None
self._notifBar = notification_bar
self._headers = []
self._entity_attrs = []
self._cell_formatters = {}
self._searchable_columns = OrderedDict()
self._supportsLists = enable_list
self._deleteOnRemove = False
self._uniqueValueColIndices = OrderedDict()
self.global_id = None
self._deferred_objects = {}
self._use_expression_builder = can_filter
if self._use_expression_builder:
self._filter_entity_btn.setVisible(True)
self._edit_entity_btn.setVisible(False)
self.set_entity(entity)
def set_entity(self, entity):
"""
Sets new entity and updates the ForeignKeyMapper with a new
:param entity: The entity of the ForeignKeyMapper
:type entity:Object
"""
from stdm.ui.entity_browser import EntityBrowser
self._entity = entity
self._dbmodel = entity_model(entity)
self._init_fk_columns()
self._entitySelector = EntityBrowser(self._entity,
parent=self,
state=SELECT,
plugin=self.plugin)
# Connect signals
self._entitySelector.recordSelected.connect(
self._onRecordSelectedEntityBrowser)
def _init_fk_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
self._entity_attrs[:] = []
if self._dbmodel is None:
msg = QApplication.translate(
'ForeignKeyMapper', 'The data model for '
'the entity could '
'not be loaded, '
'please contact '
'your database '
'administrator.')
QMessageBox.critical(
self, QApplication.translate('EntityBrowser',
'Entity Browser'), msg)
return
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
# Iterate entity column and assert if they exist
for c in self._entity.columns.values():
# Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.header()
self._headers.append(header)
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
col_name = c.name
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
# Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
try:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
except WidgetException as we:
msg = QApplication.translate(
'ForeignKeyMapper', 'Error in creating column:')
msg = '{0} {1}:{2}\n{3}'.format(
msg, self._entity.name, c.name, str(we))
QMessageBox.critical(
self,
QApplication.translate('ForeignKeyMapper',
'Widget Creation Error'),
msg)
# Set searchable columns
if c.searchable:
self._searchable_columns[header] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'ForeignKeyMapper',
'The following columns have been defined in the '
'configuration but are missing in corresponding '
'database table, please re-run the configuration wizard '
'to create them.\n{0}'.format('\n'.join(missing_columns)))
QMessageBox.warning(
self,
QApplication.translate('ForeignKeyMapper', 'Entity Browser'),
msg)
self._tableModel = BaseSTDMTableModel([], self._headers, self)
self._tbFKEntity.setModel(self._tableModel)
# First (id) column will always be hidden
self._tbFKEntity.hideColumn(0)
self._tbFKEntity.horizontalHeader().setSectionResizeMode(
QHeaderView.Interactive)
self._tbFKEntity.horizontalHeader().setStretchLastSection(True)
self._tbFKEntity.verticalHeader().setVisible(True)
def databaseModel(self):
'''
Returns the database model that represents the foreign key entity.
'''
return self._dbmodel
def setDatabaseModel(self, model):
'''
Set the database model that represents the foreign key entity.
Model has to be a callable.
'''
self._dbmodel = model
def cellFormatters(self):
"""
Returns a dictionary of cell formatters used by the foreign key mapper.
"""
return self._cell_formatters
def cell_formatter(self, column):
"""
:param column: Column name:
:type column: str
:return: Returns the corresponding formatter object based on the
column name. None will be returned if there is no corresponding
object.
:rtype: object
"""
return self._cell_formatters.get(column, None)
def entitySelector(self):
'''
Returns the dialog for selecting the entity objects.
'''
return self._entitySelector
def supportList(self):
'''
Returns whether the mapper supports only one item or multiple entities.
Default is 'True'.
'''
return self._supportsLists
def setSupportsList(self, supportsList):
'''
Sets whether the mapper supports only one item or multiple entities i.e.
one-to-one (False) and one-to-many mapping (True).
'''
self._supportsLists = supportsList
def setNotificationBar(self, notificationBar):
'''
Set the notification bar for displaying user messages.
'''
self._notifBar = notificationBar
def viewModel(self):
'''
Return the view model used by the table view.
'''
return self._tableModel
def set_expression_builder(self, state):
"""
Set the mapper to use QGIS expression builder as the entity selector.
"""
self._use_expression_builder = state
def expression_builder_enabled(self):
"""
Returns whether the mapper has been configured to use the expression builder
"""
return self._use_expression_builder
def deleteOnRemove(self):
'''
Returns the state whether a record should be deleted from the database when it
is removed from the list.
'''
return self._deleteOnRemove
def setDeleteonRemove(self, delete):
'''
Set whether whether a record should be deleted from the database when it
is removed from the list.
'''
self._deleteOnRemove = delete
def addUniqueColumnName(self, colName, replace=True):
'''
Set the name of the column whose values are to be unique.
If 'replace' is True then the existing row will be replaced
with one with the new value; else, the new row will not be added to the list.
'''
headers = list(self._dbmodel.displayMapping().values())
colIndex = getIndex(headers, colName)
if colIndex != -1:
self.addUniqueColumnIndex(colIndex, replace)
def addUniqueColumnIndex(self, colIndex, replace=True):
'''
Set the index of the column whose values are to be unique. The column indices are
zero-based.
If 'replace' is True then the existing row will be replaced with the
new value; else, the new row will not be added to the list.
For multiple replace rules defined, then the first one added to the collection is the
one that will be applied.
'''
self._uniqueValueColIndices[colIndex] = replace
def onFilterEntity(self):
"""
Slot raised to load the expression builder dialog.
"""
vl, msg = self.vector_layer()
if vl is None:
msg = msg + "\n" + QApplication.translate(
"ForeignKeyMapper",
"The expression builder cannot be used at this moment.")
QMessageBox.critical(
self,
QApplication.translate("ForeignKeyMapper",
"Expression Builder"), msg)
return
context = self._entity.short_name
filter_dlg = ForeignKeyMapperExpressionDialog(vl,
self,
context=context)
filter_dlg.setWindowTitle(
QApplication.translate("ForeignKeyMapper", "Filter By Expression"))
filter_dlg.recordSelected[int].connect(
self._onRecordSelectedEntityBrowser)
res = filter_dlg.exec_()
def _removeRow(self, rowNumber):
'''
Remove the row at the given index.
'''
self._tableModel.removeRows(rowNumber, 1)
def onRemoveEntity(self):
'''
Slot raised on clicking to remove the selected entity.
'''
selectedRowIndices = self._tbFKEntity.selectionModel().selectedRows(0)
deleted_rows = []
if len(selectedRowIndices) == 0:
msg = QApplication.translate(
"ForeignKeyMapper", "Please select the record to be removed.")
self._notifBar.clear()
self._notifBar.insertWarningNotification(msg)
return
for selectedRowIndex in selectedRowIndices:
# Delete record from database if flag has been set to True
recId = selectedRowIndex.data()
dbHandler = self._dbmodel()
delRec = dbHandler.queryObject().filter(
self._dbmodel.id == recId).first()
if not delRec is None:
self.entityRemoved.emit(delRec)
if self._deleteOnRemove:
delRec.delete()
self._removeRow(selectedRowIndex.row())
deleted_rows.append(selectedRowIndex.row())
self.deletedRows.emit(deleted_rows)
def _recordIds(self):
'''
Returns the primary keys of the records in the table.
'''
recordIds = []
if self._tableModel:
rowCount = self._tableModel.rowCount()
for r in range(rowCount):
# Get ID value
modelIndex = self._tableModel.index(r, 0)
modelId = modelIndex.data()
recordIds.append(modelId)
return recordIds
def entities(self):
'''
Returns the model instance(s) depending on the configuration specified by the user.
'''
recIds = self._recordIds()
modelInstances = self._modelInstanceFromIds(recIds)
if len(modelInstances) == 0:
if self._supportsLists:
return []
else:
return None
else:
if self._supportsLists:
return modelInstances
else:
return modelInstances[0]
def setEntities(self, entities):
'''
Insert entities into the table.
'''
if isinstance(entities, list):
for entity in entities:
self._insertModelToView(entity)
else:
self._insertModelToView(entities)
def searchModel(self, columnIndex, columnValue):
'''
Searches for 'columnValue' in the column whose index is specified by 'columnIndex' in all
rows contained in the model.
'''
if isinstance(columnValue, QVariant):
columnValue = str(columnValue.toString())
if not isinstance(columnValue, str):
columnValue = str(columnValue)
columnValue = columnValue.strip()
proxy = QSortFilterProxyModel(self)
proxy.setSourceModel(self._tableModel)
proxy.setFilterKeyColumn(columnIndex)
proxy.setFilterFixedString(columnValue)
# Will return model index containing the primary key.
matchingIndex = proxy.mapToSource(proxy.index(0, 0))
return matchingIndex
def _modelInstanceFromIds(self, ids):
'''
Returns the model instance based the value of its primary key.
'''
dbHandler = self._dbmodel()
modelInstances = []
for modelId in ids:
modelObj = dbHandler.queryObject().filter(
self._dbmodel.id == modelId).first()
if not modelObj is None:
modelInstances.append(modelObj)
return modelInstances
def _onRecordSelectedEntityBrowser(self, rec, row_number=-1):
'''
Slot raised when the user has clicked the select button
in the 'EntityBrowser' dialog
to add the selected record to the table's list.
Add the record to the foreign key table using the mappings.
'''
# Check if the record exists using the primary key so as to ensure
# only one instance is added to the table
if isinstance(rec, int):
recIndex = getIndex(self._recordIds(), rec)
if recIndex != -1:
return
dbHandler = self._dbmodel()
modelObj = dbHandler.queryObject().filter(
self._dbmodel.id == rec).first()
elif isinstance(rec, object):
modelObj = rec
else:
return
if modelObj is not None:
# Raise before entity added signal
self.beforeEntityAdded.emit(modelObj)
# Validate for unique value configurations
'''
if not self._validate_unique_columns(modelObj, row_number):
return
'''
if not self._supportsLists and self._tableModel.rowCount() > 0:
self._removeRow(0)
insert_position = self._insertModelToView(modelObj, row_number)
if isinstance(rec, object):
self._deferred_objects[insert_position] = modelObj
def _validate_unique_columns(self, model, exclude_row=-1):
"""
Loop through the attributes of the model to assert
for existing row values that should be unique based on
the configuration of unique columns.
"""
for colIndex, replace in list(self._uniqueValueColIndices.items()):
attrName = list(self._dbmodel.displayMapping().keys())[colIndex]
attrValue = getattr(model, attrName)
# Check to see if there are cell formatters so
# that the correct value is searched for in the model
if attrName in self._cell_formatters:
attrValue = self._cell_formatters[attrName](attrValue)
matchingIndex = self.searchModel(colIndex, attrValue)
if matchingIndex.isValid() and matchingIndex.row() != exclude_row:
if replace:
existingId = matchingIndex.data()
# Delete old record from db
entityModels = self._modelInstanceFromIds([existingId])
if len(entityModels) > 0:
entityModels[0].delete()
self._removeRow(matchingIndex.row())
return True
else:
# Break. Do not add item to the list.
return False
return True
def _insertModelToView(self, model_obj, row_number=-1):
"""
Insert the given database model instance into the view
at the given row number position.
"""
if row_number == -1:
row_number = self._tableModel.rowCount()
self._tableModel.insertRows(row_number, 1)
# In some instances, we will need to get the model object with
# backrefs included else exceptions will be raised on missing
# attributes
q_objs = self._modelInstanceFromIds([model_obj.id])
if len(q_objs) == 0:
return
model_obj = q_objs[0]
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(row_number, i)
attr_val = getattr(model_obj, attr)
'''
Check if there are display formatters and apply if one exists
for the given attribute.
'''
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
# Raise signal once entity has been inserted
self.afterEntityAdded.emit(model_obj, row_number)
self._tbFKEntity.resizeColumnsToContents()
return row_number
def insert_model_to_table(self, model_obj, row_number=-1):
"""
Insert the given database model instance into the view
at the given row number position.
"""
if row_number == -1:
row_number = self._tableModel.rowCount()
self._tableModel.insertRows(row_number, 1)
# In some instances, we will need to get the model object with
# backrefs included else exceptions will be raised on missing
# attributes
q_objs = self._modelInstanceFromIds([model_obj.id])
if len(q_objs) == 0:
return
model_obj = q_objs[0]
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(row_number, i)
attr_val = getattr(model_obj, attr)
# Check if there are display formatters and apply if one exists
# for the given attribute.
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
#self._tbFKEntity.resizeColumnsToContents()
self._tbFKEntity.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
return row_number
def remove_rows(self):
"""
Removes rows from the fk browser.
"""
row_count = self._tbFKEntity.model().rowCount()
self._tbFKEntity.model().removeRows(0, row_count)
def vector_layer(self):
"""
Returns a QgsVectorLayer based on the configuration information
specified in the mapper including the system-wide data connection
properties.
"""
from stdm.data.pg_utils import vector_layer
if self._dbmodel is None:
msg = QApplication.translate(
"ForeignKeyMapper",
"Primary database model object not defined.")
return None, msg
filter_layer = vector_layer(self._entity.name)
if filter_layer is None:
msg = QApplication.translate(
"ForeignKeyMapper",
"Vector layer could not be constructed from the database table."
)
return None, msg
if not filter_layer.isValid():
trans_msg = QApplication.translate(
"ForeignKeyMapper",
"The vector layer for '{0}' table is invalid.")
msg = trans_msg.format(self._entity.name)
return None, msg
return filter_layer, ""
def onAddEntity(self):
"""
Slot raised on selecting to add related entities that will be mapped to the primary
database model instance.
"""
self._entitySelector.buttonBox.button(
QDialogButtonBox.Cancel).setVisible(False)
# Clear any previous selections in the entity browser
self._entitySelector.clear_selection()
# Clear any previous notifications
self._entitySelector.clear_notifications()
self._entitySelector.exec_()
def _init_fk_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
self._entity_attrs[:] = []
if self._dbmodel is None:
msg = QApplication.translate(
'ForeignKeyMapper', 'The data model for '
'the entity could '
'not be loaded, '
'please contact '
'your database '
'administrator.'
)
QMessageBox.critical(
self,
QApplication.translate(
'EntityBrowser',
'Entity Browser'
),
msg
)
return
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
#Iterate entity column and assert if they exist
for c in self._entity.columns.values():
#Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.header()
self._headers.append(header)
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
col_name = c.name
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
#Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
try:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
except WidgetException as we:
msg = QApplication.translate(
'ForeignKeyMapper',
'Error in creating column:'
)
msg = '{0} {1}:{2}\n{3}'.format(
msg, self._entity.name, c.name, unicode(we)
)
QMessageBox.critical(
self,
QApplication.translate(
'ForeignKeyMapper',
'Widget Creation Error'
),
msg
)
#Set searchable columns
if c.searchable:
self._searchable_columns[header] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'ForeignKeyMapper',
u'The following columns have been defined in the '
u'configuration but are missing in corresponding '
u'database table, please re-run the configuration wizard '
u'to create them.\n{0}'.format(
'\n'.join(missing_columns)
)
)
QMessageBox.warning(
self,
QApplication.translate('ForeignKeyMapper','Entity Browser'),
msg
)
self._tableModel = BaseSTDMTableModel([], self._headers, self)
self._tbFKEntity.setModel(self._tableModel)
self._tbFKEntity.resizeColumnsToContents()
#First (id) column will always be hidden
self._tbFKEntity.hideColumn(0)
self._tbFKEntity.horizontalHeader().setResizeMode(
QHeaderView.Interactive
)
self._tbFKEntity.verticalHeader().setVisible(True)
class EntityBrowser(SupportsManageMixin, QDialog, Ui_EntityBrowser):
"""
Dialog for browsing entity records in a table view.
"""
# Custom signal that is raised when the dialog
# is in SELECT state. It contains
# the record id of the selected row.
recordSelected = pyqtSignal(int)
def __init__(self,
entity,
parent=None,
state=MANAGE,
load_records=True,
plugin=None):
QDialog.__init__(self, parent)
self.setupUi(self)
# Add maximize buttons
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMaximizeButtonHint)
SupportsManageMixin.__init__(self, state)
# Init document viewer setup
self._view_docs_act = None
viewer_title = QApplication.translate('EntityBrowser',
'Document Viewer')
self.doc_viewer_title = u'{0} {1}'.format(entity.ui_display(),
viewer_title)
self._doc_viewer = _EntityDocumentViewerHandler(
self.doc_viewer_title, self)
self.load_records = load_records
#Initialize toolbar
self.plugin = plugin
self.tbActions = QToolBar()
self.tbActions.setObjectName('eb_actions_toolbar')
self.tbActions.setIconSize(QSize(16, 16))
self.tbActions.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.vlActions.addWidget(self.tbActions)
self._entity = entity
self._dbmodel = entity_model(entity)
self._state = state
self._tableModel = None
self._parent = parent
self._data_initialized = False
self._notifBar = NotificationBar(self.vlNotification)
self._headers = []
self._entity_attrs = []
self._cell_formatters = {}
self.filtered_records = []
self._searchable_columns = OrderedDict()
self._show_docs_col = False
self.child_model = OrderedDict()
#ID of a record to select once records have been added to the table
self._select_item = None
self.current_records = 0
self.record_limit = self.get_records_limit(
) #get_entity_browser_record_limit()
#Enable viewing of supporting documents
if self.can_view_supporting_documents:
self._add_view_supporting_docs_btn()
self._add_advanced_search_btn()
#Connect signals
self.buttonBox.accepted.connect(self.onAccept)
self.tbEntity.doubleClicked[QModelIndex].connect(
self.onDoubleClickView)
def get_records_limit(self):
records = get_entity_browser_record_limit()
if records == 0:
records = pg_table_count(self.entity.name)
return records
def children_entities(self):
"""
:return: Returns a list of children entities
that refer to the main entity as the parent.
:rtype: list
"""
return [
ch for ch in self._entity.children()
if ch.TYPE_INFO == Entity.TYPE_INFO
]
@property
def entity(self):
"""
:return: Returns the Entity object used in this browser.
:rtype: Entity
"""
return self._entity
@property
def can_view_supporting_documents(self):
"""
:return: True if the browser supports the viewing of supporting
documents.
:rtype: bool
"""
test_ent_obj = self._dbmodel()
if self._entity.supports_documents \
and hasattr(test_ent_obj, 'documents'):
return True
return False
def _add_view_supporting_docs_btn(self):
#Add button for viewing supporting documents if supported
view_docs_str = QApplication.translate('EntityBrowser',
'View Documents')
self._view_docs_act = QAction(
QIcon(':/plugins/stdm/images/icons/document.png'), view_docs_str,
self)
#Connect signal for showing document viewer
self._view_docs_act.triggered.connect(self.on_load_document_viewer)
self.tbActions.addAction(self._view_docs_act)
def _add_advanced_search_btn(self):
#Add button for viewing supporting documents if supported
search_str = QApplication.translate('EntityBrowser', 'Advanced Search')
self._search_act = QAction(
QIcon(':/plugins/stdm/images/icons/advanced_search.png'),
search_str, self)
#Connect signal for showing document viewer
self._search_act.triggered.connect(self.on_advanced_search)
self.tbActions.addAction(self._search_act)
def dateFormatter(self):
"""
Function for formatting date values
"""
return self._dateFormatter
def setDateFormatter(self, formatter):
"""
Sets the function for formatting date values. Overrides the default function.
"""
self._dateFormatter = formatter
def state(self):
'''
Returns the current state that the dialog has been configured in.
'''
return self._state
def setState(self, state):
'''
Set the state of the dialog.
'''
self._state = state
def set_selection_record_id(self, id):
"""
Set the ID of a record to be selected only once all records have been
added to the table view.
:param id: Record id to be selected.
:type id: int
"""
self._select_item = id
def title(self):
'''
Set the title of the entity browser dialog.
Protected method to be overridden by subclasses.
'''
records = QApplication.translate('EntityBrowser', 'Records')
if self._entity.label != '':
title = self._entity.label
else:
title = self._entity.ui_display()
return u'{} {}'.format(title, records)
def setCellFormatters(self, formattermapping):
'''
Dictionary of attribute mappings and corresponding functions for
formatting the attribute value to the display value.
'''
self._cell_formatters = formattermapping
def addCellFormatter(self, attributeName, formatterFunc):
'''
Add a new cell formatter configuration to the collection
'''
self._cell_formatters[attributeName] = formatterFunc
def showEvent(self, showEvent):
'''
Override event for loading the database records once the dialog is visible.
This is for improved user experience i.e. to prevent the dialog from taking
long to load.
'''
self.setWindowTitle(unicode(self.title()))
if self._data_initialized:
return
try:
if not self._dbmodel is None:
# cProfile.runctx('self._initializeData()', globals(), locals())
self._initializeData()
except Exception as ex:
pass
self._data_initialized = True
def hideEvent(self, hideEvent):
'''
Override event which just sets a flag to indicate that the data records have already been
initialized.
'''
pass
def clear_selection(self):
"""
Deselects all selected items in the table view.
"""
self.tbEntity.clearSelection()
def clear_notifications(self):
"""
Clears all notifications messages in the dialog.
"""
self._notifBar.clear()
def recomputeRecordCount(self, init_data=False):
'''
Get the number of records in the specified table and updates the window title.
'''
entity = self._dbmodel()
# Get number of records
numRecords = entity.queryObject().count()
if init_data:
if self.current_records < 1:
if numRecords > self.record_limit:
self.current_records = self.record_limit
else:
self.current_records = numRecords
rowStr = QApplication.translate('EntityBrowser', 'row') \
if numRecords == 1 \
else QApplication.translate('EntityBrowser', 'rows')
showing = QApplication.translate('EntityBrowser', 'Showing')
windowTitle = u"{0} - {1} {2} of {3} {4}".format(
self.title(), showing, self.current_records, numRecords, rowStr)
self.setWindowTitle(windowTitle)
return numRecords
def _init_entity_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
#Iterate entity column and assert if they exist
for c in self._entity.columns.values():
# Exclude geometry columns
if isinstance(c, GeometryColumn):
continue
# Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.ui_display()
self._headers.append(header)
col_name = c.name
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
# Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
# Set searchable columns
if c.searchable:
self._searchable_columns[c.ui_display()] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'EntityBrowser',
u'The following columns have been defined in the '
u'configuration but are missing in corresponding '
u'database table, please re-run the configuration wizard '
u'to create them.\n{0}'.format('\n'.join(missing_columns)))
QMessageBox.warning(
self, QApplication.translate('EntityBrowser',
'Entity Browser'), msg)
def _select_record(self, id):
#Selects record with the given ID.
if id is None:
return
m = self.tbEntity.model()
s = self.tbEntity.selectionModel()
start_idx = m.index(0, 0)
idxs = m.match(start_idx, Qt.DisplayRole, id, 1, Qt.MatchExactly)
if len(idxs) > 0:
sel_idx = idxs[0]
#Select item
s.select(
sel_idx,
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def on_advanced_search(self):
search = AdvancedSearch(self._entity, parent=self)
search.show()
def on_load_document_viewer(self):
#Slot raised to show the document viewer for the selected entity
sel_rec_ids = self._selected_record_ids()
if len(sel_rec_ids) == 0:
return
#Get document objects
ent_obj = self._dbmodel()
for sel_id in sel_rec_ids:
er = ent_obj.queryObject().filter(
self._dbmodel.id == sel_id).first()
if not er is None:
docs = er.documents
#Notify there are no documents for the selected doc
if len(docs) == 0:
msg = QApplication.translate(
'EntityBrowser',
'There are no supporting documents for the selected record.'
)
QMessageBox.warning(self, self.doc_viewer_title, msg)
continue
self._doc_viewer.load(docs)
def _initializeData(self, filtered_records=None):
'''
Set table model and load data into it.
'''
if self._dbmodel is None:
msg = QApplication.translate(
'EntityBrowser',
'The data model for the entity could not be loaded, \n'
'please contact your database administrator.')
QMessageBox.critical(
self, QApplication.translate('EntityBrowser',
'Entity Browser'), msg)
else:
self._init_entity_columns()
# Load entity data. There might be a better way in future in order
# to ensure that there is a balance between user data discovery
# experience and performance.
if filtered_records is not None:
self.current_records = filtered_records.rowcount
numRecords = self.recomputeRecordCount(init_data=True)
# Load progress dialog
progressLabel = QApplication.translate("EntityBrowser",
"Fetching Records...")
progressDialog = QProgressDialog(progressLabel, None, 0,
numRecords, self)
QApplication.processEvents()
progressDialog.show()
progressDialog.setValue(0)
# Add records to nested list for enumeration in table model
load_data = True
if self.plugin is not None:
if self._entity.name in self.plugin.entity_table_model.keys():
if filtered_records is None:
self._tableModel = self.plugin.entity_table_model[
self._entity.name]
if isinstance(self._parent, EntityEditorDialog):
load_data = True
if load_data:
# Only one filter is possible.
if len(self.filtered_records) > 0:
entity_records = self.filtered_records
else:
entity_cls = self._dbmodel()
entity_records = entity_cls.queryObject().filter().limit(
self.record_limit).all()
# if self._tableModel is None:
entity_records_collection = []
for i, er in enumerate(entity_records):
if i == self.record_limit:
break
QApplication.processEvents()
entity_row_info = []
progressDialog.setValue(i)
try:
for attr in self._entity_attrs:
attr_val = getattr(er, attr)
# Check if there are display formatters and apply if
# one exists for the given attribute.
if attr_val is not None: # No need of formatter for None value
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(
attr_val)
entity_row_info.append(attr_val)
except Exception as ex:
QMessageBox.critical(
self,
QApplication.translate('EntityBrowser',
'Loading Records'),
unicode(ex.message))
return
entity_records_collection.append(entity_row_info)
self._tableModel = BaseSTDMTableModel(
entity_records_collection, self._headers, self)
if self.plugin is not None:
self.plugin.entity_table_model[self._entity.name] = \
self._tableModel
# Add filter columns
for header, info in self._searchable_columns.iteritems():
column_name, index = info['name'], info['header_index']
if column_name != 'id':
self.cboFilterColumn.addItem(header, info)
#Use sortfilter proxy model for the view
self._proxyModel = VerticalHeaderSortFilterProxyModel()
self._proxyModel.setDynamicSortFilter(True)
self._proxyModel.setSourceModel(self._tableModel)
self._proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
#USe first column in the combo for filtering
if self.cboFilterColumn.count() > 0:
self.set_proxy_model_filter_column(0)
self.tbEntity.setModel(self._proxyModel)
if numRecords < self.record_limit:
self.tbEntity.setSortingEnabled(True)
self.tbEntity.sortByColumn(1, Qt.AscendingOrder)
#First (ID) column will always be hidden
self.tbEntity.hideColumn(0)
self.tbEntity.horizontalHeader().setResizeMode(
QHeaderView.Interactive)
self.tbEntity.resizeColumnsToContents()
#Connect signals
self.connect(self.cboFilterColumn,
SIGNAL('currentIndexChanged (int)'),
self.onFilterColumnChanged)
self.connect(self.txtFilterPattern,
SIGNAL('textChanged(const QString&)'),
self.onFilterRegExpChanged)
#Select record with the given ID if specified
if not self._select_item is None:
self._select_record(self._select_item)
if numRecords > 0:
# Set maximum value of the progress dialog
progressDialog.setValue(numRecords)
else:
progressDialog.hide()
def _header_index_from_filter_combo_index(self, idx):
col_info = self.cboFilterColumn.itemData(idx)
return col_info['name'], col_info['header_index']
def set_proxy_model_filter_column(self, index):
#Set the filter column for the proxy model using the combo index
name, header_idx = self._header_index_from_filter_combo_index(index)
self._proxyModel.setFilterKeyColumn(header_idx)
def onFilterColumnChanged(self, index):
'''
Set the filter column for the proxy model.
'''
self.set_proxy_model_filter_column(index)
def _onFilterRegExpChanged(self, text):
cProfile.runctx('self._onFilterRegExpChanged(text)', globals(),
locals())
def onFilterRegExpChanged(self, text):
'''
Slot raised whenever the filter text changes.
'''
regExp = QRegExp(text, Qt.CaseInsensitive, QRegExp.FixedString)
self._proxyModel.setFilterRegExp(regExp)
def onDoubleClickView(self, modelindex):
'''
Slot raised upon double clicking the table view.
To be implemented by subclasses.
'''
pass
def _selected_record_ids(self):
'''
Get the IDs of the selected row in the table view.
'''
self._notifBar.clear()
selected_ids = []
sel_row_indices = self.tbEntity.selectionModel().selectedRows(0)
if len(sel_row_indices) == 0:
msg = QApplication.translate(
"EntityBrowser", "Please select a record from the table.")
self._notifBar.insertWarningNotification(msg)
return selected_ids
for proxyRowIndex in sel_row_indices:
#Get the index of the source or else the row items will have unpredictable behavior
row_index = self._proxyModel.mapToSource(proxyRowIndex)
entity_id = row_index.data(Qt.DisplayRole)
selected_ids.append(entity_id)
return selected_ids
def onAccept(self):
'''
Slot raised when user clicks to accept the dialog. The resulting action will be dependent
on the state that the browser is currently configured in.
'''
selIDs = self._selected_record_ids()
if len(selIDs) == 0:
return
if self._mode == SELECT:
#Get all selected records
for sel_id in selIDs:
self.recordSelected.emit(sel_id)
rec_selected = QApplication.translate('EntityBrowser',
'record(s) selected')
msg = u'{0:d} {1}.'.format(len(selIDs), rec_selected)
self._notifBar.insertInformationNotification(msg)
def addModelToView(self, model_obj):
'''
Convenience method for adding model info into the view.
'''
insertPosition = self._tableModel.rowCount()
self._tableModel.insertRows(insertPosition, 1)
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(insertPosition, i)
attr_val = getattr(model_obj, attr)
'''
Check if there are display formatters and apply if one exists
for the given attribute.
'''
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
return insertPosition
def _model_from_id(self, record_id, row_number):
'''
Convenience method that returns the model object based on its ID.
'''
dbHandler = self._dbmodel()
modelObj = dbHandler.queryObject().filter(
self._dbmodel.id == record_id).first()
if modelObj is None:
modelObj = self.child_model[row_number + 1, self.entity]
return modelObj if not modelObj is None else None
class ForeignKeyMapper(QWidget):
"""
Widget for selecting database records through an entity browser or
using an ExpressionBuilder for filtering records.
"""
#Custom signals
beforeEntityAdded = pyqtSignal("PyQt_PyObject")
afterEntityAdded = pyqtSignal("PyQt_PyObject", int)
entityRemoved = pyqtSignal("PyQt_PyObject")
deletedRows = pyqtSignal(list)
def __init__(self, entity, parent=None, notification_bar=None,
enable_list=True, can_filter=False, plugin=None):
QWidget.__init__(self, parent)
self.current_profile = current_profile()
self._tbFKEntity = QTableView(self)
self._tbFKEntity.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._tbFKEntity.setAlternatingRowColors(True)
self._tbFKEntity.setSelectionBehavior(QAbstractItemView.SelectRows)
self.plugin = plugin
self._add_entity_btn = QToolButton(self)
self._add_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper","Add"))
self._add_entity_btn.setIcon(
QIcon(":/plugins/stdm/images/icons/add.png"))
self._add_entity_btn.clicked.connect(self.onAddEntity)
self._edit_entity_btn = QToolButton(self)
self._edit_entity_btn.setVisible(False)
self._edit_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper","Edit"))
self._edit_entity_btn.setIcon(
QIcon(":/plugins/stdm/images/icons/edit.png"))
self._filter_entity_btn = QToolButton(self)
self._filter_entity_btn.setVisible(False)
self._filter_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper","Select by expression"))
self._filter_entity_btn.setIcon(
QIcon(":/plugins/stdm/images/icons/filter.png"))
self._filter_entity_btn.clicked.connect(self.onFilterEntity)
self._delete_entity_btn = QToolButton(self)
self._delete_entity_btn.setToolTip(
QApplication.translate("ForeignKeyMapper","Remove"))
self._delete_entity_btn.setIcon(
QIcon(":/plugins/stdm/images/icons/remove.png"))
self._delete_entity_btn.clicked.connect(self.onRemoveEntity)
layout = QVBoxLayout(self)
layout.setSpacing(4)
layout.setMargin(5)
self.grid_layout = QGridLayout(self)
self.grid_layout.setHorizontalSpacing(5)
self.grid_layout.addWidget(self._add_entity_btn, 0, 0, 1, 1)
self.grid_layout.addWidget(self._filter_entity_btn, 0, 1, 1, 1)
self.grid_layout.addWidget(self._edit_entity_btn, 0, 2, 1, 1)
self.grid_layout.addWidget(self._delete_entity_btn, 0, 3, 1, 1)
self.grid_layout.setColumnStretch(4, 5)
layout.addLayout(self.grid_layout)
layout.addWidget(self._tbFKEntity)
self.social_tenure = self.current_profile.social_tenure
self._tableModel = None
self._notifBar = notification_bar
self._headers = []
self._entity_attrs = []
self._cell_formatters = {}
self._searchable_columns = OrderedDict()
self._supportsLists = enable_list
self._deleteOnRemove = False
self._uniqueValueColIndices = OrderedDict()
self.global_id = None
self._deferred_objects = {}
self._use_expression_builder = can_filter
if self._use_expression_builder:
self._filter_entity_btn.setVisible(True)
self._edit_entity_btn.setVisible(False)
self.set_entity(entity)
def set_entity(self, entity):
"""
Sets new entity and updates the ForeignKeyMapper with a new
:param entity: The entity of the ForeignKeyMapper
:type entity:Object
"""
from stdm.ui.entity_browser import EntityBrowser
self._entity = entity
self._dbmodel = entity_model(entity)
self._init_fk_columns()
self._entitySelector = EntityBrowser(
self._entity,
parent=self,
state=SELECT,
plugin=self.plugin
)
# Connect signals
self._entitySelector.recordSelected.connect(
self._onRecordSelectedEntityBrowser
)
def _init_fk_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
self._entity_attrs[:] = []
if self._dbmodel is None:
msg = QApplication.translate(
'ForeignKeyMapper', 'The data model for '
'the entity could '
'not be loaded, '
'please contact '
'your database '
'administrator.'
)
QMessageBox.critical(
self,
QApplication.translate(
'EntityBrowser',
'Entity Browser'
),
msg
)
return
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
#Iterate entity column and assert if they exist
for c in self._entity.columns.values():
#Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.header()
self._headers.append(header)
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
col_name = c.name
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
#Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
try:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
except WidgetException as we:
msg = QApplication.translate(
'ForeignKeyMapper',
'Error in creating column:'
)
msg = '{0} {1}:{2}\n{3}'.format(
msg, self._entity.name, c.name, unicode(we)
)
QMessageBox.critical(
self,
QApplication.translate(
'ForeignKeyMapper',
'Widget Creation Error'
),
msg
)
#Set searchable columns
if c.searchable:
self._searchable_columns[header] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'ForeignKeyMapper',
u'The following columns have been defined in the '
u'configuration but are missing in corresponding '
u'database table, please re-run the configuration wizard '
u'to create them.\n{0}'.format(
'\n'.join(missing_columns)
)
)
QMessageBox.warning(
self,
QApplication.translate('ForeignKeyMapper','Entity Browser'),
msg
)
self._tableModel = BaseSTDMTableModel([], self._headers, self)
self._tbFKEntity.setModel(self._tableModel)
self._tbFKEntity.resizeColumnsToContents()
#First (id) column will always be hidden
self._tbFKEntity.hideColumn(0)
self._tbFKEntity.horizontalHeader().setResizeMode(
QHeaderView.Interactive
)
self._tbFKEntity.verticalHeader().setVisible(True)
def databaseModel(self):
'''
Returns the database model that represents the foreign key entity.
'''
return self._dbmodel
def setDatabaseModel(self,model):
'''
Set the database model that represents the foreign key entity.
Model has to be a callable.
'''
self._dbmodel = model
def cellFormatters(self):
"""
Returns a dictionary of cell formatters used by the foreign key mapper.
"""
return self._cell_formatters
def cell_formatter(self, column):
"""
:param column: Column name:
:type column: str
:return: Returns the corresponding formatter object based on the
column name. None will be returned if there is no corresponding
object.
:rtype: object
"""
return self._cell_formatters.get(column, None)
def entitySelector(self):
'''
Returns the dialog for selecting the entity objects.
'''
return self._entitySelector
def supportList(self):
'''
Returns whether the mapper supports only one item or multiple entities.
Default is 'True'.
'''
return self._supportsLists
def setSupportsList(self,supportsList):
'''
Sets whether the mapper supports only one item or multiple entities i.e.
one-to-one (False) and one-to-many mapping (True).
'''
self._supportsLists = supportsList
def setNotificationBar(self,notificationBar):
'''
Set the notification bar for displaying user messages.
'''
self._notifBar = notificationBar
def viewModel(self):
'''
Return the view model used by the table view.
'''
return self._tableModel
def set_expression_builder(self, state):
"""
Set the mapper to use QGIS expression builder as the entity selector.
"""
self._use_expression_builder = state
def expression_builder_enabled(self):
"""
Returns whether the mapper has been configured to use the expression builder
"""
return self._use_expression_builder
def deleteOnRemove(self):
'''
Returns the state whether a record should be deleted from the database when it
is removed from the list.
'''
return self._deleteOnRemove
def setDeleteonRemove(self,delete):
'''
Set whether whether a record should be deleted from the database when it
is removed from the list.
'''
self._deleteOnRemove = delete
def addUniqueColumnName(self,colName,replace = True):
'''
Set the name of the column whose values are to be unique.
If 'replace' is True then the existing row will be replaced
with one with the new value; else, the new row will not be added to the list.
'''
headers = self._dbmodel.displayMapping().values()
colIndex = getIndex(headers,colName)
if colIndex != -1:
self.addUniqueColumnIndex(colIndex, replace)
def addUniqueColumnIndex(self,colIndex,replace = True):
'''
Set the index of the column whose values are to be unique. The column indices are
zero-based.
If 'replace' is True then the existing row will be replaced with the
new value; else, the new row will not be added to the list.
For multiple replace rules defined, then the first one added to the collection is the
one that will be applied.
'''
self._uniqueValueColIndices[colIndex] = replace
def onFilterEntity(self):
"""
Slot raised to load the expression builder dialog.
"""
vl, msg = self.vector_layer()
if vl is None:
msg = msg + "\n" + QApplication.translate("ForeignKeyMapper",
"The expression builder cannot be used at this moment.")
QMessageBox.critical(self, QApplication.translate("ForeignKeyMapper",
"Expression Builder"), msg)
return
context = self._entity.short_name
filter_dlg = ForeignKeyMapperExpressionDialog(vl, self, context=context)
filter_dlg.setWindowTitle(QApplication.translate("ForeignKeyMapper",
"Filter By Expression"))
filter_dlg.recordSelected[int].connect(self._onRecordSelectedEntityBrowser)
res = filter_dlg.exec_()
def _removeRow(self,rowNumber):
'''
Remove the row at the given index.
'''
self._tableModel.removeRows(rowNumber, 1)
def onRemoveEntity(self):
'''
Slot raised on clicking to remove the selected entity.
'''
selectedRowIndices = self._tbFKEntity.selectionModel().selectedRows(0)
deleted_rows = []
if len(selectedRowIndices) == 0:
msg = QApplication.translate(
"ForeignKeyMapper",
"Please select the record to be removed."
)
self._notifBar.clear()
self._notifBar.insertWarningNotification(msg)
return
for selectedRowIndex in selectedRowIndices:
#Delete record from database if flag has been set to True
recId= selectedRowIndex.data()
dbHandler = self._dbmodel()
delRec = dbHandler.queryObject().filter(self._dbmodel.id == recId).first()
if not delRec is None:
self.entityRemoved.emit(delRec)
if self._deleteOnRemove:
delRec.delete()
self._removeRow(selectedRowIndex.row())
deleted_rows.append(selectedRowIndex.row())
self.deletedRows.emit(deleted_rows)
def _recordIds(self):
'''
Returns the primary keys of the records in the table.
'''
recordIds = []
if self._tableModel:
rowCount = self._tableModel.rowCount()
for r in range(rowCount):
#Get ID value
modelIndex = self._tableModel.index(r, 0)
modelId = modelIndex.data()
recordIds.append(modelId)
return recordIds
def entities(self):
'''
Returns the model instance(s) depending on the configuration specified by the user.
'''
recIds = self._recordIds()
modelInstances = self._modelInstanceFromIds(recIds)
if len(modelInstances) == 0:
if self._supportsLists:
return []
else:
return None
else:
if self._supportsLists:
return modelInstances
else:
return modelInstances[0]
def setEntities(self, entities):
'''
Insert entities into the table.
'''
if isinstance(entities, list):
for entity in entities:
self._insertModelToView(entity)
else:
self._insertModelToView(entities)
def searchModel(self, columnIndex, columnValue):
'''
Searches for 'columnValue' in the column whose index is specified by 'columnIndex' in all
rows contained in the model.
'''
if isinstance (columnValue, QVariant):
columnValue = unicode(columnValue.toString())
if not isinstance(columnValue, str) or \
not isinstance(columnValue, unicode):
columnValue = unicode(columnValue)
columnValue = columnValue.strip()
proxy = QSortFilterProxyModel(self)
proxy.setSourceModel(self._tableModel)
proxy.setFilterKeyColumn(columnIndex)
proxy.setFilterFixedString(columnValue)
#Will return model index containing the primary key.
matchingIndex = proxy.mapToSource(proxy.index(0,0))
return matchingIndex
def _modelInstanceFromIds(self,ids):
'''
Returns the model instance based the value of its primary key.
'''
dbHandler = self._dbmodel()
modelInstances = []
for modelId in ids:
modelObj = dbHandler.queryObject().filter(self._dbmodel.id == modelId).first()
if not modelObj is None:
modelInstances.append(modelObj)
return modelInstances
def _onRecordSelectedEntityBrowser(self, rec, row_number=-1):
'''
Slot raised when the user has clicked the select button
in the 'EntityBrowser' dialog
to add the selected record to the table's list.
Add the record to the foreign key table using the mappings.
'''
#Check if the record exists using the primary key so as to ensure
#only one instance is added to the table
if isinstance(rec, int):
recIndex = getIndex(self._recordIds(), rec)
if recIndex != -1:
return
dbHandler = self._dbmodel()
modelObj = dbHandler.queryObject().filter(self._dbmodel.id == rec).first()
elif isinstance(rec, object):
modelObj = rec
else:
return
if not modelObj is None:
#Raise before entity added signal
self.beforeEntityAdded.emit(modelObj)
#Validate for unique value configurations
'''
if not self._validate_unique_columns(modelObj, row_number):
return
'''
if not self._supportsLists and self._tableModel.rowCount() > 0:
self._removeRow(0)
insert_position = self._insertModelToView(modelObj, row_number)
if isinstance(rec, object):
self._deferred_objects[insert_position] = modelObj
def _validate_unique_columns(self,model,exclude_row = -1):
"""
Loop through the attributes of the model to assert
for existing row values that should be unique based on
the configuration of unique columns.
"""
for colIndex,replace in self._uniqueValueColIndices.items():
attrName = self._dbmodel.displayMapping().keys()[colIndex]
attrValue = getattr(model,attrName)
# Check to see if there are cell formatters so
# that the correct value is searched for in the model
if attrName in self._cell_formatters:
attrValue = self._cell_formatters[attrName](attrValue)
matchingIndex = self.searchModel(colIndex, attrValue)
if matchingIndex.isValid() and matchingIndex.row() != exclude_row:
if replace:
existingId = matchingIndex.data()
#Delete old record from db
entityModels = self._modelInstanceFromIds([existingId])
if len(entityModels) > 0:
entityModels[0].delete()
self._removeRow(matchingIndex.row())
return True
else:
#Break. Do not add item to the list.
return False
return True
def _insertModelToView(self, model_obj, row_number = -1):
"""
Insert the given database model instance into the view
at the given row number position.
"""
if row_number == -1:
row_number = self._tableModel.rowCount()
self._tableModel.insertRows(row_number, 1)
#In some instances, we will need to get the model object with
# backrefs included else exceptions will be raised on missing
# attributes
q_objs = self._modelInstanceFromIds([model_obj.id])
if len(q_objs) == 0:
return
model_obj = q_objs[0]
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(row_number, i)
attr_val = getattr(model_obj, attr)
'''
Check if there are display formatters and apply if one exists
for the given attribute.
'''
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
#Raise signal once entity has been inserted
self.afterEntityAdded.emit(model_obj, row_number)
self._tbFKEntity.resizeColumnsToContents()
return row_number
def insert_model_to_table(self, model_obj, row_number=-1):
"""
Insert the given database model instance into the view
at the given row number position.
"""
if row_number == -1:
row_number = self._tableModel.rowCount()
self._tableModel.insertRows(row_number, 1)
# In some instances, we will need to get the model object with
# backrefs included else exceptions will be raised on missing
# attributes
q_objs = self._modelInstanceFromIds([model_obj.id])
if len(q_objs) == 0:
return
model_obj = q_objs[0]
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(row_number, i)
attr_val = getattr(model_obj, attr)
# Check if there are display formatters and apply if one exists
# for the given attribute.
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
self._tbFKEntity.resizeColumnsToContents()
return row_number
def remove_rows(self):
"""
Removes rows from the fk browser.
"""
row_count = self._tbFKEntity.model().rowCount()
self._tbFKEntity.model().removeRows(0, row_count)
def vector_layer(self):
"""
Returns a QgsVectorLayer based on the configuration information
specified in the mapper including the system-wide data connection
properties.
"""
from stdm.data.pg_utils import vector_layer
if self._dbmodel is None:
msg = QApplication.translate("ForeignKeyMapper",
"Primary database model object not defined.")
return None, msg
filter_layer = vector_layer(self._entity.name)
if filter_layer is None:
msg = QApplication.translate("ForeignKeyMapper",
"Vector layer could not be constructed from the database table.")
return None, msg
if not filter_layer.isValid():
trans_msg = QApplication.translate("ForeignKeyMapper",
u"The vector layer for '{0}' table is invalid.")
msg = trans_msg.format(self._entity.name)
return None, msg
return filter_layer, ""
def onAddEntity(self):
"""
Slot raised on selecting to add related entities that will be mapped to the primary
database model instance.
"""
self._entitySelector.buttonBox.button(QDialogButtonBox.Cancel).setVisible(False)
#Clear any previous selections in the entity browser
self._entitySelector.clear_selection()
#Clear any previous notifications
self._entitySelector.clear_notifications()
self._entitySelector.exec_()
def __init__(
self, table_data, headers, parent = None, *args
):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(
table_data, headers, parent
)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(
Qt.StrongFocus|Qt.TabFocus|Qt.ClickFocus
)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers
)
self.set_size()
self.signals()
class FreezeTableWidget(QTableView):
def __init__(
self, table_data, headers, parent = None, *args
):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(
table_data, headers, parent
)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(
Qt.StrongFocus|Qt.TabFocus|Qt.ClickFocus
)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff
)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel
)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers
)
self.set_size()
self.signals()
def set_size(self):
"""
Sets the size and size policy of the tables.
:return:
:rtype:
"""
size_policy = QSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Fixed
)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(
self.sizePolicy().hasHeightForWidth()
)
self.setSizePolicy(size_policy)
self.setMinimumSize(QSize(55, 75))
self.setMaximumSize(QSize(5550, 5555))
self.SelectionMode(
QAbstractItemView.SelectColumns
)
# set column width to fit contents
self.frozen_table_view.resizeColumnsToContents()
# set row height
self.frozen_table_view.resizeRowsToContents()
def signals(self):
"""
Connects signals of the tables.
"""
# Connect the headers and scrollbars of
# both tableviews together
self.horizontalHeader().sectionResized.connect(
self.update_section_width
)
self.verticalHeader().sectionResized.connect(
self.update_section_height
)
self.frozen_table_view.verticalScrollBar().valueChanged.connect(
self.verticalScrollBar().setValue
)
self.verticalScrollBar().valueChanged.connect(
self.frozen_table_view.verticalScrollBar().setValue
)
def set_column_width(self):
"""
Sets the column width of the frozen QTableView.
"""
# Set the width of columns
columns_count = self.table_model.columnCount(self)
for col in range(columns_count):
if col == 0:
# Set the size
self.horizontalHeader().resizeSection(
col, 60
)
# Fix width
self.horizontalHeader().setResizeMode(
col, QHeaderView.Fixed
)
# Width of a fixed column - as in the main widget
self.frozen_table_view.setColumnWidth(
col, self.columnWidth(col)
)
elif col == 1:
self.horizontalHeader().resizeSection(
col, 150
)
self.horizontalHeader().setResizeMode(
col, QHeaderView.Fixed
)
self.frozen_table_view.setColumnWidth(
col, self.columnWidth(col)
)
else:
self.horizontalHeader().resizeSection(
col, 150
)
# Hide unnecessary columns in the
# widget fixed columns
self.frozen_table_view.setColumnHidden(
col, True
)
def add_widgets(self, spatial_unit, insert_row):
"""
Adds widget into the frozen table.
:param str_type_id: The STR type id of the tenure type combobox
:type str_type_id: Integer
:param insert_row: The row number the widgets to be added.
:type insert_row: Integer
"""
delegate = STRTypeDelegate(spatial_unit)
# Set delegate to add combobox under
# social tenure type column
self.frozen_table_view.setItemDelegate(
delegate
)
self.frozen_table_view.setItemDelegateForColumn(
0, delegate
)
index = self.frozen_table_view.model().index(
insert_row, 0, QModelIndex()
)
self.frozen_table_view.model().setData(
index, '', Qt.EditRole
)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 0)
)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 1)
)
def update_section_width(
self, logicalIndex, oldSize, newSize
):
"""
Updates frozen table column width and geometry.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
if logicalIndex==0 or logicalIndex==1:
self.frozen_table_view.setColumnWidth(
logicalIndex, newSize
)
self.update_frozen_table_geometry()
def update_section_height(
self, logicalIndex, oldSize, newSize
):
"""
Updates frozen table column height.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
self.frozen_table_view.setRowHeight(
logicalIndex, newSize
)
def resizeEvent(self, event):
"""
Handles the resize event of the frozen table view.
It updates the frozen table view geometry on resize of table.
:param event: The event
:type event: QEvent
"""
QTableView.resizeEvent(self, event)
try:
self.update_frozen_table_geometry()
except Exception as log:
LOGGER.debug(str(log))
def scrollTo(self, index, hint):
"""
Scrolls the view if necessary to ensure that the item at index is
visible. The view will try to position the item according to the
given hint.
:param index: The scroll index
:type index: QModelIndex
:param hint: The scroll hint
:type hint: Integer
"""
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def update_frozen_table_geometry(self):
"""
Updates the frozen table view geometry.
"""
if self.verticalHeader().isVisible():
self.frozen_table_view.setGeometry(
self.verticalHeader().width() +
self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() +
self.horizontalHeader().height()
)
else:
self.frozen_table_view.setGeometry(
self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() +
self.horizontalHeader().height()
)
def move_cursor(self, cursor_action, modifiers):
"""
Override function for correct left to scroll the keyboard.
Returns a QModelIndex object pointing to the next object in the
table view, based on the given cursorAction and keyboard modifiers
specified by modifiers.
:param cursor_action: The cursor action
:type cursor_action: Integer
:param modifiers: Qt.KeyboardModifier value.
:type modifiers: Object
:return: The current cursor position.
:rtype: QModelIndex
"""
current = QTableView.move_cursor(
self, cursor_action, modifiers
)
if cursor_action == self.MoveLeft and current.column() > 1 and \
self.visualRect(current).topLeft().x() < \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1)):
new_value = self.horizontalScrollBar().value() + \
self.visualRect(current).topLeft().x() - \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1))
self.horizontalScrollBar().setValue(new_value)
return current
def _initializeData(self, filtered_records=None):
'''
Set table model and load data into it.
'''
if self._dbmodel is None:
msg = QApplication.translate(
'EntityBrowser',
'The data model for the entity could not be loaded, \n'
'please contact your database administrator.'
)
QMessageBox.critical(
self,
QApplication.translate('EntityBrowser', 'Entity Browser'),
msg
)
else:
self._init_entity_columns()
# Load entity data. There might be a better way in future in order
# to ensure that there is a balance between user data discovery
# experience and performance.
if filtered_records is not None:
self.current_records = filtered_records.rowcount
numRecords = self.recomputeRecordCount(init_data=True)
# Load progress dialog
progressLabel = QApplication.translate(
"EntityBrowser", "Fetching Records..."
)
progressDialog = QProgressDialog(
progressLabel, None, 0, numRecords, self
)
QApplication.processEvents()
progressDialog.show()
progressDialog.setValue(0)
# Add records to nested list for enumeration in table model
load_data = True
if self.plugin is not None:
if self._entity.name in self.plugin.entity_table_model.keys():
if filtered_records is None:
self._tableModel = self.plugin.entity_table_model[
self._entity.name
]
if isinstance(self._parent, EntityEditorDialog):
load_data = True
if load_data:
# Only one filter is possible.
if len(self.filtered_records) > 0:
entity_records = self.filtered_records
else:
entity_cls = self._dbmodel()
entity_records = entity_cls.queryObject().filter().limit(
self.record_limit
).all()
# if self._tableModel is None:
entity_records_collection = []
for i, er in enumerate(entity_records):
if i == self.record_limit:
break
QApplication.processEvents()
entity_row_info = []
progressDialog.setValue(i)
try:
for attr in self._entity_attrs:
attr_val = getattr(er, attr)
# Check if there are display formatters and apply if
# one exists for the given attribute.
if attr_val is not None: # No need of formatter for None value
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
entity_row_info.append(attr_val)
except Exception as ex:
QMessageBox.critical(
self,
QApplication.translate(
'EntityBrowser', 'Loading Records'
),
unicode(ex.message))
return
entity_records_collection.append(entity_row_info)
self._tableModel = BaseSTDMTableModel(
entity_records_collection, self._headers, self
)
if self.plugin is not None:
self.plugin.entity_table_model[self._entity.name] = \
self._tableModel
# Add filter columns
for header, info in self._searchable_columns.iteritems():
column_name, index = info['name'], info['header_index']
if column_name != 'id':
self.cboFilterColumn.addItem(header, info)
#Use sortfilter proxy model for the view
self._proxyModel = VerticalHeaderSortFilterProxyModel()
self._proxyModel.setDynamicSortFilter(True)
self._proxyModel.setSourceModel(self._tableModel)
self._proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
#USe first column in the combo for filtering
if self.cboFilterColumn.count() > 0:
self.set_proxy_model_filter_column(0)
self.tbEntity.setModel(self._proxyModel)
if numRecords < self.record_limit:
self.tbEntity.setSortingEnabled(True)
self.tbEntity.sortByColumn(1, Qt.AscendingOrder)
#First (ID) column will always be hidden
self.tbEntity.hideColumn(0)
self.tbEntity.horizontalHeader().setResizeMode(QHeaderView.Interactive)
self.tbEntity.resizeColumnsToContents()
#Connect signals
self.connect(self.cboFilterColumn, SIGNAL('currentIndexChanged (int)'), self.onFilterColumnChanged)
self.connect(self.txtFilterPattern, SIGNAL('textChanged(const QString&)'), self.onFilterRegExpChanged)
#Select record with the given ID if specified
if not self._select_item is None:
self._select_record(self._select_item)
if numRecords > 0:
# Set maximum value of the progress dialog
progressDialog.setValue(numRecords)
else:
progressDialog.hide()
class EntityBrowser(SupportsManageMixin, QDialog, Ui_EntityBrowser):
"""
Dialog for browsing entity records in a table view.
"""
# Custom signal that is raised when the dialog
# is in SELECT state. It contains
# the record id of the selected row.
recordSelected = pyqtSignal(int)
def __init__(self, entity, parent=None, state=MANAGE, load_records=True, plugin=None):
QDialog.__init__(self,parent)
self.setupUi(self)
# Add maximize buttons
self.setWindowFlags(
self.windowFlags() |
Qt.WindowSystemMenuHint |
Qt.WindowMaximizeButtonHint
)
SupportsManageMixin.__init__(self, state)
# Init document viewer setup
self._view_docs_act = None
viewer_title = QApplication.translate(
'EntityBrowser',
'Document Viewer'
)
self.doc_viewer_title = u'{0} {1}'.format(
entity.ui_display(),
viewer_title
)
self._doc_viewer = _EntityDocumentViewerHandler(
self.doc_viewer_title,
self
)
self.load_records = load_records
#Initialize toolbar
self.plugin = plugin
self.tbActions = QToolBar()
self.tbActions.setObjectName('eb_actions_toolbar')
self.tbActions.setIconSize(QSize(16, 16))
self.tbActions.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.vlActions.addWidget(self.tbActions)
self._entity = entity
self._dbmodel = entity_model(entity)
self._state = state
self._tableModel = None
self._parent = parent
self._data_initialized = False
self._notifBar = NotificationBar(self.vlNotification)
self._headers = []
self._entity_attrs = []
self._cell_formatters = {}
self.filtered_records = []
self._searchable_columns = OrderedDict()
self._show_docs_col = False
self.child_model = OrderedDict()
#ID of a record to select once records have been added to the table
self._select_item = None
self.current_records = 0
self.record_limit = self.get_records_limit() #get_entity_browser_record_limit()
#Enable viewing of supporting documents
if self.can_view_supporting_documents:
self._add_view_supporting_docs_btn()
# self._add_advanced_search_btn()
#Connect signals
self.buttonBox.accepted.connect(self.onAccept)
self.tbEntity.doubleClicked[QModelIndex].connect(self.onDoubleClickView)
def get_records_limit(self):
records = get_entity_browser_record_limit()
if records == 0:
records = pg_table_count(self.entity.name)
return records
def children_entities(self):
"""
:return: Returns a list of children entities
that refer to the main entity as the parent.
:rtype: list
"""
return [ch for ch in self._entity.children()
if ch.TYPE_INFO == Entity.TYPE_INFO]
@property
def entity(self):
"""
:return: Returns the Entity object used in this browser.
:rtype: Entity
"""
return self._entity
@property
def can_view_supporting_documents(self):
"""
:return: True if the browser supports the viewing of supporting
documents.
:rtype: bool
"""
test_ent_obj = self._dbmodel()
if self._entity.supports_documents \
and hasattr(test_ent_obj, 'documents'):
return True
return False
def _add_view_supporting_docs_btn(self):
#Add button for viewing supporting documents if supported
view_docs_str = QApplication.translate(
'EntityBrowser',
'View Documents'
)
self._view_docs_act = QAction(
QIcon(':/plugins/stdm/images/icons/document.png'),
view_docs_str,
self
)
#Connect signal for showing document viewer
self._view_docs_act.triggered.connect(self.on_load_document_viewer)
self.tbActions.addAction(self._view_docs_act)
# def _add_advanced_search_btn(self):
# #Add button for viewing supporting documents if supported
# search_str = QApplication.translate(
# 'EntityBrowser',
# 'Advanced Search'
# )
# self._search_act = QAction(
# QIcon(':/plugins/stdm/images/icons/advanced_search.png'),
# search_str,
# self
# )
# #Connect signal for showing document viewer
# self._search_act.triggered.connect(self.on_advanced_search)
# self.tbActions.addAction(self._search_act)
def dateFormatter(self):
"""
Function for formatting date values
"""
return self._dateFormatter
def setDateFormatter(self,formatter):
"""
Sets the function for formatting date values. Overrides the default function.
"""
self._dateFormatter = formatter
def state(self):
'''
Returns the current state that the dialog has been configured in.
'''
return self._state
def setState(self,state):
'''
Set the state of the dialog.
'''
self._state = state
def set_selection_record_id(self, id):
"""
Set the ID of a record to be selected only once all records have been
added to the table view.
:param id: Record id to be selected.
:type id: int
"""
self._select_item = id
def title(self):
'''
Set the title of the entity browser dialog.
Protected method to be overridden by subclasses.
'''
records = QApplication.translate('EntityBrowser', 'Records')
if self._entity.label != '':
title = self._entity.label
else:
title = self._entity.ui_display()
return u'{} {}'.format(title, records)
def setCellFormatters(self,formattermapping):
'''
Dictionary of attribute mappings and corresponding functions for
formatting the attribute value to the display value.
'''
self._cell_formatters = formattermapping
def addCellFormatter(self,attributeName,formatterFunc):
'''
Add a new cell formatter configuration to the collection
'''
self._cell_formatters[attributeName] = formatterFunc
def showEvent(self,showEvent):
'''
Override event for loading the database records once the dialog is visible.
This is for improved user experience i.e. to prevent the dialog from taking
long to load.
'''
self.setWindowTitle(unicode(self.title()))
if self._data_initialized:
return
try:
if not self._dbmodel is None:
# cProfile.runctx('self._initializeData()', globals(), locals())
self._initializeData()
except Exception as ex:
pass
self._data_initialized = True
def hideEvent(self,hideEvent):
'''
Override event which just sets a flag to indicate that the data records have already been
initialized.
'''
pass
def clear_selection(self):
"""
Deselects all selected items in the table view.
"""
self.tbEntity.clearSelection()
def clear_notifications(self):
"""
Clears all notifications messages in the dialog.
"""
self._notifBar.clear()
def recomputeRecordCount(self, init_data=False):
'''
Get the number of records in the specified table and updates the window title.
'''
entity = self._dbmodel()
# Get number of records
numRecords = entity.queryObject().count()
if init_data:
if self.current_records < 1:
if numRecords > self.record_limit:
self.current_records = self.record_limit
else:
self.current_records = numRecords
rowStr = QApplication.translate('EntityBrowser', 'row') \
if numRecords == 1 \
else QApplication.translate('EntityBrowser', 'rows')
showing = QApplication.translate('EntityBrowser', 'Showing')
windowTitle = u"{0} - {1} {2} of {3} {4}".format(
self.title(), showing, self.current_records, numRecords, rowStr
)
self.setWindowTitle(windowTitle)
return numRecords
def _init_entity_columns(self):
"""
Asserts if the entity columns actually do exist in the database. The
method also initializes the table headers, entity column and cell
formatters.
"""
self._headers[:] = []
table_name = self._entity.name
columns = table_column_names(table_name)
missing_columns = []
header_idx = 0
#Iterate entity column and assert if they exist
for c in self._entity.columns.values():
# Exclude geometry columns
if isinstance(c, GeometryColumn):
continue
# Do not include virtual columns in list of missing columns
if not c.name in columns and not isinstance(c, VirtualColumn):
missing_columns.append(c.name)
else:
header = c.ui_display()
self._headers.append(header)
col_name = c.name
'''
If it is a virtual column then use column name as the header
but fully qualified column name (created by SQLAlchemy
relationship) as the entity attribute name.
'''
if isinstance(c, MultipleSelectColumn):
col_name = c.model_attribute_name
self._entity_attrs.append(col_name)
# Get widget factory so that we can use the value formatter
w_factory = ColumnWidgetRegistry.factory(c.TYPE_INFO)
if not w_factory is None:
formatter = w_factory(c)
self._cell_formatters[col_name] = formatter
# Set searchable columns
if c.searchable:
self._searchable_columns[c.ui_display()] = {
'name': c.name,
'header_index': header_idx
}
header_idx += 1
if len(missing_columns) > 0:
msg = QApplication.translate(
'EntityBrowser',
u'The following columns have been defined in the '
u'configuration but are missing in corresponding '
u'database table, please re-run the configuration wizard '
u'to create them.\n{0}'.format(
'\n'.join(missing_columns)
)
)
QMessageBox.warning(
self,
QApplication.translate('EntityBrowser','Entity Browser'),
msg
)
def _select_record(self, id):
#Selects record with the given ID.
if id is None:
return
m = self.tbEntity.model()
s = self.tbEntity.selectionModel()
start_idx = m.index(0, 0)
idxs = m.match(
start_idx,
Qt.DisplayRole,
id,
1,
Qt.MatchExactly
)
if len(idxs) > 0:
sel_idx = idxs[0]
#Select item
s.select(
sel_idx,
QItemSelectionModel.ClearAndSelect|QItemSelectionModel.Rows
)
# def on_advanced_search(self):
# search = AdvancedSearch(self._entity, parent=self)
# search.show()
def on_load_document_viewer(self):
#Slot raised to show the document viewer for the selected entity
sel_rec_ids = self._selected_record_ids()
if len(sel_rec_ids) == 0:
return
#Get document objects
ent_obj = self._dbmodel()
for sel_id in sel_rec_ids:
er = ent_obj.queryObject().filter(self._dbmodel.id == sel_id).first()
if not er is None:
docs = er.documents
#Notify there are no documents for the selected doc
if len(docs) == 0:
msg = QApplication.translate(
'EntityBrowser',
'There are no supporting documents for the selected record.'
)
QMessageBox.warning(
self,
self.doc_viewer_title,
msg
)
continue
self._doc_viewer.load(docs)
def _initializeData(self, filtered_records=None):
'''
Set table model and load data into it.
'''
if self._dbmodel is None:
msg = QApplication.translate(
'EntityBrowser',
'The data model for the entity could not be loaded, \n'
'please contact your database administrator.'
)
QMessageBox.critical(
self,
QApplication.translate('EntityBrowser', 'Entity Browser'),
msg
)
else:
self._init_entity_columns()
# Load entity data. There might be a better way in future in order
# to ensure that there is a balance between user data discovery
# experience and performance.
if filtered_records is not None:
self.current_records = filtered_records.rowcount
numRecords = self.recomputeRecordCount(init_data=True)
# Load progress dialog
progressLabel = QApplication.translate(
"EntityBrowser", "Fetching Records..."
)
progressDialog = QProgressDialog(
progressLabel, None, 0, numRecords, self
)
QApplication.processEvents()
progressDialog.show()
progressDialog.setValue(0)
# Add records to nested list for enumeration in table model
load_data = True
if self.plugin is not None:
if self._entity.name in self.plugin.entity_table_model.keys():
if filtered_records is None:
self._tableModel = self.plugin.entity_table_model[
self._entity.name
]
if isinstance(self._parent, EntityEditorDialog):
load_data = True
if load_data:
# Only one filter is possible.
if len(self.filtered_records) > 0:
entity_records = self.filtered_records
else:
entity_cls = self._dbmodel()
entity_records = entity_cls.queryObject().filter().limit(
self.record_limit
).all()
# if self._tableModel is None:
entity_records_collection = []
for i, er in enumerate(entity_records):
if i == self.record_limit:
break
QApplication.processEvents()
entity_row_info = []
progressDialog.setValue(i)
try:
for attr in self._entity_attrs:
attr_val = getattr(er, attr)
# Check if there are display formatters and apply if
# one exists for the given attribute.
if attr_val is not None: # No need of formatter for None value
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
entity_row_info.append(attr_val)
except Exception as ex:
QMessageBox.critical(
self,
QApplication.translate(
'EntityBrowser', 'Loading Records'
),
unicode(ex.message))
return
entity_records_collection.append(entity_row_info)
self._tableModel = BaseSTDMTableModel(
entity_records_collection, self._headers, self
)
if self.plugin is not None:
self.plugin.entity_table_model[self._entity.name] = \
self._tableModel
# Add filter columns
for header, info in self._searchable_columns.iteritems():
column_name, index = info['name'], info['header_index']
if column_name != 'id':
self.cboFilterColumn.addItem(header, info)
#Use sortfilter proxy model for the view
self._proxyModel = VerticalHeaderSortFilterProxyModel()
self._proxyModel.setDynamicSortFilter(True)
self._proxyModel.setSourceModel(self._tableModel)
self._proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
#USe first column in the combo for filtering
if self.cboFilterColumn.count() > 0:
self.set_proxy_model_filter_column(0)
self.tbEntity.setModel(self._proxyModel)
if numRecords < self.record_limit:
self.tbEntity.setSortingEnabled(True)
self.tbEntity.sortByColumn(1, Qt.AscendingOrder)
#First (ID) column will always be hidden
self.tbEntity.hideColumn(0)
self.tbEntity.horizontalHeader().setResizeMode(QHeaderView.Interactive)
self.tbEntity.resizeColumnsToContents()
#Connect signals
self.connect(self.cboFilterColumn, SIGNAL('currentIndexChanged (int)'), self.onFilterColumnChanged)
self.connect(self.txtFilterPattern, SIGNAL('textChanged(const QString&)'), self.onFilterRegExpChanged)
#Select record with the given ID if specified
if not self._select_item is None:
self._select_record(self._select_item)
if numRecords > 0:
# Set maximum value of the progress dialog
progressDialog.setValue(numRecords)
else:
progressDialog.hide()
def _header_index_from_filter_combo_index(self, idx):
col_info = self.cboFilterColumn.itemData(idx)
return col_info['name'], col_info['header_index']
def set_proxy_model_filter_column(self, index):
#Set the filter column for the proxy model using the combo index
name, header_idx = self._header_index_from_filter_combo_index(index)
self._proxyModel.setFilterKeyColumn(header_idx)
def onFilterColumnChanged(self, index):
'''
Set the filter column for the proxy model.
'''
self.set_proxy_model_filter_column(index)
def _onFilterRegExpChanged(self,text):
cProfile.runctx('self._onFilterRegExpChanged(text)', globals(), locals())
def onFilterRegExpChanged(self,text):
'''
Slot raised whenever the filter text changes.
'''
regExp = QRegExp(text,Qt.CaseInsensitive,QRegExp.FixedString)
self._proxyModel.setFilterRegExp(regExp)
def onDoubleClickView(self,modelindex):
'''
Slot raised upon double clicking the table view.
To be implemented by subclasses.
'''
pass
def _selected_record_ids(self):
'''
Get the IDs of the selected row in the table view.
'''
self._notifBar.clear()
selected_ids = []
sel_row_indices = self.tbEntity.selectionModel().selectedRows(0)
if len(sel_row_indices) == 0:
msg = QApplication.translate("EntityBrowser",
"Please select a record from the table.")
self._notifBar.insertWarningNotification(msg)
return selected_ids
for proxyRowIndex in sel_row_indices:
#Get the index of the source or else the row items will have unpredictable behavior
row_index = self._proxyModel.mapToSource(proxyRowIndex)
entity_id = row_index.data(Qt.DisplayRole)
selected_ids.append(entity_id)
return selected_ids
def onAccept(self):
'''
Slot raised when user clicks to accept the dialog. The resulting action will be dependent
on the state that the browser is currently configured in.
'''
selIDs = self._selected_record_ids()
if len(selIDs) == 0:
return
if self._mode == SELECT:
#Get all selected records
for sel_id in selIDs:
self.recordSelected.emit(sel_id)
rec_selected = QApplication.translate(
'EntityBrowser',
'record(s) selected'
)
msg = u'{0:d} {1}.'.format(len(selIDs), rec_selected)
self._notifBar.insertInformationNotification(msg)
def addModelToView(self, model_obj):
'''
Convenience method for adding model info into the view.
'''
insertPosition = self._tableModel.rowCount()
self._tableModel.insertRows(insertPosition, 1)
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(insertPosition, i)
attr_val = getattr(model_obj, attr)
'''
Check if there are display formatters and apply if one exists
for the given attribute.
'''
if attr in self._cell_formatters:
formatter = self._cell_formatters[attr]
attr_val = formatter.format_column_value(attr_val)
self._tableModel.setData(prop_idx, attr_val)
return insertPosition
def _model_from_id(self, record_id, row_number):
'''
Convenience method that returns the model object based on its ID.
'''
dbHandler = self._dbmodel()
modelObj = dbHandler.queryObject().filter(
self._dbmodel.id == record_id
).first()
if modelObj is None:
modelObj = self.child_model[row_number+1]
return modelObj
