Infoblox IP Reservierung via WebAPI in Powershell auslesen

Mit folgendem Powershell Skript, kann man über Servername, Domäne und VLAN ID eine Adressreservierung auf der Infoblox auslesen.

Die Abwicklung erfolgt über die WebAPI der Infoblox. Die Zugangsdaten stehen der Einfachheit halber im Skript, können aber natürlich auch via Übergabe oder Eingabe abgefragt werden.

Die VLAN ID wird via Extensible Attributes abgefragt, welche natürlich gepflegt sein sollten.
Als Rückgabe erscheint ein Objekt, mit IP-Adresse, Netzwerk, Maske, Gateway, VLAN ID und Typ der gefundenen Reservierung / IP Info

 

-> .get-infoblox-data.ps1 -ServerName "xyz" -DNSDomain "domain.local" -vlanID "10"

 

[CMDletBinding()]
param (
[Parameter(Mandatory = $true, Position = 0)]
[string]$ServerName,
[Parameter(Mandatory = $true, Position = 1)]
[string]$DNSDomain,
[Parameter(Mandatory = $true, Position = 2)]
[string]$vlanid
)

$global:ibAPIversion = "v2.7"
$global:ibFQDN = "infoblox_url"
$global:uriStart = "https://$global:ibFQDN/wapi/$global:ibAPIversion"
$pwd = ''
$username = ""
$secPW = $pwd | ConvertTo-SecureString  -asPlainText -Force
$global:cred = New-Object System.Management.Automation.PSCredential -ArgumentList $username, $secPW
$global:ityp=""

function get-fixed-addr ($vlanid, $ServerName, $DNSDomain) {
write-host "$ServerName.$DNSDomain"
try{
$fixedaddrs = Invoke-RestMethod -uri "$uriStart/fixedaddress?*SA_VLAN=$vlanid&_return_fields=options,name,comment,ipv4addr,extattrs&_max_results=1500"  -Credential $cred
$t = $fixedaddrs | ?{($_.name -like "*$ServerName.$DNSDomain*")}
$global:ityp="Reservation"
return $t.ipv4addr
}catch{
catchIBReturnError
return
}
}
function convert-prefix($prefix){
switch ($prefix) {
0{ "0.0.0.0" }
1{ "128.0.0.0" }
2{ "192.0.0.0" }
3{ "224.0.0.0" }
4{ "240.0.0.0" }
5{ "248.0.0.0" }
6{ "252.0.0.0" }
7{ "254.0.0.0" }
8{ "255.0.0.0" }
9{ "255.128.0.0" }
10{ "255.192.0.0" }
11{ "255.224.0.0" }
12{ "255.240.0.0" }
13{ "255.248.0.0" }
14{ "255.252.0.0" }
15{ "255.254.0.0" }
16{ "255.255.0.0" }
17{ "255.255.128.0" }
18{ "255.255.192.0" }
19{ "255.255.224.0" }
20{ "255.255.240.0" }
21{ "255.255.248.0" }
22{ "255.255.252.0" }
23{ "255.255.254.0" }
24{ "255.255.255.0" }
25{ "255.255.255.128" }
26{ "255.255.255.192" }
27{ "255.255.255.224" }
28{ "255.255.255.240" }
29{ "255.255.255.248" }
30{ "255.255.255.252" }
31{ "255.255.255.254" }
32{ "255.255.255.255" }
}
}
function catchIBReturnError{
$response = $_.Exception.Response
if ($response.StatusCode -eq [System.Net.HttpStatusCode]::BadRequest) {
$stream = $response.GetResponseStream()
$reader = New-Object System.IO.StreamReader($stream)
$reader.BaseStream.Position = 0
$reader.DiscardBufferedData()
$responseBody = $reader.ReadToEnd();
Write-Verbose $responseBody
$wapiErr = ConvertFrom-Json $responseBody
throw [Exception] "$($wapiErr.Error)"
$wapiErr
} else {
throw
}
}
function get-ip-from-arecord($ServerName,$DNSDomain){
#gibt es schon einen a-record?
try{
$infobloxHost = Invoke-RestMethod -uri "$global:uriStart/record:host?name~=$ServerName.$DNSDomain" -Credential $global:cred
$global:ityp="Host-Record"
#wechel ip?
$ip = $infobloxHost[0].ipv4addrs.ipv4addr
}catch{
catchIBReturnError
return
}
#gibt es schon einen host-record, wenn keinen a-record?
try{
if(!($infobloxHost)){
$infobloxHost = Invoke-RestMethod -uri "$global:uriStart/record:a?name~=$ServerName.$DNSDomain" -Credential $global:cred
$global:ityp="A-Record"
$ip = $infobloxHost[0].ipv4addr
}
}catch{
catchIBReturnError
return
}
return $ip
}
function get-network-from-ip($ip){
#erweiterte infos zur ip
try{
$infobloxIPv4Address = Invoke-RestMethod -uri "$global:uriStart/ipv4address?ip_address=$ip" -Credential $global:cred
#netzwerk
$ipNetwork = $infobloxIPv4Address[0].network
}catch{
catchIBReturnError
return
}
return $ipNetwork
}
function get-gateway-from-network ($ipNetwork) {
#gateway
try{
$infobloxGateway = Invoke-RestMethod -uri "$global:uriStart/network?ipv4addr=$ipNetwork&_return_fields=options,extattrs" -Credential $global:cred
$routers = $infobloxGateway[0].options | ?{$_.name -eq "routers"}
$routers = $routers.value
$vlan = $infobloxGateway[0].extattrs.SA_VLAN.value
}catch{
catchIBReturnError
return
}
return $routers, $vlan
}

