Beiträge von BugFix

**BugFix** · Vor 14 Stunden

Zitat von water

Kannst Du bitte kurz beschreiben, wofür Du einen Impressumgrabber brauchst

Hab ich mich auch schon gefragt.

Ich befürchte um Firmen mit ungewollter Werbung zuzuschei... Im Gegensatz zu Privatpersonen können sich Firmen leider nicht dagegen wehren. (Außer DNS-Attacke als Antwort )

**BugFix** · Freitag, 20:22

Zitat von Bitnugger

allerdings meckert VSCodium:

"message": 'setFocus' is declared but not used [XDeclaredButNotUsed]

Das hat mich auch gewundert.

Ich will grundsätzlich nichts ausschließen und halte es deshalb für möglich, dass diese proceure in den Tiefen der Includes doch schon existiert (aber dokumentiert habe ich es nicht gefunden). Somit wäre sie doppelt - und deshalb "nicht genutzt" ?

**BugFix** · Donnerstag, 19:14

Die Funktion hatte ich schmerzlich vermisst. Deshalb habe ich sie mir erstellt.

Nim

# compile: nim c --app:gui testfocus.nim


include winim/[inc\winuser]
import wNim/[wApp, wFrame, wPanel, wListBox, wTextCtrl]


# sets the focus to passed handle
# required: include winim/[inc\winuser]
proc setFocus(hwnd: HWND): WINBOOL {.discardable, stdcall, dynlib: "user32", importc: "SetFocus".}


let 
  app = App()
  frame = Frame(title="Test Focus",size=(400,250))
  panel = frame.Panel()
  lb = panel.ListBox(style=wLbNeededScroll or wLbNoSel)
  tc = panel.TextCtrl(style=wBorderSunken)


for e in @["Eintrag A","Eintrag B","Eintrag C","Eintrag D"]:
  lb.append(e)


# Fokus liegt jetzt auf: lb
# setzen auf: tc
tc.setFocus()


proc layout() =
  panel.layout:
    lb:
      left = 10
      top = 30
      width = 120
      height = 100
    tc:
      left = 20
      top = lb.bottom + 20
      width = 80
      height = 20


frame.wIdExit do ():
  frame.delete()


layout()
frame.center()
frame.show()
app.mainLoop()

Alles anzeigen

**BugFix** · Mittwoch, 14:21

GELÖST

So, bin nun auf kleinem Umweg zum Ziel (Objekt) gelangt. Wobei ich hier nur die Fehlerinfos in das Objekt lade, die anderen Nodes sind ja direkt abfragbar.

Nim

import json


type
  oErrCode = object
    code: string 
    device: seq[JsonNode]
    name: string
    description: string
    reason: seq[JsonNode]
    disposal: seq[JsonNode]
    remark: string


let str_json =
  """
  {
    "title": "Test",
    "author": "BugFix",
    "articles": [
      {"number": "a123", "storage_location": "D-75"},
      {"number": "b456", "storage_location": "C-145"},
      {"number": "c789", "storage_location": "H-63"}
    ],
    "error_list": [
      {
        "code": "101",
        "device": ["dev A","dev B","dev C"],
        "name": "SensorErrBla",
        "description": "Sensorfehler",
        "reason": ["Mainboard defekt"],
        "disposal": ["Mainboard ersetzen"],
        "remark": ""
      },
      {
        "code": "101",
        "device": ["dev D","dev E","dev F"],
        "name": "SensorErrBlub",
        "description": "Sensorfehler",
        "reason": ["Mainboard defekt"],
        "disposal": ["Mainboard ersetzen"],
        "remark": ""
      },
      {
        "code": "102",
        "device": ["dev A","dev B","dev C"],
        "name": "BatteryErrBla",
        "description": "Akkufehler",
        "reason": ["Akku defekt","Controllerboard defekt"],
        "disposal": ["Akku erstzen","Controllerboard ersetzen"],
        "remark": ""
      },
      {
        "code": "102",
        "device": ["dev D","dev E","dev F"],
        "name": "BatteryErrBlub",
        "description": "Akkufehler",
        "reason": ["Akku defekt","Controllerboard defekt","Mainboard defekt"],
        "disposal": ["Akku erstzen","Controllerboard ersetzen","Mainboard ersetzen"],
        "remark": "Bei Akkutausch: Reset Nutzung im Wartungsmenü"
      }
    ]
  }
  """


let parsed_json = parseJson(str_json)


