DDM : Digital Document Manager

Son objectif est d’avoir une vue synthétique des médias existants sur l’objet. Il permet d’accéder à l’écran de gestion en liste des médias ou directement à l’affichage d’un média :

Il est composé de 3 parties.

1. Le bouton d’accès à la gestion en liste des médias

2. L’affichage direct des thumbnails des médias typés « showroom » (PHR).

3. Affichage de tous les autres médias sous forme de petites icônes de fichier.

Il n’y a pas d’affichage des versions, seule la dernière version en cours est référencée.

Rappel : dans les écrans des événements (et des postes), cet écran est accédé de la manière suivante :

Donne :

Cet écran permet d’afficher les médias en liste, ainsi que de les gérer (modifier/supprimer) et d’en importer de nouveaux directement sur l’objet géré. Il est accessible depuis le bouton « Gérer les médias ».

L’affichage des médias dans cette liste correspond aux règles de gestion des écrans en liste (voir paramétrage table Type de média _ tme).

Cet écran est trié par défaut par date d’import du média (le dernier importé en premier).

Tous les médias existants sont listés, y compris les différentes versions d’un même document.

Sont modifiables : le type de média (voir paramétrage table Type de média _ tme), l’ordre (sensé paramétrer l’ordre d’affichage, actuellement non géré), le libellé et la langue (attribut qui permet essentiellement de filtrer la liste des médias).

NOTA : Il en existe deux autres variantes : celle du portail « I_DDM_F » et celles de « vos documents », abordés plus loin dans ce document.

