def __init__(self):
self.logfile = open('logfile')
self.db = QSqlDatabase.addDatabase("QSQLITE")
self.db.setDatabaseName('sfile.db')
self.db.open()
self.projectModel_blocked = QSqlTableModel()
self.projectModel_blacklist = QSqlTableModel()
self.projectModel_mac = QSqlTableModel()
self.sniff = Sniffer()
self.sniff.start_gui()
self.fnotification = share.get_flags()['notification']
def workcat_fill_table(self, widget, table_name, hidde=False, set_edit_triggers=QTableView.NoEditTriggers, expr=None):
""" Fill table @widget filtering query by @workcat_id
Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name+"."+table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(0, 0)
model.select()
widget.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if expr:
widget.setModel(model)
widget.model().setFilter(expr)
else:
widget.setModel(model)
if hidde:
self.refresh_table(widget)
def fill_table_planned_month(self,
qtable,
txt_filter,
tableright,
expression=None,
set_edit_triggers=QTableView.NoEditTriggers):
""" Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name + "." + tableright)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setSort(2, 0)
model.select()
qtable.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Create expresion
expr = " mu_name ILIKE '%" + str(txt_filter.text()) + "%' "
expr += " AND campaign_id = '" + str(self.planned_camp_id) + "' "
if expression is not None:
expr += expression
qtable.setModel(model)
qtable.model().setFilter(expr)
def setup_model_and_mapper(self, mcl_ref):
"""
Load the table data for selected record into a model and map to widgets.
"""
# Set up model
self.model = QSqlTableModel(db=self.db)
self.model.setTable('mcl')
self.model.setFilter("mcl_ref = {}".format(int(mcl_ref)))
self.model.select()
if self.model.rowCount() != 1:
msg = "MCL query for mcl_ref = {} returned {} rows".format(
mcl_ref, self.model.rowCount())
raise rn_except.MclFormBadMclRefError(msg)
# Set up mapper
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.setModel(self.model)
self.mapper.addMapping(self.dlg.ui.mclLineEdit, MCL_REF)
self.mapper.addMapping(self.dlg.ui.usrnLineEdit, USRN)
self.mapper.addMapping(self.dlg.ui.streetClassComboBox, STREET_CLASS)
self.mapper.addMapping(self.dlg.ui.ref1LineEdit, LOR_REF_1)
self.mapper.addMapping(self.dlg.ui.ref2LineEdit, LOR_REF_2)
self.mapper.addMapping(self.dlg.ui.laneNumberComboBox, LANE_NUMBER)
self.mapper.addMapping(self.dlg.ui.carriagewayComboBox, CARRIAGEWAY)
self.mapper.addMapping(self.dlg.ui.ruralUrbanComboBox, RURAL_URBAN_ID)
self.mapper.addMapping(self.dlg.ui.speedLimitComboBox, SPEED_LIMIT)
self.mapper.addMapping(self.dlg.ui.sectionTypeComboBox, SECTION_TYPE)
self.mapper.addMapping(self.dlg.ui.sectionDescriptionPlainTextEdit,
LOR_DESC)
self.mapper.setItemDelegate(MclEditorDelegate(self.dlg))
self.mapper.toFirst()
def setup_rdpoly_model_and_mapper(self, rd_pol_id):
"""
Load the data for the Polygon portion of the form
:param rd_pol_id: str rd_pol_id
:return:
"""
# Set up model
self.rdpoly_model = QSqlTableModel(db=self.db)
self.rdpoly_model.setTable('rdpoly')
self.rdpoly_model.setFilter("rd_pol_id = {}".format(int(rd_pol_id)))
self.rdpoly_model.select()
if self.rdpoly_model.rowCount() != 1:
msg = "Table rdpoly query for rd_pol_id = {} returned {} rows".format(
rd_pol_id, self.rdpoly_model.rowCount())
raise rn_except.RdpolyFormBadRdpolyRefError(msg)
# Set up rdpoly_mapper
self.rdpoly_mapper = QDataWidgetMapper()
self.rdpoly_mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.rdpoly_mapper.setModel(self.rdpoly_model)
self.rdpoly_mapper.addMapping(self.dlg.ui.rdpolyLineEdit, RD_POL_ID)
self.rdpoly_mapper.addMapping(self.dlg.ui.numberLineEdit, DESC_3)
self.rdpoly_mapper.addMapping(self.dlg.ui.elementComboBox, ELEMENT)
self.rdpoly_mapper.addMapping(self.dlg.ui.hierarchyComboBox, HIERARCHY)
self.rdpoly_mapper.addMapping(self.dlg.ui.offsetComboBox, OFFSET)
self.rdpoly_mapper.setItemDelegate(RdpolyEditorDelegate(self.dlg))
self.rdpoly_mapper.toFirst()
def fill_table_prices(self,
qtable,
table_view,
new_camp,
set_edit_triggers=QTableView.NoEditTriggers):
""" Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name + "." + table_view)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(2, 0)
model.select()
qtable.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return
# Attach model to table view
expr = "campaign_id = '" + new_camp + "'"
qtable.setModel(model)
qtable.model().setFilter(expr)
def setup_mcl_model_and_mapper(self, mcl_ref):
"""
Load the data for the MCL portion of the form
:param mcl_ref: str mcl_ref
:return:
"""
# Set up model
self.mcl_model = QSqlTableModel(db=self.db)
self.mcl_model.setTable('mcl')
self.mcl_model.setFilter("mcl_ref = {}".format(int(mcl_ref)))
self.mcl_model.select()
if self.mcl_model.rowCount() != 1:
msg = "MCL query for mcl_ref = {} returned {} rows".format(
mcl_ref, self.mcl_model.rowCount())
raise rn_except.RdpolyFormBadMclRefError(msg)
# Set up mcl_mapper
self.mcl_mapper = QDataWidgetMapper()
self.mcl_mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mcl_mapper.setModel(self.mcl_model)
self.mcl_mapper.addMapping(self.dlg.ui.mclLineEdit, MCL_REF)
self.mcl_mapper.addMapping(self.dlg.ui.usrnLineEdit, USRN)
self.mcl_mapper.addMapping(self.dlg.ui.lorDescPlainTextEdit, LOR_DESC)
self.mcl_mapper.addMapping(self.dlg.ui.laneNumberLineEdit, LANE_NUMBER)
self.mcl_mapper.addMapping(self.dlg.ui.speedLineEdit, SPEED_LIMIT)
self.mcl_mapper.toFirst()
def fill_table_psector(self, widget, table_name, column_id):
""" Set a model with selected filter.
Attach that model to selected table """
# Set model
self.model = QSqlTableModel()
self.model.setTable(self.schema_name + "." + table_name)
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
# put combobox in qtableview
sql = "SELECT * FROM " + self.schema_name + "." + table_name + " ORDER BY " + column_id
rows = self.controller.get_rows(sql)
for x in range(len(rows)):
combo = QComboBox()
sql = "SELECT DISTINCT(priority) FROM " + self.schema_name + "." + table_name
row = self.controller.get_rows(sql)
utils_giswater.fillComboBox(combo, row, False)
row = rows[x]
priority = row[4]
utils_giswater.setSelectedItem(combo, str(priority))
i = widget.model().index(x, 4)
widget.setIndexWidget(i, combo)
#combo.setStyleSheet("background:#F2F2F2")
combo.setStyleSheet("background:#E6E6E6")
combo.currentIndexChanged.connect(
partial(self.update_combobox_values, widget, combo, x))
def updateDbLineEdit(self):
"""
Updates the database information
"""
database = ''
try:
self.configWindow.widget.abstractDb.checkAndOpenDb()
database = self.configWindow.widget.comboBoxPostgis.currentText()
self.databaseLineEdit.setText(database)
self.validationManager = ValidationManager(
self.configWindow.widget.abstractDb, self.iface)
self.populateProcessList()
self.databaseLineEdit.setText(database)
# adjusting flags table model
self.projectModel = QSqlTableModel(
None, self.configWindow.widget.abstractDb.db)
self.projectModel.setTable('validation.aux_flags_validacao')
self.projectModel.select()
self.tableView.setModel(self.projectModel)
except Exception as e:
QtGui.QMessageBox.critical(
self, self.tr('Critical!'),
self.tr('A problem occurred! Check log for details.'))
QgsMessageLog.logMessage(
self.tr('Error loading db: ') + ':'.join(e.args),
"DSG Tools Plugin", QgsMessageLog.CRITICAL)
self.processTreeWidget.clear()
def __init__(self):
super(MainForm, self).__init__()
self.model = QSqlTableModel(self)
self.model.setTable('tbl_symbols')
self.model.select()
self.view = QTableView()
self.view.setModel(self.model)
self.view.horizontalHeader().setResizeMode(QHeaderView.Stretch)
addButton = QPushButton("&Add")
deleteButton = QPushButton("&Delete")
buttonLayout = QVBoxLayout()
buttonLayout.addWidget(addButton)
buttonLayout.addWidget(deleteButton)
buttonLayout.addStretch()
lay = QHBoxLayout()
lay.addWidget(self.view)
lay.addLayout(buttonLayout)
self.setLayout(lay)
self.connect(addButton, SIGNAL("clicked()"), self.addRecord)
self.connect(deleteButton, SIGNAL("clicked()"), self.deleteRecord)
def __init__(self, postgisDb, parent=None):
"""
Constructor
"""
super(ValidationHistory, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.postgisDb = postgisDb
self.dbEncoding = 'utf-8'
self.dictNoUser = {
'No User':
self.tr("Select a username..."), # no user name is selected
'Error':
self.tr("Processes with no user set"
), # "username" for processes unable to retrieve db user
'User Name Error':
self.tr("Unable to get database username."
) # log message raised on username retrieving error
} # text used as indicator of userName box contents
try:
self.projectModel = QSqlTableModel(None, self.postgisDb.db)
self.refreshViewTable(createTable=True)
except Exception as e:
QtGui.QMessageBox.critical(
self, self.tr('Critical!'),
self.
tr('A problem occurred! Check log for details. (Did you select a database?)'
))
QgsMessageLog.logMessage(': (did you choose )'.join(e.args),
"DSG Tools Plugin",
QgsMessageLog.CRITICAL)
def __init__(self):
super(MainWindow, self).__init__(None)
uic.loadUi("mainwindow.ui", self)
self.model = QSqlTableModel(self)
self.model.setTable("student")
self.model.select()
# 设置编辑策略
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.tableView.setModel(self.model)
def reload_table_visit(self):
feature_type = utils_giswater.get_item_data(
self.dlg_lot, self.dlg_lot.cmb_visit_class, 2)
object_id = utils_giswater.getWidgetText(self.dlg_lot,
self.dlg_lot.txt_filter)
visit_start = self.dlg_lot.date_event_from.date()
visit_end = self.dlg_lot.date_event_to.date()
# Get selected dates
date_from = visit_start.toString('yyyyMMdd 00:00:00')
date_to = visit_end.toString('yyyyMMdd 23:59:59')
if date_from > date_to:
message = "Selected date interval is not valid"
self.controller.show_warning(message)
return
visit_class_id = utils_giswater.get_item_data(
self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
sql = ("SELECT visitclass_id, formname, tablename FROM " +
self.schema_name + ".config_api_visit "
" WHERE visitclass_id ='" + str(visit_class_id) + "'")
row = self.controller.get_row(sql, log_sql=False)
table_name = row['tablename']
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Create interval dates
format_low = 'yyyy-MM-dd 00:00:00.000'
format_high = 'yyyy-MM-dd 23:59:59.999'
interval = "'{}'::timestamp AND '{}'::timestamp".format(
visit_start.toString(format_low), visit_end.toString(format_high))
expr_filter = ("(startdate BETWEEN {0}) AND (enddate BETWEEN {0})".
format(interval))
if object_id != 'null':
expr_filter += " AND " + str(
feature_type) + "_id::TEXT ILIKE '%" + str(object_id) + "%'"
expr_filter += " AND " + str(feature_type) + "_id IN ('0', "
for i in range(len(self.ids)):
expr_filter += "'" + str(self.ids[i]) + "', "
expr_filter = expr_filter[:-2] + ")"
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(expr_filter)
model.sort(0, 1)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
self.dlg_lot.tbl_visit.setModel(model)
def __init__(self, parent=None):
super(EditItemDlg, self).__init__(parent)
# # Create model
self.locusTypeModel = QSqlTableModel(self)
self.locusTypeModel.setTable("tbl_locusType")
self.locusTypeModel.select()
# Create combo and set its model
self.locusTypeComboBox = self.createCombobox(self.locusTypeModel,
"LABEL")
typeLabel = QLabel("&Type:")
typeLabel.setBuddy(self.locusTypeComboBox)
# # Create model
self.locusSubTypeModel = QSqlTableModel(self)
self.locusSubTypeModel.setTable("tbl_locus_subType1")
#self.locusSubTypeModel.select()
# Create combo and set its model
self.locusSubTypeCombobox = self.createCombobox(
self.locusSubTypeModel, "label")
#
# self.locusSubTypeCombobox = QComboBox()
# self.locusSubTypeCombobox.setModel(self.locusSubTypeModel)
# self.locusSubTypeCombobox.setModelColumn(
# self.locusTypeModel.fieldIndex("label"))
# # Create model
# self.locusSubType2Model = QSqlTableModel(self)
# self.locusSubType2Model.setTable("tbl_locus_subType1")
# self.locusSubType2Model.select()
controlLayout = QGridLayout()
controlLayout.addWidget(self.locusTypeComboBox, 4, 0)
controlLayout.addWidget(self.locusSubTypeCombobox, 5, 0)
self.setLayout(controlLayout)
self.resize(500, 125)
self.locusTypeComboBox.currentIndexChanged.connect(self.f)
def create_data_model(self, table_id):
"""
create an object from the QSqlTableModel class used to data modifications
to send to the database
:param table_id: the id passed from the radio button
:return: void
"""
self.data_model = QSqlTableModel(db=self.db)
self.data_model.setTable(self.tables[table_id])
self.data_model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.data_model.setSort(2, Qt.AscendingOrder)
self.data_model.select()
while self.data_model.canFetchMore():
self.data_model.fetchMore()
def fill_main_table(self,
dialog,
table_name,
set_edit_triggers=QTableView.NoEditTriggers,
refresh_model=True):
""" Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name + "." + table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
dialog.all_rows.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return
# Get all ids from Qtable selected_rows
id_all_selected_rows = self.select_all_rows(dialog.selected_rows,
'mu_id')
# Convert id_all_selected_rows to string
ids = "0, "
for x in range(0, len(id_all_selected_rows)):
ids += str(id_all_selected_rows[x]) + ", "
ids = ids[:-2] + ""
# Build expression
expr = (" mu_name ILIKE '%" + dialog.txt_search.text() + "%'"
" AND mu_id NOT IN (" + ids + ")"
" AND campaign_id::text = '" + str(self.campaign_id) + "'"
" OR campaign_id IS null")
self.controller.log_info(expr)
# (is_valid, expr) = self.check_expression(expr) # @UnusedVariable
# # if not is_valid:
# # return
model.setFilter(expr)
# Refresh model?
if refresh_model:
model.select()
# Attach model to table view
dialog.all_rows.setModel(model)
def set_table_model(self, table_object, geom_type, expr_filter):
""" Sets a TableModel to @widget_name attached to
@table_name and filter @expr_filter
"""
expr = None
if expr_filter:
# Check expression
(is_valid,
expr) = self.check_expression(expr_filter) #@UnusedVariable
if not is_valid:
return expr
# Set a model with selected filter expression
table_name = "v_edit_" + geom_type
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set the model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
return expr
# Attach model to selected widget
if type(table_object) is str:
widget = utils_giswater.getWidget(table_object)
if not widget:
message = "Widget not found"
self.controller.log_info(message, parameter=table_object)
return expr
elif type(table_object) is QTableView:
widget = table_object
else:
message = "Table_object is not a table name or QTableView"
self.controller.log_info(message)
return expr
if expr_filter:
widget.setModel(model)
widget.model().setFilter(expr_filter)
widget.model().select()
else:
widget.setModel(None)
return expr
def fill_table_config(self, widget, table_name):
""" Set a model with selected filter. Attach that model to selected table """
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
def __init__(self, postgisDb, parent=None):
"""
Constructor
"""
super(ValidationHistory, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.postgisDb = postgisDb
self.projectModel = QSqlTableModel(None, self.postgisDb.db)
self.projectModel.setTable('validation.process_history')
self.projectModel.select()
self.tableView.setModel(self.projectModel)
def populate_list(self, table_id):
"""
populate the list view on initialisation and when radio buttons are toggled
:param table_id: the id passed from the radio button
:return: void
"""
self.lsg_lu_dia.ui.addLookupLineEdit.clear()
self.items_model = QSqlTableModel(db=self.db)
self.items_model.setTable(self.tables[table_id])
self.items_model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.items_model.setSort(2, Qt.AscendingOrder)
self.items_model.select()
while self.items_model.canFetchMore():
self.items_model.fetchMore()
self.lsg_lu_dia.ui.itemsListView.setModel(self.items_model)
self.lsg_lu_dia.ui.itemsListView.setModelColumn(2)
def fill_table(self,
qtable,
table_name,
set_edit_triggers=QTableView.NoEditTriggers,
expr_filter=None):
""" Fill table @widget filtering query by @workcat_id
Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
expr = None
if expr_filter:
# Check expression
(is_valid,
expr) = self.check_expression(expr_filter) # @UnusedVariable
if not is_valid:
return expr
# Set a model with selected filter expression
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setSort(0, 0)
model.select()
# When change some field we need to refresh Qtableview and filter by psector_id
qtable.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if expr:
qtable.setModel(model)
qtable.model().setFilter(expr_filter)
else:
qtable.setModel(model)
return expr
def get_table_model(table, table_filters=None):
"""Get table model of table.
:param table: Table target be inserted
:type table: str
:return: Table Model for contact
:rtype: QSqlTableModel
"""
CadastaDatabase.open_database()
table_model = QSqlTableModel()
table_model.setTable(table)
table_model.setEditStrategy(QSqlTableModel.OnManualSubmit)
if table_filters:
for table_filter in table_filters:
table_model.setFilter(table_filter)
table_model.select()
return table_model
def fill_table(self,
dialog,
table_view,
set_edit_triggers=QTableView.NoEditTriggers,
update=False):
""" Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name + "." + table_view)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setSort(2, 0)
model.select()
dialog.selected_rows.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Create expresion
expr = " mu_name ILIKE '%" + dialog.txt_selected_filter.text() + "%'"
if self.selected_camp is not None:
expr += " AND campaign_id = '" + str(self.campaign_id) + "'"
if update:
expr += " OR campaign_id = '" + str(self.selected_camp) + "'"
# Attach model to table or view
dialog.selected_rows.setModel(model)
dialog.selected_rows.model().setFilter(expr)
# Set year to plan to all rows in list
for x in range(0, model.rowCount()):
i = int(dialog.selected_rows.model().fieldIndex('campaign_id'))
index = dialog.selected_rows.model().index(x, i)
model.setData(index, self.campaign_id)
self.calculate_total_price(dialog, self.campaign_id)
def fill_table_object(self, widget, table_name, expr_filter=None):
""" Set a model with selected filter. Attach that model to selected table """
if self.schema_name not in table_name:
table_name = self.schema_name + "." + table_name
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.sort(0, 1)
if expr_filter:
model.setFilter(expr_filter)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
def fill_table(self,
widget,
table_name,
set_edit_strategy=QSqlTableModel.OnManualSubmit):
""" Set a model with selected filter.
Attach that model to selected table """
# Set model
self.model = QSqlTableModel()
self.model.setTable(self.schema_name + "." + table_name)
self.model.setEditStrategy(set_edit_strategy)
self.model.setSort(0, 0)
self.model.select()
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
widget.setModel(self.model)
def set_model_to_table(self, widget, table_name, expr_filter):
""" Set a model with selected filter.
Attach that model to selected table """
# Set model
model = QSqlTableModel();
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(expr_filter)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if widget:
widget.setModel(model)
else:
self.controller.log_info("set_model_to_table: widget not found")
def __init__(self, parent):
QDialog.__init__(self)
self.parent = parent
self.model = QSqlTableModel(self, DBHandle.default)
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.model.setTable("player")
self.model.setSort(1, 0)
self.model.setHeaderData(1, Qt.Horizontal,
QVariant(m18nc("Player", "Name")))
self.model.setFilter(
'name not like "ROBOT %" and name not like "Robot %"')
self.view = MJTableView(self)
self.view.verticalHeader().show()
self.view.setModel(self.model)
self.view.hideColumn(0)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.newButton = self.buttonBox.addButton(
m18nc('define a new player', "&New"), QDialogButtonBox.ActionRole)
self.newButton.setIcon(KIcon("document-new"))
self.newButton.clicked.connect(self.slotInsert)
self.deleteButton = self.buttonBox.addButton(
m18n("&Delete"), QDialogButtonBox.ActionRole)
self.deleteButton.setIcon(KIcon("edit-delete"))
self.deleteButton.clicked.connect(self.delete)
cmdLayout = QHBoxLayout()
cmdLayout.addWidget(self.buttonBox)
layout = QVBoxLayout()
layout.addWidget(self.view)
layout.addLayout(cmdLayout)
self.setLayout(layout)
self.setWindowTitle(m18n("Players") + ' - Kajongg')
self.setObjectName('Players')
def fill_table_relations(self, widget, table_name):
""" Set a model with selected filter. Attach that model to selected table """
filter_ = ""
for row in self.selected_list:
filter_ += "arc_id = '" + str(row) + "' OR "
filter_ = filter_[:-3] + ""
filter_ += " AND arc_state = '1' "
# Set model
model = QSqlTableModel()
model.setTable(table_name)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.setFilter(filter_)
model.select()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
widget.setModel(model)
widget.show()
def __init__(self):
super(Locus, self).__init__()
self.layout = QtGui.QGridLayout()
self.LocusIdEntry = QtGui.QLineEdit()
# # Create model
self.locusTypeModel = QSqlTableModel(self)
self.locusTypeModel.setTable("tbl_locusType")
self.locusTypeModel.select()
self.locusSubType1Model = QSqlTableModel(self)
self.locusSubType1Model.setTable("tbl_locus_subtype1")
#self.locusSubType1Model.select()
self.locusSubType2Model = QSqlTableModel(self)
self.locusSubType2Model.setTable("tbl_locus_subtype2")
self.locusSubType3Model = QSqlTableModel(self)
self.locusSubType3Model.setTable("tbl_locus_subtype3")
# Create combo and set its model
self.locusType = self.createCombobox(self.locusTypeModel, "typeLabel")
self.locusSubType1 = self.createCombobox(self.locusSubType1Model, "subtype1Label")
self.locusSubType2 = self.createCombobox(self.locusSubType2Model, "subtype2Label")
self.locusSubType3 = self.createCombobox(self.locusSubType3Model, "subtype3Label")
self.SectorTrenchEntry = QtGui.QLineEdit()
self.SpaceRoomEntry = QtGui.QLineEdit()
self.LocusDescription = QtGui.QPlainTextEdit()
self.LocusDescription.setFixedHeight(100)
"""Set the layout"""
self.layout.addWidget(QtGui.QLabel('Locus Number:', self), 0, 0)
self.layout.addWidget(self.LocusIdEntry, 0, 1)
self.layout.addWidget(QtGui.QLabel('Locus Type:', self), 1, 0)
self.layout.addWidget(self.locusType, 1, 1, )
self.layout.addWidget(QtGui.QLabel('Locus SubType1:', self), 2, 0)
self.layout.addWidget(self.locusSubType1, 2, 1)
# self.layout.setColumnMinimumWidth(1, 1)
self.layout.addWidget(QtGui.QLabel('Locus SubType2:', self), 3, 0)
self.layout.addWidget(self.locusSubType2, 3, 1)
self.layout.addWidget(QtGui.QLabel('Locus SubType3:', self), 4, 0)
self.layout.addWidget(self.locusSubType3, 4, 1)
self.layout.addWidget(QtGui.QLabel('Sector/ Trench:', self), 7, 0)
self.layout.addWidget(self.SectorTrenchEntry, 7, 1, 1, 1)
self.layout.addWidget(QtGui.QLabel('Space/ Room:', self), 8, 0)
self.layout.addWidget(self.SpaceRoomEntry, 8, 1, 1, 1)
self.layout.addWidget(QtGui.QLabel('Description:', self), 9, 0)
self.layout.addWidget(self.LocusDescription, 9, 1, 1, 8)
self.map = QtGui.QPushButton('Map', self)
self.saveButton = QtGui.QPushButton('Save', self)
self.cancelButton = QtGui.QPushButton('Cancel', self)
self.addButton = QtGui.QPushButton('Add New', self)
self.layout.addWidget(self.map, 11, 0)
self.layout.addWidget(self.saveButton, 11, 4)
self.layout.addWidget(self.cancelButton, 11, 6)
self.layout.addWidget(self.addButton, 11, 2)
self.setLayout(self.layout)
self.setGeometry(500, 500, 550, 500)
self.setWindowTitle('Locus')
self.locusType.setCurrentIndex(-1)
self.locusType.currentIndexChanged.connect( self.subType1selection)
self.locusSubType1.currentIndexChanged.connect(self.subType2selection)
self.locusSubType2.currentIndexChanged.connect(self.subType3selection)
def fill_table(self, widget, table_name, hidde=False, set_edit_triggers=QTableView.NoEditTriggers, expr=None ):
""" Set a model with selected filter.
Attach that model to selected table
@setEditStrategy:
0: OnFieldChange
1: OnRowChange
2: OnManualSubmit
"""
# Set model
model = QSqlTableModel()
model.setTable(self.schema_name+"."+table_name)
model.setEditStrategy(QSqlTableModel.OnFieldChange)
model.setSort(0, 0)
model.select()
# When change some field we need to refresh Qtableview and filter by psector_id
model.dataChanged.connect(partial(self.refresh_table, widget))
model.dataChanged.connect(partial(self.update_total, widget))
widget.setEditTriggers(set_edit_triggers)
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
# Attach model to table view
if expr:
widget.setModel(model)
widget.model().setFilter(expr)
else:
widget.setModel(model)
if hidde:
self.refresh_table(widget)
