def _entity_config_from_profile(self, table_name, short_name):
"""
Creates an EntityConfig object from the table name.
:param table_name: Name of the database table.
:type table_name: str
:return: Entity configuration object.
:rtype: EntityConfig
"""
table_display_name = format_name(short_name)
entity = self.curr_profile.entity_by_name(table_name)
model = entity_model(entity)
if model is not None:
#Entity configuration
entity_cfg = EntityConfiguration()
entity_cfg.Title = table_display_name
entity_cfg.STRModel = model
entity_cfg.data_source_name = table_name
# Load filter and display columns
# using only those which are of
# numeric/varchar type
searchable_columns = entity_searchable_columns(entity)
display_columns = entity_display_columns(entity)
for c in searchable_columns:
if c != 'id':
entity_cfg.filterColumns[c] = format_name(c)
for c in display_columns:
if c != 'id':
entity_cfg.displayColumns[c] = format_name(c)
return entity_cfg
else:
return None
def _init_gui(self, show_str_tab: bool, is_party_unit: bool=False):
# Setup base elements
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName('glMain')
self.gridLayout.addLayout(
self.vlNotification, 0, 0, 1, 1
)
column_widget_area = self._setup_columns_content_area()
self.gridLayout.addWidget(
column_widget_area, 1, 0, 1, 1
)
# Add notification for mandatory columns if applicable
next_row = 2
# Set title
search_trans = self.tr('Advanced Search')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
title = '{0} {1}'.format(title_str, search_trans)
self.do_not_check_dirty = True
self.setWindowTitle(title)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setObjectName('buttonBox')
self.gridLayout.addWidget(
self.buttonBox, next_row, 0, 1, 1
)
self.buttonBox.setOrientation(Qt.Horizontal)
self.search = QPushButton(
QApplication.translate(
'EntityEditorDialog', 'Search'
)
)
self.buttonBox.addButton(
self.search, QDialogButtonBox.ActionRole
)
self.buttonBox.setStandardButtons(
QDialogButtonBox.Close | QDialogButtonBox.Reset
)
self.search.clicked.connect(self.on_search)
self.buttonBox.button(QDialogButtonBox.Close).clicked.connect(self.reject)
self.buttonBox.button(QDialogButtonBox.Reset).clicked.connect(self.reset)
def _add_fk_browser(self, child_entity, column):
# Create and add foreign key
# browser to the collection
from stdm.ui.entity_browser import (
EntityBrowserWithEditor
)
attr = u'{0}_collection'.format(child_entity.name)
# Return if the attribute does not exist
if not hasattr(self._model, attr):
return
entity_browser = EntityBrowserWithEditor(
child_entity,
self,
MANAGE,
False,
plugin=self.plugin
)
entity_browser.buttonBox.setVisible(False)
entity_browser.record_filter = []
if len(child_entity.label) > 2:
column_label = child_entity.label
else:
# Split and join to filter out entity name prefix
# e.g. 'lo_parcel' to 'parcel'
column_label = format_name(" ".join(child_entity.name.split("_", 1)[1:]))
self.entity_tab_widget.addTab(
entity_browser,
u'{0}'.format(
column_label
)
)
self.set_filter(child_entity, entity_browser)
def add_str_type_headers(self):
"""
Adds headers data for QTableView columns. The
headers comes from the selected entity.
:param entity: The entity for which the table
header is created for.
:return: List of Table headers
:rtype: List
"""
if not self.selected_party is None:
self.party_1 = self.selected_party
db_model = entity_model(self.party_1, True)
headers = []
#Load headers
if db_model is not None:
entity_display_columns(self.party_1)
# Append str type if the method
# is used for str_type
str_type_header = QApplication.translate('STRType',
'Social Tenure Type')
share_header = QApplication.translate('STRType', 'Share ')
#First (ID) column will always be hidden
headers.append(str_type_header)
headers.append(share_header)
for col in entity_display_columns(self.party_1):
headers.append(format_name(col))
return headers
def _add_fk_browser(self, child_entity, column):
# Create and add foreign key
# browser to the collection
from stdm.ui.entity_browser import (EntityBrowserWithEditor)
attr = u'{0}_collection'.format(child_entity.name)
# Return if the attribute does not exist
if not hasattr(self._model, attr):
return
entity_browser = EntityBrowserWithEditor(child_entity,
self,
MANAGE,
False,
plugin=self.plugin)
entity_browser.buttonBox.setVisible(False)
entity_browser.record_filter = []
if len(child_entity.label) > 2:
column_label = child_entity.label
else:
# Split and join to filter out entity name prefix
# e.g. 'lo_parcel' to 'parcel'
column_label = format_name(" ".join(
child_entity.name.split("_", 1)[1:]))
self.entity_tab_widget.addTab(entity_browser,
u'{0}'.format(column_label))
self.set_filter(child_entity, entity_browser)
def title(self):
'''
Set the title of the entity browser dialog.
Protected method to be overridden by subclasses.
'''
records = QApplication.translate('EntityBrowser', 'Records')
formatted_name = format_name(self._entity.ui_display())
return u'{} {}'.format(formatted_name, records)
def find_root(self, entity, feature_id):
all_roots = self.model.findItems(
format_name(entity.short_name)
)
root = None
for item in all_roots:
if item.data() == feature_id:
root = item
break
return root
def add_party_steam(self, parent, party_id):
party_icon = QIcon(
':/plugins/stdm/images/icons/table.png'
)
title = format_name(self.party.short_name)
party_root = QStandardItem(party_icon, title)
party_root.setData(party_id)
self.set_bold(party_root)
parent.appendRow([party_root])
party_root.setEditable(False)
return party_root
def _load_model_columns(self, config):
"""
Load model columns into the view for specifying file output name.
Only those columns of display type variants will be
used.
"""
model_attr_mapping = OrderedDict()
for c in config.data_source_columns():
model_attr_mapping[c] = format_name(c)
self.lstDocNaming.load_mapping(model_attr_mapping)
def _load_data_source_columns(self, entity):
"""
Load the columns of a data source for use in the file naming.
"""
table_cols = entity_display_columns(entity)
attr_mapping = OrderedDict()
for c in table_cols:
attr_mapping[c] = format_name(c)
self.lstDocNaming.load_mapping(attr_mapping)
def _load_model_columns(self, config):
"""
Load model columns into the view for specifying file output name.
Only those columns of display type variants will be
used.
"""
model_attr_mapping = OrderedDict()
for c in config.data_source_columns():
model_attr_mapping[c] = format_name(c)
self.lstDocNaming.load_mapping(model_attr_mapping)
def _add_fk_browser(self, child_entity, column):
# Create and add foreign key
# browser to the collection
from stdm.ui.entity_browser import (EntityBrowserWithEditor,
ContentGroupEntityBrowser)
attr = u'{0}_collection'.format(child_entity.name)
# Return if the attribute does not exist
if not hasattr(self._model, attr):
return
table_content = TableContentGroup(
self._parent.entity_browser.current_user.UserName,
child_entity.short_name)
if self.edit_model is not None:
parent_id = self.edit_model.id
else:
parent_id = 0
entity_browser = ContentGroupEntityBrowser(
child_entity,
table_content,
rec_id=parent_id,
parent=self,
plugin=self.plugin,
current_user=self.current_user,
load_recs=False)
#entity_browser = EntityBrowserWithEditor(
#child_entity,
#self,
#MANAGE,
#False,
#plugin=self.plugin
#)
entity_browser.buttonBox.setVisible(False)
entity_browser.record_filter = []
if len(child_entity.label) > 2:
column_label = child_entity.label
else:
# Split and join to filter out entity name prefix
# e.g. 'lo_parcel' to 'parcel'
column_label = format_name(" ".join(
child_entity.name.split("_", 1)[1:]))
self.set_filter(child_entity, entity_browser)
self.entity_tab_widget.addTab(entity_browser,
u'{0}'.format(column_label))
def _load_editor_dialog(self, recid, rownumber):
'''
Load editor dialog based on the selected model instance with the given ID.
'''
model_obj = self._model_from_id(recid, rownumber)
# show GPS editor if geometry
if self._entity.has_geometry_column():
self.sp_unit_manager.active_layer_source()
gps_tool = GPSToolDialog(iface,
self._entity,
self._entity.name,
self.sp_unit_manager.active_sp_col,
model=model_obj,
reload=False,
row_number=rownumber,
entity_browser=self)
editor_trans = self.tr('Editor')
title = u'{0} {1}'.format(format_name(self._entity.short_name),
editor_trans)
gps_tool.setWindowTitle(title)
result = gps_tool.exec_()
else:
#Load editor dialog
edit_entity_dlg = self._editor_dlg(
self._entity,
model=model_obj,
parent=self,
parent_entity=self.parent_entity)
result = edit_entity_dlg.exec_()
if result == QDialog.Accepted:
if self._entity.has_geometry_column():
edit_entity_dlg = gps_tool.entity_editor
updated_model_obj = edit_entity_dlg.model()
if not edit_entity_dlg.is_valid:
return
for i, attr in enumerate(self._entity_attrs):
prop_idx = self._tableModel.index(rownumber, i)
attr_val = getattr(updated_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)
def multi_select_highlight(self, index):
"""
Highlights a feature with rubberBald class when selecting
features are more than one.
:param index: Selected QTreeView item index
:type Integer
:return: None
"""
map = self.iface.mapCanvas()
try:
# Get the selected item text using the index
selected_item = self.model.itemFromIndex(index)
# Use mutli-select only when more than 1 items are selected.
if self.layer.selectedFeatures() < 2:
return
self.selected_root = selected_item
# Split the text to get the key and value.
selected_item_text = selected_item.text()
selected_value = selected_item.data()
# If the first word is feature, expand & highlight.
if selected_item_text == format_name(self.spatial_unit.short_name):
self.view.expand(index) # expand the item
# Clear any existing highlight
self.clear_sel_highlight()
# Insert highlight
# Create expression to target the selected feature
expression = QgsExpression(
"\"id\"='" + str(selected_value) + "'"
)
# Get feature iteration based on the expression
ft_iteration = self.layer.getFeatures(
QgsFeatureRequest(expression)
)
# Retrieve geometry and attributes
for feature in ft_iteration:
# Fetch geometry
geom = feature.geometry()
self.sel_highlight = QgsHighlight(map, geom, self.layer)
self.sel_highlight.setFillColor(selection_color())
self.sel_highlight.setWidth(4)
self.sel_highlight.setColor(QColor(212,95,0, 255))
self.sel_highlight.show()
break
except AttributeError:
# pass attribute error on child items such as party
pass
except IndexError:
pass
def _entity_config_from_profile(self, table_name, short_name):
"""
Creates an EntityConfig object from the table name.
:param table_name: Name of the database table.
:type table_name: str
:return: Entity configuration object.
:rtype: EntityConfig
"""
table_display_name = format_name(short_name)
entity = self.curr_profile.entity_by_name(table_name)
model = entity_model(entity)
if model is not None:
#Entity configuration
entity_cfg = EntityConfiguration()
entity_cfg.Title = table_display_name
entity_cfg.STRModel = model
entity_cfg.data_source_name = table_name
for col, factory in self._get_widget_factory(entity):
entity_cfg.LookupFormatters[col.name] = factory
# Load filter and display columns
# using only those which are of
# numeric/varchar type
searchable_columns = entity_searchable_columns(entity)
display_columns = entity_display_columns(entity)
for c in searchable_columns:
if c != 'id':
entity_cfg.filterColumns[c] = format_name(c)
for c in display_columns:
if c != 'id':
entity_cfg.displayColumns[c] = format_name(c)
return entity_cfg
else:
return None
def _format_display_mapping(self, model, display_cols, filter_cols):
"""
Creates a collection containing a tuple of column name and display
name as the key and value (from the model) as the value.
:return:
"""
disp_mapping = OrderedDict()
for c in display_cols.keys():
if c != "id" and c in filter_cols:
if hasattr(model, c):
k = c, format_name(c)
disp_mapping[k] = lookup_id_to_value(
self.curr_profile, c, getattr(model, c))
return disp_mapping
def onNewEntity(self):
'''
Load editor dialog for adding a new record.
'''
self._notifBar.clear()
if not self._can_add_edit():
msg = QApplication.translate(
'EntityBrowserWithEditor',
'There are no user-defined columns for this entity.')
self._notifBar.insertErrorNotification(msg)
return
if self._entity.has_geometry_column():
self.sp_unit_manager.active_layer_source()
gps_tool = GPSToolDialog(iface,
self._entity,
self._entity.name,
self.sp_unit_manager.active_sp_col,
reload=False,
entity_browser=self)
editor_trans = self.tr('Editor')
title = u'{0} {1}'.format(format_name(self._entity.short_name),
editor_trans)
gps_tool.setWindowTitle(title)
result = gps_tool.exec_()
result = False # a workaround to avoid duplicate model insert
self.addEntityDlg = gps_tool.entity_editor
else:
self.addEntityDlg = self._editor_dlg(
self._entity, parent=self, parent_entity=self.parent_entity)
self.addEntityDlg.addedModel.connect(self.on_save_and_new)
result = self.addEntityDlg.exec_()
if result == QDialog.Accepted:
model_obj = self.addEntityDlg.model()
if self.addEntityDlg.is_valid:
if self.parent_entity is None:
self.addModelToView(model_obj)
self.recomputeRecordCount()
def _load_entity_config(self, entity):
"""
Creates an EntityConfig object from entity.
:param entity: The entity object
:type entity: Object
"""
table_display_name = format_name(entity.short_name)
table_name = entity.name
try:
model = entity_model(entity)
except Exception:
return None
if model is not None:
return EntityConfig(title=table_display_name,
data_source=table_name,
model=model,
expression_builder=False,
entity_selector=None)
else:
return None
def _entity_config_from_profile(self, table_name, short_name):
"""
Creates an EntityConfig object from the table name.
:param table_name: Name of the database table.
:type table_name: str
:return: Entity configuration object.
:rtype: EntityConfig
"""
table_display_name = format_name(short_name)
self.ds_entity = self.curr_profile.entity_by_name(table_name)
model = entity_model(self.ds_entity)
if model is not None:
return EntityConfig(title=table_display_name,
data_source=table_name,
model=model,
expression_builder=True,
entity_selector=None)
else:
return None
def show_tree(self):
selected_features = self.selected_features()
if len(selected_features) < 1:
self.reset_tree_view(True)
return
if not self.entity is None:
self.reset_tree_view()
if len(selected_features) < 1:
self.disable_buttons(True)
return
layer_icon = QIcon(':/plugins/stdm/images/icons/layer.gif')
roots = self.add_parent_tree(
layer_icon, format_name(self.entity.short_name)
)
if roots is None:
return
for id, root in roots.iteritems():
db_model = entity_id_to_model(self.entity, id)
self.add_roots(db_model, root, id)
def edit_selected_steam(self, entity):
id, item = self.steam_data('edit')
feature_edit = True
if id is None:
return
if isinstance(id, str):
data_error = QApplication.translate('DetailsTreeView', id)
QMessageBox.warning(
self.iface.mainWindow(), "Edit Error", data_error
)
return
if item.text() == 'Social Tenure Relationship':
model = self.STR_models[id]
feature_edit = False
##TODO add STR wizard edit mode here.
elif item.text() == format_name(self.party.short_name):
feature_edit = False
model = self.party_models[id]
editor = EntityEditorDialog(
self.party, model, self.iface.mainWindow()
)
editor.exec_()
else:
model = self.feature_models[id]
editor = EntityEditorDialog(
entity, model, self.iface.mainWindow()
)
editor.exec_()
#root = self.find_root(entity, id)
self.view.expand(item.index())
if feature_edit:
self.update_edited_steam(entity, id)
else:
self.update_edited_steam(self.social_tenure, id)
def _entity_config_from_profile(self, table_name, short_name):
"""
Creates an EntityConfig object from the table name.
:param table_name: Name of the database table.
:type table_name: str
:return: Entity configuration object.
:rtype: EntityConfig
"""
table_display_name = format_name(short_name)
self.ds_entity = self.curr_profile.entity_by_name(table_name)
model = entity_model(self.ds_entity)
if model is not None:
return EntityConfig(title=table_display_name,
data_source=table_name,
model=model,
expression_builder=True,
entity_selector=ForeignKeyBrowser)
else:
return None
def _add_fk_browser(self, child_entity, column):
# Create and add foreign key
# browser to the collection
from stdm.ui.entity_browser import (EntityBrowserWithEditor)
attr = u'{0}_collection'.format(child_entity.name)
# Return if the attribute does not exist
if not hasattr(self._model, attr):
return
entity_browser = EntityBrowserWithEditor(child_entity, self, MANAGE,
False)
entity_browser.buttonBox.setVisible(False)
entity_browser.record_filter = []
if len(column.label) > 2:
column_label = column.label
else:
column_label = format_name(column.name)
self.entity_tab_widget.addTab(entity_browser,
u'{0}'.format(column_label))
self.set_filter(child_entity, entity_browser)
def _load_entity_config(self, entity):
"""
Creates an EntityConfig object from entity.
:param entity: The entity object
:type entity: Object
"""
table_display_name = format_name(entity.short_name)
table_name = entity.name
try:
model = entity_model(entity)
except Exception:
return None
if model is not None:
return EntityConfig(
title=table_display_name,
data_source=table_name,
model=model,
expression_builder=False,
entity_selector=None
)
else:
return None
def __init__(
self,
entity,
model=None,
parent=None,
manage_documents=True,
collect_model=False
):
"""
Class constructor.
:param entity: Entity object corresponding to a table object.
:type entity: Entity
:param model: Data object for loading data into the form widgets.
If the model is set, then the editor dialog is assumed to be in edit
mode.
:type model: object
:param parent: Parent widget that the form belongs to.
:type parent: QWidget
:param manage_documents: True if the dialog should provide controls
for managing supporting documents. Only applicable if the entity
allows for supporting documents to be attached.
:type manage_documents: bool
:param collect_model: If set to True only returns
the filled form model without saving it to the database.
:type collect_model: Boolean
:return: If collect_model, returns SQLAlchemy Model
"""
QDialog.__init__(self, parent)
self.collection_suffix = self.tr('Collection')
#Set minimum width
self.setMinimumWidth(350)
#Flag for mandatory columns
self.has_mandatory = False
self._entity = entity
self._fk_browsers = OrderedDict()
#Set notification layout bar
self.vlNotification = QVBoxLayout()
self.vlNotification.setObjectName('vlNotification')
self._notifBar = NotificationBar(self.vlNotification)
# Set manage documents only if the entity supports documents
if self._entity.supports_documents:
self._manage_documents = manage_documents
else:
self._manage_documents = False
#Setup entity model
self._ent_document_model = None
if self._entity.supports_documents:
ent_model, self._ent_document_model = entity_model(
self._entity,
with_supporting_document=True
)
else:
ent_model = entity_model(self._entity)
if not model is None:
ent_model = model
MapperMixin.__init__(self, ent_model)
self.collect_model = collect_model
#Initialize UI setup
self._init_gui()
#Set title
editor_trans = self.tr('Editor')
title = u'{0} {1}'.format(
format_name(self._entity.short_name),
editor_trans
)
self.setWindowTitle(title)
def __init__(
self,
entity,
model=None,
parent=None,
manage_documents=True,
collect_model=False,
parent_entity=None,
exclude_columns=[],
plugin = None
):
"""
Class constructor.
:param entity: Entity object corresponding to a table object.
:type entity: Entity
:param model: Data object for loading data into the form widgets.
If the model is set, then the editor dialog is assumed to be in edit
mode.
:type model: object
:param parent: Parent widget that the form belongs to.
:type parent: QWidget
:param manage_documents: True if the dialog should provide controls
for managing supporting documents. Only applicable if the entity
allows for supporting documents to be attached.
:type manage_documents: bool
:param collect_model: If set to True only returns
the filled form model without saving it to the database.
:type collect_model: Boolean
:param parent_entity: The parent entity of the editor
:type parent_entity: Object
:param exclude_columns: List of columns to be excluded if in a list.
:type exclude_columns: List
:return: If collect_model, returns SQLAlchemy Model
"""
QDialog.__init__(self, parent)
self.entity_table_model = {}
self.collection_suffix = self.tr('Collection')
#Set minimum width
self.setMinimumWidth(450)
self.plugin = plugin
#Flag for mandatory columns
self.has_mandatory = False
self.reload_form = False
self._entity = entity
self.edit_model = model
self.column_widgets = OrderedDict()
self._parent = parent
self.exclude_columns = exclude_columns
self.entity_tab_widget = None
self._disable_collections = False
self.filter_val = None
self.parent_entity = parent_entity
self.child_models = OrderedDict()
self.entity_scroll_area = None
self.entity_editor_widgets = OrderedDict()
# Set notification layout bar
self.vlNotification = QVBoxLayout()
self.vlNotification.setObjectName('vlNotification')
self._notifBar = NotificationBar(self.vlNotification)
self.do_not_check_dirty = False
# Set manage documents only if the entity supports documents
if self._entity.supports_documents:
self._manage_documents = manage_documents
else:
self._manage_documents = False
# Setup entity model
self._ent_document_model = None
if self._entity.supports_documents:
self.ent_model, self._ent_document_model = entity_model(
self._entity,
with_supporting_document=True
)
else:
self.ent_model = entity_model(self._entity)
if not model is None:
self.ent_model = model
MapperMixin.__init__(self, self.ent_model, entity)
self.collect_model = collect_model
self.register_column_widgets()
try:
if isinstance(parent._parent, EntityEditorDialog):
# hide collections form child editor
self._disable_collections = True
except AttributeError:
self._parent._parent = None
# Set title
editor_trans = self.tr('Editor')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
self.title = u'{0} {1}'.format(title_str, editor_trans)
self.setWindowTitle(self.title)
self._init_gui()
self.adjustSize()
self._get_entity_editor_widgets()
if isinstance(parent._parent, EntityEditorDialog):
self.parent_entity = parent.parent_entity
self.set_parent_values()
# make the size smaller to differentiate from parent and as it
# only has few tabs.
self.adjustSize()
self.attribute_mappers = self._attr_mapper_collection
# Exception title for editor extension exceptions
self._ext_exc_msg = self.tr(
'An error has occured while executing Python code in the editor '
'extension:'
)
# Register custom editor extension if specified
self._editor_ext = entity_dlg_extension(self)
if not self._editor_ext is None:
self._editor_ext.post_init()
# Initialize CascadingFieldContext objects
self._editor_ext.connect_cf_contexts()
def delete_selected_item(self):
str_edit = False
id, item = self.steam_data('delete')
if isinstance(id, str):
data_error = QApplication.translate(
'DetailsTreeView', id
)
QMessageBox.warning(
self.iface.mainWindow(),
'Delete Error',
data_error
)
return
if item.text() == 'Social Tenure Relationship':
str_edit = True
db_model = self.STR_models[id]
elif item.text() == format_name(self.spatial_unit.short_name) and \
id not in self.feature_STR_model.keys():
db_model = self.feature_models[id]
# if spatial unit is linked to STR, don't allow delete
elif item.text() == format_name(self.spatial_unit.short_name) and \
id in self.feature_STR_model.keys():
delete_warning = QApplication.translate(
'DetailsTreeView',
'You have to first delete the social tenure \n'
'relationship to delete the {} record.'.format(
item.text()
)
)
QMessageBox.warning(
self.iface.mainWindow(),
'Delete Error',
delete_warning
)
return
# If it is party node, STR exists and don't allow delete.
elif item.text() == format_name(self.party.short_name):
delete_warning = QApplication.translate(
'DetailsTreeView',
'You have to first delete the social tenure \n'
'relationship to delete the {} record.'.format(
item.text()
)
)
QMessageBox.warning(
self.iface.mainWindow(),
'Delete Error',
delete_warning
)
return
else:
return
delete_warning = QApplication.translate(
'DetailsTreeView',
'Are you sure you want to delete '
'the selected record(s)?\n'
'This action cannot be undone.'
)
delete_question = QMessageBox.warning(
self.iface.mainWindow(),
"Delete Warning",
delete_warning,
QMessageBox.Yes | QMessageBox.No
)
if delete_question == QMessageBox.Yes:
db_model.delete()
if str_edit:
del self.STR_models[id]
else:
self.removed_feature = id
del self.feature_models[id]
self.updated_removed_steam(str_edit, item)
else:
return
def _init_gui(self):
# Setup base elements
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName('glMain')
self.gridLayout.addLayout(self.vlNotification, 0, 0, 1, 1)
QApplication.processEvents()
column_widget_area = self._setup_columns_content_area()
self.gridLayout.addWidget(column_widget_area, 1, 0, 1, 1)
QApplication.processEvents()
# Add notification for mandatory columns if applicable
next_row = 2
# Set title
search_trans = self.tr('Advanced Search')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
title = u'{0} {1}'.format(title_str, search_trans)
self.do_not_check_dirty = True
self.setWindowTitle(title)
# if self.has_mandatory:
# self.required_fields_lbl = QLabel(self)
# msg = self.tr(
# 'Please fill out all required (*) fields.'
# )
# msg = self._highlight_asterisk(msg)
# self.required_fields_lbl.setText(msg)
# self.gridLayout.addWidget(
# self.required_fields_lbl, next_row, 0, 1, 2
# )
# # Bump up row reference
# next_row += 1
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setObjectName('buttonBox')
self.gridLayout.addWidget(self.buttonBox, next_row, 0, 1, 1)
self.buttonBox.setOrientation(Qt.Horizontal)
self.search = QPushButton(
QApplication.translate('EntityEditorDialog', 'Search'))
self.buttonBox.addButton(self.search, QDialogButtonBox.ActionRole)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.search.clicked.connect(self.on_search)
#
#
# # edit model, collect model
# # adding new record for child
#
# # Saving in parent editor
# if not isinstance(self._parent._parent, EntityEditorDialog):
# # adding a new record
# if self.edit_model is None:
# # saving when digitizing.
# if self.collect_model:
# self.buttonBox.accepted.connect(self.on_model_added)
# # saving parent editor
# else:
# self.buttonBox.accepted.connect(self.save_parent_editor)
# self.save_new_button.clicked.connect(self.save_and_new)
# # updating existing record
# else:
# if not self.collect_model:
# # updating existing record of the parent editor
# self.buttonBox.accepted.connect(self.save_parent_editor)
# else:
# self.buttonBox.accepted.connect(self.on_model_added)
# # Saving in child editor
# else:
# # save and new record
# if self.edit_model is None:
# self.buttonBox.accepted.connect(self.on_child_saved)
# self.save_new_button.clicked.connect(
# lambda: self.on_child_saved(True)
# )
#
# else:
# # When updating an existing child editor save to the db
# self.buttonBox.accepted.connect(
# self.on_child_saved
# )
# #self.buttonBox.accepted.connect(self.submit)
#
self.buttonBox.rejected.connect(self.cancel)
def __init__(self,
entity,
model=None,
parent=None,
manage_documents=True,
collect_model=False,
parent_entity=None,
exclude_columns=[],
plugin=None):
"""
Class constructor.
:param entity: Entity object corresponding to a table object.
:type entity: Entity
:param model: Data object for loading data into the form widgets.
If the model is set, then the editor dialog is assumed to be in edit
mode.
:type model: object
:param parent: Parent widget that the form belongs to.
:type parent: QWidget
:param manage_documents: True if the dialog should provide controls
for managing supporting documents. Only applicable if the entity
allows for supporting documents to be attached.
:type manage_documents: bool
:param collect_model: If set to True only returns
the filled form model without saving it to the database.
:type collect_model: Boolean
:param parent_entity: The parent entity of the editor
:type parent_entity: Object
:param exclude_columns: List of columns to be excluded if in a list.
:type exclude_columns: List
:return: If collect_model, returns SQLAlchemy Model
"""
QDialog.__init__(self, parent)
self.entity_table_model = {}
self.collection_suffix = self.tr('Collection')
#Set minimum width
self.setMinimumWidth(450)
self.plugin = plugin
#Flag for mandatory columns
self.has_mandatory = False
self.reload_form = False
self._entity = entity
self.edit_model = model
self.column_widgets = OrderedDict()
self._parent = parent
self.exclude_columns = exclude_columns
self.entity_tab_widget = None
self._disable_collections = False
self.filter_val = None
self.parent_entity = parent_entity
self.child_models = OrderedDict()
self.entity_scroll_area = None
self.entity_editor_widgets = OrderedDict()
# Set notification layout bar
self.vlNotification = QVBoxLayout()
self.vlNotification.setObjectName('vlNotification')
self._notifBar = NotificationBar(self.vlNotification)
self.do_not_check_dirty = False
# Set manage documents only if the entity supports documents
if self._entity.supports_documents:
self._manage_documents = manage_documents
else:
self._manage_documents = False
# Setup entity model
self._ent_document_model = None
if self._entity.supports_documents:
self.ent_model, self._ent_document_model = entity_model(
self._entity, with_supporting_document=True)
else:
self.ent_model = entity_model(self._entity)
if not model is None:
self.ent_model = model
MapperMixin.__init__(self, self.ent_model, entity)
self.collect_model = collect_model
self.register_column_widgets()
try:
if isinstance(parent._parent, EntityEditorDialog):
# hide collections form child editor
self._disable_collections = True
except AttributeError:
self._parent._parent = None
# Set title
editor_trans = self.tr('Editor')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
self.title = u'{0} {1}'.format(title_str, editor_trans)
self.setWindowTitle(self.title)
self._init_gui()
self.adjustSize()
self._get_entity_editor_widgets()
if isinstance(parent._parent, EntityEditorDialog):
self.parent_entity = parent.parent_entity
self.set_parent_values()
# make the size smaller to differentiate from parent and as it
# only has few tabs.
self.adjustSize()
self.attribute_mappers = self._attr_mapper_collection
# Exception title for editor extension exceptions
self._ext_exc_msg = self.tr(
'An error has occured while executing Python code in the editor '
'extension:')
# Register custom editor extension if specified
self._editor_ext = entity_dlg_extension(self)
if not self._editor_ext is None:
self._editor_ext.post_init()
# Initialize CascadingFieldContext objects
self._editor_ext.connect_cf_contexts()
def __init__(self,
entity,
model=None,
parent=None,
manage_documents=True,
collect_model=False,
parent_entity=None,
exclude_columns=[]):
"""
Class constructor.
:param entity: Entity object corresponding to a table object.
:type entity: Entity
:param model: Data object for loading data into the form widgets.
If the model is set, then the editor dialog is assumed to be in edit
mode.
:type model: object
:param parent: Parent widget that the form belongs to.
:type parent: QWidget
:param manage_documents: True if the dialog should provide controls
for managing supporting documents. Only applicable if the entity
allows for supporting documents to be attached.
:type manage_documents: bool
:param collect_model: If set to True only returns
the filled form model without saving it to the database.
:type collect_model: Boolean
:param parent_entity: The parent entity of the editor
:type parent_entity: Object
:param exclude_columns: List of columns to be excluded if in a list.
:type exclude_columns: List
:return: If collect_model, returns SQLAlchemy Model
"""
QDialog.__init__(self, parent)
self.collection_suffix = self.tr('Collection')
#Set minimum width
self.setMinimumWidth(450)
#Flag for mandatory columns
self.has_mandatory = False
self.reload_form = False
self._entity = entity
self.edit_model = model
self.column_widgets = OrderedDict()
self._parent = parent
self.exclude_columns = exclude_columns
self.entity_tab_widget = None
self._disable_collections = False
self.filter_val = None
self.parent_entity = parent_entity
self.child_models = OrderedDict()
self.entity_scroll_area = None
self.entity_editor_widgets = OrderedDict()
#Set notification layout bar
self.vlNotification = QVBoxLayout()
self.vlNotification.setObjectName('vlNotification')
self._notifBar = NotificationBar(self.vlNotification)
# Set manage documents only if the entity supports documents
if self._entity.supports_documents:
self._manage_documents = manage_documents
else:
self._manage_documents = False
# Setup entity model
self._ent_document_model = None
if self._entity.supports_documents:
self.ent_model, self._ent_document_model = entity_model(
self._entity, with_supporting_document=True)
else:
self.ent_model = entity_model(self._entity)
if not model is None:
self.ent_model = model
MapperMixin.__init__(self, self.ent_model, entity)
self.collect_model = collect_model
self.register_column_widgets()
try:
if isinstance(parent._parent, EntityEditorDialog):
# hide collections form child editor
self._disable_collections = True
except AttributeError:
self._parent._parent = None
self._init_gui()
self.resize(430, 400)
self._get_entity_editor_widgets()
# Set title
editor_trans = self.tr('Editor')
title = u'{0} {1}'.format(format_name(self._entity.short_name),
editor_trans)
self.setWindowTitle(title)
if isinstance(parent._parent, EntityEditorDialog):
self.parent_entity = parent.parent_entity
self.set_parent_values()
# make the size smaller to differentiate from parent and as it
# only has few tabs.
self.resize(390, 400)
def _init_gui(self):
# Setup base elements
self.gridLayout = QGridLayout(self)
self.gridLayout.setObjectName('glMain')
self.gridLayout.addLayout(
self.vlNotification, 0, 0, 1, 1
)
QApplication.processEvents()
column_widget_area = self._setup_columns_content_area()
self.gridLayout.addWidget(
column_widget_area, 1, 0, 1, 1
)
QApplication.processEvents()
# Add notification for mandatory columns if applicable
next_row = 2
# Set title
search_trans = self.tr('Advanced Search')
if self._entity.label is not None:
if self._entity.label != '':
title_str = self._entity.label
else:
title_str = format_name(self._entity.short_name)
else:
title_str = format_name(self._entity.short_name)
title = u'{0} {1}'.format(title_str, search_trans)
self.do_not_check_dirty = True
self.setWindowTitle(title)
# if self.has_mandatory:
# self.required_fields_lbl = QLabel(self)
# msg = self.tr(
# 'Please fill out all required (*) fields.'
# )
# msg = self._highlight_asterisk(msg)
# self.required_fields_lbl.setText(msg)
# self.gridLayout.addWidget(
# self.required_fields_lbl, next_row, 0, 1, 2
# )
# # Bump up row reference
# next_row += 1
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setObjectName('buttonBox')
self.gridLayout.addWidget(
self.buttonBox, next_row, 0, 1, 1
)
self.buttonBox.setOrientation(Qt.Horizontal)
self.search = QPushButton(
QApplication.translate(
'EntityEditorDialog', 'Search'
)
)
self.buttonBox.addButton(
self.search, QDialogButtonBox.ActionRole
)
self.buttonBox.setStandardButtons(
QDialogButtonBox.Cancel
)
self.search.clicked.connect(self.on_search)
#
#
# # edit model, collect model
# # adding new record for child
#
# # Saving in parent editor
# if not isinstance(self._parent._parent, EntityEditorDialog):
# # adding a new record
# if self.edit_model is None:
# # saving when digitizing.
# if self.collect_model:
# self.buttonBox.accepted.connect(self.on_model_added)
# # saving parent editor
# else:
# self.buttonBox.accepted.connect(self.save_parent_editor)
# self.save_new_button.clicked.connect(self.save_and_new)
# # updating existing record
# else:
# if not self.collect_model:
# # updating existing record of the parent editor
# self.buttonBox.accepted.connect(self.save_parent_editor)
# else:
# self.buttonBox.accepted.connect(self.on_model_added)
# # Saving in child editor
# else:
# # save and new record
# if self.edit_model is None:
# self.buttonBox.accepted.connect(self.on_child_saved)
# self.save_new_button.clicked.connect(
# lambda: self.on_child_saved(True)
# )
#
# else:
# # When updating an existing child editor save to the db
# self.buttonBox.accepted.connect(
# self.on_child_saved
# )
# #self.buttonBox.accepted.connect(self.submit)
#
self.buttonBox.rejected.connect(self.cancel)