trunk/obj/digitalizedDocument.class.php

<?php
/**
 * Ce fichier permet la déclaration de la class DigitalizedDocument 
 * conçus pour gérer les fichiers scannés
 *
 * @package openads
 * @version SVN : $Id
 */


/**
 * Cette classe permet d'effectuer les traitements sur les documents à incorporer dans l'application
 * 
 * Pour imorter les données depuis un dossier il faut utiliser run_import dans une boucle
 * qui parcourt le dossier qui abrite les répertoires des dossiers d'instructions
 * 
 * Pour purger les documents il faut utiliser la fonction run_purge dans une boucle
 * qui parcourt le dossier qui abrite les répertoires des dossiers d'instructions
 */
class DigitalizedDocument {

    /**
     * @access static
     * @var string Messages utilisées pour l'écriture dans le log
     */
    var $NO_REP = "Le dossier n'existe pas.";
    var $NO_FILES = "Le dossier est vide.";
    var $NO_FILE_EXIST = "Le fichier n'existe pas.";
    var $DOC_NO_CONFORME = "Le document n'est pas conforme a la regle RG2 : ";
    var $NO_LINK = "Le lien entre le document et le dossier d'instruction n'a pu etre etabli.";
    var $NO_MOVE = "Le fichier n'a pas pu etre deplace.";
    var $NO_DELETE_FOLDER = "Le dossier n'a pas pu etre supprime";
    var $NO_DELETE_FILE = "Le fichier n'a pas pu etre supprime : ";
    var $NO_IMPORT = "L'importation a été annulee.";
   
    /**
     * Instance de la classe utils
     * @var utils
     */
    var $f = NULL;

    /**
     * Instance du filestorage
     * @var storage
     */
    var $filestorage = NULL;

    /**
     * Constructeur
     */
    public function __construct($f) {

        //
        $this->f = $f;
        // Permet lors de l'instantiation d'objets métiers d'avoir accès à f
        $GLOBALS['f'] = $this->f;

        // initialise le msg attribute qui est utilise pour stocker les
        // messages de retour (reussite ou erreur)
        $this->msg = '';

        //Instance de filestorage
        $this->filestorage = $this->f->storage;

    }

    /**
     * Destructeur
     */
    public function __destruct() {

        //Détruit les instance de utils et filestorage
        unset($this->f);
        unset($this->filestorage);

        //Détruit la variable globale de 'f'
        unset($GLOBALS['f']);

    }

    /**
     * Récupère l'identifiant du type de document par rapport au code
     * @param  string $code Code du type de document
     * @return int       Identifiant du type de document
     */
    private function get_document_numerise_by_code($code) {

        //Requête SQL
        $sql = "SELECT document_numerise_type 
                FROM ".DB_PREFIXE."document_numerise_type 
                WHERE code = '".$code."'";
        $document_numerise_type = $this->f->db->getOne($sql);
        $this->f->addToLog("obj/digitalizedDocument.class.php : db->getOne(".$sql.")", VERBOSE_MODE);
        $this->f->isDatabaseError($document_numerise_type);

        //retourne la clé primaire
        return $document_numerise_type;
    }

    /**
     * Ajoute une chaine de caracteres dans le log.
     * @param string $message Le message qui doit etre ajouté dans le log.
     * @param mixed $type Le mode de log.
     */
    protected function addToLog($message, $type = DEBUG_MODE) {
        //
        logger::instance()->log("class ".get_class($this)." : "."method ".__METHOD__." - ".$message, $type);
    }

    /**
     * Cette fonction permet de recupérer et de classer dans un tableau
     * la liste des documents présent dans le dossier passé en paramètre
     * @param string $path Le chemin vers le dossier
     * @return array Tableau des documents
     */
    public function listFiles($path) {
        
        //Tableau qui sera retourné en fin de traitement
        $listFiles = array();
        
        //Ouvre le répertoire
        $dir = opendir($path);

        //Si un dossier est ouvert
        if ($dir) {

            //Parcours le dossier
            while(false !== ($file = readdir($dir))) {

                //Si le document est bien un fichier de type pdf
                if($file != '.' && $file != '..' && !is_dir($dir.$file) 
                    && strcasecmp(strstr($file, '.'), ".pdf") == 0) {

                    //Alors il est ajouté dans le tableau
                    array_push($listFiles, $file);

                }

            }

            //Ferme le répertoire
            closedir($dir);

        } else {

            //Sinon renvoi null
            $this->addToLog($this->NO_REP);
            return null;
        }

        //Si le tableau est vide on retourne null
        if (count($listFiles) == 0) {

            $this->addToLog($this->NO_FILES);
            return null;

        }

        //Retourne le tableau des documents
        return $listFiles;
        
    }

