Beiträge von Lashandan

Lashandan

Okay, sowas dachte ich mir schon. Dann hier mal ein Beispiel um zu klären, ob du dies meinst/brauchst:

AutoIt

; includes ---------------------------------------------------------------------
#include-once



; opt --------------------------------------------------------------------------
Opt('MustDeclareVars', 1)



; declaration ------------------------------------------------------------------
Global Const $GUI_EVENT_CLOSE = -3
Global $hGui
Global $cDropdown
Global $cLoadButton
Global $sListOfComputer = 'Et;repellendus;eos;quasi;adipisci;rerum;aperiam;Voluptatem;ea;nisi;Soluta;expedita'


; processing -------------------------------------------------------------------
_createGui()
_createGuiElements()

While True
    Switch GUIGetMsg()
        Case $GUI_EVENT_CLOSE
            ExitLoop

        Case $cLoadButton
            _fillCombobox($sListOfComputer)
    EndSwitch
WEnd

_guiDispose()



; functions --------------------------------------------------------------------
Func _createGui()
    $hGui = GUICreate('Demo', 350, 250)
EndFunc

Func _createGuiElements()
    $cDropdown   = GUICtrlCreateCombo('Bitte wählen ...', 15, 15, 320)
    $cLoadButton = GUICtrlCreateButton('Laden', 15, 50, 320)

    GUISetState(@SW_SHOW)
EndFunc

Func _guiDispose()
    GUIDelete($hGUI)
    Exit
EndFunc

Func _fillCombobox($sData)
    Local $sListOfComputer = StringReplace($sData, ';', '|')
    GUICtrlSetData($cDropdown, $sListOfComputer)
EndFunc

Alles anzeigen

Viele Grüße
Sven

Besten Dank für die Hilfe.

Mein Fehler war echt die PIPE im StringReplace...

Code

Local $sListOfComputer = StringReplace($sData, ';', '|')

Jetzt bekomme ich meine Rechner in die Dropdownliste

pasted-from-clipboard.png

Jetzt wird weiter gefeilt

Als nächstes sollen die Daten, sofern vorhanden, direkt nach der Auswahl des Rechners im DropDownMenü, im GUI ausgegeben werden.

Ich melde mich wieder

Lashandan

Zitat von SOLVE-SMART
Hi Lashandan ,

kannst du ggf. deinen Code (bestenfalls gesamt als *.zip) zu Verfügung stellen oder geht das auf Grund des Datenschutz nicht? Mir fällt es schwer eine hoffentlich passende Antwort zu geben, wenn ich keine Testdaten dazu erzeugen kann/habe.

Verstehe den Sinn bzw. das Ziel dazu nicht. Du willst Informationen eines Arrays der Combobox übergeben, nehme ich an? Dann sollte die Funktion doch helfen oder nicht?
AutoIt
_GUICtrlComboBoxEx_AddString()
Viele Grüße
Sven

Ich habe eine Variable in der alle Rechner separiert durch ein ";" gespeichert werden.

Diese Variable möchte ich jetzt für eine Listenansicht (Dropdown etc.) in die Liste übergeben.
Problem: derzeit stehen alle Rechner mit dem Separator in der Liste als ein gesamter Eintrag.
Ziel: alle Rechner in der Liste untereinander - eben Dropdown.

P.s. Den gesamte Code möchte ich aktuell noch nicht präsentieren da er ein paar sensible Daten erhält.
Diese muss ich bei Zeiten noch anpassen, damit der Code auch für Allgemein gelten kann.

Lashandan

Moin in die Runde.

Ich bin ein ganzes Stück weiter gekommen in den letzten Tagen und schreibe erfolgreich Daten in die Datenbank.
Derzeit nutze ich noch den "bad-way" - ich führe das alles derzeit nur lokal aus, sowohl das Programm als auch die Datenbank.

Das entschuldigt nicht, dass man sloppy programmiert um schnell zum Erfolg zu kommen - hier muss aber jeder für sich entscheiden.

Fakt ist - eure Unterstützung und Hilfe ist großartig und jeder sollte sich aneignen so sauber wie nur möglich zu programmieren, unnötige Schreibzugriffe usw. gehören vermieden.

Seit gestern schlage ich mich mit dem Problem rum, Daten aus der SQL-Tabelle zu lesen und sie wiederum in einer Dropdownliste darzustellen.

Das auslesen funktioniert und ich erhalte die Computer zurück, die sich bereits in der DB befinden.

Allerdings bekomme ich es einfach nicht gelöst, den Inhalt in der Dropdownliste anzuzeigen.

Ggf. ist die Wahl der Dropdownliste auch noch suboptimal.

Vielleicht wäre eine Liste (scrollbar) die bessere Wahl.

Ich möchte mit der Liste (ob nun dropdown oder andere Art) später dann, ein Element aus der Liste wählen und an die GUI dann alle weiteren Daten aus der DB lesen.

Initial brauche ich aber vorerst nur die Computer in der Liste.

pasted-from-clipboard.png

Ich habe in dem Screenshot mal das GUI gepostet.

Vor dem ganzen DB-Gewusel habe ich in das Eingabefeld den Rechnernamen eingetragen, nachdem ich dann den Button "Abfrage" betätige laufen verschiedene Funktionen und geben mir die gewünschten Werte zurück.
Weiterhin wird das ganze dann in der DB gespeichert.

Vorher findet aber eine Prüfung statt, ob der Rechnername und die Werte bereits vorhanden sind.
An der Prüfung feile ich ebenfalls noch, dass bereitet mir aber keine Bauchschmerzen.

In der DB sind nun 10 Datensätze vorhanden.

Somit auch 10 Computer.

Ziel ist es, in der DB "ALLE" Computer zu haben und folglich nur noch Änderungen (Tausch der Festplatte, anderer Benutzer, was auch immer) abzufragen und dann in der DB zu speichern.

Die Computer sollen also, wie oben bereits beschrieben, in einer Liste erscheinen.
Nachdem ich das Element in der Liste ausgewählt habe, soll eine neue Funktion die DB nach den Einträgen durchsuchen und sie in dem GUI wieder ausgeben.

Ich lese die Daten aus der DB aus und schreibe sie in ein Array:

Code

Local $aArray = _sql_search_act($sDatabaseFileName, $sTable, $sTableToSearchFor, $sSearchString, $sTablesReturn)

per ConsoleWrite() lasse ich mir die Ergebnisse vorsorglich ausgeben:

Hab dann versucht das Array aufzulösen und wiederum in eine Listenvariable zu schmeißen um sie anschließend in die Dropdownliste zu übergeben.

Auch die Funktion _ArrayToString() scheitert bei mir.

Wie bekomme ich meine Ergebnisse für die Computer sauber in eine Liste übergeben?

Lashandan

Zitat von Kanashius
https://www.sqlite.org/lang_update.html =>
SQL
UPDATE Rechnerinformationen SET IP-Adresse="127.0.0.0", "Uptime"="2022/01/17 07:15:55" WHERE Rechnername="WDEST1987"
Ich würde dir auch empfehlen, keine Leerzeichen/Sonderzeichen in Spaltennamen zu verwenden ("letzter Neustart"/"IP-Adresse"...) Das könnte später Probleme machen.
Dann kann man Spaltennamen ohne "" verwenden und besser von wirklichen Daten unterscheiden und - wird auch als Minus operator verwendet => SELECT IP-Adresse FROM XX könnte also auch als subtrahiere Spalte IP von Adresse und geb das zurück heißen.
Allgemein ist es Standard mit CamelCase oder _ zu schreiben, also: ip_adresse oder ipAdresse

Super Hinweis, danke dir.

Hab meinen Fehler auch bereits gefunden.

Ich bastle jetzt weiter und dann melde ich mich hoffentlich mit einem Ergebnis oder erneut mit Fragen.

Lashandan

Zitat von Concara

Hallo!

