| 1855 |
delphine |
1 |
<?php
|
|
|
2 |
/**
|
|
|
3 |
* Exemple lancement:
|
|
|
4 |
* /opt/lampp/bin/php -d memory_limit=3500M cli.php import -n
|
|
|
5 |
*/
|
|
|
6 |
class Import extends Script {
|
|
|
7 |
private $bdd = null;
|
|
|
8 |
private $auteurs = array();
|
|
|
9 |
protected $parametres_autorises = array(
|
|
|
10 |
'-n' => array(true, false, 'Nom du fichier à importer.'));
|
|
|
11 |
|
| 1857 |
aurelien |
12 |
protected $table_publication = null;
|
|
|
13 |
protected $table_auteur = null;
|
|
|
14 |
|
| 1856 |
aurelien |
15 |
protected $colonnes_obligatoires = array();
|
|
|
16 |
protected $colonnes_acceptees = array();
|
| 1855 |
delphine |
17 |
|
| 1856 |
aurelien |
18 |
protected $cache_auteur = array();
|
|
|
19 |
|
| 1855 |
delphine |
20 |
public function __construct($script_nom, $parametres) {
|
|
|
21 |
parent::__construct($script_nom, $parametres);
|
|
|
22 |
$this->bdd = new Bdd();
|
|
|
23 |
}
|
|
|
24 |
|
|
|
25 |
public function executer() {
|
|
|
26 |
try {
|
|
|
27 |
$this->initialiserScript();
|
|
|
28 |
$cmd = $this->getParametre('a');
|
|
|
29 |
$fichier = $this->getParametre('n');
|
|
|
30 |
switch ($cmd) {
|
|
|
31 |
case "import" :
|
| 1857 |
aurelien |
32 |
$resultat = $this->charger($fichier); break;
|
| 1855 |
delphine |
33 |
default :
|
|
|
34 |
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
|
|
|
35 |
}
|
|
|
36 |
} catch (Exception $erreur) {
|
|
|
37 |
$this->traiterErreur($erreur->getMessage());
|
|
|
38 |
}
|
| 1857 |
aurelien |
39 |
|
|
|
40 |
// renvoi du résultat vers la sortie php
|
|
|
41 |
echo $resultat;
|
| 1855 |
delphine |
42 |
}
|
|
|
43 |
|
|
|
44 |
private function initialiserScript() {
|
|
|
45 |
$fichierIni = $this->getScriptChemin().'import.ini';
|
|
|
46 |
if (file_exists($fichierIni)) {
|
|
|
47 |
Config::charger($fichierIni);
|
|
|
48 |
} else {
|
| 1856 |
aurelien |
49 |
$erreur = "Veuillez configurer le projet en créant le fichier 'import.ini' ".
|
|
|
50 |
"dans le dossier du module de script du projet à partir du fichier 'import.defaut.ini'.";
|
| 1855 |
delphine |
51 |
throw new Exception($erreur);
|
|
|
52 |
}
|
| 1856 |
aurelien |
53 |
|
|
|
54 |
$this->colonnes_obligatoires= Config::get('champs_obligatoires');
|
|
|
55 |
$this->colonnes_acceptees = Config::get('champs');
|
| 1857 |
aurelien |
56 |
|
|
|
57 |
$tables = Config::get('tables');
|
|
|
58 |
$this->table_publication = $tables['publication'];
|
|
|
59 |
$this->table_auteur = $tables['auteur'];
|
| 1855 |
delphine |
60 |
}
|
|
|
61 |
|
|
|
62 |
private function charger($fichier) {
|
|
|
63 |
|
| 1856 |
aurelien |
64 |
// vérification existence fichier
|
|
|
65 |
if(!file_exists(Config::get('dossiertmp').$fichier)) {
|
|
|
66 |
$erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
|
|
|
67 |
throw new Exception($erreur);
|
|
|
68 |
}
|
|
|
69 |
|
|
|
70 |
$pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
|
|
|
71 |
// Chargement de la première colonne (qui contient les noms de colonnes à importer
|
|
|
72 |
$colonnes = fgetcsv($pointeur, 0, ";");
|
|
|
73 |
|
|
|
74 |
// Vérification des colonnes obligatoires et en même temps du séparateur
|
|
|
75 |
if(count($colonnes) < 2 || !array_intersect(array_keys($this->colonnes_obligatoires), $colonnes)) {
|
|
|
76 |
$erreur = "Le fichier ne contient pas les colonnes obligatoires : ".implode(',', array_keys($this->colonnes_obligatoires))."\n";
|
|
|
77 |
$erreur .= "ou bien n'est pas séparé par le caractère ';' ";
|
|
|
78 |
throw new Exception($erreur);
|
|
|
79 |
}
|
|
|
80 |
|
|
|
81 |
$index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
|
|
|
82 |
$colonnes_importees = array();
|
|
|
83 |
foreach($index_colonnes_importees as $index_colonne_importee) {
|
|
|
84 |
$colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
|
|
|
85 |
}
|
|
|
86 |
|
|
|
87 |
$index_colonnes_refusees = array_keys(array_diff($colonnes, array_keys($this->colonnes_acceptees)));
|
|
|
88 |
// Création d'un index associant chaque numéro de colonne importée à son rôle
|
|
|
89 |
// pour y apporter des traitement spécifiques
|
|
|
90 |
$index_colonnes_importees = $colonnes;
|
|
|
91 |
foreach($index_colonnes_refusees as $colonne_refusee) {
|
|
|
92 |
unset($index_colonnes_importees[$colonne_refusee]);
|
|
|
93 |
}
|
|
|
94 |
|
|
|
95 |
$lignes = array();
|
|
|
96 |
while($ligne = fgetcsv($pointeur, 0, ";")) {
|
|
|
97 |
$ligne_inseree = array();
|
|
|
98 |
foreach($ligne as $index => &$valeur) {
|
|
|
99 |
if(!in_array($index, $index_colonnes_refusees)) {
|
|
|
100 |
$ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
|
|
|
101 |
}
|
|
|
102 |
}
|
|
|
103 |
// Ajout du nom complet formaté de la publication
|
| 1857 |
aurelien |
104 |
$ligne_inseree[] = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
|
| 1856 |
aurelien |
105 |
$lignes[] = "(".implode(",", $ligne_inseree).")";
|
|
|
106 |
}
|
|
|
107 |
|
|
|
108 |
// Ajout de la colonne nom complet aux champs de la requête
|
|
|
109 |
$colonnes_importees[] = 'cpu_fmt_nom_complet';
|
| 1857 |
aurelien |
110 |
|
|
|
111 |
// le script renvoie le nombre de publications importées
|
|
|
112 |
return $this->insererPublications($colonnes_importees, $lignes);
|
| 1855 |
delphine |
113 |
}
|
| 1856 |
aurelien |
114 |
|
|
|
115 |
protected function formaterNomComplet($ligne, $roles) {
|
| 1857 |
aurelien |
116 |
|
|
|
117 |
$roles = array_flip($roles);
|
|
|
118 |
|
|
|
119 |
// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
|
|
|
120 |
// indication_nvt = serie_tome
|
|
|
121 |
$champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
|
|
|
122 |
$champs_fmt = array();
|
|
|
123 |
|
|
|
124 |
$fmt_nom_complet = "";
|
|
|
125 |
|
|
|
126 |
foreach($champs_nom_complet as $champ) {
|
|
|
127 |
$index = $roles[$champ];
|
|
|
128 |
if(!isset($ligne[$index])) {
|
|
|
129 |
$champs_fmt[$champ] = "";
|
|
|
130 |
} else {
|
|
|
131 |
$champs_fmt[$champ] = $ligne[$index];
|
|
|
132 |
}
|
|
|
133 |
}
|
|
|
134 |
|
|
|
135 |
$indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
|
|
|
136 |
$indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
|
|
|
137 |
$indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
|
|
|
138 |
$indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
|
|
|
139 |
|
|
|
140 |
$annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
|
|
|
141 |
$annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
|
|
|
142 |
$annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
|
|
|
143 |
|
|
|
144 |
$fmt_nom_complet = array($champs_fmt['auteur'],
|
|
|
145 |
$annee_titre_editeur,
|
|
|
146 |
$champs_fmt['intitule_revue'],
|
|
|
147 |
$champs_fmt['fascicule'],
|
|
|
148 |
$indication_nvt_pages);
|
|
|
149 |
|
|
|
150 |
$fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
|
|
|
151 |
$fmt_nom_complet = implode(", ", $fmt_nom_complet);
|
|
|
152 |
|
|
|
153 |
return $fmt_nom_complet;
|
| 1856 |
aurelien |
154 |
}
|
|
|
155 |
|
|
|
156 |
private function insererPublications(&$colonnes, &$publications) {
|
| 1857 |
aurelien |
157 |
$requete = "INSERT INTO ".$this->table_publication." ".
|
| 1856 |
aurelien |
158 |
"(".implode(',', $colonnes).") ".
|
|
|
159 |
"VALUES ".implode(","."\n", $publications)."\n";
|
|
|
160 |
|
| 1857 |
aurelien |
161 |
return $this->bdd->executer($requete);
|
| 1856 |
aurelien |
162 |
}
|
|
|
163 |
|
|
|
164 |
private function traiterChamp($valeur, $role) {
|
|
|
165 |
switch($role) {
|
|
|
166 |
case 'auteur':
|
|
|
167 |
$valeur = $this->obtenirInfosAuteur($valeur);
|
|
|
168 |
break;
|
|
|
169 |
case 'editeur':
|
|
|
170 |
$valeur = 'AUTRES##'.$valeur;
|
|
|
171 |
break;
|
|
|
172 |
}
|
|
|
173 |
|
|
|
174 |
return $this->bdd->proteger($valeur);
|
|
|
175 |
}
|
|
|
176 |
|
| 1857 |
aurelien |
177 |
private function obtenirInfosAuteur($auteur_intitule) {
|
|
|
178 |
$retour = $auteur_intitule;
|
|
|
179 |
if(isset($this->cache_auteur[$auteur_intitule])) {
|
|
|
180 |
$retour = !empty($this->cache_auteur[$auteur_intitule]['cp_id_personne']) ?
|
|
|
181 |
$this->cache_auteur[$auteur_intitule]['cp_id_personne'] :
|
|
|
182 |
$this->cache_auteur[$auteur_intitule];
|
| 1856 |
aurelien |
183 |
} else {
|
| 1857 |
aurelien |
184 |
$auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
|
| 1856 |
aurelien |
185 |
$auteur_req = "(".implode(', ', $auteur).")";
|
|
|
186 |
|
| 1857 |
aurelien |
187 |
$requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
|
| 1856 |
aurelien |
188 |
$infos_auteur = $this->bdd->recupererTous($requete);
|
|
|
189 |
|
|
|
190 |
if(!empty($infos_auteur)) {
|
|
|
191 |
$retour = $infos_auteur[0]['cp_id_personne'];
|
| 1857 |
aurelien |
192 |
$this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
|
| 1856 |
aurelien |
193 |
} else {
|
| 1857 |
aurelien |
194 |
$retour = $auteur_intitule;
|
|
|
195 |
$this->cache_auteur[$auteur_intitule] = $auteur_intitule;
|
| 1856 |
aurelien |
196 |
}
|
|
|
197 |
}
|
|
|
198 |
|
|
|
199 |
return $retour;
|
|
|
200 |
}
|
|
|
201 |
|
|
|
202 |
private function fabriquerCombinaisonsAuteur($auteur) {
|
|
|
203 |
|
|
|
204 |
$auteur = trim($auteur);
|
|
|
205 |
$auteurs_formates = array($this->bdd->proteger($auteur));
|
|
|
206 |
|
|
|
207 |
// Séparation des élements de l'auteur des espaces pour obtenir
|
|
|
208 |
// les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
|
|
|
209 |
$auteur_tab = explode(' ', $auteur);
|
|
|
210 |
$auteur_tab = array_filter($auteur_tab);
|
|
|
211 |
|
|
|
212 |
$combinaisons = array();
|
|
|
213 |
foreach($auteur_tab as &$element_auteur) {
|
|
|
214 |
$combinaisons[] = array(
|
|
|
215 |
// élement tel quel (Ex: "Linné")
|
|
|
216 |
$element_auteur,
|
|
|
217 |
// possibilité de l'initiale seule (Ex: "L")
|
|
|
218 |
substr($element_auteur, 0, 1),
|
|
|
219 |
// possibilité de l'initiale avec un point du genre (Ex: "L.")
|
|
|
220 |
substr($element_auteur, 0, 1)."."
|
|
|
221 |
);
|
|
|
222 |
}
|
|
|
223 |
|
|
|
224 |
// Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus
|
|
|
225 |
// pour deux et trois élements en faisant plusieurs produits cartésiens
|
|
|
226 |
// car le nom peut être combiné différement de celui en base de données
|
|
|
227 |
// (Ex. : "Carl Von Linné" VS "C. Von Linné" ou "C. V. Linné" ou encore "Von Linné C." etc...)
|
|
|
228 |
|
|
|
229 |
// C'est moche et pas très élégant mais bon ça marche dans 90% des cas
|
|
|
230 |
// On ne teste pas plus que 3 combinaisons, car ça serait très très couteux
|
|
|
231 |
// TODO: faire mieux et factoriser les appels ci dessous
|
|
|
232 |
if(count($auteur_tab) > 2) {
|
|
|
233 |
// Cas du nom à trois parties (genre "Carl Von Linné")
|
|
|
234 |
$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1], $combinaisons[2]));
|
|
|
235 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[0], $combinaisons[2], $combinaisons[1])));
|
|
|
236 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[2], $combinaisons[0])));
|
|
|
237 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0], $combinaisons[2])));
|
|
|
238 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[1], $combinaisons[0])));
|
|
|
239 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[0], $combinaisons[1])));
|
|
|
240 |
} else {
|
|
|
241 |
// Cas du nom à trois parties (genre "Carl Linné")
|
|
|
242 |
$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
|
|
|
243 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
|
|
|
244 |
}
|
|
|
245 |
|
|
|
246 |
$auteurs_formates = array();
|
|
|
247 |
foreach($possibilites_auteurs as &$possibilite) {
|
|
|
248 |
$initiales = true;
|
|
|
249 |
// Suppression des possibilités ne contenant que des initiales avec ou sans point
|
|
|
250 |
foreach($possibilite as &$chars) {
|
|
|
251 |
$initiales = $initiales && mb_strlen($chars) <= 2;
|
|
|
252 |
}
|
| 1855 |
delphine |
253 |
|
| 1856 |
aurelien |
254 |
if(!$initiales) {
|
|
|
255 |
$auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
|
|
|
256 |
}
|
|
|
257 |
}
|
|
|
258 |
|
|
|
259 |
return $auteurs_formates;
|
|
|
260 |
}
|
|
|
261 |
|
|
|
262 |
// http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
|
|
|
263 |
function cartesian($input) {
|
|
|
264 |
// filter out empty values
|
|
|
265 |
$input = array_filter($input);
|
|
|
266 |
|
|
|
267 |
$result = array(array());
|
|
|
268 |
|
|
|
269 |
foreach ($input as $key => $values) {
|
|
|
270 |
$append = array();
|
|
|
271 |
|
|
|
272 |
foreach($result as $product) {
|
|
|
273 |
foreach($values as $item) {
|
|
|
274 |
$product[$key] = $item;
|
|
|
275 |
$append[] = $product;
|
|
|
276 |
}
|
|
|
277 |
}
|
|
|
278 |
|
|
|
279 |
$result = $append;
|
|
|
280 |
}
|
|
|
281 |
|
|
|
282 |
return $result;
|
|
|
283 |
}
|
| 1855 |
delphine |
284 |
}
|
|
|
285 |
?>
|