Neues Thema starten

TSE Export und Archivieren

 Hallo,

das Beispielprogramm ist wirklich extrem hilfreich.
Für die Export und Archivierungsaufgaben als TARball sind ja leider keine Programmteile/ beispiele zu sehen. Auch die html Doku gibt da wenig her. Wird es da noch etwas geben oder habe ich das nur übersehen?


Vielen Dank

Stefan


3 Personen haben diese Frage

Ich schliesse mich dem Vorredner an.
Insbesondere würden mich die C# DllImports für die Funktionen und das Callback interessieren.

ich füge mal was ein, bekomme aber einen AccessViolation Error im letzten Block:

Snippet

public delegate uint WormExportTarCallback(IntPtr chunk, int chunkLength, ref IntPtr callbackData);
 
[DllImport("WormAPI.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
private static extern int worm_export_tar(IntPtr context, WormExportTarCallback callback, IntPtr callbackData);


Snippet
 using (fs = File.Create("C:\\temp\\test.tar"))
 {
 
 int result = worm_export_tar(worm_context, MyWormExportTarCallback, Ptr);
 if (result != 0)
 {
 }
 }
 
}
 
 
public uint MyWormExportTarCallback(IntPtr chunk, int chunkLength, ref IntPtr callbackData)
{
 
 byte[] array = new byte[chunkLength];
 Marshal.Copy(chunk, array, 0, chunkLength);
 
 fs.Write(array, 0, chunkLength);
 
 //string s = System.Text.Encoding.ASCII.GetString(array, 0, array.Length);
 
 
 
 return 0;
}
vielleicht kann das ja mal jemand ausprobieren.

1 Person gefällt dies

Hallo,

Dein Snippet habe ich nach vb.net übersetzt und es wird eine TAR Datei erstellt (hängt an).
Nun ist die TSE so gut wie leer und ich kann nicht sagen wie es aussieht wenn die voll ist. Ist mein erster Callback...und muss erstmal verstehen wie das funktioniert. Also 1000 Dank für das snippet


Ich habe ein Modul mit den Wormklassen. Im WormAccess habe ich die Deklaration


Public fs As IO.FileStream

Public Delegate Function WormExportTarCallback(ByVal chunk As IntPtr, ByVal chunkLength As Integer, ByRef callbackData As IntPtr) As UInteger

 <DllImport("WormAPI.dll", CallingConvention:=CallingConvention.Cdecl, CharSet:=CharSet.Ansi)>
Private Shared Function worm_export_tar(ByVal context As IntPtr, ByVal callback As WormExportTarCallback, ByVal callbackData As IntPtr) As Integer
End Function


Ebenfalls als Member von WormAccess

Public Function TarStart() As Int32
    Dim ptr As IntPtr
    Dim result As Integer = worm_export_tar(worm_context, AddressOf MyWormExportTarCallback, ptr)
    If result <> 0 Then
       '??? ToDo
   End If
   Return result
End Function

Private Function MyWormExportTarCallback(ByVal chunk As IntPtr, ByVal chunkLength As Integer, ByRef callbackData As IntPtr) As UInteger
    Dim array As Byte() = New Byte(chunkLength - 1) {}
    Marshal.Copy(chunk, array, 0, chunkLength)
    fs.Write(array, 0, chunkLength)
    'TODO
    Return 0
 End Function


Der Aufruf dann zum Test per Button. Referenz auf WormAccess muss vorhanden sein, hier myWorm

myWorm.fs = IO.File.Create("C:\Temp\xyz.tar")
myWorm.TarStart()
myWorm.fs.Close()


Gruß Stefan


ps. könnte etwas mehr los sein im Forum




tar
(31 KB)

1 Person gefällt dies

Ich hänge leider genau an der gleichen Stelle (allerdings in der VB.NET-Varainte) mit AccessViolation-Error  beim Aufruf von worm_eport_tar.

Wer hat dieses Problem bereits lösen können?

hier mein aktueller Code, sowohl für Tar als auch automatisch gleich als ZIP. Es wird eine Variable ulong mTSEExportSize verwendet. Somit gibt es keine Exception mehr am Ende.


Snippet

/// <summary>
 /// exportiere die Daten der TSE in eine TAR-Datei
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportTAR(string Filename)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 
 try
 {
 File.Delete(Filename);
 }
 catch (Exception)
 {
 }
 
 mTSEExportSize = Info.TarExportSize;
 if (mTSEExportSize > 0)
 {
 try
 {
 using (mTSETarExport = File.Create(Filename))
 {
 
 result = worm_export_tar(worm_context, MyWormExportTarCallback, Ptr);
 }
 mTSETarExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 return result;
 }
 
 /// <summary>
 /// exportiere die Daten der TSE in eine ZIP-Datei, die diese TAR-Datei enthält
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportZIP(string Filename)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 
 try
 {
 File.Delete(Filename);
 }
 catch (Exception)
 {
 }
 
 mTSEExportSize = Info.TarExportSize;
 if (mTSEExportSize > 0)
 {
 try
 {
 using (var memoryStream = new MemoryStream())
 {
 
 using (var archive = new System.IO.Compression.ZipArchive(memoryStream, ZipArchiveMode.Create, true))
 {
 var demoFile = archive.CreateEntry("tse.tar");
 
 using (var entryStream = demoFile.Open())
 {
 mTSEZIPExport = new BinaryWriter(entryStream);
 result = worm_export_tar(worm_context, MyWormExportTarCallbackZipped, Ptr);
 mTSEZIPExport.Close();
 mTSEZIPExport.Dispose();
 }
 }
 
 // und speichern
 using (var fileStream = new FileStream(Filename, FileMode.Create))
 {
 memoryStream.Position = 0;
 memoryStream.WriteTo(fileStream);
 }
 }
 mTSEZIPExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 return result;
 }
 
 /// <summary>
 /// exportiere die Daten der TSE in eine ZIP-Datei, die diese TAR-Datei enthält
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportZIPByteStream(out byte[] byteSteam)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 mTSEExportSize = Info.TarExportSize;
 byteSteam = new byte[0];
 
 if (mTSEExportSize > 0)
 {
 try
 {
 using (var memoryStream = new MemoryStream())
 {
 using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
 {
 var demoFile = archive.CreateEntry("tse.tar");
 
 using (var entryStream = demoFile.Open())
 {
 mTSEZIPExport = new BinaryWriter(entryStream);
 result = worm_export_tar(worm_context, MyWormExportTarCallbackZipped, Ptr);
 mTSEZIPExport.Close();
 mTSEZIPExport.Dispose();
 }
 }
 
 byteSteam = memoryStream.ToArray();
 }
 
 mTSEZIPExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 
 return result;
 }
 
 /// <summary>
 /// Callback für den TAR Export
 /// </summary>
 /// <param name="chunk"></param>
 /// <param name="chunkLength"></param>
 /// <param name="callbackData"></param>
 /// <returns></returns>
 public int MyWormExportTarCallback(IntPtr chunk, uint chunkLength, IntPtr callbackData)
 {
 int Len = (int)chunkLength;
 if (mTSEExportSize < chunkLength)
 Len = (int)mTSEExportSize;
 
 byte[] array = new byte[Len];
 Marshal.Copy(chunk, array, 0, Len);
 
 mTSETarExport.Write(array, 0, Len);
 mTSEExportSize -= (UInt64)Len;
 
 if (mTSEExportSize == 0)
 mTSETarExport.Close();
 return 0;
 }
 
 
 /// <summary>
 /// Callback für den ZIP/TAR Export (anderes File-Objekt)
 /// </summary>
 /// <param name="chunk"></param>
 /// <param name="chunkLength"></param>
 /// <param name="callbackData"></param>
 /// <returns></returns>
 public int MyWormExportTarCallbackZipped(IntPtr chunk, uint chunkLength, IntPtr callbackData)
 {
 int Len = (int)chunkLength;
 if (mTSEExportSize < chunkLength)
 Len = (int)mTSEExportSize;
 
 
 byte[] array = new byte[Len];
 Marshal.Copy(chunk, array, 0, Len);
 
 mTSEZIPExport.Write(array, 0, Len);
 mTSEExportSize -= (UInt64)Len;
 
 if (mTSEExportSize == 0)
 mTSEZIPExport.Close();
 return 0;
 }
 

1 Person gefällt dies

Danke schön!!

Ich habe das Problem heute morgen auch gelöst, jedoch ungezippt.

Allerdings weicht gelegentlich meine Größe der exportierten Daten (mehr Bytes) von der Größe der zu expotierenden Daten ab. Aber auch das werde ich noch lösen.

worm_export_tar funktioniert nun bei mir; die exportieret TAR-Datei läßt sich mit WINZIP auch entpacken.

Das Ergebnis sind eine Reihe von Log-Dateien. Sie haben allerdings alle eine "falsche" Uhrzeit?!

Die Uhrzeit der Dateien ist 2 Stunden später als die mit worm_transaction_response_logtime zurück gegebene! Also Logteime: 10:08  Log-Datei-Time: 12:08?


Bei den ausgepackten Log-Dateien kann man zwar beim Vorgangstyp "Bestellung" alle Bestelldaten in Klartext lesen aber beim Vorgangstyp "Kassenbeleg" sieht man nicht die Bezahldaten.


Hat jemand für das erste Problem eine Erklärung?

Gibt es ein "Hilfsprogramm" mit dem man entwede die TAR-Datei in Klartext lesen kann oder die einzelnen Log-Dateien. Wie wird dan die Finanzbehörde die Dateien auswerten?

Die Funktion worm_transaction_response_logtime liefert die Uhrzeit in UnixTime zurück. Also die Zeit UTC also aktuell in Deutschland -2 Stunden. Das ist an sich korrekt. Deshalb ist bei unseren Kassenbons auch die Start/Stop Zeit der TSE Zeit 2 Stunden "früher". Die Tar Datei wird von der WormAPI.dll sicher unter Lokaler Zeit erstellt. Also das sollte so passen und ist bei mir auch so.


Dein zweites Problem kann ich nichz nachvollziehen. Die ProcessData sind in den Logs lesbar....


VG



zip
(993 Bytes)

Hallo Michael Wetterhahn,

ich habe inzwischen einen Visualisierer für die exportierten Tar-Dateien geschrieben. Dieser verifiziert auch die erzeugten Signaturen. Wenn Sie mir also Ihre Tar-Datei zukommen lassen, kann ich Ihnen die Daten visualisieren, sowie die Signaturen prüfen (processType und procssData sind TLV-codiert und damit nur bedingt lesbar).

Übrigens: alle Zeitangaben der TSE sind in Unix-TimeStamps, also Sekunden seit dem 1.1.1970 und werden in UTC angegeben. Auch die Funktion "worm_transaction_response_logTime" liefert einen solchen UTC-TimeStamp. Man muß diese Zeiten also (wie Matthias Wasserzier schon schrieb) immer in die lokale Uhrzeit wandeln, bevor man sie anzeigt. WinZip übernimmt das automatisch für den Anwender, dadurch entsteht die scheinbare Differenz.

Viele Grüße
U. Kleinert


Anmelden oder Registrieren um einen Kommentar zu veröffentlichen