<?php
/**
 * DBFORM - 'document_instruction_importe'.
 *
 * @package openfoncier
 * @version SVN : $Id$
 */

//
require_once "../gen/obj/document_instruction_importe.class.php";
require_once "../obj/trait_miniature_document.php";
require_once "../obj/trait_trouillotage_document.php";

//
class document_instruction_importe extends document_instruction_importe_gen {

    use miniature_document;
    use trouillotage_document;

    /**
     * Définition des actions disponibles sur la classe.
     *
     * @return void
     */
    function init_class_actions() {

        parent::init_class_actions();

        // ACTION - 000 - ajouter
        // Modifie la condition d'affichage du bouton ajouter
        // TODO FIXME WARNING WORKAROUND_SOUS_FORM_DOCUMENT_INSTRUCTION_IMPORTE voir le commentaire dans la surcharge d'ajaxIt dans script.js
        // Le numéro de cette action est directement référencé dans la surcharge
        $this->class_actions[0]["condition"] = array("is_addable", "can_user_access_dossier_contexte_ajout");

        // ACTION - 001 - modifier
        //
        $this->class_actions[1]["condition"] = array("is_modifiable", "can_user_access_dossier_contexte_modification");

        // ACTION - 002 - supprimer
        //
        $this->class_actions[2]["condition"] = array("is_supprimable", "can_user_access_dossier_contexte_modification");

        // ACTION - 003 - consulter
        //
        $this->class_actions[3]["condition"] = "can_user_access_dossier_contexte_modification";

        // ACTION - 004 - view_tab
        // Interface spécifique du tableau des pièces
        $this->class_actions[4] = array(
            "identifier" => "preview_edition",
            "view" => "formulaire",
            "permission_suffix" => "tab",
        );

        //
        $this->class_actions[6] = array(
            "identifier" => "telecharger_editions",
            "view" => "view_telecharger_editions",
            "permission_suffix" => "om_fichier_instruction_telecharger",
        );

        //
        $this->class_actions[997] = array(
            "identifier" => "image_data",
            "view" => "view_miniature_data",
            "permission_suffix" => "tab",
        );
    }

    /**
     * @return array
     */
    function get_var_sql_forminc__champs() {
        return array(
            "document_instruction_importe",
            "uid",
            "dossier",
            "nom_fichier",
            "description",
            "document_type",
            "date_creation",
            "date_modification",
            "uid_dossier_final",
            "'' as live_preview",
            "uid_thumbnail",
        );
    }

    // Métadonnées spécifiques pour le .info
    var $metadata = array(
        "uid" => array(
            "filename" => "get_nom_fichier",
            "dossier" => "get_dossier"
        ),
    );

    /**
     * Récupération du nom de fichier à ajouter aux métadonnées
     * @return string nom de fichier
     */
    protected function get_nom_fichier(): string {
        return $this->valF["nom_fichier"];
    }

    /**
     * Récupération du numéro de dossier à ajouter aux métadonnées
     * @return string numéro de dossier
     */
    protected function get_dossier(): string {
        return $this->valF["dossier"];
    }

    /**
     * Récupération du libellé du type de document à ajouter aux métadonnées
     * @return string libellé du type de document
     */
    protected function get_document_type_libelle(): string {
        $document_type = $this->get_inst_common('document_type', $this->valF['document_type']);
        return $document_type->getVal('libelle');
    }

    /**
     * Récupère l'identifiant du type de document depuis son code,
     * filtré par la catégorie Plat'AU.
     *
     * @param  string $code Code du type de document
     * @return mixed        Identifiant, vide s'il n'y a pas de résultat, sinon false
     */
    public function get_document_type_id_by_code(string $code) {
        $qres = $this->f->get_one_result_from_db_query(
            sprintf(
                'SELECT
                    document_type.document_type
                FROM
                    %1$sdocument_type
                    INNER JOIN %1$sdocument_type_categorie
                        ON document_type.document_type_categorie = document_type_categorie.document_type_categorie
                WHERE
                    document_type.code = \'%2$s\'
                    AND document_type_categorie.code = \'%3$s\'',
                DB_PREFIXE,
                $this->f->escape_string_for_db_query($code),
                CODE_CATEGORIE_DOC_NUM_PLATAU
            ),
            array(
                "origin" => __METHOD__,
                "force_return" => true,
            )
        );
        if ($qres["code"] !== "OK") {
            return false;
        }
        return $qres["result"];
    }

