#!/usr/bin/perl
###############################################################################
# Auteur : X H, 
# But	 : voir le perldoc ...
# ATTENTION : ne pas oublier de rajouter perl devant le nom du script pour que les paramètres soient pris en compte
###############################################################################
use warnings;
use strict;
use Data::Dumper;
use Encode; 		# pour les problèmes d'accent


use threads;
use Thread::Semaphore;
use threads::shared;

my @recup = qw/ARMEN1 ARMEN2 INITSE MOA NINIV RESEAU SIRH CSV XML BAD/;
my %s_hash;
my %hash;

# les variables génériques, pour horodater le fichier :
my ($jour, $mois, $annee) = (localtime(time() - (60 * 60 * 24)))[3, 4, 5];
my $date_veille = sprintf("%d%02d%02d",(1900+$annee), (++$mois), $jour);
my ($day, $mon, $year, $hour, $min, $sec) = (localtime)[3, 4, 5, 2, 1, 0];
my $date_fic = sprintf("%d%02d%02d",(1900+$year), (++$mon), $day);
my $date_mois = sprintf("%d%02d",(1900+$year), $mon);

my $semaphore = Thread::Semaphore->new(5); # Crée un sémaphore avec le compteur initialisé à cinq

# partage des variables, creation des threads, initialisation des variables
for (@recup){
 share ($s_hash{$_}{'go'});
 share (@{$s_hash{$_}{'fic'}});
 share ($s_hash{$_}{'source'});
 share ($s_hash{$_}{'rep'});
 share ($s_hash{$_}{'die'});
                 
 $s_hash{$_}{'go'} = 0;
 $s_hash{$_}{'die'} = 0;
 
 $hash{$_}{'thread'} = threads->new(\&recup_fic,$_);
}
# suite de l'initialisation des variables
# le motif des fichiers à récupérer
# l'appel de la variable doit être le même que lors du partage (share) sinon aucune valeur ne sera transmise au threads.
@{$s_hash{ARMEN1}{'fic'}} = ('SPO_*_T.tar.gz');
@{$s_hash{ARMEN2}{'fic'}} = ('SPO_*_T.tar.gz');
@{$s_hash{INITSE}{'fic'}} = ('SPOT_MAXIMO_*_T.tar.gz');
@{$s_hash{MOA}{'fic'}} = ('MOA1_*.zip');
@{$s_hash{NINIV}{'fic'}} = ('RMDOGNPM_*.zip');
@{$s_hash{RESEAU}{'fic'}} = ('RMDOGCSEG_*.zip');
@{$s_hash{SIRH}{'fic'}} = ('SPO.GES.N.*.ZIP', 'SPO.REF.N.*.ZIP');
@{$s_hash{CSV}{'fic'}} = ('T_*.csv', 'TP_*.csv' );
@{$s_hash{XML}{'fic'}} = ("\*$date_fic\*\.xml");
@{$s_hash{BAD}{'fic'}} = ('*.bad',
	'sqlload_agents.log',
	'sqlload_seg_gestion.log',
	'sqlload_seg_gestion_saf.log',
	'sqlload_t_cat_ressource.log',
	'sqlload_t_instal.log',
	'sqlload_t_loc_instal.log',
	'sqlload_t_loc_sur_instal.log',
	'sqlload_t_carac.log',
	'sqlload_t_carac_instal.log',
	'sqlload_t_ct_ligne.log',
	'sqlload_t_ct_saf.log',
	'sqlload_t_ct_voie.log',
	'sqlload_t_dec_lig.log',
	'sqlload_t_dec_voie.log',
	'sqlload_t_liste_val.log',
	'sqlload_t_loc_saf.log',
	'sqlload_t_rat_typ_instal.log',
	'sqlload_t_saf.log',
	'sqlload_t_spe_typ_instal.log',
	'sqlload_t_structure.log',
	'sqlload_t_trl.log',
	'sqlload_t_trv.log',
	'sqlload_t_typ_dec.log',
	'sqlload_t_typ_instal.log',
	'sqlload_t_typ_loc_autorise.log',
	'sqlload_t_typ_saf.log',
	'sqlload_t_type_ressource.log',
	'sqlload_t_val.log',
	'sqlload_t_val_bis.log',
	'sqlload_t_val_typ_dec.log',
	'sqlload_tp_article_a_exclure.log',
	'sqlload_tp_liste_val_admis.log',
	'sqlload_tp_structures_deployees.log',
	'sqlload_uch.log',
	'sqlload_uop.log');