    /**
     * Cette fonction permet de construire les métadonnées d'un document
     * à partir des informations du nom du fichier
     * @param string $filename Nom du fichier
     * @return array Tableau des metadonnées
     */
    public function extractMetadataFromFilename($filename) {

        //Tableau qui sera retourné en fin de traitement
        $metadata = array();
        
        //Récupération de l'année
        $year = substr($filename, 0, 4);
        //Récupération du mois 
        $month = substr($filename, 4, 2);
        //Récupération du jour
        $day = substr($filename, 6, 2);
        
        //Vérification que l'année, le mois et le jour sont des numériques
        if (is_numeric($year) && is_numeric($month) && is_numeric($day)) {

            //Vérification que cela correspond à une date possible
            if (checkdate($month, $day, $year)) {

                //Récupération du type de document
                //Si le séparateur '-' n'est pas présent
                if (strpos($filename, '-') === false) {

                    //On récupère le nom du fichier avant l'extension
                    $type_doc = substr(strstr($filename, '.', true), 8);

                } else {

                    //Sinon on récupère le nom du fichier avant le '-'
                    $type_doc = substr(strstr($filename, '-', true), 8);

                }

                //Si aucun type de document n'a pu être extrait
                if (empty($type_doc)) {

                    //On retourne null
                    $this->addToLog($this->DOC_NO_CONFORME.$filename);
                    return null;

                } else {

                    //Sinon on ajoute le type de document dans les métadonnées
                    $metadata['type_doc'] = $type_doc;

                }
                
                //Formate la date du document
                $metadata["date_evenement"] = date("d/m/Y", mktime(0, 0, 0, $month, $day, $year));

                //Si le tableau est vide on retourne null
                if (count($metadata) == 0) {

                    $this->addToLog($this->DOC_NO_CONFORME.$filename);
                    return null;

                }

                //On retourne les métadonnées
                return $metadata;
            }
        }

        //Le nom du document n'est pas conforme
        $this->addToLog($this->DOC_NO_CONFORME.$filename);
        return null;
        
    }

    /**
     * Cette fonction permet de récupérer des informations sur le fichier
     * nécessaire pour le filestorage
     * @param  string $path     Chemin du dossier
     * @param  string $filename Nom du fichier
     * @return array           Tableau des métadonnées
     */
    public function extractMetadataToFilestorage($path, $filename) {

        //Test si le fichier existe
        if (!file_exists($path.'/'.$filename)) {
            //
            $this->addToLog($this->NO_FILE_EXIST);
            return null;
        }

        //Tableau qui sera retourné en fin de traitement
        $metadata = array();

        //Métadonnées nécessaire au filestorage
        $metadata["filename"] = $filename;
        $metadata["size"] = filesize($path.'/'.$filename);
        $metadata["mimetype"] = mime_content_type($path.'/'.$filename);

        //Si le tableau est vide on retourne null
        if (count($metadata) == 0) {

            $this->addToLog($this->DOC_NO_CONFORME.$filename);
            return null;

        }    

        //Retourne le tableau des métadonnées
        return $metadata;
    }

    /**
     * Cette fonction permet de créer un document temporaire dans le filesystem
     * @param string $file_content Contenu du fichier
     * @param array $metadata Métadonnées du fichier
     * @return string $uid identifiant du document dans le filesystem
     */
    public function createFileTemporary($file_content, $metadata) {

        //Création du fichier sur le filestorage
        $uid = $this->filestorage->create_temporary($file_content, $metadata);

        //Retourne l'identifiant unique du fichier créé
        return $uid;
        
    }

    /**
     * Permet de lier le document importé à l'application et de le créer dans le filestorage
     * @param  object $document_numerise Instance de la classe document_numerise
     * @param  string $uid               Identifiant du fichier temporaire
     * @param  string $dossier           Identifiant du dossier d'instruction
     * @param  string $filename          Nom du document
     * @param  mixed $db                 Référence à la bdd
     * @param  mixed $DEBUG              Mode de debug
     * @return boolean                   Vrai ou faux
     */
    public function createDocumentNumerise($document_numerise, $uid, $dossier, $filename, $db, $DEBUG = NULL) {
        
        //Maj en ajout
        $document_numerise->setParameter("maj",0);

        //Extrait les informations du nom du document
        $metadataFromFilename = $this->extractMetadataFromFilename($filename);

        //Données
        $values = array(
            'document_numerise' => '',
            'uid' => 'tmp|'.$uid,
            'dossier' => $dossier,
            'nom_fichier' => '',
            'date_creation' => $metadataFromFilename['date_evenement'],
            'document_numerise_type' => $this->get_document_numerise_by_code($metadataFromFilename['type_doc']),
        );

        //Ajoute dans la table le lien
        $document_numerise->ajouter($values, $db, $DEBUG);

        //Si le document n'est pas ajouté
        if (!$document_numerise->correct) {

            //Log d'erreur
            $this->addToLog($this->NO_LINK);
            return false;
        }

        return $document_numerise->valF['document_numerise'];
    }

