Question MIGRATION AD renommage des COMPTES

Bonjour, à tous, je me permets de poster car je commence à m'arracher les cheveux ;oD

Dans le cadre d'une migration AD, je vais importer 450 comptes dans mon annuaire. Les comptes importer ont bien les champs NOM et PRENOM renseignés dans le LDAP. Par contre le SAMACCOUNTname (LE LOGIN) est basé sur le matricule. Je dois donc reconstruire celui-ci basé sur une autre nomenclature qui est NOM + premiere LETTRE DU prenom.

On doit bien-entendu vérifier la presence de Doublon et faire attention aux prénoms composés.


Voici la base de mon code. A partir de là j'ai fait plein d'essais mais je n'arrive pas à rester sur un script totalement Dynamique. J'y arrive si je définis tous les cas et que je Check si je tombe dans un de ces cas là.

[code:1]

# Debut de script permettant le renommage automatique du SAMACCOUNTNAME (nom d'ouverture de session) des agents qui viennent d'etre importés dans notre AD.

#On récupere tous les objets USERS de l'OU citée avec les propriétés CN, GIVENNAME, et SN et apres le pipe on FOREACH
Get-ADUser -filter * -searchbase \"OU=USER_GPO_TEST,OU=XXxXX,OU=BAC à SABLE,dc=XXX,dc=COM\" -Properties cn, givenName, sn, samaccountname |

ForEach {


#Pour chaque élément trouvé on définit les variables suivantes :
$Sam = $_.sAMaccountname
$Upn = $_.UserPrincipalName
$given = $_.givenName
$Givenmatch = 0
$GivenLenght = $given.lenght
#On supprime les accents et autres caracteres spéciaux. On se servira des variables normalisées pour creer les logonname.
$SamOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Sam))
$UpnOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Upn))
$GivenOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Given))
$SamFinal = $SamOK.tolower()
$UpnFinal = $UpnOK.tolower()
$GivenFinal = $GivenOK.tolower()


#On check si il y a un TIRET dans le prenom ( prenom composé ) si c'est le cas on passe une variable de controle à 1 pour effectuer un traitement spécifique sous condition.
If($GivenFinal -Match \"-\"«») { $GivenMatch = 1 }
Else { $GivenMatch = 0 }



$GivenSubString = 1
$SamNew = $_.sn + $givenfirstletter
$Ldapsam = $_.sn + $givenfinal.substring(0,$GivenSubString)
$CheckTwice = get-aduser -LDAPFilter \"(sAMAccountName=$ldapsam)\"





# A partir de là ON a formaté le nom et le prenom en minuscule, on a supprimé les accents et on est capable de savoir si il y a un tiret dans le prénom ainsi que le nombre de caratere du prénom.






}

[/code:1]



Je rencontre un probleme pour incréménté le parametre de la fonction SUBSTRING

$givenfinal.substring(0,$GivenSubString)

Si je fais un $GivenSubString++ j'ai l'impression que la focntion ne marche pas . ;oD




Et voici ce que j'avais fait à la base
Pour comprendre , Un truc bien degueulace mais qui focntionnait, Par contre la on prend pas en compte le fait du prenom composé.

:

[code:1]
#On récupere tous les objets USERS de l'OU citée avec les propriétés CN, GIVENNAME, et SN et apres le pipe on FOREACH
Get-ADUser -filter * -searchbase \"OU=USER_GPO_TEST,OU=xXX,OU=BAC à SABLE,dc=xXX,dc=COM\" -Properties cn, givenName, sn, samaccountname |




#Pour chaque élément trouvé on définit les variables suivantes :

ForEach {


# Les différents cas , avec les pluseirus possibilités de nommage ex : spagnoli alexis : givinfirstletter = a // givinfirst2letters = al // givenfirst3letters = ale
$Sam = $_.sAMaccountname
$Upn = $_.UserPrincipalName
$given = $_.givenName
$SamOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Sam))
$UpnOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Upn))
$GivenOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Given))
$GivenSubString = 1



