none
Daten aus einer DB in ein Array Schreiben... RRS feed

  • Frage

  • Hallo zusammen,

    da ich neu in der WPS Programmierung bin und nicht mehr weiter weiss, wende ich mich an euch!

    ich möchte Daten aus einer Datenbank auslesen (mit einer while Schleife) und die inhalte in ein Array schreiben damit diese inhalte mit einer Eingabe überprüft werden...

    für andere lösungen bin ich auch offen!

    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws"
    $reader = $command.ExecuteReader()
    
    $input = Read-Host
    
    while($reader.Read())
    {
        $row = $reader.GetString(4)  
    }
    $reader.Close()
    
    if ($input = $row)
    {
        Write-Host "Updaten"
    }
    else
    {
        Write-Host "Schreiben"
    }

    ich habe es schon mit einem Array versucht doch speichert der mir nur den letzen inhalt und ich weiss nicht wie ich in dem falle ein mehrdimensionales array machen kann :(

    hoffe es kann mir wer weiter helfen.

    Cheers

    Chris

    Montag, 9. Dezember 2013 11:24

Antworten

  • Funktionen müssen VOR Ihrer ersten Benutzung bekannt gemacht werden!

    Also Funktionen werden erst deklariert.

    Damit PowerShell weiß das es diese Funktion gibt.

    Bei der Deklaration werden Funktionen noch nicht ausgeführt!

    Ebenso hat die Funktion ja noch nicht alle benötigten Daten!

    Erst bei dem Aufruf der Funktion, bekommt die Funktion die Daten und die Funktion wird ausgeführt.

    Stell dir folgende Situation vor:

    Du benötigst zum Kiestransport einen Lastwagen.

    Jetzt baust du dir einen Lastwagen oder du mietest ihn.

    Jetzt zeigst du all deinen Freunden diesen Lastwagen und sagst ihnen das sie damit fahren und transportieren können.

    Das ist die Deklaration.

    Function Lastwagen {
      param(
        $Fahrer,
        $Ladung
      )
        "Fahrer $Fahrer Fährt, die Ladung ist: $Ladung"
    }

    Der Lastwagen steht immer noch ungenutzt auf dem Hof und wartet....

    Der Fahrersitz ist leer und die Ladefläche auch!

    Nun steigst du ein (Der Parameter -Fahrer bekommt einen Wert) und Lädst die Ladung der (Der Parameter -Ladung bekommt einen Wert)

    Lastwagen -Fahrer 'Chris' -Ladung 'Sand'
    
    # Funktionen können mehrmals aufgerufen werden ganau dafür sind Sie da!
    Lastwagen -Fahrer 'Tom' -Ladung 'Alt-Bier'
    Lastwagen -Fahrer 'Sabine' -Ladung 'Puppen'
    Du hast recht! In deinem Fall ist die Funktion fast überflüssig da Sie nur einmal gebraucht wird.

    Funktionen Helfen aber, den Code zu ordnen und woanders diesen Code-Schnipsel wieder zu verwenden.

    Das würde auch gehen:

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    # Load MySQL .NET Connector Objects
    [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
    [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
    
    function WriteMySQLQuery {
    	
    	param (
     		$conn,
    		[string]$query
    	)
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    # Datenbank öffnen
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # SERVERNAME, USERNAME, PASSWORD und DATABASENAME eintragen !
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    $connStr = "server=SERVERNAME;port=3306;uid=USERNAME;pwd=PASSWORD;database=DATABASENAME;Pooling=FALSE" #Pooling speichert die SQL Verbindung
    $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
    $conn.Open()
    
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    # abfragen ob es den Rechner in der Datenbank schon gibt
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws  where ws_station = '$varWS'"
    $reader = $command.ExecuteReader()
    
    # Wenn der Reader (eine) Zeile gefunden hat,
    # hat er den Rechner in der Tabelle Gefunden
    If ($reader.HasRows) {
    
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    
    	# Der Rechner ist in der Tabelle
    	# Wir machen ein Update des Eintrags-Datums
    	$query = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
    	
    	#$conn = ConnectMySQL $user $pass $MySQLHost $database
    	WriteMySQLQuery $conn $query 
    
    	#Installierte Software auslesen
    	$Items = gwmi -computer $varWS win32_Product
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "UPDATE 
    					tbl_soft 
    				  SET 
    					soft_name = '$varName', 
    					soft_vendor = '$varVendor', 
    					soft_version = '$varVersion', 
    					soft_id_num = '$varIdentifyingNumber', 
    					soft_installdate = '$varInstallDate', 
    					soft_ws = '$varWS' 
    				  WHERE 
    					soft_ws = '$varWS'"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    	
    } Else {
    	# Der Reader hat keine Zeilen gefunden; Der Rechner ist nicht in der Tabelle!
    	# Wie fügen den Rechner hinzu!
    	
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    	
    	#Betriebssystem
    	$wars = gwmi -computer $varWS Win32_OperatingSystem 
    	#Bios(Seriennummer)
    	$bios = gwmi -computer $varWS Win32_BIOS
    	#Benutzer auslesen
    	$users = gwmi -computer $varWS Win32_ComputerSystem
    
    	foreach ($war in $wars)
    	{
    		$varOS = $wars.caption
    	}
    
    	foreach ( $user in $users)
    	{
    		$varUser = $user.Username
    	}
    
    	foreach ($bio in $bios)
    	{
    		$varSerial = $bio.SerialNumber
    	}
    
    	$query2 = "INSERT INTO 
    					tbl_ws 
    					(ws_user, 
    					ws_os, 
    					ws_serial, 
    					ws_station, 
    					ws_date) 
    				VALUES 
    					('$varUser', 
    					'$varOS', 
    					'$varSerial', 
    					'$varWS', 
    					NOW())"
    
    	$Rows = WriteMySQLQuery $conn $query 
    
    	$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "	INSERT INTO 
    						tbl_soft 
    						(soft_name, 
    						soft_vendor, 
    						soft_version, 
    						soft_id_num, 
    						soft_installdate, 
    						soft_ws)
    					VALUES 
    						('$varName', 
    						'$varVendor', 
    						'$varVersion', 
    						'$varIdentifyingNumber', 
    						'$varInstallDate', 
    						'$varWS')"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    }
    
    # Die Datenbank Connection wird nicht mehr gebraucht wir schliessen sie brav
    $conn.Close()


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+


    Mittwoch, 11. Dezember 2013 10:32
  • Nun, die Fehler Meldungen in der PowerShell sind eigentlich IMMER sehr hilfreich.

    Hier heißt es, dass ein DataReader noch offen ist und dieser geschlossen werden MUSS, bevor man eine neue Abfrage stellt.

    Das eine Abfrage weitere Abfragen blockiert, ist bei Datenbanken eigentlich nicht üblich.

    Nun denn....

    Hier musst du $reader.Close() aufrufen bevor du eine neue Abfrage stellen kannst.

    Ebenso schließe ich zum Schluss die Datenbank Connection mit $conn.Close()

    in Datenbanken sollte mann immer alles Brav wieder zumachen was man vorher geöffnet hat.

    Oder man zerstört mit Dispose() die Objekte (entfernt sie aus dem Speicher), wobei die Methode Close() die saubere Lösung ist!

    Ich habe dies an den richtigen stellen eingebaut.

    Du findest die Dokumentation der MySQL Klassen hier :

    http://dev.mysql.com/doc/refman/5.6/en/connector-net-ref-mysqlclient.html

    Dort siehst du welche Möglichkeiten z.B. ein MySQL DataReader hat.

    Bitte beachte das ich kein MySQL hier habe und ich dir im Blindflug helfen muss!

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    # Load MySQL .NET Connector Objects
    [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
    [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
    
    function ConnectMySQL {
    
    	param (
    		[string]$user,
    		[string]$pass,
    		[string]$MySQLHost,
    		[string]$database
    	)
     
      # Open Connection
      $connStr = "server=" + $MySQLHost + ";port=3306;uid=" + $user + ";pwd=" + $pass + ";database="+$database+";Pooling=FALSE" #Pooling speichert die SQL Verbindung
      $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
      $conn.Open()
      $cmd = New-Object MySql.Data.MySqlClient.MySqlCommand("USE $database", $conn)
      return $conn
    }
    
    function WriteMySQLQuery {
    	
    	param (
     		$conn,
    		[string]$query
    	)
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    # Datenbank öffnen
    $conn = ConnectMySQL 'User' 'PAsswort' 'MySQLHost' 'Database'
    
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    # abfragen ob es den Rechner in der Datenbank schon gibt
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws  where ws_station = '$varWS'"
    $reader = $command.ExecuteReader()
    
    # Wenn der Reader (eine) Zeile gefunden hat,
    # hat er den Rechner in der Tabelle Gefunden
    If ($reader.HasRows) {
    
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    
    	# Der Rechner ist in der Tabelle
    	# Wir machen ein Update des Eintrags-Datums
    	$query = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
    	
    	#$conn = ConnectMySQL $user $pass $MySQLHost $database
    	WriteMySQLQuery $conn $query 
    
    	#Installierte Software auslesen
    	$Items = gwmi -computer $varWS win32_Product
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "UPDATE 
    					tbl_soft 
    				  SET 
    					soft_name = '$varName', 
    					soft_vendor = '$varVendor', 
    					soft_version = '$varVersion', 
    					soft_id_num = '$varIdentifyingNumber', 
    					soft_installdate = '$varInstallDate', 
    					soft_ws = '$varWS' 
    				  WHERE 
    					soft_ws = '$varWS'"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    	
    } Else {
    	# Der Reader hat keine Zeilen gefunden; Der Rechner ist nicht in der Tabelle!
    	# Wie fügen den Rechner hinzu!
    	
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    	
    	#Betriebssystem
    	$wars = gwmi -computer $varWS Win32_OperatingSystem 
    	#Bios(Seriennummer)
    	$bios = gwmi -computer $varWS Win32_BIOS
    	#Benutzer auslesen
    	$users = gwmi -computer $varWS Win32_ComputerSystem
    
    	foreach ($war in $wars)
    	{
    		$varOS = $wars.caption
    	}
    
    	foreach ( $user in $users)
    	{
    		$varUser = $user.Username
    	}
    
    	foreach ($bio in $bios)
    	{
    		$varSerial = $bio.SerialNumber
    	}
    
    	$query2 = "INSERT INTO 
    					tbl_ws 
    					(ws_user, 
    					ws_os, 
    					ws_serial, 
    					ws_station, 
    					ws_date) 
    				VALUES 
    					('$varUser', 
    					'$varOS', 
    					'$varSerial', 
    					'$varWS', 
    					NOW())"
    
    	$Rows = WriteMySQLQuery $conn $query 
    
    	$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "	INSERT INTO 
    						tbl_soft 
    						(soft_name, 
    						soft_vendor, 
    						soft_version, 
    						soft_id_num, 
    						soft_installdate, 
    						soft_ws)
    					VALUES 
    						('$varName', 
    						'$varVendor', 
    						'$varVersion', 
    						'$varIdentifyingNumber', 
    						'$varInstallDate', 
    						'$varWS')"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    }
    
    # Die Datenbank Connection wird nicht mehr gebraucht wir schliessen sie brav
    $conn.Close()


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+


    Mittwoch, 11. Dezember 2013 08:59

Alle Antworten

  • Ich glaube du meinst nicht ein Array!

    Ein Array enthällt immer einem Menge (eine Liste von) mehreren Werten.

    Die Eingabe des Users ist aber eine einzelnen Eingabe.

    Eine einzelnen Wert mit einer Liste von Werten zu vergleichen, geht zwar, muss man aber in deinem Fall in  einer Schleife machen.


    Ich glaube du meinst das so:

    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws"
    $reader = $command.ExecuteReader()
    
    $input = Read-Host
    
    while($reader.Read())
    {
        If ($reader.GetString(4) -eq $input) {
    		Write-Host "Updaten"
    	}  Else {
    		Write-Host "Schreiben"
    	}
    }
    $reader.Close()


    Ebenso sind die Vergleichsoperatoren in PowerShell anders als du es hier machst IF = gibt es nicht in Powershell !

    Hier heisst es IF -eq (für equal).

    Sieh hier: http://www.colorconsole.de/PS_Windows/de/about_Comparison_Operators.htm

    Die fehlen die Grundlagen.

    Schau mal in meine Signatur hier.

    Dort Empfehle ich meine PowerShell Videos bei Youtube und gute PowerShell Bücher oder Kostenlose PowerShell Tutorials


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+

    Montag, 9. Dezember 2013 13:07
  • Moin Peter,

    vielen dank für die Schnelle antwort!

    ich habe anscheinend einen wichtigen aspekt vergessen :(

    es soll als Update Funktion dienen... im ganzen soll das Programm Arbeitsstationen auslesen, wenn die Arbeitsstationschon da ist soll das Update gemacht werden wenn nicht dann soll die Hinzugefügt werden...

    wenn es nützlich ist schreib ich auch mal den ganzen quelltext hierrein?!

    und ja ich weiss das mir vieles fehlt ich nähre mein wissen auch nur duch Google, youtube und büchern und deine links schau ich mir später mal in ruhe an!

    Montag, 9. Dezember 2013 13:57
  • wenn es nützlich ist schreib ich auch mal den ganzen quelltext hierrein?!


    Ich verstehe leider immer noch nicht wie du das meinst.

    Mehr Code könnte da helfen.

    >>>>Das Programm soll Arbeitsstationen auslesen

    Woher aus der Datenbank?

    >>> wenn die Arbeitsstationschon da ist ....

    Ja wo ist sie denn schon da ?

    Wo kommen die Daten her, die du vergleichen möchtest ?


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+

    Montag, 9. Dezember 2013 15:09
  • Also...

    das programm soll später automatisch laufen.

    Es soll von jedem Computer bestimmte Informationen auslesen und in eine Datenbank speichern. Unteraderem die Seriennummer, Benutzer, Arbeitsstation Betriebssystem und die Installierte Software.

    Wenn die Arbeitstation schon in der Datenbank gespeichert ist, soll nur ein Update gemacht werden und wenn nicht sollen die daten in die Datenbank geschrieben werden.

    Hier der Code (ich weiss, an meinem Programmierstiel muss ich noch was arbeiten nur ist das alles aus verschiedenen sachen zusammen gewürfelt. Learning by doing :) )

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    $ErrorActionPreference = "SilentlyContinue" # Fehler Unterdrückung
    
    function ConnectMySQL([string]$user,[string]$pass,[string]$MySQLHost,[string]$database) {
     
      # Load MySQL .NET Connector Objects
      [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
      [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
     
      # Open Connection
      $connStr = "server=" + $MySQLHost + ";port=3306;uid=" + $user + ";pwd=" + $pass + ";database="+$database+";Pooling=FALSE" #Pooling speichert die SQL Verbindung
      $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
      $conn.Open()
      $cmd = New-Object MySql.Data.MySqlClient.MySqlCommand("USE $database", $conn)
      return $conn
    }
    
    function WriteMySQLQuery($conn, [string]$query) {
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    function WriteMySQLQuery2($conn, [string]$query2) {
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query2
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    $user       = ''
    $pass       = ''
    $database   = ''
    $MySQLHost  = ''
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws"
    $reader = $command.ExecuteReader()
    
    while($reader.Read())
    {
        if ($reader.GetString(4) -eq $input)
        {
            $query2 = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
          
    		$conn = ConnectMySQL $user $pass $MySQLHost $database
    		$Rows2 = WriteMySQLQuery2 $conn $query2 
    
    		$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    		foreach ($item in $items)
    		{
    			$varName		= $item.Name
    			$varVendor		= $item.Vendor
    			$varVersion 		= $item.Version
    			$varIdentifyingNumber	= $item.IdentifyingNumber
    			$varInstallDate	     	= $item.InstallDate
    
    			$query = "UPDATE 
    						tbl_soft 
    					  SET 
    						soft_name = '$varName', 
    						soft_vendor = '$varVendor', 
    						soft_version = '$varVersion', 
    						soft_id_num = '$varIdentifyingNumber', 
    						soft_installdate = '$varInstallDate', 
    						soft_ws = '$varWS' 
    					  WHERE 
    						soft_ws = '$varWS'"
    
    			$conn = ConnectMySQL $user $pass $MySQLHost $database
    
    			$Rows = WriteMySQLQuery $conn $query 
    		}
        }
        else 
        {
    		$wars = gwmi -computer $varWS Win32_OperatingSystem #Betriebssystem
    		$bios = gwmi -computer $varWS Win32_BIOS #Bios(Seriennummer)
    		$users = gwmi -computer $varWS Win32_ComputerSystem #Benutzer auslesen
    
    		foreach ($war in $wars)
    		{
    			$varOS = $wars.caption
    		}
    
    		foreach ( $user in $users)
    		{
    			$varUser = $user.Username
    		}
    
    		foreach ($bio in $bios)
    		{
    			$varSerial = $bio.SerialNumber
    		}
    
    		$query2 = "INSERT INTO 
    						tbl_ws 
    						(ws_user, 
    						ws_os, 
    						ws_serial, 
    						ws_station, 
    						ws_date) 
    					VALUES 
    						('$varUser', 
    						'$varOS', 
    						'$varSerial', 
    						'$varWS', 
    						NOW())"
    
    		$conn = ConnectMySQL $user $pass $MySQLHost $database
    		$Rows2 = WriteMySQLQuery2 $conn $query2 
    
    		$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    		foreach ($item in $items)
    		{
    			$varName		= $item.Name
    			$varVendor		= $item.Vendor
    			$varVersion 		= $item.Version
    			$varIdentifyingNumber	= $item.IdentifyingNumber
    			$varInstallDate	     	= $item.InstallDate
    
    			$query = "	INSERT INTO 
    							tbl_soft 
    							(soft_name, 
    							soft_vendor, 
    							soft_version, 
    							soft_id_num, 
    							soft_installdate, 
    							soft_ws)
    						VALUES 
    							('$varName', 
    							'$varVendor', 
    							'$varVersion', 
    							'$varIdentifyingNumber', 
    							'$varInstallDate', 
    							'$varWS')"
    
    			$conn = ConnectMySQL $user $pass $MySQLHost $database
    
    			$Rows = WriteMySQLQuery $conn $query 
    		}
    	}   
    }    
    $reader.Close()
    
    und die Datenbank besteht aus zwei teilen einen für die Software und einen für die Hardware
    Dienstag, 10. Dezember 2013 06:23
  • Achte auf meine Kommentare ;-)

    So müsst es tun! Ungetestet!

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    #!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # FEHLER DIE MAN NICHT SIEHT SIND TROZDEM DA !
    # UND WIE FINDET MAN DIE DANN ?
    # $ErrorActionPreference = "SilentlyContinue" # Fehler Unterdrückung
    #!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    
    # Wenn eine DLL einmal in einem Prozess geladen ist, kann sie nicht mehr entladen werden.
    # Deshalb reicht es eine DLL nur einmal zu Laden (nicht bei jedem Funktionsaufruf)
    # Load MySQL .NET Connector Objects
    [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
    [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
    
    
    # PowerShell benutzt den param() Block in Funktionen und Scripts, um Parameter zu definieren.
    # Weil man in der PowerShell sehr viele Parameter Attribute definieren kann!
    # Das wird schnell unübersichtlich!
    # Die Funktion() Klammer schreibweise, kann man nicht so übersichtlich gestalten!
    # Gewöhn dich besser an die param() schreibweise, wie hier gezeigt!
    
    function ConnectMySQL {
    
    	param (
    		[string]$user,
    		[string]$pass,
    		[string]$MySQLHost,
    		[string]$database
    	)
     
      # Open Connection
      $connStr = "server=" + $MySQLHost + ";port=3306;uid=" + $user + ";pwd=" + $pass + ";database="+$database+";Pooling=FALSE" #Pooling speichert die SQL Verbindung
      $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
      $conn.Open()
      $cmd = New-Object MySql.Data.MySqlClient.MySqlCommand("USE $database", $conn)
      return $conn
    }
    
    function WriteMySQLQuery {
    	
    	param (
     		$conn,
    		[string]$query
    	)
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    
    
    # Eine Funktion ist dafür gedacht sie mehrmals zu verwenden!
    # 100% Identische Funktionen machen keinen Sinn!
    
    #function WriteMySQLQuery2 {
    #  
    #	param(
    #  		$conn,
    #		[string]$query2
    #	) 
    #  
    #  $command = $conn.CreateCommand()
    #  $command.CommandText = $query2
    #  $RowsInserted = $command.ExecuteNonQuery()
    #  $command.Dispose()
    #  
    #  if ($RowsInserted) {
    #    return $RowInserted
    #  } else {
    #    return $false
    #  }
    #}
    
    
    
    # Die connection zur Datenbank muss nur ein eintiges mal geöffnet werden
    # deshalb braucht man keine Variablen hier!
    # Variablen machen nur sinn wenn man einen Wert mehrmals braucht oder als Behälter für Ergebnisse.
    #$user       = ''
    #$pass       = ''
    #$database   = ''
    #$MySQLHost  = ''
    
    # Datenbank öffnen
    $conn = ConnectMySQL 'User' 'PAsswort' 'MySQLHost' 'Database'
    
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    
    # Datenbanken sid dafür da damit man Sie genau danach Fragt was man wissen will!
    # immer ALLE Daten zu holen verursacht zuviel Kosten (Netzwerk traffik und Datenbank CPU Zeit)!
    
    
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws  where ws_station = '$varWS'"
    $reader = $command.ExecuteReader()
    
    # Wenn der Reader (eine) Zeile gefunden hat,
    # hat er den Rechner in der Tabelle Gefunden
    If ($reader.HasRows) {
    
    	# Der Rechner ist in der Tabelle
    	# Wir machen ein Update des Eintrags-Datums
    	$query = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
    	
    	#$conn = ConnectMySQL $user $pass $MySQLHost $database
    	WriteMySQLQuery $conn $query 
    
    	#Installierte Software auslesen
    	$Items = gwmi -computer $varWS win32_Product
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "UPDATE 
    					tbl_soft 
    				  SET 
    					soft_name = '$varName', 
    					soft_vendor = '$varVendor', 
    					soft_version = '$varVersion', 
    					soft_id_num = '$varIdentifyingNumber', 
    					soft_installdate = '$varInstallDate', 
    					soft_ws = '$varWS' 
    				  WHERE 
    					soft_ws = '$varWS'"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    	
    } Else {
    	# Der Reader hat keine Zeilen gefunden; Der Rechner ist nicht in der Tabelle!
    	# Wie fügen den Rechner hinzu!
    	
    	#Betriebssystem
    	$wars = gwmi -computer $varWS Win32_OperatingSystem 
    	#Bios(Seriennummer)
    	$bios = gwmi -computer $varWS Win32_BIOS
    	#Benutzer auslesen
    	$users = gwmi -computer $varWS Win32_ComputerSystem
    
    	foreach ($war in $wars)
    	{
    		$varOS = $wars.caption
    	}
    
    	foreach ( $user in $users)
    	{
    		$varUser = $user.Username
    	}
    
    	foreach ($bio in $bios)
    	{
    		$varSerial = $bio.SerialNumber
    	}
    
    	$query2 = "INSERT INTO 
    					tbl_ws 
    					(ws_user, 
    					ws_os, 
    					ws_serial, 
    					ws_station, 
    					ws_date) 
    				VALUES 
    					('$varUser', 
    					'$varOS', 
    					'$varSerial', 
    					'$varWS', 
    					NOW())"
    
    	$Rows = WriteMySQLQuery $conn $query 
    
    	$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "	INSERT INTO 
    						tbl_soft 
    						(soft_name, 
    						soft_vendor, 
    						soft_version, 
    						soft_id_num, 
    						soft_installdate, 
    						soft_ws)
    					VALUES 
    						('$varName', 
    						'$varVendor', 
    						'$varVersion', 
    						'$varIdentifyingNumber', 
    						'$varInstallDate', 
    						'$varWS')"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    }


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+

    Dienstag, 10. Dezember 2013 14:48
  • Guten Morgen Peter,

    vielen Dank für die Überarbeitung!

    Ich habe das gerade getestet und bekomme diese Fehlermeldung (auch wenn es was unbeholfen klingt aber ich finde den fehler ncicht :( )

    Ausnahme beim Aufrufen von "ExecuteNonQuery" mit 0 Argument(en):  "There is 
    already an open DataReader associated with this Connection which must be 
    closed first."
    In C:\invent.ps1:48 Zeichen:3
    +   $RowsInserted = $command.ExecuteNonQuery()
    +   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
        + FullyQualifiedErrorId : MySqlException

    ich habe am ende des Skripts ein $reader.close() eingebaut aber nüschts :(

    Mittwoch, 11. Dezember 2013 06:48
  • Nun, die Fehler Meldungen in der PowerShell sind eigentlich IMMER sehr hilfreich.

    Hier heißt es, dass ein DataReader noch offen ist und dieser geschlossen werden MUSS, bevor man eine neue Abfrage stellt.

    Das eine Abfrage weitere Abfragen blockiert, ist bei Datenbanken eigentlich nicht üblich.

    Nun denn....

    Hier musst du $reader.Close() aufrufen bevor du eine neue Abfrage stellen kannst.

    Ebenso schließe ich zum Schluss die Datenbank Connection mit $conn.Close()

    in Datenbanken sollte mann immer alles Brav wieder zumachen was man vorher geöffnet hat.

    Oder man zerstört mit Dispose() die Objekte (entfernt sie aus dem Speicher), wobei die Methode Close() die saubere Lösung ist!

    Ich habe dies an den richtigen stellen eingebaut.

    Du findest die Dokumentation der MySQL Klassen hier :

    http://dev.mysql.com/doc/refman/5.6/en/connector-net-ref-mysqlclient.html

    Dort siehst du welche Möglichkeiten z.B. ein MySQL DataReader hat.

    Bitte beachte das ich kein MySQL hier habe und ich dir im Blindflug helfen muss!

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    # Load MySQL .NET Connector Objects
    [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
    [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
    
    function ConnectMySQL {
    
    	param (
    		[string]$user,
    		[string]$pass,
    		[string]$MySQLHost,
    		[string]$database
    	)
     
      # Open Connection
      $connStr = "server=" + $MySQLHost + ";port=3306;uid=" + $user + ";pwd=" + $pass + ";database="+$database+";Pooling=FALSE" #Pooling speichert die SQL Verbindung
      $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
      $conn.Open()
      $cmd = New-Object MySql.Data.MySqlClient.MySqlCommand("USE $database", $conn)
      return $conn
    }
    
    function WriteMySQLQuery {
    	
    	param (
     		$conn,
    		[string]$query
    	)
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    # Datenbank öffnen
    $conn = ConnectMySQL 'User' 'PAsswort' 'MySQLHost' 'Database'
    
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    # abfragen ob es den Rechner in der Datenbank schon gibt
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws  where ws_station = '$varWS'"
    $reader = $command.ExecuteReader()
    
    # Wenn der Reader (eine) Zeile gefunden hat,
    # hat er den Rechner in der Tabelle Gefunden
    If ($reader.HasRows) {
    
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    
    	# Der Rechner ist in der Tabelle
    	# Wir machen ein Update des Eintrags-Datums
    	$query = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
    	
    	#$conn = ConnectMySQL $user $pass $MySQLHost $database
    	WriteMySQLQuery $conn $query 
    
    	#Installierte Software auslesen
    	$Items = gwmi -computer $varWS win32_Product
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "UPDATE 
    					tbl_soft 
    				  SET 
    					soft_name = '$varName', 
    					soft_vendor = '$varVendor', 
    					soft_version = '$varVersion', 
    					soft_id_num = '$varIdentifyingNumber', 
    					soft_installdate = '$varInstallDate', 
    					soft_ws = '$varWS' 
    				  WHERE 
    					soft_ws = '$varWS'"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    	
    } Else {
    	# Der Reader hat keine Zeilen gefunden; Der Rechner ist nicht in der Tabelle!
    	# Wie fügen den Rechner hinzu!
    	
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    	
    	#Betriebssystem
    	$wars = gwmi -computer $varWS Win32_OperatingSystem 
    	#Bios(Seriennummer)
    	$bios = gwmi -computer $varWS Win32_BIOS
    	#Benutzer auslesen
    	$users = gwmi -computer $varWS Win32_ComputerSystem
    
    	foreach ($war in $wars)
    	{
    		$varOS = $wars.caption
    	}
    
    	foreach ( $user in $users)
    	{
    		$varUser = $user.Username
    	}
    
    	foreach ($bio in $bios)
    	{
    		$varSerial = $bio.SerialNumber
    	}
    
    	$query2 = "INSERT INTO 
    					tbl_ws 
    					(ws_user, 
    					ws_os, 
    					ws_serial, 
    					ws_station, 
    					ws_date) 
    				VALUES 
    					('$varUser', 
    					'$varOS', 
    					'$varSerial', 
    					'$varWS', 
    					NOW())"
    
    	$Rows = WriteMySQLQuery $conn $query 
    
    	$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "	INSERT INTO 
    						tbl_soft 
    						(soft_name, 
    						soft_vendor, 
    						soft_version, 
    						soft_id_num, 
    						soft_installdate, 
    						soft_ws)
    					VALUES 
    						('$varName', 
    						'$varVendor', 
    						'$varVersion', 
    						'$varIdentifyingNumber', 
    						'$varInstallDate', 
    						'$varWS')"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    }
    
    # Die Datenbank Connection wird nicht mehr gebraucht wir schliessen sie brav
    $conn.Close()


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+


    Mittwoch, 11. Dezember 2013 08:59
  • Peter, das ist echt BOMBE :)

    VIELEN TAUSEND DANK!!!!

    so nun han ich aber noch ne frage wegen den MySQL Verbindungsaufbau...

    ich habe da noch ne frage bezüglich der Datenbank verbindung besser zum aufbau der verbindung...

    dang oben am Kopf wird ja gesagt das ich in der Funktion ConnectMySQL die Verbindung herstelle. bei param geb ich meine verbindungsdaten ein und unten wird der String dann
    zusammengesetzt. Anschliessend fülle ich ja auch die Variable $conn und öffne auch die verbindung.

    function ConnectMySQL {

        param (
            [string]$user,
            [string]$pass,
            [string]$MySQLHost,
            [string]$database
        )
     
      # Open Connection
      $connStr = "server=" + $MySQLHost + ";port=3306;uid=" + $user + ";pwd=" + $pass + ";database="+$database+";Pooling=FALSE" #Pooling speichert die SQL Verbindung
      $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
      $conn.Open()
      $cmd = New-Object MySql.Data.MySqlClient.MySqlCommand("USE $database", $conn)
      return $conn
    }

    soweit so gut

    WARUM?! muss ich dann nochmal unten die verbindungsdaten eingeben???

    $conn = ConnectMySQL 'User' 'PAsswort' 'MySQLHost' 'Database'

    ist das nicht überflüssig??? Weil wofür macht man den eine Funktion?! In PHP hab ich auch immer nur einmal die verbindung aufgemacht und hab damit dan rumgerödelt wie ich wollte.

    Gruß

    Chris

    Mittwoch, 11. Dezember 2013 09:54
  • Funktionen müssen VOR Ihrer ersten Benutzung bekannt gemacht werden!

    Also Funktionen werden erst deklariert.

    Damit PowerShell weiß das es diese Funktion gibt.

    Bei der Deklaration werden Funktionen noch nicht ausgeführt!

    Ebenso hat die Funktion ja noch nicht alle benötigten Daten!

    Erst bei dem Aufruf der Funktion, bekommt die Funktion die Daten und die Funktion wird ausgeführt.

    Stell dir folgende Situation vor:

    Du benötigst zum Kiestransport einen Lastwagen.

    Jetzt baust du dir einen Lastwagen oder du mietest ihn.

    Jetzt zeigst du all deinen Freunden diesen Lastwagen und sagst ihnen das sie damit fahren und transportieren können.

    Das ist die Deklaration.

    Function Lastwagen {
      param(
        $Fahrer,
        $Ladung
      )
        "Fahrer $Fahrer Fährt, die Ladung ist: $Ladung"
    }

    Der Lastwagen steht immer noch ungenutzt auf dem Hof und wartet....

    Der Fahrersitz ist leer und die Ladefläche auch!

    Nun steigst du ein (Der Parameter -Fahrer bekommt einen Wert) und Lädst die Ladung der (Der Parameter -Ladung bekommt einen Wert)

    Lastwagen -Fahrer 'Chris' -Ladung 'Sand'
    
    # Funktionen können mehrmals aufgerufen werden ganau dafür sind Sie da!
    Lastwagen -Fahrer 'Tom' -Ladung 'Alt-Bier'
    Lastwagen -Fahrer 'Sabine' -Ladung 'Puppen'
    Du hast recht! In deinem Fall ist die Funktion fast überflüssig da Sie nur einmal gebraucht wird.

    Funktionen Helfen aber, den Code zu ordnen und woanders diesen Code-Schnipsel wieder zu verwenden.

    Das würde auch gehen:

    # Auslesen der im Unternehmen eingesetzten Software auf den Einzelnen Arbeitsstationen
    
    # Load MySQL .NET Connector Objects
    [void][system.reflection.Assembly]::LoadFrom("C:\Program Files (x86)\MySQL\Connector NET 6.7.4\Assemblies\v2.0\MySQL.Data.dll")
    [void][system.reflection.Assembly]::LoadWithPartialName("MySql.Data")
    
    function WriteMySQLQuery {
    	
    	param (
     		$conn,
    		[string]$query
    	)
     
      $command = $conn.CreateCommand()
      $command.CommandText = $query
      $RowsInserted = $command.ExecuteNonQuery()
      $command.Dispose()
      
      if ($RowsInserted) {
        return $RowInserted
      } else {
        return $false
      }
    }
    
    # Datenbank öffnen
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # SERVERNAME, USERNAME, PASSWORD und DATABASENAME eintragen !
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    $connStr = "server=SERVERNAME;port=3306;uid=USERNAME;pwd=PASSWORD;database=DATABASENAME;Pooling=FALSE" #Pooling speichert die SQL Verbindung
    $conn = New-Object MySql.Data.MySqlClient.MySqlConnection($connStr)
    $conn.Open()
    
    
    $varWS = "" #Variable leeren
    $varWS = Read-Host "Please enter a computer name"
    #$varWS = Get-Content env:computername     #Auslesen des Computernamens
    
    # abfragen ob es den Rechner in der Datenbank schon gibt
    $command = $conn.CreateCommand()
    $command.CommandText = "SELECT * FROM tbl_ws  where ws_station = '$varWS'"
    $reader = $command.ExecuteReader()
    
    # Wenn der Reader (eine) Zeile gefunden hat,
    # hat er den Rechner in der Tabelle Gefunden
    If ($reader.HasRows) {
    
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    
    	# Der Rechner ist in der Tabelle
    	# Wir machen ein Update des Eintrags-Datums
    	$query = "UPDATE tbl_ws SET ws_date = NOW() where ws_station = '$varWS'"
    	
    	#$conn = ConnectMySQL $user $pass $MySQLHost $database
    	WriteMySQLQuery $conn $query 
    
    	#Installierte Software auslesen
    	$Items = gwmi -computer $varWS win32_Product
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "UPDATE 
    					tbl_soft 
    				  SET 
    					soft_name = '$varName', 
    					soft_vendor = '$varVendor', 
    					soft_version = '$varVersion', 
    					soft_id_num = '$varIdentifyingNumber', 
    					soft_installdate = '$varInstallDate', 
    					soft_ws = '$varWS' 
    				  WHERE 
    					soft_ws = '$varWS'"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    	
    } Else {
    	# Der Reader hat keine Zeilen gefunden; Der Rechner ist nicht in der Tabelle!
    	# Wie fügen den Rechner hinzu!
    	
    	# Der DataReader wird nicht mehr gebraucht wir schliessen Ihn brav
    	$reader.Close()
    	
    	#Betriebssystem
    	$wars = gwmi -computer $varWS Win32_OperatingSystem 
    	#Bios(Seriennummer)
    	$bios = gwmi -computer $varWS Win32_BIOS
    	#Benutzer auslesen
    	$users = gwmi -computer $varWS Win32_ComputerSystem
    
    	foreach ($war in $wars)
    	{
    		$varOS = $wars.caption
    	}
    
    	foreach ( $user in $users)
    	{
    		$varUser = $user.Username
    	}
    
    	foreach ($bio in $bios)
    	{
    		$varSerial = $bio.SerialNumber
    	}
    
    	$query2 = "INSERT INTO 
    					tbl_ws 
    					(ws_user, 
    					ws_os, 
    					ws_serial, 
    					ws_station, 
    					ws_date) 
    				VALUES 
    					('$varUser', 
    					'$varOS', 
    					'$varSerial', 
    					'$varWS', 
    					NOW())"
    
    	$Rows = WriteMySQLQuery $conn $query 
    
    	$Items = gwmi -computer $varWS win32_Product #Installierte Software auslesen
    
    	foreach ($item in $items)
    	{
    		$varName		= $item.Name
    		$varVendor		= $item.Vendor
    		$varVersion 		= $item.Version
    		$varIdentifyingNumber	= $item.IdentifyingNumber
    		$varInstallDate	     	= $item.InstallDate
    
    		$query = "	INSERT INTO 
    						tbl_soft 
    						(soft_name, 
    						soft_vendor, 
    						soft_version, 
    						soft_id_num, 
    						soft_installdate, 
    						soft_ws)
    					VALUES 
    						('$varName', 
    						'$varVendor', 
    						'$varVersion', 
    						'$varIdentifyingNumber', 
    						'$varInstallDate', 
    						'$varWS')"
    
    		$Rows = WriteMySQLQuery $conn $query 
    	}
    }
    
    # Die Datenbank Connection wird nicht mehr gebraucht wir schliessen sie brav
    $conn.Close()


    PowerShell Artikel, Buchtipps und kostenlose PowerShell Tutorials + E-Books
    auf der deutschsprachigen PowerShell Community

    Mein 21 Teiliger PowerShell Video Grundlehrgang
    Deutsche PowerShell Videos auf Youtube
    Folge mir auf:
    Twitter | Facebook | Google+


    Mittwoch, 11. Dezember 2013 10:32
  • :) Danke, werde das später mal umändern... jetzt heist es sich ums Front-End zu kümmern in C# :D

    Donnerstag, 12. Dezember 2013 06:15