    /**
     * Permet de déplacer les fichiers créés dans le filestorage vers le dossier 
     * des fichiers traités
     * @param  string $pathSrc     Chemin du dossier source
     * @param  string $pathDes     Chemin du dossier de destination
     * @param  string $filename    Nom du fichier
     * @return boolean Retourne true si le fichier à été déplacé sinon false 
     */
    public function moveDocumentNumerise($pathSrc, $pathDes, $filename) {

        //Si le dossier de destination n'existe pas, il est créé
        if (!file_exists($pathDes)) {
            mkdir($pathDes);
        }
        
        //Déplace le document
        $move = rename($pathSrc.'/'.$filename, $pathDes.'/'.$filename);

        //Si le déplacement à réussi
        if ($move) {

            //On retourne TRUE
            return true;
        } 

        //Si le deplacement n'est pas fait on retourne false
        $this->addToLog($this->NO_MOVE);
        return false;
        
    }

    /**
     * Cette fonction permet de vider un répertoire
     * Si la date d'import du fichier et le nombre de jour ne sont pas renseignés
     * alors les fichiers sont supprimés sans vérification sur la date
     * @param string $file Fichier traité
     * @param date $dateImport Date de l'importation du fichier
     * @param int $nbDay Nombre de jour à soustraite à la date du jour
     * @return boolean true si le traitement à été fait sinon false
     */
    public function purgeFiles($file, $dateImport = null, $nbDay = null) {

        //Si la date et le nombre de jour ne sont pas renseigné
        if (($nbDay == 'null' || $nbDay == null || $nbDay == '') 
            && ($dateImport == 'null' || $dateImport == null || $dateImport == '')) {

            //On supprime le fichier sans faire de test
            if (unlink($file)) {
              
                return true;

            }

        //Si la date d'import et le nombre de jour sont renseignés
        } else {

            //Date d'import dans un format correct pour la comparaison
            $dateImport = new DateTime($dateImport);
            $dateImport = $dateImport->format('Ymd');

            //Date limite pour la suppresion des fichier (Date du jour - 60 jours)
            $dateLimit = date('d-m-Y', strtotime("- $nbDay day", strtotime(date('d-m-Y'))));
            $dateLimit = new DateTime($dateLimit);
            $dateLimit = $dateLimit->format('Ymd');

            //Si la date du fichier à dépassé la date limite
            if ($dateImport <= $dateLimit) {

                //on supprime le fichier
                if (unlink($file)) {
                    
                    return true;

                }

            }

        }

        //Si aucun traitement n'a été fait on retourne false
        $this->addToLog($this->NO_DELETE_FILE.$file);
        return false;

    }

    /**
     * Cette fonction permet de supprimer un dossier
     * @param  string $path Chemin du dossier
     * @return boolean       Retourn vrai si le dossier à été supprimé sinon faux
     */
    public function deleteFolder($path) {

        //Si le fichier est supprimé on retourne true
        if (rmdir($path)) {
            return true;
        }

        //Si le fichier n'a pas été supprimé on retourne false
        $this->addToLog($this->NO_DELETE_FOLDER);
        return false;

    }