proc getErrCodes(jn: JsonNode, errcode = ""): seq[oErrCode] =
  var 
    s_errors = newSeq[oErrCode]()
    oErr: oErrCode
  let a_errlist = jn["error_list"].getElems()
  for err in a_errlist:
    if errcode == "" or (errcode != "" and errcode == err["code"].getStr()):
      oErr.code = err["code"].getStr()
      oErr.device = @(err["device"].getElems())
      oErr.name = err["name"].getStr()
      oErr.description = err["description"].getStr()
      oErr.reason = @(err["reason"].getElems())
      oErr.disposal = @(err["disposal"].getElems())
      oErr.remark = err["remark"].getStr()
      s_errors.add(oErr)
  result = s_errors
  
let sError102 = getErrCodes(parsed_json, "102")


for oE in sError102:
  echo oE.code & ", " & oE.name
  echo oE.device
  echo "----------------------------------------"

Alles anzeigen

Code: Console

102, BatteryErrBla
@["dev A", "dev B", "dev C"]
----------------------------------------
102, BatteryErrBlub
@["dev D", "dev E", "dev F"]
----------------------------------------

**BugFix** · Mittwoch, 14:15

Zitat von Moombas

Ich meinte hier:

Das ist keine JSON-Datei, sondern nur die Struktur mit Kommentaren (die in JSON-Dateien ja nicht möglich sind).

**BugFix** · Mittwoch, 13:02

OK, ich löse das Problem nun anders. Die Verschachtelung der error_list konnte von der json Funktion nicht geparst werden, ich bekam ein Objekt mit einem leeren Array.

Somit habe ich das um eine Stufe "entschachtelt" und führe den Error-Code in jedem Error-List Objekt mit.

Nim

import json


let str_json =
  """
  {
    "title": "Test",
    "author": "BugFix",
    "articles": [
      {"number": "a123", "storage_location": "D-75"},
      {"number": "b456", "storage_location": "C-145"},
      {"number": "c789", "storage_location": "H-63"}
    ],
    "error_list": [
      {
        "code": "101",
        "device": ["dev A","dev B","dev C"],
        "name": "SensorErrBla",
        "description": "Sensorfehler",
        "reason": ["Mainboard defekt"],
        "disposal": ["Mainboard ersetzen"],
        "remark": ""
      },
      {
        "code": "101",
        "device": ["dev D","dev E","dev F"],
        "name": "SensorErrBlub",
        "description": "Sensorfehler",
        "reason": ["Mainboard defekt"],
        "disposal": ["Mainboard ersetzen"],
        "remark": ""
      },
      {
        "code": "102",
        "device": ["dev A","dev B","dev C"],
        "name": "BatteryErrBla",
        "description": "Akkufehler",
        "reason": ["Akku defekt","Controllerboard defekt"],
        "disposal": ["Akku erstzen","Controllerboard ersetzen"],
        "remark": ""
      },
      {
        "code": "102",
        "device": ["dev D","dev E","dev F"],
        "name": "BatteryErrBlub",
        "description": "Akkufehler",
        "reason": ["Akku defekt","Controllerboard defekt","Mainboard defekt"],
        "disposal": ["Akku erstzen","Controllerboard ersetzen","Mainboard ersetzen"],
        "remark": "Bei Akkutausch: Reset Nutzung im Wartungsmenü"
      }
    ]
  }
  """
let 
  parse_json = parseJson(str_json)
  a_errlist = parse_json["error_list"].getElems()


for e in a_errlist:
  if e["code"].getStr() == "102": echo e["name"].getStr(), ":   ", e["device"].getElems()

Alles anzeigen

**BugFix** · Mittwoch, 12:42

Zitat

Function _WinAPI_FileInUse

Tests whether the specified file in use by another application

#include <WinAPIFiles.au3>
_WinAPI_FileInUse ( $sFilePath )

Success: 1 - File in use by another application.

Failure: 0.

Alles anzeigen

**BugFix** · Mittwoch, 12:15

Zitat von Moombas

Fehlt dir in Zeile 18 deines Json strings nicht ein ","? Wobei das natürlich ein Copy/Paste Fehler sein kann, da du ja sicher mit anderen Daten arbeitest.

Kann sein, dass ich den Wald vor lauter Bäumen nicht sehe.

Zeile #18 des JSON ist doch Code-Zeile #43

43 ],

