J'ai téléchargé la dernier version de mon "compilateur" préféré. Après quelques testes, je me suis rendu compte que plusieurs problèmes avait été résolue dans les dernières versions :
- Intégration natif des descriptions dans le champs détail de l'exe.
- Résolution des problèmes d'accents qui s'affichait mal.
- La fonction "Parcourir les dossiers" fonctionne également.
- Les faux positif avec les anti-virus semble également résolu.
Auparavant, j'étais obligé de modifier le code du compilateur pour contourner tout ces petites problèmes. Malheureusement les faux positif de l'anti-virus étais devenu vraiment très gênant. Du coup, j'ai "recompiler" tout mes applications avec la nouvelle version, et maintenant mes anti-virus ne râle plus du tout.
J'en ai profité pour moderniser l'interface d'Eco 7. Actuellement, je continue à moderniser son code. Je compte faire quelques modifications ici et là, et en particulier intégrer la base de données LiteDB.
Il y a quelques jours, j'ai appris que le https était devenu activable sur les blogs utilisant un domaine personnalisé. Je suis passé aussitôt sur le site bêta de Blogger (draft.blogger.com) pour activé la fonction HTTPS sur mon domaine personnalisé. Il faut un peu de temps pour que cela se mette en place. Après 24/48h le site est enfin accessible en https.
Pour que le site soit pleinement compatible http et https, j'ai du modifier le code de mes liens internes. Pour cela j'ai utilisé l'astuce suivant :
Généralement, les liens sont écrit sous la forme href="http://exemple.com". Si j'ouvre mon site en mode https, ce lien basculera le site en mode http. Pour corriger cela, je pourrai modifier mon lien pour qu'il ouvre la page en mode https en écrivant href="https://exemple.com". Malheureusement, si j'ouvre mon site en mode http, cela basculera le site en https. Pour éviter que le site bascule d'un mode à l'autre en cours d'exploration, l'astuce consiste à supprimer les mots "http:" et "https:" dans mes liens internes en utilisant la forme href="//exemple.com". Le navigateur comprendra alors qu'il faut conserver le protocole utilisé à l'ouverture du site et ne basculera plus inopinément entre les modes http et https.
Note du 2/3/2018 : Pour essayer de trouver une solution à mes problèmes d'indexations, j'ai basculé le site en full https.
Memo-LiteDB est un exemple d'utilisation des fonctions "FileStorage" de LiteDB. Ce programme ouvre un fichier RichTextBox depuis la base de données, et l'affiche dans la fenêtre "Mémo" après l'avoir décrypté à l'aide du mot de passe saisi à l'ouverture du programme. A la fermeture de la fenêtre, le fichier est enregistré dans la base de données LiteDB après l'avoir crypté.
Memo-LiteDB
Ce programme nécessite la Dll "LiteDB.dll" v5.0.10. Créer un dossier "ldb" au même niveau que le script. Puis télécharger la Dll dans le dossier "ldb".
Dans cet article, nous allons voir l'utilisation de la base de données LiteDB dans un environnement Windows PowerShell. Nous allons créer la base et ses collections. Nous verrons ensuite l'utilisation des instructions Insert, Update, Delete, Find, les requêtes [LiteDB.Query], et le stockage de fichiers.
Référence
Toujours à la recherche d'une base de données légère pour mes scriptes PowerShell, j'ai découvert LiteDB. Cette base de données
"sans serveur" de type NoSQL se présente sous la forme d'une simple Dll de moins de 300Ko. Elle ne nécessite ni installation, ni droit administrateur. LiteDB est donc facilement portable pour peu que le FrameWork 3.5 (ou compatible) soit installé sur le système.
Dans l'exemple ci-dessous, j'utilise la version 3.1.4 car la version 4.1.0 refusait de se charger sous certain environnement vieillissant (mais encore utilisé en entreprise).
################################################################
#
# Base de données : LiteBD v3.1.4
# Powershell.sekki.fr
#
# 1 - Créer un dossier ldb à côté du script.
# 2 - Télécharger et copier LiteDB.dll+xml dans le dossier ldb.
#
################################################################
#Ajouter un enregistrement dans la base de données.
$bson["_id"] = [LiteDB.ObjectId]::NewObjectId()
$bson["date"] = date
$bson["Nom"] = $nom
$bson["Prix"] = $prix
$bson["Cat"] = $cat
[void]$coll.Insert($bson) #Insére le document dans la collection.
}
#Modifier un enregistrement.
$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))
foreach ($q in $query)
{
$q["Cat"] = "A"
[void]$coll.Update($q)
}
#Supprimer un enregistrement : Méthode 1.
#$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))
#foreach ($q in $query)
# {
# $coll.Delete($q["_id"])
# }
#Supprimer un enregistrement : Méthode 2.
#$nb = $coll.Delete([LiteDB.Query]::eq("Nom","Jumbor"))
###Les requétes.
#Renvoi les articles dont le nom exact est :
$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))
#Renvoi les articles dont le prix est plus grand que :
$query = $coll.Find([LiteDB.Query]::gt("Prix",30))
#Renvoi les articles dont le prix est plus petit que :
$query = $coll.Find([LiteDB.Query]::lt("Prix",30))
#Renvoi les articles dont le nom commence par :
$query = $coll.Find([LiteDB.Query]::startswith("Nom","S"))
#Renvoi tout les enregistrements :
$query = $coll.Find([LiteDB.Query]::all())
###Charger des fichiers dans la base de données.
#Insérer/remplacer un fichier dans la base de données :
#$db.FileStorage.Upload("$/Fichiers/file1.jpg", $curpath+"\file1.jpg")
#Lire un fichier dans la base de données et l'enregistrer sur le disque local :
#[LiteDB.LiteFileInfo] $file = $db.FileStorage.FindById("$/Fichiers/file1.jpg")
#$file.SaveAs($curpath+"\file1.jpg")
#Lire un fichier dans la base de données et le charger dans une variable :
#[LiteDB.LiteFileInfo] $file = $db.FileStorage.FindById("$/Fichiers/file1.jpg")
#$image = [System.Drawing.Image]::FromStream($file.OpenRead())
#Pause
if (!$psISE) { Write-Host -NoNewLine "Press any key to continue..."
$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") }
#Compresser la base de données.
[void]$db.Shrink()
Dans cet article, nous allons voir l’accès aux bases PostgreSQL avec Windows PowerShell et le Data Provider "Ngpsql.dll". L'exemple suivant montre comment se connecter sur une base PostgreSQL, et utilisation des instructions Create Table, Insert, Query, Update et Drop Table.
Référence
Avant d’exécuter le script, notez que j'ai préalablement installé un serveur "PostgreSQL Portable" sur lequel j'ai créé la base de données "Base1". J'ai également créé un dossier "npgsql" au même niveau que mon script. Ce dossier contient contient les fichiers du Data Provider NpgSQL. La table et les données peuvent être créé ensuite à l'aide des exemples de requêtes SQL présent dans le script.
#---------------------------------------------------------------------------#
#Voici la liste de différentes requêtes SQL que vous pouvez essayer.
#Supprimez le # devant la requête SQL que vous souhaitez tester.
#---------------------------------------------------------------------------#
#Créer une table.
#$psQuery = "CREATE TABLE Table1(Colonne1 nchar(16) PRIMARY KEY NOT NULL, Colonne2 nchar(16));"
#Ajouter une ligne.
#$psQuery = "INSERT INTO Table1(Colonne1,Colonne2) VALUES ('Jumbor','PowerShell');"
#Lire une table.
#$psQuery = "select * from Table1;"
#Lire une ligne.
#$psQuery = "select * from Table1 WHERE Colonne1 = 'Jumbor12';"
#Modifier une valeur.
#$psQuery = "UPDATE Table1 SET Colonne2 = 'PowerShell 2.0' WHERE Colonne2 = 'PowerShell';"
#Supprimer une ligne.
#$psQuery = "DELETE FROM Table1 WHERE Colonne1 = 'Jumbor12';"
#Supprimer une table.
#$psQuery = "DROP TABLE Table1;"
#---------------------------------------------------------------------------#
Cet exemple montre comment mettre en place une icône dans la zone de notification (System Tray). Pour cela, nous allons construire notre l’icône avec l'object System.Windows.Forms.NotifyIcon auquel nous allons associer un menu contextuel. Le menu contextuel permettra d'afficher la fenêtre lorsque celle-ci est masquer, de simuler un popup dans la zone de notification, et de quitter l'application.
#Construction de l'icone pour la zone de notification.
#Attention : Mettre un chemin valide pour le fichier .ico.
$TrayIcon = New-Object System.Windows.Forms.NotifyIcon
$TrayIcon.Icon = "c:\xxx.ico" #Image au format .ico.
$TrayIcon.Text = "TrayIcon" #Texte de l'info bulle.
$TrayIcon.ContextMenu = $menuT1 #Menu contextuel.
$TrayIcon.Visible = $True
#Fenêtre.
$formA = New-Object System.Windows.Forms.form
$formA.Size = New-Object Drawing.Point 200,90
$formA.Text = "Tray Icon" #Titre de la fenêtre.
#Masque la fenetre dans la barre de taches.
$formA.ShowInTaskbar = $false
#Bouton pour afficher un popup dans la zone de notification.
$boutonA2 = New-Object Windows.Forms.Button
$boutonA2.Location = New-Object Drawing.Point 5,28
$boutonA2.Size = New-Object System.Drawing.Size(85,23)
$boutonA2.text = "Popup"
$boutonA2.add_click({
$TrayIcon.BalloonTipTitle = "Tray Icon"
$TrayIcon.BalloonTipText = $textA1.Text
$TrayIcon.BalloonTipIcon = "Info" #None,Info,Warning,Error
$TrayIcon.ShowBalloonTip(300000)
})
#Champ texte pour changer le texte du popup.
$textA1 = New-Object Windows.Forms.TextBox
$textA1.Location = New-Object Drawing.Point 5,5
$textA1.Size = New-Object System.Drawing.Size(175,23)
$textA1.Text = "Changez moi !"
#Afficher la fenêtre.
$formA.controls.add($boutonA1)
$formA.controls.add($boutonA2)
$formA.controls.add($textA1)
[void][System.Windows.Forms.Application]::Run($formA)
#Fin.
$TrayIcon.Dispose()
Merci de remplacer le chemin "c:\xxx.ico" dans l'exemple par un chemin valide vers un fichier .ico (celui de votre choix). Sinon vous obtiendrez une erreur lors de l’exécution de l'exemple.
Dans cet exemple, j'utilise un script en cSharp pour récupérer les frappes clavier sur les touches F1 à F12. Puis je passe l'information au script Windows PowerShell. Cette technique me permet de déclencher une action sans avoir le focus sur l'application PowerShell (Global Hook)
Dans cet exemple, j'utilise un programme déjà publié un peu partout, mais adapté ici pour récupère que les touches de fonctions de F1 à F12. Ce programme se décomposer en deux parties. Un programme en CShape que j’intègre directement dans le script PowerShell et qui est lancé dans un RunSpace afin de ne pas bloquer mon script. Et un programme principale en PowerShell qui lance l'action lorsque la frappe est détecté. La communication entre les deux programmes n'est pas ce qu'il y a de plus simple à traiter. Après plusieurs essai, j'ai actuellement opté pour un socket réseau afin de pouvoir échanger des données entre le programme en CShape et le programme principale en Powershell. Ce n'est pas forcement l'idéal, mais c'est la solution qui m'a posé le moins de problèmes.
Exemple
##################################################################
# Script C# :
# Récupère les frappes aux claviers (quelques soit l'application),
# et en informe le programme en écrit en Powershell.
##################################################################
# Script PowerShell :
# Lance le script en C# dans un nouveau thread, et écoute les
# informations transmissent par le script en C#.
##################################################################
##################################################################
# Script C#
# Récupère les frappes aux claviers (F1 à F12),
# et on informe le script PS1.
##################################################################
$csharp1 = {
Add-Type -TypeDefinition @"
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Net.Sockets;
using System.Diagnostics;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace KL {
public static class Program {
private const int WH_KEYBOARD_LL = 13;
private const int WM_KEYDOWN = 0x0100;
##################################################################
# Ouverture d'un canal de communication réseau en UDP.
# Communication entre le script C# et PowerShell.
##################################################################
##################################################################
# Lance l'application C# dans un Runspace.
##################################################################
##################################################################
# Timer pour écouter les retours de l'application C#
##################################################################
Pour éviter qu'une partie du programme continue de tourner tout seul dans son coin, il est important de bien fermer tout ce petit monde dans l'ordre. Tout d'abord il faut demander au programme CSharp de se fermer. Pour cela je simule dans mon programme PowerShell une frappe sur la touche F16. Le programme CShape est configuré pour s'arrêter lorsqu’il capture une frappe sur la touche F16. Ceci fait, je ferme mon RunSpace, puis je libérer mes ressources réseaux.
Nous allons voir dans cet article les bases permettant de gérer un fichier Xml avec Windows PowerShell. Dans les exemples suivants, nous allons lire le fichier Xml. Le premier exemple utilise la méthode de l'index pour lire les données. Le second exemple utilise la commande foreach.
Fichier XML
En premier lieu, nous allons créer un fichier texte "livres.xml". Ce fichier doit contenir les lignes de données suivantes :
Une fois le fichier enregistré (dans c:\temp par exemple), nous allons utiliser PowerShell pour le lire.
Exemple 1
#Lecture du fichier.
[xml]$xml = get-content (“c:\temp\livres.xml”)
#Je récupéré dans $Livres les données entre la balise <Livres> et </Livres>.
$Livres = $xml.Livres
#Puis j'affiche mes données.
Write-Host $Livres.Manga[0].Edition
Write-Host $Livres.Manga[0].Titre
Write-Host $Livres.Manga[0].Numero
Ici je suis obligé d'indexer $Livre.Manga[] car dans mon fichier Xml, j'ai plusieurs fois la balise <Manga>. Si la balise n'était présente qu'une seul fois, j'aurais dû écrire Write-Host $Livres.Manga.Edition (sans l'indexation). Ceci viens de l’interprétation de la commande Get-Content. Lorsqu'il rencontre plusieurs fois une même balise, il la traduit sous la forme d'un tableau. Pour éviter les problèmes d'écriture suivant le nombre d’élément répétable présent dans un document Xml, il vaut mieux passer par un Foreach :
Exemple 2
#Lecture du fichier.
[xml]$xml = get-content (“c:\temp\livres.xml”)
#Je récupéré dans $Livres les données entre la balise <Livres> et </Livres>.
$Livres = $xml.Livres
#Puis j'affiche mes données.
foreach ($m in $Livres.Manga)
{
Write-Host $m.Edition
Write-Host $m.Titre
Write-Host $m.Numero
}
Ici, la commande foreach fonctionne quelques soit le nombre de balise <Manga> présent dans le document Xml.
Dans cet article, nous allons voir comment utiliser les bases FireBird avec
Windows PowerShell et le Data Provider "Ado.net". L'exemple suivant
montre comment se connecter sur une base FireBird, et utilisation des
instructions Create Table, Insert Into, Select, Update, Delete From et Drop Table.
Installer FireBird
Je cherchais une base de donnée légère et portable pour pouvoir héberger mes données et je suis tombé sur FireBird. Cette base de donnée fait moins de 20Mo, et il est possible de la rendre portable à l'aide d'une petite procédure.
Tout d'abord nous devons installer FireBird. Les sources sont ici "Download_FireBird". Téléchargez la dernière version pour Win64 "SuperServer", puis installez la base de donnée.
Il nous faudra également un connecteur pour pouvoir utiliser FireBird avec PowerShell. Les sources du connecteur sont ici "ADO.NET".
La procédure pour convertir FireBird en version portable est ici "Procédure". Bon d'accord, c'est en anglais. Je vais vous traduire ca rapidement :
- Installez FireBird (si ce n'est pas déjà fait).
- Arrêtez les services de FireBird.
- Copiez le dossier “C:\Program Files\Firebird\Firebird_2_5\” sur votre clé USB par exemple.
- Ouvrez le dossier ou vous avez copié FireBird.
- Supprimez le fichier firebird.conf (Si vous avez apporté des modifications).
- Créez un nouveau batch nommé "Start.bat".
- Editez le fichier "Start.bat", et copiez les deux lignes suivante dedans : cd bin fbserver.exe -a -p 3050 -database "localhost:..\security2.fdb" –n
- Créez également le batch "Stop.bat".
- Editez le fichier "Stop.bat", et copiez la ligne suivante dedans : taskkill /F /IM fbserver.exe /T
Et voila c'est fini ;)
FlameRobin
Bien que cela ne sois pas indispensable pour cet article, vous pouvez également installer FlameRobin pour l'administration graphique de la base. Je vous laisse consulter le site ici "FlameRobin".
Créer une base
Maintenant que FireBird tourne, il est temps de créer une base de donnée. Allez dans le dossier "FireBird\bin", et lancez "iSQL.exe". Tapez la commande suivante : SQL>CREATE DATABASE 'mypath\JumborDB.fdb' page_size 8192 CON>user 'SYSDBA' password 'masterkey';
N'oubliez pas de remplacer "mypath" par un chemin valide.
Exemple
#############################################################
# Prérequis :
# Installer le connecteur ADO.NET.
# Créer la base de test "JumborDB" avec iSql.
#############################################################
#Chaine de connection.
$Connetion = "User=SYSDBA;Password=masterkey;DataSource=localhost;Port=3050;Database=JumborDB;initial catalog=mypath\\JumborDB.fdb;Dialect=3;Charset=NONE;Role=;Connection lifetime=15;Pooling=true;MinPoolSize=0;MaxPoolSize=50;Packet Size=8192;ServerType=0;"
#N'oubliez pas de remplacer "mypath" par un chemin valide.
Function FB_Query([string] $fbConn, [string] $fbQuery)
{
#Etablit la connexion avec la base SQL.
$firebird = new-object FirebirdSql.Data.FirebirdClient.FbConnection($fbConn)
$firebird.Open()
#Exécute et récupère le résultat.
$DataSet = New-Object System.Data.DataSet
$Adapter = New-Object FirebirdSql.Data.FirebirdClient.FBDataAdapter($fbQuery, $firebird)
$Adapter.Fill($DataSet)
#Ferme la connexion avec la base SQL.
$firebird.Close()
#Renvoie le résultat.
return $DataSet.Tables[0]
#Close.
$Adapter.Close
$DataSet.Close
}
######################################################################
# Voici la liste de différentes requêtes SQL que vous pouvez essayer.
# Supprimez le # devant la requête SQL que vous souhaitez tester.
######################################################################
#Créer une table.
#$myQuery = "CREATE TABLE Table1 (Colonne1 varchar(20) not null, Colonne2 varchar(20) not null)"
#Ajouter une ligne.
#$myQuery = "INSERT INTO Table1 (Colonne1,Colonne2) VALUES ('Jumbor12','PowerShell')"
#Lire une table.
#$myQuery = "SELECT * FROM Table1"
#Lire une ligne.
#$myQuery = "SELECT * FROM Table1 WHERE Colonne1 = 'Jumbor12'"
#Modifier une valeur.
#$myQuery = "UPDATE Table1 SET Colonne2 = 'PowerShell 2.0' WHERE Colonne2 = 'PowerShell'"
#Supprimer une ligne.
#$myQuery = "DELETE FROM Table1 WHERE Colonne1 = 'Jumbor12'"
#Supprimer une table.
#$myQuery = "DROP TABLE Table1"
######################################################################
#Affiche la requête exécutée.
Write-Host $myQuery
#Exécute la requête.
$rtn = FB_Query $Connetion $myQuery
foreach ($raw in $rtn)
{
#Ici j'affiche le retour pour les requêtes de lecture de données.
Try { Write-Host "Line :" $raw[0] $raw[1] } catch {}
}
Write-Host "Exécution terminé."
Je vais vous présenter ici un exemple de barre de progression basé sur l'objet "Forms.ProgressBar". La barre de progression prend une valeur allant de 0 (vide) à 100 (plein). Bien entendu, par défaut cette valeur est à 0. La barre de progression augmente d'une valeur définit dans la propriété ".Step" en appelant la méthode ".PerformStep()". Par exemple, si la propriété ".Step" est définit à 25, il faudra appeler 4 fois la méthode ".PerformStep()" pour remplir la barre de progression.
#Timer.
#Le timer va me permettre de lancer automatiquement le traitement
#1 seconde après l'ouverture de la fenêtre.
$timer1 = new-object System.Windows.forms.timer
$timer1.Interval = 1000 #Initialement je lance le timer au bout d'une seconde.
$timer1.Enabled = $true
$timer1.add_Tick({
#Initialisation.
#Pour éviter de lancer 2 fois le traitement je change
# l'intervalle d'exécution du timer.
$timer1.Interval = 999999
#Boucle de traitement.
for ($i=0;$i -le 100;$i++)
{
#Force l'exécution des events de la fenêtre.
[System.Windows.Forms.Application]::DoEvents()
#Mise à jour de la bar de progression.
$progressA1.PerformStep()
#Traitement de votre choix.
Sleep -Milliseconds 50
}
#Arrête le timer et ferme la fenêtre.
$timer1.Stop()
$formA.Close()
})
#Attache les contrôles à la fenêtre.
$formA.controls.add($labelA1)
$formA.controls.add($progressA1)
Nous allons voir dans cet article deux méthodes pour créer un timer et afficher le résultat d'une commande à intervalle régulier. Dans les exemples suivants, je vais afficher le résultat de la commande "Get-Process" toutes les 5 secondes. Mon premier script montre comment créer un timer dans une console PowerShell.
Exemple 1
#Création d'un timer.
$timer = new-object timers.timer
$timer.Interval = 1000 #Démarrage.
$nom = "T1" #Identifiant de mon timer.
$boucle = 5 #Arrête le timer après 5 exécutions.
Le script suivant est une solution alternatif. Il utilise le timer des fenêtres (Forms) pour afficher toutes les 5 secondes le résultat de la commande "Get-Process".
######################
# Console avec timer
######################
#Paramêtres.
$global:consw = 600 #Largeur de la console au démarrage.
$global:consh = 300 #Hauteur de la console au démarrage.
$global:intvl = 5 #Intervale d'execution du timer (en seconde).
$global:titre = "Console avec timer" #Titre de la fenêtre.
(NDA : Malheureusement cet article est un peu obsolète aujourd'hui. Je vais préparer un nouvel article avec le résumé des commandes AD actuelles.)
Il existe différentes façons d'interroger l'Active Directory en PowerShell. Dans cet article, j'utilise l'extension de commande de Quest pour manipuler l'AD.
Edit : A l’époque ou j'ai rédigé cet article, Quest était une très bonne alternative aux commandes natives disponibles sous PowerShell. Evidement, aujourd'hui en 2018 les systèmes Windows Serveurs AD intègre cela très bien sans avoir à passer par cet extension.
Installation
1) Allez sur le site de Quest "www.quest.com/powershell/activeroles-server.aspx"
2) Cliquez sur la case à cocher "I have read and accept the agreement".
3) Téléchargez la dernière version de "ActiveRoles Management Shell for AD".
4) Et installez l'extension.
(La documentation pdf est plutôt bien fait. N'hésitez pas à la consulter.)
Liste des groupes d'un utilisateur (méthode alternatif)
Normalement Quest propose la fonction "Get-QADMemberOf" pour réaliser cette action. Malheureusement lorsque cette commande rencontre un groupe d'un domaine qui ne vous est pas accessible, elle s'arrête avec une erreur et ne retourne rien. Si vous rencontrez ce problème, je vous propose de passer par le script suivant :
#Chargement des commandes Quest.
Add-psSnapin quest.activeroles.admanagement
#Compte de connexion à l'AD.
$username = "DOMAINE\login.admin"
#Invite de saisi du mot de passe.
$password = read-host ("Password pour "+$username) -assecurestring
#Connexion à l'AD
$AD1 = Connect-QADService -service "domain.sekki.fr" -Credential $cred
#Affiche les groupes de l'utilisateur au format "Domain\Groupe".
$user = "DOMAINE\login.user"
Get-QADUser $user | foreach {
foreach ($mof in $_.MemberOf)
{
#Initialise.
$grp = "";$dom = "";
#Converti les données séparées par une virgule en tableau.
$tmof = $mof.split(",")
#Recupère le nom du groupe.
foreach($e in $tmof) { if ($e -like "CN=*") {$grp = $e;break} }
#Récupère le nom du domaine du groupe.
foreach($e in $tmof) { if ($e -like "DC=*") {$dom = $e;break} }
#Supprime les infos initules.
$grp = $grp.Replace("CN=","")
$dom = $dom.Replace("DC=","")
#Recompose le nom du groupe au format "Domain\Groupe".
$groupe = $dom+"\"+$grp
#Affiche le nom du groupe.
write-host $groupe
}
}
#Déconnexion de l'AD.
Disconnect-QADService -connection $AD1
