From e3d79a9af87f91bc189b14f409268e58619859f7 Mon Sep 17 00:00:00 2001 From: lpofredc Date: Thu, 26 Sep 2024 14:43:33 +0200 Subject: [PATCH 1/2] fix #145 and improve data behaviour --- plugin_qgis_lpo/commons/helpers.py | 122 +++------ .../processing/processing_algorithm.py | 233 +++++++----------- plugin_qgis_lpo/processing/refresh_data.py | 19 +- 3 files changed, 143 insertions(+), 231 deletions(-) diff --git a/plugin_qgis_lpo/commons/helpers.py b/plugin_qgis_lpo/commons/helpers.py index 216a684..68a4040 100644 --- a/plugin_qgis_lpo/commons/helpers.py +++ b/plugin_qgis_lpo/commons/helpers.py @@ -193,9 +193,8 @@ def sql_datetime_filter_builder( def sql_timeinterval_cols_builder( # noqa C901 self: QgsProcessingAlgorithm, - time_interval_param, - start_year_param: int, - end_year_param: int, + period_type_filter: str, + time_interval_param: str, aggregation_type_param: str, parameters: Dict, context: QgsProcessingContext, @@ -210,41 +209,41 @@ def sql_timeinterval_cols_builder( # noqa C901 "*" if aggregation_type_param == "Nombre de données" else "DISTINCT t.cd_ref" ) if time_interval_param == "Par année": - add_five_years = self.parameterAsEnums( - parameters, self.ADD_FIVE_YEARS, context # type: ignore - ) - if len(add_five_years) > 0: - if (end_year_param - start_year_param + 1) % 5 != 0: + timestamp = datetime.now() + if period_type_filter in ("5 dernières années", "10 dernières années", "Pas de filtre temporel"): + end_year = int(timestamp.strftime("%Y")) + period = period_type_filter.split()[0] + start_year = end_year - int(period if period.isdigit() else 10) + years = [str(year) for year in range(start_year,end_year)] + + elif period_type_filter == "Cette année": + end_year = int(timestamp.strftime("%Y")) + start_year = end_year + years = [timestamp.strftime("%Y"),] + + elif period_type_filter == "Date de début - Date de fin (à définir ci-dessous)": + # Retrieve the start and end dates + start_date = datetime.fromisoformat(self.parameterAsString(parameters, self.START_DATE, context)) + end_date = datetime.fromisoformat(self.parameterAsString(parameters, self.END_DATE, context)) + + if end_date < start_date: raise QgsProcessingException( - "Veuillez renseigner une période en année qui soit " - "divisible par 5 ! Exemple : 2011 - 2020." + "Veuillez renseigner une date de fin postérieure ou égale à la date de début !" ) else: - counter = start_year_param - step_limit = start_year_param - while counter <= end_year_param: - select_data.append( - f"""COUNT({count_param}) filter (WHERE date_an={counter}) AS \"{counter}\" """ - ) - x_var.append(str(counter)) - if counter == step_limit + 4: - select_data.append( - f"""COUNT({count_param}) filter (WHERE date_an>={counter-4} and date_an<={counter}) AS \"{counter-4} - {counter}\" """ - ) - step_limit += 5 - counter += 1 - else: - for year in range(start_year_param, end_year_param + 1): + end_year = int(end_date.strftime("%Y")) + start_year = int(start_date.strftime("%Y")) + years = [str(year) for year in range(start_year,end_year)] + + for year in years: select_data.append( f"""COUNT({count_param}) filter (WHERE date_an={year}) AS \"{year}\"""" ) x_var.append(str(year)) - select_data.append( - f"""COUNT({count_param}) filter (WHERE date_an>={start_year_param} and date_an<={end_year_param}) AS \"TOTAL\"""" - ) + else: - start_month = self.parameterAsEnum(parameters, self.START_MONTH, context) - end_month = self.parameterAsEnum(parameters, self.END_MONTH, context) + monthes = self.parameterAsEnums(parameters, self.MONTHES, context) + self.log(message=f'MONTHES {monthes}') months_numbers_variables = [ "01", "02", @@ -259,60 +258,17 @@ def sql_timeinterval_cols_builder( # noqa C901 "11", "12", ] - if start_year_param == end_year_param: - if end_month < start_month: - raise QgsProcessingException( - "Veuillez renseigner un mois de fin postérieur ou égal au mois de début !" - ) - else: - for month in range(start_month, end_month + 1): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{start_year_param}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {start_year_param}\"""" - ) - x_var.append( - self._months_names_variables[month] # type: ignore - + " " - + str(start_year_param) - ) - elif end_year_param == start_year_param + 1: - for month in range(start_month, 12): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{start_year_param}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {start_year_param}\"""" - ) - x_var.append( - self._months_names_variables[month] + " " + str(start_year_param) # type: ignore + for month in monthes: + select_data.append( + f"""COUNT({count_param}) filter (WHERE extract(month from date)={month+1}) AS \"{self._months_names_variables[month]}\"""" ) - for month in range(0, end_month + 1): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{end_year_param}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {end_year_param}\"""" - ) - x_var.append( - self._months_names_variables[month] + " " + str(end_year_param) - ) - else: - for month in range(start_month, 12): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{start_year_param}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {start_year_param}\"""" - ) - x_var.append( - self._months_names_variables[month] + " " + str(start_year_param) - ) - for year in range(start_year_param + 1, end_year_param): - for month in range(0, 12): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{year}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {year}\"""" - ) - x_var.append(self._months_names_variables[month] + " " + str(year)) - for month in range(0, end_month + 1): - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')='{end_year_param}-{months_numbers_variables[month]}') AS \"{self._months_names_variables[month]} {end_year_param}\"""" - ) - x_var.append( - self._months_names_variables[month] + " " + str(end_year_param) - ) - select_data.append( - f"""COUNT({count_param}) filter (WHERE to_char(date, 'YYYY-MM')>='{start_year_param}-{months_numbers_variables[start_month]}' and to_char(date, 'YYYY-MM')<='{end_year_param}-{months_numbers_variables[end_month]}') AS \"TOTAL\"""" - ) + x_var.append( + self._months_names_variables[month] # type: ignore + ) + # Adding total count + select_data.append( + f"""COUNT({count_param}) AS \"TOTAL\"""" + ) final_select_data = ", ".join(select_data) feedback.pushDebugInfo(final_select_data) return final_select_data, x_var diff --git a/plugin_qgis_lpo/processing/processing_algorithm.py b/plugin_qgis_lpo/processing/processing_algorithm.py index 79ad2cf..4f9bfc3 100644 --- a/plugin_qgis_lpo/processing/processing_algorithm.py +++ b/plugin_qgis_lpo/processing/processing_algorithm.py @@ -77,10 +77,7 @@ class BaseProcessingAlgorithm(QgsProcessingAlgorithm): TIME_INTERVAL = "TIME_INTERVAL" ADD_FIVE_YEARS = "ADD_FIVE_YEARS" TEST = "TEST" - START_MONTH = "START_MONTH" - START_YEAR = "START_YEAR" - END_MONTH = "END_MONTH" - END_YEAR = "END_YEAR" + MONTHES = "MONTHES" EXTRA_WHERE = "EXTRA_WHERE" OUTPUT = "OUTPUT" OUTPUT_NAME = "OUTPUT_NAME" @@ -194,8 +191,6 @@ def __init__(self) -> None: self._lr_columns_db: List[str] = ["lr_r"] self._lr_columns_with_alias: List[str] = ['lr_r as "LR Régionale"'] self._time_interval: str - self._start_year: int - self._end_year: int def tr(self, string: str) -> str: """QgsProcessingAlgorithm translatable string with the self.tr() function.""" @@ -263,30 +258,28 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 optional_text = "(facultatif)" # self._ts = datetime.now() # self._db_variables = QgsSettings() - self.addParameter( - QgsProcessingParameterProviderConnection( - self.DATABASE, - self.tr( - f"""BASE DE DONNÉES {required_text} : + database = QgsProcessingParameterProviderConnection( + self.DATABASE, + self.tr( + f"""BASE DE DONNÉES {required_text} : sélectionnez votre connexion à la base de données LPO""" - ), - "postgres", - defaultValue="geonature_lpo", - optional=False, - ) + ), + "postgres", + defaultValue="geonature_lpo", + optional=False, ) + self.addParameter(database) # Input vector layer = study area - self.addParameter( - QgsProcessingParameterFeatureSource( - self.STUDY_AREA, - self.tr( - f"""ZONE D'ÉTUDE {required_text} : + study_area = QgsProcessingParameterFeatureSource( + self.STUDY_AREA, + self.tr( + f"""ZONE D'ÉTUDE {required_text} : sélectionnez votre zone d'étude, à partir de laquelle seront extraits les résultats""" - ), - [QgsProcessing.TypeVectorPolygon], - ) + ), + [QgsProcessing.TypeVectorPolygon], ) + self.addParameter(study_area) if self._has_taxonomic_rank_form and self._taxonomic_ranks: self._taxonomic_ranks_labels = [ @@ -317,6 +310,48 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 ) self.addParameter(taxonomic_rank) + period_type = QgsProcessingParameterEnum( + self.PERIOD, + self.tr( + f"""PÉRIODE {required_text} : + sélectionnez une période pour filtrer vos données + d'observations""" + ), + self._period_variables, + allowMultiple=False, + optional=True, + ) + period_type.setMetadata( + { + "widget_wrapper": { + "useCheckBoxes": True, + "columns": len(self._period_variables) / 2, + } + } + ) + # period_type.setFlags(period_type.flags() | QgsProcessingParameterDefinition.FlagHidden) + self.addParameter(period_type) + + start_date = QgsProcessingParameterString( + self.START_DATE, + f"Date de début {optional_text}", + defaultValue="", + optional=True, + ) + start_date.setMetadata({"widget_wrapper": {"class": DateTimeWidget}}) + # start_date.setFlags(start_date.flags() | QgsProcessingParameterDefinition.FlagHidden) + self.addParameter(start_date) + + end_date = QgsProcessingParameterString( + self.END_DATE, + f"Date de fin {optional_text}", + defaultValue="", + optional=True, + ) + end_date.setMetadata({"widget_wrapper": {"class": DateTimeWidget}}) + # end_date.setFlags(end_date.flags() | QgsProcessingParameterDefinition.FlagHidden) + self.addParameter(end_date) + if self._has_time_interval_form: # ## Time interval and period ### time_interval = QgsProcessingParameterEnum( @@ -337,86 +372,16 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 ) self.addParameter(time_interval) - self.addParameter( - QgsProcessingParameterEnum( - self.START_MONTH, - self.tr("Mois de début"), - self._months_names_variables, - allowMultiple=False, - optional=True, - ) - ) - - self.addParameter( - QgsProcessingParameterNumber( - self.START_YEAR, - self.tr("Année de début"), - QgsProcessingParameterNumber.Integer, - defaultValue=2010, - minValue=1800, - maxValue=int(self._ts.strftime("%Y")), - ) - ) - - self.addParameter( - QgsProcessingParameterEnum( - self.END_MONTH, - self.tr("Mois de fin"), - self._months_names_variables, - allowMultiple=False, - optional=True, - ) - ) - - self.addParameter( - QgsProcessingParameterNumber( - self.END_YEAR, - self.tr("Année de fin"), - QgsProcessingParameterNumber.Integer, - defaultValue=self._ts.strftime("%Y"), - minValue=1800, - maxValue=int(self._ts.strftime("%Y")), - ) - ) - else: - period_type = QgsProcessingParameterEnum( - self.PERIOD, - self.tr( - f"""PÉRIODE {required_text} : - sélectionnez une période pour filtrer vos données - d'observations""" - ), - self._period_variables, - allowMultiple=False, - optional=False, - ) - period_type.setMetadata( - { - "widget_wrapper": { - "useCheckBoxes": True, - "columns": len(self._period_variables) / 2, - } - } - ) - self.addParameter(period_type) - - start_date = QgsProcessingParameterString( - self.START_DATE, - f"Date de début {optional_text}", - defaultValue="", - optional=True, - ) - start_date.setMetadata({"widget_wrapper": {"class": DateTimeWidget}}) - self.addParameter(start_date) - - end_date = QgsProcessingParameterString( - self.END_DATE, - f"Date de fin {optional_text}", - defaultValue="", + monthes = QgsProcessingParameterEnum( + self.MONTHES, + self.tr("Mois de début"), + self._months_names_variables, + allowMultiple=True, optional=True, + defaultValue=[v for v in range(12)] ) - end_date.setMetadata({"widget_wrapper": {"class": DateTimeWidget}}) - self.addParameter(end_date) + self.addParameter(monthes) + if self._return_geo_agg: areas_types = QgsProcessingParameterEnum( @@ -435,18 +400,17 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 self.addParameter(areas_types) # ## Taxons filters ## - self.addParameter( - QgsProcessingParameterEnum( - self.GROUPE_TAXO, - self.tr( - f"""TAXONS {optional_text} : + taxon_filter = QgsProcessingParameterEnum( + self.GROUPE_TAXO, + self.tr( + f"""TAXONS {optional_text} : filtrer les données par groupes taxonomiques""" - ), - self._db_variables.value("groupe_taxo"), - allowMultiple=True, - optional=True, - ) + ), + self._db_variables.value("groupe_taxo"), + allowMultiple=True, + optional=True, ) + self.addParameter(taxon_filter) if self._has_histogram: histogram_options = QgsProcessingParameterEnum( @@ -479,28 +443,26 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 ) self.addParameter(output_histogram) - self.addParameter( - QgsProcessingParameterString( - self.OUTPUT_NAME, - self.tr( - f"""PARAMÉTRAGE DES RESULTATS EN SORTIE + output_name = QgsProcessingParameterString( + self.OUTPUT_NAME, + self.tr( + f"""PARAMÉTRAGE DES RESULTATS EN SORTIE {optional_text} : personnalisez le nom de votre couche en base de données""" - ), - self.tr(self._output_name), - ) + ), + self.tr(self._output_name), ) + self.addParameter(output_name) # Boolean : True = add the summary table in the DB ; False = don't - self.addParameter( - QgsProcessingParameterBoolean( - self.ADD_TABLE, - self.tr( - "Enregistrer les résultats en sortie dans une nouvelle table en base de données" - ), - False, - ) + add_table = QgsProcessingParameterBoolean( + self.ADD_TABLE, + self.tr( + "Enregistrer les résultats en sortie dans une nouvelle table en base de données" + ), + False, ) + self.addParameter(add_table) if self._has_source_data_filter: source_data_where = QgsProcessingParameterEnum( @@ -546,6 +508,9 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 extra_where.flags() | QgsProcessingParameterDefinition.FlagAdvanced ) self.addParameter(extra_where) + self.log( + message=f"initAlgorithm {self._name} SD{self.START_DATE} ED{self.END_DATE} end" + ) def processAlgorithm( # noqa N802 self, @@ -703,14 +668,7 @@ def processAlgorithm( # noqa N802 self.parameterAsEnum(parameters, self.TIME_INTERVAL, context) ] self.log(message=f"time_interval {self._time_interval}") - self._start_year = self.parameterAsInt(parameters, self.START_YEAR, context) - self.log(message=f"start_year {self._start_year}") - self._end_year = self.parameterAsInt(parameters, self.END_YEAR, context) - self.log(message=f"end_year {self._end_year}") - if self._end_year < self._start_year: - raise QgsProcessingException( - "Veuillez renseigner une année de fin postérieure à l'année de début !" - ) + self._monthes = self.parameterAsEnum(parameters, self.MONTHES, context) taxonomic_rank = self._taxonomic_ranks_labels[ self.parameterAsEnum(parameters, self.TAXONOMIC_RANK, context) ] @@ -726,9 +684,8 @@ def processAlgorithm( # noqa N802 self._x_var, ) = sql_timeinterval_cols_builder( self, + self._period_type, self._time_interval, - self._start_year, - self._end_year, aggregation_type, parameters, context, diff --git a/plugin_qgis_lpo/processing/refresh_data.py b/plugin_qgis_lpo/processing/refresh_data.py index ec4ee98..af0ea84 100644 --- a/plugin_qgis_lpo/processing/refresh_data.py +++ b/plugin_qgis_lpo/processing/refresh_data.py @@ -59,18 +59,17 @@ def initAlgorithm(self, _config: None) -> None: # noqa N802 # self._ts = datetime.now() # self._db_variables = QgsSettings() - self.addParameter( - QgsProcessingParameterProviderConnection( - self.DATABASE, - self.tr( - f"""BASE DE DONNÉES {required_text} : + database = QgsProcessingParameterProviderConnection( + self.DATABASE, + self.tr( + f"""BASE DE DONNÉES {required_text} : sélectionnez votre connexion à la base de données LPO""" - ), - "postgres", - defaultValue="geonature_lpo", - optional=False, - ) + ), + "postgres", + defaultValue="geonature_lpo", + optional=False, ) + self.addParameter(database) def processAlgorithm( self, From 31612a87350257552bcdfb8c8ea93cc8ab3bf5e1 Mon Sep 17 00:00:00 2001 From: lpofredc Date: Thu, 26 Sep 2024 14:52:02 +0200 Subject: [PATCH 2/2] update version --- CHANGELOG.md | 9 +++++++++ plugin_qgis_lpo/metadata.txt | 2 +- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 161b033..fe21405 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this +## 3.3.5 - 2024-09-25 + +* Time interval script (fix #145 from PR #147) is now fixed and usable as expected + +## 3.3.4 - 2024-09-24 + +* Plugin menu is now correctly removed from bar when plugin is uninstalled or reloaded + ## 3.3.3 - 2024-08-26 + * update documentation ## 3.3.2 - 2024-08-26 diff --git a/plugin_qgis_lpo/metadata.txt b/plugin_qgis_lpo/metadata.txt index b5ac69f..6f9d810 100644 --- a/plugin_qgis_lpo/metadata.txt +++ b/plugin_qgis_lpo/metadata.txt @@ -21,5 +21,5 @@ qgisMinimumVersion=3.16 qgisMaximumVersion=3.99 # versioning -version=3.3.3 +version=3.3.5 changelog=https://github.com/lpoaura/PluginQGis-LPOData/blob/master/CHANGELOG.md