    /**
     * Surcharge de la méthode permettant de produire les métadonnées associées à un champ.
     *
     * @param  string  $champ  Champ sur lequel on récupère les métadonnées
     *
     * @return array|null  Métadonnées du champ, ou null si une erreur survient
     */
    function getMetadata($champ) {

        // Initialisation du tableau de métadonnées
        $metadata = array();

        if ($champ === 'uid') {
            // Instanciation d'une instruction pour récupérer les métadonnées
            $inst_instruction = $this->f->get_inst__om_dbform(array(
                "obj" => "instruction",
                "idx" => "]",
            ));
            $key_dossier = array_search("dossier", $inst_instruction->champs);
            if ($key_dossier !== false) {
                $inst_instruction->val[$key_dossier] = $this->valF['dossier'];
            }

            // Sources globale et locale des métadonnées
            $md_sources = array();
            if(isset($this->metadata_global) && !empty($this->metadata_global)) {
                $md_sources = $this->metadata_global;
            }
            if(isset($inst_instruction->metadata["om_fichier_instruction"]) && !empty($inst_instruction->metadata["om_fichier_instruction"])) {
                $md_sources = array_merge($md_sources, $inst_instruction->metadata["om_fichier_instruction"]);
            }
            if (isset($this->metadata[$champ]) && !empty($this->metadata[$champ])) {
                $md_sources = array_merge($md_sources, $this->metadata[$champ]);
            }

            // Pour chaque source on associe la valeur retournée par la fonction correspondante
            // de la classe instruction ou surchargée dans l'objet courant
            foreach ($md_sources as $key => $callable) {
                // Cas spécifique de la métadonnée 'filename' surchargée dans l'objet courant
                if ($key == "filename") {
                    $metadata[$key] = $this->get_nom_fichier();
                }
                // Cas spécifique de la métadonnée 'dossier' surchargée dans l'objet courant
                elseif ($key == "dossier") {
                    $metadata[$key] = $this->get_dossier();
                }
                // Cas spécifique de la métadonnée 'title' surchargée dans l'objet courant
                elseif ($key == "title") {
                    $metadata[$key] = $this->get_document_type_libelle();
                }
                // Autrement, si elle existe, on priorise la méthode de la classe instruction
                elseif (is_string($callable) && method_exists($inst_instruction, $callable)) {
                    $metadata[$key] = $inst_instruction->$callable($champ);
                }
                // Sinon, enfin, on appelle la fonction parente (om_dbform)
                elseif (is_callable($callable)) {
                    $metadata[$key] = call_user_func($callable, $champ);
                }
            }
        }
        return $metadata;
    }

    /**
     * CONDITION - is_ajoutable.
     *
     * Condition pour pouvoir ajouter
     *
     * @return boolean
     */
    function is_ajoutable() {
        // Test du bypass
        if ($this->f->isAccredited($this->get_absolute_class_name()."_ajouter_bypass")) {
            return true;
        }
        // Test des autres conditions
        return $this->is_ajoutable_or_modifiable_or_supprimable($this->getParameter("idxformulaire"));
    }

    /**
     * CONDITION - is_modifiable.
     *
     * Condition pour afficher le bouton modifier
     *
     * @return boolean
     */
    function is_modifiable() {
        // Test du bypass
        if ($this->f->isAccredited($this->get_absolute_class_name()."_modifier_bypass")) {
            return true;
        }
        // Bloquer la modification si le document est lié à un uid externe
        // (i.e. il a été importé via une tâche entrante)
        if ($this->has_external_uid_link() === true) {
            return false;
        }
        // Test des autres conditions
        return $this->is_ajoutable_or_modifiable_or_supprimable();
    }

    /**
     * CONDITION - is_supprimable.
     *
     * Condition pour afficher le bouton supprimer
     * @return boolean
     */
    function is_supprimable() {
        // Test du bypass
        if ($this->f->isAccredited($this->get_absolute_class_name()."_supprimer_bypass")) {
            return true;
        }
        // Bloquer la suppression si le document est lié à un uid externe
        // (i.e. il a été importé via une tâche entrante)
        if ($this->has_external_uid_link() === true) {
            return false;
        }
        // Test des autres conditions
        return $this->is_ajoutable_or_modifiable_or_supprimable();
    }

