Und noch was:
wofür der Parameter "storedTransactionNumbers" sein soll, sehe ich nicht. Mit dem Passiert rein gar nichts, obwohl die Funktion fehlerfrei läuft.
Moin,
die Definition und auch die Dokumentation sind korrekt. Der letzte Parameter ist kein Array, sondern ein Zeiger auf einen Int32-Wert. Aus der Doku:
@param[out] storedTransactionNumbers The amount of elements that were stored
in @p transactionNumbers. Might be less than @p transactionNumbersLength
if there are not enough started transactions.
Folgende Definition funktioniert:
type
WormContext = NativeUInt;
PWormContext = ^WormContext;
worm_uint = uint64;
worm_puint = ^worm_uint;
WormError = word;
//...
function worm_transaction_listStartedTransactions(
context : PWormContext; const clientId : PBytes; toSkip : int32;
transactionNumbers : worm_puint; transactionNumbersLength : int32;
storedTransactionNumbers : PInt32) : WormError; cdecl;
Hallo Daniel,
vielen Dank. Dass Du die Clients als PBytes definierst, hat mir bei worm-tse-listRegisteredClients schon mal geholfen (ich habe die jetzt programmweit als TBytes definiert und schon läufts).
Die listStartedTransactions nehme ich mir jetzt wieder vor und melde mich zurück.
Siehe https://support.gastro-mis.de/support/discussions/topics/36000015196
Hallo Daniel,
ich hab mir den PInt32 als ^Int32 definiert.
Jetzt bekomme ich was raus, aber was soll das sein? Es kommt sowas raus: -1073740920, selten auch ein Positiver Wert von 1073746824, immer dasselbe, egal wieviele Transaktionen ich hinzugefügt habe.
Es ist zumindest egal, ob ich stdcall oder Windows32 benutze, die beiden Werte sind immer die gleichen.
Wenn einmal der positive Wert kommt, ist es bei der nächsten Abfrage wieder der negative.
Ich bin momentan EOF :-)
Hans
Hallo zusammen,
noch ein Problem bei den Transactions:
Die Funktion
procedure worm_transaction_response_serialNumber(const response: IntPtr; out serialNumber: TBytes; out serialNumberLength: UInt64/UInt32); cdecl; external 'WormAPI.dll';
bringt eine Zugriffverletzung, aber nur bei der Transaktionsnummer 1 (also der zweiten). Dies auch nur bei den dll-Versionen stdcall und Windows32, Windows64 arbeitet ohne Fehler. Meine Kasse ist aber 32bit und diese Zugriffverletzung lässt sich nicht abfangen.
Das Ergebnis der response_serialNumber stimmt, hier der gesamte response der Transaktion 1:
neu: 1: 17.04.2019 16:19:29
Seriennummer der TSE: 89-0E-2E-44-87-1D-1B-C5-C7-7F-47-E6-C2-6E-25-D3-30-90-F4-DD-67-D9-84-10-C6-7E-CE-08-77-83-BD-0C
Signaturzähler der Transaktion: 3639
Signatur der Transaktion:
02E4176F4B6DE62D5AADA28E8219843184B3492C3B244F704155C0A67A93A266DA1E75FDD90296BB53DD0CB1219CA72871329B9E432DC025F4AA40FC4BA2BCAB5FDB8763DB16D100558EDCB54661A0F5FD42D188408DAB2346914ACBC808520A
Alle anderen response Abfragen arbeiten fehlerlos, sogar die worm_transaction_response_signature, die ja die gleiche Syntax hat.
Kann mir da irgendwer von Euch weiterhelfen?
Vielen Dank
Hans
Hallo Daniel,
wenn ich hier im Forum so lese, glaube ich manchmal, dass jeder hier ein Delphi von seinem eigenen Stern hat :). Ich arbeite mit 10.3.
Die Funktionsdefinition, die jetzt stabil mit jeder DLL läuft ist:
function worm_transaction_listStartedTransactions(Context: PIntPtr; const clientId: PAnsiChar; toSkip: Int32; out transactionNumbers: array of UInt64; out transactionNumbersLength: Int32; out storedTransactionNumbers: PInt32): WormError; cdecl; external 'WormAPI.dll';
Der Abruf läuft so:
procedure TForm2.getTRsButtonClick(Sender: TObject);
var
transactionNumbersLength, i: Int32;
storedTransactionNumbers: PInt32;
WE: WormError;
{$IFDEF stdcall}
AAI: array of UInt32;
{$ELSE}
AAI: array of UInt64;
{$ENDIF}
begin
WormTransactionStarted := True;
try
MemoNTR.Lines.Clear;
repeat
Application.ProcessMessages;
until not WormTimeSyncThreadWorking;
Setlength(AAI, 62);
try
WE := worm_transaction_listStartedTransactions(PWormContext, PWormClientId, 0, AAI, transactionNumbersLength, storedTransactionNumbers);
if WE = WORM_ERROR_NOERROR then
begin
MemoNTR.Lines.Add('Transaktionen erfolgreich gelesen');
if transactionNumbersLength > 0 then
MemoNTR.Lines.Add('transactionNumbersLength: ' + IntToStr(transactionNumbersLength){ + ' offene Transaktionen:'})
else
MemoNTR.Lines.Add('keine offenen Transaktionen gefunden');
for i := 0 to transactionNumbersLength - 1 do
MemoNTR.Lines.Add('Transaktionsnummer ' + IntToStr(AAI[i]));
if storedTransactionNumbers <> nil then
MemoNTR.Lines.Add('storedTransactionNumbers: ' + IntToStr(Int32(storedTransactionNumbers)))
else
MemoNTR.Lines.Add('storedTransactionNumbers: NIL')
end else
MemoNTR.Lines.Add('Fehler ' + writeWormError(WE) + ': Offene Transaktionen konnten nicht gelesen werden');
finally
Setlength(AAI, 0);
end;
finally
WormTransactionStarted := False;
end;
end;Das Ergebnis ist korrekt bis auf die storedTransactionNumbers:
Transaktionen erfolgreich gelesen transactionNumbersLength: 5 Transaktionsnummer 0 Transaktionsnummer 1 Transaktionsnummer 2 Transaktionsnummer 4 Transaktionsnummer 5 storedTransactionNumbers: NIL
Ich hatte zwar schon eine Konstellation, bei der die storedTransactionNumbers die Anzahl der offenen Transaktionen und die transactionNumbersLength die gesamte Anzahl an Transaktionen lieferte (also eigentlich auch verkehrt herum, und das auch nur nach einem vorhergehenden transaction_start), dafür war dann transactionNumbers NIL, und zwar immer dann, wenn diese wie bei Dir als Pointer to UInt.. definiert waren. Und die sind ja der Zweck der Übung.
Nur mit einem array für die transactionNumbers habe ich auch die offenen rausbekommen, dafür ist storedTransactionNumbers NIL.
Vielleicht kommt ja mal jemand drauf, was hier los ist und posted das auch.
Grüße
Hans
Hallo zusammen,
hat jemand schon eine Lösung?
Hier ist mein Quellcode und ich bekomme nur immer die Meldung offene Transaktionsnummer = 0.
Wenn ich den Client aber deRegistrieren möchte, sagt er mir offene Transaktionen vorhanden.
procedure Tglb_TSE.Btn_TransFreeClick(Sender: TObject);
var
i, j, k : Integer;
var_skip_int : Integer;
ptransactionNumbers : array of UInt64;
pstoredTransactionNumbers : PInt;
transactionNumbersLength : Integer = 0;
begin
var_Laufwerk_str := Field_Laufwerk.Text;
var_Lizenz_ID_str := Field_Lizenznr.Text;
var_Kassenanzahl_str := Field_Kassenanzahl.Text;
i := 1;
j := 0;
var_skip_int := 0;
Setlength(ptransactionNumbers, 62);
GetMem(pstoredTransactionNumbers, 1000);
for i := 1 to StrToInt(var_Kassenanzahl_str) do
begin
try
TSE_Error := TSE_worm_transaction_listStartedTransactions(pContext, PChar(TSE_Client_ID), var_skip_int, ptransactionNumbers, transactionNumbersLength, pstoredTransactionNumbers);
if (TSE_Error = WORM_ERROR_NOERROR) then
begin
Memo.Lines.Add('Transaktionen erfolgreich gelesen');
if transactionNumbersLength > 0 then
Memo.Lines.Add('transactionNumbersLength: ' + IntToStr(transactionNumbersLength){ + ' offene Transaktionen:'})
else
Memo.Lines.Add('keine offenen Transaktionen gefunden');
for j := 0 to transactionNumbersLength - 1 do
Memo.Lines.Add('Transaktionsnummer ' + IntToStr(ptransactionNumbers[j]));
if pstoredTransactionNumbers <> nil then
Memo.Lines.Add('storedTransactionNumbers: ' + IntToStr(pstoredTransactionNumbers^))
else
Memo.Lines.Add('storedTransactionNumbers: NIL')
end
else
Memo.Lines.Add('Fehler ' + PChar(IntToStr(Qword(Ord(TSE_Error)))) + ': Offene Transaktionen konnten nicht gelesen werden');
finally
Memo.Lines.Add('');
end;
end;
end;
Oder weiß vielleicht jemand wo hier der Fehler ist?
Danke
LHSoft
Hallo zusammen,
kann es sein, dass die Definition der Funktion falsch ist?
Die Definition ist laut API-Dokumentation
worm_transaction_listStartedTransactions(WormContext * context, const char * clientId, int toSkip, worm_uint * transactionNumbers, int transactionNumbersLength, int * storedTransactionNumbers)
mit
[in] context
[in] clientId
[in] toSkip
[out] transactionNumbers
[in] transactionNumbersLength
[out] storedTransactionNumbers
Wenn ich die Funktion in Delphi so wie in der Doku definiere, kommt nur ein Zugriffsfehler.
Allerdings bei
TWorm_transaction_listStartedTransactions = function(Context: IntPtr; const clientId: String; toSkip: Integer; transactionNumbers: array of Integer; out transactionNumbersLength: Integer; storedTransactionNumbers: array of Integer): Integer; stdcall;
läuft es richtig, WormError ist 0 und der transactionNumbersLength bringt mir die richtige Zahl der offenen Transaktionen, die auch in transactionNumbers richtig ausgegeben werden.
Also müsste der Parameter transactionNumbersLength ja mit OUT gekennzeichnet sein.
Ich verwende die neueste DLL version.
Weiß da jemand was? Kann mir das jemand bestätigen?
Hans
1 Person hat diese Frage