Ich kopiere die sqlite3.dll und sqlite3_x64.dll immer in den jeweilige Scriptordner , man weiß ja nie ob sich mal etwas ändert und dann hat man zumindest eine funktionsfähige Version.

Index und Primary key sind zwei verschiedene Sachen, erfüllen aber einfach angewendet die selbe Funktion, nämlich, dass man nur einen Datensatz mit dem gleichen Namen einfügen kann.

Die index Erstellung habe ich dir ja schon im Scriptbeispiel mit hinzugefügt ( auskommentiert ), wenn auch mit "falschen" Tabellennamen("PCNAME", "Benutzername").

Beispiel Indexerstellung "nur" auf letzter angemeldeter Benutzer:

AutoIt

Func _Create_Databasefile($sDatabaseFileName, $sCollums, $sTablename = $sDatabaseFileName)
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    If Not _SQLite_Exec(-1, 'CREATE TABLE if not exists "' & $sTablename & '" (' & $sCollums & ');') = $SQLITE_OK Then _
            MsgBox(16, "SQLite Error", _SQLite_ErrMsg()) ; CREATE a Table
     If Not _SQLite_Exec(-1, 'create unique index if not exists Unique1 on ' & $sDatabaseFileName & ' ("letzter angemeldeter Benutzer");') = $SQLITE_OK Then _
             MsgBox(16, "SQLite Error", _SQLite_ErrMsg(), 1); CREATE a INDEX
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_Create_Databasefile

Beispiel Primary Key auf letzter angemeldeter Benutzer:

AutoIt

#include <SQLite.au3>
#include <SQLite.dll.au3>

Local $sDatabaseFileName = "TEST_DB"

;Datenbank File erstellen und Tabelle anlegen
If Not FileExists($sDatabaseFileName & ".db3") Then
    _Create_Databasefile($sDatabaseFileName, ' "Prozessor" TEXT, "RAM" INTEGER, "letzter angemeldeter Benutzer" TEXT PRIMARY KEY, "OS" TEXT')
EndIF

pasted-from-clipboard.png

Beispiel mit einer Abfrage vor dem schreiben in die Datenbank (Datenbank mit index und primary key)

AutoIt

;Ins Script dann diese Includes:
#include <SQLite.au3>
#include <SQLite.dll.au3>

Local $sDatabaseFileName = "TEST_DB"
Local $InsertDaten, $sValueExist
Local $aInsertDaten
;Datenbank File erstellen und Tabelle anlegen
If Not FileExists($sDatabaseFileName & ".db3") Then
    _Create_Databasefile($sDatabaseFileName, ' "Prozessor" TEXT, "RAM" INTEGER, "letzter angemeldeter Benutzer" TEXT PRIMARY KEY, "OS" TEXT')
EndIf

;@TAB habe ich bei meinem Projekt als Trennung siehe StringReplace in der _sql Funktion
$InsertDaten = "Intel Pentium 75" & @TAB & "8192" & @TAB & "MAX Mustermann" & @TAB & "Linux wtf"
;~ $InsertDaten = "Intel Pentium 190" & @TAB & "18192" & @TAB & "MAX Mustermann" & @TAB & "Linux wtf1"

;~ ;Auf einen einzelnen Wert prüfen "letzter angemeldeter Benutzer"
;~ $sValueExist = _sql_search_act($sDatabaseFileName, $sDatabaseFileName, "letzter angemeldeter Benutzer", "MAX Mustermann", "letzter angemeldeter Benutzer")
;~ ConsoleWrite("$sValueExist = " & $sValueExist & @CRLF)
;~ If $sValueExist = "" Then
;~     ConsoleWrite("Neueintrag " & $InsertDaten & @CRLF)
;~     _sql($sDatabaseFileName, $InsertDaten)
;~ Else
;~     ConsoleWrite("Update " & $InsertDaten & @CRLF)
;~     _sql_update($sDatabaseFileName, $InsertDaten)
;~ EndIf

$aInsertDaten = StringSplit($InsertDaten, @TAB)
;Eingabewerte prüfen und nur wenn sich was verändert hat Update durchführen
$sValueExist = _sql_search_act($sDatabaseFileName, $sDatabaseFileName, "letzter angemeldeter Benutzer", $aInsertDaten[3])
ConsoleWrite("$sValueExist = " & $sValueExist & @CRLF)
If $sValueExist = "" Then
    ConsoleWrite("Neueintrag " & $InsertDaten & @CRLF)
    _sql($sDatabaseFileName, $InsertDaten)
ElseIf $sValueExist <> $InsertDaten Then
    ConsoleWrite("Update " & $InsertDaten & @CRLF)
    _sql_update($sDatabaseFileName, $InsertDaten)
EndIf


Func _sql($sDatabaseFileName, $sInsertData, $sTablename = $sDatabaseFileName)
    Local $hQuery, $aRow, $sMsg
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    $sInsertData = StringReplace($sInsertData, @TAB, '","')
    $sInsertData = '"' & $sInsertData & '"'
    _SQLite_Exec(-1, "INSERT INTO " & $sTablename & " VALUES (" & $sInsertData & ");")     ; INSERT Data
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_sql

Func _sql_update($sDatabaseFileName, $sInsertData, $sTable = $sDatabaseFileName)
    Local $hQuery, $aRow, $sMsg
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    $sInsertData = StringReplace($sInsertData, @TAB, ',')
    $sInsertData = StringSplit($sInsertData, ",")
    _SQLite_Exec(-1, 'UPDATE ' & $sTable & ' set "Prozessor" = "' & $sInsertData[1] & _
            '", "RAM" = "' & $sInsertData[2] & _
            '", "OS" = "' & $sInsertData[4] & _
            '" WHERE "letzter angemeldeter Benutzer" = "' & $sInsertData[3] & '";')
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_sql_update

Func _sql_search_act($sDatabaseFileName, $sTable, $sTableToSearchFor, $sSearchString, $sTablesReturn = "")
    Local $hQuery, $aRow, $sMsg, $iItems, $sReturnData
    If $sTablesReturn = "" Then
        $sTablesReturn = "*"
    Else
        $sTablesReturn = '"' & $sTablesReturn & '"'
    EndIf
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    ConsoleWrite('SELECT ' & $sTablesReturn & ' FROM ' & $sTable & ' where "' & $sTableToSearchFor & '" like "' & $sSearchString & '";' & @CRLF)
    _SQLite_Query(-1, 'SELECT ' & $sTablesReturn & ' FROM ' & $sTable & ' where "' & $sTableToSearchFor & '" like "' & $sSearchString & '";', $hQuery)     ; the query
    While _SQLite_FetchData($hQuery, $aRow) = $SQLITE_OK
        For $iItems = 0 To UBound($aRow) - 1
            $sReturnData &= $aRow[$iItems] & @TAB
        Next
    WEnd
    _SQLite_Close()
    _SQLite_Shutdown()
    Return StringTrimRight($sReturnData, 1)
EndFunc   ;==>_sql_search_act

Func _Create_Databasefile($sDatabaseFileName, $sCollums, $sTablename = $sDatabaseFileName)
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    If Not _SQLite_Exec(-1, 'CREATE TABLE if not exists "' & $sTablename & '" (' & $sCollums & ');') = $SQLITE_OK Then _
            MsgBox(16, "SQLite Error", _SQLite_ErrMsg()) ; CREATE a Table
    If Not _SQLite_Exec(-1, 'create unique index if not exists Unique1 on ' & $sDatabaseFileName & ' ("letzter angemeldeter Benutzer");') = $SQLITE_OK Then _
            MsgBox(16, "SQLite Error", _SQLite_ErrMsg(), 1) ; CREATE a INDEX
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_Create_Databasefile

Alles anzeigen

WoW, wiedermal vielen Dank für die großartige Hilfe bei dem Thema!!!

Folgender Fortschritt:

Die Tabelle und die Datenbank ist angelegt.

Code

