nicer log

DakotaSender/DakotaSystemFile.cs

@@ -14,7 +14,10 @@ namespace DakotaSender
         public string Datenannahmestelle { get; set; }
         public string Transfernummer { get; set; }
 
-        public FileInfo Auftragsdatei { get; set; }
-        public FileInfo Nutzdatendatei { get; set; }
+        public FileInfo SourceAuftragsdatei { get; set; }
+        public FileInfo SourceNutzdatendatei { get; set; }
+
+        public FileInfo DestinationAuftragsdatei { get; set; }
+        public FileInfo DestinationNutzdatendatei { get; set; }
     }
 }

DakotaSender/Program.cs

@@ -17,6 +17,8 @@ namespace DakotaSender
         static int[] AcceptStatusCodes = new int[] { 0 };
         static int[] AcceptSendCodes = new int[] { 0 };
 
+        static bool time_in_line = false;
+
         static void Main(string[] args)
         {
             FileStream filestream = new FileStream(GetLogPath(), FileMode.Append);
@@ -36,7 +38,7 @@ namespace DakotaSender
             }
             catch (Exception e)
             {
-                Console.WriteLine(e.ToString());
+                PrintLine(e.ToString());
             }
 
             PrintEnd();
@@ -44,27 +46,46 @@ namespace DakotaSender
 
         static void PrintTitle()
         {
-            Console.WriteLine();
-            Console.WriteLine("-------------------");
-            Console.WriteLine("Dakota Sender Modul");
-            Console.WriteLine(DateTime.Now.ToLocalTime());
-            Console.WriteLine("-------------------");
+            PrintLine();
+            PrintLine("-------------------");
+            PrintLine("Dakota Sender Modul");
+            PrintLine("-------------------");
         }
         static void PrintEnd()
         {
-            Console.WriteLine("Ende");
-            Console.WriteLine("-------------------");
+            PrintLine("Ende");
+            PrintLine("-------------------");
+        }
+
+        static void PrintLine(string line = null)
+        {
+            PrintWithTime(line + "\n", !time_in_line);
+
+            time_in_line = false;
+        }
+        static void Print(string line)
+        {
+            PrintWithTime(line, !time_in_line);
+
+            time_in_line = true;
+        }
+        static void PrintWithTime(string line, bool showTime)
+        {
+            if (showTime)
+                Console.Write($"[{DateTime.Now:dd.MM.yy HH:mm:ss.fff}] {line}");
+            else
+                Console.Write(line);
         }
 
         static void CheckDakotaStatus()
         {
-            Console.WriteLine("Überprüfe Dakota Status");
+            PrintLine("Überprüfe Dakota Status");
 
             var code = ExecuteDakota("-s");
 
             if (AcceptStatusCodes.Contains(code))
             {
-                Console.WriteLine("Ok");
+                PrintLine("Ok");
             }
             else
             {
@@ -73,13 +94,13 @@ namespace DakotaSender
         }
         static void ProcessFiles()
         {
-            Console.WriteLine("Scanne Dakota Dateien");
+            PrintLine("Scanne Dakota Dateien");
 
             var toCheck = ScanQueueFolder();
 
             if (toCheck is null)
             {
-                Console.WriteLine("Keine Dakota Dateien gefunden.");
+                PrintLine("Keine Dakota Dateien gefunden.");
                 return;
             }
 
@@ -87,34 +108,37 @@ namespace DakotaSender
 
             if (!testCheck)
             {
-                Console.WriteLine($"Keine Dakota Dateien für {TEST_TENANT} gefunden.");
+                PrintLine($"Keine Dakota Dateien für {TEST_TENANT} gefunden.");
                 return;
             }
 
             foreach (var file in files)
             {
-                Console.WriteLine($"Verarbeite Datei: {file.Nutzdatendatei.Name}");
-                Console.WriteLine($"- Tenant: {file.Tenant}");
-                Console.WriteLine($"- Protokoll Oid: {file.ProtokollOid}");
-                Console.WriteLine($"- Datenannahmestelle: {file.Datenannahmestelle}");
-                Console.WriteLine($"- Uhrzeit: {DateTime.Now.ToLocalTime()}");
+                var protokoll_oid = file.ProtokollOid;
+
+                PrintLine($"Verarbeite Datei: {file.SourceNutzdatendatei.Name}");
+                PrintLine($"- Tenant: {file.Tenant}");
+                PrintLine($"- Protokoll Oid: {protokoll_oid}");
+                PrintLine($"- Datenannahmestelle: {file.Datenannahmestelle}");
 
                 CopyFile(file);
 
-                Console.WriteLine("Sende via Dakota.");
+                Print("Sende via Dakota. ");
 
                 var code = ExecuteDakota("-x");
 
                 if (AcceptSendCodes.Contains(code))
                 {
-                    Console.WriteLine($"Ok. ({DateTime.Now.ToLocalTime()})");
+                    PrintLine($"Ok.");
+
+                    DeleteSourceFile(file);
                 }
                 else
                 {
-                    throw new Exception($"Statuscode {code} wird nicht akzeptiert");
-                }
+                    PrintLine($"Verarbeitung fehlgeschlagen. Statuscode {code} wird nicht akzeptiert.");
 
-                DeleteFile(file);
+                    DeleteDestinationFile(file);
+                }
             }
         }
 