    /**
     * Vérifie si le document d'instruction importé est lié à un uid externe.
     *
     * @return bool true si un lien externe existe, false sinon
     */
    protected function has_external_uid_link(): bool {
        $inst_lien = $this->f->get_inst__om_dbform(array(
            "obj" => "lien_id_interne_uid_externe",
            "idx" => 0,
        ));
        return $inst_lien->is_exists(
            'document_instruction_importe',
            $this->getVal($this->clePrimaire)
        );
    }

    /**
     * Conditions pour afficher les boutons modifier et supprimer
     *
     * @return boolean
     */
    function is_ajoutable_or_modifiable_or_supprimable() {
        // Tester si le dossier est cloturé ,
        // et si l'instructeur est de la même division
        if ($this->is_instructeur_from_division_dossier() === true &&
            $this->is_dossier_instruction_not_closed() === true){
            return true;
        }

        return false;
    }

    /**
     * Définition des types des champs du formulaire.
     */
    function setType(&$form,$maj) {
        parent::setType($form,$maj);

        //type
        $form->setType('document_instruction_importe','hidden');
        $form->setType('dossier','hidden');
        $form->setType('nom_fichier','hidden');
        $form->setType('live_preview', 'hidden');
        $form->setType('uid_dossier_final','hidden');
        $form->setType('uid_thumbnail', 'hidden');
        $form->setType('date_creation','datestatic');
        $form->setType('date_modification','datestatic');

        if (in_array($maj, array( 0, 1,))) { // 0 ajout, 1 modifier
            if ($this->getParameter("retourformulaire") == "") {
                $form->setType('uid','upload');
            } else {
                $form->setType('uid','upload2');
            }
            $form->setType('date_creation', 'hidden');
            $form->setType('date_modification', 'hidden');
        } // fin ajout

        if ($maj==2){ //supprimer
            $form->setType('uid','filestatic');
            $form->setType('document_type','static');
        } // fin supprimer

        if ($maj==3){ //consulter
            $form->setType('uid','file');
        } // fin consulter

        if ($maj == 4) {
            foreach ($this->champs as $champ) {
                $form->setType($champ, 'hidden');
            }
            // Détermine si c'est une image ou un pdf qui doit être affiché
            $form->setType('live_preview', 'previsualiser');
        }
    }

    function setLayout(&$form, $maj){
        // si le paramètre 'param_communes' est défini et valide
        if (in_array($maj, array( 0, 1, ))) { // 0 ajout, 1 modifier
                $class = 'text-info ui-state-highlight ui-state-info';
                $message = __("Documents ajoutés manuellement par l’instructeur ou importés depuis une autre source. Ils complètent le dossier en cours et sont notifiables.");
                $this->f->display_panel_information(
                    $class,
                    $message
                );
        }
        $form->setFieldset('document_instruction_importe', 'D', __('Document d\'instruction importé'));
        $form->setBloc('document_instruction_importe', 'D', "", "sousform-document_instruction_importe-action-".$maj);
        $form->setBloc('uid_dossier_final', 'F');
        $form->setFieldset('uid_dossier_final', 'F', '');
    }

    function setLib(&$form, $maj) {
        parent::setLib($form, $maj);

        $form->setLib("uid", __("fichier"));
        $form->setLib('date_creation', __("Date de création"));
        $form->setLib('date_modification', __("Date de dernière modification"));
        $form->setLib("live_preview", "");
        $form->setLib("description_type", __("Description"));
        $form->setLib("document_type", __("Type du document"));
    }

    function setSelect(&$form, $maj, &$dnu1 = null, $dnu2 = null) {
        parent::setSelect($form, $maj);
        // Dans le cas d'un dossier d'instruction, filtrage des pièces selon le type de dossier
        $sql_document_type = $this->get_var_sql_forminc__sql("document_type");
        $this->init_select(
            $form,
            $this->f->get_db_reference(),
            $maj,
            null,
            "document_type",
            $sql_document_type,
            $this->get_var_sql_forminc__sql("document_type_by_id"),
            false
        );

        if ($this->is_in_context_of_foreign_key("dossier", $this->getParameter("retourformulaire")) === true) {
            //Tableau des contraintes
            $params = array(
                "constraint" => array(
                    "extension" => ".gif;.jpg;.jpeg;.png;.pdf;.doc;.docx;.odt;.xls;.xlsx;.ods;.tiff;.bitmap"
                ),
            );

            $form->setSelect("uid", $params);
        }

        if ($maj == 4) {
            $file = $this->f->storage->get($this->getVal('uid'));
            $base64 = base64_encode($file['file_content']);
            $form->setSelect('live_preview', array(
                'base64' => $base64,
                'mimetype' => $file['metadata']['mimetype'],
                'label' => $this->getVal('description_type'),
                'href' => sprintf(
                    '../app/index.php?module=form&snippet=file&obj=document_instruction_importe&champ=uid&id=%1$s',
                    $this->getVal($this->clePrimaire)
                )
            ));
        }
    }