_Create_Databasefile($sDatabaseFileName, ' "Rechnername" TEXT PRIMARY KEY, "letzter Neustart" DATETIME, "Uptime" DATETIME, "IP-Adresse" TEXT, "Arbeitsspeicher" TEXT, "Kerne" TEXT, "Prozessor" TEXT, "Betriebssystem" TEXT, "Serial" TEXT, "Rechnermodell" TEXT, "Hersteller" TEXT, "Benutzer" TEXT, "Struktur" TEXT, "Mac-Adresse" TEXT, "Disk-Type" TEXT')

der erste Eintrag wird sauber erzeugt.

Die Probleme mit den Hochkommata konnte ich auch erstmal soweit lösen.

Aber nun bekomme ich beim Update folgendes Problem:
Ich lasse wieder Daten sammeln und möchte sie per Update in die Datenbank schreiben.

Vorher prüfe ich auf den angelegten PRIMARY KEY Rechnername.

Dann werden die Daten zusammengeschrieben (hier Beispielhaft)

Code

$InsertDaten = "WDEST1987" & @TAB & $sUpTime & @TAB & $sLastBootupTime & @TAB & "127.0.0.0" & @TAB & "24" & @TAB & "28" & @TAB & "98" & @TAB & "Win 10" & @TAB & "9373763636" & @TAB & "HP Z2 Mini G3 Workstation" & @TAB & "HP" & @TAB & "domaene\testuser" & @TAB &  "64" & @TAB & "1111111" & @TAB & $sDisktype

Und erhalte dann folgenden Fehler:

Code

!   SQLite.au3 Error
--> Function: _SQLite_Exec
--> Query:    UPDATE Rechnerinformationen SET "WDEST1987","7 days, 7 hours, 38 minutes, 43 seconds","2022/01/17 07:15:55","127.0.0.0","24","28","98","Win 10","9373763636","HP Z2 Mini G3 Workstation","HP","domaene\testuser","64","1111111","NVMe Samsung SSD 960SSD";
--> Error:    near ",": syntax error

ich finde einfach nicht was da falsch läuft.

Lashandan

Zitat von Bitnugger

Die Files auf https://www.sqlite.org/download.html sind aktueller.

Danke für den Hinweis.

bin jetzt auch erstmal ein Stück weiter gekommen.

Die Tabelle mit den Köpfen ist angelegt.

Als nächstes habe ich meinen Rechner einige Male abgefragt und da fällt schnell auf, dass es noch keinen Index gib.

Den kann ich theoretisch mit dem DB Browser for SQLLite setzen.

Würde den Index dann auf den Rechnernamen setzen da dieser (in meinem Fall) eindeutig ist.

Wie aber realisiere ich die folgenden Punkte:

1. ich möchte bevor ich den Rechner erneut abfrage, prüfen, ob es in der SQL-Datenbank bereits einen Eintrag gibt.

2. wenn ein Eintrag vorhanden ist (Rechnername würde ja dann zur Identifizierung ausreichen) möchte ich das SQL_Update verwenden.

--> Wie stelle ich das dann an?

Lashandan

Concara

ich habe nun folgende Schritte unternommen:

1. ich habe von "https://www.autoitscript.com/autoit3/pkgmgr/sqlite/" die aktuellste *.zip-Datei geladen

diese habe ich dann direkt in den SkriptOrdner gepackt.

2. ich habe die Includes in mein Skript integriert.

3. ich teste danach den "falschen und schnellen" Weg zuerst.

Hier erhalte ich nun aber direkt einen Error:

Eigentlich sollte die DB doch automatisch mit der Funktion initial angelegt werden oder nicht?

Code

;Datenbank File erstellen und Tabelle anlegen
If Not FileExists($sDatabaseFileName & ".db3") Then
_Create_Databasefile($sDatabaseFileName, ' "Prozessor" TEXT, "RAM" INTEGER, "letzter angemeldeter Benutzer" TEXT, "OS" TEXT')
ConsoleWrite("Datenbank existiert")
EndIF

Lashandan

Zitat von Concara
Hallo!
Meine Meinung nach vergiss das mit INI.
Wenn du es mit sqlite probieren willst hier mal der Link damit du starten kannst: https://www.autoitscript.com/autoit3/pkgmgr/sqlite/
Link stammt von dieser Seite https://www.autoitscript.com/autoit3/docs/l…ite_Startup.htm
Von dort ladest du dir die sqlite3.dll und sqlite3_x64.dll herunter und gib sie in den Script Ordner.
Oder:
Auszug:
If #include <SQLite.dll.au3> is included the SQLite version is checked.
The SQLite files can be downloaded from https://www.autoitscript.com/autoit3/pkgmgr/sqlite/SQLite3_version.zip that can be stored in @ScriptDir, @SystemDir, @WindowsDir, or @WorkingDir.
Zum Start flach und mit "schnellem" Erfolg alle Daten in eine Tabelle und "alles" wird rein geschrieben ohne Überprüfung:
AutoIt
;In das Script dann diese Includes:
#include <SQLite.au3>
#include <SQLite.dll.au3>

Local $sDatabaseFileName = "TEST_DB"

;Datenbank File erstellen und Tabelle anlegen
If Not FileExists($sDatabaseFileName & ".db3") Then
    _Create_Databasefile($sDatabaseFileName, ' "Prozessor" TEXT, "RAM" INTEGER, "letzter angemeldeter Benutzer" TEXT, "OS" TEXT')
EndIF

;@TAB habe ich bei meinem Projekt als Trennung siehe StringReplace in der _sql Funktion
$InsertDaten = "Intel Pentium 75" & @TAB & "8192" & @TAB & "MAX Mustermann" & @TAB & "Linux wtf" 
_sql($sDatabaseFileName, $InsertDaten)

Func _sql($sDatabaseFileName, $sInsertData, $sTablename = $sDatabaseFileName)
    Local $hQuery, $aRow, $sMsg
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    $sInsertData = StringReplace($sInsertData, @TAB, '","')
    $sInsertData = '"' & $sInsertData & '"'
    _SQLite_Exec(-1, "INSERT INTO " & $sTablename & " VALUES (" & $sInsertData & ");")     ; INSERT Data
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_sql

Func _sql_update($sDatabaseFileName, $sInsertData, $sTablename = $sDatabaseFileName)
    Local $hQuery, $aRow, $sMsg
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    $sInsertData = StringReplace($sInsertData, @TAB, '","')
    $sInsertData = '"' & $sInsertData & '"'
    _SQLite_Exec(-1, "UPDATE " & $sTablename & " SET " & $sInsertData & ";")     ; INSERT Data
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_sql_update
 
Func _Create_Databasefile($sDatabaseFileName, $sCollums, $sTablename = $sDatabaseFileName)
    _SQLite_Startup()
    _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    If Not _SQLite_Exec(-1, 'CREATE TABLE if not exists "' & $sTablename & '" (' & $sCollums & ');') = $SQLITE_OK Then _
            MsgBox(16, "SQLite Error", _SQLite_ErrMsg()) ; CREATE a Table
;~     If Not _SQLite_Exec(-1, 'create unique index if not exists Unique1 on ' & $sDatabaseFileName & ' ("PCNAME", "Benutzername");') = $SQLITE_OK Then _
;~             MsgBox(16, "SQLite Error", _SQLite_ErrMsg(), 1); CREATE a INDEX
    _SQLite_Close()
    _SQLite_Shutdown()
