def init_gui(self):
"""
Initializes form widgets
"""
min_date = QDate.currentDate()
today = QDate.currentDate()
self.edtMinDate.setDate(min_date)
self.edtMaxDate.setDate(today)
self.edtMinDate.setDate(self._min_val)
self.edtMaxDate.setDate(self._max_val)
self.edtMinDate.setFocus()
self.rbMinFixed.setChecked(True)
self.rbMaxFixed.setChecked(True)
self.rbMinFixed.toggled.connect(self.min_fixed_toggle_handler)
self.rbMaxFixed.toggled.connect(self.max_fixed_toggle_handler)
self.rbMinCurr.toggled.connect(self.min_curr_toggle_handler)
self.rbMaxCurr.toggled.connect(self.max_curr_toggle_handler)
self.rbMinCurr.setChecked(self.min_use_current_date)
self.rbMaxCurr.setChecked(self.max_use_current_date)
# disable controls if column already exist in database
self.edtMinDate.setEnabled(not self.in_db)
self.edtMaxDate.setEnabled(not self.in_db)
self.rbMinFixed.setEnabled(not self.in_db)
self.rbMinCurr.setEnabled(not self.in_db)
self.rbMaxFixed.setEnabled(not self.in_db)
self.rbMaxCurr.setEnabled(not self.in_db)
def month_selector(self):
month_selector = MonthSelector()
self.load_settings(month_selector)
month_selector.all_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
month_selector.selected_rows.setSelectionBehavior(QAbstractItemView.SelectRows)
month_selector.setWindowTitle("Planificador mensual")
# Set label with selected text from previus dialog
month_selector.lbl_plan_code.setText(self.plan_code)
month_selector.lbl_year.setText(self.planned_camp_name)
sql = (f"SELECT start_date, end_date FROM cat_campaign "
f" WHERE id ='{self.planned_camp_id}'")
row = self.controller.get_row(sql)
if row is not None:
start_date = QDate.fromString(str(row[0]), 'yyyy-MM-dd')
end_date = QDate.fromString(str(row[1]), 'yyyy-MM-dd')
else:
start_date = QDate.currentDate()
end_date = QDate.currentDate().addYears(1)
utils_giswater.setCalendarDate(month_selector, month_selector.date_inici, start_date)
utils_giswater.setCalendarDate(month_selector, month_selector.date_fi, end_date)
view_name = 'v_plan_mu_year'
tableleft = 'planning'
id_table_left = 'mu_id'
# Left QTableView
expr = " AND ( plan_code is NULL OR plan_code = '')"
self.fill_table_planned_month(month_selector.all_rows, month_selector.txt_search, view_name, expr)
month_selector.txt_search.textChanged.connect(
partial(self.fill_table_planned_month, month_selector.all_rows, month_selector.txt_search, view_name, expr, QTableView.NoEditTriggers))
month_selector.btn_select.clicked.connect(
partial(self.month_selector_row, month_selector, id_table_left, tableleft, view_name))
self.set_table_columns(month_selector, month_selector.all_rows, view_name, 'basic_month_left')
# Right QTableView
expr = " AND plan_code = '" + self.plan_code + "'"
self.fill_table_planned_month(month_selector.selected_rows, month_selector.txt_selected_filter, view_name, expr)
month_selector.txt_selected_filter.textChanged.connect(
partial(self.fill_table_planned_month, month_selector.selected_rows, month_selector.txt_selected_filter, view_name, expr, QTableView.NoEditTriggers))
month_selector.btn_unselect.clicked.connect(
partial(self.month_unselector_row, month_selector, id_table_left, tableleft, view_name))
self.set_table_columns(month_selector, month_selector.selected_rows, view_name, 'basic_month_right')
self.calculate_total_price(month_selector, self.planned_camp_id)
month_selector.btn_close.clicked.connect(partial(self.close_dialog, month_selector))
month_selector.rejected.connect(partial(self.close_dialog, month_selector))
month_selector.exec_()
def fill_fields(self):
""" Fill dates and combos cat_work/state type end """
sql = 'SELECT id as id, name as idval FROM value_state_type WHERE id IS NOT NULL AND state = 0'
rows = self.controller.get_rows(sql)
qt_tools.set_item_data(self.dlg_work_end.cmb_statetype_end, rows, 1)
row = self.controller.get_config('statetype_end_vdefault')
if row:
qt_tools.set_combo_itemData(self.dlg_work_end.cmb_statetype_end,
row[0], 0)
row = self.controller.get_config('edit_enddate_vdefault')
if row:
enddate = self.manage_dates(row[0]).date()
self.dlg_work_end.enddate.setDate(enddate)
else:
enddate = QDate.currentDate()
qt_tools.setCalendarDate(self.dlg_work_end, "enddate", enddate)
sql = "SELECT id FROM cat_work"
rows = self.controller.get_rows(sql)
qt_tools.fillComboBox(self.dlg_work_end,
self.dlg_work_end.workcat_id_end,
rows,
allow_nulls=False)
qt_tools.set_autocompleter(self.dlg_work_end.workcat_id_end)
row = self.controller.get_config('edit_workcat_end_vdefault')
if row:
qt_tools.setWidgetText(self.dlg_work_end,
self.dlg_work_end.workcat_id_end, row[0])
def add_assessment(self):
"""Initiates adding a new assessment"""
self.assessment_dialog = AssessmentDlg(self.qris_project)
self.assessment_dialog.dateEdit_assessment_date.setDate(
QDate.currentDate())
self.assessment_dialog.dataChange.connect(self.build_tree_view)
self.assessment_dialog.show()
def get_default_dates(self):
""" Load the dates from the DB for the current_user and set vars (self.from_date, self.to_date) """
sql = (f"SELECT from_date, to_date FROM selector_date"
f" WHERE cur_user = '******'")
row = self.controller.get_row(sql)
try:
if row:
self.from_date = QDate(row[0])
self.to_date = QDate(row[1])
else:
self.from_date = QDate.currentDate()
self.to_date = QDate.currentDate().addDays(1)
except:
self.from_date = QDate.currentDate()
self.to_date = QDate.currentDate().addDays(1)
def _fill_fields(self):
""" Fill dates and combos cat_work/state type end """
sql = 'SELECT id as id, name as idval FROM value_state_type WHERE id IS NOT NULL AND state = 0'
rows = tools_db.get_rows(sql)
tools_qt.fill_combo_values(self.dlg_work_end.cmb_statetype_end, rows,
1)
row = tools_gw.get_config_value('edit_statetype_0_vdefault')
if row:
tools_qt.set_combo_value(self.dlg_work_end.cmb_statetype_end,
row[0], 0)
row = tools_gw.get_config_value('edit_enddate_vdefault')
if row:
enddate = self._manage_dates(row[0]).date()
self.dlg_work_end.enddate.setDate(enddate)
else:
enddate = QDate.currentDate()
tools_qt.set_calendar(self.dlg_work_end, "enddate", enddate)
sql = "SELECT id FROM cat_work"
rows = tools_db.get_rows(sql)
tools_qt.fill_combo_box(self.dlg_work_end,
self.dlg_work_end.workcat_id_end, rows, True)
tools_qt.set_autocompleter(self.dlg_work_end.workcat_id_end)
row = tools_gw.get_config_value('edit_workcat_vdefault')
if row:
tools_qt.set_widget_text(self.dlg_work_end,
self.dlg_work_end.workcat_id_end, row[0])
def fill_widget_with_fields(self, dialog, data_object, field_names):
"""Fill the Widget with value get from data_object limited to
the list of field_names."""
for field_name in field_names:
value = getattr(data_object, field_name)
if not hasattr(dialog, field_name):
continue
widget = getattr(dialog, field_name)
if type(widget) == QDateEdit:
widget.setDate(value if value else QDate.currentDate())
elif type(widget) == QDateTimeEdit:
widget.setDateTime(value if value else QDateTime.currentDateTime())
if type(widget) in [QLineEdit, QTextEdit]:
if value:
widget.setText(value)
else:
widget.clear()
if type(widget) in [QComboBox]:
if not value:
widget.setCurrentIndex(0)
continue
# look the value in item text
index = widget.findText(str(value))
if index >= 0:
widget.setCurrentIndex(index)
continue
# look the value in itemData
index = widget.findData(value)
if index >= 0:
widget.setCurrentIndex(index)
continue
def createWidget(self):
now = QTime.currentTime()
curdate = QDateTime(QDate.currentDate(), QTime(now.hour(), 0))
dateEdit = QDateTimeEdit(curdate.toUTC())
dateEdit.setDisplayFormat("yyyy-MM-dd HH:mm")
dateEdit.setTimeSpec(Qt.TimeZone)
return dateEdit
def basic_new_prices(self, dialog=None):
""" Button 303: Price generator """
# Close previous dialog
if dialog is not None:
self.close_dialog(dialog)
self.dlg_new_campaign = NewPrices()
self.load_settings(self.dlg_new_campaign)
# Set default dates
current_year = QDate.currentDate().year()
start_date = QDate.fromString(str(int(current_year)) + '/11/01', 'yyyy/MM/dd')
self.dlg_new_campaign.start_date.setDate(start_date)
end_date = QDate.fromString(str(int(current_year)+1) + '/10/31', 'yyyy/MM/dd')
self.dlg_new_campaign.end_date.setDate(end_date)
table_name = 'cat_campaign'
field_id = 'id'
field_name = 'name'
self.dlg_new_campaign.rejected.connect(partial(self.close_dialog, self.dlg_new_campaign))
self.dlg_new_campaign.btn_cancel.clicked.connect(partial(self.close_dialog, self.dlg_new_campaign))
self.dlg_new_campaign.btn_accept.clicked.connect(partial(self.manage_new_price_catalog))
self.populate_cmb_years(table_name, field_id, field_name, self.dlg_new_campaign.cbx_years)
self.set_completer_object(table_name, self.dlg_new_campaign.txt_campaign, field_name)
if self.rows_cmb_poda_type is None:
self.update_cmb_poda_type()
if self.rows_cmb_builder is None:
self.update_cmb_builder()
self.open_dialog(self.dlg_new_campaign)
def set_calendar(dialog, widget, date, default_current_date=True):
if type(widget) is str or type(widget) is str:
widget = dialog.findChild(QWidget, widget)
if not widget:
return
if global_vars.date_format in ("dd/MM/yyyy", "dd-MM-yyyy", "yyyy/MM/dd",
"yyyy-MM-dd"):
widget.setDisplayFormat(global_vars.date_format)
if type(widget) is QDateEdit \
or (type(widget) is QgsDateTimeEdit and widget.displayFormat() in
('dd/MM/yyyy', 'yyyy/MM/dd', 'dd-MM-yyyy', 'yyyy-MM-dd')):
if date is None:
if default_current_date:
date = QDate.currentDate()
else:
date = QDate.fromString('01-01-2000', 'dd-MM-yyyy')
widget.setDate(date)
elif type(widget) is QDateTimeEdit \
or (type(widget) is QgsDateTimeEdit and widget.displayFormat() in
('dd/MM/yyyy hh:mm:ss', 'yyyy/MM/dd hh:mm:ss', 'dd-MM-yyyy hh:mm:ss', 'yyyy-MM-dd hh:mm:ss')):
if date is None:
date = QDateTime.currentDateTime()
widget.setDateTime(date)
def __init__(self,
icon_path,
action_name,
text,
toolbar,
action_group,
icon_type=1):
super().__init__(icon_path, action_name, text, toolbar, action_group,
icon_type)
self.current_date = QDate.currentDate().toString('yyyy-MM-dd')
self.project_type = global_vars.project_type
self.feature_type = None
self.geom_view = None
self.cat_table = None
self.feature_edit_type = None
self.feature_type_cat = None
self.feature_id = None
self.list_tables = [
'v_edit_arc', 'v_edit_node', 'v_edit_connec', 'v_edit_gully'
]
# Create a menu and add all the actions
if toolbar is not None:
toolbar.removeAction(self.action)
self.menu = QMenu()
self.menu.setObjectName("GW_replace_menu")
self._fill_action_menu()
if toolbar is not None:
self.action.setMenu(self.menu)
toolbar.addAction(self.action)
def createWidget(self):
self._combo = QDateEdit()
self._combo.setCalendarPopup(True)
today = QDate.currentDate()
self._combo.setDate(today)
return self._combo
def test_value_date(self):
test_property = DateProperty('test name', QDate.currentDate(),
'gco:Date')
test_property.value = QDate.fromString('2015-06-07')
with self.assertRaises(TypeError):
test_property.value = 20150607
def _get_default_dates(self):
""" Load the dates from the DB for the current_user and set vars (self.from_date, self.to_date) """
# Set project user
self.current_user = global_vars.current_user
sql = (f"SELECT from_date, to_date FROM selector_date"
f" WHERE cur_user = '******'")
row = tools_db.get_row(sql)
try:
if row:
self.from_date = QDate(row[0])
self.to_date = QDate(row[1])
else:
self.from_date = QDate.currentDate()
self.to_date = QDate.currentDate().addDays(1)
except Exception:
self.from_date = QDate.currentDate()
self.to_date = QDate.currentDate().addDays(1)
def evaluation_test(self, layout, label):
# $CURRENT_DATE evaluation
label.setText("__$CURRENT_DATE__")
assert label.currentText() == ("__" + QDate.currentDate().toString() + "__")
# $CURRENT_DATE() evaluation
label.setText("__$CURRENT_DATE(dd)(ok)__")
expected = "__" + QDateTime.currentDateTime().toString("dd") + "(ok)__"
assert label.currentText() == expected
# $CURRENT_DATE() evaluation (inside an expression)
label.setText("__[%$CURRENT_DATE(dd) + 1%](ok)__")
dd = QDate.currentDate().day()
expected = "__%d(ok)__" % (dd + 1)
assert label.currentText() == expected
# expression evaluation (without associated feature)
label.setText("__[%\"NAME_1\"%][%21*2%]__")
assert label.currentText() == "__[NAME_1]42__"
def init(self):
"""
Fill options, default values and connect triggers of the dockwidget
"""
# connect triggers
self.dockwidget.pushButton.clicked.connect(self.do_something)
self.dockwidget.checkBoxStartDetected.toggled[bool].connect(
self.dockwidget.startDetectedAt.setEnabled)
self.dockwidget.checkBoxEndDetected.toggled[bool].connect(
self.dockwidget.endDetectedAt.setEnabled)
self.dockwidget.checkBoxStartPublished.toggled[bool].connect(
self.dockwidget.startPublishedAt.setEnabled)
self.dockwidget.checkBoxEndPublished.toggled[bool].connect(
self.dockwidget.endPublishedAt.setEnabled)
# set defaults
self.dockwidget.endDetectedAt.setDate(QDate.currentDate())
self.dockwidget.endPublishedAt.setDate(QDate.currentDate())
def evaluation_test(self, layout, label):
# $CURRENT_DATE evaluation
label.setText("__$CURRENT_DATE__")
assert label.currentText() == ("__" + QDate.currentDate().toString() + "__")
# $CURRENT_DATE() evaluation
label.setText("__$CURRENT_DATE(dd)(ok)__")
expected = "__" + QDateTime.currentDateTime().toString("dd") + "(ok)__"
assert label.currentText() == expected
# $CURRENT_DATE() evaluation (inside an expression)
label.setText("__[%$CURRENT_DATE(dd) + 1%](ok)__")
dd = QDate.currentDate().day()
expected = "__%d(ok)__" % (dd + 1)
assert label.currentText() == expected
# expression evaluation (without associated feature)
label.setText("__[%\"NAME_1\"%][%21*2%]__")
assert label.currentText() == "__[NAME_1]42__"
def evaluation_test(self, layout, label):
# $CURRENT_DATE evaluation
label.setText("__$CURRENT_DATE__")
self.assertEqual(label.currentText(), ("__" + QDate.currentDate().toString() + "__"))
# $CURRENT_DATE() evaluation
label.setText("__$CURRENT_DATE(dd)(ok)__")
expected = "__" + QDateTime.currentDateTime().toString("dd") + "(ok)__"
self.assertEqual(label.currentText(), expected)
# $CURRENT_DATE() evaluation (inside an expression)
label.setText("__[%$CURRENT_DATE(dd) + 1%](ok)__")
dd = QDate.currentDate().day()
expected = "__%d(ok)__" % (dd + 1)
self.assertEqual(label.currentText(), expected)
# expression evaluation (without associated feature)
label.setText("__[%try(\"NAME_1\", '[NAME_1]')%][%21*2%]__")
self.assertEqual(label.currentText(), "__[NAME_1]42__")
def test_value_date(self):
test_property = DateProperty(
'test name',
QDate.currentDate(),
'gco:Date'
)
test_property.value = QDate.fromString('2015-06-07')
with self.assertRaises(TypeError):
test_property.value = 20150607
def toggle_download_button(self, tab):
"""
Enable/disable download button and hide footprint on tab change
"""
if tab == 2:
item_id = self.dockwidget.item_id.text()
credential = self.dockwidget.credential.text()
if item_id and credential:
self.dockwidget.downloadButton.setEnabled(True)
elif self.downloading:
self.dockwidget.downloadButton.setEnabled(True)
else:
self.dockwidget.downloadButton.setDisabled(True)
else:
self.dockwidget.footprint.setChecked(False)
self.footprint.hide()
# update valid maximum dates on tab change
self.dockwidget.startdate.setMaximumDate(QDate.currentDate())
self.dockwidget.enddate.setMaximumDate(QDate.currentDate())
def __init__(self, icon_path, text, toolbar, action_group):
""" Class constructor """
super().__init__(icon_path, text, toolbar, action_group)
self.current_date = QDate.currentDate().toString('yyyy-MM-dd')
self.project_type = None
self.geom_type = None
self.geom_view = None
self.cat_table = None
self.feature_type_ws = None
self.feature_type_ud = None
def set_calendars(self, dialog, widget, table_name, value, parameter):
""" Executes query and set QDateEdit """
sql = (f"SELECT {value} FROM {table_name}"
f" WHERE parameter = '{parameter}' AND cur_user = current_user")
row = self.controller.get_row(sql)
if row:
date = QDate.fromString(row[0], 'yyyy-MM-dd')
else:
date = QDate.currentDate()
utils_giswater.setCalendarDate(dialog, widget, date)
def update_dlg_fields(self, new_collection):
"""Update list of band combinations and availability from selected collection"""
self.dlg.bands.clear() #This will remove all previous items
self.dlg.bands.addItems(
GEE_DATASETS[new_collection]['bandcombinations'].keys())
self.dlg.infotext.setPlainText(
GEE_DATASETS[new_collection]['description'])
if 'cloudfield' in GEE_DATASETS[new_collection]:
self.dlg.cloudcover.setEnabled(True)
else:
self.dlg.cloudcover.setEnabled(False)
# date availability
if 'availability' in GEE_DATASETS[new_collection]:
self.dlg.startdate.setEnabled(True)
self.dlg.enddate.setEnabled(True)
mindate = GEE_DATASETS[new_collection]['availability'][0].split(
'-')
year, month, day = int(mindate[0]), int(mindate[1]), int(
mindate[2])
self.dlg.startdate.setMinimumDate(QDate(year, month, day))
self.dlg.enddate.setMinimumDate(QDate(year, month, day))
if GEE_DATASETS[new_collection]['availability'][1] is None:
self.dlg.startdate.setMaximumDate(QDate.currentDate())
self.dlg.enddate.setMaximumDate(QDate.currentDate().addDays(1))
self.dlg.startdate.setDate(
QDate.currentDate().addDays(-3)) # to fill default date
else:
maxdate = GEE_DATASETS[new_collection]['availability'][
1].split('-')
year, month, day = int(maxdate[0]), int(maxdate[1]), int(
maxdate[2])
self.dlg.startdate.setMaximumDate(QDate(year, month, day))
self.dlg.enddate.setMaximumDate(
QDate(year, month, day).addDays(1))
self.dlg.startdate.setDate(
QDate(year, month,
day).addDays(-3)) # to fill default date
else:
self.dlg.startdate.setEnabled(False)
self.dlg.enddate.setEnabled(False)
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
self.dlg = ConstIdentificacionDialog(parent=iface.mainWindow())
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'ConstIdentificacion_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Constancia Identificacion')
self.abrePredio5 = False
self.directorioAGuardar5 = None
self.cve_catastral5 = None
self.canvas = iface.mapCanvas()
# eventos
self.dlg.btnBrowse_4.clicked.connect(self.selectDirectory4)
self.dlg.btnGenerar_4.clicked.connect(self.generarDoc4)
self.dlg.btnSeleccionar_4.clicked.connect(self.activarSeleccion4)
self.dlg.exit_signal.connect(self.closeEvent)
self.dlg.fldCveCat_4.textChanged.connect(self.lineEditToUpper4)
#validaciones
rx = QRegExp("[a-zA-Z0-9]{31}")
val = QRegExpValidator(rx)
self.dlg.fldCveCat_4.setValidator(val)
rx = QRegExp("[a-zA-ZÀ-ÿ ]{255}")
val = QRegExpValidator(rx)
self.dlg.fldNomSolic.setValidator(val)
self.onlyInt = QIntValidator()
self.dlg.fldNumSolucitud.setValidator(self.onlyInt)
self.dlg.dateEdit_2.setDate(QDate.currentDate())
def __init__(self, iface, settings, action, index_action):
""" Class constructor """
super(ReplaceFeatureMapTool, self).__init__(iface, settings, action,
index_action)
self.current_date = QDate.currentDate().toString('yyyy-MM-dd')
self.project_type = None
self.geom_type = None
self.geom_view = None
self.cat_table = None
self.feature_type_ws = None
self.feature_type_ud = None
def set_calendars(dialog, widget, table_name, value, parameter):
""" Executes query and set QDateEdit """
sql = (f"SELECT {value} FROM {table_name}"
f" WHERE parameter = '{parameter}' AND cur_user = current_user")
row = global_vars.controller.get_row(sql)
if row:
if row[0]:
row[0] = row[0].replace('/', '-')
date = QDate.fromString(row[0], 'yyyy-MM-dd')
else:
date = QDate.currentDate()
qt_tools.setCalendarDate(dialog, widget, date)
def update_collection(self):
"""
Set collection to search in and valid start and end dates for this collection
"""
collection_id = self.dockwidget.collection.currentText()
inpe_collections = {
description: id
for id, description in self.collections
}
# set collection to search
self.search.collections([inpe_collections[collection_id]])
# set valid minimum dates
mindate = self.collections.get_temporal_extent(
inpe_collections[collection_id])[0].split('-')
year, month, day = int(mindate[0]), int(mindate[1]), int(mindate[2])
self.dockwidget.startdate.setMinimumDate(QDate(year, month, day))
self.dockwidget.enddate.setMinimumDate(QDate(year, month, day))
# set valid maximum dates
self.dockwidget.startdate.setMaximumDate(QDate.currentDate())
self.dockwidget.enddate.setMaximumDate(QDate.currentDate())
def processPoint(self):
TOMsMessageLog.logMessage("In CreatePointTool.processPoint",
level=Qgis.Warning)
self.sketchPoints = self.points()
nrPoints = self.size()
for point in self.sketchPoints:
TOMsMessageLog.logMessage(
("In CreateRestrictionTool - getPointsCaptured X:" +
str(point.x()) + " Y: " + str(point.y())),
level=Qgis.Warning)
# stop capture activity
self.stopCapturing()
self.currLayer.startEditing(
) # doesn't return true when editing started - and so using isEditable
if self.currLayer.isEditable(
) == False: # removed so that "public" users are not effected
reply = QMessageBox.information(
None, "Information",
"Could not start transaction on " + self.currLayer.name(),
QMessageBox.Ok)
#x = event.pos().x()
#y = event.pos().y()
#pointLocation = self.canvas.getCoordinateTransform().toMapCoordinates(x, y)
#TOMsMessageLog.logMessage("In CreatePointTool - location" + " X: " +str(pointLocation.x()) + " Y: " + str(pointLocation.y()), level=Qgis.Info)
fields = self.currLayer.dataProvider().fields()
feature = QgsFeature()
feature.setFields(fields)
feature.setGeometry(QgsGeometry.fromPointXY(self.sketchPoints[0]))
#feature.setGeometry(QgsGeometry.fromPointXY(pointLocation))
self.setDefaultFieldRestrictionDetails(feature, self.currLayer,
QDate.currentDate())
self.currLayer.addFeature(feature) # TH (added for v3)
dialog = self.iface.getFeatureForm(self.currLayer, feature)
self.setupFieldRestrictionDialog(dialog, self.currLayer,
feature) # connects signals, etc
dialog.show()
def timeForChecking(self):
""" determine whether it's the time for checking for news and updates now """
if self.checkingOnStartInterval() == 0:
return True
settings = QgsSettings()
try:
# QgsSettings may contain ivalid value...
interval = settings.value(settingsGroup + "/checkOnStartLastDate",
type=QDate).daysTo(QDate.currentDate())
except:
interval = 0
if interval >= self.checkingOnStartInterval():
return True
else:
return False
def __init__(self, iface):
QObject.__init__(self)
#ProposalTypeUtilsMixin.__init__(self)
self.tableNames = TOMSLayers(self.iface)
#self.tableNames.TOMsLayersSet.connect(self.setRestrictionLayers)
self.__date = QDate.currentDate()
self.canvas = self.iface.mapCanvas()
self.setGPStoolsActivated = False
gpsTool = GPS(iface)
iface.mapCanvas().setMapTool(gpsTool)
def set_dates_from_to(widget_from, widget_to, table_name, field_from, field_to):
sql = (f"SELECT MIN(LEAST({field_from}, {field_to})),"
f" MAX(GREATEST({field_from}, {field_to}))"
f" FROM {table_name}")
row = global_vars.controller.get_row(sql, log_sql=False)
current_date = QDate.currentDate()
if row:
if row[0]:
widget_from.setDate(row[0])
else:
widget_from.setDate(current_date)
if row[1]:
widget_to.setDate(row[1])
else:
widget_to.setDate(current_date)
def __init__(self, iface):
QObject.__init__(self)
#ProposalTypeUtilsMixin.__init__(self)
self.iface = iface
self.tableNames = TOMSLayers(self.iface)
#self.tableNames.TOMsLayersSet.connect(self.setRestrictionLayers)
self.__date = QDate.currentDate()
self.currProposalFeature = None
self.canvas = self.iface.mapCanvas()
self.currProposalObject = TOMsProposal(self)
self.setTOMsActivated = False
def testDefaultValues(self):
""" test detection of defaults on OGR layer """
tmpfile = os.path.join(self.basetestpath, 'testDefaults.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('field1', ogr.OFTInteger))
fld2 = ogr.FieldDefn('field2', ogr.OFTInteger)
fld2.SetDefault('5')
lyr.CreateField(fld2)
fld3 = ogr.FieldDefn('field3', ogr.OFTString)
fld3.SetDefault("'some ''default'")
lyr.CreateField(fld3)
fld4 = ogr.FieldDefn('field4', ogr.OFTDate)
fld4.SetDefault("CURRENT_DATE")
lyr.CreateField(fld4)
fld5 = ogr.FieldDefn('field5', ogr.OFTTime)
fld5.SetDefault("CURRENT_TIME")
lyr.CreateField(fld5)
fld6 = ogr.FieldDefn('field6', ogr.OFTDateTime)
fld6.SetDefault("CURRENT_TIMESTAMP")
lyr.CreateField(fld6)
ds = None
vl = QgsVectorLayer('{}'.format(tmpfile), 'test', 'ogr')
self.assertTrue(vl.isValid())
# test some bad indexes
self.assertFalse(vl.dataProvider().defaultValue(-1))
self.assertFalse(vl.dataProvider().defaultValue(1001))
# test default
self.assertEqual(vl.dataProvider().defaultValue(1), NULL)
self.assertEqual(vl.dataProvider().defaultValue(2), 5)
self.assertEqual(vl.dataProvider().defaultValue(3), "some 'default")
self.assertEqual(vl.dataProvider().defaultValue(4), QDate.currentDate())
# time may pass, so we allow 1 second difference here
self.assertTrue(vl.dataProvider().defaultValue(5).secsTo(QTime.currentTime()) < 1)
self.assertTrue(vl.dataProvider().defaultValue(6).secsTo(QDateTime.currentDateTime()) < 1)
def saveCheckingOnStartLastDate(self):
""" set today's date as the day of last checking """
settings = QgsSettings()
settings.setValue(settingsGroup + "/checkOnStartLastDate", QDate.currentDate())
def timeForChecking(self):
""" determine whether it's the time for checking for news and updates now """
if self.checkingOnStartInterval() == 0:
return True
settings = QgsSettings()
try:
# QgsSettings may contain ivalid value...
interval = settings.value(settingsGroup + "/checkOnStartLastDate", type=QDate).daysTo(QDate.currentDate())
except:
interval = 0
if interval >= self.checkingOnStartInterval():
return True
else:
return False
def getPage(self, fs):
(db, conninfo) = self.plugin.opendb()
if db is None:
return None
qry = QSqlQuery(db)
if qry.exec_("SELECT 1 FROM information_schema.columns WHERE table_schema={} AND table_name='eignerart' AND column_name='anteil'".format(quote(self.plugin.settings.schema))) and qry.next():
exists_ea_anteil = qry.value(0) == 1
else:
exists_ea_anteil = False
html = ""
for i in range(0, len(fs)):
flsnr = fs[i]['flsnr']
best = self.fetchall(db, (
"SELECT " +
"ea.bvnr" +
",'' as pz" +
",(SELECT eignerart FROM eign_shl WHERE ea.b=b) as eignerart" +
",%s as anteil" +
",ea.ff_stand AS zhist" +
",b.bestdnr" +
",b.gbbz" +
",b.gbblnr" +
",b.bestfl" +
",b.ff_stand AS bhist" +
" FROM eignerart ea" +
" JOIN bestand b ON ea.bestdnr = b.bestdnr" +
" WHERE ea.flsnr = '%s'" +
" ORDER BY zhist,bhist,b") % ("ea.anteil" if exists_ea_anteil else "''", flsnr)
)
res = self.fetchall(db, "SELECT f.*,g.gemarkung FROM flurst f LEFT OUTER JOIN gema_shl g ON (f.gemashl=g.gemashl) WHERE f.flsnr='%s' AND f.ff_stand=0" % flsnr)
if len(res) == 1:
res = res[0]
else:
QMessageBox.information(None, "Fehler", u"Flurstück %s nicht gefunden.\n[%s]" % (flsnr, repr(fs)))
return None
res['datum'] = QDate.currentDate().toString("d. MMMM yyyy")
res['hist'] = 0
if qry.exec_(u"SELECT " + u" AND ".join(["has_table_privilege('{}', 'SELECT')".format(x) for x in ['strassen', 'str_shl']])) and qry.next() and qry.value(0):
res['str'] = self.fetchall(db, "SELECT sstr.strname,str.hausnr FROM str_shl sstr JOIN strassen str ON str.strshl=sstr.strshl WHERE str.flsnr='%s' AND str.ff_stand=0" % flsnr)
if qry.exec_(u"SELECT " + u" AND ".join(["has_table_privilege('{}', 'SELECT')".format(x) for x in ['nutz_21', 'nutz_shl']])) and qry.next() and qry.value(0):
res['nutz'] = self.fetchall(db, "SELECT n21.*, nu.nutzshl, nu.nutzung FROM nutz_21 n21, nutz_shl nu WHERE n21.flsnr='%s' AND n21.nutzsl=nu.nutzshl AND n21.ff_stand=0" % flsnr)
if qry.exec_(u"SELECT " + u" AND ".join(["has_table_privilege('{}', 'SELECT')".format(x) for x in ['klas_3x', 'kls_shl']])) and qry.next() and qry.value(0):
res['klas'] = self.fetchall(db, "SELECT sum(fl::int) AS fl, min(kls.klf_text) AS klf_text FROM klas_3x kl, kls_shl kls WHERE kl.flsnr='%s' AND kl.klf=kls.klf AND kl.ff_stand=0 GROUP BY kls.klf" % flsnr)
if qry.exec_(u"SELECT " + u" AND ".join(["has_table_privilege('{}', 'SELECT')".format(x) for x in ['ausfst', 'afst_shl']])) and qry.next() and qry.value(0):
res['afst'] = self.fetchall(db, "SELECT au.*, af.afst_txt FROM ausfst au,afst_shl af WHERE au.flsnr='%s' AND au.ausf_st=af.ausf_st AND au.ff_stand=0" % flsnr)
if qry.exec_(u"SELECT " + u" AND ".join(["has_table_privilege('{}', 'SELECT')".format(x) for x in ['bestand', 'eignerart', 'eign_shl']])) and qry.next() and qry.value(0):
res['best'] = self.fetchall(db, "SELECT ea.bvnr,'' as pz,(SELECT eignerart FROM eign_shl WHERE ea.b = b) as eignerart,%s as anteil,ea.ff_stand AS zhist,b.bestdnr,b.gbbz,b.gbblnr,b.bestfl,b.ff_stand AS bhist FROM eignerart ea JOIN bestand b ON ea.bestdnr = b.bestdnr WHERE ea.flsnr='%s' ORDER BY zhist,bhist,b" % (
"ea.anteil" if exists_ea_anteil else "''",
flsnr
))
if qry.exec_("SELECT has_table_privilege('eigner', 'SELECT')") and qry.next() and qry.value(0):
for b in res['best']:
b['bse'] = self.fetchall(db, "SELECT * FROM eigner WHERE bestdnr='%s' AND ff_stand=0" % b['bestdnr'])
# for k,v in res.iteritems():
# qDebug( u"%s:%s\n" % ( k, unicode(v) ) )
html = u"""
<HTML xmlns="http://www.w3.org/1999/xhtml">
<HEAD>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</HEAD>
<BODY>
<style>
.fls_tab{width:100%%;empty-cells:show}
.fls_headline{font-weight:bold;font-size:4em;}
.fls_headline_col{background-color:#EEEEEE;width:100%%;height:30px;text-align:left;}
.fls_time {background-color:#EEEEEE;font-weight:bold;font-size:4em;text-align:right;width:100%%}
.fls_col_names{font-weight:bold;}
.fls_col_values{vertical-align:top;}
.fls_bst{width:100%%;empty-cells:show}
.fls_hr{border:dotted 1px;color:#080808;}
.fls_footnote{text-align:center;}
</style>
<TABLE class="fls_tab" border="0" width="100%%" cellspacing="0">
<TR class="fls_headline">
<TD colspan="3" class="fls_headline_col">Flurstücksnachweis</TD><TD class="fls_time" colspan="4" align="right">%(datum)s</TD></TR>
</TR>
<TR><TD colspan="7"> </TD></TR>
<TR>
<TD colspan="7"><h3>Flurstück %(gemashl)s-%(flr)s-%(flsnrk)s<hr style="width:100%%"></h3></TD>
</TR>
<TR class="fls_col_names">
<TD width="15%%">Gemarkung</TD>
<TD width="6%%">Flur</TD>
<TD width="15%%">Flurstück</TD>
<TD width="20%%">Flurkarte</TD>
<TD width="17%%">Entstehung</TD>
<TD width="17%%">Fortführung</TD>
<TD width="5%%">Fläche</TD>
</TR>
<TR class="fls_col_values">
<TD>%(gemashl)s<br>%(gemarkung)s</TD>
<TD>%(flr)s</TD>
<TD>%(flsnrk)s</TD>
<TD>%(flurknr)s</TD>
<TD>%(entst)s</TD>
<TD>%(fortf)s</TD>
<TD>%(flsfl)s m²</TD>
</TR>
</TABLE>
""" % res
if res['blbnr']:
html += u"""
<TABLE class="fls_tab" border="0" width="100%%">
<TR class="fls_col_names">
<TD width="21%%"></TD>
<TD width="79%%">Baulastenblattnr.</TD>
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(blbnr)s</TD>
</TR>
</TABLE>
""" % res
if res['lagebez'] or res['anl_verm']:
html += u"""
<TABLE class="fls_tab" border="0" width="100%%">
<TR class="fls_col_names">
<TD width="21%%"></TD>
<TD width="52%%">Lage</TD>
<TD width="27%%">Anliegervermerk</TD>
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(lagebez)s</TD>
<TD>%(anl_verm)s</TD>
</TR>
</TABLE>
""" % res
if 'str' in res:
if res['str']:
html += u"""
<TABLE border="0" class="fls_tab" width="100%">
<TR class="fls_col_names">
<TD width="21%"></TD>
<TD width="52%">Strasse</TD>
<TD width="27%">Hausnummer</TD>
</TR>
"""
for strres in res['str']:
html += u"""
<TR class="fls_col_values">
<TD></TD><TD>%(strname)s</TD><TD>%(hausnr)s</TD></TR>
</TR>
""" % strres
html += u"""
</TABLE>
"""
if 'nutz' in res:
html += u"""
<TABLE border="0" class="fls_tab" width="100%">
<TR class="fls_col_names"><TD width="21%"></TD><TD width="69%">Nutzung</TD><TD width="10%">Fläche</TD></TR>
"""
if res['nutz']:
for nutz in res['nutz']:
html += u"""
<TR class="fls_col_values"><TD></TD><TD>21%(nutzshl)s - %(nutzung)s</TD><TD>%(fl)s m²</TD></TR>
""" % nutz
else:
html += u"""
<TR class="fls_col_values"><TD></TD><TD colspan=2>Keine</TD></TR>
"""
html += u"""
</TABLE>
"""
if 'klas' in res:
html += u"""
<TABLE border="0" class="fls_tab" width="100%">
<TR class="fls_col_names"><TD width="21%"></TD><TD width="69%">Klassifizierung(en)</TD><TD width="10%">Fläche</TD></TR>
"""
if res['klas']:
for klas in res['klas']:
html += u"""
<TR class="fls_col_values"><TD></TD><TD>%(klf_text)s</TD><TD>%(fl)s m²</TD></TR>
""" % klas
else:
html += u"""
<TR class="fls_col_values"><TD></TD><TD colspan=2>Keine</TD></TR>
"""
html += u"""
</TABLE>
"""
if 'afst' in res:
html += u"""
<TABLE border="0" class="fls_tab" width="100%">
<TR class="fls_col_names"><TD width="21%"></TD><TD width="79%">Ausführende Stelle(n)</TD></TR>
"""
if res['afst']:
for afst in res['afst']:
html += u"""
<TR class="fls_col_values"><TD></TD><TD>%(afst_txt)s</TD></TR>
""" % afst
else:
html += u"""
<TR class="fls_col_values"><TD></TD><TD colspan=2>Keine</TD></TR>
"""
html += u"""
</TABLE>
"""
if 'best' in res:
if res['best']:
html += u"""
<br>
<TABLE border="0" class="fls_bst" width="100%">
<TR><TD colspan="6"><h3>Bestände<hr style="width:100%"></h3></TD></TR>
"""
for best in res['best']:
html += u"""
<TR class="fls_col_names">
<TD>Bestandsnummer</TD>
<TD>Grundbuchbezirk</TD>
<TD colspan="2">Grundbuchblattnr.</TD>
<TD>Anteil</TD>
</TR>
<TR class="fls_col_values">
<TD>%(bestdnr)s</TD>
<TD>%(gbbz)s</TD>
<TD colspan="2">%(gbblnr)s</TD>
<TD>%(anteil)s</TD>
</TR>
<TR class="fls_col_names">
<TD></TD>
<TD>Buchungskennz.</TD>
<TD>BVNR</TD>
<TD>PZ</TD>
""" % best
if res['hist']:
html += u"""
<TD>Hist. Bestand</TD><TD>Hist. Zuordnung</TD>
"""
else:
html += u"""
<TD></TD><TD></TD>
"""
html += u"""
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(eignerart)s</TD>
<TD>%(bvnr)s</TD>
<TD>%(pz)s</TD>
""" % best
html += "<TD>%s</TD>" % ("ja" if res['hist'] and best['bhist'] else "")
html += "<TD>%s</TD>" % ("ja" if res['hist'] and best['zhist'] else "")
html += u"""
</TR>
"""
if 'bse' in best:
if best['bse']:
html += u"""
<TR class="fls_col_names"><TD>Anteil</TD><TD colspan="5">Namensinformation</TD></TR>
"""
for bse in best['bse']:
html += u"""
<TR class="fls_col_values">
<TD>%(antverh)s</TD>
<TD colspan="5">%(name1)s %(name2)s<br>%(name3)s<br>%(name4)s</TD>
</TR>
""" % bse
else:
html += u"""
<p>Kein Eigentümer gefunden.</p>
"""
html += u"""
<TR><TD colspan="6"><hr class="fls_hr"></TD></TR>
"""
html += u"""
"""
footnote = self.plugin.settings.footnote
if footnote:
html += u"""
<TR><TD colspan="7" class="fls_footnote">%s</TD></TR>
""" % footnote
html += u"""
</TABLE>
</BODY>
</HTML>
"""
return html