    /**
     * Méthode de traitement des données retournées par le formulaire
     */
    function setvalF($val = array()) {
        parent::setvalF($val);

        if ($val["date_creation"] == "") {
            $this->valF["date_creation"] = date("Y-m-d");
        }
        $this->valF["date_modification"] = date("Y-m-d");

        if ($val["uid_thumbnail"] == "") {
            $this->valF["uid_thumbnail"] = "";
        }

        // Le nom de fichier sera généré dans les triggerajouter et modifier,
        // mais pour passer la validation "required", on met une valeur générique
        $this->valF["nom_fichier"] = "to-be-replaced";
    }

    /** @inheritDoc */
    function triggerajouter($id, &$dnu1 = null, $val = array(), $dnu2 = null) {
        $res = parent::triggerajouter($id, $dnu1, $val, $dnu2);

        $this->traitement_normaliser_nom_fichier();

        return $res;
    }

    /** @inheritDoc */
    function triggerajouterapres($id, &$dnu1 = null, $val = array(), $dnu2 = null)
    {
        $res = parent::triggerajouterapres($id, $dnu1, $val, $dnu2);

        if ($this->f->is_option_miniature_fichier_enabled() === true) {
            $this->traitement_fichier_miniaturise();
        }

        return $res;
    }

    /** @inheritDoc */
    function triggermodifier($id, &$dnu1 = null, $val = array(), $dnu2 = null) {
        $res = parent::triggermodifier($id, $dnu1, $val, $dnu2);

        $this->traitement_normaliser_nom_fichier();

        // On force la synchronisation des métadonnées pour que le
        // nom du fichier dans les metadatas correspond bien à celui enregistré
        $file_data = $this->f->storage->get($this->valF['uid']);
        if (isset($file_data['metadata'])) {
            $metadata = $file_data['metadata']; /** @var array $metadata - phpdoc pour corriger le mauvais type de retour */
            if ($metadata['filename'] !== $this->valF['nom_fichier']) {
                $metadata['filename'] = $this->valF['nom_fichier'];
                $is_correct = $this->f->storage->update_metadata($this->valF['uid'], $metadata);
                if ($is_correct === OP_FAILURE) {
                    $this->addToLog(
                        sprintf(__("Erreur lors de la mise à jour du document %s."), $this->valF['uid']), 
                        DEBUG_MODE
                    );
                }
            }
        }

        return $res;
    }

    /** @inheritDoc */
    function triggermodifierapres($id, &$dnu1 = null, $val = array(), $dnu2 = null)
    {
        $res = parent::triggermodifierapres($id, $dnu1, $val, $dnu2);

        if ($this->f->is_option_miniature_fichier_enabled() === true) {
            $this->traitement_fichier_miniaturise();
        }

        return $res;
    }

    /** @inheritDoc */
    function triggersupprimer($id, &$dnu1 = null, $val = array(), $dnu2 = null)
    {
        $res = parent::triggersupprimer($id, $dnu1, $val, $dnu2);

        $this->supprimer_fichier_miniaturise_si_existe();

        return $res;
    }