#
switch ($given.length)
{
1 { $givenfirstletter = $given.substring(0,1) }
2 { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2) }
3 { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2)
$givenfirst3letters = $given.substring(0,3) }
4 { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2)
$givenfirst3letters = $given.substring(0,3)
$givenfirst4letters = $given.substring(0,4) }
5 { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2)
$givenfirst3letters = $given.substring(0,3)
$givenfirst4letters = $given.substring(0,4)
$givenfirst5letters = $given.substring(0,5) }
6 { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2)
$givenfirst3letters = $given.substring(0,3)
$givenfirst4letters = $given.substring(0,4)
$givenfirst5letters = $given.substring(0,5)
$givenfirst6letters = $given.substring(0,6) }

default { $givenfirstletter = $given.substring(0,1)
$givenfirst2letters = $given.substring(0,2)
$givenfirst3letters = $given.substring(0,3)
$givenfirst4letters = $given.substring(0,4)
$givenfirst5letters = $given.substring(0,5)
$givenfirst6letters = $given.substring(0,6) }
}
# $givenfirstletter = $given.substring(0,1)
# $givenfirst2letters = $given.substring(0,2)
# $givenfirst3letters = $given.substring(0,3)
# $givenfirst4letters = $given.substring(0,4)
# $givenfirst5letters = $given.substring(0,5)
# $givenfirst6letters = $given.substring(0,6)
# $givenfirst7letters = $given.substring(0,7)

# on créé les variables de nommage ; et on les passe en minuscule. ici en utilisant que la premiere lettre du prénom.
$sAMANew = $_.sn + $givenfirstletter
$UpnNew = $_.sn + $givenfirstletter + \"@xXX.com\"
$sAMANewlower = $sAMANew.tolower()
$UpnNewlower = $UpnNew.tolower()

# on créé les variables de nommage ; et on les passe en minuscule. ici en utilisant que les deux lettres du prénom.
$sAMANew2 = $_.sn + $givenfirst2letters
$UpnNew2 = $_.sn + $givenfirst2letters + \"@xXX.com\"
$sAMANewlower2 = $sAMANew2.tolower()
$UpnNewlower2 = $UpnNew2.tolower()

# on créé les variables de nommage ; et on les passe en minuscule. ici en utilisant que les trois lettres du prénom.
$sAMANew3 = $_.sn + $givenfirst3letters
$UpnNew3 = $_.sn + $givenfirst3letters + \"@xXX.com\"
$sAMANewlower3 = $sAMANew3.tolower()
$UpnNewlower3 = $UpnNew3.tolower()

# on créé les variables de nommage ; et on les passe en minuscule. ici en utilisant que les quatre lettres du prénom.
$sAMANew4 = $_.sn + $givenfirst4letters
$UpnNew4 = $_.sn + $givenfirst4letters + \"@xXX.com\"
$sAMANewlower4 = $sAMANew4.tolower()
$UpnNewlower4 = $UpnNew4.tolower()

$sAMANew5 = $_.sn + $givenfirst5letters
$UpnNew5 = $_.sn + $givenfirst5letters + \"@xXX.com\"
$sAMANewlower5 = $sAMANew5.tolower()
$UpnNewlower5 = $UpnNew5.tolower()

$sAMANew6 = $_.sn + $givenfirst6letters
$UpnNew6 = $_.sn + $givenfirst6letters + \"@xXX.com\"
$sAMANewlower6 = $sAMANew6.tolower()
$UpnNewlower6 = $UpnNew6.tolower()


