def setup_model(self):
db = Db_Instance("edit_associate").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, unicode("Seareiros - Edição de Associado".decode('utf-8')), message)
else:
self._model = QSqlRelationalTableModel(self, db=db)
self._model.setTable("associate")
self._act_model = QSqlRelationalTableModel(self, db=db)
self._act_model.setTable("associate_in_activity")
# TODO: Maybe I should validate these
# associate
self._model.setFilter("id = " + str(self._record_id))
self._model.select()
self._record = self._model.record(0)
# activities
self._activity_records = []
sql_statement = """SELECT id, description, room, weekday, weektime FROM activity a,
associate_in_activity a_a WHERE
a.id = a_a.id_activity AND a_a.id_associate = %s
""" % str(self._record_id)
model_activities = QSqlQueryModel()
model_activities.setQuery(sql_statement, db)
# checking query validity
if not model_activities.lastError().isValid():
self._activity_records = iterate_model(model_activities)
def check_barcode(self, txt):
if len(txt) == self.edBarcode.maxLength():
db = Db_Instance("obook_barcode_search").get_instance()
try:
if db.open():
query = QSqlQuery(db)
query.prepare("SELECT * FROM book WHERE barcode = :barcode")
query.bindValue(":barcode", txt)
query.exec_()
if query.next():
self.add_book_from_record(query.record())
self.edBarcode.clear()
else:
raise RecordNotFoundException
else:
raise DbUnavailableException
except RecordNotFoundException:
message = unicode("Código de barra inválido!\n\n"""
"O código informado não corresponde a nenhum livro cadastrado".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Livraria", message)
except DbUnavailableException:
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Livraria", message)
self.edBarcode.setFocus()
def setup_model(self):
db = Db_Instance("form_book").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n" "Banco de dados indisponível".decode("utf-8"))
QMessageBox.critical(self, "Seareiros - Cadastro de Livro", message)
else:
# book
self._model = QSqlTableModel(self, db=db)
self._model.setTable("book")
# subject
self._subject_model = QSqlTableModel(self, db=db)
self._subject_model.setTable("subject")
self._subject_model.select()
# author
self._author_model = QSqlTableModel(self, db=db)
self._author_model.setTable("author")
self._author_model.select()
# sauthor
self._s_author_model = QSqlTableModel(self, db=db)
self._s_author_model.setTable("s_author")
self._s_author_model.select()
# publisher
self._publisher_model = QSqlTableModel(self, db=db)
self._publisher_model.setTable("publisher")
self._publisher_model.select()
# book subjects
self._book_in_subj_model = QSqlTableModel(self, db=db)
self._book_in_subj_model.setTable("book_in_subject")
def setup_model(self):
db = Db_Instance("form_associate").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Cadastro de Associado", message)
else:
self._model = QSqlRelationalTableModel(self, db=db)
self._model.setTable("associate")
self._act_model = QSqlRelationalTableModel(self, db=db)
self._act_model.setTable("associate_in_activity")
def setup_model(self):
db = Db_Instance("oform_book").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Livraria", message)
else:
# book order
self._model = QSqlTableModel(self, db=db)
self._model.setTable("order_request")
# book order items
self._items_model = QSqlTableModel(self, db=db)
self._items_model.setTable("book_order_item")
def _get_name_from_id(self, table, id):
db = Db_Instance(table + "_fetch_" + str(id) + "_name").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT name FROM %s WHERE id = :id" % table)
query.bindValue(":name", id)
query.exec_()
if query.next():
return query.record().value("name")
else:
return None
def _get_id_from_name(self, table, name):
db = Db_Instance(table + "_fetch_" + name + "_id").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT id FROM %s WHERE name = :name" % table)
query.bindValue(":name", name)
query.exec_()
if query.next():
return query.record().value("id")
else:
return None
def get_added_record(self):
db = Db_Instance("added_book_record").get_instance()
if db.open() and self._book_id:
query = QSqlQuery(db)
query.prepare("SELECT * FROM book WHERE id = :id")
query.bindValue(":id", self._book_id)
query.exec_()
if query.next():
return query.record()
else:
return None
else:
return None
def setup_model(self):
db = Db_Instance("oform_product").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n" "Banco de dados indisponível".decode("utf-8"))
QMessageBox.critical(self, "Seareiros - Vendas do Bazar", message)
else:
# product order
self._model = QSqlTableModel(self, db=db)
self._model.setTable("order_request")
# product order items
self._items_model = QSqlTableModel(self, db=db)
self._items_model.setTable("product_order_item")
def get_added_record(self):
""" My workaround to get the last inserted id without any postgres specific queries """
db = Db_Instance("add_associate_last_id").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT * FROM associate WHERE fullname = :fullname")
query.bindValue(":fullname", self.edFullName.text())
query.exec_()
if query.next():
return query.record()
else:
return None
def setup_model(self):
db = Db_Instance("edit_book").get_instance()
if not db.open():
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, unicode("Seareiros - Edição de Livro".decode('utf-8')), message)
else:
# book
self._model = QSqlRelationalTableModel(self, db=db)
self._model.setTable("book")
self._model.setFilter("id = " + str(self._record_id))
# self._model.setRelation(self.column["author"], QSqlRelation("author", "id", "name"))
# self._model.setRelation(self.column["s_author"], QSqlRelation("s_author", "id", "name"))
# self._model.setRelation(self.column["publisher"], QSqlRelation("publisher", "id", "name"))
self._model.select()
self._record = self._model.record(0)
# models for setting up qcompleters:
# book_in_subject
self._book_in_subj_model = QSqlTableModel(self, db=db)
self._book_in_subj_model.setTable("book_in_subject")
# subject
self._subject_model = QSqlTableModel(self, db=db)
self._subject_model.setTable("subject")
self._subject_model.select()
# author
self._author_model = QSqlTableModel(self, db=db)
self._author_model.setTable("author")
self._author_model.select()
# s_author
self._s_author_model = QSqlTableModel(self, db=db)
self._s_author_model.setTable("s_author")
self._s_author_model.select()
# publisher
self._publisher_model = QSqlTableModel(self, db=db)
self._publisher_model.setTable("publisher")
self._publisher_model.select()
# retrieving current subjects, should probably place this elsewhere but it's related to models
self._subject_records = []
sql_statement = """SELECT id, name FROM subject s, book_in_subject b_s
WHERE s.id = b_s.subject_id AND b_s.book_id = %s
""" % str(self._record_id)
read_only_subject_model = QSqlQueryModel()
read_only_subject_model.setQuery(sql_statement, db)
# checking query validity
if not read_only_subject_model.lastError().isValid():
self._subj_records = iterate_model(read_only_subject_model)