comme j'ai une petite tête je me suis fait un petit shell
il faut
un répertoire dans lequel
on met des fichiers .txt
formatés ainsi :
première ligne : un ou plusieurs mots séparés par des ;
lignes suivantes : du texte correspondant aux mots de la première ligne
le shell "cmd-yad"
il utilise "yad" , il faut donc que yad soit installé voir
https://doc.ubuntu-fr.org/yad_yet_another_dialog
dans la boite qui s'ouvre , on met un mot à rechercher (ou une partie de mot) ou un des mots proposés
(mais pas de jokers)
le shell affichera dans une fenêtre les fichiers dont la première ligne contient le mot en question
il y a peut-être des bugs mais je m'en sers beaucoup ..... depuis .. un certain temps ....
quelques exemples de fichier (les noms de fichier ne servent pas)
exemple 1
fichier 1.txt
gksudo;
depuis 18.04 ne plus utiliser
gksudo nautilus
mais
nautilus admin:///
exemple 2
fichier 2.txt
find;recherche;
find voir man file exemples P367
======================================================================
trouver tous les « .mp3 » et exécuter ls -ails sur eux
find -iname "*.mp3" -exec ls -ails {} \;
=======================================================================
faire un cat sur tous les fichiers .txt
find -iname "*.txt" -exec cat {} \;
===============================================================
trouver tous les fichiers .mp3 et les transférer dans /var/tmp/
find -iname ''*.mp3'' -exec ....
==========================================================================
...... suivent plusieurs exemples
exemple 3
fichier 3.txt
dwservices;connexion
1-sur le PC à controler :
il faut la première fois
télécharger le programme dwagent.sh sur le site de DWServices
le rendre exécutable
puis à chaque demande d'intervention
lancer le programme
choisir exécuter
le programme donne les infos suivantes :
utilisateur et mot de passe à fournir au PC qui controlera
317-044-287-92 4316
2-le PC controleur
se connecte sur DWServices
remplit utilisateur (317-044-287-92) et mot de passe (4316) donnés par le PC à contrôler
le shell cmd-yad (beaucoup de choses à revoir certainement)
(j'ai utilisé des trucs qui vont sans doute faire hurler les puristes .....)
dans tri_chaine par exemple si /dev/shm n'est pas monté , il faudra utiliser tmp
que l'on appelle par cmd-yad <nom du répertoire contenant les fichiers textes> .. ou par un .desktop adéquat
#!/bin/bash
#le paramètre 1 est le répertoire de recherche
version="2018/12/07"
version="2018/12/16"
echo $0 " $version"
if [[ $# -eq 0 ]]
then
rep1="/media/Data/informatique/cmd"
else
rep1="$1"
fi
if [[ ! -d "$rep1" ]]
then
zenity --info --text="répertoire non trouvé : $rep1" --title $0
exit 1
fi
# le répertoire temporaire
[[ -d /tmp ]] && TMP="/tmp"
[[ -d /dev/shm ]] && TMP="/dev/shm"
[[ -z ${TMP} ]] && TMP="/home/$USER"
#####################################################################################
fich=${TMP}/res_rech.txt
liste_fich=${TMP}/liste_fich.txt
resultat_final=${TMP}/résultat_final.txt
lon_totale=100 # longueur de la chaine diese générée
lon_debut=10 # longueur chaine de début
recherche_exacte="FALSE"
#####################################################################################
function sortir { # effacer les fichiers temporaires en sortant
rm ${resultat_final} 2>/dev/null
rm ${liste_fich} 2>/dev/null
rm ${fich} 2>/dev/null
exit
}
chaine_de_longueur() { # reçoit un caractère [ou chaine] $1 , une longueur $2 ,
# renvoie une chaine constituée de $2 caractères
typeset chaine
#tests erreur
[[ $# -lt 2 ]] && { echo "il faut 2 paramètres" ; return 63 ; }
i=0 ; chaine=""
while [[ $i -lt $2 ]]
do
((i++))
chaine="${chaine}$1"
done
echo ${chaine:0:$2}
}
####################################################################################
# pour la présentation du résultat génération d'une chaine de "$lon_totale" dièses
diese=$( chaine_de_longueur "#" $lon_totale )
# pour la présentation du résultat génération d'une chaine de "$lon_debut" dièses
ch1=$( chaine_de_longueur "#" $lon_debut )
###################################################################################
function tri_chaine { # recoit $1 x1;x2;x3;.....xn
# renvoie une chaine y1;y2;y3....yn
# termes sont tous différents et triés alphabétiquement
# on doit pouvoir faire plus simple !!!!
# écrire chaque terme de $1 dans tmp2.txt
tmp2=${TMP}/tmp2.txt
rm ${tmp2} 2>/dev/null
( IFS=";" list=($1) ; \
for i in ${!list[@]} ; \
do echo ${list[$i]} >> ${tmp2} ; \
done \
)
# tri et suppression des doublons ,résultat dans tmp1.txt
tmp1=${TMP}/tmp1.txt
sort ${tmp2} | uniq > ${tmp1}
# reconstruire la chaine en lisant le fichier tmp1.txt
chaine=""
while read ligne
do
chaine="${chaine}${ligne};"
done < ${tmp1}
# effacer les fichiers inutiles
rm ${tmp1} 2>/dev/null
rm ${tmp2} 2>/dev/null
# envoyer le résultat
echo "$chaine"
}
###################################################################################
# récupère la 1ère ligne des fichiers : dmidecode;...;smbios awk;champ; yad;form etc ;octet
res=$( find "$rep1" -depth -name "*.txt" -exec head -1 {} \; )
# pour le traitement par yad , remplacement de "; " et de " " par ";"
tmp3=$( sed 's/ *; */;/g' <<< "$res" )
# tri et supression des doublons
tmp4=$( tri_chaine "$tmp3" )
# remplacement des ";" par "!" pour le traitement de yad CBE
prem=$( sed -e 's/;/!/g' <<< $tmp4 ) # donne !()![![[!]]!{}!ajout!ansi!.....!m_a_j!..!mise_a_jour!mise-à-jour!..
###################################################################################################
function calcul_chaine_3 {
# reçoit $1=nom de fichier $2=ch4 et $3=numéro [déjà formaté sur 3 car]
# retourne ch , chaine formatée de x dièses de façon à ce ce que
# <$lon_debut dièses><$1><$ch3><ch4><ch5> ait une longueur de $lon_totale
# ${#1} c'est la longueur nom fichier
# ${#2} c'est la longueur de "début" ou "fin "
# ${#3} c'est la longueur n°
(( lon3 = $lon_totale - $lon_debut - ${#1} - ${#2} - ${#3} -1 ))
echo $( chaine_de_longueur "#" $lon3 )
}
##################################################################################################
function ajuster-le-texte { # mot1 mot2 ou mot1 ou mot2
if [[ -z "$saisie1" ]]
then
texte="$saisie2" # si rien dans la saisie 1 , on prend mot2
else
if [[ -z "$saisie2" ]]
then
texte="$saisie1" # sinon si rien dans saisie 2 , on prend mot1
else
if [[ "$saisie1" = "$saisie2" ]]
then # si 2 saisies identiques , on prend mot1
texte="$saisie1"
else
texte="$saisie1 et de $saisie2" # si 2 saisies différentes , on prend les 2
fi
fi
fi
}
#################################################################################################
while true # la sortie se fait par le choix Fermer ("gtk-close")
do
res=$( yad --center --width 500 \
--title="$0 : Recherche d'informations " \
--text="Recherche de fichiers" \
--form \
\
--field="dont la première ligne contient:CBE" "!$prem" \
--field="(option) et qui contient aussi" "" \
--field="Répertoire de recherche :CB" "$rep1" \
--field="sous-répertoires inclus :CHK" TRUE \
--field="recherche exacte sur le 1er mot :CHK" $recherche_exacte \
--button="gtk-edit:3" \
--button="gtk-close:1" \
--button="gtk-ok:0" \
2>/dev/null )
code=$?
echo "code : $code"
[[ $code -eq 1 ]] && sortir # sortir
[[ $code -eq 2 ]] && continue # ici ne sert à rien , pas de code 2
[[ $code -eq 252 ]] && continue # clic sur la croix de fermeture de fenêtre
[[ $code -eq 127 ]] && zenity --info --text="il faut installer yad pour pouvoir continuer" --title $0 && sortir
# récupération des saisies
saisie1=$(echo "$res"|awk -F'|' '{print $1}')
saisie2=$(echo "$res"|awk -F'|' '{print $2}')
rep=$(echo "$res"|awk -F'|' '{print $3}')
s_rep=$(echo "$res"|awk -F'|' '{print $4}')
recherche_exacte=$(echo "$res"|awk -F'|' '{print $5}')
[[ "$saisie1""$saisie2" = "" ]] && continue # aucune saisie on retourne au début
# à re-étudier saisie des caractères spéciaux
[[ "$saisie1" = "[[" ]] && saisie1="\[\["
# traitement
if [[ "$rep" = "$rep1" ]] # "/media/Data/informatique/cmd"
# mais il n'y a qu'un répertoire
then
ajuster-le-texte
nb=0
echo "recherche de $texte dans le répertoire $rep " > $fich
case "$s_rep" in
"TRUE" ) s_r=2 ; echo "avec les sous répertoires" >> $fich ;;
"FALSE" ) s_r=1 ; echo "sans les sous répertoires" >> $fich ;;
esac
# XYXYXYXYXYXY sera remplacé par le nombre de fichiers trouvés
echo "Nombre de fichier(s) trouvé(s) : XYXYXYXYXYXY" >> $fich
# récupérer le nom des fichiers .txt
find "$rep" -maxdepth $s_r -iname "*.txt" > "$liste_fich"
while read f # nom de fichier du répertoire de recherche
do
# récupérer les noms de fichiers adéquats
if [[ $recherche_exacte = "TRUE" ]]
then
# recherche exacte
res=$(head -1 "$f" | grep -iw "$saisie1" | grep -iw "$saisie2" )
else
# recherche simple
res=$(head -1 "$f" | grep -i "$saisie1" | grep -i "$saisie2" )
fi
if [[ -n "$res" ]] ; then
((nb++)) ; n=" $nb" ; ch5=${n:(-3)} # numéro sur 3 caractères
rep=$(dirname "$f")
# pour une meilleure présentation
ch3=$( calcul_chaine_3 "$rep " " début" "$ch5" )
echo >> $fich
echo "$ch1 $rep $ch3 début$ch5" >> $fich
echo " fichier : $(basename "$f")" >> $fich
echo $diese >> $fich
cat "$f" >> $fich
echo $diese >> $fich
echo " fin fichier : $(basename "$f")" >> $fich
ch3=$( calcul_chaine_3 "#" " fin " "$ch5" )
echo "$ch1##$ch3 fin $ch5" >> $fich
#echo $diese >> $fich
fi
done < "$liste_fich"
if [[ $nb -eq 0 ]]
then
echo "rien trouvé" >> $fich
else
echo "$nb fichier(s) trouvé(s)" >> $fich
fi
sed "3 s/XYXYXYXYXYXY/$nb/" < "$fich" > ${resultat_final}
zenity --text-info --filename "${resultat_final}" --height "640" --width "1280" --font "Monospace Bold 12" --title $0
else
zenity --info --text="pas encore traité" --title $0
#sleep 2
fi
done
###########################################################################################