#Write-Host \"SAM\" $sam
#Write-Host \"UPN\" $Upn
#Write-Host \"GIVEN\" $given
#Write-Host \"SAMANEW\" $sAMANew
#Write-Host \"UPN NEW\"$UpnNew
#Write-Host \"SAMANEWLOWER\" $sAMANewlower
#Write-Host \"UPNNEWLOWER\" $UpnNewlower
#Write-Host \"SAMANEWLOWER2\" $sAMANewlower2
#Write-Host \"UPNNEWLOWER2\" $UpnNewlower2
#Write-Host \"SAMANEWLOWER3\" $sAMANewlower3
#Write-Host \"UPNNEWLOWER3\" $UpnNewlower3
#Write-Host \"SAMANEWLOWER4\" $sAMANewlower4
#Write-Host \"UPNNEWLOWER4\" $UpnNewlower4
#Write-Host \"SAMANEWLOWER5\" $sAMANewlower5
#Write-Host \"UPNNEWLOWER5\" $UpnNewlower5
#write-host \"GIVEN FIRST\" $givenfirstletter
#write-host \"GIVENT FIRST 2\" $givenfirst2letters
#write-host \"GIVEN FIRST 3\" $givenfirst3letters
#write-host \"GIVEN FIRST 4\" $givenfirst4letters


# On check que l'utilisateur que l'on souhaite creer n'existe pas déjà dans l'AD.
$CheckTwice = get-aduser -LDAPFilter \"(sAMAccountName=$SamANewlower)\"
$CheckSAm = $CheckTwice.samaccountname


switch ($CheckSAm)
{
$null {$option = 1}
$SAMANewlower {$option = 2}
$SAMANewlower2 {$option = 3}
$SAMANewlower3 {$option = 4}
$SAMANewlower4 {$option = 5}
default {\"Le compte $Samanewlower n'a pu etre formaté correctement.\"}
}

$option

#Si il n'existe pas on fixe la valeure de la variable $option à 1
# if ($Checksam -eq $null) {
# write-host \" check newlower\"
# $option = 1 }
#Si il existe avec la premiere lettre du prénom on fixe la valeure de la variable $option à 2
# if ($Checksam -eq $sAMANewlower) {
# write-host \" check newlower1\"
# $option = 2}
#Si il existe avec les deux lettres du prénom on fixe la valeure de la variable $option à 3
# if ($Checksam -eq $sAMANewlower2) {
# write-host \" check newlower2\"
# $option = 3}
#Si il existe avec les trois lettres du prénom on fixe la valeure de la variable $option à 4
# if ($Checksam -eq $sAMANewlower3) {
# write-host \" check newlower3\"
# $option = 4 }

# $option




switch ($option)
{
1 { set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower;}
set-ADuser $sAMANewlower -replace @{UserPrincipalName=$UpnNewlower;}}
2 { set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower2;}
set-ADuser $sAMANewlower2 -replace @{UserPrincipalName=$UpnNewlower2;}}
3 { set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower2;}
set-ADuser $sAMANewlower2 -replace @{UserPrincipalName=$UpnNewlower2;}}
4 { set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower4;}
set-ADuser $sAMANewlower4 -replace @{UserPrincipalName=$UpnNewlower4;}}
default {\"Le compte $Samanewlower n'a pu etre renommé.\"}
}



#On modifie le compte en fonction de la valeur de la variable $option
# Si $option = 1 alors on renomme le compte avec la premiere lettre du prénom uniquement
# if ($option -eq 1) {
# set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower;}
# set-ADuser $sAMANewlower -replace @{UserPrincipalName=$UpnNewlower;}
# write-host \"CheckSAM NULL\"
# }
# Si $option = 2 on renomme avec deux lettres du prénom
# elseif ($option -eq 2) {
# set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower2;}
# set-ADuser $sAMANewlower2 -replace @{UserPrincipalName=$UpnNewlower2;}
# write-host \"CheckSAM 1\"
# }
# Si $option = 3 on renomme avec trois lettres du prénom
# elseif ($option -eq 3) {
# set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower3;}
# set-ADuser $sAMANewlower3 -replace @{UserPrincipalName=$UpnNewlower3;}
# write-host \"CheckSAM 2\"
# }
# Si $option = 4 on renomme avec trois lettres du prénom
# elseif ($option -eq 4) {
# set-ADuser $Sam -replace @{sAMAccountname=$sAMANewlower4;}
# set-ADuser $sAMANewlower4 -replace @{UserPrincipalName=$UpnNewlower4;}
# write-host \"CheckSAM 3\"
# }



}
[/code:1]



