def __init__(self):
'''
Constructor
'''
super(tbFactura, self).__init__()
# ESTABLECER LA INTERFAZ AL FORMULARIO
self.setupUi(self)
# VALIDADOR DE MODO DE EDICION
self.readOnly = True
self.editmodel = None
#ESTABLECER LA FECHA INICIAL , (establecida al dia de mañana)
self.categoriesview.headers = [
"Descripcion", "Precio", "Unidades", "Existencia", "", "", ""
]
# Crear el modelo para cargar catalogo de clientes
self.clientesModel = QSqlQueryModel()
# Crear lista de autocompletado para el combo de clientes
self.clienteCompleter = QCompleter()
# Modelo que carga el catalogo de productos
self.existenciaModel = QSqlQueryModel()
# Establecer todos los controles en modo de edicion
self.setControls(False)
# Crear la conexion a la base de datos
self.database = QSqlDatabase.database()
self.vistaprevia = False
# Cargar los modelos del modo de edicion
self.updateEditModels()
self.parent = self.parent()
def __init__( self ,tipopersona, parent ):
'''
Constructor
'''
super( dlgPersona, self ).__init__( parent )
self.setupUi(self)
# self.tableview.addActions( ( self.actionEdit, self.actionNew ) )
self.idtipopersona = tipopersona
self.table = ""
self.backmodel = QSqlQueryModel()
self.database = parent.database
self.filtermodel = QSortFilterProxyModel( self )
self.filtermodel.setSourceModel( self.backmodel )
self.filtermodel.setDynamicSortFilter( True )
self.filtermodel.setFilterKeyColumn( -1 )
self.filtermodel.setFilterCaseSensitivity( Qt.CaseInsensitive )
self.paisesModel = QSqlQueryModel()
self.cbpais.setModel( self.paisesModel )
self.cbpais.setCurrentIndex( -1 )
self.cbpais.setFocus()
self.cbpais.setModelColumn( 1 )
self.paisescompleter = QCompleter()
self.paisescompleter.setCaseSensitivity( Qt.CaseInsensitive )
self.paisescompleter.setModel( self.paisesModel )
self.paisescompleter.setCompletionColumn( 1 )
self.cbpais.setCompleter( self.paisescompleter )
self.proveedoresModel = QSqlQueryModel()
self.cbproveedor.setModel( self.proveedoresModel )
self.cbproveedor.setCurrentIndex( -1 )
self.cbproveedor.setFocus()
self.cbproveedor.setModelColumn( 1 )
self.proveedorcompleter = QCompleter()
self.proveedorcompleter.setCaseSensitivity( Qt.CaseInsensitive )
self.proveedorcompleter.setModel( self.proveedoresModel )
self.proveedorcompleter.setCompletionColumn( 1 )
self.cbproveedor.setCompleter( self.proveedorcompleter )
# self.tableview.setModel(self.filtermodel)
self.cbsexo.setCurrentIndex(-1)
self.txtnombre.setFocus()
self.setReadOnly(True)
QTimer.singleShot( 0, self.updateModels )
def get_linked_esu_list(self, usrn):
"""
function that selects all esus for a determined street
:param usrn: the unique identifier of a certain street
:return: list[esu_ids] all esu ids linked to a certain street or
void in case a street does not have any linked esu
"""
# executing the query
esus_query_model = QSqlQueryModel()
esus_query_model.setQuery(self.queries[9].format(usrn))
while esus_query_model.canFetchMore():
esus_query_model.fetchMore()
n_rows = esus_query_model.rowCount()
# skip if no esus are linked
if n_rows == 0:
return
else:
i = 0
esus_list = []
# creating a list of ESUs Ids that are linked to the street
while i <= n_rows - 1:
model_index = esus_query_model.createIndex(i, 0)
esu = model_index.data()
esus_list.append(esu)
i += 1
return esus_list
def show_predictions_table(self):
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
self.tableView_PM.setWindowTitle("Connect to QSQLITE Database Example")
db.setHostName("localhost")
db.setDatabaseName("serm.db")
db.setUserName("")
db.setPassword("")
if (db.open()==False):
message = "Database Error"
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Error at opening database")
msg.setInformativeText(message)
msg.setWindowTitle("Informative Message")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
projectModel = QSqlQueryModel()
projectModel.setQuery("SELECT datetime,smoke,temperature,humidity,windspeed,fri,ffwi FROM predictions ORDER BY recid DESC",db)
self.tableView_PM.setModel(projectModel)
self.tableView_PM.adjustSize
self.tableView_PM.setColumnWidth(0,160)
self.tableView_PM.show()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.ui = sm.Ui_Dialog()
self.ui.setupUi(self)
self.ui.table_studentList
# Call DB
self.db = QSqlDatabase.addDatabase("QSQLITE")
self.db.setDatabaseName("studentInformation001.db")
self.db.open()
# End of call DB
# student info into table view
projectModel = QSqlQueryModel()
projectModel.setQuery(
"SELECT schoolNumber, Name FROM Student ORDER BY schoolNumber ASC",
self.db)
projectView = self.ui.table_studentList
projectView.setModel(projectModel)
projectView.show()
#end of student info into table view
# QTableView Click Event
self.qTableView = self.ui.table_studentList
self.qTableView.clicked.connect(self.showInfo)
# click and connection update
self.ui.Btn_Update.clicked.connect(self.cont)
# click and connection grade
self.ui.Btn_Grade.clicked.connect(self.contGrade)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = sm.Ui_MainWindow()
self.ui.setupUi(self)
self.ui.table_studentList
# Call DB
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("studentInformation001.db")
db.open()
# End of call DB
# student info into table view
projectModel = QSqlQueryModel()
projectModel.setQuery(
"SELECT schoolNumber, Name FROM Student ORDER BY schoolNumber ASC",
db)
projectView = self.ui.table_studentList
projectView.setModel(projectModel)
projectView.show()
#end of student info into table view
# QTableView Click Event
self.qTableView = self.ui.table_studentList
self.qTableView.clicked.connect(self.showInfo)
def tabChangedSlot(self,argTabIndex):
if argTabIndex==1:
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
self.tableView.setWindowTitle("Connect to QSQLITE Database Example")
db.setHostName("localhost")
db.setDatabaseName("serm_shadow.db")
db.setUserName("")
db.setPassword("")
if (db.open()==False):
message = "Database Error"
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Error at opening database")
msg.setInformativeText(message)
msg.setWindowTitle("Informative Message")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
projectModel = QSqlQueryModel()
projectModel.setQuery("SELECT datetime,temperature,humidity,smoke,lpg,co,windspeed,winddir,ffwi,risk FROM data_means ORDER BY recid DESC",db)
self.tableView.setModel(projectModel)
self.tableView.adjustSize
self.tableView.setColumnWidth(0,168)
self.tableView.show()
elif argTabIndex==3:
conn = sqlite3.connect('serm.db')
ds = pd.read_sql("SELECT timestamp,datetime,risk,smoke,temperature,humidity,windspeed,ffwi from data_means", conn);
conn.close()
ds.to_csv("serm.csv")
self.show_predictions_table()
def querymodel(self, sql, **mappings):
query = self._query(sql, **mappings)
if query.exec_():
model = QSqlQueryModel()
model.setQuery(query)
return model
else:
raise DatabaseException(query.lastError().text())
def loading(self):
save_path = 'database/'
complete = os.path.join(save_path, "user")
f = open(complete, "r")
creator = f.read()
f.close()
print(creator)
save_path = 'database/'
comp = os.path.join(save_path, "user.sqlite")
db = sqlite3.connect(comp)
cur = db.cursor()
f = unicode(
cur.execute('SELECT Role FROM users where Username=(?)',
(creator, )).fetchone()[0])
db.close()
if (f == "Admin"):
save_path = 'database/'
complete = os.path.join(save_path, "user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("select * from Files", db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
elif (f == 'User'):
save_path = 'database/'
save = os.path.join(save_path, "user.sqlite")
db = sqlite3.connect(save)
cur = db.cursor()
f = """SELECT * FROM Files where File_creator=('%s')""" % (
creator) #This shit cost me a lot i will never forget
complete = os.path.join(save_path, "user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery(f, db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
def clear_xref_and_esu_tables(self):
"""
Blank model clears the xref table
"""
# Set xref to empty model
empty_model = QSqlQueryModel()
self.street_browser.ui.crossReferenceTableView.setModel(empty_model)
# Clear list widget
self.street_browser.ui.linkEsuListWidget.clear()
def querymodel(self, sql, **mappings):
sql = sql.replace(r"\r\n", " ")
query = self._query(sql, **mappings)
print sql, mappings
if query.exec_():
model = QSqlQueryModel()
model.setQuery(query)
return model
else:
raise DatabaseException(query.lastError().text())
def __init__(self):
super(MainWindow, self).__init__(None)
self.model = QSqlQueryModel(self)
self.model.setQuery("select * from student")
self.model.setHeaderData(0, Qt.Horizontal, self.tr("学号"))
self.model.setHeaderData(1, Qt.Horizontal, self.tr("姓名"))
self.model.setHeaderData(2, Qt.Horizontal, self.tr("课程"))
self.view = QTableView(self)
self.view.setModel(self.model)
self.setCentralWidget(self.view)
def fill_tables(self, qtable, table_name):
"""
:param qtable: QTableView to show
:param table_name: view or table name wich we want to charge
"""
sql = "SELECT * FROM " + self.controller.schema_name + "." + table_name
sql += " WHERE node_id = '" + self.id + "'"
model = QSqlQueryModel()
model.setQuery(sql)
qtable.setModel(model)
qtable.show()
def fill_table_by_query(self, qtable, query):
"""
:param qtable: QTableView to show
:param query: query to set model
"""
model = QSqlQueryModel()
model.setQuery(query)
qtable.setModel(model)
qtable.show()
# Check for errors
if model.lastError().isValid():
self.controller.show_warning(model.lastError().text())
def loading(self):
db = QSqlDatabase.addDatabase("QSQLITE")
save_path='database/'
complete = os.path.join(save_path,"user.sqlite")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("select * from users",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
def __init__(self, parent=None, datamodel=None):
"""
Constructor
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self.model = QSqlQueryModel()
self.selTableView.setModel(self.model)
self.database = datamodel.getQSqlDatabase()
self.updateModel()
self.selTableView.hideColumn(0)
self.selTableView.hideColumn(5)
self.selTableView.hideColumn(6)
# Change status and keep the column.
QObject.connect(datamodel, SIGNAL("modelInstalled()"),
self.on_datamodel_modelInstalled)
def populate_list(self, table_id):
"""
populate the list view on initialisation and when radio buttons are toggled,
this view is just for show because QSqlQueryModel class does not handle editing
but data need to be displayed as concatenated strings, this is not allowed in a
QSqlTableModel class
:param table_id: the id passed from the radio button
:return: void
"""
self.srwr_lu_dia.ui.typeDescLineEdit.clear()
self.items_model = QSqlQueryModel()
self.items_model.setQuery(self.queries[table_id], self.db)
while self.items_model.canFetchMore():
self.items_model.fetchMore()
self.srwr_lu_dia.ui.typeNoSpinBox.setValue(0)
self.srwr_lu_dia.ui.itemsListView.setModel(self.items_model)
self.srwr_lu_dia.ui.itemsListView.setModelColumn(1)
self.create_data_model(table_id)
def __init__(self, netmanager, clipboard, parent=None):
super(MainWin, self).__init__(parent)
self.setWindowTitle("Eilat Browser " + netmanager.name)
self.netmanager = netmanager
self.clipboard = clipboard
self.tab_widget = QTabWidget(self)
self.tab_widget.tabBar().setMovable(True)
self.setCentralWidget(self.tab_widget)
self.tab_widget.setTabsClosable(True)
database = QSqlDatabase("QPSQL")
database.open("pguser", "pguser")
query = QSqlQuery(
"select concat(host, path) h, count(*) c from reply " +
"where status between 200 and 399 " +
"and is_bookmarkable(path) " +
"and host not in (select host from filtro) " + "group by h " +
"order by c desc", database)
self.model = QSqlQueryModel()
self.model.setQuery(query)
self.tab_widget.tabCloseRequested.connect(self.del_tab)
def new_tab_from_clipboard():
""" One-use callback for QShortcut.
Reads the content of the PRIMARY clipboard and navigates to it
on a new tab.
"""
url = unicode(self.clipboard.text(QClipboard.Selection)).strip()
self.add_tab(url)
set_shortcuts([("Ctrl+T", self, self.add_tab),
("Y", self, new_tab_from_clipboard),
("Ctrl+W", self, self.del_tab),
("N", self, partial(self.inc_tab, -1)),
("Ctrl+PgUp", self, partial(self.inc_tab, -1)),
("M", self, self.inc_tab),
("Ctrl+PgDown", self, self.inc_tab),
("Ctrl+Q", self, QApplication.closeAllWindows)])
def __init__(self, parent):
'''
Constructor
'''
super(DlgPais, self).__init__(parent)
self.setupUi(self)
self.table = ""
self.backmodel = QSqlQueryModel()
self.database = parent.database
self.filtermodel = QSortFilterProxyModel(self)
self.filtermodel.setSourceModel(self.backmodel)
self.filtermodel.setDynamicSortFilter(True)
self.filtermodel.setFilterKeyColumn(-1)
self.filtermodel.setFilterCaseSensitivity(Qt.CaseInsensitive)
# self.tableview.setModel(self.filtermodel)
self.setReadOnly(True)
QTimer.singleShot(0, self.updateModels)
def workcat_fill_table(self, workcat_id):
""" Fill table @widget filtering query by @workcat_id """
result_select = utils_giswater.getWidgetText(self.items_dialog.txt_name)
if result_select != 'null':
expr = " feature_id LIKE '%" + result_select + "%'"
# Refresh model with selected filter
self.controller.log_info(expr)
self.tbl_psm.model().setFilter(expr)
self.tbl_psm.model().select()
return
# Define SQL
sql = ("SELECT 'NODE' as feature_type, nodecat_id AS featurecat_id, node_id AS feature_id, code, name as state"
" FROM " + self.schema_name + ".v_edit_node JOIN " + self.schema_name + ".value_state ON id = state"
" WHERE workcat_id = '" + str(workcat_id) + "'"
" UNION"
" SELECT 'ARC', arccat_id, arc_id, code, name"
" FROM " + self.schema_name + ".v_edit_arc JOIN " + self.schema_name + ".value_state ON id = state"
" WHERE workcat_id = '" + str(workcat_id) + "'"
" UNION"
" SELECT 'ELEMENT', elementcat_id, element_id, code, name"
" FROM " + self.schema_name + ".v_edit_element JOIN " + self.schema_name + ".value_state ON id = state"
" WHERE workcat_id = '" + str(workcat_id) + "'"
" UNION"
" SELECT 'CONNEC', connecat_id, connec_id, code, name"
" FROM " + self.schema_name + ".v_edit_connec JOIN " + self.schema_name + ".value_state ON id = state"
" WHERE workcat_id = '" + str(workcat_id) + "'")
# Set model
self.model = QSqlQueryModel()
self.model.setQuery(sql)
# Check for errors
if self.model.lastError().isValid():
self.controller.show_warning(self.model.lastError().text())
# Attach model to table view
self.tbl_psm.setModel(self.model)
def write_content(self,
query_id,
header_id,
header_no_content_id,
columns_name_id,
include_footpaths=True,
include_subtitle=False):
"""
format the content of the data coming from the db either in text or dialog format
:param query_id: int reference to the query dictionary
:param header_id: int reference to the header dictionary
:param header_no_content_id: int reference to the header no content dictionary
:param columns_name_id: int reference to the list of columns of the required table
:param include_footpaths: bool value to include footpaths in type 3 streets query
:param include_subtitle: bool indicates if the header has a subtitle
:return: void
"""
# build a query model object
query_model = QSqlQueryModel()
if not include_footpaths:
filtered_query = self.queries[2].replace(
"AND (lnkESU_STREET.Currency_flag = 0)",
"AND (lnkESU_STREET.Currency_flag = 0) AND "
"(tblStreet.Description not like '%Footpath%')")
query_model.setQuery(filtered_query)
else:
query_model.setQuery(self.queries[query_id])
while query_model.canFetchMore():
query_model.fetchMore()
parent_model_index = QModelIndex()
# if the path is not specified sends data to function creating a list
if self.file_path is None:
assert isinstance(columns_name_id, object)
items_list = self.content_to_screen(
content_list=None,
query_model=query_model,
columns_name_id=columns_name_id,
no_content_id=header_no_content_id)
return items_list
def results_to_txt_row(self, vals, sql, mode):
query_model = QSqlQueryModel()
query_model.setQuery(sql)
model_index = QModelIndex()
row_count = query_model.rowCount(model_index)
if row_count < 1:
self.file.write(self.no_content)
else:
query = QSqlQuery(self.db)
query.exec_(sql)
rec = query.record()
if mode == "streets":
avals = [
rec.indexOf(vals[0]),
rec.indexOf(vals[1]),
rec.indexOf(vals[2]),
rec.indexOf(vals[3]),
rec.indexOf(vals[4]),
rec.indexOf(vals[5]),
rec.indexOf(vals[6]),
rec.indexOf(vals[7]),
rec.indexOf(vals[8]),
rec.indexOf(vals[9]),
rec.indexOf(vals[10]),
rec.indexOf(vals[11])
]
n = 0
# write content
headers = self.headers[0]
while n <= len(headers) - 1:
if n == len(headers) - 1:
self.file.write(str(headers[n]) + "\n")
else:
self.file.write(str(headers[n]) + " ")
n += 1
while query.next():
line = [
query.value(avals[0]),
query.value(avals[1]),
query.value(avals[2]),
query.value(avals[3]),
query.value(avals[4]),
query.value(avals[5]),
query.value(avals[6]),
query.value(avals[7]),
query.value(avals[8]),
query.value(avals[9]),
query.value(avals[10]),
query.value(avals[11])
]
self.file.write(
str(line[0]) + " , " + str(line[1]) + " , " +
str(line[2]) + " , " + str(line[3]) + " , " +
str(line[4]) + " , " + str(line[5]) + " , " +
self.format_dates(str(line[6])) + " , " +
self.format_dates(str(line[7])) + " , " +
self.format_dates(str(line[8])) + " , " +
self.format_dates(str(line[9])) + " , " +
str(line[10]) + " " + str(line[11]) + "\n")
else:
avals = [
rec.indexOf(vals[0]),
rec.indexOf(vals[1]),
rec.indexOf(vals[2]),
rec.indexOf(vals[3]),
rec.indexOf(vals[4]),
rec.indexOf(vals[5]),
rec.indexOf(vals[6]),
rec.indexOf(vals[7])
]
m = 0
headers = self.headers[1]
while m <= len(headers) - 1:
if m == len(headers) - 1:
self.file.write(str(headers[m]) + "\n")
else:
self.file.write(str(headers[m]) + " ")
m += 1
while query.next():
line = [
query.value(avals[0]),
query.value(avals[1]),
query.value(avals[2]),
query.value(avals[3]),
query.value(avals[4]),
query.value(avals[5]),
query.value(avals[6]),
query.value(avals[7])
]
self.file.write(
str(line[0]) + " , " + str(line[1]) + " , " +
str(line[2]) + " , " + str(line[3]) + " , " +
str(line[4]) + " , " + str(line[5]) + " , " +
str(line[6]) + " , " + str(line[7]) + "\n")
from PyQt4.QtSql import QSqlQueryModel, QSqlDatabase
from PyQt4.QtGui import QApplication, QListView, QTableView
import sys
app = QApplication(sys.argv)
db = QSqlDatabase.addDatabase("QMYSQL")
db.setHostName("localhost")
db.setDatabaseName("app")
db.setUserName("root")
db.setPassword("")
db.open()
projectModel = QSqlQueryModel()
projectModel.setQuery("select name from customers", db)
projectView = QTableView()
projectView.setModel(projectModel)
projectView.show()
model = projectView.model()
indexes = projectView.selectionModel().currentIndex().row()
app.exec_()
def loading(self):
save_path='database/'
complete = os.path.join(save_path,"user")
f=open(complete,"r")
creator=f.read()
f.close()
############so finally i came up with something###########
#TOPSECRET=4
#SECRET=3
#CONFIDENTIAL=2
#UNCLASSIFIED=1
############never under estimate your opponent###############
print(creator)
save_path='database/'
comp = os.path.join(save_path,"user.sqlite")
db = sqlite3.connect(comp)
cur= db.cursor()
f=unicode(cur.execute('SELECT Role FROM users where Username=(?)',(creator,)).fetchone()[0])
cl=unicode(cur.execute('SELECT Clearance FROM users where Username=(?)',(creator,)).fetchone()[0])
allow=unicode(cur.execute('SELECT access_auth FROM users where Username=(?)',(creator,)).fetchone()[0])
db.close()
if(f=="Admin"):
save_path='database/'
complete = os.path.join(save_path,"user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("select * from Files",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
elif(f=='User'):
if(allow=="Yes"):
if(cl =="TOPSECRET"):
save_path='database/'
save = os.path.join(save_path,"user.sqlite")
db = sqlite3.connect(save)
cur= db.cursor()
complete = os.path.join(save_path,"user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("SELECT * FROM files where Clearance in('TOPSECRET','SECRET','CONFIDENTIAL','UNCLASSIFIED')",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
elif(cl =="SECRET"):
save_path='database/'
save = os.path.join(save_path,"user.sqlite")
db = sqlite3.connect(save)
cur= db.cursor()
complete = os.path.join(save_path,"user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("SELECT * FROM files where Clearance in('SECRET','CONFIDENTIAL','UNCLASSIFIED')",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
elif(cl =="CONFIDENTIAL"):
save_path='database/'
save = os.path.join(save_path,"user.sqlite")
db = sqlite3.connect(save)
cur= db.cursor()
complete = os.path.join(save_path,"user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("SELECT * FROM files where Clearance in('CONFIDENTIAL','UNCLASSIFIED')",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
elif(cl =="UNCLASSIFIED"):
save_path='database/'
save = os.path.join(save_path,"user.sqlite")
db = sqlite3.connect(save)
cur= db.cursor()
complete = os.path.join(save_path,"user.sqlite")
db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName(complete)
db.open()
View = QSqlQueryModel()
View.setQuery("SELECT * FROM files where Clearance in('UNCLASSIFIED')",db)
self.tableView = QtGui.QTableView()
self.tableView.setModel(View)
self.tableView.show()
print q.exec_()
except Exception, e:
import traceback
QMessageBox.critical(
None, "Error",
u"<h2>%s</h2></pre>%s</pre>" % (type(e), traceback.format_exc()))
sys.exit()
query = QSqlQuery('''
SELECT CONCAT(UC.nombre_uc, '(' ,UC.id_UC,')'),
UC.id FROM UC WHERE UC.co_id = %(co_id)d
''' % {'co_id': 1})
print "Error?", query.lastError().databaseText()
model = QSqlQueryModel()
model.setQuery(query)
combo_box = QComboBoxModelQuery()
combo_box.setMinimumWidth(400)
def prueba(index):
print "-------------------------------------------------------------"
print index
print "El id es", combo_box.get_col_value(0),\
combo_box.get_col_value()
print "Conexion", combo_box.connect(combo_box,
SIGNAL('currentIndexChanged(int)'),
prueba)
def loadtree(self, geom, epsg, pid, profilename, buffervalue):
epsg = self.xuni(epsg)
pid = self.xuni(pid)
profilename = self.xuni(profilename)
# Create profile model
if self.parent.dbmeta.isOpen():
# Create model for treeview
model = QtGui.QStandardItemModel()
model.setHorizontalHeaderLabels(['Identification'])
# Find treeview widget from dialog
view = self.twResult
view.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
view.clicked.connect(self.on_viewClicked)
# Set model and looks for treeview
view.setModel(model)
view.setUniformRowHeights(True)
view.setAlternatingRowColors(True)
view.header().setStretchLastSection(True)
view.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
# Fetch profile data from database
profilemodel = QSqlQueryModel()
profilemodel.setQuery(
'select * from "' + self.parent.config['db_schema'] +
'"."profiles_layers_view" where pid = ' + str(pid),
self.parent.dbmeta)
# Create root item
profile = QtGui.QStandardItem(
tr(u'{} ({} layers)').format(profilename,
profilemodel.rowCount()))
# Get profile link (if it can be retrieved (no of layers > 0)
if profilemodel.rowCount() > 0:
profile.setData(
u'p|' +
self.xuni(profilemodel.record(0).value('profile_link')) +
u'|||')
else:
profile.setData(u'p||||')
# Create root item
model.appendRow(profile)
# rowcounter layers with non-zero conflicts
nextRow = 0
# Iterate through layers in selected profile.....
for i in range(profilemodel.rowCount()):
# Fetch record nr. i
r = profilemodel.record(i)
# Rowcount default (-1 --> db not open)
rc = -1
# Open or reconnect database for layer
dbl = self.parent.connectDatabase('c' + str(r.value('cid')),
r.value('servertypename'),
r.value('host'),
r.value('port'),
r.value('username'),
r.value('password'),
r.value('database'),
r.value('serverconnection'))
if not dbl is None:
# Create wkt string for layer query
# (it has to be converted for each layer - they might have different projections)
wkt = self.parent.cnvobj2wkt(geom, epsg, r.value('epsg'))
# Fetch layerdata from database
layermodel = QSqlQueryModel()
# Generate SQL statement
sel1 = r.value('sql_detail').format(
r.value('profilename'), r.value('layername'),
r.value('compoundid'), r.value('linkid'),
r.value('geomid'), r.value('schemaname'),
r.value('tablename'))
sel2 = r.value('sql_filter').format(
wkt, r.value('epsg'), buffervalue, r.value('geomid'))
sel = sel1 + u' where ' + sel2
# Execute SQL and create layermodel content
layermodel.setQuery(sel, dbl)
rc = layermodel.rowCount()
# Create stub QStandardItem for layer
lName = QtGui.QStandardItem(
tr(u'{} ({} overlaps)').format(r.value('layername'),
rc))
lName.setData(u'l|' + self.xuni(r.value('layerlink')) +
u'|' + self.xuni(r.value('qlr_file')) +
u'||')
for j in range(rc):
# Fetch record nr. j
q = layermodel.record(j)
# Append data to lName item
li = QtGui.QStandardItem(q.value('layerid'))
li.setData(u'i|' + self.xuni(q.value('link')) + '|' +
self.xuni(r.value('qlr_file')) + '|' +
self.xuni(q.value('wkt_geom')) + '|' +
self.xuni(r.value('epsg')))
lName.appendRow(li)
#Append layerinfo to profile item
if rc > 0:
lName.setBackground(QtGui.QColor(255, 230, 230))
lName.sortChildren(0)
profile.insertRow(nextRow, lName)
nextRow = nextRow + 1
elif rc == 0:
profile.appendRow(lName)
else:
pass # db not found
view.expandToDepth(0)
def __init__(self, parent=None):
super(Users, self).__init__(parent)
self.model = QSqlQueryModel()
self.sortProxyModels = {}
self.init_model()
self.init_proxy_models()
def check_start_end(self, tol):
# set the feature counter to 0
count = 0
# initialises two virtual objects points (start and end point)
start_point = self.start_point
end_point = self.end_point
# uses the qgis python api to access the ESU Graphic Layer
esu_layer = self.esu_layer
# runs the query number 8 to retrieve all streets from the Database
streets_model = QSqlQueryModel()
streets_model.setQuery(self.queries[8])
while streets_model.canFetchMore():
streets_model.fetchMore()
n_columns = streets_model.columnCount()
n_rows = streets_model.rowCount()
i = 0
j = 0
# first loop start (for each street):
start_end_content = []
while i <= n_rows - 1:
self.progress_win.setLabelText("Checking start-end Coordinates...")
# initialises the state of the checks booleans both to false
start_ok = False
end_ok = False
col_info = []
while j <= n_columns - 1:
model_index = streets_model.createIndex(i, j)
if j == 0:
data = model_index.data()
col_info.append(data)
if j == 1:
data = model_index.data()
col_info.append(data)
if j == 2:
data = model_index.data()
col_info.append(data)
if j >= 3:
data = model_index.data()
col_info.append(data)
j += 1
usrn = col_info[0]
ref_type = col_info[2]
desc = col_info[1]
start_point.set(float(col_info[3]), float(col_info[4]))
end_point.set(float(col_info[5]), float(col_info[6]))
# filter the layer "ESU Graphic" for the ESUs Ids returned from the list
# deal just with the arcs part of multi arcs street
esus_list = self.get_linked_esu_list(usrn)
feat_filter = self.build_layer_filter(esus_list)
feat_request = QgsFeatureRequest()
feat_request.setFilterExpression(feat_filter)
# second loop starts (for each arc (ESU) composing the street)
# iterate through all filtered features and their proximity with the start and end of the street
features = self.esu_layer.getFeatures(feat_request)
features.rewind()
# iterates through features
for feat in features:
# check start end points for each of the only if none of the start end points of
# a ESU on each street is not already matched
if (start_ok is not True) or (end_ok is not True):
result = self.start_end_proximity(start_point, end_point,
feat, tol)
# both dist are ok
if result == 3:
start_ok = True
end_ok = True
# just end dist is ok
elif result == 2:
end_ok = True
# just start dist is ok
elif result == 1:
start_ok = True
else:
break
# in case of problems
if not start_ok or not end_ok:
count += 1
start_end_item = [str(col_info[0]) + ","]
# handles the creation of the report on a text file
if not start_ok and not end_ok:
start_end_item.append("(both),")
if not start_ok and end_ok:
start_end_item.append("(start),")
if start_ok and not end_ok:
start_end_item.append("(end),")
start_end_item.append(str(ref_type) + ",")
start_end_item.append(str(desc) + "\n")
start_end_content.append(start_end_item)
j = 0
i += 1
if count == 0:
self.progress_win.setValue(7)
return
else:
start_end_content.insert(0, self.column_names[5])
self.progress_win.setValue(7)
return self.content_to_screen(content_list=start_end_content,
query_model=None,
columns_name_id=None,
no_content_id=8)