    /**
     * @override Pour forcer la redirection vers la page d'affichage des documents d'instruction
     *
     * @inheritDoc
     */
    function get_back_link($view = "formulaire") {
        // Récupération du mode de l'action
        $crud = $this->get_action_crud();

        // @override : on renvoie vers la liste de tous les documents d'instruction
        // plutôt que vers une liste des documents d'instruction importés
        if (
            $crud === 'read' // Consultation, le retour est toujours vers la liste globale
            || ($crud === 'create' && !($this->getParameter('validation') > 0 && $this->correct)) // Un formulaire de création retourne vers la liste globale, sauf s'il est validé
            || ($crud === 'delete' && $this->getParameter('validation') > 0) // Une suppression validée renvoie vers la liste globale
        ) {
            $href = sprintf(OM_ROUTE_SOUSFORM."&obj=%s&action=%s&idx=%s&retourformulaire=%s&idxformulaire=%s&retour=form",
                "document_numerise",
                310,
                $this->getParameter('idxformulaire'),
                'dossier_instruction',
                $this->getParameter('idxformulaire'),
            );

            if ($this->getParameter('message_id')) {
                $href .= '&message_id='.$this->getParameter('message_id');
            }

            return $href;
        }

        return parent::get_back_link($view);
    }

    protected function traitement_normaliser_nom_fichier() {
        $est_fichier_modifie = str_starts_with($this->valF['uid'], 'tmp|');

        if ($est_fichier_modifie) {
            // Récupère l'extension sur le fichier temporaire
            [, $temporary_uid] = explode("|", $this->valF['uid']);
            $original_filename = $this->f->storage->getFilename_temporary($temporary_uid);
        } else {
            $original_filename = $this->getVal('nom_fichier');
        }

        $extension = pathinfo($original_filename, PATHINFO_EXTENSION);

        // Normalisation du nom de fichier
        if ($this->f->is_option_enabled(OPTION_NORMALISE_NOM_DOC)) {
            $nom_fichier_normalise = $this->normalise_nom_document_instruction_importe(
                $this->valF['dossier'],
                $this->valF['date_creation'],
                $this->valF[$this->clePrimaire],
                $this->valF['document_type'],
            );

            $this->valF['nom_fichier'] = "{$nom_fichier_normalise}.{$extension}";
        } else {
            // Traitement par défaut si l'option n'est pas activée
            $this->valF['nom_fichier'] = $this->generate_filename(
                $this->valF["date_creation"],
                $this->valF['document_type'],
                $extension,
                $this->valF['dossier'],
            );
        }
    }

    /**
     * TODO regrouper avec la génération de filename avec l'option option_normaliser_nommage_document_numerise
     * fonction $this->traitement_normalise_nom_document_instruction_importe()
     *
     * Génère le nom du fichier.
     *
     * @param  string  $p_date                  Date
     * @param  string  $document_type_id        Identifiant du type de document
     * @param  string  $extension               Extension
     * @param  string  $p_dossier               Numéro du dossier
     * @return string                           Nom du fichier
     */
    protected function generate_filename(string $p_date, string $document_type_id, string $extension, string $p_dossier) {
        // Change le format de la date
        $date = date("Ymd");
        if ($p_date !== null && $p_date !== '') {
            $date = date("Ymd", strtotime($p_date));
        }

        // Récupération du code du type
        $document_type = $this->get_inst_common('document_type', $document_type_id);
        $code_dnt = $document_type->getVal('code');

        // Compose le nom du fichier date + code type document numérisé + extension
        $filename = "{$date}{$code_dnt}.{$extension}";

        // Vérification des doublons
        $counter = 1;
        while ($this->filename_exists_for_dossier_instruction_importe($filename, $p_dossier) === true) {
            $filename = "{$date}{$code_dnt}-{$counter}.{$extension}";
            $counter++;
        }

        return $filename;
    }

