.Rhistory

#   - le fichier d'erreur appellé "erreur-protocole-region-annee.txt" permet de garder les erreurs des valeurs
#   - meme si le fichier ne contient aucune erreur, il n'est pas inséré dans la base de données - a finir
# ---------------------------------------------------------------------------------------------------------------
# Positionner dans le bon répertoire
#setwd("/var/www/html/farmland/up_files")
setwd("/home/will/web/prod/dynafor/farmland/up_files")
#nom du fichier à vérifier
nom_fichier = scan("file_name.txt","",n=1)
# Lecture du fichier des fonctions
#source('oreme_functions_v1.R')
source('../scripts/oreme_db_v1.2.R')
source('../scripts/oreme_tools_v1.R')
source('../scripts/oreme_data_checking_v1.2.R')
# Parametre java
options(java.parameters = "-Xmx1512m")
# Libraries
library(RPostgreSQL) # connexion au SGBD postgres
library(XLConnect) # lecture de fichier xls
# Connection à la base farmbiodiv
connexion <- connect_db("farmland","dynuser","!Bd;09","147.100.166.41")
con <- connexion$con
#Destruction du fichier erreur.txt utilisé uniquement pour des problèmes de construction de nom de fichier
if (file.exists('erreur.txt')) file.remove('erreur.txt')
file.create('erreur.txt')
# Initialisation
verif <- TRUE #existence d'erreur (si FALSE alors on n'intégre pas dans la BDD)
continue <- TRUE #doit-on continuer les verifs ?
#ecriture dans le fichier trace_execution.txt
cat("nom_fichier : ",nom_fichier,"\n",file="trace_execution.txt",append=TRUE)
# Verification du nom du fichier (1 : Data ; 2 : protocole ; 3 : Region ; 4 : Annee ; 5 : extension xls ou xlsx)
if(regexpr('\\.xlsx$', nom_fichier) != -1 & regexpr('\\.xls$', nom_fichier) != -1)
{
write.table(paste("L'extension du fichier ", nom_fichier, " n'est pas correcte, elle doit être xls ou xlsx\n", sep = ""), file='erreur.txt',append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
if (continue)
{
# Traitement du nom du fichier
structure_nom_fichier <- unlist (strsplit(gsub(".xlsx","",nom_fichier, fixed=TRUE), '-'))
if(length(structure_nom_fichier) != 4)
{
write.table(paste("Le nom du fichier ", nom_fichier, " n'est pas correct, il doit être de la forme Data-protocole-region-annee (ex : Data-plant-Camargue-2013.xlsx)\n", sep = ""), file='erreur.txt',append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if (continue)
{
# Traitement du nom du fichier (1 : Data ; 2 : protocole ; 3 : Région ; 4 : annee ; 5 : extension xls ou xlsx)
protocole <- structure_nom_fichier[2]
region <- structure_nom_fichier[3]
annee <-  structure_nom_fichier[4]
cat("protocole",protocole,"\n")
cat("region",region,"\n")
cat("annee",annee,"\n")
#ecriture dans le fichier trace_execution.txt
cat("protocole : ",protocole," region : ",region, " année : ",annee,"\n",file="trace_execution.txt",append=TRUE)
# Construction du nom du fichier d'erreur
fichier_erreur <- paste('erreur-',protocole,'-',region,'-',annee,'.txt',sep='')
# Destruction du fichier d'erreur
if (file.exists(fichier_erreur)) file.remove(fichier_erreur)
file.create(fichier_erreur)
# Repertoire + nom du fichier
fichier_a_traiter <- nom_fichier
# Verification de l'existence du fichier
if(!file.exists(fichier_a_traiter))
{
write.table(paste("Le fichier ", fichier_a_traiter, " n'existe pas\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
# ---------------------------------------------------------------------------------------------------------------
# Programme pour vérifier les fichiers de données
# Fonctionnnement : le programme vérifie un seul fichier à la fois. il faut le spécifier dans le script.
# Remarques importantes :
#   - tout n'a pas été programmé - restes des détails à faire style lecture de la valeur de la valeur manquante
#   - vérifier l'execution du programme dans la console - toutes les erreurs ne sont pas attrapées
#   - le fichier d'erreur appellé "erreur.txt" permet de garder les erreurs (absence du fichier, mauvaus nom)
#   - le fichier d'erreur appellé "erreur-protocole-region-annee.txt" permet de garder les erreurs des valeurs
#   - meme si le fichier ne contient aucune erreur, il n'est pas inséré dans la base de données - a finir
# ---------------------------------------------------------------------------------------------------------------
# Positionner dans le bon répertoire
#setwd("/var/www/html/farmland/up_files")
setwd("/home/will/web/prod/dynafor/farmland/up_files")
#nom du fichier à vérifier
nom_fichier = scan("file_name.txt","",n=1)
# Lecture du fichier des fonctions
#source('oreme_functions_v1.R')
source('../scripts/oreme_db_v1.2.R')
source('../scripts/oreme_tools_v1.R')
source('../scripts/oreme_data_checking_v1.2.R')
# Parametre java
options(java.parameters = "-Xmx1512m")
# Libraries
library(RPostgreSQL) # connexion au SGBD postgres
library(XLConnect) # lecture de fichier xls
# Connection à la base farmbiodiv
connexion <- connect_db("farmland","dynuser","!Bd;09","147.100.166.41")
con <- connexion$con
#Destruction du fichier erreur.txt utilisé uniquement pour des problèmes de construction de nom de fichier
if (file.exists('erreur.txt')) file.remove('erreur.txt')
file.create('erreur.txt')
# Initialisation
verif <- TRUE #existence d'erreur (si FALSE alors on n'intégre pas dans la BDD)
continue <- TRUE #doit-on continuer les verifs ?
#ecriture dans le fichier trace_execution.txt
cat("nom_fichier : ",nom_fichier,"\n",file="trace_execution.txt",append=TRUE)
# Verification du nom du fichier (1 : Data ; 2 : protocole ; 3 : Region ; 4 : Annee ; 5 : extension xls ou xlsx)
if(regexpr('\\.xlsx$', nom_fichier) != -1 & regexpr('\\.xls$', nom_fichier) != -1)
{
write.table(paste("L'extension du fichier ", nom_fichier, " n'est pas correcte, elle doit être xls ou xlsx\n", sep = ""), file='erreur.txt',append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
if (continue)
{
# Traitement du nom du fichier
structure_nom_fichier <- unlist (strsplit(gsub(".xlsx","",nom_fichier, fixed=TRUE), '-'))
if(length(structure_nom_fichier) != 4)
{
write.table(paste("Le nom du fichier ", nom_fichier, " n'est pas correct, il doit être de la forme Data-protocole-region-annee (ex : Data-plant-Camargue-2013.xlsx)\n", sep = ""), file='erreur.txt',append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if (continue)
{
# Traitement du nom du fichier (1 : Data ; 2 : protocole ; 3 : Région ; 4 : annee ; 5 : extension xls ou xlsx)
protocole <- structure_nom_fichier[2]
region <- structure_nom_fichier[3]
annee <-  structure_nom_fichier[4]
cat("protocole",protocole,"\n")
cat("region",region,"\n")
cat("annee",annee,"\n")
#ecriture dans le fichier trace_execution.txt
cat("protocole : ",protocole," region : ",region, " année : ",annee,"\n",file="trace_execution.txt",append=TRUE)
# Construction du nom du fichier d'erreur
fichier_erreur <- paste('erreur-',protocole,'-',region,'-',annee,'.txt',sep='')
# Destruction du fichier d'erreur
if (file.exists(fichier_erreur)) file.remove(fichier_erreur)
file.create(fichier_erreur)
# Repertoire + nom du fichier
fichier_a_traiter <- nom_fichier
# Verification de l'existence du fichier
if(!file.exists(fichier_a_traiter))
{
write.table(paste("Le fichier ", fichier_a_traiter, " n'existe pas\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
# Est ce que le fichier a déjà été traité ?
# Requete pour interroger la table campagne_inseree dans la BDD
req <- paste("SELECT count(*) FROM campagne_inseree WHERE region='",region,"' AND protocole='",protocole,"' AND annee=",annee,sep='')
retour <- try(nb <- dbGetQuery(con,req), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete sur la table campagne_inseree : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
} else if (nb != 0)
{
cat("Ce fichier a déjà été intégré\n")
#ecriture dans le fichier trace_execution.txt
cat("Ce fichier a déjà été intégré\n",file="trace_execution.txt",append=TRUE)
write.table(paste("Ce fichier de données a déjà été intégré\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
# Lecture du classeur de données
retour <- try(wb <- loadWorkbook(fichier_a_traiter), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible de lire le fichier : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
# Lecture de(s) feuille(s) de données
retour <- try(data <- readWorksheet(wb, sheet = 1), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible de lire la feuille 1 : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
# Traduction en minuscule des noms de colonnes de la table
names(data) <- tolower(names(data))
# Remplacer les . par _ des noms de colonnes de la table
names(data) <- gsub("..", ".",names(data),fixed=TRUE)
names(data) <- gsub(".","_",names(data), fixed=TRUE)
}
# -------------------------------------------------------------------------------------
# Première partie de test : field_values
# -------------------------------------------------------------------------------------
if(continue)
{
# Requete pour interroger les 7 premiers lignes de la table field_values dans le SGBD
req <- paste('SELECT * FROM ',protocole,'.field_values LIMIT 7' ,sep='')
retour <- try(caracteristiques_autorisees <- dbGetQuery(con,req), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete sur la table field_values : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
# Suppression de la première colonne du dataframe "caracteristiques_autorisees"
caracteristiques_autorisees_sans_entete <- caracteristiques_autorisees[-1]
# Parcours des caracteristiques des attributs de la table "field_values" pour constitution de listes
attribut_name <- colnames(caracteristiques_autorisees_sans_entete)
## unique = yes (les valeurs doivent etre unique)
attribut_unique <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[1, ] == 'yes'])
## missing values accepted = no (la variable ne doit pas y avoir de valeur manquante)
attribut_missing <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[2, ] == 'no'])
attribut_missing_value <- caracteristiques_autorisees_sans_entete[3,]
## case = no (la case des valeurs n'est pas importante)
attribut_case <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[4, ] == 'no'])
attribut_type <- tolower(caracteristiques_autorisees_sans_entete[5,])
## field format <> no (les valeurs ont un format precis)
attribut_format <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[6, ] != 'no'])
attribut_list <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[7, ] == 'list'])
attribut_minmax <- colnames(caracteristiques_autorisees_sans_entete[, caracteristiques_autorisees_sans_entete[7, ] == 'min-max'])
# Verification / valeurs absentes
for(var in names(data))
{
# Verification des champs par rapport aux valeurs manquantes / missing values accepted
if (var %in% attribut_missing) {
resultat <- check_no_missing_value(var,data)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
}
}
}
if(continue)
{
# remplacement des ND dans le tableau de données data
data_sans_ND <- data
for(var in names(data_sans_ND)) if(is.character(data_sans_ND[, var]) | is.factor(data_sans_ND[, var])) data_sans_ND[ ! is.na(data_sans_ND[, var]) & data_sans_ND[, var] == "ND", var] <- NA
}
if(continue)
{
# remplacement des ',' par des '.' pour les attributs de type "real"
for(var in names(data_sans_ND))
{
if (attribut_type[which(attribut_name == var)] == 'real' & is.character(data_sans_ND[, var])) {
data_sans_ND[,var] <- gsub(',', '.', data_sans_ND[,var])
}
}
}
if (continue)
{
# Verification / valeurs attendues, valeurs uniques
for(var in names(data_sans_ND))
{
# Verification des champs par rapport aux valeurs attendues (field values = list ou min-max)
# Verifier que les valeurs de variable sont valides / field values = list
if (var %in% attribut_list) {
req <- paste('SELECT DISTINCT R1.',var,' FROM (SELECT ',var,',row_number() OVER () AS rangee FROM ',protocole,'.field_values WHERE ',var,' IS NOT NULL) AS R1 WHERE R1.rangee NOT IN (1,2,3,4,5,6,7)' ,sep='')
retour <- try(valeurs_autorisees <- dbGetQuery(con,req), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete sur les valeurs autorisees (list) de ", var, " : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
} else
{
valeurs_autorisees_missing_value <- c(valeurs_autorisees[[var]], attribut_missing_value[[var]])
# conversion pour les probl?s de c?lles ...
valeurs_autorisees_missing_value <- iconv(valeurs_autorisees_missing_value,"UTF-8","windows-1252")
if(var %in% attribut_case) cased <- F else cased <- T
#prend en compte data (et non data_sans_ND) car la valeur ND est ajoute à la liste des valeurs possibles
resultat <- check_belong (var,data,valeurs_autorisees_missing_value,cased = cased)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
}
}
# Verifier que les valeurs de variable sont valides / field values = min-max
if (var %in% attribut_minmax) {
req <- paste('SELECT DISTINCT MIN(R1.',var,') AS min, MAX(R1.',var,') AS max FROM (SELECT ',var,',row_number() OVER () AS rangee FROM ',protocole,'.field_values WHERE ',var,' IS NOT NULL) AS R1 WHERE R1.rangee NOT IN (1,2,3,4,5,6,7)' ,sep='')
retour <- try(valeurs_autorisees <- dbGetQuery(con,req), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete sur les valeurs autorisees (min-max) de ", var, " : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
} else
{
# type numeric / entier
if (attribut_type[which(attribut_name == var)] %in% c('real','integer')) {
resultat <- check_within_range (var, data_sans_ND, as.numeric(valeurs_autorisees[["min"]]), as.numeric(valeurs_autorisees[["max"]]))
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
}
# type date
#if (attribut_type[which(attribut_name == var)] %in% c('date')) {
#  resultat <- check_within_range (var, data_sans_ND, valeurs_autorisees[["min"]], valeurs_autorisees[["max"]],"date")
#  verif <- verif && resultat$res
#  if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
#}
# type heure : a faire plus tard
}
}
# Verification des champs par rapport aux valeurs uniques
if (var %in% attribut_unique) {
resultat <- check_unicity(var,data)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
}
}
}
if (continue)
{
# Verification / types attendues
# Verifier le type du contenu des colonnes et les convertir dans le type indiqué dans la table field_values - attribut_type
for (indice in 1:length(attribut_name)) {
if (attribut_type[indice] == 'text') data_sans_ND[,indice] <- as.character(data_sans_ND[,indice])
if (attribut_type[indice] == 'integer') {
resultat <- check_integer(attribut_name[indice],data_sans_ND)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
else data_sans_ND[,indice] <- as.integer(data_sans_ND[,indice])
}
if (attribut_type[indice] == 'date') {
resultat <- check_date(attribut_name[indice],data_sans_ND)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
else data_sans_ND[,indice] <- as.POSIXct(data_sans_ND[,indice])
}
if (tolower(attribut_type[indice]) == 'time') {
# utilisation de la fonction datetime car on extrait l'heure après la vérification du type
resultat <- check_datetime(attribut_name[indice],data_sans_ND)
verif <- verif && resultat$res
if(!resultat$res) write.table(resultat$msg,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
else
# Transformation en fonction du type de la variable time (dépend de la présence ou non de NA)
if (is.double(data_sans_ND[, indice])) data_sans_ND[,indice] <- substr(as.character(data_sans_ND[,indice]+51*60-21), 12, 19)
else data_sans_ND[!is.na(data_sans_ND[,indice]),indice] <- substr(as.character(as.POSIXct(data_sans_ND[!is.na(data_sans_ND[,indice]),indice])+51*60-21), 12, 19)
}
}
}
# -------------------------------------------------------------------------------------
# deuxieme partie de test
# -------------------------------------------------------------------------------------
if(continue)
{
# Requete pour interroger la table data_checking dans le SGBD
req <- paste('SELECT * FROM ',protocole,'.data_checking' ,sep='')
retour <- try(caracteristiques_autorisees <- dbGetQuery(con,req), silent = T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete sur la table data_checking : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
continue <- FALSE
}
}
if(continue)
{
#parcours de la table "data_checking" pour constitution de listes
texte <- caracteristiques_autorisees[,1]
variable_a_selectionner <- caracteristiques_autorisees[,2]
variable_pour_verification <- caracteristiques_autorisees[,3]
type_verification <- caracteristiques_autorisees[,4]
condition_a_respecter <- caracteristiques_autorisees[,5]
variable_pour_condition_a_respecter <- caracteristiques_autorisees[,6]
type_condition <- caracteristiques_autorisees[,7]
test_a_faire <- caracteristiques_autorisees[,8]
#Test générique
for (nb_test in 1:nrow(caracteristiques_autorisees)) {
#constitution des variables pour le filtre des requêtes pour condition_a_respecter
var_pour_condition_a_respecter <- unlist (strsplit(variable_pour_condition_a_respecter[nb_test], ','))
# constitution des valeurs pour le filtre des requêtes - pour condition_a_respecter
if (!is.na(var_pour_condition_a_respecter[1])) {
#il y a des variables dans la partie WHERE
val_pour_condition_a_respecter <- var_pour_condition_a_respecter
val_pour_condition_a_respecter[val_pour_condition_a_respecter == 'protocole'] <- protocole
val_pour_condition_a_respecter[val_pour_condition_a_respecter == 'region'] <- region
val_pour_condition_a_respecter[val_pour_condition_a_respecter == 'annee'] <- annee
#constitution de la requete
req <- paste (condition_a_respecter[nb_test]," WHERE ",sep='')
for(ind in 1:length(var_pour_condition_a_respecter))
{
if(ind != 1)  req <- paste (req," AND ",sep = '')
req <- paste (req, var_pour_condition_a_respecter[ind],"='",val_pour_condition_a_respecter[ind],"'",sep='')
}
}
else  req <- condition_a_respecter[nb_test]
retour <- try(valeurs_autorisees <- dbGetQuery(con,req), silent =T)
if(class(retour) == "try-error")
{
write.table(paste("Impossible d'effectuer la requete de verification (data_checking) numero ", nb_test, " : ", retour[1], "\n", sep = ""), file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
} else
{
#constitution du tableau initial
var_a_selectionner <- unlist (strsplit(variable_a_selectionner[nb_test], ','))
tableau_0 <- unique(data_sans_ND[, var_a_selectionner])
#constitution des boucles
var_pour_verification <- unlist (strsplit(variable_pour_verification[nb_test], ','))
# 1 boucle
if (length(var_pour_verification) == 1) {
for (id_1 in unique(tableau_0[,var_pour_verification[1]])) {
data_1 <- tableau_0[tableau_0[,var_pour_verification[1]] == id_1,]
if (test_a_faire[nb_test] == '<') test_valeur <- (nrow(data_1) < valeurs_autorisees[["nb"]])
else
if (test_a_faire[nb_test] == '>') test_valeur <- (nrow(data_1) > valeurs_autorisees[["nb"]])
else
if(test_a_faire[nb_test] == '!=') test_valeur <- (nrow(data_1) != valeurs_autorisees[["nb"]])
#else test_valeur <- (nrow(data_3) == valeurs_autorisees[["nb"]])
else test_valeur <- (nrow(data_1) == valeurs_autorisees[["nb"]]) # ligne modifiée car bug lors de l'intégration de données 2014 -> à vérifier (data_3 n'est pas déclarée ...)
if(test_valeur) {
txt <- paste(texte[nb_test],' : ', id_1, sep='')
write.table(txt,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
verif <- FALSE
}
}
}
# 2 boucles
if (length(var_pour_verification) == 2) {
for (id_1 in unique(tableau_0[,var_pour_verification[1]])) {
data_1 <- tableau_0[tableau_0[,var_pour_verification[1]] == id_1,]
for (id_2 in unique(data_1[,var_pour_verification[2]])) {
data_2 <- data_1[data_1[,var_pour_verification[2]] == id_2,]
if (test_a_faire[nb_test] == '<') test_valeur <- (nrow(data_2) < valeurs_autorisees[["nb"]])
else
if (test_a_faire[nb_test] == '>') test_valeur <- (nrow(data_2) > valeurs_autorisees[["nb"]])
else
if(test_a_faire[nb_test] == '!=') test_valeur <- (nrow(data_2) != valeurs_autorisees[["nb"]])
#else test_valeur <- (nrow(data_3) == valeurs_autorisees[["nb"]])
else test_valeur <- (nrow(data_2) == valeurs_autorisees[["nb"]]) # ligne modifiée car bug lors de l'intégration de données 2014 -> à vérifier (data_3 n'est pas déclarée ...)
if(test_valeur) {
txt <- paste(texte[nb_test],' : ', id_1,' ', id_2, sep='')
write.table(txt,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
verif <- FALSE
}
}
}
}
# 3 boucles
if (length(var_pour_verification) == 3) {
for (id_1 in unique(tableau_0[,var_pour_verification[1]])) {
data_1 <- tableau_0[tableau_0[,var_pour_verification[1]] == id_1,]
for (id_2 in unique(data_1[,var_pour_verification[2]])) {
data_2 <- data_1[data_1[,var_pour_verification[2]] == id_2,]
for (id_3 in unique(data_2[,var_pour_verification[3]])) {
data_3 <- data_2[data_2[,var_pour_verification[3]] == id_3,]
if (test_a_faire[nb_test] == '<') test_valeur <- (nrow(data_3) < valeurs_autorisees[["nb"]])
else
if (test_a_faire[nb_test] == '>') test_valeur <- (nrow(data_3) > valeurs_autorisees[["nb"]])
else
if(test_a_faire[nb_test] == '!=') test_valeur <- (nrow(data_3) != valeurs_autorisees[["nb"]])
else test_valeur <- (nrow(data_3) == valeurs_autorisees[["nb"]])
if(test_valeur) {
txt <- paste(texte[nb_test],' : ', id_1,' ', id_2,' ',id_3, sep='')
write.table(txt,file=fichier_erreur,append = T, row.names = F, col.names = F, quote = F)
verif <- FALSE
}
}
}
}
}
}
}
}
if(continue)
{
if(!verif) {
cat("Le fichier de données contient des erreurs. Il n'a pas été intégré la base de donnée\n")
cat("Le fichier de données contient des erreurs. Il n'a pas été intégré la base de donnée\n",file="trace_execution.txt",append=TRUE)
} else
{
cat("Le fichier de données ne contient aucune erreur\n")
#ecriture dans le fichier trace_execution.txt
cat("Le fichier de données ne contient aucune erreur\n",file="trace_execution.txt",append=TRUE)
# Récupération de l'id_data max dans la table "data"
req <- paste("SELECT MAX(id_data) FROM ", protocole, ".data", sep = "")
retour <- try(max_id <- dbGetQuery(con, req)$max, silent = T)
if(class(retour) == "try-error")
{
cat(paste("erreur sur le max id_data dans la table data du protocole", protocole, "\n", sep = ""))
#ecriture dans le fichier trace_execution.txt
cat(paste("erreur sur le max id_data dans la table data du protocole", protocole, "\n", sep = ""),file="trace_execution.txt",append=TRUE)
} else
{ # Ajout de la colonne id_data
if(is.na(max_id)) data_sans_ND$id_data <- seq(1, nrow(data_sans_ND)) else data_sans_ND$id_data <- seq(max_id + 1, (nrow(data)+ max_id))
#Initialisation de max_id si c'est le premier fichier géré pour ce protocole
if(is.na(max_id)) max_id=0
# Réorganisation des colonnes selon les noms de champs de la table table_name
data_sans_ND <- order_db_colnames(data_sans_ND, "data", protocole, con)
# Insertion de la table dans la BDD
dbWriteTable(con, c(protocole, "data"), data_sans_ND, append = T, row.names = F)
# Insertion dans la table campagne_inseree du schema public
campagne <- data.frame(region,protocole,annee,nrow(data_sans_ND),max_id+1,max_id+nrow(data_sans_ND))
dbWriteTable(con,"campagne_inseree",campagne, append = T, row.names = F)
# copie du fichier traité
file.copy(paste('Fichiers_XLS/',nom_fichier,sep=''),paste('Fichiers_XLS/Fichiers_XLS_inseres/',nom_fichier,'.traite.',Sys.Date(),sep=''),overwrite=TRUE) #reponse [1] TRUE pourquoi ?#  }
# Nombre de données de cette région/ protocole dans la BDD
cat(nrow(data_sans_ND), "données pour la région ",region,"et le protocole ",protocole," ont été ajoutés a la BDD")
#ecriture dans le fichier trace_execution.txt
cat(nrow(data_sans_ND), "données pour la région ",region,"et le protocole ",protocole," ont été ajoutés a la BDD\n",file="trace_execution.txt",append=TRUE)
}
}
}
#ecriture dans le fichier trace_execution.txt
cat("\n--------------------------\n",file="trace_execution.txt",append=TRUE)
# Déconnexion
deconnect <- disconnect_db(connexion)
slidify("jRBDD1015.Rmd")
require('slidify')
slidify("jRBDD1015.Rmd")
slidify("jRBDD1015.Rmd")
require('slidify')
slidify("Rochebrune.Rmd")
require('slidify')
slidify("jRBDD1015.Rmd")