EndFunc   ;==>_Create_Databasefile
Alles anzeigen
Nachteile in dem Script:
_SQLite_Startup() und _SQLite_Shutdown() werden bei jedem Funktionsaufruf gestartet und beendet.
Bei großen Datenmengen sind einzelne Insert sehr langsam
Besser:
Code
    _SQLite_Startup()
    Do
        Sleep(Random(20, 250, 1))
        _SQLite_Open(@ScriptDir & "\" & $sDatabaseFileName & ".db3")
    Until Not @error
    _SQLite_Exec(-1, "Begin Transaction;")
    _SQLite_Exec(-1, $result) ; INSERT Data
    _SQLite_Exec(-1, "Commit Transaction;")
    _SQLite_Close()
    _SQLite_Shutdown()
$result ist dann so aufgebaut:
INSERT INTO "main"."TEST_DB" ("Prozessor", "RAM", "letzter angemeldeter Benutzer", "OS") VALUES ('Intel Pentium 75', '8192', 'MAX Mustermann', 'Linux wtf');
INSERT INTO "main"."TEST_DB" ("Prozessor", "RAM", "letzter angemeldeter Benutzer", "OS") VALUES ('Intel Pentium 90', '8192', 'MAX Musterfrau', 'Linux Mint');
INSERT INTO "main"."TEST_DB" ("Prozessor", "RAM", "letzter angemeldeter Benutzer", "OS") VALUES ('Intel Pentium 100', '8192', 'MAX Mustermann1', 'Linux wtf');
INSERT INTO "main"."TEST_DB" ("Prozessor", "RAM", "letzter angemeldeter Benutzer", "OS") VALUES ('Intel Pentium 200', '8192', 'MAX Musterfrau2', 'Linux Mint');
.....
Das geht rasend schnell bei Sqlite und bei anderen DBs auch.
Auf ein Problem stösst du wahrscheinlich auch, Anführungszeichen "zerstören" dir deine inserts.
Also musst du eine Routine schreiben die diese doppelt kommentiert.
Beispiel: Intel "Pentium" 300 wird dann Intel ""Pentium"" 300

Sehr Hilfreich zum Nachsehen und SQl ausprobieren ein DB Browser: DB Browser for SQLite (sqlitebrowser.org)
Alles anzeigen

Wow
vielen Dank für diese ausführliche Hilfestellung.

Dann werde ich das mit der Ini wirklich direkt skippen und mich dort mal einlesen.

Ich werde den Thread mal lieber noch nicht schließen um ggf. weitere Fragen zu posten bzw. euch am Ende das Ergebnis zu präsentieren.
Möglicherweise kann der ein oder andere ja davon profitieren wie man Ergebnisse aus einer Abfrage dann entsprechend in einer DB ablegt.

Ich melde mich

Lashandan

Zitat von Musashi

Grundsätzlich könnte man z.B. eine .ini-Datei verwenden, mit :
[Sektionsname] = Rechnername (d.h. Kürzel+Nummer)
-> die jeweiligen Informationen als Key=Value Paare anlegen
Ich würde aber eine Datenbanklösung mittels SQLITE vorziehen !.
Jeder Datensatz stellt einen Rechner dar, mit Rechnername als Hauptindex, und den Informationen als Datensatzfelder.

Danke für deine Hinweise.

Ich werde mir tatsächlich erstmal die .Ini-Variante anschauen und versuchen.

Das Thema Datenbanklösung muss ich mir erstmal zu Gemüte ziehen.

Wenn du hier noch zielführende Hilfe hast, immer her damit

Lashandan

Hallo Freunde,

ich habe mal wieder ein erneutes Anliegen und brauche eure Hilfe:

- ich habe ein kleines Programm geschrieben mit dem ich bestimmte Informationen von Rechnern abfragen kann

--> Prozessor, RAM, letzter angemeldeter Benutzer, OS, usw.

- das Programm ist so geschrieben, dass man einen Rechnernamen (in unserem Unternehmen Kürzel+Nummer) eingeben muss und dann die Abfragen direkt erfolgen und in einem GUI ausgegeben werden.

- da es durchaus vorkommt, dass ich den ein oder anderen Rechner mehrfach abfrage, möchte ich ein weiteres Feature einbauen:

- ich möchte eine Art Datenbank (Datenbank, Ini, Datei, irgendwas) hinter das ganze stellen

- diese soll dann mit den ganzen Infos gefüllt werden

- auf der anderen Seite, möchte ich auch lesend auf die Datenbank zugreifen können um Rechnerinformationen die ich bereits habe, zu speichern, zu updaten etc.

- dabei möchte ich nicht die einzelnen Informationen updaten, sondern immer nur in der Gesamtheit der abfragenden Funktionen

- Ziel soll es sein, dass ich Rechner die ich bereits abgefragt habe und für die es Einträge gibt, mit den jeweiligen Infos angezeigt bekomme und ggf. updaten kann bzw. einfach die Funktion zum Abfragen erneut ausführe

was für Möglichkeiten, schlank, habe ich denn hier?

Ich bitte um kreative Vorschläge und Ideen oder Hilfe dazu

Lashandan

Und natürlich noch der Code, finde es ja selbst immer schrecklich wenn man keine Lösung zur eingehenden Frage findet.

AutoIt

; COM-Fehlerbehandlungsroutine initialisieren
Local $oMyError = ObjEvent("AutoIt.Error","MyErrFunc")

; Objekt für den HTTP-Post-Request
Local $objHTTP = ObjCreate("Microsoft.XMLHTTP")

; Objekt für die XML-Datei in DOM
Local $o_XML = ObjCreate("Microsoft.XMLDOM")

; Iput-Box für die Eingabe
$strValue = InputBox("Eingabemaske", "Bitte Personalnummer eingeben!", "4230")

; Erstellen der SOAP-Hülle
$strEnvelope = '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:urn="urn:mwm-org:soap:soap">' & _
   '<soapenv:Header/>' & _
   '<soapenv:Body>'   & _
      '<urn:onhand>' & _
         '<urn:piPersNr>'&$strValue&'</urn:piPersNr>' & _
         '<urn:gpcBCR_Connection_Obj>?</urn:gpcBCR_Connection_Obj>' & _
      '</urn:onhand>' & _
   '</soapenv:Body>' & _
'</soapenv:Envelope>'

; Soapadresse
$objHTTP.Open('POST', 'http://ADRESSE:PORT/soap?wsdl', False)

; Standard-SOAP/XML-Header für den Content-Typ
$objHTTP.setRequestHeader ("Content-Type", "text/xml")

; Header für die aufzurufende Methode
$objHTTP.setRequestHeader ("onhand", "urn:mwm-org:soap:soap#opcAntwort")

; SOAP-Aufruf
$objHTTP.send ($strEnvelope)

; Response-Text
$strReturn = $objHTTP.responseText

; XML parsen
If Not $o_XML.loadXML($strReturn) Then Exit MsgBox(48, "Fehler", "Fehler beim Laden des XML-Strings")

; Element extrahieren (Auswahl über XPath-Selektoren)
$s_opcAntwort = $o_XML.SelectSingleNode('//opcAntwort')

; Antwort
MsgBox(0,"opcAntwort", $s_opcAntwort.text)


Func MyErrFunc()
$HexNumber=hex($oMyError.number,8)
ConsoleWrite("We intercepted a COM Error !" & @CRLF & @CRLF & _
             "err.description is: " & @TAB & $oMyError.description & @CRLF & _
             "err.windescription:" & @TAB & $oMyError.windescription & @CRLF & _
             "err.number is: " & @TAB & $HexNumber & @CRLF & _
             "err.lastdllerror is: " & @TAB & $oMyError.lastdllerror & @CRLF & _
             "err.scriptline is: " & @TAB & $oMyError.scriptline & @CRLF & _
             "err.source is: " & @TAB & $oMyError.source & @CRLF & _
             "err.helpfile is: " & @TAB & $oMyError.helpfile & @CRLF & _
             "err.helpcontext is: " & @TAB & $oMyError.helpcontext & @CRLF & _
            "" _
            )
SetError(1) ; die nach Antwort dieser Funktion zu prüfen ist
Endfunc; MyErrFunc()

Alles anzeigen

der nächste wird auch darüber stolpern also noch ein weiterer Hinweis.
Um den evelope-string zu definieren, kann man SoapUI (und anderen Alternativen) zur Hilfe nehmen:

Man ruft dazu also die WSDL-URL auf und bindet diese ins SoapUI ein.

Danach erhält man folgende Information.

Hier finde ich also die Funktion(en)

In Request 1 finde ich dann denn gesamten String für $strEnvelope.

pasted-from-clipboard.png

Die entsprechende Antwort auf die gesendete Personalnummer erhalte ich ebenfalls.

pasted-from-clipboard.png

Alles andere ergibt sich dann mit dem o.g. Code und sieht als Antwort so aus:

Vielen Dank nochmal an alle!

Lashandan

Lottich vielen Dank für deine Antwort, mit stringsplit bzw. stringbetween kann ich aber nicht alle Möglichkeiten abfangen da es meist alphanumerische Felder sind die ich abfrage.

AspirinJunkie genau danach habe ich gesucht und mein Ansatz war ja dann schonmal nicht ganz falsch
Besten Dank -

Lashandan

Hallo in die Runde,

ich beschäftige mich seit kurzer Zeit mit SOAP.

Die Schnittstelle etc. ist abgestimmt, ich bekomme auch bereits ein Ergebnis.

Nun möchte ich aber einen ganz speziellen Wert aus dem return ausgeben.

Folgendes erhalte ich zurück:

Code

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing">
   <SOAP-ENV:Header>
      <wsa:MessageID SOAP-ENV:mustUnderstand="0">uuid:21110c70-a727-11ea-8274-ce09341d2009</wsa:MessageID>
      <wsa:To SOAP-ENV:mustUnderstand="0">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:To>
   </SOAP-ENV:Header>
   <SOAP-ENV:Body>
      <ns1:onhandResponse xmlns:ns1="urn:mwm-org:soap:soap">
         <ns1:result xsi:nil="true"/>
         <opcAntwort xmlns="urn:mwm-org:soap:soap">Fischer, Lars</opcAntwort>
      </ns1:onhandResponse>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Alles anzeigen

Wie gelingt es mir nun, genau den Inhalt von opcAntwort auszugeben?

Habe es hiermit versucht:

AutoIt

; Load the return envelope into a DOM
$loadXML = $objReturn.loadXML ($strReturn)


; Query the return envelope
$strQuery = "SOAP-ENV:Envelope/SOAP-ENV:Body/opcAntwort"

$objReturn.selectSingleNode($strQuery)
$Soap = $objReturn.Text

MsgBox(0, "Soap", $Soap)

Alles anzeigen

aber hier erhalte ich:

Code

uuid:93098820-a727-11ea-8274-ce09341d2009 http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous Nachname, Vorname

Kann mir jemand weiterhelfen?

Lashandan

Vielen Dank für eure Hilfen und Hinweise.

alpines Das wird auf jeden Fall noch Interessant, wenn ich mehrere Parameter mitgeben möchte.

BugFix genau so möchte ich es lösen

Moombas Danke vielmals! Genau nach so einer Möglichkeit habe ich gesucht, dass ich die jeweilige Funktion an die Progressbar zurückmelden kann wenn diese fertig ist.

Danke an alle

Lashandan

Hi Leute,

ich widme mich mal wieder dem leidigen Thema eine Progressbar zu platzieren.

Folgendes möchte ich:

- Ich habe ein GUI in dem ein Rechnername zum Abfragen eingetragen werden kann.

- Nach dem Klick auf den Button Abfragen durchläuft eine While-Schleife diverse Funktionen die mir Informationen zu verschiedenen Rechnern ausgeben

- diese erscheinen dann nach und nach in dem GUI

nun soll das Ganze noch durch eine ProgressBar aufgewertet werden, damit der Nutzer auch weiß, wann die Abfrage fertig ist.

Ist es möglich, jede Funktion am Ende einen Wert an die Progressbar zu übergeben der die Funktion sozusagen "fertig" meldet?

Wenn ja wie?

Ich brauche auch keine Zeiten oder geschätzte Dauer sondern wirklich eine jeweilige Rückmeldung wenn eine Funktion fertig ist.

Die letzte Funktion übermittelt dann quasi das Ende und danach soll die Progressbar schließen.

Hab das Netzt und das Forum hier schon durchsucht aber nichts für meinen Zweck gefunden was mich zufrieden stellt

Hab bis jetzt nur sloppy-Code und schmeiße den mal hier rein:

C

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>

#include <Date.au3>
#include <MsgBoxConstants.au3>
#include <GUIConstants.au3>
#include <Inet.au3>
#include <WinAPI.au3>
#include <Math.au3>
#Region ### START Koda GUI section ### Form=C:\Users\Documents\AutoIt\RechnerUptime\Form1.kxf
$Form1 = GUICreate("Form1", 615, 437, 200, 129)
$Group1 = GUICtrlCreateGroup("Eingaben", 16, 8, 577, 57)
global $iComputer = GUICtrlCreateInput("WDEST1987", 120, 32, 121, 22, BitOR($ES_CENTER,$ES_UPPERCASE))

GUICtrlSetFont(-1, 9, 400, 0, "Calibri")
$Label1 = GUICtrlCreateLabel("Rechnername:", 34, 32, 82, 18)
;GUICtrlSetFont(-1, 9, 400, 0, "Calibri")
$go = GUICtrlCreateButton("Abfragen", 248, 32, 75, 25)
;GUICtrlSetFont(-1, 9, 400, 0, "Calibri")

;$Progress1 = GUICtrlCreateProgress(336, 32, 241, 17, BitOR($PBS_SMOOTH,$WS_BORDER))

GUICtrlCreateGroup("", -99, -99, 1, 1)
$Group2 = GUICtrlCreateGroup("Rechnerinformationen", 16, 80, 577, 345)
;GUICtrlSetFont(-1, 9, 400, 0, "Calibri")

;#################___ Rechnername ___#################
$Icon1 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -16, 32, 104, 32, 32)
$Label2 = GUICtrlCreateLabel("Rechnername:", 72, 112, 82, 18)
$lRechnername = GUICtrlCreateLabel("Rechnername", 168, 112, 100, 18)