#ip bekommen, sollte Reservierung, Host, a-record vorhanden sein
$returnIP = get-fixed-addr $vlanid $ServerName $DNSDomain
if(!($returnIP)){
write-host 'Reservierung nicht gefunden, suche nach Host- oder A-Record'
$returnIP = get-ip-from-arecord $ServerName $DNSDomain
}

#wenn ip vorhanden, netzwerk holen
if($returnIP){
$returnNW = get-network-from-ip $returnIP
$returnNoIP = "FALSE"
}else{$returnNoIP = "TRUE";$global:ityp=""}

#wenn netzwerk geholt, gateway finden
if($returnNW){
$returnGW = get-gateway-from-network $returnNW
$returnVLAN = $returnGW[1]
$returnGW = $returnGW[0]
$returnNWtmp = ($returnNW.split("/"))
$returnNW = ($returnNW.split("/"))["0"]
$returnSNM = convert-prefix $returnNWtmp["1"]
}

#werte zurückgeben
$ipObject = "" | Select IP,NW,SNM,GW,VLAN,Typ,NOIP
$ipObject.IP = $returnIP
$ipObject.NW = $returnNW
$ipObject.SNM = $returnSNM
$ipObject.GW = $returnGW
$ipObject.VLAN = $returnVLAN
$ipObject.Typ = $global:ityp
$ipObject.NOIP = $returnNoIP
write-host $ipObject
return $ipObject

Infoblox IP Reservierung via WebAPI in Powershell

Mit folgendem Powershell Skript, kann man über Servername, Domäne und VLAN ID eine Adressreservierung auf der Infoblox vornehmen.

Die Abwicklung erfolgt über die WebAPI der Infoblox. Die Zugangsdaten stehen der Einfachheit halber im Skript, können aber natürlich auch via Übergabe oder Eingabe abgefragt werden.

Die VLAN ID wird via Extensible Attributes abgefragt, welche natürlich gepflegt sein sollten.

 

-> .set-infoblox-data.ps1 -ServerName "xyz" -DNSDomain "domain.local" -vlanID "10"

 

[CMDletBinding()]
param (
    [Parameter(Mandatory = $true, Position = 0)]
    [string]$ServerName,
    [Parameter(Mandatory = $true, Position = 1)]
    [string]$DNSDomain,
    [Parameter(Mandatory = $true, Position = 2)]
    [string]$vlandID
)

$ibAPIversion = "v2.7"
$ibFQDN = "infoblox_url"
$uriStart = "https://$ibFQDN/wapi/$ibAPIversion"
$pwd = ''
$username = ""
$secPW = $pwd | ConvertTo-SecureString  -asPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential -ArgumentList $username, $secPW