# les répertoires distants où trouver les fichiers
$s_hash{ARMEN1}{'source'} = '/transfert/reception';
$s_hash{ARMEN2}{'source'} = "/transfert/reception/DIFARMEN_$date_fic";
$s_hash{INITSE}{'source'} = '/transfert/reception';
# $s_hash{INITSE2}{'source'} = "/transfert/reception/INITSE_$date_fic";
$s_hash{MOA}{'source'} = '/transfert/reception';
# $s_hash{MOA2}{'source'} = "/transfert/reception/MOA1_$date_fic";
$s_hash{NINIV}{'source'} = '/transfert/reception';
# $s_hash{NINIV2}{'source'} = "/transfert/reception/NINIV_$date_fic";
$s_hash{RESEAU}{'source'} = '/transfert/reception';
# $s_hash{RESEAU2}{'source'} = "/transfert/reception/RESEAU_$date_fic";
$s_hash{SIRH}{'source'} = '/transfert/reception';
# $s_hash{SIRH2}{'source'} = "/transfert/reception/SIRH_$date_fic";
$s_hash{CSV}{'source'} = '/transfert/reception';
$s_hash{XML}{'source'} = '/transfert/emission';
$s_hash{BAD}{'source'} = '/traces/spotimp/loader';
# pour l'affichage dans la fenêtre
$s_hash{ARMEN1}{'data'} = 'non';
$s_hash{ARMEN2}{'data'} = 'non';
$s_hash{INITSE}{'data'} = 'non';
$s_hash{MOA}{'data'} = 'non';
$s_hash{NINIV}{'data'} = 'non';
$s_hash{RESEAU}{'data'} = 'non';
$s_hash{SIRH}{'data'} = 'non';
$s_hash{CSV}{'data'} = 'non';
$s_hash{XML}{'data'} = 'non';
$s_hash{BAD}{'data'} = 'non';


# passage au GUI pour réaliser les traitements.
use Tkx;

# sélection du répertoire de version pour stockage des fichiers 
my $rep_fichiers = Tkx::tk___chooseDirectory(-initialdir => '~', -title => decode( "utf-8", "Sélection du répertoire de la version SPOT IF."), -mustexist => 1);
unless ($rep_fichiers){
	for (@recup){
		$s_hash{$_}{'die'} = 1;
		$hash{$_}{'thread'}->join;
	}
	exit 9;
}
$rep_fichiers = encode( "iso-8859-1",$rep_fichiers);

my $rep_jour = encode( "iso-8859-1","$rep_fichiers/$date_fic");
if (-d $rep_jour) {
	$rep_jour = Tkx::tk___chooseDirectory(-initialdir => '~', -title => decode( "utf-8", "Sélection du répertoire ou déposer les fichiers PROD du jour."));
} else {
	# print LOG "Creation du repertoire $rep_jour.\n";
	mkdir $rep_jour or die "Probleme creation repertoire $rep_jour E/S: $!\n";
	my $rep_tmp = "$rep_jour/CSV";
	mkdir $rep_tmp or die "Probleme creation repertoire $rep_tmp E/S: $!\n";
	$rep_tmp = encode( "iso-8859-1","$rep_fichiers/$date_fic/".decode("utf8", "XML Générés"));
	# $rep_tmp = "$rep_jour/XML Générés";
	mkdir $rep_tmp or die "Probleme creation repertoire $rep_tmp E/S: $!\n";
	$rep_tmp = encode( "iso-8859-1","$rep_fichiers/$date_fic/".decode("utf8", "Logs Préparateur"));
	# $rep_tmp = "$rep_jour/Logs Préparateur";
	mkdir $rep_tmp or die "Probleme creation repertoire $rep_tmp E/S: $!\n";
}