;#################___ Letzter Start ___#################
$Icon2 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -28, 32, 144, 32, 32)
$Label4 = GUICtrlCreateLabel("Letzter Start:", 72, 152, 70, 18)
$lLetzter_Start = GUICtrlCreateLabel("Letzter Start", 168, 152, 300, 18)

;#################___ Uptime ___#################
$Icon3 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -22, 32, 184, 32, 32)
$Label6 = GUICtrlCreateLabel("Uptime:", 72, 192, 47, 18)
$lUptime = GUICtrlCreateLabel("Uptime", 168, 192, 300, 18)

;#################___ IP-Adresse ___#################
$Icon4 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -222, 32, 224, 32, 32)
$Label8 = GUICtrlCreateLabel("IP-Adresse:", 72, 232, 65, 18)
$lIPAdresse = GUICtrlCreateLabel("Label9", 168, 232, 300, 18)

;#################___ Arbeitsspeicher ___#################
$Icon5 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -13, 32, 264, 32, 32)
$Label10 = GUICtrlCreateLabel("Arbeitsspeicher:", 72, 272, 93, 18)
$lArbeitsspeicher = GUICtrlCreateLabel("Label11", 168, 272, 300, 18)

;#################___ Prozessor ___#################
$Icon6 = GUICtrlCreateIcon("C:\Windows\System32\imageres.dll", -145, 32, 304, 32, 32)
$Label12 = GUICtrlCreateLabel("Prozessor:", 72, 312, 59, 18)
$lProzessor = GUICtrlCreateLabel("Label13", 168, 312, 450, 24)

;#################___ Betriebssystem ___#################
$Icon7 = GUICtrlCreateIcon("C:\Windows\System32\imageres.dll", -2, 32, 344, 32, 32)
$Label14 = GUICtrlCreateLabel("Betriebssystem:", 72, 352, 91, 18)
$lBetriebssystem = GUICtrlCreateLabel("Label15", 168, 352, 350, 24)

;#################___ Serial ___#################
$Icon8 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -45, 32, 384, 32, 32)
$Label16 = GUICtrlCreateLabel("Serial:", 72, 392, 39, 18)
$lSerialNumber = GUICtrlCreateLabel("Label17", 168, 392, 300, 18)

