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_METADATA_APP = "Le type de document n'apparait pas dans la table document_numerise_type : ";
    var $NO_FILESTORAGE = "Le syteme de stockage n'est pas accessible. Erreur de parametrage. Contactez votre administrateur.";
    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);

        unset($GLOBALS['f']);

    }

    /**
     * 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 d'analyser le dossier
     * en de créer l'objet du dossier d'instruction
     * @param string $foldername Nom du répertoire
     * @return object objet du dossier d'instruction
     */
    public function analyseFolder($foldername) {
        
        //Clé primaire dossier
        $dossier = str_replace('.', '', $foldername);

        //Requête pour récupérer les informations essentiels sur le dossier d'instruction
        $sql = "SELECT dossier.dossier as dossier, dossier_autorisation.dossier_autorisation as dossier_autorisation, 
                    dossier.date_demande as date_demande_initiale, dossier_instruction_type.code as dossier_instruction_type, 
                    etat_dossier_autorisation.libelle as statut, dossier_autorisation_type.code as dossier_autorisation_type
                FROM ".DB_PREFIXE."dossier 
                    LEFT JOIN ".DB_PREFIXE."dossier_instruction_type  
                        ON dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation 
                        ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation 
                    LEFT JOIN ".DB_PREFIXE."etat_dossier_autorisation
                        ON  dossier_autorisation.etat_dossier_autorisation = etat_dossier_autorisation.etat_dossier_autorisation
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille
                        ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type
                        On dossier_autorisation_type_detaille.dossier_autorisation_type = dossier_autorisation_type.dossier_autorisation_type
                WHERE dossier.dossier = '".$dossier."'";
        $res = $this->f->db->query($sql);
        $this->f->addToLog("obj/digitalizedDocument.class.php : db->query(".$sql.")", VERBOSE_MODE);
        $this->f->isDatabaseError($res);
        
        //Le résultat est récupéré dans un objet
        $row =& $res->fetchRow(DB_FETCHMODE_OBJECT);

        //Si il y a un résultat
        if ($row !== null) {

            //Alors on créé l'objet dossier_instruction
            $dossier_instruction = $row;

        } else {

            //Sinon on retourne null pour indiquer une erreur
            $this->addToLog($this->NO_REP);
            return null;
        }

        //Retourne un objet dossier instruction
        return $dossier_instruction;
    }

    /**
     * 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 documenbt 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 une information sur le document
     * en cherchant dans la base de données
     * @param string $code Code du type du document
     * @return string Libellé du type du document
     */
    public function extractMetadataFromApp($code) {
        
        //Requête pour récupérer le type de document
        $sql = "SELECT libelle 
                FROM  ".DB_PREFIXE."document_numerise_type 
                WHERE code = '".$code."'";
        $libelle = $this->f->db->getOne($sql);
        $this->f->addToLog("obj/digitalizedDocument.class.php : db->getOne(".$sql.")", VERBOSE_MODE);
        $this->f->isDatabaseError($libelle);

        //S'il n'y a aucun résultat
        if ($libelle === null) {

            //retourne null
            $this->addToLog($this->NO_METADATA_APP.$code);
            return null;

        }

        //Retourne le libellé du type du document
        return $libelle;
    }

    /**
     * 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 d'assembler toutes les métadonnées
     * @param object $dossier_instruction Objet regroupant les informations sur le dossier d'instruction
     * @param  string $path     Chemin du dossier
     * @param  string $filename Nom du fichier
     * @return array           Tableau des métadonnées
     */
    public function setMetadata($dossier_instruction, $path, $filename) {

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

        //Données récupérées du répertoire
        //Si l'objet dossier_instruction n'existe pas
        if (empty($dossier_instruction)) {

            //Retourne null
            $this->addToLog($this->NO_REP);
            return null;

        }
        $metadata['dossier'] = $dossier_instruction->dossier;
        $metadata['dossier_autorisation'] = $dossier_instruction->dossier_autorisation;
        $metadata['date_demande_initiale'] = date("Y/m", strtotime($dossier_instruction->date_demande_initiale));
        $metadata['dossier_instruction_type'] = $dossier_instruction->dossier_instruction_type;
        $metadata['statut'] = $dossier_instruction->statut;
        $metadata['dossier_autorisation_type'] = $dossier_instruction->dossier_autorisation_type;

        //Données constantes
        $metadata['groupe'] = "ADS";
        $metadata['code_produit'] = "OpenADS";

        //Données récupérées du nom du fichier
        $metadataFromFilename = $this->extractMetadataFromFilename($filename);
        //S'il n'y a pas de données extrait du nom du fichier
        if ($metadataFromFilename === null) {

            //Retourne null
            return null;
        }
        //Parcours les résultats pour les ajouter au métadonnées global
        foreach($metadataFromFilename as $key => $value) {
            $metadata[$key] = $value;
        }

        //Données récupérées de la BDD
        $metadataFromApp = $this->extractMetadataFromApp($metadata['type_doc']);
        //S'il n'y a pas de données recupéré dans la bdd
        if ($metadataFromApp === null) {

            //Retourne null
            return null;
        }
        $metadata['type_doc'] = $metadataFromApp;

        //Données récupérées pour le filestorage
        $metadataToFilestorage = $this->extractMetadataToFilestorage($path, $filename);
        //S'il n'y a pas de données recupérées pour le filestorage
        if ($metadataToFilestorage === null) {

            //Retourne null
            return null;
        }
        //Parcours les résultats pour les ajouter au métadonnées global
        foreach($metadataToFilestorage as $key => $value) {
            $metadata[$key] = $value;
        }

        //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 metadonnées global
        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 createFile($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;
        
    }

    /**
     * Cette fonction permet de supprimer un document temporaire dans le filesystem
     * @param string $uid Identifiant du fichier sur le filesystem
     * @return string $uid Identifiant du fichier supprimé
     */
    public function deleteFile($uid) {
      
        //Suppression du fichier du filestorage
        $uid = $this->filestorage->delete_temporary($uid);

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

    /**
     * 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 l'id
        return $document_numerise_type;
    }

    /**
     * Permet de lier le document importé à l'application et de le créer dans le filestorage
     * @param string $uid L'identifiant du fichier
     * @param string $metadata Métadonnées du document
     * @param mixed $db Référence à la bdd
     * @param mixed $DEBUG mode de débuggage
     * @return int L'identifiant de la dernière ligne ajouté
     */
    public function createFileStorage($uid, $metadata, $db, $DEBUG = NULL) {
        
        //Création d'un objet de type document_numerise
        require_once '../obj/document_numerise.class.php';
        $document_numerise = new document_numerise(']', $db, $DEBUG);
        $document_numerise->setParameter("maj",0);

        //Afin de recupérer le code du type du document
        $metadataFromFilename = $this->extractMetadataFromFilename($metadata['filename']);

        //Données
        $values = array(
            'document_numerise' => '',
            'uid' => $uid,
            'dossier' => $metadata['dossier'],
            'nom_fichier' => '',
            'date_creation' => $metadata['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);

        //
        if (!$document_numerise->correct) {

            //
            $this->addToLog($this->NO_LINK);
            return false;
        }

        return true;
    }

    /**
     * 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 moveFile($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 sont renseigné
        if ($dateImport && $nbDay) {
            
            //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 la date d'import et le nombre de jour ne sont renseignés
        } else {

            //On supprime le fichier sans faire de test
            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);
        //Analyse le dossier pour récupérer les informations du dossier d'instruction
        $dossier_instruction = $this->analyseFolder($foldername);
        //Si le dossier n'existe pas dans la BDD
        if ($dossier_instruction === null) {
            //On annule l'importation
            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->addToLog($this->NO_IMPORT);
            return false;
        }
        
        foreach ($listFiles as $key => $filename) {

            //Construit les métadonnées
            $metadata = array();
            $metadata = $this->setMetadata($dossier_instruction, $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 dans le filestrorage
                $uid = $this->createFile($file_content, $metadata);

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

                    //Créer le lien entre le fichier et l'application
                    $createFileStorage = $this->createFileStorage($uid, $metadata, $this->f->db, $DEBUG);

                    //Si le lien ne s'est pas fait
                    if ($createFileStorage === false) {
                        
                        //On supprime le fichier du filestorage
                        $delete = $this->deleteFile($uid);

                    } else {

                        //Sinon on déplace le document créé dans le filestorage
                        //du dossier des "à traiter" vers celui des "traités"
                        $this->moveFile($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);

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

}

?>