class FormManager(QObject):
# Signals:
submitted = pyqtSignal(bool, str, object)
# Slots:
def _block_change(self, selected, deselected, clearAndSelect):
close_form_required_lyr_msg()
cur_lyr = iface.mapCanvas().currentLayer()
cur_lyr.selectionChanged.disconnect(self._block_change)
cur_lyr.setSelectedFeatures([self.cur_feat.id()])
cur_lyr.selectionChanged.connect(self._block_change)
def _on_record_submitted(self, upd, table_name, obj):
if table_name == 'sigmaf':
self.rel_sf.upd_item(obj) if upd else self.rel_sf.add_item(obj)
elif table_name == 'composyntaxon':
self.rel_syn.upd_item(obj) if upd else self.rel_syn.add_item(obj)
def _get_syntax(self, idx):
if not idx == -1:
for item in self.sf_form.relation.get_items():
self.del_record('composyntaxon', item)
self.sf_form.relation.init_table()
code = self.sf_form.ui.findChild(QComboBox, 'code_sigma').itemData(idx)
if code:
syntax_list = CatalogReader('sigmaf').get_syntaxons_from_sf(code)
for syntax in syntax_list:
uvc = iface.mapCanvas().currentLayer().selectedFeatures()[0]['uvc']
syntax['uvc'] = uvc
cur_sf = self.sf_form.feat_id
if cur_sf:
syntax['sigmaf'] = cur_sf
else:
s = QSettings()
syntax['sigmaf'] = s.value('current_info/sigmaf')
self.submit('composyntaxon', syntax, None)
# Constructor:
def __init__(self):
QObject.__init__(self)
self.cur_feat = None
self.uvc_form = None
self.sf_form = None
self.syntax_form = None
self.rel_sf = None
self.rel_syn = None
# Private methods:
def _get_selected_feature(self):
cur_lyr = iface.mapCanvas().currentLayer()
if not cur_lyr:
return 0
features = cur_lyr.selectedFeatures()
feat = features[0] if len(features) == 1 else 1
return feat
def _check_state(self):
if self.uvc_form and self.uvc_form.ui.isVisible():
return False
cur_carhab_lyr = CarhabLayerRegistry.instance().getCurrentCarhabLayer()
if not cur_carhab_lyr:
no_carhab_lyr_msg()
return False
if self._get_selected_feature() == 0:
no_vector_lyr_msg()
return False
if self._get_selected_feature() == 1:
one_only_selected_feat_msg()
return False
return True
def _exit_fill_form(self):
cur_lyr = iface.mapCanvas().currentLayer()
try:
cur_lyr.selectionChanged.disconnect(self._block_change)
except:
pass
try:
self.submitted.disconnect(self._on_record_submitted)
except:
pass
def _open_form(self, tbl_name, form):
if form.relation:
r = self.get_recorder(form.relation.child_table)
child_items = r.select(tbl_name, form.feat_id)
form.relation.fill_table(child_items)
db_obj = self.get_record(tbl_name, form.feat_id)
form.fill_form(db_obj)
form.open()
# Public methods:
def run(self):
try:
self.submitted.disconnect(self._on_record_submitted)
except:
pass
if self._check_state():
self.db = self.get_db()
self.create_savepoint()
self.submitted.connect(self._on_record_submitted)
cur_lyr = iface.mapCanvas().currentLayer()
cur_lyr.selectionChanged.connect(self._block_change)
self.cur_feat = self._get_selected_feature()
uvc_id = self.cur_feat['uvc']
disp_fields = [
'code_serie',
'lb_serie',
'typ_facies',
'pct_recouv'
]
self.rel_sf = RelationsManager('sigmaf', disp_fields)
self.rel_sf.add_clicked.connect(self.open_sf)
self.rel_sf.edit_clicked.connect(self.open_sf)
self.rel_sf.del_clicked.connect(self.del_record)
pos = Qt.RightDockWidgetArea
self.uvc_form = Form('form_uvc', uvc_id, self.rel_sf, pos)
cur_geom_typ = self.cur_feat.geometry().type()
surface_field = self.uvc_form.ui.findChild(QWidget, 'surface')
larg_lin_field = self.uvc_form.ui.findChild(QWidget, 'larg_lin')
larg_lin_field.setEnabled(cur_geom_typ == 1)
surface_field.setReadOnly(not cur_geom_typ == 0)
self.uvc_form.valid_clicked.connect(self.submit_uvc)
self.uvc_form.canceled.connect(self.cancel_uvc_fill)
self.uvc_form.closed.connect(self._exit_fill_form)
self._open_form('uvc', self.uvc_form)
def open_sf(self, table_name, id=None):
self.create_savepoint('sigmaf')
s = QSettings()
s.setValue('current_info/sigmaf', id)
disp_fields = [
'cd_syntax',
'lb_syntax',
'abon_domin'
]
self.rel_syn = RelationsManager('composyntaxon', disp_fields)
self.rel_syn.add_clicked.connect(self.open_syntaxon)
self.rel_syn.edit_clicked.connect(self.open_syntaxon)
self.rel_syn.del_clicked.connect(self.del_record)
from_cat = False
r = self.get_recorder('sigmaf')
if id:
from_cat = r.select('id', id)[0].get('catalog')
else:
last_sf_id = r.get_last_id() if r.get_last_id() else 0
s.setValue('current_info/sigmaf', last_sf_id + 1)
from_cat = question('Appel aux catalogues ?,',\
'Sélectionner un sigma facies issu des catalogues ?')
s.setValue('current_info/sigmaf/catalog', int(from_cat))
if not s.value('catalogs'):
popup('Les référentiels ne sont pas renseignés')
Catalog().run()
return
form_name = 'form_sigmaf_cat' if from_cat else 'form_sigmaf'
self.sf_form = Form(form_name, id, self.rel_syn)
self.sf_form.canceled.connect(self.cancel_sf_fill)
self.sf_form.valid_clicked.connect(self.submit_sf)
self._open_form('sigmaf', self.sf_form)
cd_sf_field = self.sf_form.ui.findChild(QComboBox, 'code_sigma')
if cd_sf_field:
cd_sf_field.currentIndexChanged.connect(self._get_syntax)
def open_syntaxon(self, table_name, id=None):
self.syntax_form = Form('form_syntaxon', id)
self.syntax_form.canceled.connect(self.cancel_syntaxon_fill)
self.syntax_form.valid_clicked.connect(self.submit_syntax)
self._open_form('composyntaxon', self.syntax_form)
def submit_sf(self, table_name, form_obj, id):
self.submit(table_name, form_obj, id)
self.sf_form.close()
def submit_syntax(self, table_name, form_obj, id):
self.submit(table_name, form_obj, id)
self.syntax_form.close()
def cancel_uvc_fill(self):
if self.uvc_form.upd_flag:
if not warning_input_lost_msg():
return
self.rollback()
self.close_db()
self.uvc_form.close()
def cancel_sf_fill(self):
self.rollback('sigmaf')
self.sf_form.close()
def cancel_syntaxon_fill(self):
self.syntax_form.close()
# Db methods :
def get_db(self):
cur_carhab_lyr = CarhabLayerRegistry.instance().getCurrentCarhabLayer()
db = DbManager(cur_carhab_lyr.dbPath)
return db
def close_db(self):
self.db.close()
def create_savepoint(self, savepoint=None):
req = 'SAVEPOINT ' + savepoint if savepoint else 'BEGIN'
self.db.execute(req)
def rollback(self, savepoint=None):
req = 'ROLLBACK TO SAVEPOINT ' + savepoint if savepoint else 'ROLLBACK'
self.db.execute(req)
def get_recorder(self, tbl):
db = self.db
r = Recorder(db, tbl)
return r
def get_record(self, tbl, id):
r = self.get_recorder(tbl)
db_obj = {}
for row in r.select('id', id):
db_obj = row
return db_obj
def del_record(self, table_name, id):
db = self.db
r = Recorder(db, table_name)
r.delete_row(id)
def submit(self, table_name, form_obj, id):
db = self.db
r = Recorder(db, table_name)
updated = True
if id:
result_msg = r.update(id, form_obj)
form_obj['id'] = id
else:
result_msg = r.input(form_obj)
updated = False
form_obj['id'] = r.get_last_id()
self.submitted.emit(updated, table_name, form_obj)
return result_msg
def submit_uvc(self, table_name, form_obj, id):
result_msg = self.submit(table_name, form_obj, id)
if not result_msg == 1:
popup(str(result_msg))
return
self.db.commit()
iface.mapCanvas().currentLayer().triggerRepaint()
self.close_db()
self.uvc_form.close()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.sports = []
self.ui.add_btn.clicked.connect(self._newForm)
self.ui.item1 = QtWidgets.QListWidgetItem("Events")
self.ui.main_list.addItem(self.ui.item1)
self.ui.item2 = QtWidgets.QListWidgetItem("Results")
self.ui.main_list.addItem(self.ui.item2)
self.ui.main_list.itemClicked.connect(self._mainClicked)
self.manager = QtNetwork.QNetworkAccessManager()
self.sport_req = QtNetwork.QNetworkRequest(QtCore.QUrl("API URL"))
self.sport_reply = self.manager.get(self.sport_req)
self.sport_reply.finished.connect(self._sportsReply)
self.ui.sport_combo.activated.connect(self._mainReq)
self.ui.subClass_list.itemClicked.connect(self._loadForm)
self.sport_dic = {}
self.loaded = []
self.resizeTimer = QtCore.QTimer()
self.resizeTimer.setSingleShot(True)
self.resizeTimer.timeout.connect(self.tryResize)
def _mainReq(self):
self.ui.subClass_list.clear()
self.ui.add_btn.setEnabled(True)
self.selected_sport = self.sport_dic.get(
self.ui.sport_combo.currentText())
selected = self.ui.main_list.currentItem()
if selected.text() == "Events":
dic = {"offset": 0, "limit": 100, "sport_id": self.selected_sport}
vari_req = QtCore.QJsonDocument.fromVariant(dic)
json_req = QtCore.QJsonDocument.toJson(vari_req)
req = QtNetwork.QNetworkRequest(QtCore.QUrl("API URL"))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/json")
self.event_reply = self.manager.post(req, json_req)
self.event_reply.finished.connect(self._eventsReply)
if selected.text() == "Results":
pass
def _loadForm(self, item):
i = self.ui.subClass_list.currentRow()
self.form = Form()
self.ui.formWidgetLayout.addWidget(self.form)
self.form.formClosed.connect(self._closeForm)
title = self.events["message"][i]["title"]
self.loaded.append(title)
self.form.form.title_edit_3.setText(title)
dateTime = str(self.events["message"][i]["event_time"])[0:19]
date = QtCore.QDateTime.fromString(dateTime, "yyyy-MM-ddTHH:mm:ss")
self.form.form.dateTime_edit_3.setDateTime(date)
self.loaded.append(dateTime) ####fix this after Ali comes!
description = self.events["message"][i]["description"]
self.form.form.description_edit_5.append(description)
self.loaded.append(description)
self.event_id = self.events["message"][i]["id"]
league = self.events["message"][i]["league"]["name"]
self.form.form.lig_combo_5.addItem(league)
self.loaded.append(league)
self.leaguesReq(self.selected_sport)
location = self.events["message"][i]["location"][
"address"] + " " + self.events["message"][i]["location"][
"name"] + " " + self.events["message"][i]["location"]["city"]
self.form.form.location_combo_3.addItem(location)
self.loaded.append(location)
teams = []
for j in range(len(self.events["message"][i]["teams"])):
self.form.team.addTeam(
self.events["message"][i]["teams"][j]["name"])
teams.append(self.events["message"][i]["teams"][j]["name"])
self.loaded.append(teams)
def _eventsReply(self):
reply_file = self.event_reply.readAll()
json_file = QtCore.QJsonDocument.fromJson(reply_file)
self.events = json_file.toVariant()
# print(self.events)
for i in range(len(self.events["message"])):
self.ui.subClass_list.addItem(
str(self.events["message"][i]["title"]))
def leaguesReq(self, sport_id):
dic = {"sports": [{"id": sport_id}]}
vari_req = QtCore.QJsonDocument.fromVariant(dic)
json_req = QtCore.QJsonDocument.toJson(vari_req)
req = QtNetwork.QNetworkRequest(QtCore.QUrl("API URL"))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/json")
self.league_reply = self.manager.post(req, json_req)
self.league_reply.finished.connect(self._leaguesReply)
def _leaguesReply(self):
reply_file = self.league_reply.readAll()
json_file = QtCore.QJsonDocument.fromJson(reply_file)
v = json_file.toVariant()
for i in range(len(v["message"])):
self.form.form.lig_combo_5.addItem(v["message"][i]["name"])
def _sportsReply(self):
reply_file = self.sport_reply.readAll()
json_file = QtCore.QJsonDocument.fromJson(reply_file)
v = json_file.toVariant(
) #changing variant of c++ to normal python variable that can be anything
for i in range(len(v["message"])):
self.sport_dic.update(
{v["message"][i]["name"]: v["message"][i]["id"]})
self.ui.sport_combo.addItem(v["message"][i]["name"])
def _mainClicked(self):
try:
self.form.cancel()
except AttributeError:
self.ui.sport_combo.setEnabled(True)
def _newForm(self):
self.ui.add_btn.setDisabled(True)
self.ui.sport_combo.setDisabled(True)
self.leaguesReq(self.selected_sport)
self.form = Form()
self.ui.formWidgetLayout.addWidget(self.form)
self.form.formClosed.connect(self._closeForm)
self.repaint()
def _closeForm(self, btn):
if btn == "save":
pass
# self.ui.sizePolicy.setHorizontalStretch(0)
# self.restoreState(self.state)
elif btn == "close":
pass
self.form.close()
del (self.form)
self.ui.add_btn.setEnabled(True)
self.ui.sport_combo.setEnabled(True)
self.resizeTimer.start(200)
self.updateGeometry()
self.repaint()
def tryResize(self):
self.resize(400, 400)
