BeWoPlaner/DakotaSender/Program.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DakotaSender
{
    class Program
    {
        static readonly string TEST_TENANT = "7375324044";

        static int[] AcceptStatusCodes = new int[] { 0 };
        static int[] AcceptSendCodes = new int[] { 0 };

        static void Main(string[] args)
        {
            FileStream filestream = new FileStream(GetLogPath(), FileMode.Append);
            var streamwriter = new StreamWriter(filestream);
            streamwriter.AutoFlush = true;

            Console.SetOut(streamwriter);
            Console.SetError(streamwriter);

            try
            {
                PrintTitle();

                CheckDakotaStatus();

                ProcessFiles();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }

            PrintEnd();
        }

        static void PrintTitle()
        {
            Console.WriteLine();
            Console.WriteLine("-------------------");
            Console.WriteLine("Dakota Sender Modul");
            Console.WriteLine(DateTime.Now.ToLocalTime());
            Console.WriteLine("-------------------");
        }
        static void PrintEnd()
        {
            Console.WriteLine("Ende");
            Console.WriteLine("-------------------");
        }

        static void CheckDakotaStatus()
        {
            Console.WriteLine("Überprüfe Dakota Status");

            var code = ExecuteDakota("-s");

            if (AcceptStatusCodes.Contains(code))
            {
                Console.WriteLine("Ok");
            }
            else
            {
                throw new Exception($"Statuscode {code} wird nicht akzeptiert");
            }
        }
        static void ProcessFiles()
        {
            Console.WriteLine("Scanne Dakota Dateien");

            var toCheck = ScanQueueFolder();

            if (toCheck is null)
            {
                Console.WriteLine("Keine Dakota Dateien gefunden.");
                return;
            }

            var testCheck = toCheck.TryGetValue(TEST_TENANT, out var files);

            if (!testCheck)
            {
                Console.WriteLine($"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()}");

                CopyFile(file);

                Console.WriteLine("Sende via Dakota.");

                var code = ExecuteDakota("-x");

                if (AcceptSendCodes.Contains(code))
                {
                    Console.WriteLine($"Ok. ({DateTime.Now.ToLocalTime()})");
                }
                else
                {
                    throw new Exception($"Statuscode {code} wird nicht akzeptiert");
                }

                DeleteFile(file);
            }
        }

        static Dictionary<string, List<DakotaSystemFile>> ScanQueueFolder()
        {
            var queue = GetQueueFolder();

            var files = queue.GetFiles("*.auf", SearchOption.TopDirectoryOnly);

            var toCheck = new Dictionary<string, List<DakotaSystemFile>>();
            foreach (var auft in files)
            {
                var nutz_fullname = auft.FullName.Substring(0, auft.FullName.Length - 4);
                var nutz = new FileInfo(nutz_fullname);

                if (!nutz.Exists)
                {
                    Console.WriteLine($"{auft.FullName} wird ignoriert. {nutz.FullName} nicht vorhanden");
                    continue;
                }

                Console.WriteLine($"{auft.FullName} gefunden.");

                var split = nutz.Name.Split('_');
                var tenant = split[0];

                if (tenant != TEST_TENANT && tenant != "demo")
                {
                    Console.WriteLine($"{auft.FullName} wird ignoriert. Tenant {tenant} nicht gültig.");
                    continue;
                }
                else
                {
                    tenant = TEST_TENANT;
                }

                var file = new DakotaSystemFile()
                {
                    Auftragsdatei = auft,
                    Nutzdatendatei = nutz,
                    Tenant = tenant,
                    ProtokollOid = long.Parse(split[1]),
                    Datenannahmestelle = split[2],
                    Transfernummer = split[3]
                };

                if (!toCheck.ContainsKey(tenant))
                    toCheck.Add(tenant, new List<DakotaSystemFile>());

                toCheck[tenant].Add(file);
            }

            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);

            Console.Write($"Kopiere \"{sour_auftrags}\" nach \"{dest_auftrags}\". ");

            File.Copy(sour_auftrags, dest_auftrags);

            Console.WriteLine("Ok.");

            Console.Write($"Kopiere \"{sour_nutz}\" nach \"{dest_nutz}\". ");

            File.Copy(sour_nutz, dest_nutz);

            Console.WriteLine("Ok.");
        }
        static void DeleteFile(DakotaSystemFile file)
        {
            File.Delete(file.Auftragsdatei.FullName);
            File.Delete(file.Nutzdatendatei.FullName);
        }

        static int ExecuteDakota(string arg)
        {
            var fileinfo = GetDakotaExe();

            Console.WriteLine($"{fileinfo.Name} {arg} wird ausgeführt");

            var process = Process.Start(GetDakotaExe().FullName, arg);

            var success = process.WaitForExit(GetProcessWaitForExitMs());

            if (success)
            {
                var exitcode = process.ExitCode;

                Console.WriteLine($"Returncode {exitcode}");

                return exitcode;
            }
            else
            {
                throw new Exception("Timeout");
            }
        }

        static DirectoryInfo GetDakotaFolderDatenannahmestelle(string datenannahmestelle)
        {
            var folder = new DirectoryInfo(Path.Combine(GetDakotaFolder().FullName, "TP5Daten", datenannahmestelle));

            if (!folder.Exists)
                folder = new DirectoryInfo(Path.Combine(GetDakotaFolder().FullName, "TP5Daten", datenannahmestelle.Substring(0, datenannahmestelle.Length - 1)));

            if (!folder.Exists)
                throw new Exception($"Datenannahmestelle {datenannahmestelle} konnte nicht gefunden werden.");

            return folder;
        }

        static string GetLogPath()
            => ConfigurationManager.AppSettings.Get("LogPath") ?? @"C:\GkvAbrechnung\Sender\log.txt";
        static int GetProcessWaitForExitMs()
            => int.Parse(ConfigurationManager.AppSettings.Get("ProcessWaitForExitMs") ?? "10000");
        static FileInfo GetDakotaExe()
            => new FileInfo(ConfigurationManager.AppSettings.Get("DakotaExePath") ?? @"C:\Program Files (x86)\ITSG\dakotale\dakota30.exe");
        static DirectoryInfo GetDakotaFolder()
            => new DirectoryInfo(ConfigurationManager.AppSettings.Get("DakotaFolder") ?? @"C:\dakotale\");
        static DirectoryInfo GetQueueFolder()
            => new DirectoryInfo(ConfigurationManager.AppSettings.Get("GkvAbrechnungQueueFolderPath") ?? @"C:\GkvAbrechnung\Queue\");
        static DirectoryInfo GetResultFolder()
            => new DirectoryInfo(ConfigurationManager.AppSettings.Get("GkvAbrechnungResultFolderPath") ?? @"C:\GkvAbrechnung\Results\");
    }
}