# maintenant que le répertoire du jour est choisi, fin de l'initialisation des varaibles
# les répertoires locaux (ou sur le réseau) où déposer les fichiers
$s_hash{ARMEN1}{'rep'} = $rep_jour;
$s_hash{ARMEN2}{'rep'} = $rep_jour;
$s_hash{INITSE}{'rep'} = $rep_jour;
$s_hash{MOA}{'rep'} = $rep_jour;
$s_hash{NINIV}{'rep'} = $rep_jour;
$s_hash{RESEAU}{'rep'} = $rep_jour;
$s_hash{SIRH}{'rep'} = $rep_jour;
$s_hash{CSV}{'rep'} = "$rep_jour/CSV";
$s_hash{XML}{'rep'} = encode( "iso-8859-1","$rep_fichiers/$date_fic/".decode("utf8", "XML Générés"));
$s_hash{BAD}{'rep'} = encode( "iso-8859-1","$rep_fichiers/$date_fic/".decode("utf8", "Logs Préparateur"));

# la fenêtre où tout se passe
my $fenetre = Tkx::widget->new(".");
$fenetre->g_wm_title("Recup quotidien");
$fenetre->g_wm_minsize(300, 200);

# le label pour le répertoire choisi
my $repert = $fenetre->new_ttk__label(-textvariable => \$rep_fichiers, );

# le bouton pour ARMEN
my $armen1 = $fenetre->new_button( -text => decode("utf8","Le fichier ARMEN SPO_$date_veille*_T.tar.gz est il présent dans le répertoire distant ?"),
								  -command => [\&fct_click, 'ARMEN1'],
								);
my $lib_armen1 = $fenetre->new_ttk__label(-textvariable => \$s_hash{'ARMEN1'}{'data'}, );
my $armen2 = $fenetre->new_button( -text => decode("utf8","Le fichier ARMEN SPO_$date_veille*_T.tar.gz est il archivé dans le répertoire distant ?"),
								  -command => [\&fct_click, 'ARMEN2'],
								);
my $lib_armen2 = $fenetre->new_ttk__label(-textvariable => \$s_hash{'ARMEN2'}{'data'}, );

# le bouton pour INITSE
my $initse = $fenetre->new_button( -state => 'disabled', 
								   -text => decode("utf8",'Récupération des fichiers INITSE ?'), 
								   -command => [\&fct_click, 'INITSE'],
								);
my $lib_initse = $fenetre->new_ttk__label(-textvariable => \$s_hash{'INITSE'}{'data'}, );

# le bouton pour MOA
my $moa = $fenetre->new_button( -state => 'disabled', 
								-text => decode("utf8",'Récupération des fichiers MOA ?'), 
								-command => [\&fct_click, 'MOA'],
								);
my $lib_moa = $fenetre->new_ttk__label(-textvariable => \$s_hash{'MOA'}{'data'}, );

# le bouton pour NINIV
my $niniv = $fenetre->new_button( -state => 'disabled', 
								  -text => decode("utf8",'Récupération des fichiers NINIV ?'), 
								  -command => [\&fct_click, 'NINIV'],
								);
my $lib_niniv = $fenetre->new_ttk__label(-textvariable => \$s_hash{'NINIV'}{'data'}, );

# le bouton pour RESEAU
my $reseau = $fenetre->new_button( -state => 'disabled', 
								   -text => decode("utf8",'Récupération des fichiers RESEAU ?'), 
								   -command => [\&fct_click, 'RESEAU'],
								);
my $lib_reseau = $fenetre->new_ttk__label(-textvariable => \$s_hash{'RESEAU'}{'data'}, );