44 "error_list": {
45 "101": [

Da ist doch ein Komma. Oder wo meinst Du? Gib mal die Codezeile an oder kopiere die Zeile hier rein.

**BugFix** · 21. September 2022

EDIT #3: Lösung mit geänderter JSON-Struktur hier: Post #4

Lösung mit Überführung in Objekt hier: Post #7

Ich hatte hier auf meine JSON-Datei verwiesen.

Die Umsetzung in mein Projekt soll in Nim erfolgen.

Ich habe die Struktur der JSON-Datei mal heruntergebrochen auf ein Minimum:

Code

{
  "KEY": "Value-String",            "# Version"
  "KEY": "Value-String",            "# Creator"
  "KEY": [                          "# Source: ARRAY OBJEKTE - keine fixe Anzahl"
    {
      "KEY": "Value-String",        "# product-number"
      "KEY": "Value-String"         "# title"
    }        
  ],
  "KEY": {                                                "# error-list: OBJEKT"
      "KEY": [                                            "# error-code: ARRAY OBJEKTE - keine fixe Anzahl"
        {
          "KEY": ["Array Strings - keine fixe Anzahl"],   "# device"
          "KEY": "Value-String",                          "# name"
          "KEY": "Value-String",                          "# description"
          "KEY": ["Array Strings - keine fixe Anzahl"],   "# reason"
          "KEY": ["Array Strings - keine fixe Anzahl"],   "# disposal"
          "KEY": "Value-String"                           "# remark"
        }
      ]
  }
}

Alles anzeigen

Die Nim JSON Library bietet die Möglichkeit, die geparsten JSON-Daten in ein Objekt zu überführen.

Somit habe ich auf obiger Struktur aufbauend meine Datentypen erstellt.

Hier mal meine Testdatei mit minimalem JSON-Musterdatensatz:

Nim

import json
type 
  oSource = object
    product_number: string
    product_title: string
  oErrCode = object
    device: openArray[string]
    name: string
    description: string
    reason: openArray[string]
    disposal: openArray[string]
    remark: string
  oErrListItem = object
    code_number: string
    code_item: openArray[oErrCode]
  oErrList = object
    errors: openArray[oErrListItem]
  oError = object
    version: string
    craetor: string
    source: openArray[oSource]
    error_list: oErrList


let err_json = 
  """
  {
    "version": "2022-09",
    "creator": "BugFix",
    "source": [
      {
        "product_number": "XYZ 123ab",
        "product_title": "Servicemanual für Geräte des Typs A / B"
      },
      {
        "product_number": "XYZ 123c",
        "product_title": "Servicemanual für Geräte des Typs C"
      },
      {
        "product_number": "XYZ 123def",
        "product_title": "Servicemanual für Geräte des Typs D / E / F"
      }
    ],
    "error_list": {
      "101": [
        {
          "device": ["dev A","dev B","dev C"],
          "name": "SensorErrBla",
          "description": "Sensorfehler",
          "reason": ["Mainboard defekt"],
          "disposal": ["Mainboard ersetzen"],
          "remark": ""
        },
        {
          "device": ["dev D","dev E","dev F"],
          "name": "SensorErrBlub",
          "description": "Sensorfehler",
          "reason": ["Mainboard defekt"],
          "disposal": ["Mainboard ersetzen"],
          "remark": ""
        }
      ],
      "102": [
        {
          "device": ["dev A","dev B"],
          "name": "BatteryErrBla",
          "description": "Akkufehler",
          "reason": ["Akku defekt","Controllerboard defekt"],
          "disposal": ["Akku erstzen","Controllerboard ersetzen"],
          "remark": "Bei Akkutausch: Reset Nutzung im Wartungsmenü"
        },
        {
          "device": ["dev C"],
          "name": "BatteryErrBlub",
          "description": "Akkuladefehler",
          "reason": ["Controllerboard defekt"],
          "disposal": ["Controllerboard ersetzen"],
          "remark": ""
        },
        {
          "device": ["dev D","dev D],
          "name": "BatteryErrBlaBlub",
          "description": "Akkufehler",
          "reason": ["Akku defekt","Akku nicht vorhanden"],
          "disposal": ["Akku ersetzen","Akku einsetzen"],
          "remark": "Bei Akkutausch: Reset Nutzung im Wartungsmenü"
        }
      ]
    }
  }
  """  
  
let 
  obj_json = parseJson(err_json)        # JSON String parsen
  oErrorsJSON = to(obj_json, oError)    # JSON String in mein Objekt überführen


echo oErrorsJSON.creator

Alles anzeigen

Grundsätzlich ist die Überführung verschachtelteter Strukturen in ein Objekt möglich: Nim: How to parse nested JSON into objects

Im dortigen Bsp. sind jedoch alle Daten fix.

Ich habe jedoch in allen Arrays eine veränderliche Anzahl von Einträgen, deshalb die Nutzung von "openArray". Und hier liegt das Problem. Gleich beim ersten Auftauchen fliegt es mir um die Ohren:

Code

Error: type mismatch: got <openArray[oSource], JsonNode, string>
but expected one of:
proc initFromJson(dst: var JsonNode; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var JsonNode
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson(dst: var bool; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var bool
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson(dst: var string; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var string
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[S, T](dst: var array[S, T]; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var array[S, T]
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T: SomeFloat](dst: var T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var T: SomeFloat
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T: SomeInteger](dst: var T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var T: SomeInteger
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T: distinct](dst: var T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var T: distinct
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T: enum](dst: var T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var T: enum
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T: object | tuple](dst: var T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var T: object or tuple
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T](dst: var Option[T]; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var Option[initFromJson.T]
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T](dst: var OrderedTable[string, T]; jsonNode: JsonNode;
                    jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var OrderedTable[system.string, initFromJson.T]
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T](dst: var Table[string, T]; jsonNode: JsonNode;
                    jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var Table[system.string, initFromJson.T]
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T](dst: var ref T; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var ref T
  but expression 'dst.source' is of type: openArray[oSource]
proc initFromJson[T](dst: var seq[T]; jsonNode: JsonNode; jsonPath: var string)
  first type mismatch at position: 1
  required type for dst: var seq[T]
  but expression 'dst.source' is of type: openArray[oSource]

Alles anzeigen

In einem ersten Versuch hatte ich statt "openArray[string]" mit Sequences gearbeitet. Nur schlägt auch das fehl, weil der JSON-Parser wohl erkennt, wenn Daten in einem Array vorliegen und die Übernahme in eine Sequenz ablehnt. - Fehlermeldung (Compile) war in etwa: "Type is seq[string] but array found".

Wie komme ich nun am besten aus der Situation raus?

Momentan fiele mir nur ein: Statt "openArray" mit "array[string,FIXE-ZAHL]" zu arbeiten und alle Einträge in der JSON-Datei entsprechend mit Leerwerten auffüllen.

Also wenn ihr Ideen habt: Gern her damit.

EDIT:

OK, in der Beschreibung zur Funktion to steht es auch

Zitat

Known limitations:

Heterogeneous arrays are not supported.

Dann muss ich mich wohl doch von Node zu Node hangeln.

EDIT #2:

Hmm, ein weiteres Problem

Mit dem JSON-String aus obigem Code

Nim

let 
  obj_json = parseJson(err_json)        # JSON String parsen

echo obj_json["version"].getStr()

Führt zum Fehler bei der Ausführung:

Code

C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(931) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(847) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(806) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(806) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(815) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(806) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\json.nim(818) parseJson
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\parsejson.nim(526) eat
C:\Users\BugFix\scoop\apps\nim\1.2.0\lib\pure\parsejson.nim(522) raiseParseErr
Error: unhandled exception: input(36, 15) Error: ] expected [JsonParsingError]

Die Zeile, bevor der Error geworfen wird ist: eat(p, tkBracketRi)

Nach meinem Verständnis ein Fehler: Schließende Klammer nicht gefunden. Aber die Klammerzuordnung ist korrekt im JSON-String.

Großes

**BugFix** · 19. September 2022

Zitat von Kanashius

Es kommt zwar drauf an, wie viele Geräte du generell verwerwaltest,... Aber ich würde in Erwägung ziehen, die Infos nach Gerät zu speichern und dann ggf. alle durchiterieren, um die Geräte zu finden, die die Fehlermeldung haben.
Selbst wenn du 10000 Geräte hast dürfte das durchlaufen nicht lange dauern.

Der Hinweis ist grundsätzlich richtig. Ich hatte aber nicht erwähnt, dass es hier nur um Gerätetypen allgemein geht. Also nicht für jedes (mit Seriennnummer identifizierbare) Gerät werden Fehlercodes gespeichert, sondern nur über den Artikel als solchen. Und diese Anzahl ist bei uns überschaubar, so etwa 50-60 Artikel sind betroffen. Die Anzahl der relevanten Fehler ist bei etwa 30 - 40 pro Gerätetyp.

Ausschnitt JSON

Ich habe bei einigen Fehlercodes 2 max. 3 unterschiedliche Bedeutungen. Somit ist der Aufwand (s. Bsp.) auf 2 oder 3 Einträge begrenzt.

Eine Speicherung mit PrimärKey=Gerätetyp würde für jeden Eintrag aus dem Array "device" einen Eintrag erfordern mit allen anderen Angaben. Der obige Eintrag wäre dann doppelt so umfangreich und voll unnötiger Redundanzen.

Meiner Meinung nach ist die bisherige Variante für meinen Anwendungsfall passend.

Trotzdem Danke für die Investition deines Gehirnschmalzes.

**BugFix** · 19. September 2022

Zitat von AspirinJunkie

Ich rate daher einfach mal und schlage folgenden Aufbau vor:

Danke, du hast schon richtig erahnt wohin ich wollte. Ich hatte keine Vorstellung, wie ich die Codes platziere, da sie mehrfach auftreten können aber eigentlich ja als Key fungieren sollen.

**BugFix** · 19. September 2022

Ich möchte die Fehlerkataloge verschiedener Geräte in eine JSON-Datei überführen und damit eine Software füttern, mit der auch unsere Innendienstmitarbeiter telefonisch eine erste Diagnostik vornehmen können.

Meine Idee ist, dass der User den Fehlercode eingibt, Geräte die diesen Code verwenden angezeigt bekommt und dann für die weiteren Informationen das korrekte Gerät auswählt (bzw. dies im Dialog mit dem Kunden tut - das für den Fall, dass gerade kein Zugriff auf die Kundendaten möglich ist - z.B. tel. Notdienst).

Hier mal zwei fiktive Codes, die aber z.T. unterschiedliche Bedeutung haben können (je nach Gerät):

Code

Fehlercode: 108
Geräte: Device_A, Device_B, Device_C
Bezeichnung: ClockTimeError
Beschreibung: Fehler Echtzeituhr
Ursachen: Uhrzeit nicht gestellt, Batterie auf Mainboard leer, Mainboard defekt
Beseitigung: Uhrzeit stellen, Batterie auf Mainboard ersetzen, Mainboard ersetzen


Fehlercode: 108
Geräte: Device_D, Device_E
Bezeichnung: TemperatureError
Beschreibung: Fehler Temperatursensor
Ursachen: Sensor defekt oder nicht angeschlossen
Beseitigung: Sensor anschliessen oder ersetzen


Fehlercode: 333
Geräte: Device_A, Device_B, Device_C, Device_D, Device_E
Bezeichnung: LogBatteryError
Beschreibung: Fehler Log-Speicherbatterie
Ursachen: Spannung auf kritischen Wert gefallen
Beseitigung: Batterie ersetzen

Alles anzeigen

In JSON würde ich das jetzt so anlegen:

JSON

{
    "errorcode version": "0.0.1",
    "error list": [
        {
        "code": 108 [
                {
                "device": ["Device_A", "Device_B", "Device_C"],
                "name": "ClockTimeError",
                "description": "Fehler Echtzeituhr",
                "reason": ["Uhrzeit nicht gestellt", "Batterie auf Mainboard leer", "Mainboard defekt"],
                "disposal": ["Uhrzeit stellen", "Batterie auf Mainboard ersetzen", "Mainboard ersetzen"]
                },
                {
                "device": ["Device_D", "Device_E"],
                "name": "TemperatureError",
                "description": "Fehler Temperatursensor",
                "reason": "Sensor defekt oder nicht angeschlossen",
                "disposal": "Sensor anschliessen oder ersetzen"
                }
            ],
        "code": 333
            {
            "device": ["Device_A", "Device_B", "Device_C", "Device_D", "Device_E"],
            "name": "LogBatteryError",
            "description": "Fehler Log-Speicherbatterie",
            "reason": "Spannung auf kritischen Wert gefallen",
            "disposal": "Batterie ersetzen"
            }
        }
    ]
}

Alles anzeigen

Ist das in der Form korrekt?

**BugFix** · 15. September 2022

Vom Ablauf her sieht das ja soweit OK aus (ich weiß nur nicht, warum die Sleep darin sind).

Ich würde es etwas anders gestalten:

AutoIt

$sCmd = "C:\Program Files (x86)\Sage\Sage 100\8.1\Shared\OLStart.exe /APP ABF /EXCL /DB ACCDE /VER 8.1"
$sClasshWnd = "[CLASS:OFormPopup]"
$sClassInstCtrl = "[CLASS:OFormSub; INSTANCE:2]"

; Run OLStart.exe
$PID = Run($sCmd )
$hWnd = WinWait($sClasshWnd)
WinActivate($hWnd)
If WinWaitActive($hWnd, 30) Then ; Timeout 30 s
    ; Wait for 30 seconds. <<< bezieht sich dein warten auf "WinWaitActive"? - s. TimeOut-Parameter
    ;~ Sleep(30000)
    ControlSend($hWnd, "", $sClassInstCtrl, "{Enter}")
EndIf

Alles anzeigen

Wegen der Remote-Verbindung beachte das Edit in Post #4.

**BugFix** · 13. September 2022

Die Verwendung von Class/Instance ist auch immer der ID vorzuziehen, da diese bei vielen Programmen dynamisch generiert wird und dadurch bei jedem Programmstart differiert.

**BugFix** · 11. September 2022

Zitat von gert_nrw_71

Laut Doku ist FileSetPos auch nur mit einem filehandle einsetzbar ?

Das ist korrekt.

Aber warum zum Teufel willst du die Datei UNBEDINGT zum Lesen UND Schreiben öffnen?!

Dazu besteht doch keine Notwendigkeit, so wie du das umsetzt.

Also

1. sRead = FileRead(Dateipfad)

2. sRead manipulieren

3. hwnd = FileOpen(Dateipfad, Overwrite)

4. FileWrite(hwnd , manipulierte sRead)

5. FileClose(hwnd)

**BugFix** · 11. September 2022

Backslash, Asterisk, Fragezeichen, Größer, Kleiner sind alles "Magic Charakters" und deshalb im Pattern mit einem Backslash zu maskieren.

**BugFix** · 10. September 2022

Da du nur einen Lese- und einen Schreibvorgang hast, spar dir FileOpen und verwende einfach den Dateipfad für Read/Write. Dann hast auch keine Probleme mit den Flags.

Edit:

Das dein Text gelöscht wird, liegt daran, dass du im gemeinsamen Read/Write anders vorgehen musst.

Zitat

When reading and writing via the same file handle, the FileSetPos() function must be used to update the current file position.

**BugFix** · 10. September 2022

Zitat von gert_nrw_71

wie kann ich denn den geänderten HTML Code wieder abspeichern, das kriege ich irgendwie nicht hin ?

In deinem Kommentar steht zwar: Öffnen zum Lesen und Schreiben - Aber du tust es nicht. Du musst schon das Flag setzen.

**BugFix** · 7. September 2022

Zitat von water

Daher ist es für die "normale" Word find & replace nicht erreichbar.

Das ist schon klar. Mit "Suchen & Ersetzen" meinte ich schon eine auf das VBA Objekt bezogene, zu implementierende Funktion, die das übernimmt.

Ich wollte nur klarmachen:

Wenn ich sowieso ersetze, dann doch lieber mit Variablen statt Fixwerten.

**BugFix** · 7. September 2022

Zitat von bazii

Den Aufwand zu betreiben, die teilweise sehr aufwendigen Vorlagen neu aufzusetzen kann ich derzeit nicht leisten.

Aber wo ist der Unterschied, ob du per Suchen & Ersetzen einfügst:

Suche "Meier" Ersetze "Müller"

oder

Suche "Meier" Ersetze "INIRead(Inipfad, Chef)" - mit entsprechender VBA Umsetzung

Danach hast du alle Vorlagen dynamisch aktualisiert.

Beiträge von BugFix

Automatisierung eines Impressum-Grabbers

wNim - setFocus

wNim - setFocus

[gelöst] Nested JSON to Object

[gelöst] Nested JSON to Object

[gelöst] Nested JSON to Object

File in use / Überprüfung

[gelöst] Nested JSON to Object

[gelöst] Nested JSON to Object

Daten in JSON anlegen - Struktur korrekt?

Daten in JSON anlegen - Struktur korrekt?

Daten in JSON anlegen - Struktur korrekt?

automatisierter Programmstart

automatisierter Programmstart

mit AutoIt HTML Quellcodeseiten (.htm) modifizieren

Suche Hilfe - unzulässige Zeichen bei Dateinamen ersetzen - mit "StringRegExp" für ANFÄNGER!

mit AutoIt HTML Quellcodeseiten (.htm) modifizieren

mit AutoIt HTML Quellcodeseiten (.htm) modifizieren

Microsoft Word: Suche und ersetze Text in den Inhalten der VBA-Progammierung (gelöst)

Microsoft Word: Suche und ersetze Text in den Inhalten der VBA-Progammierung (gelöst)