Cet écran correspond aux règles de gestion du mode fiche (plein écran) d’un média. Il permet la visualisation du média en lui-même (selon règles de gestion associées au type de média (voir table tme), voire de son thumbnail, et de ses différentes règles de gestion.

Le principe général est pour l’utilisateur de pouvoir charger des documents pour sa propre utilisation, ainsi que les modifier. Dans le même écran, il peut visualiser des documents « corporate » uploadés sur les entités magasin (niv4) ou groupe (niv1).

Les documents affichés en liste et sont triés par défaut par ordre inverse de chargement en base, afin de présenter les documents les plus récents en premier.

L’affichage des médias des produits, tiers et événements répond aux mêmes principes et sont implémentés dans les mêmes composants logiciels, même si leur intégration ergonomique est propre à chaque objet. Les écrans de synthèse, gestion en liste et d’affichage des médias sont décrits dans le chapitre des principes généraux.

Un nouvel écran a été défini en respectant le fonctionnement de l’existant :

Présentes à différents endroits dans l’application les images des rubriques ont été reprises à l’identique avec le module DDM :

Nota : ce sont les thumbnails des images typées « showroom » (PHR) qui sont affichées.

Pour ce qui est de la gestion des médias des rubriques, celle-ci est réalisée à l’identique du fonctionnement standard, depuis l’onglet « rubrique » des catalogues :

SQL de création des tables, schémas et index pour le module DDM. Ecrase les éléments éventuellement déjà présents.

Permet de redéfinir la table de paramétrage (« TBL ») tme, avec les nouvelles règles de paramétrage de DDM.

Permet de mettre en place le module DDM par indirection des BusinessViews suffixes MEDIA_D et MEDIA_L.

Permet de référencer les nouveaux écrans, ainsi que le portail I_DDM_F tel que présenté dans ce document. Ce portail est habilité dans la gestion de la centrale.

Permet enfin de définir le PPE DDM001, ainsi que les règles de gestion des différents items du portail I_DDM_F.

Permet de paramétrer rapidement les liens MEV dans un contexte strictement Pack. Les liens sont à recalculer pour les « codent » :

• MEDIA_BLOB
• DOC_REC

A noter qu’ils sont strictement équivalents à ceux de la table média.

La table de définition des liens multi entité (MEP) est paramétrée pour les entités ci-dessus dans le fichier « mep.sql ».

Ce PPE permet de personnaliser le comportement du portail de gestion des médias, par métier.

A1 Codent (=MEDIA_BLOB.TYPTIE). Limite le contenu du portail au type. La valeur ‘ALL’ permet de gérer explicitement tous les médias.

A2 « Segment » (=MEDIA_BLOB.NOMCLE sur 3 caractères). Limite le contenu du portail dans le cas des événements et des tiers.

Paramétrage des cibles livrées dans le module DDM :

Dans le portail de configuration, gestion des BusinessViews, une sélection sur le nom I_DDM_GESTION permet d’afficher toutes les BusinessViews définies.

Voici la liste des critères de lancement, elle est commune à tous les traitements :

On notera particulièrement la présence des critères calculés :

Nombre de version en base : Nombre total de version d’un document.

Nombre de versions plus récentes : SI = 0 : version courante (la dernière mise à jour). Ainsi la sélection de toutes les versions sauf la dernière (cas de purges dans anciennes versions, revient à sélectionner toutes les lignes sauf celles qui sont égale à 0).

Nombre de versions plus anciennes : SI = 0 : version la plus ancienne.

Liste simple des médias. Il est possible de définir 6 niveaux de tris (cumul en taille de fichiers et nombre de fichiers à chaque rupture).

Ces lanceurs sont basés sur la même édition que la liste. Les 6 niveaux de ruptures sont aussi gérés.

Des critères d’entête d’édition, permettent de gérer des Flag (O/N) qui permettent de marquer les enregistrements en indiquant à l’application de déclencher les traitements (MEDIA_BLOB.FLGTRT).

Les traitements ne sont ni immédiats ni synchrones avec la fin du traitement batch.

Les traitements définis par défaut ne font qu’une seule action, mais il est possible de déclencher 1 ou plusieurs actions simultanément dans un même traitement.

L’implémentation par défaut de DDM, scrute le sous répertoire ddm_in/edeve de spl du client serveur (variable « ddm.scanner.ACE » du fichier ddm.properties).

Extrait du fichier ddm.properties définissant la variable ddm.scanner.ACE :

ddm.scanner.basedir=/C:/app/ddm_data
ddm.scanner.ACE=/C:/app/ddm_data
ddm.datasource.pooled=false
ddm.scanner.active=true
ddm.indexer=ot_target
ddm.storage.basedir=/C:/app/ddm_data/storage

Extrait du fichier ddm.properties.xml concernant le scan des événements à auto archiver :

< input dir ="${ddm.scanner.ACE}/ddm_in/edeve " includes =" *.ref " frequency =" 1 " fileRefDeletion =" true " fileDeletion =" true ">
< param name =" indexer " value =" ${ddm.indexer} "/>
< param name =" thumbFormat " value =" jpg "/>
< fileKeyProvider name =" ref "/>
< fileKeyProvider name =" flat_ref "/>
</ input >

Installations possible de DDM :

• DDM est installé en stand-alone sur le serveur de traitement,
• DDM est installé dans le serveur d’application (dans le webmodule « btoe » par exemple). Un partage réseau soit alors permettre la scrutation du répertoire du serveur de traitement.

Ajouter le connecteur de sortie DDM par duplication du connecteur pdf :

Paramétrage du connecteur DDM :

• Output mode doit être positionné à « process »
• Create directory doit être à « Yes »

1. Ajouter dans les maquettes entete_edition.str_fra et entete_masquee.str_fra les champs suivants :

   %CR ----------------------------------------
   %CR -- Declenchement option entete 50
   %CR ----------------------------------------
   V ~605=C(40)
   VEE ~605="ddm_in\edeve"
   %EEDDM Archivage @319
   %EEDDM .ref file path ~605

   Ces champs sont :

   • L’indicateur d’archivage O/N
   • Le chemin vers le répertoire d’entrée du module ddm relativement au répertoire de sortie standard (spl)
2. Il faut également modifier le projet StreamServe entête édition pour intégrer ces champs.
   • Ajout dans l’event de l’entête des nouveaux champs :

     

   • Définition des champs :

     

3. Modification des fonctions de l’entête pour prise en compte des nouvelles variables.

   Dans le fichier fonctions_gnx_entete modification des fonctions InitSessionVariableEntete() et GetSessionVariableEntete()

func InitSessionVariableEntete ()
{
$numjobid=#1;
$session_name_entete="session_entete_"+$numjobid;
sessionstart($session_name_entete,120);
// Ajout pour ddm
sessionsetvariable($session_name_entete, "EE_archiver", $EE_archiver);
sessionsetvariable($session_name_entete, "EE_repddm ", $EE_repddm );
// Fin ajout ddm
sessionsetvariable($session_name_entete, "EE_impentete", $EE_impentete);
sessionsetvariable($session_name_entete, "EE_adress_soc ", $EE_adress_soc );…

func GetSessionVariableEntete()
{
 $numjobid=#1;
 $session_name_entete="session_entete_"+$numjobid;
 // Ajout pour ddm
 $EE_archiver = sessiongetvariable($session_name_entete,"EE_archiver"); 
 $EE_repddm = sessiongetvariable($session_name_entete,"EE_repddm");
 // Fin ajout ddm
 $EE_impentete = sessiongetvariable($session_name_entete,"EE_impentete"); 
 $EE_adress_soc = sessiongetvariable($session_name_entete,"EE_adress_soc ");
…

Dans notre exemple il s’agit de la commande de vente

include="ap$std_fra:entete_masquee.str_fra"
%05START V1EDIT_COMMANDE
include="ap$std_fra:ddm_edeve.str_fra"
%05Barème lir (B05) @805
%05Calcul en TTC (O N) (B05) @806

%CR ----------------------------------------
%CR -- Variables de generation des .ref
%CR ----------------------------------------
%05DDM Filename of .ref file ~602
%05DDM RefFile filename ~603
%05DDM RefFile typtie TIE
%05DDM RefFile nomcle @54@076
%05DDM RefFile lib256 DDM Auto archivage
%05DDM RefFile codlan @668
%05DDM RefFile codsoc 1
%05DDM RefFile uticod ~604

StreamIn
// Generated with StreamIN
// Sun 17/2-2013, 14:23:46
Root Name "Message"
Field "DDM RefFile filename" $ddm_file
Field "DDM Filename of .ref file" $ddm_ref_file
Field "DDM RefFile typtie" $ddm_ref_typtie
Field "DDM RefFile nomcle" $ddm_ref_nomcle
Field "DDM RefFile lib256" $ddm_ref_lib256
Field "DDM RefFile codlan" $ddm_ref_codlan
Field "DDM RefFile codsoc" $ddm_ref_codsoc
Field "DDM RefFile uticod" $ddm_ref_uticod

//!CodePage UTF8!
func ddm_before_event()
{
 // Mémorisation du connecteur demandé dans ACE
 $connecteur=$outq;
// Mémorisation de la destination demandée dans ACE
 $destination=$setdestpath;
// Génération du fichier d'indexation ddm
// Chemin et nom du fichier .ref
 $file_ref=$output_gnx+"\"+$EE_repddm+"\"+$ddm_ref_file; 
 //ouverture du fichier
open_file($file_ref,"w"); 
ecrire_fic_ref();
} 
func ddm_after_event()
{
 //Process à appeler
 $fprocess = #1;
 // Appel du process pour achivage
 // Si l'archivage est demandé
if($EE_archiver="O")
{
// Définition du fichier à produire à destination de ddm
 //$setdestpath= $output_gnx+"\"+$EE_repddm+"\"+$ddm_file;
$setdestpath= $output_gnx+"\"+$ddm_file;
// le connecteur de sortie à utiliser est ddm
$outq="ddm";
// apple du process pour envoyer vers répertoire entrée ddm
callproc($process);
// Après la génération du fichier pour ddm on remet les variables aux valeurs
// demandées dans ACE pour gérer le cas classique
 $setdestpath=$destination; 
$outq=$connecteur;
}
// fermeture du fichier ref
 close_file($file_ref);
} 
func ecrire_fic_ref ()
{
 //write_ln($file_ref,"CodePage UTF8");
$ficref_typtie="typtie="+$ddm_ref_typtie;
 write_ln($file_ref,$ficref_typtie);
$ficref_lib256="lib256="+$ddm_ref_lib256;
 write_ln($file_ref,$ficref_lib256);
$ficref_codlan="codlan="+$ddm_ref_codlan;
write_ln($file_ref,$ficref_codlan);
$ficref_codsoc="codsoc="+$ddm_ref_codsoc;
write_ln($file_ref,$ficref_codsoc);
$ficref_typmed="typmed=ARC";
write_ln($file_ref,$ficref_typmed);
$ficref_filename="filename="+ $ddm_file;
write_ln($file_ref,$ficref_filename);
$ficref_nomcle="nomcle="+$ddm_ref_nomcle;
write_ln($file_ref,$ficref_nomcle);
 $ficref_uticod="utidcod="+$ddm_ref_uticod ;
 write_ln($file_ref,$ficref_uticod);
}
func open_file()
{
$file = #1;
$mode=#2;
$err = fileopen($file, $mode);
 //If the action was unsuccessful, pass the error value
//to ioerrtext and store the error text returned by
//ioerrtext in $errtext.
//Send the error text to the log file
if(num($err)!=0)
{
 $errtext=ioerrtext($err);
log(0,"Errortext "+$errtext);
}
} 
func close_file()
{
$file = #1;  
//Close myfile.txt and store the returned value in $err 
$err = fileclose($file); 
//If the action was unsuccessful, pass the error value
//to ioerrtext and store the error text returned by
//ioerrtext in $errtext.
//Send the error text to the log file 
if(num($err)!=0)
{
$errtext=ioerrtext($err);
 log(0,"Errortext "+$errtext);
}  
}  
func write_ln()
{
 $file = #1;
 $ligne = #2;
 //Write the contents of $utbuf to myfile.txt,
 //add a new line, and store the returned value in $err
$err = filewriteln($file,$ligne);
//If the action was unsuccessful, pass the error value
//to ioerrtext and store the error text returned by
//ioerrtext in $errtext.
 //Send the error text to the log file 
if(num($err)!=0)
{
$errtext=ioerrtext($err);log(0,"Errortext "+$errtext); 
}
}