# le bouton pour SIRH
my $sirh = $fenetre->new_button( -state => 'disabled', 
								 -text => decode("utf8",'Récupération des fichiers SIRH ?'), 
								 -command => [\&fct_click, 'SIRH'],
								);
my $lib_sirh = $fenetre->new_ttk__label(-textvariable => \$s_hash{'SIRH'}{'data'}, );

# le bouton pour CSV
my $csv = $fenetre->new_button( -state => 'disabled', 
								  -text => decode( "utf-8","Les fichiers T_*.csv, TP_*.csv\nsont ils présents dans le répertoire distant ?"), 
								  -command => [\&fct_click, 'CSV'],
								);

# le bouton pour XML
my $xml = $fenetre->new_button( -state => 'disabled', 
								  -text => decode( "utf-8","Les fichiers *.xml sont ils présents dans le répertoire distant ?"), 
								  -command => [\&fct_click, 'XML'],
								);

# le bouton pour Bad, Log
my $reste = $fenetre->new_button( -state => 'disabled', 
								  -text => decode( "utf-8","Les fichiers *.bad, *.log\nsont ils présents dans le répertoire distant ?"), 
								  -command => [\&fct_click, 'BAD'],
								);

# répartition des boutons dans la fenêtre
$repert->g_grid(-row => 0,  -column => 0, -columnspan => 2, -padx => 5, -pady => 5,);
$armen1->g_grid(-row => 1,  -column => 0, -padx => 5, -pady => 5,);
$armen2->g_grid(-row => 2,  -column => 0, -padx => 5, -pady => 5,);
$initse->g_grid(-row => 3,  -column => 0, -padx => 5, -pady => 5,);
$moa->g_grid (  -row => 4,  -column => 0, -padx => 5, -pady => 5,);
$niniv->g_grid( -row => 5,  -column => 0, -padx => 5, -pady => 5,);
$reseau->g_grid(-row => 6,  -column => 0, -padx => 5, -pady => 5,);
$sirh->g_grid ( -row => 7,  -column => 0, -padx => 5, -pady => 5,);
$csv->g_grid(   -row => 8,  -column => 0, -padx => 5, -pady => 5,);
$xml->g_grid(   -row => 9,  -column => 0, -padx => 5, -pady => 5,);
$reste->g_grid( -row => 10, -column => 0, -padx => 5, -pady => 5,);

$lib_armen1->g_grid(-row => 1, -column => 1, -padx => 5, -pady => 5,);
$lib_armen2->g_grid(-row => 2, -column => 1, -padx => 5, -pady => 5,);
$lib_initse->g_grid(-row => 3, -column => 1, -padx => 5, -pady => 5,);
$lib_moa->g_grid (  -row => 4, -column => 1, -padx => 5, -pady => 5,);
$lib_niniv->g_grid( -row => 5, -column => 1, -padx => 5, -pady => 5,);
$lib_reseau->g_grid(-row => 6, -column => 1, -padx => 5, -pady => 5,);
$lib_sirh->g_grid ( -row => 7, -column => 1, -padx => 5, -pady => 5,);

# Affichage d'un bouton pour fermer la fenêtre 
my $bouton = $fenetre->new_button(
	-text    => 'Fermer la fenetre', 
	-command => sub { 
		for (@recup){
			$s_hash{$_}{'die'} = 1;
			$hash{$_}{'thread'}->join;
		}
		
		# $fenetre->g_destroy; # plante la fermeture du script ...
		exit;
	}, 
); 
$bouton->g_grid(-row => 11, -column => 1, -padx => 5, -pady => 5,);

Tkx::MainLoop;    # Obligatoire

print "Fin du traitement.\n";

=head1 NAME

IF_recup_quotidien.pl

=head1 SYNOPSIS

Interactive mode:

  perl IF_recup_quotidien.pl 

=head1 DESCRIPTION

Il s'agit d'automatiser la création des répertoire et la récupération quotidienne des fichiers de PROD pour SPOT IF.