function catchIBReturnError{
    $response = $_.Exception.Response
    if ($response.StatusCode -eq [System.Net.HttpStatusCode]::BadRequest) {
        $stream = $response.GetResponseStream()
        $reader = New-Object System.IO.StreamReader($stream)
        $reader.BaseStream.Position = 0
        $reader.DiscardBufferedData()
        $responseBody = $reader.ReadToEnd();
        Write-Verbose $responseBody
        $wapiErr = ConvertFrom-Json $responseBody
        throw [Exception] "$($wapiErr.Error)"
    } else {
        throw
    }
}

try{
    $network = Invoke-RestMethod -uri "$uriStart/network?*SA_VLAN=$vlandID&_return_fields=options,extattrs" -Credential $cred
  }catch{
      catchIBReturnError
  }
if(!($network)){
    throw "Kein passendes Netzwerk mit der VLAN ID $vlandID gefunden. Extattrs gepflegt?"
}
#json string für reservierung
###############################
$Body = @{  name="$ServerName.$DNSDomain";
            ipv4addrs= @(
                @{
                    ipv4addr="func:nextavailableip:$($network._ref)"
                }
            )
            view = "WIE AUCH IMMER EURE ANSICHT HEIßT";
        }

$JSON = $Body | ConvertTo-json
####################################

#rückgabe abfangen wenn error
try{
    $reservierung = Invoke-RestMethod -uri "$uriStart/record:host?_return_fields=ipv4addrs" -Method Post -Credential $cred -Body $JSON -ContentType "application/json" -Verbose
}catch{
    catchIBReturnError
}
return "Reservierung wurde erfolgreich angelegt"

Outlook Kalender in PST exportieren via Powershell

kurz notiert:

Ein Export des Outlook Kalenders kann via Powershell Skript wie folgt realisiert werden

$Outlook = New-Object -ComObject Outlook.Application
$NS = $Outlook.GetNamespace('MAPI')
$Store = $NS.Stores | ? {$_.displayname -eq "abc@xyz.de"}
$Calendar = $Store.GetDefaultFolder([Microsoft.Office.Interop.Outlook.OlDefaultFolders]::olFolderCalendar)
#PST Store
$Outlook.Session.AddStore("c:tmptemp.pst")
$PST = $ns.Stores | ? {$_.filepath -eq "c:tmptemp.pst"}
$PSTRoot= $PST.GetRootFolder()
$PSTFolder= $NS.Folders.Item($PSTRoot.Name)
#Export
$Calendar.CopyTo($PST)
#Trennen des Archivs
$NS.GetType().InvokeMember('RemoveStore',[System.Reflection.BindingFlags]::InvokeMethod,$null,$NS,($PSTFolder))

Das Archiv könnte man anschließend auch in ein bestehendes Exchange (Online) Postfach importieren.

#mit exchange (online) verbinden
$Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.office365.com/powershell-liveid/ -Credential (Get-Credential) -Authentication Basic -AllowRedirection
New-MailboxImportRequest -Mailbox <Name> -FilePath <UNC-Pfad und Name der PST-Datei> -TargetRootFolder <Ordner im Postfach>
#Zwischenstand abfragen
Get-MailboxImportRequest <Name des Importvorgangs> | fl
#Import löschen
Remove-MailboxImportRequest

Lokale Administratoren aller Domänen Computer auflisten – Powershell

Möchte man eine Übersicht aller lokalen Administratoren-Konten / -Gruppen der Computer innerhalb einer Domäne erhalten, kann man das via Powershell Skript automatisiert laufen lassen. Das Ergebnis ist entweder in der Konsole sichtbar oder kann via Out-file in eine Datei geschrieben werden. Für das Skript wird das Active Directory Modul benötigt.

[fusion_builder_container hundred_percent=”yes” overflow=”visible”][fusion_builder_row][fusion_builder_column type=”1_1″ background_position=”left top” background_color=”” border_size=”” border_color=”” border_style=”solid” spacing=”yes” background_image=”” background_repeat=”no-repeat” padding=”” margin_top=”0px” margin_bottom=”0px” class=”” id=”” animation_type=”” animation_speed=”0.3″ animation_direction=”left” hide_on_mobile=”no” center_content=”no” min_height=”none”]