;#################___ Rechnermodell ___#################
$Icon9 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -208, 336, 104, 32, 32)
$Label18 = GUICtrlCreateLabel("Rechnermodell:", 376, 112, 90, 18)
$lModell = GUICtrlCreateLabel("Label19", 480, 112, 300, 18)

;#################___ Hersteller ___#################
$Icon10 = GUICtrlCreateIcon("C:\Windows\System32\shell32.dll", -208, 336, 144, 32, 32)
$Label20 = GUICtrlCreateLabel("Hersteller:", 376, 152, 62, 18)
$lHersteller = GUICtrlCreateLabel("Label19", 480, 152, 300, 18)

GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###

While true
    $nMsg = GUIGetMsg()
    Switch $nMsg
        Case $GUI_EVENT_CLOSE
            Exit

        Case $go
            local $start = 0, $iEnd = 0, $iHours = 0, $iMins = 0, $iSecs = 0
            ProgressOn("Status der Abfrage", "Abfrage läuft...", "", 350, 350, 0)
            $start = TimerInit()
            $GesamtDauer = _TicksToTime($iEnd, $iHours, $iMins, $iSecs)
            for $i = 1 to $GesamtDauer Step 1
                 $iPercent = Int($i / $GesamtDauer * 100)
                 ProgressSet($iPercent, $i  & "/" & $GesamtDauer & @TAB & "(" & $iPercent & "%)")

            next
            $sComputer = GuiCtrlRead($iComputer)
            _Uptime($sComputer)
            GetMemWMI($sComputer)
            _LowMetricIP($sComputer)
            CheckCPU($sComputer)
            getOS($sComputer)
            getSerialNumber($sComputer)
            Modell($sComputer)
            Hersteller($sComputer)
            ProgressSet($iPercent, "Completed!")
            ProgressOff()

    EndSwitch
WEnd

Func _Uptime($sComputer)
    $iPing = Ping($sComputer, 500)
        If Not $iPing Then Return "Rechner nicht erreichbar/offline"
    $oWMIService = ObjGet("winmgmts:\\" & $sComputer & "\root\cimv2")
        If Not IsObj($oWMIService) Then Return "Fehler beim Verbinden (Admin-PC)"
    $oColOperatingSystems = $oWMIService.ExecQuery("Select LastBootUpTime from Win32_OperatingSystem")
        For $oOS In $oColOperatingSystems
            Local $sBootup = $oOS.LastBootUpTime
            Local $sLastBootupTime = __WMIDateStringToDate($sBootup)
        Next
    $oColOperatingSystems = 0
    $oWMIService = 0
    Local $sUpTime = __FormatUptime($sLastBootupTime)
    GUICtrlSetData($lLetzter_Start, __WMIDateStringToDate($sBootup))
    GUICtrlSetData($lRechnername, $sComputer)
    ;Return "Rechnername: " & $sComputer & @CRLF & "Last Boot: " & $sLastBootupTime & @CRLF & "Uptime: " & $sUpTime & @CRLF & "IP-Adresse: "
EndFunc   ;==>_Uptime

Func GetMemWMI($sComputer)
;~     ConsoleWrite("Abfrage startet..." & @CRLF)
;~     Local $sLogFileOS = @ScriptDir & "\" & "Arbeitsspeicher" & "_Stand_" & @YEAR & @MON & @MDAY & ".txt"
;~     Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
    Local $mem, $colItems, $colItem, $ping, $x
    Local $sError1 = $sComputer & ";Error 1: " & ";Host ist Offline" & @CRLF
    Local $sConsoleError1 = $sComputer & " Error 1: " & "Host ist Offline" & @CRLF
    Local $sError2 = $sComputer & ";Error 2: " & ";Host nicht erreichbar" & @CRLF
    Local $sConsoleError2 = $sComputer & " Error 2: " & "Host nicht erreichbar" & @CRLF
    Local $sError3 = $sComputer & ";Error 3: " & ";Bad destination" & @CRLF
    Local $sConsoleError3 = $sComputer & " Error 3: " & "Bad destination" & @CRLF
    Local $sError4 = $sComputer & ";Error 4: " & ";Kein Zugriff" & @CRLF
    Local $sConsoleError4 = $sComputer & " Error 4: " & "Kein Zugriff" & @CRLF
    $ping = Ping($sComputer, 500)
    $mem = ''
    Switch @error
        Case 1
            ;MsgBox(64, @error, "Host is offline")
;~         FileWriteLine($hOpenLFileOS, $sError1)
;~         ConsoleWrite($sConsoleError1)
        Case 2
            ;MsgBox(64, @error, "Host is unreachable")
;~         FileWriteLine($hOpenLFileOS, $sError2)
;~         ConsoleWrite($sConsoleError2)
        Case 3
            ;MsgBox(64, @error, "Bad destination")
;~         FileWriteLine($hOpenLFileOS, $sError3)
;~         ConsoleWrite($sConsoleError3)
        Case 4
            ;MsgBox(64, @error, "Other errors")
;~         FileWriteLine($hOpenLFileOS, $sError4)
;~         ConsoleWrite($sConsoleError4)
        Case Else
;~         ConsoleWrite($sComputer & " Ping: " & $ping & @CRLF)
            $objWMIService = ObjGet("winmgmts:{impersonationLevel = impersonate}!\\" & $sComputer & "\root\cimv2")
            If IsObj($objWMIService) Then
                $colItems = $objWMIService.ExecQuery("Select Capacity from Win32_PhysicalMemory", "WQL", 0x30)
                For $objItem In $colItems
                    $mem += $objItem.Capacity
                Next
;~             MsgBox(0,"", $mem)
                $sResultMem = $sComputer & " verfügt über: " & Round($mem / 1024 ^ 3, 2) & " GB" & @CRLF
;~             ConsoleWrite($sComputer & " Arbeitsspeicher: " & Round($mem / 1024 ^3, 2) & " GB" & @CRLF)
;~             FileWriteLine($hOpenLFileOS, $sComputer & " Arbeitsspeicher: " & Round($mem / 1024 ^3, 2) & " GB")
            Else
                $sResultMem = "Recher nicht erreichbar"
;~             ConsoleWrite($sComputer & " Rechner nicht ABFRAGBAR" & @CRLF)
;~             FileWriteLine($hOpenLFileOS, $sComputer & " Rechner nicht ABFRAGBAR" & @CRLF)
            EndIf
    EndSwitch
;~     FileClose($hOpenLFileOS)
;~     ConsoleWrite("Abfrage ende!" & @CRLF)
    GUICtrlSetData($lArbeitsspeicher, $sResultMem)
EndFunc   ;==>GetMemWMI

Func _LowMetricIP($sHost = $sComputer)
    Local $objAdapter, $iMetric = 500, $sActualIP
    Local $objWMIService = ObjGet("winmgmts:{impersonationLevel = impersonate}!\\" & $sHost & "\root\cimv2")
    If Not IsObj($objWMIService) Then Return SetError(1, 0, 0)
    Local $colAdapter = $objWMIService.ExecQuery("Select * From Win32_NetworkAdapterConfiguration WHERE IPEnabled = True", "WQL", 0x30)
    If IsObj($colAdapter) Then
        For $objAdapter In $colAdapter
            If $objAdapter.IPConnectionMetric < $iMetric And IsString($objAdapter.DefaultIPGateway(0)) Then ; ggf. kann auch die Gateway-Prüfung entfallen !
                $sActualIP = $objAdapter.IPAddress(0)
                $iMetric = $objAdapter.IPConnectionMetric
            EndIf
        Next
        GUICtrlSetData($lIPAdresse, $sActualIP)
        If $sActualIP Then Return $sActualIP
    EndIf
    Return SetError(2, 0, 0)
EndFunc   ;==>_LowMetricIP

