Jump to content

status_Q

Members
  • Gesamte Inhalte

    11
  • Registriert seit

  • Letzter Besuch

Beiträge erstellt von status_Q

  1. vor 19 Minuten schrieb Sunny61:

    BTW: Es heißt Weisung und Vorgesetzten.

     

    Vielen Dank. Ohne Kaffee ist es wohl noch etwas zu früh für mich.

     

    vor 12 Minuten schrieb Sunny61:

    Was möchtest Du erreichen? Sollen die Laufwerke verbunden werden oder nicht? Falls letzteres, sollen sie für bestimmte Benutzer/Gruppen NICHT verbunden werden?

    das Script soll unabhängig vom lokalen User und deren Berechtigungen bei Start/Neustart/Wechsel/Abmelden und Anmelden von UserB zu UserA zu UserB eine Verbindung zu den Laufwerken herstellen.

    Derzeit funktioniert die Verbindung zu den Netzlaufwerken bei Start/Neustart inkl. Autologin an UserB dank eurer Hilfe sehr gut.

     

    Die IT-Abteilung der Firma, hat einen User in den Credentials zur Verfügung  gestellt. Die Rechner auf denen das Script ausgeführt wird, sind keine Domänenrechner

     

    Falls noch Erklärungsbedarf besteht, gerne melden. 

      

  2. über die Korrektheit dieser Möglichkeit lässt sich streiten. Es ist die Philosophie des Unternehmens/Weißung des Vorgesetzen.

    Jetzt hab ich allerdings einen ähnlich gelagerten Fall wie oben beschrieben. Allerdings beim Benutzer abmelden/Wechsel. Beim Hochfahren bzw. Neustart wird User A angemeldet. Die Netzlaufwerke werden verbunden. User A wird abgemeldet/Wechsel und lokal Admin angemeldet. Das Script startet aber die Laufwerke können nicht verbunden werden.  Habt Ihr eine Idee?

    Vielen Dank

  3. vielen Dank für die Hinweiße. Nach kurzer Überprüfung, dürfte es der Schnellstart gewesen sein. Vielen Dank dafür!

    vor einer Stunde schrieb testperson:

    P.S.: Credentials in einem Script? :shock2:

    keine Sorge. Ich kompiliere mein Script in eine .exe. Da sieht der User nichts von den credentials 

     

    Nochmals recht herzlichen Dank. Ihr habt mir meinen Tag versüßt :D

     

    Happy Coding!!

  4. Hallo Community,

     

    ich habe etwas Schwierigkeiten mit meinem Script und der Fehlerursache. Eventuell bin ich etwas festgefahren und Ihr könnt mir neue Einblicke zur Problemlösung bieten.

    Mein Script stellt die Verbindung zu Firmennetzlaufwerke an einigen PC´s her. Da diese Laufwerke nicht Persistent sind, müssen nach jedem Neustart oder nach dem Herunterfahren die Netzlaufwerke neu verbunden werden. Sporadisch, speziell nachdem ein Computer heruntergefahren wurde und neu eingeschaltet wird, kann er vorkommen, das mein Script keine Verbindung zum Netzlaufwerk herstellen kann. 

     

    Anbei ein Codeschnipsel:

    #region Laufwerk K testen und verbinden
    $path = "K:\"
    write-host "testing Drive connection..."$path -ForegroundColor Yellow
    $xPath = Test-Path -Path $path
    $count = 0
    #Schleife die bis zu 15x versucht eine Verbindung zum Neztlaufwerk herzustellen
    if (Test-Path -Path $path) {
        Write-Host "$path Connected!" -ForegroundColor Green
    }
    else {
        while (-not($xPath) -and $count -le 15) {
    
            if (-not(Test-Path -Path $path)) {
                Write-Host "start connecting to Network Drive"$path -ForegroundColor Blue
                $connectDrive = Start-Job -ScriptBlock {
                    $driveName = "K"
                    $provider = "FileSystem" 
                    $driveRoot = "\\xxxx.xxx.xxx\xx"
                    $password = ConvertTo-SecureString "xxxx" -AsPlainText -Force
                    $credentials = New-Object System.Management.Automation.PSCredential("xxxxxx", $password)
            
                    New-PSDrive  -Name $driveName -PSProvider $provider -Root $driveRoot -Credential $credentials -Scope Global
                    $drive = New-Object -ComObject wscript.network
                    $drive.MapNetworkDrive("k:", "\\xxxx.xxx.xxx\xx")
                }
                Wait-Job -Job $connectDrive -Timeout 10
            }
            $xPath = Test-Path -Path $path
            $count++
        }
    }
    #Fehlermeldung wird erzeugt, falls keine Verbindung hergestellt werden kann
    if (-not(Test-Path -Path $path)) {
        Write-Host "can not connect to network drive"$path", please check connection!" -ForegroundColor Red
        $msgError = New-Object -ComObject "WScript.Shell"
        $intButton = $msgError.Popup("Can not connect to Network Drive K:\", 0, "ERROR", 4096)
        if ($intButton -eq 1) {} 
    
    } 
    #endregion

    Falls Ihr Fragen oder mehr Infos benötigt, lasst es mich wissen.

    Vielen Dank

  5. @daabm Der Dienst ist mir auch schon vor die Füße gestolpert, während ich nach Input für mein Script gesucht habe. Leider fällt dieser aus Lizenztechnisches Gründen und Vorgaben aus der Obrigkeit der IT-Administratoren raus (Stichwort:"Nicht freigegebene Dienste von dritten"). Trotzdem, herzlichsten Dank für diesen Einwand.

    Das ich mit meinem Script einen Vollsprint in die Materie hinlege und "von 0 auf 100" starte habe ich bereits bemerkt. Aber da muss ich jetzt durch :D 

    @BOfH_666 Durch die Abänderung von dir, kann ich mir jetzt Unterschiedliche DeviceID´s der Geräte anzeigen lassen. Im nächsten Schritt würde ich jetzt die gewünschte PNPDeviceID in eine Variable schreiben. In etwa so:

     if ($RAW.PNPDeviceID -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0") {
            $DUMMYDeviceID = $RAW.PNPDeviceID 
                Write-Output "USB erkannt"
     }
    else {
        Write-Output "USB nicht erkannt"
    }

    wenn ich davon ausgehe, dass die -Property DeviceID von CIM = Laufwerksbuchstabe des USB-Sticks ist und ich das ganze Testweiße ausgebe:

     if ($RAW.PNPDeviceID -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0") {
            $DUMMYDeviceID = $RAW.PNPDeviceID 
            write-Output $RAW.DeviceID
                Write-Output "USB erkannt"         
     }
    else {
        Write-Output "USB nicht erkannt"
    }
    
    -------------------------------
      Ausgabe in Konsole:
       
       DeviceID Description        VolumeName PNPDeviceID
    -------- -----------        ---------- -----------
    E:       Wechseldatenträger Transcend  USBSTOR\DISK&VEN_JETFLASH&PROD_TRANSCEND_64GB&REV_1100\CCF2QI87N652XP2V&0
    Q:       Wechseldatenträger VERBATIM   USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0
    \\.\PHYSICALDRIVE1
    USB erkannt
    

    folglich habe ich echt Schwierigkeiten, mir den Laufwerksbuchstaben ausgeben zu lassen.

  6. Hallo Zusammen,

     

    Herzlichsten Dank für das rasche Feedback. Visual Studio Code mit PowerShell wurde installiert und einsatzbereit. 

     

    @BOfH_666 gerne können wir mein Script in seine Einzelteile zerlegen. Viele Wege führen schließlich zum Ziel. Das Problem mit CIM hatte ich bereits in der Anfangsphase, dass mir dort die DeviceID des Geräts nicht eindeutig ausgegeben wird. Siehe hierzu meinen Screenshot.

    DeviceID_CIM.JPG

    DeviceID_WIM.JPG

  7. Hallo MurdocX,

     

    Herzlichen Dank für die Begrüßung und deiner Verbesserungsvorschläge. 

     

    die echo-Ausgaben sind wohl noch Altlasten aus meinen Anfangszeiten der php Programmierungen.

    • echo ersetzt durch "write-output"
    • @ und () wurden bei den Ausgaben ebenfalls entfernt
    • where wurde durch where-object ersetzt
    • Region wurden eingepflegt
    • Variablen wurden jetzt vor DO-Loop deklariert
    • Kommentare am Zeilenanfang
    • Code habe ich neu strukturiert -->ein Befehlt pro Zeile
    • Break wurde entfernt
    Zitat

    Warum verwendest du eigentlich Start-Sleep?

    wenn ich das Script in der ISE ohne start-Sleep ausführe, "Springt" das script förmlich ohne jegliche Ausgabe an read-host -prompt "Exit". Durch Eingabe von Bspw. Enter werden dann alle Meldungen ausgegeben.

     

    Zitat

    Schau Dir bitte mal IseSteroids an. Das gibts auch in einer Testversion, die sollte für Dein Script reichen. Dann siehst du die Probleme schneller.

    wird ich mal testen. Danke 

     

    Zitat
    
    }
    Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25)) 

     

    Zitat

    Diese Objekte werden erst innerhalb der DoLoop-Schleife definiert und es ist zum Schleifenende nicht klar, ob diese überhaupt existieren. Abschlussbedingen werden vorher definiert und nur gefüllt. Das Objekt sollte dann schon Instanziert (erstellt) worden sein. Die letzten Klammern und das "break" haben da nichts verloren, denn die Schleife wird mit Until beendet und irgendwie wieder geöffnet als neue Schleife.

    aber genau das möchte ich. Erst wenn  Driveletter und DeviceID matchen soll die Schleife beendet werden. Falls dies nicht geschieht (PC vergibt nach Portwechsel neuen Laufwerksbuchstaben, USB-Stick fehlt, USB-Port falsch verdrahtet ect.), wird die Schleife weitere 25 mal ausgeführt und anschließend beendet.  

     

     

    Überarbeiteter Code:

    
    #region  -----------------Start des Scripts------------------------------------
    write-output "Starte Auslesen der angeschlossenen USB Drives"
    #start-sleep -s 3
    #endregion
    
    
    #region -------Wird einmalig benötigt um die DeviceID des USB Sticks manuell auszulesen und in Variablen zu schreiben-------
    
        
    #------Anzeige aller Laufwerk vom Typ "Entfernbar"---------#
    <#Get-Volume|
        where-object {$_.Drivetype -eq"Removable"}
    
    -----------Filterung von USB Geräte-------------
    Get-Disk|
    	where-object{$_.BusType -eq"USB"}|
    		Select-Object SerialNumber, FriendlyName
    
    #------------Filterung von USB-Geräten anhand von Beschreibung und DeviceID----------#
    Get-WmiObject Win32_USBControllerDevice | 
        ForEach-Object { [wmi]$_.dependent } |
            where-object -FilterScript {($_.deviceid)}|
                select-Object description,deviceid
    
    #-----------Hier wird der Laufwerkszuordnung ermittelt, es werden alle Pfade von USB Sticks angezeiget. Richtiger Pfad wird manuell in Variable $DUMMYDISKPATH eingetragen-----------#
    Get-Volume |
        where-object {$_.Drivetype -eq"Removable"}|
            ForEach-Object {$VolObj = $_
                $ParObj = Get-Partition | 
                    Where-Object {$_.AccessPaths -contains $VolObj.Path }
                        if ($ParObj.DiskId) {$ParObj |
                            Select-Object -Property Diskpath
                        if ($ParObj.DriveLetter) {$ParObj |
                        Select-Object -Property Driveletter
    }}}                                                                                                             
    
                       
    <# Get-WmiObject Win32_USBControllerDevice | 
        ForEach-Object {[wmi]$_.dependent } |
            Where-Object -FilterScript{($_.deviceid -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0")}| 
                select-Object description,deviceid   
    #>
    
    #>
    #endregion
    
    
    
    #region------------------------------------------------Schleife für Auslesen der USB-Daten-------------------------------------------------------------
    #Variable wird Initialisiert
    $loopUSBcheck=1
    #Hier wird die DeviceID des USB Sticks geschrieben
    $DUMMYusbID = "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0"
    #Hier wird der Pfad des USB Sticks aus Diskpath geschrieben 
    $DUMMYDISKPATH = "\\?\usbstor#disk&ven_verbatim&prod_store_n_go&rev_pmap#0700039a2b79de49&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" 
    $DUMMYletter = $ParObj.DriveLetter
     Do{
    $TestingDriveUSB = New-Object -TypeName PSObject
    
    #Hier wird nach der Art des Sticks mit der DeviceID gesucht
        $TestingdriveName = Get-WmiObject Win32_USBControllerDevice | 
            ForEach-Object { [wmi]$_.dependent } |
                Where-Object -FilterScript {($_.deviceid -eq $DUMMYusbID)}|
                    select-Object description
                                               
    #Hier wird die DeviceID anhand von Statischer Variable gesucht
        $TestingdriveID = Get-WmiObject Win32_USBControllerDevice |
            ForEach-Object {[wmi]$_.dependent } |
                Where-Object -FilterScript {($_.deviceid -eq $DUMMYusbID)}|
                    select-Object deviceid
    
    #Hier wird der Laufwerksbuchstabe ermittelt
        $TestingdriveLetter = Get-Volume |
            Where-Object {$_.Drivetype -eq"Removable"}|
                ForEach-Object {$VolObj = $_
                    $ParObj = Get-Partition |
                        Where-Object {$_.AccessPaths -contains $VolObj.Path}
                            if ($ParObj.DiskId -eq $DUMMYDISKPATH) {$ParObj |
                                Select-Object -Property Diskpath
                            if ($ParObj.DriveLetter -eq $DUMMYletter) {$ParObj |
                                Select-Object -Property Driveletter
    }}}
    
    #--------------------------------------------------Ausgabe der ermittelten USB-Daten in einer Tabelle------------------------------------------------------------
    $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name DeviceID -Value $TestingdriveID                                                                          
    $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Art -Value $TestingdriveName
    $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Driveletter -Value $DUMMYletter
    
       # start-sleep -s 3
    Write-Output $TestingDriveUSB
            
    $loopUSBcheck
        $loopUSBcheck++
    }
    Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25))  
    #endregion
    
    #region-------------Laufwerk mounten + Laufwerkswechsel-----------------------
    
    write-output "Greife auf Laufwerk zu....."
       # start-sleep -s 3
    if ($Pfad=$TestingDriveUSB.Driveletter +":\"){
        Set-Location $Pfad
            Write-Output "Teste Laufwerkswechsel..."
                #start-sleep -s 3
                 if (Test-Path $Pfad){ 
                        write-output "$Pfad Laufwerkswechsel gültig"}}
    else {Write-Output "Mounten fehlgeschlagen, da $Pfad und $TestingDriveUSB.Driveletter unterschiedlich"}
         
    #endregion
    
    #region---------Suche Dateien-------------------------------------------------------------------------------
    
    Write-Output "Suche Dateien....."
        #start-sleep -s 3
    
    #----------------------Wird benötigt um Dateien in Konsole anzuzeigen---------------------------------
    <#Get-ChildItem $Pfad -Recurse | 
    	where {$_.Extension -eq".txt"} | 
     		% {Write-Output $_.FullName}
     #>
    
    if (Get-ChildItem $Pfad -Recurse | 
        where {$_.Extension -eq".txt"} |
            % {Write-Output $_.FullName} )
                {write-output "Suche erfolgreich"}
    else {write-output "Suche fehlgeschlagen"}
      
    #endregion
    
    #region----------------------------------Lese Datei--------------------------------------------------------
    
    write-output "Starte Auslesen...."
     #start-sleep -s 3
        Get-Content -Path $Pfad\HalloWelt.txt
            if (Get-Content -Path $Pfad\HalloWelt.txt){
                    Write-Output "Auslesen erfolgreich"}
            else{Write-Output "Fehlgeschlagen!"}
    #endregion
    
    #region----------------------------Wechsle Laufwerkverzeichnis--------------------------------------------
    Set-Location C:\
    #endregion---------------------------------------------------------------------------------------------------
    
    
    read-host -Prompt "exit"

     

  8. Hallo Community,

     

    ich bin blutiger Anfänger im Scripting. Ich weiße lediglich etwas fortgeschritteneres Wissen in der SPS Programmierung (Siemens Step 7, TIA) auf.

     

    Hintergrund:

    ein Speichermedium "USB" wird auf einer Testapplikation fest verbaut. Mittels einer Testsoftware werden USB-Ports durchgeschaltet. Das Script soll immer dann ausgeführt werden, wenn ein Portwechsel stattgefunden hat. Dieser Testaufbau wird flexibel an einigen Geräten eingesetzt. Da sich der Laufwerksbuchstabe jedes mal ändert soll ein universell einsetzbares Script erstellt werden um Kommunikation und Datentransfer testen zu können. 

     

    Ziel meines Scriptes ist es, anhand der DeviceID eines USB-Sticks, den Laufwerksbuchstaben zu ermitteln. Wurde dieser gefunden, soll eine .txt-Datei gelesen werden.

     

    Durch intensive Recherche und "Try-and-Error" konnte ich einen kleinen Erfolg verbuchen. Mein Script wird erfolgreich in der PowerShell ISE ausgeführt.

     

    #-----------------Start des Scripts------------------------------------#
    write-output @("Starte Auslesen der angeschlossenen USB Drives")
    
    
        start-sleep -s 3
    #-----------------------------------------------------------------------#
    
                      #-------Wird einmalig benötigt um die DeviceID des USB Sticks manuell auszulesen und in Variablen zu schreiben-------#
    #-------------------------------------------------------------------------------------------------------------------------------#
        
                                #------Anzeige aller Laufwerk vom Typ "Entfernbar"---------#
     <#                                   Get-Volume|where {$_.Drivetype -eq"Removable"}
     
                                        #-----------Filterung von USB Geräte-------------#
                                        Get-Disk|where {$_.BusType -eq"USB"}|Select-Object SerialNumber, FriendlyName
    
                                                #------------Filterung von USB-Geräten anhand von Beschreibung und DeviceID----------#
    
                                        Get-WmiObject Win32_USBControllerDevice | ForEach-Object { [wmi]$_.dependent } |where-object -FilterScript {($_.deviceid)}| select-Object description,deviceid
    
                                #-----------Hier wird der Laufwerkszuordnung ermittelt, es werden alle Pfade von USB Sticks angezeiget. Richtiger Pfad wird manuell in Variable $DUMMYDISKPATH eingetragen-----------#
    
                                        Get-Volume |where {$_.Drivetype -eq"Removable"}|ForEach-Object {
                                            $VolObj = $_
                                                $ParObj = Get-Partition | Where-Object { 
                                                                        $_.AccessPaths -contains $VolObj.Path }
    
                                            if ($ParObj.DiskId) {
                                                    $ParObj |Select-Object -Property Diskpath
                                                    
                                            if ($ParObj.DriveLetter) {
                                                    $ParObj |Select-Object -Property Driveletter
                                                    
                                        }}}                                                                                                             
    
                       
                <# Get-WmiObject Win32_USBControllerDevice | ForEach-Object { 
                                [wmi]$_.dependent } |Where-Object -FilterScript {
                                ($_.deviceid -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0")
                                } | select-Object description,deviceid   
                #>
    
    #>
    
    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
    
    
    #------------------------------------------------Schleife für Auslesen der USB-Daten-----------------------------------------------------------------#
        $loopUSBcheck=1
     Do{
    
             $TestingDriveUSB = New-Object -TypeName PSObject
                 $DUMMYusbID = "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0" #Hier wird die DeviceID des USB Sticks geschrieben
                 $DUMMYDISKPATH = "\\?\usbstor#disk&ven_verbatim&prod_store_n_go&rev_pmap#0700039a2b79de49&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" #Hier wird der Pfad des USB Sticks aus Diskpath geschrieben
                 $DUMMYletter = $ParObj.DriveLetter
      
                         $TestingdriveName = Get-WmiObject Win32_USBControllerDevice | ForEach-Object { #Hier wird nach der Art des Sticks mit der DeviceID gesucht
                                    [wmi]$_.dependent } |Where-Object -FilterScript {
                                        ($_.deviceid -eq $DUMMYusbID)
                                               }| select-Object description
                                               
    
                         $TestingdriveID = Get-WmiObject Win32_USBControllerDevice | ForEach-Object {  #Hier wird die DeviceID anhand von Statischer Variable gesucht
                                    [wmi]$_.dependent } |Where-Object -FilterScript {
                                        ($_.deviceid -eq $DUMMYusbID)
                                                } | select-Object deviceid
    
      
                           $TestingdriveLetter = Get-Volume |where {$_.Drivetype -eq"Removable"}|ForEach-Object { #Hier wird der Laufwerksbuchstabe ermittelt
                                    $VolObj = $_
                                    $ParObj = Get-Partition | Where-Object { 
                                         $_.AccessPaths -contains $VolObj.Path }
    
                                    if ($ParObj.DiskId -eq $DUMMYDISKPATH) {
                                       $ParObj |Select-Object -Property Diskpath
                                                    
                                    if ($ParObj.DriveLetter -eq $DUMMYletter) {
                                       $ParObj |Select-Object -Property Driveletter
                                                    
                                        }}}
    
    #--------------------------------------------------Ausgabe der ermittelten USB-Daten in einer Tabelle-------------------------------------------------------------------------#
    
              $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name DeviceID -Value $TestingdriveID                                                                          
              $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Art -Value $TestingdriveName
              $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Driveletter -Value $DUMMYletter
    
        start-sleep -s 3
    
            echo $TestingDriveUSB
            
    $loopUSBcheck
        $loopUSBcheck++
    }
    Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25)){break}  
    #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
    
    #-------------Laufwerk mounten + Laufwerkswechsel-----------------------#
    
    write-output @("Greife auf Laufwerk zu.....")
        start-sleep -s 3
    if ($Pfad=$TestingDriveUSB.Driveletter +":\"){
        Set-Location $Pfad
            Write-Output "Teste Laufwerkswechsel..."
                start-sleep -s 3
                 Test-Path $Pfad 
                    write-output "$Pfad Laufwerkswechsel gültig!"}
    else {Write-Output "Mounten fehlgeschlagen, da $Pfad und $TestingDriveUSB.Driveletter unterschiedlich"}
         
    #----------------------------------------------------------------------#
    
    #---------Suche Dateien-------------------------------------------------------------------------------#
    
    Echo "Suche Dateien....."
        start-sleep -s 3
    
    #----------------------Wird benötigt um Dateien in Konsole anzuzeigen---------------------------------#
    
            <#Get-ChildItem $Pfad -Recurse | where {$_.Extension -eq".txt"} | % {
                Write-Output $_.FullName}
            #>
    #-----------------------------------------------------------------------------------------------------#
    
              if (Get-ChildItem $Pfad -Recurse | where {$_.Extension -eq".txt"} | % {
                     Write-Output $_.FullName} ){ 
                        write-output "Suche erfolgreich"}
             else { 
                    write-output "Suche fehlgeschlagen"}{break}
      
    #----------------------------------------------------------------------------------------------------#
    
    #----------------------------------Lese Datei--------------------------------------------------------#
    
    Echo "Starte Auslesen...."
     start-sleep -s 3
        Get-Content -Path $Pfad\HalloWelt.txt
            if (Get-Content -Path $Pfad\HalloWelt.txt){
                    Write-Output "Auslesen erfolgreich"}
            else{
                    Write-Output "Fehlgeschlagen!"}{break}
    #---------------------------------------------------------------------------------------------------#
    
    #----------------------------Wechsle Laufwerkverzeichnis--------------------------------------------#
    Set-Location C:\
    #---------------------------------------------------------------------------------------------------#
    
    
    read-host -Prompt "exit"

     

    Führe ich das Script allerdings direkt in der PowerShell Konsole oder via Verknüpfung aus, wird mir der Laufwerksbuchstabe des Sticks nicht mehr angezeigt. Dadurch kann ich nicht mehr das Verzeichnis wechseln und auch nicht die Datei lesen.

     

    Ich hoffe auf höfliche und Konstruktive Kritik sowie Hilfestellung zu meiner Thematik.

    Sollten noch mehr Infos benötigt werden, lasst es mich gerne Wissen.

     

    Vielen Herzlichen Dank

     

    Beste Grüße

     

    Status_Q

     

     

    Ausschnitt_Powershellise_Script.JPG

    Powershellkonsolescript.JPG

×
×
  • Neu erstellen...