function get-adminmember-ofall{
$searchOU='ou=06computergruppen,dc=example,dc=local'
$anz_comp = Get-ADComputer -filter * -SearchBase $searchOU
$anz_comp = $anz_comp.count
$i=1
Get-ADComputer -filter * -SearchBase $searchOU|
     Foreach-Object{
			write-host "$i von $anz_comp"
			$server=$_.Name
			if(Test-Connection $_.Name -q){
				$i++
                Write-Host "Ueberpruefe $server" -fore green
                ([ADSI]"WinNT://$server/Administratoren").psbase.invoke('Members') |
                ForEach-Object{
                     $member=$_.GetType().InvokeMember('Name', 'GetProperty', $null, $_, $null)
                     New-Object PSObject -Property @{Server=$server;Account=$member}
                }
			}else{
				$i++
                Write-Host "$server - keine Verbindung" -fore red
           }
     }
}

lokale admins[/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]

Verwaiste SIDs von Verzeichnissen und Dateien entfernen – Powershell

Wenn man Berechtigungen auf Ordner setzt und die Gruppe bzw. der Benutzer im Active Directory gelöscht wurde, bleiben die SIDs auf den Verzeichnissen und Dateien bestehen. Sie können dann allerdings nicht mehr aufgelöst werden. Somit steht dort anstelle des Usernamens nur die alte SID.
Diese kann man via Skript automatisiert finden und entfernen lassen.
Über
Import-Module .Dateiname_des_Skripts.ps1
kann das Skript geladen werden und anschließen unter Angabe des Pfades ausgeführt werden.
Remove-orphanedSID -path "C:..."
Über ein Aktivieren des Attributs “-whatif” kann erst einmal ein Testlauf erfolgen, der die SIDs noch nicht entfernt.

Function Remove-orphanedSID
{
[CmdletBinding()]
	Param
	(
		#Define parameters
		[Parameter(Mandatory=$true,Position=1)]
		[String]$path
	)
write-host "Sammle alle Ordner/Dateien"
$Apath = gci $path -recurse
write-host "Pruefe, das kann einige zeit in Anspruch nehmen"
foreach ($file in $Apath)
{
	$PSPath = $file.fullname
	try
		{
			$acl = Get-Acl -Path $PSPath
			foreach($acc in $acl.access )
			{
				$value = $acc.IdentityReference.Value
				if($value -match "S-1-5-*")
				{
					$acl.RemoveAccessRule($acc) | out-null
					Write-Host "Entferne SID: $value  von  $PSPath "
					Set-Acl -Path $PSPath -AclObject $acl #-whatif
				}
			}
		}
		catch
		{
			write-host $error
		}
}
}

Active Directory Object Restore via Powershell

Neben der Wiederherstellung von versehentlich gelöschten Objekten im AD durch ldp.exe, kann sie auch via Powershell erfolgen.

Notwendig ist dafür das ActiveDirectory Modul, welches in den RSAT Paketen enthalten ist und über die Windows Funktionen aktiviert werden kann.

Durch

Get-ADObject -SearchBase "CN=Deleted Objects,DC=example,DC=local" -filter * -IncludeDeletedObjects -Properties lastKnownParent

lassen sich alle gelöschten Objekte anzeigen. Das Property lastKnownParent gibt dabei zusätzlich die letzte bekannte OU aus, in der sich die jeweiligen Objekte befanden. Diese muss vor der Wiederherstellung des Objektes vorhanden sein und ggf. ebenfalls wiederhergestellt werden.

Über die Anpassung des Filters kann man sich nur das gewünschte Objekt anzeigen lassen:

Get-ADObject -Filter 'sAMAccountName -eq "username"' -SearchBase "CN=Deleted Objects,DC=eutech,DC=local"  -IncludeDeletedObjects -Properties *

Dadurch wird nach einem einzelnen Benutzer gesucht und alle Eigenschaften angezeigt.

Mit dem Pipen in das “Restore-ADObject” CMDlet kann das Objekt wiederhergestellt werden:

Get-ADObject -Filter 'sAMAccountName -eq "username"' -SearchBase "CN=Deleted Objects,DC=example,DC=local"  -IncludeDeletedObjects -Properties * | Restore-AdObject

Sollte eine OU wiederhergestellt werden, so muss man bedenken, dass der Wiederherstellungsbefehl nur die OU, nicht aber die darin enthaltenen Objekte wiederherstellt. Dies muss manuell oder z.B. durch eine foreach-Schleife erfolgen:

Get-ADObject -Filter * -IncludeDeletedObjects -Properties lastknownparent | ?{$_.lastknownparent -eq "OU=XY
ADEL:a7417fbf-3627-48f6-b48d-224cd642fcb1,CN=Deleted Objects,DC=example,DC=local"} | restore-adobject

-> Raussuchen aller gelöschten Objekte, filtern nach lastknownparent, wiederherstellen

Über den zusätzlichen Parameter “whatif” kann man den Wiederherstellungsprozess erst einmal testen.

ad-restore-ps

Subversion Needs Lock Property global setzen

Wenn man SVN zur Revisionsverwaltung von Quellcode nutzt, kann man über das Property “Needs Lock” festlegen, dass keine Änderung an Dateien vorgenommen werden kann, solange man diese Dateien nicht für sich gesperrt hat.
Sollte im Nachhinein auffallen, dass das Property nicht durchgängig gesetzt ist, kann das über folgende Skripte automatisiert werden.
Zunächst muss eine Liste aller Repositories erstellt werden, in deinen das Property fehlt.
Dazu kann folgendes Bash Skript auf dem Subversion Server genutzt werden.

#!/bin/bash
#Dateien in jedem Repository finden, die die Eigenschaft "Needs-Lock" nicht gesetzt haben
#
#findReposWithoutLogInHEAD.sh ausführen.
#Repositories ohne Needs-Lock Property werden ausgegeben.
#Ausgaben in Datei umleiten: ./findReposWithoutLogInHEAD.sh >> needLockFehlt.log
#Log auf PC kopieren und PS Script starten: checkoutWholeRepo.ps1

IFS=$'n'
cd /srv/svn-parent/
pwd

#Verzeichnis auflisten
array=(*/)

#Repos durchgehen
for dir in "${array[@]%/*}";
do #echo "$dir";
	files=`svn list -r HEAD -R http://subversion-server/svn/$dir --username *** --password "***" | grep -e ".*.vi$" -e ".*.ctl$" -e ".*.lvlib$" -e ".*.lvclass$" -e ".*.rtm$" -e ".*.lvproj$"`
	for fn in $files;
	do
		#wenn svn propget nicht gleich yes, dann ist prop nicht gesetzt
		if [[ $(svn propget svn:needs-lock http://subversion-server/svn/$dir/$fn --revprop -r HEAD) != "*"  ]]; then
			#echo Hier ist Prop nicht gesetzt
			echo http://subversion-server/svn/$dir/$fn
		fi
	done
done

Die Ausgabe des Skripts sollte in eine Datei umgeleitet werden, die dem Powershell Skript mitgegeben wird. Das Skript setzt das Vorhandensein des SVN Clients Tortoise SVN voraus!

#Liest Liste von Dateien ein, denen Needs:Lock fehlt, checkt das jeweilige Repository aus und setzt die Eigenschaft auf die Dateien
#

$files = cat "PfadzumLog.log"
#Array für die Repositories, wo die Namen drin stehen
$repoArray=@()
$lwDPfad
$pfadAufD ="D:SVNREPOS"

$checkout='checkout'
$usernamePasswort='--username "***" --password "***"'

#Initiierung für den ersten String
$a = $files[0].split("/")
$compString=$a[4] + "/" + $a[5]
Write-Host "Erstes Repo: $compString"
$repoArray+=("http://subversion-server/svn/"+$compString)

for ($i=0; $i -lt $files.length; $i++){
	if($files[$i] -match $compString){
        #Repo gleich, nichts zu tun
	}else{
		Write-Host "Neues Repo gefunden: "$files[$i]
		$a = $files[$i].split("/")
		$compString=$a[4] + "/" + $a[5]
		#Write-host $compString
        $repoArray+=("http://subversion-server/svn/"+$compString)
	}
}

#Jedes Repo einzeln auschecken
foreach($s in $repoArray){
Write-Warning "Checke $s aus"
#hier auschecken
svn.exe checkout $s $pfadAufD

    foreach($file in $files){
        if($file -match $s){
        #das sind die Dateien, die angepasst werden müssen
        #Pfad lokal anpassen
            #write-host $file
            $z = $file.split("/")
            $compString=$z[0] + "/" + $z[1] + "/" +$z[2] + "/" +$z[3] + "/" +$z[4] + "/" +$z[5]
            $lwDPfad = $file -replace $compString, $pfadAufD
            $lwDPfad = $lwDPfad -replace "/",""
            #Das ist der Pfad zur Datei, die angepasst werden muss:
            if(test-path $lwDPfad){
                write-host "Datei gefunden: $lwDPfad" -ForegroundColor green
                svn lock $lwDPfad
                svn propset svn:needs-lock yes $lwDPfad

                }
            else{
                write-host "Datei nicht gefunden: $lwDPfad" -ForegroundColor red}
        }
    }
#Fertig mit Repo, also commit und dann löschen
svn commit $pfadAufD -m "Needs Lock wurde auf die Dateien gesetzt"
read-host
Write-Warning "Lösche Inhalte..."
rmdir "$pfadAufD*" -force -Recurse
}

Damit werden nun alle gefundenen Repositories ausgecheckt und das Property gesetzt. Danach wird es wieder eingecheckt.

Datenbank Backup – Powershell

PS> .backup.ps1 -serverName “localhostSQLEXPRESS” -backupTempDirectory “C:tmp” -daysToStoreBackups 1 -copyDirectory “pfadzumDatenbank_Backup”

[fusion_builder_container hundred_percent=”yes” overflow=”visible”][fusion_builder_row][fusion_builder_column type=”1_1″ background_position=”left top” background_color=”” border_size=”” border_color=”” border_style=”solid” spacing=”yes” background_image=”” background_repeat=”no-repeat” padding=”” margin_top=”0px” margin_bottom=”0px” class=”” id=”” animation_type=”” animation_speed=”0.3″ animation_direction=”left” hide_on_mobile=”no” center_content=”no” min_height=”none”]

param(
$serverName,
$backupTempDirectory,
$daysToStoreBackups,
$copyDirectory
)

&nbsp;
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoEnum") | Out-Null

$server = New-Object ("Microsoft.SqlServer.Management.Smo.Server") $serverName
$dbs = $server.Databases
foreach ($database in $dbs | where { $_.IsSystemObject -eq $False })
{
write-host "Backup Database" $database.Name -foregroundcolor green
$dbName = $database.Name

$timestamp = Get-Date -format yyyy-MM-dd-HHmmss
$targetPath = $backupTempDirectory + "" + $dbName + "_" + $timestamp + ".bak"

$smoBackup = New-Object ("Microsoft.SqlServer.Management.Smo.Backup")
$smoBackup.Action = "Database"
$smoBackup.BackupSetDescription = "Full Backup of " + $dbName
$smoBackup.BackupSetName = $dbName + " Backup"
$smoBackup.Database = $dbName
$smoBackup.MediaDescription = "Disk"
$smoBackup.Devices.AddDevice($targetPath, "File")
$smoBackup.SqlBackup($server)

"backed up $dbName ($serverName) to $targetPath"
}

Get-ChildItem "$backupTempDirectory*.bak" |? { $_.lastwritetime -le (Get-Date).AddDays(-$daysToStoreBackups)} |% {Remove-Item $_ -force }
"removed all previous backups older than $daysToStoreBackups days"

Write-Host "Move the $dbName database(s): $backupTempDirectory$dbName*.bak to $copyDirectory"
mv $backupTempDirectory$dbName*.bak $copyDirectory -force

[/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]

Dateien im Ordner zippen, löschen und archivieren – Powershell

Dateien, die älter sind als x Tage, sollen innerhalb eines Ordner gezippt, gelöscht und archiviert werden.


<#
.SYNOPSIS
.
.DESCRIPTION
Find, delete and zip files in a folder.
.PARAMETER days
Check the last write time of a file. File is older than x days
.PARAMETER path
Path of the root folder of the files to be deleted.
.PARAMETER zip
Makes an archive containing all the files that were found.
.PARAMETER delete
Deletes the files that were found.
.PARAMETER archivePath
Specifies the path of the archive file. Standard path: C:tmparchive-"DATE".zip
.EXAMPLE
C:PS> .delete_old_files.ps1 -days 5 -path C:tmp -zip yes -delete yes -archivepath C:archives
Files that are older than 5 days from now on, root folder C:tmp, files will be zipped and deleted, the archive for the zip files will be in C:archives
Note that 7zip is a must have for zipping the files!
.NOTES
Author: Jens Braun
Date: Feb 04, 2016
#>

param(
[parameter(Mandatory=$true)]
[int]$days,
[parameter(Mandatory=$true)]
[string]$path,
[parameter(Mandatory=$false)]
[string]$zip,
[parameter(Mandatory=$false)]
[string]$delete,
[parameter(Mandatory=$false)]
[string]$archivePath
)

$sz="C:Program Files (x86)7-Zip7z.exe"
$z=1
$date = get-date -uformat "%Y-%m-%d"
#Soll gezippt werden?
if($zip -eq "yes"){
if(test-path "C:Program Files (x86)7-Zip7z.exe"){
Write-Host "7zip found"
Write-Host "Files will be zipped"
if($archivePath){
if(test-path $archivePath){
$archivePath= -join ($archivePath,"archive-",$date,".","zip")
Write-Host "archive to $archive"
}else{
$archivePath = "C:tmparchive-$date.zip"
Write-Host "Archive Path not found, using Standardarchive: $archivePath"
}
}else{
$archivePath = "C:tmparchive-$date.zip"
Write-Host "Archive Path not found, using Standardarchive: $archivePath"
}
}else{
Write-Warning "7zip not found"
$zip = "no"
}
}else{
Write-Host "Files will not be zipped"
$zip = "no"
}

#Soll gelöcht werden?
if($delete -eq "yes"){
Write-Host "Files will be deleted"
}else{
Write-Host "Files will not be deleted"
$delete="no"
}

#weder noch
if(($delete -eq "no") -and ($zip -eq "no")){
Write-Warning "Neither delete nor zipping, exiting!"
break
}

#path vorhanden?
if(!(test-path $path)){
write-warning "Archive Path not found"
break
}
#Nur Dateien, keine Ordner!
$files2delete = gci -path $path -recurse -force | ? -FilterScript {(($_.LastWriteTime -lt (get-date).adddays(-$days)) -and (! $_.PSIsContainer)) }

$Files2Remove = $files2delete.Count
foreach ($file in $files2delete){
Write-Progress -Activity "Working..." -status ("Files Processed $z of "+$Files2Remove.ToString()) -percentComplete ($z / $Files2Remove*100)
if($zip -eq "yes"){
& $sz a $archivePath $file.fullname -ssc >$null 2>&1
}

if($delete -eq "yes"){
remove-item $file.fullname -force -whatif
}

$z++
}

Massenkonvertierung .doc nach .pdf – Powershell

Mit diesem Powershell Skript ist es möglich, alle Word Dokumente (.doc und .docx) automatisch in ein PDF umzuwandeln.
Dazu muss der Code als .ps1 Datei gespeichert werden.
Entweder wird danach das Skript direkt aufgerufen oder in der Powershell gestartet und der Pfad eingegeben.

powershell-console

Anschließend befinden sich neben den Word Dokumenten ebenfalls PDF Dokumente im Verzeichnis.

explorer-docs

[fusion_builder_container hundred_percent=”yes” overflow=”visible”][fusion_builder_row][fusion_builder_column type=”1_1″ background_position=”left top” background_color=”” border_size=”” border_color=”” border_style=”solid” spacing=”yes” background_image=”” background_repeat=”no-repeat” padding=”” margin_top=”0px” margin_bottom=”0px” class=”” id=”” animation_type=”” animation_speed=”0.3″ animation_direction=”left” hide_on_mobile=”no” center_content=”no” min_height=”none”]

$documents_path = Read-Host "Pfad eingeben "
$word_app = New-Object -ComObject Word.Application
# This filter will find .doc as well as .docx documents
Get-ChildItem -Path $documents_path -Filter *.doc? | ForEach-Object {
$document = $word_app.Documents.Open($_.FullName)
$pdf_filename = "$($_.DirectoryName)$($_.BaseName).pdf"
$document.SaveAs([ref] $pdf_filename, [ref] 17)
$document.Close()
}
$word_app.Quit()

Alternativ gibt es das Skripte hier als Download.[/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]