Func CheckCPU($sComputer)
    $wbemFlagReturnImmediately = 0x10
    $wbemFlagForwardOnly = 0x20
    $colItems = ""
    $objWMIService = ObjGet("winmgmts:\\" & $sComputer & "\root\CIMV2")
    $colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_Processor", "WQL", $wbemFlagReturnImmediately + $wbemFlagForwardOnly)
    If IsObj($colItems) Then
        For $objItem In $colItems
            $CPUSpeed = $objItem.CurrentClockSpeed
        Next
    EndIf
    $colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_Processor", "WQL", $wbemFlagReturnImmediately + $wbemFlagForwardOnly)
    If IsObj($colItems) Then
        For $objItem In $colItems
            $Cores = $objItem.NumberOfLogicalProcessors
        Next
    Else
        $Cores = "Konnte nicht ermittelt werden."
    EndIf
    $colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_Processor", "WQL", $wbemFlagReturnImmediately + $wbemFlagForwardOnly)
    If IsObj($colItems) Then
        For $objItem In $colItems
            $Processors = $objItem.NumberOfCores
        Next
    Else
        $Processors = "Konnte nicht ermittelt werden."
    EndIf
    GUICtrlSetData($lProzessor, "Kerne: " & $Cores & @CRLF & "Prozessor"&"(en)"&": " & $Processors & " je " & Ceiling($CPUSpeed) / 1000 & " Ghz")
    ;Return "Kerne: " & $Cores & @CRLF & "Taktung: " & @CRLF & "Prozessor: " & $Processors & @CRLF & Ceiling($CPUSpeed) / 1000 & " Ghz"
EndFunc   ;==>CheckCPU

Func getOS($sComputer)
    $wbemFlagReturnImmediately = 0x10
    $wbemFlagForwardOnly = 0x20
    $colItems = ""
    $strComputer = $sComputer
    $objWMIService = ObjGet("winmgmts:\\" & $strComputer & "\root\CIMV2")
    $colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_OperatingSystem", "WQL", _
            $wbemFlagReturnImmediately + $wbemFlagForwardOnly)
    If IsObj($colItems) Then
        For $objItem In $colItems
            $OS = $objItem.Name
        Next
    EndIf
    GUICtrlSetData($lBetriebssystem, $OS)
    Return "OS: " & $OS
EndFunc   ;==>getOS

Func getSerialNumber($sComputer)
    $wbemFlagReturnImmediately = 0x10
    $wbemFlagForwardOnly = 0x20
    $colItems = ""
    $strComputer = $sComputer

    $Output = ""
    $Output = $Output & "Computer: " & $strComputer & @CRLF
    $Output = $Output & "==========================================" & @CRLF
;~     $objWMIService = ObjGet("winmgmts:\\" & $strComputer & "\root\CIMV2")
    $objWMIService = ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & $strComputer & "\root\cimv2")

    $aBIOS = $objWMIService.ExecQuery("Select * from Win32_BIOS")
    For $element In $aBIOS
        $SerialNumber = $element.SerialNumber
    Next
    GUICtrlSetData($lSerialNumber, $SerialNumber)
    Return "Seriennummer: " & $SerialNumber
EndFunc   ;==>getSerialNumber

Func Modell($sComputer)
    $strComputer = $sComputer
    $aComputer = ObjGet("winmgmts:\\" & $strComputer & "\root\CIMV2").ExecQuery("SELECT Model FROM Win32_ComputerSystem", "WQL", 0).ItemIndex(0).Model
    GUICtrlSetData($lModell, $aComputer)
    Return "Modell: " & $aComputer
EndFunc   ;==>Abutze

Func Hersteller($sComputer)
    local $iHours, $iMins, $iSecs
    $strComputer = $sComputer
    $sHersteller = ObjGet("winmgmts:\\" & $strComputer & "\root\CIMV2").ExecQuery("Select Name, Manufacturer, Model from Win32_ComputerSystem", "WQL", 0).ItemIndex(0).Manufacturer
    GUICtrlSetData($lHersteller, $sHersteller)
    Global $iEnd = TimerDiff($start)

    Return "Hersteller: " & $sHersteller
EndFunc   ;==>Hersteller


Func __WMIDateStringToDate($sBootup)
    Return StringLeft($sBootup, 4) & "/" & StringMid($sBootup, 5, 2) & "/" & StringMid($sBootup, 7, 2) & " " & StringMid($sBootup, 9, 2) & ":" & StringMid($sBootup, 11, 2) & ":" & StringMid($sBootup, 13, 2)
EndFunc   ;==>__WMIDateStringToDate

Func __FormatUptime($sLastBootupTime)
    Local $aDateDiffs = [[0, 24, " day"], [0, 60, " hour"], [0, 60, " minute"], [0, 1, " second"]]
    Local $aDateDiff = StringSplit("D|h|n|s", "|")
    Local $sNow = _NowCalc()
    For $sDiff = 1 To $aDateDiff[0]
        $aDateDiffs[$sDiff - 1][0] = _DateDiff($aDateDiff[$sDiff], $sLastBootupTime, $sNow)
    Next
    Local $iUbound = UBound($aDateDiffs) - 1
    For $iX = $iUbound To 0 Step -1
        If $iX > 0 Then
            If $aDateDiffs[$iX - 1][0] > 0 Then $aDateDiffs[$iX][0] = ($aDateDiffs[$iX][0] - ($aDateDiffs[$iX - 1][0] * $aDateDiffs[$iX - 1][1]))
        EndIf
    Next
    Local $sUpTime = ""
    For $iX = 0 To $iUbound
        If $aDateDiffs[$iX][0] > 0 Then
            $sUpTime &= $aDateDiffs[$iX][0] & $aDateDiffs[$iX][2]
            If $aDateDiffs[$iX][0] > 1 Then $sUpTime &= "s"
            If $iX < $iUbound Then $sUpTime &= ", "
        EndIf
    Next
    GUICtrlSetData($lUptime, $sUpTime)
    Return $sUpTime
EndFunc   ;==>__FormatUptime

Alles anzeigen

Lashandan

Ich nehme alles zurück.

Trivialer Fehler meinerseits.

Wir nutzen verschiedene Netze und ein Wechsel ins freie Netzt ließ mich die Datei sauber laden und dann auch erfolgreich installieren.

Jetzt gehts ans Testen

Lashandan

Zitat von Musashi

Hi Lashandan

Ich habe es nur ganz kurz überflogen, nicht getestet :

1. Statt :

ShellExecute($sExe, $sString & " " & $start)

Sleep(1000)

könnest Du :

ShellExecuteWait... verwenden.

2. Func Aufruf() :

-> Niemals Global Deklarationen in einer Funktion verwenden.

Gruß Musashi

Alles anzeigen

Hi @Musashi

Ich möchte ja, dass sich mehrere Instanzen gleichzeitig starten und nicht das aufeinander gewartet wird, bis die andere fertig ist.

Dann hätte ich mit ShellExecuteWait() nichts gekonnt.

Die globalen Deklarationen habe ich auf local geändert.

Das hätte mir schon vorher auffallen müssen

Danke dafür

Lashandan

BugFix

Habs jetzt durchdrungen und verstanden.

Aufrufskript:

C

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Change2CUI=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#include <Array.au3>
#include <AutoITConstants.au3>
#include <MsgBoxConstants.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>

Global $ComputerList = @ScriptDir & "\computer.txt"
Local  $sExe = @ScriptDir & "\" & "Verarbeitungsprogramm.exe"

Aufruf()

