trunk/obj/digitalizedDocument.class.php

<?php
/**
 * Ce script permet de définir la classe 'DigitalizedDocument'.
 *
 * @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 {

    /**
     * [$log_file description]
     * @var string
     */
    static protected $log_file = "digitalized_document.log";

    /**
     * @access static
     * @var string Messages utilisées pour l'écriture dans le log
     */
    var $NO_REP;
    var $NO_FILES;
    var $NO_FILE_EXIST;
    var $DOC_NO_CONFORME;
    var $NO_LINK;
    var $NO_MOVE;
    var $NO_DELETE_FOLDER;
    var $NO_DELETE_FILE;
    var $NO_IMPORT;
   
    /**
     * Instance de la classe utils
     * @var utils
     */
    var $f = NULL;

    /**
     * Instance du filestorage
     * @var storage
     */
    var $filestorage = NULL;
    
    /**
     * Nom des fichiers qui ne se sont pas importés
     * @var array
     */
    var $filenameError = array();

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

        //Set des attributs
        $this->NO_REP = _("Le dossier n'existe pas.");
        $this->NO_FILES = _("Le dossier est vide.");
        $this->NO_FILE_EXIST = _("Le fichier n'existe pas.");
        $this->DOC_NO_CONFORME = _("Le document n'est pas conforme a la regle RG2 : ");
        $this->NO_LINK = _("Le lien entre le document et le dossier d'instruction n'a pu etre etabli.");
        $this->NO_MOVE = _("Le fichier n'a pas pu etre deplace.");
        $this->NO_DELETE_FOLDER = _("Le dossier n'a pas pu etre supprime");
        $this->NO_DELETE_FILE = _("Le fichier n'a pas pu etre supprime : ");
        $this->NO_IMPORT = _("L'importation a été annulee.");

        //
        $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(__METHOD__."(): 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.
     */
    protected function add_to_log($message, $debug = false) {
        //
        logger::instance()->log_to_file(self::$log_file, $message);
        if ($debug === true) {
            $this->f->addToLog($message, DEBUG_MODE);
        }
    }

    /**
     * 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->add_to_log(__METHOD__."(): ".$path." : ".$this->NO_REP);
            return null;
        }

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

            $this->add_to_log(__METHOD__."(): ".$path." : ".$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->add_to_log(__METHOD__."(): ".$this->DOC_NO_CONFORME.$filename, true);
                    return null;

                } else {

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

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

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

                    $this->add_to_log(__METHOD__."(): ".$this->DOC_NO_CONFORME.$filename, true);
                    return null;

                }

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

        //Le nom du document n'est pas conforme
        $this->add_to_log(__METHOD__."(): ".$this->DOC_NO_CONFORME.$filename, true);
        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->add_to_log(__METHOD__.'(): '.$path.'/'.$filename.' : '.$this->NO_FILE_EXIST, true);
            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->add_to_log(__METHOD__."(): ".$this->DOC_NO_CONFORME.$filename, true);
            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
     *
     * @return boolean                   Vrai ou faux
     */
    public function createDocumentNumerise($document_numerise, $uid, $dossier, $filename) {
        
        //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' => $filename,
            'date_creation' => $metadataFromFilename['dateEvenementDocument'],
            'document_numerise_type' => $this->get_document_numerise_by_code($metadataFromFilename['title']),
            'uid_dossier_final' => ''
        );

        //Ajoute dans la table le lien
        $add = $document_numerise->ajouter($values);

        //Si le document n'est pas ajouté
        if ($add === false) {

            //Log d'erreur
            $this->add_to_log(__METHOD__."(): ".$dossier."/".$filename." : "._("Une erreur s'est produite lors de l'ajout du document ").$filename.".", true);
            $this->add_to_log(__METHOD__."(): ".$document_numerise->msg, true);
            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 === true) {
            return true;
        } else {
            $this->add_to_log(__METHOD__."(): ".$pathSrc."/".$filename." : ".$this->NO_MOVE, true);
            return false;
        }

        //Si le deplacement n'est pas fait on retourne false
        $this->add_to_log(__METHOD__."(): ".$pathSrc."/".$filename." : ".$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
            $delete_file = unlink($file);
            if ($delete_file === true) {
                return true;
            } else {
                $this->add_to_log(__METHOD__."(): ".$file." : ".$this->NO_DELETE_FILE.$file, true);
                return false;
            }

        //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
                $delete_file = unlink($file);
                if ($delete_file === true) {
                    return true;
                } else {
                    $this->add_to_log(__METHOD__."(): ".$file." : ".$this->NO_DELETE_FILE.$file, true);
                    return false;
                }

            }

        }

        //Si aucun traitement n'a été fait on retourne false
        $this->add_to_log(__METHOD__."(): ".$file." : ".$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
        $delete_folder = rmdir($path);
        if ($delete_folder === true) {
            return true;
        } else {
            $this->add_to_log(__METHOD__."(): ".$path." : ".$this->NO_DELETE_FOLDER, true);
            return false;
        }

        //Si le fichier n'a pas été supprimé on retourne false
        $this->add_to_log(__METHOD__."(): ".$path." : ".$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
     *
     * @return boolean true si le traitement à été fait sinon false
     */
    function run_import($pathSrc, $pathDes) {
        
        //Récupération du nom du répertoire
        $foldername = substr(strrchr($pathSrc, "/"), 1);

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

        //Vérifie si le numéro de dossier d'instruction est sur quatres chiffres
        if(preg_match('/[A-Za-z]{2,3}'.$this->f->getParameter("departement").
            $this->f->getParameter("commune").'[0-9]{2}[0-9]{4}[A-Za-z]{1,5}[0-9]{1,2}/', 
            $dossier)){
            
            //On modifie le nom du dossier d'instruction pour qu'il ait la numérotation
            //standard
            $tempDossier = preg_split('/([A-Za-z]{2,3}'.$this->f->getParameter("departement").
                $this->f->getParameter("commune").'[0-9]{2})/i', $dossier, 0, PREG_SPLIT_NO_EMPTY | 
                PREG_SPLIT_DELIM_CAPTURE);
            
            $dossier = $tempDossier[0]."0".$tempDossier[1];
        }
        
        //On vérifie que le dossier existe
        $sql = "SELECT dossier 
            FROM ".DB_PREFIXE."dossier
            WHERE dossier = '".$dossier."'";
        $dossierExist = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."(): db->getOne(".$sql.")", VERBOSE_MODE);
        $this->f->isDatabaseError($dossierExist);
        
        //Si le dossier n'existe pas on annule l'importation
        if (!$dossierExist){
            $this->add_to_log(__METHOD__."(): ".$pathSrc."/ : "._("Le dossier d'instruction n'existe pas.")." ".$this->NO_IMPORT, true);
            return false;
        }

        //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->add_to_log(__METHOD__."(): ".$pathSrc."/ ".$this->NO_FILES." ".$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);
                // On vide la mémoire utilisée par le fichier
                unset($file_content);
                //Si le fichier est créé
                if ($uid !== null) {

                    //Instancie la class document_numerise
                    $document_numerise = $this->f->get_inst__om_dbform(array(
                        "obj" => "document_numerise",
                        "idx" => "]",
                    ));
            
                    //Valeur retour formulaire
                    $document_numerise->setParameter("retourformulaire", "dossier_instruction");

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

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

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

                    }
                    else {
                        //On annule l'importation
                        $this->add_to_log(__METHOD__."(): ".$pathSrc." : "._("Une erreur s'est produite lors de l'ajout du document ").$filename.". ".$this->NO_IMPORT, true);
                        $this->filenameError[] = $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);
        $count_purged_files = 0;

        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
                if($this->purgeFiles($file, $dateImport, $nbDay)) {
                    unset($listFiles[$key]);
                    $count_purged_files++;
                }
                
            }

        }
        
        //Si il n'y a plus de document
        if (empty($listFiles)) {

            //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 $count_purged_files;
        
    }

}


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