A noté que je n'attends pas qu'on fasse le script à ma place mais qu'on me propose des orientations logiques pour que je puisse me débrouiller seul !


je vous remercie par avance de m'avoir lu déjà ;o)

Bonne journée à toutes et tous !!<br><br>Message édité par: Alexis, à: 19/10/15 15:18

Je pensai à faire un DO while.
Ce qui me permet d'incrémenter tant qu'un compte existe deja avec la premiere lettre du prénom .. etc ...


[code:1]
Do {
$Ldapsam = $_.sn + $givenfinal.substring(0,$GivenSubString)
$checktwice = get-aduser -LDAPFilter \&quot;(sAMAccountName=$ldapsam)\&quot;
$GivenSubString++ }
While ($checktwice -ne $null)

[/code:1]

Mais l'incrémentation du Substring ne fonctionne pas !<br><br>Message édité par: Alexis, à: 19/10/15 16:02

petit bout pour la gestion du nom composé, maintenatn me erste à resoudre le meme probleme dans els deux cas en fait, soit incrémenter la variable du Substring en fonction de la reponse de l'AD pour incrementer pour eviter les doublons dans l'AD.


[code:1]
If($GivenFinal -Match \&quot;-\&quot;«») {
$GivenMatch = 1
$givenFinal = $GivenFinal.Split(\&quot;-\&quot;«»)
$givenfinal = $givenfinal[0].substring(0,1) + $givenfinal[1].substring(0,1)

}
Else { $GivenMatch = 0 }

[/code:1]

salut alexis

regarde ce post qui reprend un peu ta demande

sinon j'ai regardé ton script rapidement, et le principal est bon (attention de créé upn après avoir créé ton samaccountname)

ton code, que j'ai un peu simplifier ici pour un test, fonctionne mais je n'ai pas faire de test tres compliqué !
j'ai juste créé les utilisateurs test1 et test12 avant :

[code:1]$test = \&quot;test\&quot;
$givenfinal = \&quot;1234\&quot;
$GivenSubString = 1
$test | foreach {
Do {
$Ldapsam = $_ + $givenfinal.substring(0,$GivenSubString++)
$Ldapsam
$checktwice = get-aduser -Filter {SamAccountName -eq $Ldapsam}
}
While ($checktwice -ne $null)
}

write-host \&quot;login = $Ldapsam\&quot;

# resultat :
#test1
#test12
#test123
#login = test123
[/code:1]

Salut merci pour ton coup d'oeil , le lien que tu m'as donné m'a enormement aidé.

Enfait je pense que je m’étais mal expliqué sur mes prérequis de base. Je viens de réussir le script. Je le finalise et le POST. et je réexpliquerai ce dont j'avais besoin. Je POST tout ça dans la journée ;o)

un grand merci à tous !!

Voila un script qui fonctionne à merveille.

Donc pour reprendre, j'importe dans une OU des comptes depuis un autre AD. Tout ces comptes utilisent un MATRRICULE pour ouvrir les sessions.

Je dois donc renommer tous les SAMACCOUNTNAME pour qu'ils soient formatés NOMDEFAMILLE+ PREMIERE LETTRE DU PRENOM.

Avec homonymie et gestion des prénoms composés.

Je viens de realisé plein de tests et cela fonctionne parfaitement.

J'imagine que niveau Algo je dois pas être le meilleur mais comme je n'ai que 450 comptes à traiter ! C'est le resultat qui m'importe. je reste à disposition si vous souhaitez avoir des precisions. Mais le script finalement reste assez simple.



[code:1]

# Debut de script permettant le renaommage automatique du SAMACCOUNTNAME (nom d'ouverture de session) des agents qui viennent d'etre importés dans notre AD.
# Le script est basé sur le champ NOM et PRENOM. il recompose le login avec ces deux valeurs en collant le NOMDEFAMILLE avec la premiere lettre du prénom. Si le login existe deja,il incremente.