Func Aufruf()
    $n = FileReadToArray($ComputerList)
    Global $cProzesse = InputBox("Instanzen", "Es sind " & Ubound($n) & " Einträge in " & $ComputerList & "." & @CRLF & "Wieviele Instanzen möchten Sie starten?" & @CRLF & _
                                                "1-Instanz: " & @TAB & Ceiling(Ubound($n) / 1) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "2-Instanzen: " & @TAB & Ceiling(Ubound($n) / 2) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "3-Instanzen: " & @TAB & Ceiling(Ubound($n) / 3) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "4-Instanzen: " & @TAB & Ceiling(Ubound($n) / 4) & @TAB  & " Durchläufe pro Instanz."& @CRLF & _
                                                "5-Instanzen: " & @TAB & Ceiling(Ubound($n) / 5) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "6-Instanzen: " & @TAB & Ceiling(Ubound($n) / 6) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "7-Instanzen: " & @TAB & Ceiling(Ubound($n) / 7) & @TAB  & " Durchläufe pro Instanz." & @CRLF & _
                                                "8-Instanzen: " & @TAB & Ceiling(Ubound($n) / 8) & @TAB  & " Durchläufe pro Instanz.", "Bitte eine Zahl eintragen", "", 350, 280, 850, 350)
    Global $i = Ceiling(Ubound($n) / $cProzesse)
    Global $sString = ''
    for $start = 1 to $cProzesse
        Local $sString = ''
        for $sStartIntervall = 1 to $i
            $sWorkString = FileReadLine($ComputerList, (($start*$i)-($i-$sStartIntervall)))
            if $sString <> '' Then
                $sString = $sString & ";"
            EndIf
            $sString = $sString & $sWorkString
        Next
        ShellExecute($sExe, $sString & " " & $start)
        Sleep(1000)
    Next
EndFunc   ;==>Aufruf

Alles anzeigen

Hier musste ich am Ende aber einen Sleep(1000) einbauen.

Denn sonst kloppen sich die jeweiligen Verarbeitungsprogramme um die Einträge und es kommt zu Fehlern in der Exportdatei.

Verarbeitungsprogramm:

C

#include <Array.au3>
#include <AutoITConstants.au3>
#include <WinHttp.au3>
#include <MsgBoxConstants.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>

If $CMDLINE[0] Then
;~     MsgBox(0,"", $CMDLINE[2])
    Local $sString = $CMDLINE[1]
    Local $run = StringSplit($sString, ";")
    for $i = 1 to Ubound($run) -1
        Local $sLogFileOS = @ScriptDir & "\" & "Arbeitsspeicher" & "_Stand_" & @YEAR & @MON & @MDAY & ".txt"

        Local $sError1 = $run[$i] & ";Error 1: " & ";Host ist Offline" & ";mit Instanz: " & $CMDLINE[2]  & @CRLF
        Local $sConsoleError1 = $run[$i]  & " Error 1: " & "Host ist Offline" & @CRLF

        Local $sError2 = $run[$i] & ";Error 2: " & ";Host nicht erreichbar" & ";mit Instanz: " & $CMDLINE[2] & @CRLF
        Local $sConsoleError2 = $run[$i]  & " Error 2: " & "Host nicht erreichbar" & @CRLF

        Local $sError3 = $run[$i] & ";Error 3: " & ";Bad destination" & ";mit Instanz: " & $CMDLINE[2] & @CRLF
        Local $sConsoleError3 = $run[$i]  & " Error 3: " & "Bad destination" & @CRLF

        Local $sError4 = $run[$i] & ";Error 4: " & ";Kein Zugriff" & ";mit Instanz: " & $CMDLINE[2] & @CRLF
        Local $sConsoleError4 = $run[$i]  & " Error 4: " & "Kein Zugriff" & @CRLF

    ;~     MsgBox(0, "", $CMDLINE[$i])
        ConsoleWrite("Abfrage startet..." & @CRLF)
        $ping = Ping($run[$i], 500)
        $mem = ''
        Switch @error
        Case 1
;~              MsgBox(64, @error, "Host is offline")
            Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
             FileWriteLine($hOpenLFileOS, $sError1)
             ConsoleWrite($sConsoleError1)
            FileClose($hOpenLFileOS)
        Case 2
    ;~         ;MsgBox(64, @error, "Host is unreachable")
            Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
             FileWriteLine($hOpenLFileOS, $sError2)
             ConsoleWrite($sConsoleError2)
            FileClose($hOpenLFileOS)
        Case 3
    ;~         ;MsgBox(64, @error, "Bad destination")
            Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
            FileWriteLine($hOpenLFileOS, $sError3)
             ConsoleWrite($sConsoleError3)
            FileClose($hOpenLFileOS)
        Case 4
    ;~         ;MsgBox(64, @error, "Other errors")
            Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
             FileWriteLine($hOpenLFileOS, $sError4)
             ConsoleWrite($sConsoleError4)
            FileClose($hOpenLFileOS)
        Case Else
            ConsoleWrite($run[$i] & " Ping: " & $ping & @CRLF)
            $objWMIService = ObjGet("winmgmts:{impersonationLevel = impersonate}!\\" & $run[$i] & "\root\cimv2")
            If IsObj($objWMIService) Then
                $colItems = $objWMIService.ExecQuery("Select Capacity from Win32_PhysicalMemory", "WQL", 0x30)
                For $objItem In $colItems
                    $mem += $objItem.Capacity
                Next
;~                 MsgBox(0,"", Round($mem / 1024 ^3, 2) & " GB" & @CRLF)
                ConsoleWrite($run[$i] & " Arbeitsspeicher: " & Round($mem / 1024 ^3, 2) & " GB" & @CRLF)
                Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
                FileWriteLine($hOpenLFileOS, $run[$i] & ";Arbeitsspeicher: " & Round($mem / 1024 ^3, 2) & " GB" & ";mit Instanz: " & $CMDLINE[2] & @CRLF)
                FileClose($hOpenLFileOS)
            Else
                ConsoleWrite($run[$i] & " Rechner nicht ABFRAGBAR" & @CRLF)
                Local $hOpenLFileOS = FileOpen($sLogFileOS, $FO_Append)
                FileWriteLine($hOpenLFileOS, $run[$i] & ";Rechner nicht ABFRAGBAR" & ";mit Instanz: " & $CMDLINE[2] & @CRLF)
                FileClose($hOpenLFileOS)
            EndIf
        EndSwitch
    Next
    ConsoleWrite("Abfrage ende!" & @CRLF)
EndIf

Alles anzeigen

Lashandan

BugFix

Vielen Dank für das Aufrufskript.

Ich stehe aber grade irgendwie im Wald.

Aus dem Aufrufskript werden die Parameter ausgegeben.

Wie binde ich diese nun korrekt in die kompilierte work.exe ein?

Im Verarbeitungsskript muss ich diese Paramter ja bekannt geben bzw. mit ihnen in der Funktion arbeiten.

Leider verstehe ich das nicht so ganz.

Lashandan

BugFix vielen Dank für deine schnelle Unterstützung

Folgendes habe ich bis jetzt.

Code

Func Aufruf()

Global $cProzesse = InputBox("Instanzen", "Wie viele Instanzen möchten Sie starten?", "Bitte eine Zahl eintragen", "", 250, 250, 850, 350)
$n = FileReadToArray($ComputerList)
Global $i = Ubound($n) / $cProzesse

for $start = 1 to $cProzesse
;~ Local $sString = ''
for $sStartIntervall = 1 to $i
$sWorkString = FileReadLine($ComputerList, (($start*$i)-($i-$sStartIntervall)))
if $sString <> '' Then
$sString = $sString & ";"
EndIf
$sString = $sString & $sWorkString
Next



MsgBox(0, "", $sString)
Next
;~ Return $sString
EndFunc ;==>Aufruf

Alles anzeigen

Als nächstes möchte ich das Verarbeitungsskript erstellen.

Wie übergebe ich den String richtig, sodass das Verarbeitungsskript diesen Zeile für Zeile verarbeitet?

Beiträge von Lashandan

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

Abfrageergebnisse in Datei/Datenbank schreiben/lesen

XML selectSingleNode

XML selectSingleNode

XML selectSingleNode

Progressbar Problem

Progressbar Problem

ISN AutoIt Studio

Eine Funktion mehrfach starten

Eine Funktion mehrfach starten

Eine Funktion mehrfach starten

Eine Funktion mehrfach starten