    /**
     *
     * TODO mettre jour la PHP doc en même qu'on refactor ça et la méthode generate_filename
     * Normalise le nom donné au document en lui donnant un nom de cette forme :
     *  - IDDI_DATE_TYPEPIECE_IDPIECE_LIBTYPEPIECE
     * Avec
     *  - IDDI : libellé du dossier d'instruction
     *  - DATE : date de création du document au format YYYYMMDD
     *  - TYPEPIECE : soit la nomenclature du CERFA (si existante), soit le code du type de pièce
     *  - IDPIECE : identifiant numérique de la pièce (document)
     *  - LIBTYPEPIECE : libellé du type de pièce ou de la description pour les "autres à préciser"
     *    limité à 50 caractères, avec ses majuscules et dont les espaces ont été remplacé par des '-'.
     *
     * @param string id_di : identifiant du dossier d'instruction
     * @param string date_creation : date de création du document numérisé
     * @param string code_type_document : identifiant du type de document numerisé
     * @param int id_document : identifiant du document numérisé
     * @param string lib_type_document : libellé du type de document numérisé
     * @param string (optional) description du type de document numérisé
     */
    protected function normalise_nom_document_instruction_importe(
        string $id_di,
        string $date_creation,
        string $id_document,
        string $id_document_type,
    ): string {
        // Les différentes parties du nom du document sont traitées pour avoir le format voulu puis
        // stocker dans un tableau. Cela permet de constituer le nom en concatenant les différentes
        // parties via un implode ayant '_' pour glue.
        $parties_nom = array(
            'iddi' => '',
            'date' => '',
            'typepiece' => '',
            'idpiece' => '',
            'libtypepiece' => '',
        );

        // Récupération du IDDI : nom du dossier
        $parties_nom['iddi'] = $id_di;

        // Récupération du DATE : date de création du document au format YYYYMMDD
        // Il y a plusieurs format possible (BDD -> AAAA-MM-DD, Interface -> DD/MM/AAAA).
        // La date est donc transformée en timestamp avant d'être re-modifié au format voulu
        // ce qui fonctionne quelque soit le format d'entrée de la date.
        $parties_nom['date'] = date('Ymd', strtotime($date_creation));

        // Récupération du TYPEPIECE : code cerfa si existant (et non vide) ou code du type de document sinon
        $document_type = $this->get_inst_common('document_type', $id_document_type);

        $parties_nom['typepiece'] = $document_type->getVal('code');

        // Récupération du IDPIECE : identifiant du document
        $parties_nom['idpiece'] = $id_document;

        // Récupération du LIBTYPEPIECE : si la pièce à le type "autre à préciser" et que sa description n'est pas
        // vide prend la description, sinon prend le libellé du type de pièce.
        // Limite le nombre de caractère du nom à 50 caractère puis remplace tous les espaces par des tirets (-).
        $lib_type_piece = $document_type->getVal('libelle');
        $lib_type_piece = $this->normalize_filename(mb_substr($lib_type_piece, 0, 50));

        $parties_nom['libtypepiece'] = $lib_type_piece;

        // Constitution du nom du fichier
        return implode('_', $parties_nom);
    }

    /**
     * Permet de vérifier si le nom du document d'instruction importé
     * est déjà utilisé dans la BDD pour le dossier d'instruction courant.
     *
     * @param  string $filename Le nom du fichier dont on veut vérifier l'existence.
     * @return bool             true si le fichier existe, sinon false.
     */
    private function filename_exists_for_dossier_instruction_importe($filename, $p_dossier = null): bool {
        // Identifiant du dossier d'instruction
        $idx_dossier = $p_dossier;
        if ($p_dossier === null
            || $p_dossier === '') {
            //
            $idx_dossier = $this->valF['dossier'];
        }
        // Requête
        $qres = $this->f->get_one_result_from_db_query(
            sprintf(
                'SELECT
                    count(document_instruction_importe)
                FROM
                    %1$sdocument_instruction_importe
                WHERE
                    dossier = \'%2$s\'
                    AND nom_fichier = \'%3$s\'',
                DB_PREFIXE,
                $this->f->escape_string_for_db_query($idx_dossier),
                $this->f->escape_string_for_db_query($filename)
            ),
            array(
                "origin" => __METHOD__,
            )
        );
        // Si le nom de fichier existe une ou plusieurs fois
        if ($qres["result"] >= 1) {
            return true;
        }
        return false;
    }

     /**
     * Rend une chaine de caractère compatible avec le nommage des fichiers sous Windows
     * - Ôte les accents
     * - Ne laisse que des caractères alphanumériques à la string
     *
     * @param string $input chaîne de caractère à remplacer, sans extension
     */
    public function normalize_filename(string $input): string {
        // Remplacer les caractères accentués par leur équivalent non accentué
        $input = iconv('UTF-8', 'ASCII//TRANSLIT//IGNORE', $input);

        // Remplacer tous les caractères non alphanumériques par "-"
        $input = preg_replace('/[^a-zA-Z0-9]+/u', '-', $input);

        // Supprimer les tirets en début et fin de chaîne
        $input = trim($input, '-');

        return $input;
    }

    /**
     * Récupère le fichier stocké dans le système de fichier correspondant à cette instance
     *
     * @return array|string
     */
    public function get_fichier() {
        return $this->f->storage->get($this->getVal('uid'));
    }
}// fin classe