#On récupere tous les objets USERS de l'OU citée avec les propriétés CN, GIVENNAME, et SN et apres le pipe on FOREACH
Get-ADUser -filter * -searchbase \&quot;OU=USER_GPO_TEST,OU=xXxxX,OU=BAC à SABLE,dc=XxxXx,dc=COM\&quot; -Properties cn, givenName, sn, samaccountname |

ForEach {


#Pour chaque élément trouvé on définit les variables suivantes :
$Sam = $_.sAMaccountname
$Upn = $_.UserPrincipalName
$given = $_.givenName
$LastName = $_.surname
$Givenmatch = 0
$GivenLenght = $given.lenght


#On supprime les accents et autres caracteres spéciaux. On se servira des variables normalisées pour creer les logonname.
$SamOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Sam))
$UpnOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Upn))
$GivenOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($Given))
$LastNameOK = [Text.Encoding]::ASCII.GetString([Text.Encoding]::GetEncoding(1251).GetBytes($LastName))
$SamFinal = $SamOK.tolower()
$UpnFinal = $UpnOK.tolower()
$GivenFinal = $GivenOK.tolower()
$lastFinal = $LastnameOk.tolower()
$LastNameCount = $LastNameOk.length
$IncSub = $LastNameCount + 1




# Gestion des prénoms composés. SI il y a un tiret dans le prenom, On split, on prend la premiere lettre du premier prenom et on la colle au deuxieme prenom complet. on fera du SubString Sur ce format . EX: Jean-Michel ---&gt; Jean Michel

---

&gt; JMichel
#On formate le SAMACCOUNTNAME A tester dans l'AD
# Si il y a un tiret on comence à incrementé les lettres du prenoms à partir de la premiere lettre du deuxieme prenom.

If($GivenFinal -Match \&quot;-\&quot;«») {
$IncSub = $LastNameCount + 2
$givenFinal = $GivenFinal.Split(\&quot;-\&quot;«»)
$givenfinal = $givenfinal[0].substring(0,1) + $givenfinal[1]
$Looped = $lastfinal + $givenfinal
$LoopedSub = $looped.Substring(0,$Incsub)

}
Else {
$Looped = $lastfinal + $givenfinal
$LoopedSub = $looped.Substring(0,$Incsub)

}

#On check l'AD pour voir sile compte existe au format preparé au dessus. NOM + premiere lettre du prénom. Si le compte existe alors on incremente le SUBSTRING et on met à jour la valeur de la variable $LoopedSub en ajoutant une lettre au prenom. ET on repasse pour voir si ce nouveau nom de comtpe existe. SInon on réincremente. etc
while (get-aduser -LDAPFilter \&quot;(sAMAccountName=$LoopedSub)\&quot;«»)
{ $LoopedSub = $looped.Substring(0,$Incsub)
$incsub = $incsub + 1
write-host \&quot;OK\&quot; $loopedsub
}

#Si le compte n'existe pas alors la condition est rempli on passe à letape suivante. On définit le LOGIN du COMPTE dans l'AD.

$NewUPN = $LoopedSub + \&quot;@MonDomaine.com\&quot;
$NewUPN = $NewUPN.ToLower()
Write-host \&quot;FINAL\&quot; $LoopedSub \&quot;OK\&quot;


#On renomme le compte existant avec son SAM actuel avant modification ,par le Nouvel SAMAccountname qui est formaté NOMDEFAMILLE + lettre de prenom necessaire pour l'homonymie.
set-ADuser $Sam -replace @{sAMAccountname=$LoopedSub;}
# Ensuite on renomme le champ USERPRINCIPALNAME du nouvel SAMaccountname ( qui vient detre renommé ) avec le format SAMACCOUNTNAME + Nom Du Domaine.
set-ADuser $LoopedSub -replace @{UserPrincipalName=$NewUPN;}


}[/code:1]

Message édité par: Alexis, à: 20/10/15 12:04<br><br>Message édité par: Alexis, à: 29/10/15 20:18