[clos] outil de recherche d'informations

ar barzh paour · Le 06/12/2018, à 19:28

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


###########################################################################################

Dernière modification par ar barzh paour (Le 28/02/2019, à 18:23)

ar barzh paour · Le 06/12/2018, à 19:35

quelques premièrs lignes de mes fichiers :

awk;
awk;champ;
awk;syntaxe
cat;ajout;
chaine;extraction;expression
gsettings;clé;schéma
dmidecode;matériel;bios;cpu;smbios;
mise-à-jour;paquet
sed;ajout;insertion
test;[;[[

etc

en prime le .desktop que j'ai sur mon bureau, à adapté en fonction de vos emplacements de fichiers bien sur

[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Icon[fr_FR]=/home/jpb/Images/yeux.png
Name[fr_FR]=info-commandes-programmes
Exec=/media/SH/cmd-yad "/media/Data/informatique/cmd"
Comment[fr_FR]=recherche-info-commandes
Name=info-commandes via SH
Comment=recherche-info-commandes via SH
Icon=/home/jpb/Images/yeux.png
Comment[fr_FR.UTF-8]=donnez en paramètre le répertoire de recherche

Dernière modification par ar barzh paour (Le 07/12/2018, à 05:35)

ar barzh paour · Le 07/12/2018, à 05:42

une amélioration si quelqu'un sait faire :
dans la boite de dialoque de yad

actuellement le fonctionnement est le suivant :
on saisit le mot à rechercher
puis il faut cliquer sur "valider"

je trouverais plus pratique que le retour chariot valide la saisie, je ne sais pas si c'est possible dans yad

ar barzh paour · Le 16/12/2018, à 09:19

remplacement version 2018/12/07 par 2018/12/16 , petites améliorations

ar barzh paour · Le 28/02/2019, à 18:23

pas de réaction
je clos

moths-art · Le 06/03/2019, à 21:05

Désolé, j'ai pas trop compris à quoi ça servait.

bruno · Le 06/03/2019, à 22:57

Bonsoir,

Exemple 1 :
On ne lance jamais un gestionnaire de fichier en mode graphique en tant que root.

Exemple 2 :

ls -ails *.mp3
cat *.txt
mv *.mp3 /var/tmp/

Watael · Le 06/03/2019, à 23:07

find permet de descendre dans les sous-répertoires.
par contre, pour cat et rm, j'aurais utiliser + au lieu de \;
et pour ls, je ne sais pas l'option -ls ne permettrait pas la même chose... ?

bruno · Le 06/03/2019, à 23:10

Watael a écrit :

find permet de descendre dans les sous-répertoires.

ls aussi

ls -Rails *.mp3

moths-art · Le 06/03/2019, à 23:12

Ok, je comprends mieux.

Perso, j'utilise "eg" avec des fichiers en markdown (donc t'as de la couleur, gras, liens cliquables etc.). Mes exemples sont là : https://github.com/mothsART/mongrimmoire
Le tout soupoudré de petits alias dans mon zshrc.

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 06/12/2018, à 19:28

[clos] outil de recherche d'informations

#2 Le 06/12/2018, à 19:35

Re : [clos] outil de recherche d'informations

#3 Le 07/12/2018, à 05:42

Re : [clos] outil de recherche d'informations

#4 Le 16/12/2018, à 09:19

Re : [clos] outil de recherche d'informations

#5 Le 28/02/2019, à 18:23

Re : [clos] outil de recherche d'informations

#6 Le 06/03/2019, à 21:05

Re : [clos] outil de recherche d'informations

#7 Le 06/03/2019, à 22:57

Re : [clos] outil de recherche d'informations

#8 Le 06/03/2019, à 23:07

Re : [clos] outil de recherche d'informations

#9 Le 06/03/2019, à 23:10

Re : [clos] outil de recherche d'informations

#10 Le 06/03/2019, à 23:12

Re : [clos] outil de recherche d'informations

Pied de page des forums