=head1 ALGORITHME

création des variables partagees pour les threads.
création des threads.

création de la fenêtre.
création des boutons (à l'état inactif) pour les récupérations possibles.


choix du répertoire de version de SPOT IF.
création du répertoire <Date du jour> et des répertoires CSV, XML, Logs préparateurs dans ce répertoire créé.
affichage de répertoire (Label).
passage successif, à l'état actif, de chacun des boutons, puis à nouveau inactif.

les boutons permettent, par les threads crees precedemment, si besoin, 
récupération des fichiers DIFARMEN, INITSE, MOA1, NINIV, RESEAU, SIRH d'extension .Tar.GZ ou .Zip dans le répertoire <Date du jour>.
récupération des fichiers CSV dans le répertoire du même nom.
récupération des fichiers XML dans le répertoire du même nom.
récupération des fichiers BAD dans le répertoire des Logs.
récupération des fichiers LOG dans le répertoire du même nom.


=head1 AUTEUR

Xavier HERVIEU, beginner in Perl.

=cut

sub recup_fic{

# récupération du paramètre
	my $dthread = shift;

	while(1){
		# print "boucle $dthread ";
       if($s_hash{$dthread}{'die'} == 1){ goto END }; 
      
       if ( $s_hash{$dthread}{'go'} == 1 ){
	   
			# my $lst_fic = $s_hash{$dthread}{'fic'};
			# print Dumper($lst_fic);
			# print ":$dthread\n";

			for my $truc (@{$s_hash{$dthread}{'fic'}}) {
				$semaphore->down;
			
				# eval( system( 'date' ) );
				print "fichier '$truc' dans '$s_hash{$dthread}{source}' vers '$s_hash{$dthread}{rep}'.\n";
				# transfert via pscp de PUTTY du ou des fichiers
				`C:/MCOBOX/pscp -sftp -pw <pwd> <login>\@<ip_adress>:$s_hash{$dthread}{source}/$truc "$s_hash{$dthread}{rep}/"` ;
			
				$semaphore->up;
			}

			$s_hash{$dthread}{'go'} = 0; #turn off self before returning      
		} else { 
			sleep 1;
		}
    }
END:
print "fin du Thread $dthread.\n";
}

sub fct_click { 

	my $param = shift;
	
	my $etat;
	my $etat1 = 'disabled';
	my $etat2 = 'disabled';
	if($param eq 'CSV') {
		$etat = 'disabled';
		$etat1 = 'normal';
	} elsif($param eq 'XML') {
		$etat = 'disabled';
		$etat2 = 'normal';
	} elsif($param eq 'BAD') {
		$etat = 'disabled';
	} else {
		$etat = 'normal';
	}

	$s_hash{$param}{'data'} = 'OUI'; 
	
	$s_hash{$param}{'go'} = 1; 

	$armen1->m_configure(-state => 'disabled'); 
	$armen2->m_configure(-state => 'disabled'); 
	$initse->m_configure(-state => ($s_hash{INITSE}{'data'} eq 'OUI')?'disabled':$etat); 
	$moa->m_configure(-state => ($s_hash{MOA}{'data'} eq 'OUI')?'disabled':$etat); 
	$niniv->m_configure(-state => ($s_hash{NINIV}{'data'} eq 'OUI')?'disabled':$etat); 
	$reseau->m_configure(-state => ($s_hash{RESEAU}{'data'} eq 'OUI')?'disabled':$etat); 
	$sirh->m_configure(-state => ($s_hash{SIRH}{'data'} eq 'OUI')?'disabled':$etat); 
	$csv->m_configure(-state => ($s_hash{CSV}{'data'} eq 'OUI')?'disabled':$etat); 
	$xml->m_configure(-state => ($s_hash{XML}{'data'} eq 'OUI')?'disabled':$etat1); 
	$reste->m_configure(-state => ($s_hash{BAD}{'data'} eq 'OUI')?'disabled':$etat2);
}