    /**
     * Cette fonction permet de lancer toutes les fonctions utiles 
     * à l'importation des documents scannés
     * @param string $pathSrc Le chemin vers le dossier à traiter
     * @param string $pathDes Le chemin vers le dossier après le traitement
     * @param mixed $DEBUG mode de débuggage
     * @return boolean true si le traitement à été fait sinon false
     */
    function run_import($pathSrc, $pathDes, $DEBUG = NULL) {
        
        //Récupération du nom du répertoire
        $foldername = substr(strrchr($pathSrc, "/"), 1);

        //Identifiant du dossier
        $dossier = str_replace('.', '', $foldername);

        //Instancie la class document_numerise
        require_once "../obj/document_numerise.class.php";
        $document_numerise = new document_numerise("]", $this->f->db, $DEBUG);

        //Valeur retour formulaire
        $document_numerise->retourformulaire = "dossier_instruction";

        //Liste les documents contenus dans le dossier
        $listFiles = $this->listFiles($pathSrc);
        //Si il n'y a aucun document
        if ($listFiles === null) {
            //On annule l'importation
            $this->addToLog($this->NO_IMPORT);
            return false;
        }
        
        foreach ($listFiles as $key => $filename) {

            //Construit les métadonnées
            $metadata = array();
            //Données récupérées pour le filestorage
            $metadata = $this->extractMetadataToFilestorage($pathSrc, $filename);

            //S'il y a des métadonnées
            if ($metadata !== null) {

                //Recupère le contenu du fichier
                $file_content = file_get_contents($pathSrc.'/'.$filename);

                //Créer le fichier temporaire
                $uid = $this->createFileTemporary($file_content, $metadata);

                //Si le fichier est créé
                if ($uid !== null) {

                    //Créer le document sur le filestorage et dans la table document_numerise
                    $createFileStorage = $this->createDocumentNumerise($document_numerise, $uid, $dossier, $filename, $this->f->db, $DEBUG);

                    //Si le document est crée sur le filestorage
                    if ($createFileStorage !== false) {

                        //On déplace le document créé dans le filestorage
                        //du dossier des "à traiter" vers celui des "traités"
                        $this->moveDocumentNumerise($pathSrc, $pathDes, $filename);

                    }

                }
            }

        }//Fin foreach

        //Retourne true
        return true;

    }

    /**
     * Cette fonction permet de lancer toutes les fonctions utiles à la purge de dossier
     * @param string $path Le chemin vers le dossier
     * @param int $nbDay Nombre de jour à soustraite à la date du jour
     * @return boolean true si le traitement à été fait sinon false
     */
    function run_purge($path, $nbDay = null) {

        //Liste les documents contenus dans le dossier
        $listFiles = $this->listFiles($path);

        if ($listFiles !== null) {

            //Parcours la liste des fichiers
            foreach ($listFiles as $key => $filename) {
                //Fichier
                $file = $path.'/'.$filename;
                //Si le nombre de jour est renseigné
                if ($nbDay !== null) {

                    //il faut renseigner la date d'import du fichier
                    $dateImport = date("Y-m-d", filemtime($file));

                } else {

                    //Sinon la date d'import est null
                    $dateImport = null;

                }
                
                //S'il n'y pas d'erreur on exécute la fonction purgeFiles
                $this->purgeFiles($file, $dateImport, $nbDay);
            }

            //Analyse le dossier après traitement
            $listFiles = $this->listFiles($path);
        }
        
        //Si il n'y a plus de document
        if ($listFiles === null) {

            //on supprime le dossier
            $deleteFolder = $this->deleteFolder($path);
            //Si le dossier n'a pas été supprimé on retourne false
            if (!$deleteFolder) {

                return false;
            }
        }

        //Si il n'y a pas d'erreur on retourne true
        return true;
        
    }

}