@@ -132,18 +156,21 @@ namespace DakotaSender
 
                 if (!nutz.Exists)
                 {
-                    Console.WriteLine($"{auft.FullName} wird ignoriert. {nutz.FullName} nicht vorhanden");
+                    PrintLine($"{auft.FullName} wird ignoriert. {nutz.FullName} nicht vorhanden");
                     continue;
                 }
 
-                Console.WriteLine($"{auft.FullName} gefunden.");
+                PrintLine($"{auft.FullName} gefunden.");
 
                 var split = nutz.Name.Split('_');
                 var tenant = split[0];
+                var p_oid = long.Parse(split[1]);
+                var datenannahmestelle = split[2];
+                var transfernummer = split[3];
 
                 if (tenant != TEST_TENANT && tenant != "demo")
                 {
-                    Console.WriteLine($"{auft.FullName} wird ignoriert. Tenant {tenant} nicht gültig.");
+                    PrintLine($"{auft.FullName} wird ignoriert. Tenant {tenant} nicht gültig.");
                     continue;
                 }
                 else
@@ -151,14 +178,21 @@ namespace DakotaSender
                     tenant = TEST_TENANT;
                 }
 
+                var destination = GetDakotaFolderDatenannahmestelle(datenannahmestelle).FullName;
+                var dest_file = Path.Combine(destination, transfernummer);
+                var dest_auft = new FileInfo(dest_file + ".auf");
+                var dest_nutz = new FileInfo(dest_file);
+
                 var file = new DakotaSystemFile()
                 {
-                    Auftragsdatei = auft,
-                    Nutzdatendatei = nutz,
+                    SourceAuftragsdatei = auft,
+                    SourceNutzdatendatei = nutz,
                     Tenant = tenant,
-                    ProtokollOid = long.Parse(split[1]),
-                    Datenannahmestelle = split[2],
-                    Transfernummer = split[3]
+                    ProtokollOid = p_oid,
+                    Datenannahmestelle = datenannahmestelle,
+                    Transfernummer = transfernummer,
+                    DestinationAuftragsdatei = dest_auft,
+                    DestinationNutzdatendatei = dest_nutz
                 };
 
                 if (!toCheck.ContainsKey(tenant))
@@ -169,38 +203,46 @@ namespace DakotaSender
 
             return toCheck.Any() ? toCheck : null;
         }
+
         static void CopyFile(DakotaSystemFile file)
         {
-            var transfernummer = file.Transfernummer;
-            var dest_folder = GetDakotaFolderDatenannahmestelle(file.Datenannahmestelle).FullName;
-            var sour_auftrags = file.Auftragsdatei.FullName;
-            var dest_auftrags = Path.Combine(dest_folder, transfernummer + ".auf");
-            var sour_nutz = file.Nutzdatendatei.FullName;
-            var dest_nutz = Path.Combine(dest_folder, transfernummer);
+            var sour_auftrags = file.SourceAuftragsdatei.FullName;
+            var dest_auftrags = file.DestinationAuftragsdatei.FullName;
+            var sour_nutz = file.SourceNutzdatendatei.FullName;
+            var dest_nutz = file.DestinationNutzdatendatei.FullName;
 
-            Console.Write($"Kopiere \"{sour_auftrags}\" nach \"{dest_auftrags}\". ");
+            Print($"Kopiere \"{sour_auftrags}\" nach \"{dest_auftrags}\". ");
 
             File.Copy(sour_auftrags, dest_auftrags);
 
-            Console.WriteLine("Ok.");
+            PrintLine("Ok.");
 
-            Console.Write($"Kopiere \"{sour_nutz}\" nach \"{dest_nutz}\". ");
+            Print($"Kopiere \"{sour_nutz}\" nach \"{dest_nutz}\". ");
 
             File.Copy(sour_nutz, dest_nutz);
 
-            Console.WriteLine("Ok.");
+            PrintLine("Ok.");
         }
-        static void DeleteFile(DakotaSystemFile file)
+        static void DeleteSourceFile(DakotaSystemFile file)
         {
-            File.Delete(file.Auftragsdatei.FullName);
-            File.Delete(file.Nutzdatendatei.FullName);
+            PrintLine($"Lösche {file.SourceAuftragsdatei.FullName}.");
+            File.Delete(file.SourceAuftragsdatei.FullName);
+            PrintLine($"Lösche {file.SourceNutzdatendatei.FullName}.");
+            File.Delete(file.SourceNutzdatendatei.FullName);
+        }
+        static void DeleteDestinationFile(DakotaSystemFile file)
+        {
+            PrintLine($"Lösche {file.DestinationAuftragsdatei.FullName}.");
+            File.Delete(file.DestinationAuftragsdatei.FullName);
+            PrintLine($"Lösche {file.DestinationNutzdatendatei.FullName}.");
+            File.Delete(file.DestinationNutzdatendatei.FullName);
         }
 
         static int ExecuteDakota(string arg)
         {
             var fileinfo = GetDakotaExe();
 
-            Console.WriteLine($"{fileinfo.Name} {arg} wird ausgeführt");
+            PrintLine($"{fileinfo.Name} {arg} wird ausgeführt");
 
             var process = Process.Start(GetDakotaExe().FullName, arg);
 
@@ -210,7 +252,7 @@ namespace DakotaSender
             {
                 var exitcode = process.ExitCode;
 
-                Console.WriteLine($"Returncode {exitcode}");
+                PrintLine($"Returncode {exitcode}");
 
                 return exitcode;
             }