diff --git a/dev/flat_import_ars_data.Rmd b/dev/flat_import_ars_data.Rmd
index dfbd8ecec41bc739878891d78fb0dddcec6795d3..3c94878b5dfa91f8a5e767426385668c9b652698 100644
--- a/dev/flat_import_ars_data.Rmd
+++ b/dev/flat_import_ars_data.Rmd
@@ -1,5 +1,5 @@
---
-title: "Import des données ARS"
+title: "Import des donn\u00e9es ARS"
output: html_document
editor_options:
chunk_output_type: console
@@ -7,6 +7,8 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
+library(glue)
library(xlsx)
library(datalibaba)
library(RPostgreSQL)
@@ -20,56 +22,28 @@ library(dplyr)
pkgload::load_all(export_all = FALSE)
```
-# Présentation
-
-Cette page contient la logique métier concernant l'import des données brutes
-fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
-Nitrates
-
-# Connexion à la base de données PostgreSQL
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
+# Accéder aux valeurs pour last_year et filepath_data_ars
+last_year <- config$last_year
+filepath_data_ars <- config$filepath_data_ars
```
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
-
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
-```
-
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "nitrates"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
+# Présentation
-```
+Cette page contient la logique métier concernant l'import des données brutes
+fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
+Nitrates.
# Import des données de l'ARS dans un dataframe par millésime
Les données sont transmies au format XLSX.
-```{r import_data_ars_2023, eval=FALSE}
-data_ars_2023 <- collectr::import_xlsx(
- filepath = "T:\\datalab\\SRNP_DEMA_SI_EAU\\NITRATES\\DONNEES_CLIENT\\SOURCES\\ARS\\2024_06\\Nitrates 2023 pour DREAL EPNT4 2024-05-31.xlsx",
+```{r import_data_ars_last_year, eval=FALSE}
+data_ars_last_year <- collectr::import_xlsx(
+ filepath = filepath_data_ars,
sheet = 1,
row = 2)
@@ -79,16 +53,16 @@ data_ars_2023 <- collectr::import_xlsx(
```{r create-nitrate_data_ars, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = data_ars_2023,
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::poster_data(data = data_ars_last_year,
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2023)",
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (", last_year, ")"),
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
user = "admin")
@@ -101,7 +75,7 @@ datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2023)",
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "nitrates",
- table = "nitrate_data_analyse_ars_2023",
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
column_name = "plv_date",
column_type = "date",
role = "admin")
@@ -125,23 +99,46 @@ collectr::archive_table(database = "si_eau",
```{r import_and_merge_tables, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_data_analyse_ars_2023",
+ source_table = glue::glue("nitrate_data_analyse_ars_", last_year),
source_schema = "nitrates",
target_table = "nitrate_data_analyse_ars",
target_schema = "nitrates",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2007-2023)",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (2007-", last_year, ")",
table = "nitrate_data_analyse_ars",
schema = "nitrates",
db = "si_eau",
user = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es ARS",
+ template_dir = "import-des-donnees-ars",
+ template_description = "Import des donn\u00e9es ARS",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_ars_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_ars_data.Rmd", vignette_name = "Import des données ARS")
+fusen::inflate(flat_file = "dev/flat_import_ars_data.Rmd", vignette_name = "Import des donn\u00e9es ARS")
```
diff --git a/dev/flat_import_hubeau_eso_data.Rmd b/dev/flat_import_hubeau_eso_data.Rmd
index b9a4d3116b2a95ddf090229f57572d55034e282b..73b25305daa36f6eb160731cc975d843a2cfbb48 100644
--- a/dev/flat_import_hubeau_eso_data.Rmd
+++ b/dev/flat_import_hubeau_eso_data.Rmd
@@ -1,5 +1,5 @@
---
-title: "Import des données Hub'eau ESO"
+title: "Import des donn\u00e9es Hubeau ESO"
output: html_document
editor_options:
chunk_output_type: console
@@ -7,6 +7,8 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
+library(glue)
library(hubeau)
library(datalibaba)
library(RPostgreSQL)
@@ -20,102 +22,55 @@ library(dplyr)
pkgload::load_all(export_all = FALSE)
```
-# Présentation
-
-> Cette page contient la logique métier concernant l'import des données de
-l'[API Hub'eau "Qualité des nappes d'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes) dans le cadre du projet Nitrates
-
-# Connexion à la base de données PostgreSQL
-
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
+# Accéder à la valeur pour last_year
+last_year <- config$last_year
```
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "qualite_cours_d_eau"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
+# Présentation
-```
+Cette page contient la logique métier concernant l'import des données de
+l'[API Hub'eau "Qualit\u00e9 des nappes d\'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes)
+dans le cadre du projet Nitrates.
# Import des données Hub'eau ESU dans un dataframe par millésime
On utilise la fonction `get_qualite_nappes_analyses()` du package [{hubeau}](https://github.com/inrae/hubeau)
-```{r create-nitrate_analyse_esu_2020, eval=FALSE}
-nitrate_analyse_eso_2020 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2020-01-01",
- date_fin_prelevement = "2020-12-31",
- size = "5000")
-```
+```{r create-nitrate_analyse_esu_last_year, eval=FALSE}
+nitrate_analyse_eso_last_year <- hubeau::get_qualite_nappes_analyses(
+ code_param = "1340",
+ code_region = "52",
+ date_debut_prelevement = glue::glue(last_year, "-01-01"),
+ date_fin_prelevement = glue::glue(last_year, "-12-31"),
+ size = "5000"
+ )
-```{r create-nitrate_analyse_esu_2021, eval=FALSE}
-nitrate_analyse_eso_2021 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2021-01-01",
- date_fin_prelevement = "2021-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2022, eval=FALSE}
-nitrate_analyse_eso_2022 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2022-01-01",
- date_fin_prelevement = "2022-12-31",
- size = "5000")
-
-```
-
-```{r create-nitrate_analyse_esu_2023, eval=FALSE}
-nitrate_analyse_eso_2023 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2023-01-01",
- date_fin_prelevement = "2023-12-31",
- size = "5000")
```
# Création d'une table pour le nouveau millésime
```{r create-nitrate_data_ars, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_analyse_eso_2023,
- table = "nitrate_qualite_nappes_analyses_2023",
+datalibaba::poster_data(data = nitrate_analyse_eso_last_year,
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
schema = "qualite_nappes_eau_souterraine",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESO issues de l''API Hub''eau qualite_nappes : données brutes",
- table = "nitrate_qualite_nappes_analyses_2023",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses \"Nitrates\" ESO issues de l\'\'API Hubeau qualite_nappes : donn\u00e9es brutes ",
+ last_year),
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin")
```
@@ -125,7 +80,7 @@ datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESO issues de l''AP
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "qualite_nappes_eau_souterraine",
- table = "nitrate_qualite_nappes_analyses_2023",
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
column_name = "date_debut_prelevement",
column_type = "date",
role = "admin")
@@ -149,22 +104,51 @@ collectr::archive_table(database = "si_eau",
```{r import_and_merge_tables, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_nappes_analyses_2023",
+ source_table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
source_schema = "qualite_nappes_eau_souterraine",
target_table = "nitrate_qualite_nappes_analyses",
target_schema = "qualite_nappes_eau_souterraine",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ESO API Hub'eau Qualité des nappes d'eau souterraine (2007-2023)",
- table = "nitrate_qualite_nappes_analyses",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses Nitrates ESO API Hubeau Qualit\u00e9 des nappes d\'eau souterraine (2007-",
+ last_year,
+ ")"),
+ table = "nitrate_qualite_nappes_analyses",
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin"
+ )
+
+```
+
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es Hubeau ESO",
+ template_dir = "import-des-donnees-hubeau-eso",
+ template_description = "Import des donn\u00e9es Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_hubeau_eso_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
```
```{r development-inflate, eval=FALSE}
# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_hubeau_eso_data.Rmd", vignette_name = "Import des données Hub'eau ESO")
+fusen::inflate(flat_file = "dev/flat_import_hubeau_eso_data.Rmd", vignette_name = "Import des donn\u00e9es Hubeau ESO")
```
diff --git a/dev/flat_import_hubeau_esu_data.Rmd b/dev/flat_import_hubeau_esu_data.Rmd
index df26f047b69a81404c2f3c78d244cc51c567fc8a..c023b7b3cbfc79a1895cd98870342e0db5c5d80d 100644
--- a/dev/flat_import_hubeau_esu_data.Rmd
+++ b/dev/flat_import_hubeau_esu_data.Rmd
@@ -1,5 +1,5 @@
---
-title: "Import des données Hub'eau ESU"
+title: "Import des donn\u00e9es Hubeau ESU"
output: html_document
editor_options:
chunk_output_type: console
@@ -7,6 +7,8 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
+library(glue)
library(hubeau)
library(datalibaba)
library(RPostgreSQL)
@@ -20,89 +22,39 @@ library(dplyr)
pkgload::load_all(export_all = FALSE)
```
-# Présentation
-
-> Cette page contient la logique métier concernant l'import des données de
-l'[API Hub'eau "Qualité des cours d'eau"](https://hubeau.eaufrance.fr/page/api-qualite-cours-deau) dans le cadre du projet Nitrates
-
-# Connexion à la base de données PostgreSQL
-
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
+# Accéder à la valeur pour last_year
+last_year <- config$last_year
```
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "qualite_cours_d_eau"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
+# Présentation
-```
+Cette page contient la logique métier concernant l'import des données de
+l'[API Hub'eau "Qualit\u00e9 des cours d\'eau"](https://hubeau.eaufrance.fr/page/api-qualite-cours-deau)
+dans le cadre du projet Nitrates.
# Import des données Hub'eau ESU dans un dataframe par millésime
On utilise la fonction `get_qualite_rivieres_analyse()` du package [{hubeau}](https://github.com/inrae/hubeau)
-```{r create-nitrate_analyse_esu_2020, eval=FALSE}
-nitrate_analyse_esu_2020 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2020-01-01",
- date_fin_prelevement = "2020-12-31",
- size = "5000")
-```
+```{r create-nitrate_analyse_esu_last_year, eval=FALSE}
+nitrate_analyse_esu_last_year <- hubeau::get_qualite_rivieres_analyse(
+ code_parametre = "1340",
+ code_region = "52",
+ date_debut_prelevement = glue::glue(last_year, "-01-01"),
+ date_fin_prelevement = glue::glue(last_year, "-12-31"),
+ size = "5000"
+)
-```{r create-nitrate_analyse_esu_2021, eval=FALSE}
-nitrate_analyse_esu_2021 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2021-01-01",
- date_fin_prelevement = "2021-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2022, eval=FALSE}
-nitrate_analyse_esu_2022 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2022-01-01",
- date_fin_prelevement = "2022-12-31",
- size = "5000")
-
-```
-
-```{r create-nitrate_analyse_esu_2023, eval=FALSE}
-nitrate_analyse_esu_2023 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2023-01-01",
- date_fin_prelevement = "2023-12-31",
- size = "5000")
```
# Correction de l'encodage si nécessaire pour certaines variables
```{r change-encoding, eval=FALSE}
-nitrate_analyse_esu_2023 <- nitrate_analyse_esu_2023 |>
+nitrate_analyse_esu_last_year <- nitrate_analyse_esu_last_year |>
dplyr::mutate(libelle_station = iconv(libelle_station, from = "ISO-8859-1", to = "UTF-8"))
```
@@ -110,19 +62,23 @@ nitrate_analyse_esu_2023 <- nitrate_analyse_esu_2023 |>
```{r create-nitrate_data_ars, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_analyse_esu_2023,
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
+datalibaba::poster_data(data = nitrate_analyse_esu_last_year,
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
schema = "qualite_cours_d_eau",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESU issues de l''API Hub''eau qualite_rivieres : données brutes",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
- schema = "qualite_cours_d_eau",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses \"Nitrates\" ESU issues de l\'\'API Hubeau qualite_rivieres : donn\u00e9es brutes ",
+ last_year
+ ),
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ schema = "qualite_cours_d_eau",
+ db = "si_eau",
+ user = "admin")
```
@@ -132,14 +88,14 @@ datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESU issues de l''AP
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "qualite_cours_d_eau",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
column_name = "date_prelevement",
column_type = "date",
role = "admin")
collectr::modify_column_type(database = "si_eau",
schema = "qualite_cours_d_eau",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
column_name = "date_analyse",
column_type = "date",
role = "admin")
@@ -163,22 +119,51 @@ collectr::archive_table(database = "si_eau",
```{r import_and_merge_tables, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_rivieres_analyse_pc_2023",
+ source_table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
source_schema = "qualite_cours_d_eau",
target_table = "nitrate_qualite_rivieres_analyse_pc",
target_schema = "qualite_cours_d_eau",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ESU API Hub'eau Qualité des cours d'eau (2007-2023)",
- table = "nitrate_qualite_rivieres_analyse_pc",
- schema = "qualite_cours_d_eau",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses Nitrates ESU API Hubeau Qualit\u00e9 des nappes d\'eau souterraine (2007-",
+ last_year,
+ ")"),
+ table = "nitrate_qualite_rivieres_analyse_pc",
+ schema = "qualite_cours_d_eau",
+ db = "si_eau",
+ user = "admin"
+ )
+
+```
+
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es Hubeau ESU",
+ template_dir = "import-des-donnees-hubeau-esu",
+ template_description = "Import des donn\u00e9es Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_hubeau_esu_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
```
```{r development-inflate, eval=FALSE}
# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_hubeau_esu_data.Rmd", vignette_name = "Import des données Hub'eau ESU")
+fusen::inflate(flat_file = "dev/flat_import_hubeau_esu_data.Rmd", vignette_name = "Import des donn\u00e9es Hubeau ESU")
```
diff --git a/dev/flat_insert_ars_into_analyse.Rmd b/dev/flat_insert_ars_into_analyse.Rmd
index 418785fa572f01e03ee940fb552e567bac39a34c..82f341425596057a3665d0c58b20c0d87f867f28 100644
--- a/dev/flat_insert_ars_into_analyse.Rmd
+++ b/dev/flat_insert_ars_into_analyse.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des données de l'ARS dans la table des analyses
## Chargement des données ARS brutes
@@ -33,6 +42,7 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
db = "si_eau",
user = "admin"
)
+
```
## Consolidation des données ARS
@@ -73,7 +83,7 @@ On affecte le code_remarque et la valeur des variables resultat_analyse et limi
```{r mutate-from_ana_param_alpha_resultat, eval=FALSE}
# Ajouter les colonnes code_remarque, resultat_analyse et limite_quantification
nitrate_analyse_ars <- nitrate_analyse_ars |>
- mutate(
+ dplyr::mutate(
# Ajout de la colonne code_remarque selon la condition spécifiée
code_remarque = dplyr::case_when(
stringr::str_starts(ana_param_alpha_resultat, "<") ~ 10,
@@ -89,6 +99,7 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
TRUE ~ NA_character_ # Utilisation de NA pour les valeurs non pertinentes
)
)
+
```
On sélectionne les champs utiles à la table des analyses :
@@ -132,9 +143,9 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -155,57 +166,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelvement_ars, eval=FALSE}
# Joindre les dataframes nitrate_analyse_ars et nitrate_prelevement
nitrate_analyse_ars <- nitrate_analyse_ars |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
-```
-
-```{r function-add_code_analyse, eval=FALSE}
-#' Ajouter une variable code_analyse au dataframe
-#'
-#' @description Cette fonction ajoute une nouvelle variable `code_analyse`
-#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
-#' construite en fonction du paramètre `version` fourni.
-#'
-#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
-#' la variable `code_analyse`.
-#' @param version Une chaîne de caractères représentant la version de la
-#' séquence à utiliser.
-#'
-#' @return Un dataframe avec une nouvelle colonne `code_analyse` contenant
-#' les valeurs de la séquence PostgreSQL.
-#'
-#' @importFrom DBI dbGetQuery dbDisconnect
-#' @importFrom dplyr mutate
-#' @importFrom glue glue
-#' @importFrom datalibaba connect_to_db
-#' @export
-add_code_analyse <- function(dataframe, version) {
- # Établir une connexion à la base de données PostgreSQL
- connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
- # Construire le nom de la séquence
- sequence_name <- glue::glue("nitrates.nitrate_analyse_{version}_code_analyse_seq")
-
- # Initialiser une liste pour stocker les valeurs de la séquence
- code_analyses <- c()
-
- # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
- for (i in 1:nrow(dataframe)) {
- query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_analyse")
- result <- DBI::dbGetQuery(connexion, query)
- code_analyses <- c(code_analyses, result$code_analyse)
- }
-
- # Ajouter la nouvelle variable au dataframe
- dataframe <- dataframe |>
- dplyr::mutate(code_analyse = code_analyses)
-
- # Fermer la connexion à la base de données
- DBI::dbDisconnect(connexion)
-
- return(dataframe)
-}
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
@@ -213,7 +176,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_ars, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_analyse_ars <- add_code_analyse(
- nitrate_analyse_ars, "v0_15")
+ nitrate_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_analyse_ars)
@@ -239,10 +202,10 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
On charge les données consolidées dans un table dédiée :
-```{r insert-into_nitrate_prelevement_v0_15, eval=FALSE}
+```{r insert_into_nitrate_prelevement_version, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_analyse_ars,
- table = "nitrate_analyse_ars_v0_15",
+ table = glue::glue("nitrate_analyse_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -256,14 +219,36 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_ars, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_ars_v0_15",
+ source_table = glue::glue("nitrate_analyse_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses ARS",
+ template_dir = "insertion-des-analyses-ars",
+ template_description = "Insertion des analyses ARS",
+ template_create_dir = TRUE
+)
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_ars_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/dev/flat_insert_ars_into_prelevement.Rmd b/dev/flat_insert_ars_into_prelevement.Rmd
index 4330e91d714547a3ec72b911abca2f491921dc4a..ad96c14ab0db60b674a0a3c15f88a52f87250d4d 100644
--- a/dev/flat_insert_ars_into_prelevement.Rmd
+++ b/dev/flat_insert_ars_into_prelevement.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des données de l'ARS dans la table des prélèvements
## Chargement des données ARS brutes et des stations ESO
@@ -34,7 +43,7 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
)
```
-La table des stations ESO est chargée :
+La table des stations ESO est chargée afin de remplacer ultérieurement le code SISE-EAUX par le code BSS pour les prélèvements ESO :
```{r load-nitrate_station_eso, eval=FALSE}
station_eso <- datalibaba::importer_data(
table = "station_eso",
@@ -111,61 +120,11 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
id_prelevement_motif)
```
-
-```{r function-add_code_prelevement, eval=FALSE}
-#' Ajouter une variable code_prelevement au dataframe
-#'
-#' @description Cette fonction ajoute une nouvelle variable `code_prelevement`
-#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
-#' construite en fonction du paramètre `version` fourni.
-#'
-#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
-#' la variable `code_prelevement`.
-#' @param version Une chaîne de caractères représentant la version de la
-#' séquence à utiliser.
-#'
-#' @return Un dataframe avec une nouvelle colonne `code_prelevement` contenant
-#' les valeurs de la séquence PostgreSQL.
-#'
-#' @importFrom DBI dbGetQuery dbDisconnect
-#' @importFrom dplyr mutate
-#' @importFrom glue glue
-#' @importFrom datalibaba connect_to_db
-#' @export
-add_code_prelevement <- function(dataframe, version) {
- # Établir une connexion à la base de données PostgreSQL
- connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
- # Construire le nom de la séquence
- sequence_name <- glue::glue("nitrates.nitrate_prelevement_{version}_code_prelevement_seq")
-
- # Initialiser une liste pour stocker les valeurs de la séquence
- code_prelevements <- c()
-
- # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
- for (i in 1:nrow(dataframe)) {
- query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_prelevement")
- result <- DBI::dbGetQuery(connexion, query)
- code_prelevements <- c(code_prelevements, result$code_prelevement)
- }
-
- # Ajouter la nouvelle variable au dataframe
- dataframe <- dataframe |>
- dplyr::mutate(code_prelevement = code_prelevements)
-
- # Fermer la connexion à la base de données
- DBI::dbDisconnect(connexion)
-
- return(dataframe)
-}
-
-```
-
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_ars, eval=FALSE}
# Utiliser la fonction add_code_prelevement_ars avec la version souhaitée
nitrate_data_analyse_ars <- add_code_prelevement(
- nitrate_data_analyse_ars, "v0_16")
+ nitrate_data_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_data_analyse_ars)
@@ -176,7 +135,7 @@ On charge les données consolidées dans un table dédiée :
```{r insert-into_nitrate_prelevement_v0_16, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_data_analyse_ars,
- table = "nitrate_prelevement_ars_v0_16",
+ table = glue::glue("nitrate_prelevement_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -190,14 +149,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_ars, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_ars_v0_16",
+ source_table = glue::glue("nitrate_prelevement_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements ARS",
+ template_dir = "insertion-des-prelevements-ars",
+ template_description = "Insertion des pr\u00e9l\u00e8vements ARS",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_ars_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/dev/flat_insert_hubeau_eso_into_analyse.Rmd b/dev/flat_insert_hubeau_eso_into_analyse.Rmd
index d48a9624bce734b03188bdbeff15314e1eb6b9a4..6655e54a96b6a97af9eaa5853783789516f335c8 100644
--- a/dev/flat_insert_hubeau_eso_into_analyse.Rmd
+++ b/dev/flat_insert_hubeau_eso_into_analyse.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des analyses Hub'eau ESO dans la table des analyses
## Chargement des analyses Hub'eau ESO
@@ -94,9 +103,9 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -117,9 +126,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelevement_hubeau_eso, eval=FALSE}
# Joindre les dataframes nitrate_qualite_nappes_analyses et nitrate_prelevement
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
@@ -135,7 +144,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_hubeau_eso, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_nappes_analyses <- add_code_analyse(
- nitrate_qualite_nappes_analyses, "v0_15")
+ nitrate_qualite_nappes_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_analyses)
@@ -162,10 +171,10 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
On charge les données consolidées dans un table dédiée :
-```{r insert-into_nitrate_prelevement_v0_15, eval=FALSE}
+```{r insert-into_nitrate_prelevement_v0_xx, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_nappes_analyses,
- table = "nitrate_analyse_hubeau_eso_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -179,14 +188,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_eso, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_hubeau_eso_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses Hubeau ESO",
+ template_dir = "insertion-des-analyses-hubeau-eso",
+ template_description = "Insertion des analyses Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_eso_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/dev/flat_insert_hubeau_eso_into_prelevement.Rmd b/dev/flat_insert_hubeau_eso_into_prelevement.Rmd
index 9ef92fb731ac4c4a3e08bf95be9769f14693c72d..839cb2d8fbc021c547e26a7b18279433d808aa96 100644
--- a/dev/flat_insert_hubeau_eso_into_prelevement.Rmd
+++ b/dev/flat_insert_hubeau_eso_into_prelevement.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des données Hub'eau ESO dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESO
@@ -89,7 +98,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_hubeau_eso, eval=FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_nappes_prelevements <- add_code_prelevement(
- nitrate_qualite_nappes_prelevements, "v0_16")
+ nitrate_qualite_nappes_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_prelevements)
@@ -99,8 +108,8 @@ print(nitrate_qualite_nappes_prelevements)
On charge les données consolidées dans un table dédiée :
```{r insert-into_nitrate_prelevement_hubeau_eso, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
- table = "nitrate_prelevement_hubeau_eso_v0_16",
+datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
+ table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -114,14 +123,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_eso, eval=FALSE}
# Insérer les prélèvements Hub'eau ESO vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_eso_v0_16",
+ source_table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements Hubeau ESO",
+ template_dir = "insertion-des-prelevements-hubeau-eso",
+ template_description = "Insertion des pr\u00e9l\u00e8vements Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_eso_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/dev/flat_insert_hubeau_esu_into_analyse.Rmd b/dev/flat_insert_hubeau_esu_into_analyse.Rmd
index 69fb3db52e0e967e12ef7405178d5a8b31b69bfc..5c8863a17311cb0e39f59a1f58c45e2bb7683d87 100644
--- a/dev/flat_insert_hubeau_esu_into_analyse.Rmd
+++ b/dev/flat_insert_hubeau_esu_into_analyse.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des analyses Hub'eau ESU dans la table des analyses
## Chargement des analyses Hub'eau ESU
@@ -84,9 +93,9 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -107,9 +116,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelevement_hubeau_esu, eval=FALSE}
# Joindre les dataframes nitrate_qualite_rivieres_analyses et nitrate_prelevement
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
@@ -125,7 +134,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_hubeau_esu, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_rivieres_analyses <- add_code_analyse(
- nitrate_qualite_rivieres_analyses, "v0_15")
+ nitrate_qualite_rivieres_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_analyses)
@@ -152,10 +161,10 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
On charge les données consolidées dans une table dédiée :
-```{r insert-into_nitrate_analyse_hubeau_esu_v0_15, eval=FALSE}
+```{r insert-into_nitrate_analyse_hubeau_esu_version, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_analyses,
- table = "nitrate_analyse_hubeau_esu_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -169,14 +178,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_esu, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_hubeau_esu_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses Hubeau ESU",
+ template_dir = "insertion-des-analyses-hubeau-esu",
+ template_description = "Insertion des analyses Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_esu_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/dev/flat_insert_hubeau_esu_into_prelevement.Rmd b/dev/flat_insert_hubeau_esu_into_prelevement.Rmd
index 40e8a150462c73344a8fb66b17737a5cfda91430..23432b596ffb0413781a3616255565e91f76f73f 100644
--- a/dev/flat_insert_hubeau_esu_into_prelevement.Rmd
+++ b/dev/flat_insert_hubeau_esu_into_prelevement.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,14 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour version
+version <- config$version
+```
+
# Consolidation et insertion des données Hub'eau ESU dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESU
@@ -53,7 +62,7 @@ On ajoute les variables `source` et `nature_eau` :
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::mutate(
source = "Na\u00efades",
- nature_eau = "ESO")
+ nature_eau = "ESU")
```
@@ -91,7 +100,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_hubeau_esu, eval=FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_rivieres_prelevements <- add_code_prelevement(
- nitrate_qualite_rivieres_prelevements, "v0_16")
+ nitrate_qualite_rivieres_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_prelevements)
@@ -102,7 +111,7 @@ On charge les données consolidées dans une table dédiée :
```{r insert-into_nitrate_prelevement_hubeau_esu, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_prelevements,
- table = "nitrate_prelevement_hubeau_esu_v0_16",
+ table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -116,14 +125,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_esu, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_esu_v0_16",
+ source_table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements Hubeau ESU",
+ template_dir = "insertion-des-prelevements-hubeau-esu",
+ template_description = "Insertion des pr\u00e9l\u00e8vements Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_esu_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/creation-des-tables-finales/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/creation-des-tables-et-des-sequences/skeleton/skeleton.Rmd
similarity index 58%
rename from inst/rmarkdown/templates/creation-des-tables-finales/skeleton/skeleton.Rmd
rename to inst/rmarkdown/templates/creation-des-tables-et-des-sequences/skeleton/skeleton.Rmd
index 059dd427c3c457484378c65c1e5b7a82c572769f..28c7dbf2bf50d08f79f928895a97c5978694751c 100644
--- a/inst/rmarkdown/templates/creation-des-tables-finales/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/creation-des-tables-et-des-sequences/skeleton/skeleton.Rmd
@@ -1,5 +1,5 @@
---
-title: "Cr\u00e9ation des tables finales"
+title: "Cr\u00e9ation des tables et des s\u00e9quences"
output: html_document
editor_options:
chunk_output_type: console
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(glue)
library(DBI)
library(datalibaba)
@@ -17,13 +18,20 @@ library(datalibaba)
pkgload::load_all(export_all = FALSE)
```
-# Présentation
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-> Cette page contient la logique métier concernant la création des tables de prélèvements et d'analyses concernant les nitrates.
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+# Création des tables en base
-# Table des prélèvements
+## Création de la table des prélèvements et ajout des commentaires
-```{r function-create_nitrate_prelevement_table}
+```{r function-create_nitrate_prelevement_table, eval=FALSE}
#' Créer une table de prélèvements de nitrates
#'
#' @description Cette fonction crée une table dans une base de données PostgreSQL
@@ -32,12 +40,13 @@ pkgload::load_all(export_all = FALSE)
#'
#' @param version String. Version de la table (par exemple, 'v1').
#' @param last_year Integer. L'année la plus récente incluse dans les données de la table.
-#' @param connexion DBIConnection. Connexion active à la base de données PostgreSQL.
#'
#' @return String. Le script SQL utilisé pour créer la table.
#' @export
#' @importFrom datalibaba connect_to_db
-create_nitrate_prelevement_table <- function(version, last_year, connexion) {
+create_nitrate_prelevement_table <- function(version, last_year) {
+ # Établir une connexion à la base de données PostgreSQL
+ connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
# Génération de la date du jour
date_now <- format(Sys.Date(), "%d/%m/%Y")
@@ -54,6 +63,7 @@ create_nitrate_prelevement_table <- function(version, last_year, connexion) {
date_prelevement date,
heure_prelevement character varying(8),
code_support int,
+ nature_eau character varying(3),
id_usage character varying(3),
id_prelevement_motif character varying(2),
commentaire character varying(254),
@@ -83,6 +93,7 @@ create_nitrate_prelevement_table <- function(version, last_year, connexion) {
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.date_prelevement IS 'Date du pr\u00e9l\u00e8vement';
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.heure_prelevement IS 'Heure du pr\u00e9l\u00e8vement';
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.code_support IS 'Code du support de pr\u00e9l\u00e8vement';
+ COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.nature_eau IS 'Nature de l''eau du pr\u00e9l\u00e8vement (ESO/ESU)';
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.id_usage IS 'Code de l''usage du pr\u00e9l\u00e8vement';
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.id_prelevement_motif IS 'Code du motif du pr\u00e9l\u00e8vement';
COMMENT ON COLUMN nitrates.nitrate_prelevement_{version}.commentaire IS 'Commentaire';
@@ -108,17 +119,15 @@ create_nitrate_prelevement_table <- function(version, last_year, connexion) {
}
```
-```{r examples-create_nitrate_prelevement_table, eval=FALSE}
-# Connexion à la base de données
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
+Création de la table `nitrates.nitrate_prelevement_version` :
+```{r create_nitrate_prelevement_table_version, eval=FALSE}
# Création du script SQL avec la version choisie
-version <- "v0_15"
-last_year <- "2023"
-sql <- create_nitrate_prelevement_table(version, last_year, connexion)
+sql <- create_nitrate_prelevement_table(version, last_year)
```
-```{r function-create_nitrate_analyse_table}
+## Création de la table des analyses et ajout des commentaires
+
+```{r function-create_nitrate_analyse_table, eval=FALSE}
#' Créer une table d'analyses de nitrates
#'
#' @description Cette fonction crée une table dans une base de données PostgreSQL
@@ -127,12 +136,13 @@ sql <- create_nitrate_prelevement_table(version, last_year, connexion)
#'
#' @param version String. Version de la table (par exemple, 'v1').
#' @param last_year Integer. L'année la plus récente incluse dans les données de la table.
-#' @param connexion DBIConnection. Connexion active à la base de données PostgreSQL.
#'
#' @return String. Le script SQL utilisé pour créer la table.
#' @export
#' @importFrom datalibaba connect_to_db
-create_nitrate_analyse_table <- function(version, last_year, connexion) {
+create_nitrate_analyse_table <- function(version, last_year) {
+ # Établir une connexion à la base de données PostgreSQL
+ connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
# Génération de la date du jour
date_now <- format(Sys.Date(), "%d/%m/%Y")
@@ -211,19 +221,140 @@ create_nitrate_analyse_table <- function(version, last_year, connexion) {
```
-```{r examples-create_nitrate_analyse_table, eval=FALSE}
-# Connexion à la base de données
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
+Création de la table `nitrates.nitrate_analyse_version` :
+```{r create_nitrate_analyse_table, eval=FALSE}
# Création du script SQL avec la version choisie
-version <- "v0_15"
-last_year <- "2023"
-sql <- create_nitrate_analyse_table(version, last_year, connexion)
+sql <- create_nitrate_analyse_table(version, last_year)
+```
+
+# Incrémentation des séquences
+
+## Incrémentation de la table des prélèvements
+
+```{r function-add_code_prelevement, eval=FALSE}
+#' Ajouter une variable code_prelevement au dataframe
+#'
+#' @description Cette fonction ajoute une nouvelle variable `code_prelevement`
+#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
+#' construite en fonction du paramètre `version` fourni.
+#'
+#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
+#' la variable `code_prelevement`.
+#' @param version Une chaîne de caractères représentant la version de la
+#' séquence à utiliser.
+#'
+#' @return Un dataframe avec une nouvelle colonne `code_prelevement` contenant
+#' les valeurs de la séquence PostgreSQL.
+#'
+#' @importFrom DBI dbGetQuery dbDisconnect
+#' @importFrom dplyr mutate
+#' @importFrom glue glue
+#' @importFrom datalibaba connect_to_db
+#' @export
+add_code_prelevement <- function(dataframe, version) {
+ # Établir une connexion à la base de données PostgreSQL
+ connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
+
+ # Construire le nom de la séquence
+ sequence_name <- glue::glue("nitrates.nitrate_prelevement_{version}_code_prelevement_seq")
+
+ # Initialiser une liste pour stocker les valeurs de la séquence
+ code_prelevements <- c()
+
+ # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
+ for (i in 1:nrow(dataframe)) {
+ query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_prelevement")
+ result <- DBI::dbGetQuery(connexion, query)
+ code_prelevements <- c(code_prelevements, result$code_prelevement)
+ }
+
+ # Ajouter la nouvelle variable au dataframe
+ dataframe <- dataframe |>
+ dplyr::mutate(code_prelevement = code_prelevements)
+
+ # Fermer la connexion à la base de données
+ DBI::dbDisconnect(connexion)
+
+ return(dataframe)
+}
+
```
+## Incrémentation de la table des analyses
+
+```{r function-add_code_analyse, eval=FALSE}
+#' Ajouter une variable code_analyse au dataframe
+#'
+#' @description Cette fonction ajoute une nouvelle variable `code_analyse`
+#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
+#' construite en fonction du paramètre `version` fourni.
+#'
+#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
+#' la variable `code_analyse`.
+#' @param version Une chaîne de caractères représentant la version de la
+#' séquence à utiliser.
+#'
+#' @return Un dataframe avec une nouvelle colonne `code_analyse` contenant
+#' les valeurs de la séquence PostgreSQL.
+#'
+#' @importFrom DBI dbGetQuery dbDisconnect
+#' @importFrom dplyr mutate
+#' @importFrom glue glue
+#' @importFrom datalibaba connect_to_db
+#' @export
+add_code_analyse <- function(dataframe, version) {
+ # Établir une connexion à la base de données PostgreSQL
+ connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
+
+ # Construire le nom de la séquence
+ sequence_name <- glue::glue("nitrates.nitrate_analyse_{version}_code_analyse_seq")
+
+ # Initialiser une liste pour stocker les valeurs de la séquence
+ code_analyses <- c()
+
+ # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
+ for (i in 1:nrow(dataframe)) {
+ query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_analyse")
+ result <- DBI::dbGetQuery(connexion, query)
+ code_analyses <- c(code_analyses, result$code_analyse)
+ }
+
+ # Ajouter la nouvelle variable au dataframe
+ dataframe <- dataframe |>
+ dplyr::mutate(code_analyse = code_analyses)
+
+ # Fermer la connexion à la base de données
+ DBI::dbDisconnect(connexion)
+
+ return(dataframe)
+}
+
+```
+
+```{r development-skeleton, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Cr\u00e9ation des tables et des s\u00e9quences",
+ template_dir = "creation-des-tables-et-des-sequences",
+ template_description = "Cr\u00e9ation des tables et des s\u00e9quences",
+ template_create_dir = TRUE
+)
+
+# Définir les chemins source et destination
+source_file <- "dev/flat_create_tables_sequences.Rmd"
+destination_dir <- "inst/rmarkdown/templates/creation-des-tables-et-des-sequences/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_create_tables.Rmd", vignette_name = "Cr\u00e9ation des tables finales")
+fusen::inflate(flat_file = "dev/flat_create_tables_sequences.Rmd", vignette_name = "Cr\u00e9ation des tables et des s\u00e9quences")
```
diff --git a/inst/rmarkdown/templates/creation-des-tables-et-des-sequences/template.yaml b/inst/rmarkdown/templates/creation-des-tables-et-des-sequences/template.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2f079626722b53512c80bc039c1a4ba7eda4e390
--- /dev/null
+++ b/inst/rmarkdown/templates/creation-des-tables-et-des-sequences/template.yaml
@@ -0,0 +1,4 @@
+name: Création des tables et des séquences
+description: >
+ Création des tables et des séquences
+create_dir: TRUE
diff --git a/inst/rmarkdown/templates/creation-des-tables-finales/template.yaml b/inst/rmarkdown/templates/creation-des-tables-finales/template.yaml
deleted file mode 100644
index d8b53064db6c365bd1dcf69074f12d12e338ed6f..0000000000000000000000000000000000000000
--- a/inst/rmarkdown/templates/creation-des-tables-finales/template.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-name: Création des tables finales
-description: >
- Création des tables finales
-create_dir: FALSE
diff --git a/inst/rmarkdown/templates/import-des-donnees-ars/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/import-des-donnees-ars/skeleton/skeleton.Rmd
index dfbd8ecec41bc739878891d78fb0dddcec6795d3..bd334bcef70eeaddbd448b03afcd4c42fd2c4175 100644
--- a/inst/rmarkdown/templates/import-des-donnees-ars/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/import-des-donnees-ars/skeleton/skeleton.Rmd
@@ -1,5 +1,5 @@
---
-title: "Import des données ARS"
+title: "Import des donn\u00e9es ARS"
output: html_document
editor_options:
chunk_output_type: console
@@ -7,6 +7,8 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
+library(glue)
library(xlsx)
library(datalibaba)
library(RPostgreSQL)
@@ -20,56 +22,29 @@ library(dplyr)
pkgload::load_all(export_all = FALSE)
```
-# Présentation
-
-Cette page contient la logique métier concernant l'import des données brutes
-fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
-Nitrates
-
-# Connexion à la base de données PostgreSQL
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+filepath_data_ars <- config$filepath_data_ars
```
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
-
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
-```
-
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "nitrates"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
+# Présentation
-```
+Cette page contient la logique métier concernant l'import des données brutes
+fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
+Nitrates.
# Import des données de l'ARS dans un dataframe par millésime
Les données sont transmies au format XLSX.
-```{r import_data_ars_2023, eval=FALSE}
-data_ars_2023 <- collectr::import_xlsx(
- filepath = "T:\\datalab\\SRNP_DEMA_SI_EAU\\NITRATES\\DONNEES_CLIENT\\SOURCES\\ARS\\2024_06\\Nitrates 2023 pour DREAL EPNT4 2024-05-31.xlsx",
+```{r import_data_ars_last_year, eval=FALSE}
+data_ars_last_year <- collectr::import_xlsx(
+ filepath = filepath_data_ars,
sheet = 1,
row = 2)
@@ -79,16 +54,16 @@ data_ars_2023 <- collectr::import_xlsx(
```{r create-nitrate_data_ars, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = data_ars_2023,
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::poster_data(data = data_ars_last_year,
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2023)",
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (", last_year, ")"),
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
user = "admin")
@@ -101,7 +76,7 @@ datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2023)",
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "nitrates",
- table = "nitrate_data_analyse_ars_2023",
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
column_name = "plv_date",
column_type = "date",
role = "admin")
@@ -125,23 +100,46 @@ collectr::archive_table(database = "si_eau",
```{r import_and_merge_tables, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_data_analyse_ars_2023",
+ source_table = glue::glue("nitrate_data_analyse_ars_", last_year),
source_schema = "nitrates",
target_table = "nitrate_data_analyse_ars",
target_schema = "nitrates",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2007-2023)",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (2007-", last_year, ")",
table = "nitrate_data_analyse_ars",
schema = "nitrates",
db = "si_eau",
user = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es ARS",
+ template_dir = "import-des-donnees-ars",
+ template_description = "Import des donn\u00e9es ARS",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_ars_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_ars_data.Rmd", vignette_name = "Import des données ARS")
+fusen::inflate(flat_file = "dev/flat_import_ars_data.Rmd", vignette_name = "Import des donn\u00e9es ARS")
```
diff --git a/inst/rmarkdown/templates/import-des-donnees-hub-eau-eso/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/import-des-donnees-hub-eau-eso/skeleton/skeleton.Rmd
deleted file mode 100644
index b9a4d3116b2a95ddf090229f57572d55034e282b..0000000000000000000000000000000000000000
--- a/inst/rmarkdown/templates/import-des-donnees-hub-eau-eso/skeleton/skeleton.Rmd
+++ /dev/null
@@ -1,170 +0,0 @@
----
-title: "Import des données Hub'eau ESO"
-output: html_document
-editor_options:
- chunk_output_type: console
----
-
-```{r development, include=FALSE}
-library(testthat)
-library(hubeau)
-library(datalibaba)
-library(RPostgreSQL)
-library(sf)
-library(collectr)
-library(dplyr)
-```
-
-```{r development-1}
-# Load already included functions
-pkgload::load_all(export_all = FALSE)
-```
-
-# Présentation
-
-> Cette page contient la logique métier concernant l'import des données de
-l'[API Hub'eau "Qualité des nappes d'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes) dans le cadre du projet Nitrates
-
-# Connexion à la base de données PostgreSQL
-
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
-
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
-```
-
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "qualite_cours_d_eau"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
-
-```
-
-# Import des données Hub'eau ESU dans un dataframe par millésime
-
-On utilise la fonction `get_qualite_nappes_analyses()` du package [{hubeau}](https://github.com/inrae/hubeau)
-
-```{r create-nitrate_analyse_esu_2020, eval=FALSE}
-nitrate_analyse_eso_2020 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2020-01-01",
- date_fin_prelevement = "2020-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2021, eval=FALSE}
-nitrate_analyse_eso_2021 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2021-01-01",
- date_fin_prelevement = "2021-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2022, eval=FALSE}
-nitrate_analyse_eso_2022 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2022-01-01",
- date_fin_prelevement = "2022-12-31",
- size = "5000")
-
-```
-
-```{r create-nitrate_analyse_esu_2023, eval=FALSE}
-nitrate_analyse_eso_2023 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2023-01-01",
- date_fin_prelevement = "2023-12-31",
- size = "5000")
-```
-
-# Création d'une table pour le nouveau millésime
-
-```{r create-nitrate_data_ars, eval=FALSE}
-# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_analyse_eso_2023,
- table = "nitrate_qualite_nappes_analyses_2023",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- overwrite = TRUE,
- user = "admin")
-
-# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESO issues de l''API Hub''eau qualite_nappes : données brutes",
- table = "nitrate_qualite_nappes_analyses_2023",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
-
-```
-
-# Modification du type des champs si besoin
-
-```{r modify_column_type, eval=FALSE}
-# Modifier le type de colonne pour les champs de date
-collectr::modify_column_type(database = "si_eau",
- schema = "qualite_nappes_eau_souterraine",
- table = "nitrate_qualite_nappes_analyses_2023",
- column_name = "date_debut_prelevement",
- column_type = "date",
- role = "admin")
-
-```
-
-# Archivage de la version précédente de la table
-
-```{r archive_table, eval=FALSE}
-# Archiver la version actuelle de la table avec tous les millésimes
-collectr::archive_table(database = "si_eau",
- schema = "qualite_nappes_eau_souterraine",
- new_schema = "zz_archives",
- table = "nitrate_qualite_nappes_analyses",
- role = "admin")
-
-```
-
-# Insertion des données du nouveau millésime en base dans la table globale
-
-```{r import_and_merge_tables, eval=FALSE}
-# Insérer les données de la table du dernier millésime vers la table complète
-collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_nappes_analyses_2023",
- source_schema = "qualite_nappes_eau_souterraine",
- target_table = "nitrate_qualite_nappes_analyses",
- target_schema = "qualite_nappes_eau_souterraine",
- role = "admin")
-
-# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ESO API Hub'eau Qualité des nappes d'eau souterraine (2007-2023)",
- table = "nitrate_qualite_nappes_analyses",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
-```
-
-```{r development-inflate, eval=FALSE}
-# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
-# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_hubeau_eso_data.Rmd", vignette_name = "Import des données Hub'eau ESO")
-```
diff --git a/inst/rmarkdown/templates/import-des-donnees-hub-eau-esu/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/import-des-donnees-hub-eau-esu/skeleton/skeleton.Rmd
deleted file mode 100644
index df26f047b69a81404c2f3c78d244cc51c567fc8a..0000000000000000000000000000000000000000
--- a/inst/rmarkdown/templates/import-des-donnees-hub-eau-esu/skeleton/skeleton.Rmd
+++ /dev/null
@@ -1,184 +0,0 @@
----
-title: "Import des données Hub'eau ESU"
-output: html_document
-editor_options:
- chunk_output_type: console
----
-
-```{r development, include=FALSE}
-library(testthat)
-library(hubeau)
-library(datalibaba)
-library(RPostgreSQL)
-library(sf)
-library(collectr)
-library(dplyr)
-```
-
-```{r development-1}
-# Load already included functions
-pkgload::load_all(export_all = FALSE)
-```
-
-# Présentation
-
-> Cette page contient la logique métier concernant l'import des données de
-l'[API Hub'eau "Qualité des cours d'eau"](https://hubeau.eaufrance.fr/page/api-qualite-cours-deau) dans le cadre du projet Nitrates
-
-# Connexion à la base de données PostgreSQL
-
-```{r connect_to_db, eval=FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-
-```{r list_schemas, eval=FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
-
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
-
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
-```
-
-```{r list_tables, eval=FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "qualite_cours_d_eau"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
-
-```
-
-# Import des données Hub'eau ESU dans un dataframe par millésime
-
-On utilise la fonction `get_qualite_rivieres_analyse()` du package [{hubeau}](https://github.com/inrae/hubeau)
-
-```{r create-nitrate_analyse_esu_2020, eval=FALSE}
-nitrate_analyse_esu_2020 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2020-01-01",
- date_fin_prelevement = "2020-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2021, eval=FALSE}
-nitrate_analyse_esu_2021 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2021-01-01",
- date_fin_prelevement = "2021-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2022, eval=FALSE}
-nitrate_analyse_esu_2022 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2022-01-01",
- date_fin_prelevement = "2022-12-31",
- size = "5000")
-
-```
-
-```{r create-nitrate_analyse_esu_2023, eval=FALSE}
-nitrate_analyse_esu_2023 <- hubeau::get_qualite_rivieres_analyse(code_parametre = "1340",
- code_region = "52",
- date_debut_prelevement = "2023-01-01",
- date_fin_prelevement = "2023-12-31",
- size = "5000")
-```
-
-# Correction de l'encodage si nécessaire pour certaines variables
-
-```{r change-encoding, eval=FALSE}
-nitrate_analyse_esu_2023 <- nitrate_analyse_esu_2023 |>
- dplyr::mutate(libelle_station = iconv(libelle_station, from = "ISO-8859-1", to = "UTF-8"))
-```
-
-# Création d'une table pour le nouveau millésime
-
-```{r create-nitrate_data_ars, eval=FALSE}
-# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_analyse_esu_2023,
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
- schema = "qualite_cours_d_eau",
- db = "si_eau",
- overwrite = TRUE,
- user = "admin")
-
-# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESU issues de l''API Hub''eau qualite_rivieres : données brutes",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
- schema = "qualite_cours_d_eau",
- db = "si_eau",
- user = "admin")
-
-```
-
-# Modification du type des champs si besoin
-
-```{r modify_column_type, eval=FALSE}
-# Modifier le type de colonne pour les champs de date
-collectr::modify_column_type(database = "si_eau",
- schema = "qualite_cours_d_eau",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
- column_name = "date_prelevement",
- column_type = "date",
- role = "admin")
-
-collectr::modify_column_type(database = "si_eau",
- schema = "qualite_cours_d_eau",
- table = "nitrate_qualite_rivieres_analyse_pc_2023",
- column_name = "date_analyse",
- column_type = "date",
- role = "admin")
-
-```
-
-# Archivage de la version précédente de la table
-
-```{r archive_table, eval=FALSE}
-# Archiver la version actuelle de la table avec tous les millésimes
-collectr::archive_table(database = "si_eau",
- schema = "qualite_cours_d_eau",
- new_schema = "zz_archives",
- table = "nitrate_qualite_rivieres_analyse_pc",
- role = "admin")
-
-```
-
-# Insertion des données du nouveau millésime en base dans la table globale
-
-```{r import_and_merge_tables, eval=FALSE}
-# Insérer les données de la table du dernier millésime vers la table complète
-collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_rivieres_analyse_pc_2023",
- source_schema = "qualite_cours_d_eau",
- target_table = "nitrate_qualite_rivieres_analyse_pc",
- target_schema = "qualite_cours_d_eau",
- role = "admin")
-
-# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ESU API Hub'eau Qualité des cours d'eau (2007-2023)",
- table = "nitrate_qualite_rivieres_analyse_pc",
- schema = "qualite_cours_d_eau",
- db = "si_eau",
- user = "admin")
-```
-
-```{r development-inflate, eval=FALSE}
-# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
-# Execute in the console directly
-fusen::inflate(flat_file = "dev/flat_import_hubeau_esu_data.Rmd", vignette_name = "Import des données Hub'eau ESU")
-```
diff --git a/inst/rmarkdown/templates/import-des-donnees-hubeau-eso/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/import-des-donnees-hubeau-eso/skeleton/skeleton.Rmd
new file mode 100644
index 0000000000000000000000000000000000000000..73b25305daa36f6eb160731cc975d843a2cfbb48
--- /dev/null
+++ b/inst/rmarkdown/templates/import-des-donnees-hubeau-eso/skeleton/skeleton.Rmd
@@ -0,0 +1,154 @@
+---
+title: "Import des donn\u00e9es Hubeau ESO"
+output: html_document
+editor_options:
+ chunk_output_type: console
+---
+
+```{r development, include=FALSE}
+library(testthat)
+library(yaml)
+library(glue)
+library(hubeau)
+library(datalibaba)
+library(RPostgreSQL)
+library(sf)
+library(collectr)
+library(dplyr)
+```
+
+```{r development-1}
+# Load already included functions
+pkgload::load_all(export_all = FALSE)
+```
+
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour last_year
+last_year <- config$last_year
+```
+
+# Présentation
+
+Cette page contient la logique métier concernant l'import des données de
+l'[API Hub'eau "Qualit\u00e9 des nappes d\'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes)
+dans le cadre du projet Nitrates.
+
+# Import des données Hub'eau ESU dans un dataframe par millésime
+
+On utilise la fonction `get_qualite_nappes_analyses()` du package [{hubeau}](https://github.com/inrae/hubeau)
+
+```{r create-nitrate_analyse_esu_last_year, eval=FALSE}
+nitrate_analyse_eso_last_year <- hubeau::get_qualite_nappes_analyses(
+ code_param = "1340",
+ code_region = "52",
+ date_debut_prelevement = glue::glue(last_year, "-01-01"),
+ date_fin_prelevement = glue::glue(last_year, "-12-31"),
+ size = "5000"
+ )
+
+```
+
+# Création d'une table pour le nouveau millésime
+
+```{r create-nitrate_data_ars, eval=FALSE}
+# Charger les données dans une nouvelle table en base
+datalibaba::poster_data(data = nitrate_analyse_eso_last_year,
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ overwrite = TRUE,
+ user = "admin")
+
+# Ajouter un commentaire sur la table
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses \"Nitrates\" ESO issues de l\'\'API Hubeau qualite_nappes : donn\u00e9es brutes ",
+ last_year),
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin")
+
+```
+
+# Modification du type des champs si besoin
+
+```{r modify_column_type, eval=FALSE}
+# Modifier le type de colonne pour les champs de date
+collectr::modify_column_type(database = "si_eau",
+ schema = "qualite_nappes_eau_souterraine",
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ column_name = "date_debut_prelevement",
+ column_type = "date",
+ role = "admin")
+
+```
+
+# Archivage de la version précédente de la table
+
+```{r archive_table, eval=FALSE}
+# Archiver la version actuelle de la table avec tous les millésimes
+collectr::archive_table(database = "si_eau",
+ schema = "qualite_nappes_eau_souterraine",
+ new_schema = "zz_archives",
+ table = "nitrate_qualite_nappes_analyses",
+ role = "admin")
+
+```
+
+# Insertion des données du nouveau millésime en base dans la table globale
+
+```{r import_and_merge_tables, eval=FALSE}
+# Insérer les données de la table du dernier millésime vers la table complète
+collectr::import_and_merge_tables(database = "si_eau",
+ source_table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ source_schema = "qualite_nappes_eau_souterraine",
+ target_table = "nitrate_qualite_nappes_analyses",
+ target_schema = "qualite_nappes_eau_souterraine",
+ role = "admin")
+
+# Actualiser le commentaire sur la table
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses Nitrates ESO API Hubeau Qualit\u00e9 des nappes d\'eau souterraine (2007-",
+ last_year,
+ ")"),
+ table = "nitrate_qualite_nappes_analyses",
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin"
+ )
+
+```
+
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es Hubeau ESO",
+ template_dir = "import-des-donnees-hubeau-eso",
+ template_description = "Import des donn\u00e9es Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_hubeau_eso_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
+```{r development-inflate, eval=FALSE}
+# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
+# Execute in the console directly
+fusen::inflate(flat_file = "dev/flat_import_hubeau_eso_data.Rmd", vignette_name = "Import des donn\u00e9es Hubeau ESO")
+```
diff --git a/inst/rmarkdown/templates/import-des-donnees-hub-eau-eso/template.yaml b/inst/rmarkdown/templates/import-des-donnees-hubeau-eso/template.yaml
similarity index 100%
rename from inst/rmarkdown/templates/import-des-donnees-hub-eau-eso/template.yaml
rename to inst/rmarkdown/templates/import-des-donnees-hubeau-eso/template.yaml
diff --git a/inst/rmarkdown/templates/import-des-donnees-hubeau-esu/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/import-des-donnees-hubeau-esu/skeleton/skeleton.Rmd
new file mode 100644
index 0000000000000000000000000000000000000000..c023b7b3cbfc79a1895cd98870342e0db5c5d80d
--- /dev/null
+++ b/inst/rmarkdown/templates/import-des-donnees-hubeau-esu/skeleton/skeleton.Rmd
@@ -0,0 +1,169 @@
+---
+title: "Import des donn\u00e9es Hubeau ESU"
+output: html_document
+editor_options:
+ chunk_output_type: console
+---
+
+```{r development, include=FALSE}
+library(testthat)
+library(yaml)
+library(glue)
+library(hubeau)
+library(datalibaba)
+library(RPostgreSQL)
+library(sf)
+library(collectr)
+library(dplyr)
+```
+
+```{r development-1}
+# Load already included functions
+pkgload::load_all(export_all = FALSE)
+```
+
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder à la valeur pour last_year
+last_year <- config$last_year
+```
+
+# Présentation
+
+Cette page contient la logique métier concernant l'import des données de
+l'[API Hub'eau "Qualit\u00e9 des cours d\'eau"](https://hubeau.eaufrance.fr/page/api-qualite-cours-deau)
+dans le cadre du projet Nitrates.
+
+# Import des données Hub'eau ESU dans un dataframe par millésime
+
+On utilise la fonction `get_qualite_rivieres_analyse()` du package [{hubeau}](https://github.com/inrae/hubeau)
+
+```{r create-nitrate_analyse_esu_last_year, eval=FALSE}
+nitrate_analyse_esu_last_year <- hubeau::get_qualite_rivieres_analyse(
+ code_parametre = "1340",
+ code_region = "52",
+ date_debut_prelevement = glue::glue(last_year, "-01-01"),
+ date_fin_prelevement = glue::glue(last_year, "-12-31"),
+ size = "5000"
+)
+
+```
+
+# Correction de l'encodage si nécessaire pour certaines variables
+
+```{r change-encoding, eval=FALSE}
+nitrate_analyse_esu_last_year <- nitrate_analyse_esu_last_year |>
+ dplyr::mutate(libelle_station = iconv(libelle_station, from = "ISO-8859-1", to = "UTF-8"))
+```
+
+# Création d'une table pour le nouveau millésime
+
+```{r create-nitrate_data_ars, eval=FALSE}
+# Charger les données dans une nouvelle table en base
+datalibaba::poster_data(data = nitrate_analyse_esu_last_year,
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ schema = "qualite_cours_d_eau",
+ db = "si_eau",
+ overwrite = TRUE,
+ user = "admin")
+
+# Ajouter un commentaire sur la table
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses \"Nitrates\" ESU issues de l\'\'API Hubeau qualite_rivieres : donn\u00e9es brutes ",
+ last_year
+ ),
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ schema = "qualite_cours_d_eau",
+ db = "si_eau",
+ user = "admin")
+
+```
+
+# Modification du type des champs si besoin
+
+```{r modify_column_type, eval=FALSE}
+# Modifier le type de colonne pour les champs de date
+collectr::modify_column_type(database = "si_eau",
+ schema = "qualite_cours_d_eau",
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ column_name = "date_prelevement",
+ column_type = "date",
+ role = "admin")
+
+collectr::modify_column_type(database = "si_eau",
+ schema = "qualite_cours_d_eau",
+ table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ column_name = "date_analyse",
+ column_type = "date",
+ role = "admin")
+
+```
+
+# Archivage de la version précédente de la table
+
+```{r archive_table, eval=FALSE}
+# Archiver la version actuelle de la table avec tous les millésimes
+collectr::archive_table(database = "si_eau",
+ schema = "qualite_cours_d_eau",
+ new_schema = "zz_archives",
+ table = "nitrate_qualite_rivieres_analyse_pc",
+ role = "admin")
+
+```
+
+# Insertion des données du nouveau millésime en base dans la table globale
+
+```{r import_and_merge_tables, eval=FALSE}
+# Insérer les données de la table du dernier millésime vers la table complète
+collectr::import_and_merge_tables(database = "si_eau",
+ source_table = glue::glue("nitrate_qualite_rivieres_analyse_pc_", last_year),
+ source_schema = "qualite_cours_d_eau",
+ target_table = "nitrate_qualite_rivieres_analyse_pc",
+ target_schema = "qualite_cours_d_eau",
+ role = "admin")
+
+# Actualiser le commentaire sur la table
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses Nitrates ESU API Hubeau Qualit\u00e9 des nappes d\'eau souterraine (2007-",
+ last_year,
+ ")"),
+ table = "nitrate_qualite_rivieres_analyse_pc",
+ schema = "qualite_cours_d_eau",
+ db = "si_eau",
+ user = "admin"
+ )
+
+```
+
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Import des donn\u00e9es Hubeau ESU",
+ template_dir = "import-des-donnees-hubeau-esu",
+ template_description = "Import des donn\u00e9es Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_import_hubeau_esu_data.Rmd"
+destination_dir <- "inst/rmarkdown/templates/import-des-donnees-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
+```{r development-inflate, eval=FALSE}
+# Keep eval=FALSE to avoid infinite loop in case you hit the knit button
+# Execute in the console directly
+fusen::inflate(flat_file = "dev/flat_import_hubeau_esu_data.Rmd", vignette_name = "Import des donn\u00e9es Hubeau ESU")
+```
diff --git a/inst/rmarkdown/templates/import-des-donnees-hub-eau-esu/template.yaml b/inst/rmarkdown/templates/import-des-donnees-hubeau-esu/template.yaml
similarity index 100%
rename from inst/rmarkdown/templates/import-des-donnees-hub-eau-esu/template.yaml
rename to inst/rmarkdown/templates/import-des-donnees-hubeau-esu/template.yaml
diff --git a/inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton/skeleton.Rmd
index 418785fa572f01e03ee940fb552e567bac39a34c..039d2bf4b9a1dea266005d5d6f4f61f1a26cd818 100644
--- a/inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,16 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+
+```
+
# Consolidation et insertion des données de l'ARS dans la table des analyses
## Chargement des données ARS brutes
@@ -33,6 +44,7 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
db = "si_eau",
user = "admin"
)
+
```
## Consolidation des données ARS
@@ -73,7 +85,7 @@ On affecte le code_remarque et la valeur des variables resultat_analyse et limi
```{r mutate-from_ana_param_alpha_resultat, eval=FALSE}
# Ajouter les colonnes code_remarque, resultat_analyse et limite_quantification
nitrate_analyse_ars <- nitrate_analyse_ars |>
- mutate(
+ dplyr::mutate(
# Ajout de la colonne code_remarque selon la condition spécifiée
code_remarque = dplyr::case_when(
stringr::str_starts(ana_param_alpha_resultat, "<") ~ 10,
@@ -89,6 +101,7 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
TRUE ~ NA_character_ # Utilisation de NA pour les valeurs non pertinentes
)
)
+
```
On sélectionne les champs utiles à la table des analyses :
@@ -132,9 +145,9 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -155,57 +168,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelvement_ars, eval=FALSE}
# Joindre les dataframes nitrate_analyse_ars et nitrate_prelevement
nitrate_analyse_ars <- nitrate_analyse_ars |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
-```
-
-```{r function-add_code_analyse, eval=FALSE}
-#' Ajouter une variable code_analyse au dataframe
-#'
-#' @description Cette fonction ajoute une nouvelle variable `code_analyse`
-#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
-#' construite en fonction du paramètre `version` fourni.
-#'
-#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
-#' la variable `code_analyse`.
-#' @param version Une chaîne de caractères représentant la version de la
-#' séquence à utiliser.
-#'
-#' @return Un dataframe avec une nouvelle colonne `code_analyse` contenant
-#' les valeurs de la séquence PostgreSQL.
-#'
-#' @importFrom DBI dbGetQuery dbDisconnect
-#' @importFrom dplyr mutate
-#' @importFrom glue glue
-#' @importFrom datalibaba connect_to_db
-#' @export
-add_code_analyse <- function(dataframe, version) {
- # Établir une connexion à la base de données PostgreSQL
- connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
- # Construire le nom de la séquence
- sequence_name <- glue::glue("nitrates.nitrate_analyse_{version}_code_analyse_seq")
-
- # Initialiser une liste pour stocker les valeurs de la séquence
- code_analyses <- c()
-
- # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
- for (i in 1:nrow(dataframe)) {
- query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_analyse")
- result <- DBI::dbGetQuery(connexion, query)
- code_analyses <- c(code_analyses, result$code_analyse)
- }
-
- # Ajouter la nouvelle variable au dataframe
- dataframe <- dataframe |>
- dplyr::mutate(code_analyse = code_analyses)
-
- # Fermer la connexion à la base de données
- DBI::dbDisconnect(connexion)
-
- return(dataframe)
-}
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
@@ -213,7 +178,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_ars, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_analyse_ars <- add_code_analyse(
- nitrate_analyse_ars, "v0_15")
+ nitrate_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_analyse_ars)
@@ -239,10 +204,10 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
On charge les données consolidées dans un table dédiée :
-```{r insert-into_nitrate_prelevement_v0_15, eval=FALSE}
+```{r insert_into_nitrate_prelevement_version, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_analyse_ars,
- table = "nitrate_analyse_ars_v0_15",
+ table = glue::glue("nitrate_analyse_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -256,14 +221,36 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_ars, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_ars_v0_15",
+ source_table = glue::glue("nitrate_analyse_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses ARS",
+ template_dir = "insertion-des-analyses-ars",
+ template_description = "Insertion des analyses ARS",
+ template_create_dir = TRUE
+)
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_ars_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton/skeleton.Rmd
index d48a9624bce734b03188bdbeff15314e1eb6b9a4..5b93e1b7a3b31485b3fe49cbc3234d67a4ae4eaa 100644
--- a/inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,15 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
# Consolidation et insertion des analyses Hub'eau ESO dans la table des analyses
## Chargement des analyses Hub'eau ESO
@@ -94,9 +104,9 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -117,9 +127,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelevement_hubeau_eso, eval=FALSE}
# Joindre les dataframes nitrate_qualite_nappes_analyses et nitrate_prelevement
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
@@ -135,7 +145,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_hubeau_eso, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_nappes_analyses <- add_code_analyse(
- nitrate_qualite_nappes_analyses, "v0_15")
+ nitrate_qualite_nappes_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_analyses)
@@ -162,10 +172,10 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
On charge les données consolidées dans un table dédiée :
-```{r insert-into_nitrate_prelevement_v0_15, eval=FALSE}
+```{r insert-into_nitrate_prelevement_v0_xx, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_nappes_analyses,
- table = "nitrate_analyse_hubeau_eso_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -179,14 +189,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_eso, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_hubeau_eso_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer initialement l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses Hubeau ESO",
+ template_dir = "insertion-des-analyses-hubeau-eso",
+ template_description = "Insertion des analyses Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_eso_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton/skeleton.Rmd
index 69fb3db52e0e967e12ef7405178d5a8b31b69bfc..a56efcdfab55f3d796491f60e1c7186872b233a5 100644
--- a/inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,15 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
# Consolidation et insertion des analyses Hub'eau ESU dans la table des analyses
## Chargement des analyses Hub'eau ESU
@@ -84,9 +94,9 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
La table des prélèvements est chargée :
```{r load-nitrate_prelevement, eval=FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -107,9 +117,9 @@ On joint le dataframe des prélèvements pour récupérer la variable code_prele
```{r join-prelevement_hubeau_esu, eval=FALSE}
# Joindre les dataframes nitrate_qualite_rivieres_analyses et nitrate_prelevement
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
@@ -125,7 +135,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_analyse_hubeau_esu, eval=FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_rivieres_analyses <- add_code_analyse(
- nitrate_qualite_rivieres_analyses, "v0_15")
+ nitrate_qualite_rivieres_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_analyses)
@@ -152,10 +162,10 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
On charge les données consolidées dans une table dédiée :
-```{r insert-into_nitrate_analyse_hubeau_esu_v0_15, eval=FALSE}
+```{r insert-into_nitrate_analyse_hubeau_esu_version, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_analyses,
- table = "nitrate_analyse_hubeau_esu_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -169,14 +179,37 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_esu, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_hubeau_esu_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton-dir, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des analyses Hubeau ESU",
+ template_dir = "insertion-des-analyses-hubeau-esu",
+ template_description = "Insertion des analyses Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+```
+
+```{r development-skeleton-copy, eval=FALSE}
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_esu_into_analyse.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-analyses-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton/skeleton.Rmd
index 2507cc574230d42bc5c14a05aad6a9cef405ed5c..2931a8d2f8536bd4fc187df47db211f3be9a5c4a 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,9 +21,18 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
# Consolidation et insertion des données de l'ARS dans la table des prélèvements
-## Chargement des données ARS brutes
+## Chargement des données ARS brutes et des stations ESO
La table des données brutes Nitrates de l'ARS est chargée :
```{r load-nitrate_data_analyse_ars, eval=FALSE}
@@ -34,6 +44,16 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
)
```
+La table des stations ESO est chargée afin de remplacer ultérieurement le code SISE-EAUX par le code BSS pour les prélèvements ESO :
+```{r load-nitrate_station_eso, eval=FALSE}
+station_eso <- datalibaba::importer_data(
+ table = "station_eso",
+ schema = "stations",
+ db = "si_eau",
+ user = "admin"
+)
+```
+
## Consolidation des données ARS
On ajoute les variables `source` et `code_support` :
@@ -63,6 +83,7 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
date_prelevement = plv_date,
heure_prelevement = plv_heure,
code_support,
+ nature_eau,
id_usage = usage,
id_prelevement_motif = plv_motif)
@@ -76,60 +97,35 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
-```{r function-add_code_prelevement, eval=FALSE}
-#' Ajouter une variable code_prelevement au dataframe
-#'
-#' @description Cette fonction ajoute une nouvelle variable `code_prelevement`
-#' au dataframe en utilisant une séquence PostgreSQL dynamique. La séquence est
-#' construite en fonction du paramètre `version` fourni.
-#'
-#' @param dataframe Un dataframe contenant les données sur lesquelles ajouter
-#' la variable `code_prelevement`.
-#' @param version Une chaîne de caractères représentant la version de la
-#' séquence à utiliser.
-#'
-#' @return Un dataframe avec une nouvelle colonne `code_prelevement` contenant
-#' les valeurs de la séquence PostgreSQL.
-#'
-#' @importFrom DBI dbGetQuery dbDisconnect
-#' @importFrom dplyr mutate
-#' @importFrom glue glue
-#' @importFrom datalibaba connect_to_db
-#' @export
-add_code_prelevement <- function(dataframe, version) {
- # Établir une connexion à la base de données PostgreSQL
- connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
- # Construire le nom de la séquence
- sequence_name <- glue::glue("nitrates.nitrate_prelevement_{version}_code_prelevement_seq")
-
- # Initialiser une liste pour stocker les valeurs de la séquence
- code_prelevements <- c()
-
- # Pour chaque ligne du dataframe, obtenir une valeur de la séquence
- for (i in 1:nrow(dataframe)) {
- query <- glue::glue("SELECT nextval(\'{sequence_name}\') AS code_prelevement")
- result <- DBI::dbGetQuery(connexion, query)
- code_prelevements <- c(code_prelevements, result$code_prelevement)
- }
-
- # Ajouter la nouvelle variable au dataframe
- dataframe <- dataframe |>
- dplyr::mutate(code_prelevement = code_prelevements)
-
- # Fermer la connexion à la base de données
- DBI::dbDisconnect(connexion)
-
- return(dataframe)
-}
+On met à jour le champs code_station avec le code BSS :
+```{r update_code_bss, eval=FALSE}
+nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
+ dplyr::left_join(station_eso, by = c("code_station" = "code_sise_eaux"), suffix = c("_ars", "_station_eso"))
+
+nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
+ dplyr::mutate(code_station = ifelse(!is.na(code_station_station_eso), code_station_station_eso, code_station)) |>
+ dplyr::select(-code_station_station_eso, -source_station_eso)
+```
+On ne conserve que les champs utiles à la table des prélèvements :
+```{r select-variables-ars_v2, eval=FALSE}
+nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
+ dplyr::select(code_intervenant,
+ source = source_ars,
+ code_station,
+ date_prelevement,
+ heure_prelevement,
+ code_support,
+ nature_eau,
+ id_usage,
+ id_prelevement_motif)
```
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_ars, eval=FALSE}
# Utiliser la fonction add_code_prelevement_ars avec la version souhaitée
nitrate_data_analyse_ars <- add_code_prelevement(
- nitrate_data_analyse_ars, "v0_15")
+ nitrate_data_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_data_analyse_ars)
@@ -137,10 +133,10 @@ print(nitrate_data_analyse_ars)
```
On charge les données consolidées dans un table dédiée :
-```{r insert-into_nitrate_prelevement_v0_15, eval=FALSE}
+```{r insert-into_nitrate_prelevement_v0_16, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_data_analyse_ars,
- table = "nitrate_prelevement_ars_v0_15",
+ table = glue::glue("nitrate_prelevement_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -154,14 +150,34 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_ars, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_ars_v0_15",
+ source_table = glue::glue("nitrate_prelevement_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_15",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements ARS",
+ template_dir = "insertion-des-prelevements-ars",
+ template_description = "Insertion des pr\u00e9l\u00e8vements ARS",
+ template_create_dir = TRUE
+)
+
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_ars_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-ars/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-ars/template.yaml b/inst/rmarkdown/templates/insertion-des-prelevements-ars/template.yaml
index 79ed12ffe7f3219b815b0a56d7e7ea0abff86b01..82c2d2944a0da87c524a233e5f4fdb1f39f732b0 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-ars/template.yaml
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-ars/template.yaml
@@ -1,4 +1,4 @@
name: Insertion des prélèvements ARS
description: >
Insertion des prélèvements ARS
-create_dir: FALSE
+create_dir: TRUE
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton/skeleton.Rmd
index b87e02a5463d04ad7339633af1a6e845eb28f823..94a8a53d035afe7bce054b834f633f1b014263c1 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,15 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
# Consolidation et insertion des données Hub'eau ESO dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESO
@@ -47,13 +57,14 @@ nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
## Consolidation des prélèvements Hub'eau ESO
-On ajoute les variables `source` et `code_support` :
+On ajoute les variables `source`, `code_support` et `nature_eau` :
```{r add-source_code_support_hubeau_eso, eval=FALSE}
-# Ajouter les variables source et code_support
+# Ajouter les variables source, code_support et nature_eau
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::mutate(
source = "ADES",
- code_support = 3)
+ code_support = 3,
+ nature_eau = "ESO")
```
On sélectionne les champs utiles à la table des prélèvements :
@@ -64,7 +75,8 @@ nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
code_reseau = codes_reseau,
code_station = bss_id,
date_prelevement = date_debut_prelevement,
- code_support)
+ code_support,
+ nature_eau)
```
On modifie le type de la variable `code_support` de character en integer :
@@ -87,7 +99,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_hubeau_eso, eval=FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_nappes_prelevements <- add_code_prelevement(
- nitrate_qualite_nappes_prelevements, "v0_15")
+ nitrate_qualite_nappes_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_prelevements)
@@ -97,8 +109,8 @@ print(nitrate_qualite_nappes_prelevements)
On charge les données consolidées dans un table dédiée :
```{r insert-into_nitrate_prelevement_hubeau_eso, eval=FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
- table = "nitrate_prelevement_hubeau_eso_v0_15",
+datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
+ table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -112,14 +124,34 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_eso, eval=FALSE}
# Insérer les prélèvements Hub'eau ESO vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_eso_v0_15",
+ source_table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_15",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements Hubeau ESO",
+ template_dir = "insertion-des-prelevements-hubeau-eso",
+ template_description = "Insertion des pr\u00e9l\u00e8vements Hubeau ESO",
+ template_create_dir = TRUE
+)
+
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_eso_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/template.yaml b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/template.yaml
index 6cc2eeb42f8f937d68e7ca83e6eb827c6f0adea7..6ebe66a2e8b91bb28f80ff36b220ff84ca5ecb13 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/template.yaml
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-eso/template.yaml
@@ -1,4 +1,4 @@
name: Insertion des prélèvements Hubeau ESO
description: >
Insertion des prélèvements Hubeau ESO
-create_dir: FALSE
+create_dir: TRUE
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton/skeleton.Rmd
index 856ef327732c96f5f1427b0026779c5400449404..70e2525d1c26b31b4f29896f99fb37ca98b3e27d 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton/skeleton.Rmd
@@ -7,6 +7,7 @@ editor_options:
```{r development, include=FALSE}
library(testthat)
+library(yaml)
library(datalibaba)
library(dplyr)
library(stringr)
@@ -20,6 +21,15 @@ library(RPostgres)
pkgload::load_all(export_all = FALSE)
```
+```{r config, eval=FALSE}
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
# Consolidation et insertion des données Hub'eau ESU dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESU
@@ -47,11 +57,14 @@ nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |
)
```
-On ajoute la variable `source` :
+On ajoute les variables `source` et `nature_eau` :
```{r add-source_code_support_hubeau_esu, eval=FALSE}
-# Ajouter les variables source et code_support
+# Ajouter les variables source et nature_eau
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
- dplyr::mutate(source = "Na\u00efades")
+ dplyr::mutate(
+ source = "Na\u00efades",
+ nature_eau = "ESU")
+
```
On sélectionne les champs utiles à la table des prélèvements :
@@ -64,6 +77,7 @@ nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |
date_prelevement,
heure_prelevement,
code_support,
+ nature_eau,
commentaire = commentaires_analyse)
```
@@ -87,7 +101,7 @@ On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
```{r add_code_prelevement_hubeau_esu, eval=FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_rivieres_prelevements <- add_code_prelevement(
- nitrate_qualite_rivieres_prelevements, "v0_15")
+ nitrate_qualite_rivieres_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_prelevements)
@@ -98,7 +112,7 @@ On charge les données consolidées dans une table dédiée :
```{r insert-into_nitrate_prelevement_hubeau_esu, eval=FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_prelevements,
- table = "nitrate_prelevement_hubeau_esu_v0_15",
+ table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -112,14 +126,34 @@ On insère enfin les enregistrements de cette table dans la table globale :
```{r import_and_merge_tables_hubeau_esu, eval=FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_esu_v0_15",
+ source_table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_15",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+```{r development-skeleton, eval=FALSE}
+# Créer de l'arborescence et des fichiers du template
+usethis::use_rmarkdown_template(
+ template_name = "Insertion des pr\u00e9l\u00e8vements Hubeau ESU",
+ template_dir = "insertion-des-prelevements-hubeau-esu",
+ template_description = "Insertion des pr\u00e9l\u00e8vements Hubeau ESU",
+ template_create_dir = TRUE
+)
+
+# Définir les chemins source et destination
+source_file <- "dev/flat_insert_hubeau_esu_into_prelevement.Rmd"
+destination_dir <- "inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/skeleton"
+destination_file <- file.path(destination_dir, "skeleton.Rmd")
+
+# Copier et renommer le fichier
+file.copy(from = source_file, to = destination_file, overwrite = TRUE)
+message("File copied and renamed successfully.")
+
+```
+
```{r development-inflate, eval=FALSE}
# Run but keep eval=FALSE to avoid infinite loop
# Execute in the console directly
diff --git a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/template.yaml b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/template.yaml
index df273c69358c6dadab13214137479613412d7d39..a6b66b1d43cee3b14c4f7338bccf46a50e5a4d1e 100644
--- a/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/template.yaml
+++ b/inst/rmarkdown/templates/insertion-des-prelevements-hubeau-esu/template.yaml
@@ -1,4 +1,4 @@
name: Insertion des prélèvements Hubeau ESU
description: >
Insertion des prélèvements Hubeau ESU
-create_dir: FALSE
+create_dir: TRUE
diff --git a/man/create_nitrate_analyse_table.Rd b/man/create_nitrate_analyse_table.Rd
index a3b57535a3cef4a504277ddd38a5e874b7045348..e1ce932054aaeaae1a4ee1e3e5ebe37128f6959c 100644
--- a/man/create_nitrate_analyse_table.Rd
+++ b/man/create_nitrate_analyse_table.Rd
@@ -1,17 +1,15 @@
% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/create_nitrate_prelevement_table.R
+% Please edit documentation in R/create_nitrate_analyse_table.R
\name{create_nitrate_analyse_table}
\alias{create_nitrate_analyse_table}
\title{Créer une table d'analyses de nitrates}
\usage{
-create_nitrate_analyse_table(version, last_year, connexion)
+create_nitrate_analyse_table(version, last_year)
}
\arguments{
\item{version}{String. Version de la table (par exemple, 'v1').}
\item{last_year}{Integer. L'année la plus récente incluse dans les données de la table.}
-
-\item{connexion}{DBIConnection. Connexion active à la base de données PostgreSQL.}
}
\value{
String. Le script SQL utilisé pour créer la table.
@@ -21,12 +19,3 @@ Cette fonction crée une table dans une base de données PostgreSQL
pour stocker les informations relatives aux analyses de nitrates, incluant
les contraintes et les séquences nécessaires.
}
-\examples{
-# Connexion à la base de données
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
-# Création du script SQL avec la version choisie
-version <- "v0_16"
-last_year <- "2023"
-sql <- create_nitrate_analyse_table(version, last_year, connexion)
-}
diff --git a/man/create_nitrate_prelevement_table.Rd b/man/create_nitrate_prelevement_table.Rd
index 1f1f58ec328c308d7e46d84770bd6f86d6a87634..085106846f9f38b38bd121185e6d179f4aafe0dc 100644
--- a/man/create_nitrate_prelevement_table.Rd
+++ b/man/create_nitrate_prelevement_table.Rd
@@ -4,14 +4,12 @@
\alias{create_nitrate_prelevement_table}
\title{Créer une table de prélèvements de nitrates}
\usage{
-create_nitrate_prelevement_table(version, last_year, connexion)
+create_nitrate_prelevement_table(version, last_year)
}
\arguments{
\item{version}{String. Version de la table (par exemple, 'v1').}
\item{last_year}{Integer. L'année la plus récente incluse dans les données de la table.}
-
-\item{connexion}{DBIConnection. Connexion active à la base de données PostgreSQL.}
}
\value{
String. Le script SQL utilisé pour créer la table.
@@ -21,12 +19,3 @@ Cette fonction crée une table dans une base de données PostgreSQL
pour stocker les informations relatives aux prélèvements de nitrates,
incluant les contraintes et les séquences nécessaires.
}
-\examples{
-# Connexion à la base de données
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-
-# Création du script SQL avec la version choisie
-version <- "v0_16"
-last_year <- "2023"
-sql <- create_nitrate_prelevement_table(version, last_year, connexion)
-}
diff --git a/vignettes/import-des-donnees-ars.Rmd b/vignettes/import-des-donnees-ars.Rmd
index a4206dc1369a68123ad00b9e2a616c2c2a089a03..a5b00cbb4e229bd755e7c9f6048624c38d51badf 100644
--- a/vignettes/import-des-donnees-ars.Rmd
+++ b/vignettes/import-des-donnees-ars.Rmd
@@ -2,7 +2,7 @@
title: "Import des données ARS"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{import-des-donnees-ars}
+ %\VignetteIndexEntry{Import des données ARS}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,105 +14,89 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_import_ars_data.Rmd: do not edit by hand -->
-# Présentation
-
-Cette page contient la logique métier concernant l'import des données brutes
-fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
-Nitrates
-
-# Connexion à la base de données PostgreSQL
-```{r connect_to_db, eval = FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-```{r list_schemas, eval = FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
+```{r config}
+#| eval: no
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+filepath_data_ars <- config$filepath_data_ars
```
-```{r list_tables, eval = FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "nitrates"))
-
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
+# Présentation
-```
+Cette page contient la logique métier concernant l'import des données brutes
+fournies par l'ARS dans une base de données POstgreSQL dans le cadre du projet
+Nitrates.
# Import des données de l'ARS dans un dataframe par millésime
Les données sont transmies au format XLSX.
+```{r import_data_ars_last_year}
+#| eval: no
-
-```{r import_data_ars_2023, eval = FALSE}
-data_ars_2023 <- collectr::import_xlsx(
- filepath = "T:\\datalab\\SRNP_DEMA_SI_EAU\\NITRATES\\DONNEES_CLIENT\\SOURCES\\ARS\\2024_06\\Nitrates 2023 pour DREAL EPNT4 2024-05-31.xlsx",
+data_ars_last_year <- collectr::import_xlsx(
+ filepath = filepath_data_ars,
sheet = 1,
row = 2)
```
+
# Création d'une table pour le nouveau millésime
+```{r create-nitrate_data_ars}
+#| eval: no
-```{r create-nitrate_data_ars, eval = FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = data_ars_2023,
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::poster_data(data = data_ars_last_year,
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2023)",
- table = "nitrate_data_analyse_ars_2023",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (", last_year, ")"),
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
schema = "nitrates",
db = "si_eau",
user = "admin")
```
+
# Modification du type des champs si besoin
+```{r modify_column_type}
+#| eval: no
-```{r modify_column_type, eval = FALSE}
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "nitrates",
- table = "nitrate_data_analyse_ars_2023",
+ table = glue::glue("nitrate_data_analyse_ars_", last_year),
column_name = "plv_date",
column_type = "date",
role = "admin")
```
+
# Archivage de la version précédente de la table
+```{r archive_table}
+#| eval: no
-```{r archive_table, eval = FALSE}
# Archiver la version actuelle de la table avec tous les millésimes
collectr::archive_table(database = "si_eau",
schema = "nitrates",
@@ -122,22 +106,28 @@ collectr::archive_table(database = "si_eau",
```
+
# Insertion des données du nouveau millésime en base dans la table globale
+```{r import_and_merge_tables}
+#| eval: no
-```{r import_and_merge_tables, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_data_analyse_ars_2023",
+ source_table = glue::glue("nitrate_data_analyse_ars_", last_year),
source_schema = "nitrates",
target_table = "nitrate_data_analyse_ars",
target_schema = "nitrates",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ARS (2007-2023)",
+datalibaba::commenter_table(comment = glue::glue("Analyses Nitrates ARS (2007-", last_year, ")",
table = "nitrate_data_analyse_ars",
schema = "nitrates",
db = "si_eau",
user = "admin")
```
+
+
+
+
diff --git a/vignettes/import-des-donnees-hub-eau-eso.Rmd b/vignettes/import-des-donnees-hub-eau-eso.Rmd
index b85e1f9f8f1fec3787b1ff8dd7870ac875315435..db8192814ffcc4cda6b3ea2dc3a6adfc9a4d20ee 100644
--- a/vignettes/import-des-donnees-hub-eau-eso.Rmd
+++ b/vignettes/import-des-donnees-hub-eau-eso.Rmd
@@ -2,7 +2,7 @@
title: "Import des données Hub'eau ESO"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{import-des-donnees-hub-eau-eso}
+ %\VignetteIndexEntry{Import des données Hub'eau ESO}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,129 +14,90 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_import_hubeau_eso_data.Rmd: do not edit by hand -->
-# Présentation
-
-> Cette page contient la logique métier concernant l'import des données de
-l'[API Hub'eau "Qualité des nappes d'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes) dans le cadre du projet Nitrates
-
-# Connexion à la base de données PostgreSQL
-```{r connect_to_db, eval = FALSE}
-# Se connecter à la base de données PostgreSQL si_eau
-connexion <- datalibaba::connect_to_db(db = "si_eau", user = "admin")
-```
-```{r list_schemas, eval = FALSE}
-# Lister les schémas présents dans la base
-schemas_list <- data.frame(datalibaba::list_schemas(connexion))
+```{r config}
+#| eval: no
-# Renommer la variable unique en "nom_schema"
-schemas_list <- schemas_list |>
- rename(nom_schema = unique(names(.)))
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
-# Trier le dataframe par la variable nom_schema
-schemas_list <- schemas_list |>
- arrange(nom_schema)
+# Accéder à la valeur pour last_year
+last_year <- config$last_year
```
-```{r list_tables, eval = FALSE}
-# Lister les tables présentes dans le schéma spécifié
-tables_list <- data.frame(datalibaba::list_tables(
- con = connexion,
- db = "si_eau",
- schema = "qualite_cours_d_eau"))
-# Renommer la variable unique en "nom_table"
-tables_list <- tables_list |>
- rename(nom_table = names(tables_list)[1])
+# Présentation
-# Trier le dataframe par la variable nom_table
-tables_list <- tables_list |>
- arrange(nom_table)
-
-```
+Cette page contient la logique métier concernant l'import des données de
+l'[API Hub'eau "Qualit\u00e9 des nappes d\'eau souterraine"](https://hubeau.eaufrance.fr/page/api-qualite-nappes)
+dans le cadre du projet Nitrates.
# Import des données Hub'eau ESU dans un dataframe par millésime
On utilise la fonction `get_qualite_nappes_analyses()` du package [{hubeau}](https://github.com/inrae/hubeau)
-
-
-```{r create-nitrate_analyse_esu_2020, eval = FALSE}
-nitrate_analyse_eso_2020 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2020-01-01",
- date_fin_prelevement = "2020-12-31",
- size = "5000")
-```
-
-```{r create-nitrate_analyse_esu_2021, eval = FALSE}
-nitrate_analyse_eso_2021 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2021-01-01",
- date_fin_prelevement = "2021-12-31",
- size = "5000")
+```{r create-nitrate_analyse_esu_last_year}
+#| eval: no
+
+nitrate_analyse_eso_last_year <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
+ code_region = "52",
+ date_debut_prelevement = glue::glue(last_year, "-01-01"),
+ date_fin_prelevement = glue::glue(last_year, "-12-31"),
+ size = "5000")
```
-```{r create-nitrate_analyse_esu_2022, eval = FALSE}
-nitrate_analyse_eso_2022 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2022-01-01",
- date_fin_prelevement = "2022-12-31",
- size = "5000")
-
-```
-
-```{r create-nitrate_analyse_esu_2023, eval = FALSE}
-nitrate_analyse_eso_2023 <- hubeau::get_qualite_nappes_analyses(code_param = "1340",
- code_region = "52",
- date_debut_prelevement = "2023-01-01",
- date_fin_prelevement = "2023-12-31",
- size = "5000")
-```
# Création d'une table pour le nouveau millésime
+```{r create-nitrate_data_ars}
+#| eval: no
-```{r create-nitrate_data_ars, eval = FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_analyse_eso_2023,
- table = "nitrate_qualite_nappes_analyses_2023",
+datalibaba::poster_data(data = nitrate_analyse_eso_last_year,
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
schema = "qualite_nappes_eau_souterraine",
db = "si_eau",
overwrite = TRUE,
user = "admin")
# Ajouter un commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses \"Nitrates\" ESO issues de l''API Hub''eau qualite_nappes : données brutes",
- table = "nitrate_qualite_nappes_analyses_2023",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses \"Nitrates\" ESO issues de l\'\'API Hub\'\'eau qualite_nappes : donn\u00e9es brutes",
+ last_year),
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin")
```
+
# Modification du type des champs si besoin
+```{r modify_column_type}
+#| eval: no
-```{r modify_column_type, eval = FALSE}
# Modifier le type de colonne pour les champs de date
collectr::modify_column_type(database = "si_eau",
schema = "qualite_nappes_eau_souterraine",
- table = "nitrate_qualite_nappes_analyses_2023",
+ table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
column_name = "date_debut_prelevement",
column_type = "date",
role = "admin")
```
+
# Archivage de la version précédente de la table
+```{r archive_table}
+#| eval: no
-```{r archive_table, eval = FALSE}
# Archiver la version actuelle de la table avec tous les millésimes
collectr::archive_table(database = "si_eau",
schema = "qualite_nappes_eau_souterraine",
@@ -146,22 +107,31 @@ collectr::archive_table(database = "si_eau",
```
+
# Insertion des données du nouveau millésime en base dans la table globale
+```{r import_and_merge_tables}
+#| eval: no
-```{r import_and_merge_tables, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_nappes_analyses_2023",
+ source_table = glue::glue("nitrate_qualite_nappes_analyses_", last_year),
source_schema = "qualite_nappes_eau_souterraine",
target_table = "nitrate_qualite_nappes_analyses",
target_schema = "qualite_nappes_eau_souterraine",
role = "admin")
# Actualiser le commentaire sur la table
-datalibaba::commenter_table(comment = "Analyses Nitrates ESO API Hub'eau Qualité des nappes d'eau souterraine (2007-2023)",
- table = "nitrate_qualite_nappes_analyses",
- schema = "qualite_nappes_eau_souterraine",
- db = "si_eau",
- user = "admin")
+datalibaba::commenter_table(
+ comment = glue::glue(
+ "Analyses Nitrates ESO API Hub\'eau Qualit\u00e9 des nappes d\'eau souterraine (2007-",
+ last_year,
+ ")"),
+ table = "nitrate_qualite_nappes_analyses",
+ schema = "qualite_nappes_eau_souterraine",
+ db = "si_eau",
+ user = "admin")
```
+
+
+
diff --git a/vignettes/insertion-des-analyses-ars.Rmd b/vignettes/insertion-des-analyses-ars.Rmd
index 5f76b05a8ff87f7e25d2b036337086b010a01f47..ab6a7a1bd9a67e5d2dbb64b5da396e9d5017fdeb 100644
--- a/vignettes/insertion-des-analyses-ars.Rmd
+++ b/vignettes/insertion-des-analyses-ars.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des analyses ARS"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-analyses-ars}
+ %\VignetteIndexEntry{Insertion des analyses ARS}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,36 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_ars_into_analyse.Rmd: do not edit by hand -->
-# Consolidation et insertion des données de l'ARS dans la table des prélèvements
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+
+```
+
+
+# Consolidation et insertion des données de l'ARS dans la table des analyses
## Chargement des données ARS brutes
La table des données brutes Nitrates de l'ARS est chargée :
+```{r load-nitrate_data_analyse_ars}
+#| eval: no
-```{r load-nitrate_data_analyse_ars, eval = FALSE}
# Charger la table nitrates.nitrate_data_analyse_ars
nitrate_data_analyse_ars <- datalibaba::importer_data(
table = "nitrate_data_analyse_ars",
@@ -34,22 +51,27 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
db = "si_eau",
user = "admin"
)
+
```
+
## Consolidation des données ARS
On supprime les enregistrements correspondants à des totaux :
+```{r filter-param_nom_ars}
+#| eval: no
-```{r filter-param_nom_ars, eval = FALSE}
# Supprimer les lignes ne correspondant pas à une analyse
nitrate_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::filter(!stringr::str_starts(param_nom, "Total"))
```
+
On remplace les chaînes de caractère par NA dans la variable `ana_param_alpha_resultat` :
+```{r replace-strings-with-na}
+#| eval: no
-```{r replace-strings-with-na, eval = FALSE}
# Remplacer chaînes de caractère dans la colonne ana_param_alpha_resultat
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::mutate(
@@ -61,9 +83,11 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
+
On remplace des valeurs dans ana_param_alpha_resultat et param_code:
+```{r replace-dot_ana_param_alpha_resultat}
+#| eval: no
-```{r replace-dot_ana_param_alpha_resultat, eval = FALSE}
# Remplacer les valeurs dans les colonnes ana_param_alpha_resultat et param_code
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::mutate(
@@ -73,12 +97,14 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
+
On affecte le code_remarque et la valeur des variables resultat_analyse et limite_quantification :
+```{r mutate-from_ana_param_alpha_resultat}
+#| eval: no
-```{r mutate-from_ana_param_alpha_resultat, eval = FALSE}
# Ajouter les colonnes code_remarque, resultat_analyse et limite_quantification
nitrate_analyse_ars <- nitrate_analyse_ars |>
- mutate(
+ dplyr::mutate(
# Ajout de la colonne code_remarque selon la condition spécifiée
code_remarque = dplyr::case_when(
stringr::str_starts(ana_param_alpha_resultat, "<") ~ 10,
@@ -94,11 +120,14 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
TRUE ~ NA_character_ # Utilisation de NA pour les valeurs non pertinentes
)
)
+
```
+
On sélectionne les champs utiles à la table des analyses :
+```{r select-variables-ars}
+#| eval: no
-```{r select-variables-ars, eval = FALSE}
# Sélectionner les variables
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::select(code_station = ins_code_national,
@@ -113,9 +142,11 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
+
On supprime les caractères < et > dans les variables resultat_analyse et limite_quantification :
+```{r replace-inferior_superior}
+#| eval: no
-```{r replace-inferior_superior, eval = FALSE}
# Remplacer les valeurs dans les colonnes resultat_analyse et limite_quantification
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::mutate(resultat_analyse =
@@ -125,9 +156,11 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
+
On modifie le type des variables resultat_analyse et limite_quantification :
+```{r change-fieldtypes}
+#| eval: no
-```{r change-fieldtypes, eval = FALSE}
# Remplacer les valeurs dans les colonnes resultat_analyse et limite_quantification
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::mutate(resultat_analyse = as.numeric(resultat_analyse),
@@ -136,14 +169,16 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
-# Jointure avec la table des prélèvements créée auparavant
+
+## Jointure avec la table des prélèvements créée auparavant
La table des prélèvements est chargée :
+```{r load-nitrate_prelevement}
+#| eval: no
-```{r load-nitrate_prelevement, eval = FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -151,43 +186,52 @@ nitrate_prelevement <- datalibaba::importer_data(
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et `date_prelevement`
afin de ne conserver qu'un prélèvement par station et date donnée :
+```{r select-distinct-rows-ars}
+#| eval: no
-```{r select-distinct-rows-ars, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On joint le dataframe des prélèvements pour récupérer la variable code_prelevement :
+```{r join-prelvement_ars}
+#| eval: no
-```{r join-prelvement_ars, eval = FALSE}
# Joindre les dataframes nitrate_analyse_ars et nitrate_prelevement
nitrate_analyse_ars <- nitrate_analyse_ars |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_analyse_ars}
+#| eval: no
-```{r add_code_analyse_ars, eval = FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_analyse_ars <- add_code_analyse(
- nitrate_analyse_ars, "v0_15")
+ nitrate_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_analyse_ars)
```
-# Chargement en base
+
+## Préparation pour l'insertion en base
On corrige l'ordre des champs les champs utiles à la table des analyses :
+```{r select-variables-ars-final}
+#| eval: no
-```{r select-variables-ars-final, eval = FALSE}
# Sélectionner les variables dans l'ordre des champs de la table à alimenter
nitrate_analyse_ars <- nitrate_analyse_ars |>
dplyr::select(code_analyse,
@@ -202,12 +246,14 @@ nitrate_analyse_ars <- nitrate_analyse_ars |>
```
+
On charge les données consolidées dans un table dédiée :
+```{r insert_into_nitrate_prelevement_version}
+#| eval: no
-```{r insert-into_nitrate_prelevement_v0_15, eval = FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_analyse_ars,
- table = "nitrate_analyse_ars_v0_15",
+ table = glue::glue("nitrate_analyse_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -215,18 +261,23 @@ datalibaba::poster_data(data = nitrate_analyse_ars,
user = "admin")
```
-# Insertion des données ARS du nouveau millésime en base dans la table globale
+
+## Insertion des analyses ARS en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_ars}
+#| eval: no
-```{r import_and_merge_tables_ars, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_ars_v0_15",
+ source_table = glue::glue("nitrate_analyse_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+
diff --git a/vignettes/insertion-des-analyses-hubeau-eso.Rmd b/vignettes/insertion-des-analyses-hubeau-eso.Rmd
index 891cd91656c974c253e85a456a5d4131155cbaa7..5d7ce0d56111183015da643d8b408cd89a93fa8e 100644
--- a/vignettes/insertion-des-analyses-hubeau-eso.Rmd
+++ b/vignettes/insertion-des-analyses-hubeau-eso.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des analyses Hubeau ESO"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-analyses-hubeau-eso}
+ %\VignetteIndexEntry{Insertion des analyses Hubeau ESO}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,35 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_hubeau_eso_into_analyse.Rmd: do not edit by hand -->
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+
# Consolidation et insertion des analyses Hub'eau ESO dans la table des analyses
## Chargement des analyses Hub'eau ESO
La table des données brutes Nitrates Hub'eau ESO est chargée :
+```{r load-nitrate_qualite_nappes_analyses}
+#| eval: no
-```{r load-nitrate_qualite_nappes_analyses, eval = FALSE}
# Charger la table qualite_nappes_eau_souterraine.nitrate_qualite_nappes_analyses
nitrate_qualite_nappes_analyses <- datalibaba::importer_data(
table = "nitrate_qualite_nappes_analyses",
@@ -36,22 +52,26 @@ nitrate_qualite_nappes_analyses <- datalibaba::importer_data(
)
```
+
## Filtre par code_producteur pour exclure les données ARS
On sélectionne les code_producteur correspondants aux enregistrements hors
données ARS de la région :
+```{r select-code_producteur_hubeau_eso}
+#| eval: no
-```{r select-code_producteur_hubeau_eso, eval = FALSE}
# Filtrer pour exclure les données ARS
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::filter(!code_producteur %in% c('44','49','53','72','85'))
```
+
## Consolidation des données Hub'eau ESO
On remplace des valeurs dans limite_detection et limite_quantification :
+```{r replace-dot_limite_detection}
+#| eval: no
-```{r replace-dot_limite_detection, eval = FALSE}
# Remplacer les valeurs dans les colonnes limite_detection et limite_quantification
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::mutate(
@@ -62,9 +82,11 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
+
On sélectionne les champs utiles à la table des analyses :
+```{r select-variables-hubeau_eso}
+#| eval: no
-```{r select-variables-hubeau_eso, eval = FALSE}
# Sélectionner les variables
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::select(code_station = bss_id,
@@ -80,9 +102,11 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
+
On modifie le type des variables numériques :
+```{r change-fieldtypes}
+#| eval: no
-```{r change-fieldtypes, eval = FALSE}
# Remplacer les valeurs dans les colonnes resultat_analyse et limite_quantification
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::mutate(resultat_analyse = as.numeric(resultat_analyse),
@@ -95,14 +119,16 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
+
# Jointure avec la table des prélèvements créée auparavant
La table des prélèvements est chargée :
+```{r load-nitrate_prelevement}
+#| eval: no
-```{r load-nitrate_prelevement, eval = FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -110,53 +136,63 @@ nitrate_prelevement <- datalibaba::importer_data(
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et `date_prelevement`
afin de ne conserver qu'un prélèvement par station et date donnée :
+```{r select-distinct-rows_hubeau_eso}
+#| eval: no
-```{r select-distinct-rows_hubeau_eso, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On joint le dataframe des prélèvements pour récupérer la variable code_prelevement :
+```{r join-prelevement_hubeau_eso}
+#| eval: no
-```{r join-prelevement_hubeau_eso, eval = FALSE}
# Joindre les dataframes nitrate_qualite_nappes_analyses et nitrate_prelevement
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
+
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
`code_parametre` et `resultat_analyse` afin de ne conserver qu'une analyse :
+```{r select-distinct-rows_hubeau_eso_2}
+#| eval: no
-```{r select-distinct-rows_hubeau_eso_2, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::distinct(code_prelevement, code_parametre, resultat_analyse, .keep_all = TRUE)
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_analyse_hubeau_eso}
+#| eval: no
-```{r add_code_analyse_hubeau_eso, eval = FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_nappes_analyses <- add_code_analyse(
- nitrate_qualite_nappes_analyses, "v0_15")
+ nitrate_qualite_nappes_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_analyses)
```
+
# Chargement en base
On corrige l'ordre des champs les champs utiles à la table des analyses :
+```{r select-variables-hubeau_eso_final}
+#| eval: no
-```{r select-variables-hubeau_eso_final, eval = FALSE}
# Sélectionner les variables dans l'ordre des champs de la table à alimenter
nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
dplyr::select(code_analyse,
@@ -172,12 +208,14 @@ nitrate_qualite_nappes_analyses <- nitrate_qualite_nappes_analyses |>
```
+
On charge les données consolidées dans un table dédiée :
+```{r insert-into_nitrate_prelevement_v0_xx}
+#| eval: no
-```{r insert-into_nitrate_prelevement_v0_15, eval = FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_nappes_analyses,
- table = "nitrate_analyse_hubeau_eso_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -185,18 +223,24 @@ datalibaba::poster_data(data = nitrate_qualite_nappes_analyses,
user = "admin")
```
+
# Insertion des données Hub'eau ESO en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_hubeau_eso}
+#| eval: no
-```{r import_and_merge_tables_hubeau_eso, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_analyse_hubeau_eso_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+
+
diff --git a/vignettes/insertion-des-analyses-hubeau-esu.Rmd b/vignettes/insertion-des-analyses-hubeau-esu.Rmd
index 0f1689ddd608d9312d0768eb16fdb8453cec949a..7e3af132890cec31ada9e785da7d6a9477f862c5 100644
--- a/vignettes/insertion-des-analyses-hubeau-esu.Rmd
+++ b/vignettes/insertion-des-analyses-hubeau-esu.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des analyses Hubeau ESU"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-analyses-hubeau-esu}
+ %\VignetteIndexEntry{Insertion des analyses Hubeau ESU}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,35 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_hubeau_esu_into_analyse.Rmd: do not edit by hand -->
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+
# Consolidation et insertion des analyses Hub'eau ESU dans la table des analyses
## Chargement des analyses Hub'eau ESU
La table des données brutes Nitrates Hub'eau ESU est chargée :
+```{r load-nitrate_qualite_rivieres_analyse_pc}
+#| eval: no
-```{r load-nitrate_qualite_rivieres_analyse_pc, eval = FALSE}
# Charger la table qualite_cours_d_eau.nitrate_qualite_rivieres_analyse_pc
nitrate_qualite_rivieres_analyses <- datalibaba::importer_data(
table = "nitrate_qualite_rivieres_analyse_pc",
@@ -36,11 +52,13 @@ nitrate_qualite_rivieres_analyses <- datalibaba::importer_data(
)
```
+
## Consolidation des analyses Hub'eau ESU
On remplace des valeurs dans limite_detection et limite_quantification :
+```{r replace-dot_limite_detection}
+#| eval: no
-```{r replace-dot_limite_detection, eval = FALSE}
# Remplacer les valeurs dans les colonnes limite_detection et limite_quantification
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::mutate(
@@ -51,9 +69,11 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
+
On sélectionne les champs utiles à la table des analyses :
+```{r select-variables-hubeau_esu}
+#| eval: no
-```{r select-variables-hubeau_esu, eval = FALSE}
# Sélectionner les variables
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::select(code_station,
@@ -69,9 +89,11 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
+
On modifie le type des variables resultat_analyse et limite_quantification :
+```{r change-fieldtypes}
+#| eval: no
-```{r change-fieldtypes, eval = FALSE}
# Remplacer les valeurs dans les colonnes resultat_analyse et limite_quantification
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::mutate(resultat_analyse = as.numeric(resultat_analyse),
@@ -84,14 +106,16 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
+
# Jointure avec la table des prélèvements créée auparavant
La table des prélèvements est chargée :
+```{r load-nitrate_prelevement}
+#| eval: no
-```{r load-nitrate_prelevement, eval = FALSE}
-# Charger la table nitrates.nitrate_prelevement_v0_15
+# Charger la table nitrates.nitrate_prelevement_version
nitrate_prelevement <- datalibaba::importer_data(
- table = "nitrate_prelevement_v0_15",
+ table = glue::glue("nitrate_prelevement_", version),
schema = "nitrates",
db = "si_eau",
user = "admin"
@@ -99,53 +123,63 @@ nitrate_prelevement <- datalibaba::importer_data(
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et `date_prelevement`
afin de ne conserver qu'un prélèvement par station et date donnée :
+```{r select-distinct-rows_hubeau_esu}
+#| eval: no
-```{r select-distinct-rows_hubeau_esu, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On joint le dataframe des prélèvements pour récupérer la variable code_prelevement :
+```{r join-prelevement_hubeau_esu}
+#| eval: no
-```{r join-prelevement_hubeau_esu, eval = FALSE}
# Joindre les dataframes nitrate_qualite_rivieres_analyses et nitrate_prelevement
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
- left_join(nitrate_prelevement |>
- select(code_station, date_prelevement, code_prelevement),
- by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
+ dplyr::left_join(nitrate_prelevement |>
+ dplyr::select(code_station, date_prelevement, code_prelevement),
+ by = c("code_station" = "code_station", "date_prelevement" = "date_prelevement"))
```
+
On dédoublonne les lignes en utilisant les champs `code_prelevement`,
`code_parametre` et `resultat_analyse` afin de ne conserver qu'une analyse :
+```{r select-distinct-rows_hubeau_esu_2}
+#| eval: no
-```{r select-distinct-rows_hubeau_esu_2, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::distinct(code_prelevement, code_parametre, resultat_analyse, .keep_all = TRUE)
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_analyse_hubeau_esu}
+#| eval: no
-```{r add_code_analyse_hubeau_esu, eval = FALSE}
# Utiliser la fonction add_code_analyse_ars avec la version souhaitée
nitrate_qualite_rivieres_analyses <- add_code_analyse(
- nitrate_qualite_rivieres_analyses, "v0_15")
+ nitrate_qualite_rivieres_analyses, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_analyses)
```
+
# Chargement en base
On corrige l'ordre des champs les champs utiles à la table des analyses :
+```{r select-variables-hubeau_esu_final}
+#| eval: no
-```{r select-variables-hubeau_esu_final, eval = FALSE}
# Sélectionner les variables dans l'ordre des champs de la table à alimenter
nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
dplyr::select(code_analyse,
@@ -161,12 +195,14 @@ nitrate_qualite_rivieres_analyses <- nitrate_qualite_rivieres_analyses |>
```
+
On charge les données consolidées dans une table dédiée :
+```{r insert-into_nitrate_analyse_hubeau_esu_version}
+#| eval: no
-```{r insert-into_nitrate_prelevement_v0_15, eval = FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_analyses,
- table = "nitrate_qualite_rivieres_analyses_v0_15",
+ table = glue::glue("nitrate_analyse_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -174,18 +210,24 @@ datalibaba::poster_data(data = nitrate_qualite_rivieres_analyses,
user = "admin")
```
+
# Insertion des analyses Hub'eau ESU en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_hubeau_esu}
+#| eval: no
-```{r import_and_merge_tables_hubeau_esu, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_qualite_rivieres_analyses_v0_15",
+ source_table = glue::glue("nitrate_analyse_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_analyse_v0_15",
+ target_table = glue::glue("nitrate_analyse_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+
+
diff --git a/vignettes/insertion-des-prelevements-ars.Rmd b/vignettes/insertion-des-prelevements-ars.Rmd
index 1d1f9c3b4aeab335c4f2aae1b7722d6ac261610c..fa0e73cdd215f4f747d4c7f96870d81e8a53b23b 100644
--- a/vignettes/insertion-des-prelevements-ars.Rmd
+++ b/vignettes/insertion-des-prelevements-ars.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des prélèvements ARS"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-prelevements-ars}
+ %\VignetteIndexEntry{Insertion des prélèvements ARS}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,35 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_ars_into_prelevement.Rmd: do not edit by hand -->
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+
# Consolidation et insertion des données de l'ARS dans la table des prélèvements
## Chargement des données ARS brutes et des stations ESO
La table des données brutes Nitrates de l'ARS est chargée :
+```{r load-nitrate_data_analyse_ars}
+#| eval: no
-```{r load-nitrate_data_analyse_ars, eval = FALSE}
nitrate_data_analyse_ars <- datalibaba::importer_data(
table = "nitrate_data_analyse_ars",
schema = "nitrates",
@@ -35,9 +51,11 @@ nitrate_data_analyse_ars <- datalibaba::importer_data(
)
```
-La table des stations ESO est chargée :
-```{r load-nitrate_station_eso, eval = FALSE}
+La table des stations ESO est chargée afin de remplacer ultérieurement le code SISE-EAUX par le code BSS pour les prélèvements ESO :
+```{r load-nitrate_station_eso}
+#| eval: no
+
station_eso <- datalibaba::importer_data(
table = "station_eso",
schema = "stations",
@@ -46,11 +64,13 @@ station_eso <- datalibaba::importer_data(
)
```
+
## Consolidation des données ARS
On ajoute les variables `source` et `code_support` :
+```{r add-source_code_support_ars}
+#| eval: no
-```{r add-source_code_support_ars, eval = FALSE}
# Ajouter les variables source et code_support
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::mutate(
@@ -59,17 +79,21 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
)
```
+
On remplace "h" par ":" dans la variable `plv_heure` :
+```{r replace-in_plv_heure}
+#| eval: no
-```{r replace-in_plv_heure, eval = FALSE}
# Remplacer "h" par ":" dans la colonne plv_heure
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::mutate(plv_heure = stringr::str_replace_all(plv_heure, "h", ":"))
```
+
On sélectionne les champs utiles à la table des prélèvements :
+```{r select-variables-ars}
+#| eval: no
-```{r select-variables-ars, eval = FALSE}
# Sélectionner les variables
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::select(code_intervenant = geo_dept_ddass_gest_code,
@@ -84,18 +108,22 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et `date_prelevement`
afin de ne conserver qu'un prélèvement par station et date donnée :
+```{r select-distinct-rows-ars}
+#| eval: no
-```{r select-distinct-rows-ars, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On met à jour le champs code_station avec le code BSS :
+```{r update_code_bss}
+#| eval: no
-```{r update_code_bss, eval = FALSE}
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::left_join(station_eso, by = c("code_station" = "code_sise_eaux"), suffix = c("_ars", "_station_eso"))
@@ -104,9 +132,11 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::select(-code_station_station_eso, -source_station_eso)
```
+
On ne conserve que les champs utiles à la table des prélèvements :
+```{r select-variables-ars_v2}
+#| eval: no
-```{r select-variables-ars_v2, eval = FALSE}
nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
dplyr::select(code_intervenant,
source = source_ars,
@@ -119,24 +149,28 @@ nitrate_data_analyse_ars <- nitrate_data_analyse_ars |>
id_prelevement_motif)
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_prelevement_ars}
+#| eval: no
-```{r add_code_prelevement_ars, eval = FALSE}
# Utiliser la fonction add_code_prelevement_ars avec la version souhaitée
nitrate_data_analyse_ars <- add_code_prelevement(
- nitrate_data_analyse_ars, "v0_16")
+ nitrate_data_analyse_ars, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_data_analyse_ars)
```
+
On charge les données consolidées dans un table dédiée :
+```{r insert-into_nitrate_prelevement_v0_16}
+#| eval: no
-```{r insert-into_nitrate_prelevement_v0_16, eval = FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_data_analyse_ars,
- table = "nitrate_prelevement_ars_v0_16",
+ table = glue::glue("nitrate_prelevement_ars_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -144,18 +178,23 @@ datalibaba::poster_data(data = nitrate_data_analyse_ars,
user = "admin")
```
+
# Insertion des données ARS du nouveau millésime en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_ars}
+#| eval: no
-```{r import_and_merge_tables_ars, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_ars_v0_16",
+ source_table = glue::glue("nitrate_prelevement_ars_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+
diff --git a/vignettes/insertion-des-prelevements-hubeau-eso.Rmd b/vignettes/insertion-des-prelevements-hubeau-eso.Rmd
index 131e7f3d0cd24f4b22de83f7b249d14812ee9c01..9390f4f36c3a8aa09777db910565dfb6a560a57f 100644
--- a/vignettes/insertion-des-prelevements-hubeau-eso.Rmd
+++ b/vignettes/insertion-des-prelevements-hubeau-eso.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des prélèvements Hubeau ESO"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-prelevements-hubeau-eso}
+ %\VignetteIndexEntry{Insertion des prélèvements Hubeau ESO}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,35 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_hubeau_eso_into_prelevement.Rmd: do not edit by hand -->
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+
# Consolidation et insertion des données Hub'eau ESO dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESO
La table des données brutes Nitrates Hub'eau ESO est chargée :
+```{r load-nitrate_qualite_nappes_analyses}
+#| eval: no
-```{r load-nitrate_qualite_nappes_analyses, eval = FALSE}
# Charger la table qualite_nappes_eau_souterraine.nitrate_qualite_rivieres_analyse_pc
nitrate_qualite_nappes_prelevements <- datalibaba::importer_data(
table = "nitrate_qualite_nappes_analyses",
@@ -36,22 +52,26 @@ nitrate_qualite_nappes_prelevements <- datalibaba::importer_data(
)
```
+
## Filtre par code_producteur pour exclure les données ARS
On sélectionne les code_producteur correspondants aux enregistrements hors
données ARS de la région :
+```{r select-code_producteur_hubeau_eso}
+#| eval: no
-```{r select-code_producteur_hubeau_eso, eval = FALSE}
# Filtrer pour exclure les données ARS
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::filter(!code_producteur %in% c('44','49','53','72','85'))
```
+
## Consolidation des prélèvements Hub'eau ESO
On ajoute les variables `source`, `code_support` et `nature_eau` :
+```{r add-source_code_support_hubeau_eso}
+#| eval: no
-```{r add-source_code_support_hubeau_eso, eval = FALSE}
# Ajouter les variables source, code_support et nature_eau
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::mutate(
@@ -60,9 +80,11 @@ nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
nature_eau = "ESO")
```
+
On sélectionne les champs utiles à la table des prélèvements :
+```{r select-variables_hubeau_eso}
+#| eval: no
-```{r select-variables_hubeau_eso, eval = FALSE}
# Sélectionner les variables
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::select(source,
@@ -73,42 +95,50 @@ nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
nature_eau)
```
+
On modifie le type de la variable `code_support` de character en integer :
+```{r change-type_code_support}
+#| eval: no
-```{r change-type_code_support, eval = FALSE}
# Convertir la variable code_support de character en integer
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::mutate(code_support = as.integer(code_support))
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et
`date_prelevement` afin de ne conserver qu'un prélèvement par station et date
donnée :
+```{r select-distinct-rows_hubeau_eso}
+#| eval: no
-```{r select-distinct-rows_hubeau_eso, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_nappes_prelevements <- nitrate_qualite_nappes_prelevements |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_prelevement_hubeau_eso}
+#| eval: no
-```{r add_code_prelevement_hubeau_eso, eval = FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_nappes_prelevements <- add_code_prelevement(
- nitrate_qualite_nappes_prelevements, "v0_16")
+ nitrate_qualite_nappes_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_nappes_prelevements)
```
+
On charge les données consolidées dans un table dédiée :
+```{r insert-into_nitrate_prelevement_hubeau_eso}
+#| eval: no
-```{r insert-into_nitrate_prelevement_hubeau_eso, eval = FALSE}
# Charger les données dans une nouvelle table en base
-datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
- table = "nitrate_prelevement_hubeau_eso_v0_16",
+datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
+ table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -116,18 +146,23 @@ datalibaba::poster_data(data = nitrate_qualite_nappes_prelevements,
user = "admin")
```
+
# Insertion des prélèvements Hub'eau ESO en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_hubeau_eso}
+#| eval: no
-```{r import_and_merge_tables_hubeau_eso, eval = FALSE}
# Insérer les prélèvements Hub'eau ESO vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_eso_v0_16",
+ source_table = glue::glue("nitrate_prelevement_hubeau_eso_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+
diff --git a/vignettes/insertion-des-prelevements-hubeau-esu.Rmd b/vignettes/insertion-des-prelevements-hubeau-esu.Rmd
index b24dc407a803f9fe7b1c909261646891d60f2509..00278219b017f69f728b8be6b5b6e3d5a897ec52 100644
--- a/vignettes/insertion-des-prelevements-hubeau-esu.Rmd
+++ b/vignettes/insertion-des-prelevements-hubeau-esu.Rmd
@@ -2,7 +2,7 @@
title: "Insertion des prélèvements Hubeau ESU"
output: rmarkdown::html_vignette
vignette: >
- %\VignetteIndexEntry{insertion-des-prelevements-hubeau-esu}
+ %\VignetteIndexEntry{Insertion des prélèvements Hubeau ESU}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
@@ -14,19 +14,35 @@ knitr::opts_chunk$set(
)
```
-```{r setup}
+```{r}
library(data.nitrates)
```
<!-- WARNING - This vignette is generated by {fusen} from dev/flat_insert_hubeau_esu_into_prelevement.Rmd: do not edit by hand -->
+
+
+
+```{r config}
+#| eval: no
+
+# Lire le fichier de configuration
+config <- yaml::read_yaml("config.yml")
+
+# Accéder aux valeurs pour version et last_year
+version <- config$version
+last_year <- config$last_year
+```
+
+
# Consolidation et insertion des données Hub'eau ESU dans la table des prélèvements
## Chargement des prélèvements Hub'eau ESU
La table des données brutes Nitrates Hub'eau ESU est chargée :
+```{r load-nitrate_qualite_rivieres_analyse_pc}
+#| eval: no
-```{r load-nitrate_qualite_rivieres_analyse_pc, eval = FALSE}
# Charger la table qualite_nappes_eau_souterraine.nitrate_qualite_rivieres_analyse_pc
nitrate_qualite_rivieres_prelevements <- datalibaba::importer_data(
table = "nitrate_qualite_rivieres_analyse_pc",
@@ -36,11 +52,13 @@ nitrate_qualite_rivieres_prelevements <- datalibaba::importer_data(
)
```
+
## Consolidation des prélèvements Hub'eau ESU
On remplace "." par "," dans les variables `limite_detection` et `limite_quantification` :
+```{r replace-in_limite_detection}
+#| eval: no
-```{r replace-in_limite_detection, eval = FALSE}
# Remplacer "." par "," dans les colonnes limite_detection et limite_quantification
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::mutate(
@@ -49,20 +67,24 @@ nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |
)
```
+
On ajoute les variables `source` et `nature_eau` :
+```{r add-source_code_support_hubeau_esu}
+#| eval: no
-```{r add-source_code_support_hubeau_esu, eval = FALSE}
# Ajouter les variables source et nature_eau
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::mutate(
source = "Na\u00efades",
- nature_eau = "ESO")
+ nature_eau = "ESU")
```
+
On sélectionne les champs utiles à la table des prélèvements :
+```{r select-variables_hubeau_esu}
+#| eval: no
-```{r select-variables_hubeau_esu, eval = FALSE}
# Sélectionner les variables
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::select(source,
@@ -75,42 +97,50 @@ nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |
commentaire = commentaires_analyse)
```
+
On modifie le type de la variable `code_support` de character en integer :
+```{r change-type_code_support}
+#| eval: no
-```{r change-type_code_support, eval = FALSE}
# Convertir la variable code_support de character en integer
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::mutate(code_support = as.integer(code_support))
```
+
On dédoublonne les lignes en utilisant les champs `code_station` et
`date_prelevement` afin de ne conserver qu'un prélèvement par station et date
donnée :
+```{r select-distinct-rows_hubeau_esu}
+#| eval: no
-```{r select-distinct-rows_hubeau_esu, eval = FALSE}
# Dédoublonner les lignes sur les colonnes code_station et date_prelevement
nitrate_qualite_rivieres_prelevements <- nitrate_qualite_rivieres_prelevements |>
dplyr::distinct(code_station, date_prelevement, .keep_all = TRUE)
```
+
On ajoute un identifiant unique s'appuyant sur une séquence stockée en base :
+```{r add_code_prelevement_hubeau_esu}
+#| eval: no
-```{r add_code_prelevement_hubeau_esu, eval = FALSE}
# Utiliser la fonction add_code_prelevement avec la version souhaitée
nitrate_qualite_rivieres_prelevements <- add_code_prelevement(
- nitrate_qualite_rivieres_prelevements, "v0_16")
+ nitrate_qualite_rivieres_prelevements, version)
# Afficher le dataframe pour vérifier les modifications
print(nitrate_qualite_rivieres_prelevements)
```
+
On charge les données consolidées dans une table dédiée :
+```{r insert-into_nitrate_prelevement_hubeau_esu}
+#| eval: no
-```{r insert-into_nitrate_prelevement_hubeau_esu, eval = FALSE}
# Charger les données dans une nouvelle table en base
datalibaba::poster_data(data = nitrate_qualite_rivieres_prelevements,
- table = "nitrate_prelevement_hubeau_esu_v0_16",
+ table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
schema = "nitrates",
db = "si_eau",
overwrite = TRUE,
@@ -118,18 +148,23 @@ datalibaba::poster_data(data = nitrate_qualite_rivieres_prelevements,
user = "admin")
```
+
# Insertion des prélèvements Hub'eau ESU en base dans la table globale
On insère enfin les enregistrements de cette table dans la table globale :
+```{r import_and_merge_tables_hubeau_esu}
+#| eval: no
-```{r import_and_merge_tables_hubeau_esu, eval = FALSE}
# Insérer les données de la table du dernier millésime vers la table complète
collectr::import_and_merge_tables(database = "si_eau",
- source_table = "nitrate_prelevement_hubeau_esu_v0_16",
+ source_table = glue::glue("nitrate_prelevement_hubeau_esu_", version),
source_schema = "nitrates",
- target_table = "nitrate_prelevement_v0_16",
+ target_table = glue::glue("nitrate_prelevement_", version),
target_schema = "nitrates",
role = "admin")
```
+
+
+