?>
1	softime	1835	<?php
2			/**
3			* Ce fichier permet la déclaration de la class DigitalizedDocument
4			* conçus pour gérer les fichiers scannés
5			*
6			* @package openads
7			* @version SVN : $Id
8			*/
9
10
11	fmichon	1860
12	softime	1835	/**
13			* Cette classe permet d'effectuer les traitements sur les documents à incorporer dans l'application
14			*
15			* Pour imorter les données depuis un dossier il faut utiliser run_import dans une boucle
16			* qui parcourt le dossier qui abrite les répertoires des dossiers d'instructions
17			*
18			* Pour purger les documents il faut utiliser la fonction run_purge dans une boucle
19			* qui parcourt le dossier qui abrite les répertoires des dossiers d'instructions
20			*/
21			class DigitalizedDocument {
22
23			/**
24			* @access static
25			* @var string Messages utilisées pour l'écriture dans le log
26			*/
27			var $NO_REP = "Le dossier n'existe pas.";
28			var $NO_FILES = "Le dossier est vide.";
29			var $NO_FILE_EXIST = "Le fichier n'existe pas.";
30			var $DOC_NO_CONFORME = "Le document n'est pas conforme a la regle RG2 : ";
31			var $NO_LINK = "Le lien entre le document et le dossier d'instruction n'a pu etre etabli.";
32	softime	1851	var $NO_MOVE = "Le fichier n'a pas pu etre deplace.";
33			var $NO_DELETE_FOLDER = "Le dossier n'a pas pu etre supprime";
34			var $NO_DELETE_FILE = "Le fichier n'a pas pu etre supprime : ";
35	softime	1876	var $NO_IMPORT = "L'importation a été annulee.";
36	softime	1851
37	softime	1835	/**
38			* Instance de la classe utils
39			* @var utils
40			*/
41			var $f = NULL;
42
43			/**
44			* Instance du filestorage
45			* @var storage
46			*/
47			var $filestorage = NULL;
48
49			/**
50			* Constructeur
51			*/
52	fmichon	1860	public function __construct($f) {
53	softime	1835
54	fmichon	1860	//
55			$this->f = $f;
56	softime	1835	// Permet lors de l'instantiation d'objets métiers d'avoir accès à f
57			$GLOBALS['f'] = $this->f;
58
59			// initialise le msg attribute qui est utilise pour stocker les
60			// messages de retour (reussite ou erreur)
61			$this->msg = '';
62
63			//Instance de filestorage
64			$this->filestorage = $this->f->storage;
65
66			}
67
68			/**
69			* Destructeur
70			*/
71			public function __destruct() {
72
73			//Détruit les instance de utils et filestorage
74			unset($this->f);
75			unset($this->filestorage);
76
77	softime	1929	//Détruit la variable globale de 'f'
78	softime	1835	unset($GLOBALS['f']);
79
80			}
81
82			/**
83	softime	1929	* Récupère l'identifiant du type de document par rapport au code
84			* @param string $code Code du type de document
85			* @return int Identifiant du type de document
86			*/
87			private function get_document_numerise_by_code($code) {
88
89			//Requête SQL
90			$sql = "SELECT document_numerise_type
91			FROM ".DB_PREFIXE."document_numerise_type
92			WHERE code = '".$code."'";
93			$document_numerise_type = $this->f->db->getOne($sql);
94			$this->f->addToLog("obj/digitalizedDocument.class.php : db->getOne(".$sql.")", VERBOSE_MODE);
95			$this->f->isDatabaseError($document_numerise_type);
96
97			//retourne la clé primaire
98			return $document_numerise_type;
99			}
100
101			/**
102	softime	1835	* Ajoute une chaine de caracteres dans le log.
103			* @param string $message Le message qui doit etre ajouté dans le log.
104			* @param mixed $type Le mode de log.
105			*/
106			protected function addToLog($message, $type = DEBUG_MODE) {
107			//
108			logger::instance()->log("class ".get_class($this)." : "."method ".__METHOD__." - ".$message, $type);
109			}
110
111			/**
112			* Cette fonction permet de recupérer et de classer dans un tableau
113			* la liste des documents présent dans le dossier passé en paramètre
114			* @param string $path Le chemin vers le dossier
115			* @return array Tableau des documents
116			*/
117			public function listFiles($path) {
118
119			//Tableau qui sera retourné en fin de traitement
120			$listFiles = array();
121
122			//Ouvre le répertoire
123			$dir = opendir($path);
124
125			//Si un dossier est ouvert
126			if ($dir) {
127
128			//Parcours le dossier
129			while(false !== ($file = readdir($dir))) {
130
131			//Si le document est bien un fichier de type pdf
132			if($file != '.' && $file != '..' && !is_dir($dir.$file)
133	softime	1876	&& strcasecmp(strstr($file, '.'), ".pdf") == 0) {
134	softime	1835
135			//Alors il est ajouté dans le tableau
136			array_push($listFiles, $file);
137
138			}
139
140			}
141
142			//Ferme le répertoire
143			closedir($dir);
144
145	softime	1851	} else {
146
147			//Sinon renvoi null
148			$this->addToLog($this->NO_REP);
149			return null;
150	softime	1835	}
151
152			//Si le tableau est vide on retourne null
153			if (count($listFiles) == 0) {
154
155			$this->addToLog($this->NO_FILES);
156			return null;
157
158			}
159
160			//Retourne le tableau des documents
161			return $listFiles;
162
163			}
164
165			/**
166			* Cette fonction permet de construire les métadonnées d'un document
167			* à partir des informations du nom du fichier
168			* @param string $filename Nom du fichier
169			* @return array Tableau des metadonnées
170			*/
171			public function extractMetadataFromFilename($filename) {
172
173			//Tableau qui sera retourné en fin de traitement
174			$metadata = array();
175
176			//Récupération de l'année
177			$year = substr($filename, 0, 4);
178			//Récupération du mois
179			$month = substr($filename, 4, 2);
180			//Récupération du jour
181			$day = substr($filename, 6, 2);
182
183			//Vérification que l'année, le mois et le jour sont des numériques
184			if (is_numeric($year) && is_numeric($month) && is_numeric($day)) {
185
186			//Vérification que cela correspond à une date possible
187			if (checkdate($month, $day, $year)) {
188
189			//Récupération du type de document
190			//Si le séparateur '-' n'est pas présent
191			if (strpos($filename, '-') === false) {
192
193			//On récupère le nom du fichier avant l'extension
194			$type_doc = substr(strstr($filename, '.', true), 8);
195
196			} else {
197
198			//Sinon on récupère le nom du fichier avant le '-'
199			$type_doc = substr(strstr($filename, '-', true), 8);
200
201			}
202
203	softime	1929	//Si aucun type de document n'a pu être extrait
204	softime	1835	if (empty($type_doc)) {
205
206			//On retourne null
207			$this->addToLog($this->DOC_NO_CONFORME.$filename);
208			return null;
209
210			} else {
211
212			//Sinon on ajoute le type de document dans les métadonnées
213			$metadata['type_doc'] = $type_doc;
214
215			}
216
217			//Formate la date du document
218			$metadata["date_evenement"] = date("d/m/Y", mktime(0, 0, 0, $month, $day, $year));
219
220			//Si le tableau est vide on retourne null
221			if (count($metadata) == 0) {
222
223			$this->addToLog($this->DOC_NO_CONFORME.$filename);
224			return null;
225
226			}
227
228			//On retourne les métadonnées
229			return $metadata;
230			}
231			}
232
233			//Le nom du document n'est pas conforme
234			$this->addToLog($this->DOC_NO_CONFORME.$filename);
235			return null;
236
237			}
238
239			/**
240			* Cette fonction permet de récupérer des informations sur le fichier
241			* nécessaire pour le filestorage
242			* @param string $path Chemin du dossier
243			* @param string $filename Nom du fichier
244			* @return array Tableau des métadonnées
245			*/
246			public function extractMetadataToFilestorage($path, $filename) {
247
248			//Test si le fichier existe
249			if (!file_exists($path.'/'.$filename)) {
250			//
251			$this->addToLog($this->NO_FILE_EXIST);
252			return null;
253			}
254
255			//Tableau qui sera retourné en fin de traitement
256			$metadata = array();
257
258			//Métadonnées nécessaire au filestorage
259			$metadata["filename"] = $filename;
260			$metadata["size"] = filesize($path.'/'.$filename);
261			$metadata["mimetype"] = mime_content_type($path.'/'.$filename);
262
263			//Si le tableau est vide on retourne null
264			if (count($metadata) == 0) {
265
266			$this->addToLog($this->DOC_NO_CONFORME.$filename);
267			return null;
268
269			}
270
271			//Retourne le tableau des métadonnées
272			return $metadata;
273			}
274
275			/**
276	softime	1892	* Cette fonction permet de créer un document temporaire dans le filesystem
277	softime	1835	* @param string $file_content Contenu du fichier
278	softime	1892	* @param array $metadata Métadonnées du fichier
279			* @return string $uid identifiant du document dans le filesystem
280	softime	1835	*/
281	softime	1929	public function createFileTemporary($file_content, $metadata) {
282	softime	1835
283			//Création du fichier sur le filestorage
284	softime	1892	$uid = $this->filestorage->create_temporary($file_content, $metadata);
285	softime	1835
286			//Retourne l'identifiant unique du fichier créé
287			return $uid;
288
289			}
290
291			/**
292	softime	1892	* Permet de lier le document importé à l'application et de le créer dans le filestorage
293	softime	1929	* @param object $document_numerise Instance de la classe document_numerise
294			* @param string $uid Identifiant du fichier temporaire
295			* @param string $dossier Identifiant du dossier d'instruction
296			* @param string $filename Nom du document
297			* @param mixed $db Référence à la bdd
298			* @param mixed $DEBUG Mode de debug
299			* @return boolean Vrai ou faux
300	softime	1835	*/
301	softime	1929	public function createDocumentNumerise($document_numerise, $uid, $dossier, $filename, $db, $DEBUG = NULL) {
302	softime	1835
303	softime	1929	//Maj en ajout
304	softime	1835	$document_numerise->setParameter("maj",0);
305
306	softime	1929	//Extrait les informations du nom du document
307			$metadataFromFilename = $this->extractMetadataFromFilename($filename);
308	softime	1892
309	softime	1835	//Données
310			$values = array(
311			'document_numerise' => '',
312	softime	1929	'uid' => 'tmp\|'.$uid,
313			'dossier' => $dossier,
314	softime	1892	'nom_fichier' => '',
315	softime	1929	'date_creation' => $metadataFromFilename['date_evenement'],
316	softime	1892	'document_numerise_type' => $this->get_document_numerise_by_code($metadataFromFilename['type_doc']),
317	softime	1835	);
318
319			//Ajoute dans la table le lien
320			$document_numerise->ajouter($values, $db, $DEBUG);
321
322	softime	1929	//Si le document n'est pas ajouté
323	softime	1851	if (!$document_numerise->correct) {
324	softime	1835
325	softime	1929	//Log d'erreur
326	softime	1835	$this->addToLog($this->NO_LINK);
327			return false;
328	softime	1851	}
329	softime	1835
330	softime	1929	return $document_numerise->valF['document_numerise'];
331	softime	1835	}
332
333			/**
334			* Permet de déplacer les fichiers créés dans le filestorage vers le dossier
335			* des fichiers traités
336			* @param string $pathSrc Chemin du dossier source
337			* @param string $pathDes Chemin du dossier de destination
338			* @param string $filename Nom du fichier
339			* @return boolean Retourne true si le fichier à été déplacé sinon false
340			*/
341	softime	1929	public function moveDocumentNumerise($pathSrc, $pathDes, $filename) {
342	softime	1835
343			//Si le dossier de destination n'existe pas, il est créé
344			if (!file_exists($pathDes)) {
345			mkdir($pathDes);
346			}
347
348			//Déplace le document
349			$move = rename($pathSrc.'/'.$filename, $pathDes.'/'.$filename);
350
351			//Si le déplacement à réussi
352			if ($move) {
353
354			//On retourne TRUE
355			return true;
356			}
357
358			//Si le deplacement n'est pas fait on retourne false
359			$this->addToLog($this->NO_MOVE);
360			return false;
361
362			}
363
364			/**
365			* Cette fonction permet de vider un répertoire
366	softime	1851	* Si la date d'import du fichier et le nombre de jour ne sont pas renseignés
367			* alors les fichiers sont supprimés sans vérification sur la date
368	softime	1835	* @param string $file Fichier traité
369			* @param date $dateImport Date de l'importation du fichier
370			* @param int $nbDay Nombre de jour à soustraite à la date du jour
371			* @return boolean true si le traitement à été fait sinon false
372			*/
373			public function purgeFiles($file, $dateImport = null, $nbDay = null) {
374	softime	1942
375			//Si la date et le nombre de jour ne sont pas renseigné
376			if (($nbDay == 'null' \|\| $nbDay == null \|\| $nbDay == '')
377			&& ($dateImport == 'null' \|\| $dateImport == null \|\| $dateImport == '')) {
378
379			//On supprime le fichier sans faire de test
380			if (unlink($file)) {
381
382			return true;
383
384			}
385
386			//Si la date d'import et le nombre de jour sont renseignés
387			} else {
388
389	softime	1892	//Date d'import dans un format correct pour la comparaison
390			$dateImport = new DateTime($dateImport);
391			$dateImport = $dateImport->format('Ymd');
392
393			//Date limite pour la suppresion des fichier (Date du jour - 60 jours)
394	softime	1835	$dateLimit = date('d-m-Y', strtotime("- $nbDay day", strtotime(date('d-m-Y'))));
395	softime	1892	$dateLimit = new DateTime($dateLimit);
396			$dateLimit = $dateLimit->format('Ymd');
397
398	softime	1835	//Si la date du fichier à dépassé la date limite
399	softime	1892	if ($dateImport <= $dateLimit) {
400	softime	1835
401			//on supprime le fichier
402			if (unlink($file)) {
403
404			return true;
405
406			}
407
408			}
409
410			}
411
412			//Si aucun traitement n'a été fait on retourne false
413	softime	1851	$this->addToLog($this->NO_DELETE_FILE.$file);
414	softime	1835	return false;
415
416			}
417
418			/**
419			* Cette fonction permet de supprimer un dossier
420			* @param string $path Chemin du dossier
421			* @return boolean Retourn vrai si le dossier à été supprimé sinon faux
422			*/
423			public function deleteFolder($path) {
424
425			//Si le fichier est supprimé on retourne true
426			if (rmdir($path)) {
427			return true;
428			}
429
430			//Si le fichier n'a pas été supprimé on retourne false
431	softime	1851	$this->addToLog($this->NO_DELETE_FOLDER);
432	softime	1835	return false;
433
434			}
435
436			/**
437			* Cette fonction permet de lancer toutes les fonctions utiles
438			* à l'importation des documents scannés
439			* @param string $pathSrc Le chemin vers le dossier à traiter
440			* @param string $pathDes Le chemin vers le dossier après le traitement
441			* @param mixed $DEBUG mode de débuggage
442			* @return boolean true si le traitement à été fait sinon false
443			*/
444	softime	1876	function run_import($pathSrc, $pathDes, $DEBUG = NULL) {
445	softime	1835
446			//Récupération du nom du répertoire
447			$foldername = substr(strrchr($pathSrc, "/"), 1);
448	nhaye	1900
449	softime	1929	//Identifiant du dossier
450			$dossier = str_replace('.', '', $foldername);
451	nhaye	1900
452	softime	1929	//Instancie la class document_numerise
453			require_once "../obj/document_numerise.class.php";
454			$document_numerise = new document_numerise("]", $this->f->db, $DEBUG);
455	softime	1835
456	softime	1929	//Valeur retour formulaire
457			$document_numerise->retourformulaire = "dossier_instruction";
458
459	softime	1835	//Liste les documents contenus dans le dossier
460			$listFiles = $this->listFiles($pathSrc);
461			//Si il n'y a aucun document
462			if ($listFiles === null) {
463			//On annule l'importation
464			$this->addToLog($this->NO_IMPORT);
465			return false;
466			}
467
468			foreach ($listFiles as $key => $filename) {
469
470			//Construit les métadonnées
471			$metadata = array();
472	nhaye	1900	//Données récupérées pour le filestorage
473			$metadata = $this->extractMetadataToFilestorage($pathSrc, $filename);
474	softime	1835
475			//S'il y a des métadonnées
476			if ($metadata !== null) {
477
478			//Recupère le contenu du fichier
479			$file_content = file_get_contents($pathSrc.'/'.$filename);
480
481	softime	1929	//Créer le fichier temporaire
482			$uid = $this->createFileTemporary($file_content, $metadata);
483
484	softime	1835	//Si le fichier est créé
485			if ($uid !== null) {
486
487	softime	1929	//Créer le document sur le filestorage et dans la table document_numerise
488			$createFileStorage = $this->createDocumentNumerise($document_numerise, $uid, $dossier, $filename, $this->f->db, $DEBUG);
489	softime	1835
490	softime	1929	//Si le document est crée sur le filestorage
491			if ($createFileStorage !== false) {
492	softime	1835
493	softime	1929	//On déplace le document créé dans le filestorage
494	softime	1835	//du dossier des "à traiter" vers celui des "traités"
495	softime	1929	$this->moveDocumentNumerise($pathSrc, $pathDes, $filename);
496	softime	1835
497			}
498
499			}
500			}
501
502			}//Fin foreach
503
504			//Retourne true
505			return true;
506
507			}
508
509			/**
510			* Cette fonction permet de lancer toutes les fonctions utiles à la purge de dossier
511			* @param string $path Le chemin vers le dossier
512			* @param int $nbDay Nombre de jour à soustraite à la date du jour
513			* @return boolean true si le traitement à été fait sinon false
514			*/
515			function run_purge($path, $nbDay = null) {
516
517			//Liste les documents contenus dans le dossier
518			$listFiles = $this->listFiles($path);
519
520	softime	1934	if ($listFiles !== null) {
521	softime	1835
522	softime	1934	//Parcours la liste des fichiers
523			foreach ($listFiles as $key => $filename) {
524			//Fichier
525			$file = $path.'/'.$filename;
526			//Si le nombre de jour est renseigné
527			if ($nbDay !== null) {
528	softime	1835
529	softime	1934	//il faut renseigner la date d'import du fichier
530			$dateImport = date("Y-m-d", filemtime($file));
531	softime	1835
532	softime	1934	} else {
533	softime	1835
534	softime	1934	//Sinon la date d'import est null
535			$dateImport = null;
536
537			}
538
539			//S'il n'y pas d'erreur on exécute la fonction purgeFiles
540			$this->purgeFiles($file, $dateImport, $nbDay);
541	softime	1835	}
542	softime	1934
543			//Analyse le dossier après traitement
544			$listFiles = $this->listFiles($path);
545	softime	1835	}
546
547			//Si il n'y a plus de document
548			if ($listFiles === null) {
549
550			//on supprime le dossier
551			$deleteFolder = $this->deleteFolder($path);
552			//Si le dossier n'a pas été supprimé on retourne false
553			if (!$deleteFolder) {
554
555			return false;
556			}
557			}
558
559			//Si il n'y a pas d'erreur on retourne true
560			return true;
561
562			}
563
564			}
565
566			?>