diff --git a/BeWoOhneReports.sln b/BeWoOhneReports.sln index 6a8978484..13075a9e8 100644 --- a/BeWoOhneReports.sln +++ b/BeWoOhneReports.sln @@ -29,6 +29,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReportingService", "ReportS EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ChatController", "..\Chat\ChatController\ChatController.csproj", "{8A83C4DC-A0B1-4A51-AE1D-366D7A05B298}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dakota", "Dakota\Dakota.csproj", "{47331732-DD96-4075-869F-83AA9F3F9937}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|.NET = Debug|.NET @@ -139,6 +141,18 @@ Global {8A83C4DC-A0B1-4A51-AE1D-366D7A05B298}.Release|Any CPU.Build.0 = Release|Any CPU {8A83C4DC-A0B1-4A51-AE1D-366D7A05B298}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {8A83C4DC-A0B1-4A51-AE1D-366D7A05B298}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|.NET.ActiveCfg = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|.NET.Build.0 = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|Any CPU.Build.0 = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|.NET.ActiveCfg = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|.NET.Build.0 = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|Any CPU.ActiveCfg = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|Any CPU.Build.0 = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {47331732-DD96-4075-869F-83AA9F3F9937}.Release|Mixed Platforms.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Dakota/Dakota.csproj b/Dakota/Dakota.csproj new file mode 100644 index 000000000..9a214e6bd --- /dev/null +++ b/Dakota/Dakota.csproj @@ -0,0 +1,73 @@ + + + + + Debug + AnyCPU + {47331732-DD96-4075-869F-83AA9F3F9937} + Library + Properties + Dakota + Dakota + v4.7.2 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Dakota/DakotaConfig.cs b/Dakota/DakotaConfig.cs new file mode 100644 index 000000000..a4472337e --- /dev/null +++ b/Dakota/DakotaConfig.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + public static class DakotaConfig + { + public static string TrennzeichenInnerhalb => ":"; + public static string Trennzeichen => "+"; + public static string Aufhebungszeichen => "?"; + public static string Segmentendezeichen => "'"; + } +} diff --git a/Dakota/Dateneinheit.cs b/Dakota/Dateneinheit.cs new file mode 100644 index 000000000..7b81c807f --- /dev/null +++ b/Dakota/Dateneinheit.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal abstract class Dateneinheit + { + public abstract string GetValue(); + } +} diff --git a/Dakota/Datenelement.cs b/Dakota/Datenelement.cs new file mode 100644 index 000000000..214d437be --- /dev/null +++ b/Dakota/Datenelement.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal class Datenelement : Dateneinheit + { + public string Value { get; set; } + public int MinStellen { get; set; } + public int MaxStellen { get; set; } + + public Datenelement() + { + + } + + public Datenelement(int min, int max) + { + MinStellen = min; + MaxStellen = max; + } + + public Datenelement(int count) + { + MinStellen = count; + MaxStellen = count; + } + + public override string GetValue() + { + return Value; + } + } +} diff --git a/Dakota/Datenelementgruppe.cs b/Dakota/Datenelementgruppe.cs new file mode 100644 index 000000000..60504d416 --- /dev/null +++ b/Dakota/Datenelementgruppe.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal class Datenelementgruppe : Dateneinheit + { + public Datenelement[] Datenelemente { get; set; } + + public Datenelementgruppe(int count) + { + if (count < 2) + throw new ArgumentOutOfRangeException("#37493218741616891269821"); + + Datenelemente = new Datenelement[count]; + } + + public void SetValue(int loc, string val) + { + Datenelemente[loc].Value = val; + } + + public string GetValue(int loc) + { + return Datenelemente[loc].GetValue(); + } + + public override string GetValue() + { + return string.Join(DakotaConfig.TrennzeichenInnerhalb, Datenelemente.Select(x => x.GetValue())); + } + } +} diff --git a/Dakota/Nachricht.cs b/Dakota/Nachricht.cs new file mode 100644 index 000000000..47b4a6f94 --- /dev/null +++ b/Dakota/Nachricht.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal class Nachricht + { + //public List Segmente { get; set; } + + //public Nachricht() + //{ + // Segmente = new List(); + //} + } +} diff --git a/Dakota/NachrichtSLGA.cs b/Dakota/NachrichtSLGA.cs new file mode 100644 index 000000000..83b7febbe --- /dev/null +++ b/Dakota/NachrichtSLGA.cs @@ -0,0 +1,43 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + /// + /// Gesamtaufstellung der + /// Abrechnung(Rechnung) + /// + internal class NachrichtSLGA + { + /// + /// Das Segment enthält Informationen über die zu verarbeitende Rechnung, den Rechnungssteller + /// (Leistungserbringer oder Abrechnungsstelle) und das IK der Krankenkasse von + /// der Krankenversichertenkarte bzw.von der ärztlichen Verordnung + /// + public SegmentSLGAFKT SegmentFKT { get; set; } + /// + /// Das Segment enthält die Rechnungsinformationen, wie Rechnungsnummer und Rechnungsdatum. + /// + public SegmentSLGAREC SegmentREC { get; set; } + /// + /// Das Segment enthält Informationen zur Umsatzsteuer. + /// + public SegmentSLGAUST SegmentUST { get; set; } + /// + /// Das Segment enthält Informationen, ob Skonto gewährt wird + /// (Skonto in Prozent, Zahlungsziel). + /// + public SegmentSLGASKO SegmentSKO { get; set; } + /// + /// Das Segment enthält Rechnungssummen (Bruttobetrag, Zuzahlungsbetrag, Nettobetrag je Status). + /// + public SegmentSLGAGES SegmentGES { get; set; } + /// + /// Das Segment enthält den Namen und die Firmenbezeichnung des Leistungserbringers + /// + public SegmentSLGANAM SegmentNAM { get; set; } + } +} diff --git a/Dakota/NachrichtSLLA.cs b/Dakota/NachrichtSLLA.cs new file mode 100644 index 000000000..65ceebd6f --- /dev/null +++ b/Dakota/NachrichtSLLA.cs @@ -0,0 +1,49 @@ +using Dakota.Segmente; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + /// + /// Leistungserbringer + /// + internal class NachrichtSLLA + { + /// + /// Das Segment enthält Informationen über den tatsächlichen /// Leistungserbringer und das IK der Krankenkasse von der + /// Krankenversichertenkarte bzw.der ärztlichen Verordnung bezogen auf die folgenden Abrechnungsfälle.Es kommt je Nachricht nur einmal vor. + /// + public SegmentSLLAFKT SegmentSLLAFKT { get; private set; } + /// + /// Das Segment enthält die Rechnungsinformationen, wie Rechnungsnummer und Rechnungsdatum + /// + public SegmentSLLAREC SegmentSLLAREC { get; private set; } + /// + /// Das Segment enthält die Versichertendaten eines Abrechnungsfalles (Verordnung), und gilt gleichzeitig als BeginnSegment für einen Abrechnungsfall. Jeder Abrechnungsfall ist /// mit einer eindeutigen Belegnummer zu kennzeichnen, die der /// auf der Verordnung zu übertragenen Belegnummer(s. § 4 des + /// Richtlinientextes) entsprechen muss. + /// + public SegmentSLLAINV SegmentSLLAINV { get; private set; } + /// + /// Dieses Segment enthält bei Korrekturlieferungen die ursprünglichen Rechnungsinformationen. Es wird zunächst nur + /// in Abhängigkeit für die Verarbeitungskennzeichen + /// '02' Nachforderung, + /// ‚03‘ Zuzahlungsforderung und + /// ‚04‘ Korrekturrechnung + /// (Schlüsselverzeichnis Anlage 3, Kapitel 8.1.7) geliefert + /// + public SegmentSLLAURI SegmentSLLAURI { get; private set; } + /// + /// Das Segment enthält den Namen und die Adressdaten des + /// Versicherten. + /// + public SegmentSLLANAD SegmentSLLANAD { get; private set; } + /// + /// Das Segment enthält den Imagenamen bei Übermittlung von + /// Imagearchiven durch den Absender. + /// + public SegmentSLLAIMG SegmentSLLAIMG { get; private set; } + } +} diff --git a/Dakota/Nutzdatendatei.cs b/Dakota/Nutzdatendatei.cs new file mode 100644 index 000000000..11df8585f --- /dev/null +++ b/Dakota/Nutzdatendatei.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal class Nutzdatendatei + { + //public List Nachrichten { get; set; } + + //public Nutzdatendatei() + //{ + // Nachrichten = new List(); + //} + } +} diff --git a/Dakota/Properties/AssemblyInfo.cs b/Dakota/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..698714780 --- /dev/null +++ b/Dakota/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die einer Assembly zugeordnet sind. +[assembly: AssemblyTitle("Dakota")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Dakota")] +[assembly: AssemblyCopyright("Copyright © 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly +// für COM-Komponenten unsichtbar. Wenn Sie auf einen Typ in dieser Assembly von +// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen. +[assembly: ComVisible(false)] + +// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +[assembly: Guid("47331732-dd96-4075-869f-83aa9f3f9937")] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden, +// indem Sie "*" wie unten gezeigt eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Dakota/Segmente/Segment.cs b/Dakota/Segmente/Segment.cs new file mode 100644 index 000000000..f48ab3959 --- /dev/null +++ b/Dakota/Segmente/Segment.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal abstract class Segment + { + //public List Datenelemente { get; set; } + + public abstract string GetHead(); + public abstract List GetBody(); + + public string ToString() + { + return GetHead() + DakotaConfig.Trennzeichen + string.Join(DakotaConfig.Trennzeichen, GetBody().Select(x => x.GetValue())) + DakotaConfig.Segmentendezeichen; + } + } +} diff --git a/Dakota/Segmente/SegmentSLGAFKT.cs b/Dakota/Segmente/SegmentSLGAFKT.cs new file mode 100644 index 000000000..91d8129de --- /dev/null +++ b/Dakota/Segmente/SegmentSLGAFKT.cs @@ -0,0 +1,67 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment ist je Nachricht einmal + /// zu übermitteln. + /// + internal class SegmentSLGAFKT : Segment + { + /// + /// siehe Schlüssel Verarbeitungskennzeichen Anlage 3 Abschnitt 8.1.7 + /// + public Datenelement Verarbeitungskennzeichen { get; private set; } + /// + /// Feld ist nur anzugeben und mit „J“ zu + /// füllen, wenn es sich um eine Sammelrechnung handelt + /// + public Datenelement Sammelrechnung { get; private set; } + /// + /// Es ist das IK des Leistungserbringers + /// anzugeben – mit folgender Ausnahme: + /// Erfolgt die Abrechnung über eine + /// Abrechnungsstelle mit Inkassovollmacht, so ist in der Sammelrechnungs-SLGA das IK der Abrechnungsstelle anzugeben. + /// + public Datenelement IKLeistungserbringers { get; private set; } + /// + /// Einzutragen ist das IK des Kostenträ- + /// gers auf den das IK der KV-Karte in + /// der Kostenträgerdatei verweist; diese + /// Angabe ist identisch mit dem IK des + /// Kostenträgers im FKT-Segment der + /// zugehörigen SLLA-Nachricht. + /// + public Datenelement IKKostenträger { get; private set; } + /// + /// IK der Krankenkasse von der KVKarte bzw. der ärztlichen Verordnung + /// ist zwingend anzugeben, außer es + /// handelt sich um eine Sammelrechnung-SLGA.Bei allen SLGA-Nachrichten als Gesamtrechnung ist diese + /// Angabe identisch mit SLLA.FKT.IK der + /// Krankenkasse der zugehörigen SLLANachricht. + /// + public Datenelement IKKrankenkasse { get; private set; } + /// + /// Einzutragen ist das IK des Absenders der Datei. Diese Angabe ist identisch mit UNB.Absender + /// + public Datenelement IKAbsender { get; private set; } + + public SegmentSLGAFKT() + { + Verarbeitungskennzeichen = new Datenelement(2); + Sammelrechnung = new Datenelement(1); + IKLeistungserbringers = new Datenelement(9); + IKKostenträger = new Datenelement(9); + IKKrankenkasse = new Datenelement(9); + IKAbsender = new Datenelement(9); + } + + public override string GetHead() => "FKT"; + public override List GetBody() + => new List() { Verarbeitungskennzeichen, Sammelrechnung }; + } +} diff --git a/Dakota/Segmente/SegmentSLGAGES.cs b/Dakota/Segmente/SegmentSLGAGES.cs new file mode 100644 index 000000000..ab9503b93 --- /dev/null +++ b/Dakota/Segmente/SegmentSLGAGES.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment muss je Nachricht mindestens zweimal und kann höchstens + /// neunmal vorkommen.Es ist stets ein + /// GES-Segment für den Summenstatus + /// 00 zuerst zu übermitteln.Diese + /// Summe ergibt sich aus der Addition + /// der nachfolgend anzugebenden Betragssummen des jeweiligen Versichertenstatus (SLGA). Die Betragssumme des Versichertenstatus + /// (SLGA) entspricht den Summen der + /// Abrechnungsfälle (SLLA), die diesen + /// Status beinhalten. + /// + internal class SegmentSLGAGES : Segment + { + /// + /// Siehe Schlüssel Summenstatus + /// Anlage 3 Abschnitt 8.1.6 + /// + public Datenelement Status { get; private set; } + /// + /// Bei Verarbeitungskennzeichen „01“, + /// „02“ und „04“: + /// Gesamtrechnungsbetrag(ggf.inklusive Mehrwertsteuer) + /// Berechnungsregel: + /// GES.Gesamtbruttobetrag minus + /// GES.Gesamtbetrag Zuzahlung und/oder Eigenanteil und/oder Pauschale + /// Korrekturbetrag. + /// Bei Verarbeitungskennzeichen „03“: + /// Entspricht dem Wert aus GES.Gesamtbetrag Zuzahlung und/oder Eigenanteil und/oder Pauschale Korrekturbetrag. + /// + public Datenelement Gesamtrechnungsbetrag { get; private set; } + /// + /// Bei Verarbeitungskennzeichen „01“, + /// „02“ und „04“: + /// Summe der Gesamtbruttobeträge der + /// Abrechnungsfälle(inklusive gesetzlicher Zuzahlungsbeträge oder Eigenanteil und/oder Pauschale Korrekturbetrag sowie ggf.Mehrwertsteuer) + /// aus BES. + /// Bei Verarbeitungskennzeichen „03“: + /// Ist der Gesamtbruttobetrag mit 0,00 + /// zu übermitteln. + /// + public Datenelement Gesamtbruttobetrag { get; private set; } + /// + /// Bei Verarbeitungskennzeichen „01“ + /// und „02“: + /// Summe der gesetzlichen Zuzahlungen und/oder der Eigenanteile der + /// Abrechnungsfälle aus BES + /// Berechnungsregel: + /// Summe aller Abrechnungsfälle(BES.Gesambetrag gesetzliche Zuzahlung + BES.Gesamtbetrag Eigenanteil). + /// Bei Verarbeitungskennzeichen „03“: + /// Summe der gesetzlichen Zuzahlungen und/oder der Eigenanteile der + /// Abrechnungsfälle aus GZF + /// Berechnungsregel: + /// Summe aller Abrechnungsfälle(GZF.Gesambetrag gesetzliche Zuzahlung + GZF.Gesamtbetrag Eigenanteil). + /// Bei Verarbeitungskennzeichen „04“: + /// Summe der gesetzlichen Zuzahlungen und/oder der Eigenanteile der + /// Abrechnungsfälle aus BES + /// Berechnungsregel: + /// Summe aller Abrechnungsfälle(BES.Gesambetrag gesetzliche Zuzahlung + BES.Gesamtbetrag Eigenanteil + BES.Pauschale Korrekturbetrag). + /// + public Datenelement GesamtbetragZuzahlung { get; private set; } + + public SegmentSLGAGES() + { + Status = new Datenelement(2); + Gesamtrechnungsbetrag = new Datenelement(3, 13); + Gesamtbruttobetrag = new Datenelement(3, 13); + GesamtbetragZuzahlung = new Datenelement(3, 13); + } + + public override string GetHead() => "GES"; + public override List GetBody() + => new List() { Status, Gesamtrechnungsbetrag, Gesamtbruttobetrag, GesamtbetragZuzahlung }; + } +} diff --git a/Dakota/Segmente/SegmentSLGANAM.cs b/Dakota/Segmente/SegmentSLGANAM.cs new file mode 100644 index 000000000..78c758cfe --- /dev/null +++ b/Dakota/Segmente/SegmentSLGANAM.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment ist je Nachricht einmal + /// zu übermitteln + /// + internal class SegmentSLGANAM : Segment + { + /// + /// Name bzw. Firmenbezeichnung des + /// Rechnungsstellers(Leistungserbringer oder Abrechnungsstelle + /// + public Datenelement Name1 { get; private set; } + /// + /// ggf. Ansprechpartner und Telefonnummer. + /// + public Datenelement Name2 { get; private set; } + /// + /// ggf. Ansprechpartner und Telefonnummer. + /// + public Datenelement Name3 { get; private set; } + /// + /// E-Mail-Adresse; + /// zugelassen sind Buchstaben und Ziffern, ausgenommen Umlaute + /// + public Datenelement Name4 { get; private set; } + + public SegmentSLGANAM() + { + Name1 = new Datenelement(0, 30); + Name2 = new Datenelement(0, 30); + Name3 = new Datenelement(0, 30); + Name4 = new Datenelement(0, 70); + } + + public override string GetHead() => "NAM"; + public override List GetBody() + => new List() { Name1, Name2, Name3, Name4 }; + } +} diff --git a/Dakota/Segmente/SegmentSLGAREC.cs b/Dakota/Segmente/SegmentSLGAREC.cs new file mode 100644 index 000000000..275d7f7a6 --- /dev/null +++ b/Dakota/Segmente/SegmentSLGAREC.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment ist je Nachricht einmal zu + /// übermitteln und ist identisch mit dem + /// REC-Segment der zugehörigen SLLANachricht. + /// + internal class SegmentSLGAREC : Segment + { + /// + /// Datenelementgruppe bestehend aus + /// Sammel-Rechnungsnummer:EinzelRechnungsnummer. + /// Einzutragen ist die eindeutige Rechnungsnummer, die der Rechnungssteller vergibt.Eine Rechnungsnummer ist + /// eindeutig, wenn sie über alle Rechnungsjahre hinweg - ohne Kombination mit anderen identifizierenden + /// Schlüsseln oder Merkmalen (z.B.IK des + /// Leistungserbringers, Rechnungsdatum) + /// – für eine Krankenkasse nur einer einzigen Rechnung zugeordnet werden + /// kann. + /// Diese Rechnungsnummer ist vollständig und unverändert auf die Urbelege + /// zu übernehmen (siehe Richtlinien § 4 + /// Abs.1 und § 3 des Richtlinientextes). + /// Außer bei der Sammelrechnung-SLGA + /// muss diese Angabe übereinstimmen + /// mit SLLA.REC.Rechnungsnummer der + /// zugehörigen SLLA-Nachricht.Die + /// Rechnungsnummer im Datensatz muss + /// identisch sein mit der Rechnungsnummer auf dem Begleitzettel(vgl.Anlage + /// 4). + /// Sonderzeichen(einschließlich Leerzeichen) sind nicht zugelassen, ausgenommen sind der Bindestrich „-„ und + /// der Schrägstrich „/“ als Gliederungszeichen.Aufeinanderfolgende Gliederungszeichen sind unzulässig.Die + /// Rechnungsnummer darf nicht mit einem Gliederungszeichen beginnen + /// bzw.enden. + /// + public Datenelementgruppe Rechnungsnummer { get; private set; } + /// + /// Die Einzel-Rechnungsnummer ist zusätzlich zur Sammel-Rechnungsnummer anzugeben, wenn eine SLGANachricht als Sammelrechnung zusätzlich in der Nutzdatendatei übermittelt + /// wird, ansonsten wird lediglich das Datenelement Sammel-Rechnungsnummer gefüllt und die Einzel-Rechnungsnummer auf „0“ gesetzt(zum Beispiel + /// 00234567:0 + /// + public Datenelement SammelRechnungsnummer { get; private set; } + /// + /// Ist der Absender der Datei eine Abrechnungsstelle mit Inkassovollmacht + /// erhält jeder Leistungserbringer innerhalb einer Rechnung eine eigene eindeutige Einzel-Rechnungsnummer. + /// Beispiel: Sammel-Rechnungsnummer + /// Abrechnungszentrum: 001, daraus + /// ergibt sich die Rechnungsnummer für + /// den 1. Leistungserbringer 001:1, für + /// den 2. Leistungserbringer 001 :2 usw + /// + public Datenelement EinzelRechnungsnummer { get; private set; } + /// + /// Rechnungsdatum JJJJMMTT + /// + public Datenelement Datum { get; private set; } + /// + /// Siehe Schlüssel Rechnungsart + /// Anlage 3 Abschnitt 8.1.4. + /// Dieser Schlüsselwert muss in der + /// Sammelrechnungs-SLGA und allen + /// zugehörigen SLGA-und SLLA-Nachrichten gleich sein. + /// + public Datenelement Rechnungsart { get; private set; } + + public SegmentSLGAREC() + { + Rechnungsnummer = new Datenelementgruppe(2); + SammelRechnungsnummer = Rechnungsnummer.Datenelemente[0] = new Datenelement(0, 14); + EinzelRechnungsnummer = Rechnungsnummer.Datenelemente[1] = new Datenelement(0, 6); + Datum = new Datenelement(8); + Rechnungsart = new Datenelement(1); + } + + public override List GetBody() + => new List() { Rechnungsnummer, Datum, Rechnungsart }; + + public override string GetHead() => "REC"; + } +} diff --git a/Dakota/Segmente/SegmentSLGASKO.cs b/Dakota/Segmente/SegmentSLGASKO.cs new file mode 100644 index 000000000..8c9d60284 --- /dev/null +++ b/Dakota/Segmente/SegmentSLGASKO.cs @@ -0,0 +1,43 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment kann je Nachricht + /// mehrfach übermittelt werden. + /// Das Skonto ist bei Inanspruchnahme + /// durch den Kostenträger abzuziehen. + /// Der Leistungserbringer hat immer + /// den vollen Gesamtrechnungsbetrag + /// anzugeben. + /// + internal class SegmentSLGASKO : Segment + { + /// + /// Angabe des gewährten Skonto in + /// Prozent. Ohne führende 0 wenn. + /// xx,xy% + /// + public Datenelement SkontoProzent { get; private set; } + /// + /// Angabe des Zahlungsziels in Tagen. + /// Bei Zahlung innerhalb der hier angegebenen Tage wird Skonto gewährt + /// + public Datenelement Zahlungsziel { get; private set; } + + public SegmentSLGASKO() + { + SkontoProzent = new Datenelement(3, 5); + Zahlungsziel = new Datenelement(0, 3); + } + + public override string GetHead() => "SKO"; + + public override List GetBody() + => new List() { SkontoProzent, Zahlungsziel }; + } +} diff --git a/Dakota/Segmente/SegmentSLGAUST.cs b/Dakota/Segmente/SegmentSLGAUST.cs new file mode 100644 index 000000000..2862f66b3 --- /dev/null +++ b/Dakota/Segmente/SegmentSLGAUST.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Das Segment kann je Nachricht einmal übermittelt werden. Es ist nicht + /// in der Sammelrechnung-SLGA zu + /// übermitteln + /// + internal class SegmentSLGAUST : Segment + { + /// + /// Steuernummer gemäß § 14 Abs. 1a + /// UStG oder Umsatzsteuer-Identifikationsnummer. + /// + public Datenelement Steuernummer { get; private set; } + /// + /// "J" wenn befreit gem. § 4 UStG + /// + public Datenelement Kennung { get; private set; } + + public SegmentSLGAUST() + { + Steuernummer = new Datenelement(0, 20); + Kennung = new Datenelement(1); + } + + public override string GetHead() => "UST"; + + public override List GetBody() + => new List() { Steuernummer, Kennung }; + } +} diff --git a/Dakota/Segmente/SegmentSLLAFKT.cs b/Dakota/Segmente/SegmentSLLAFKT.cs new file mode 100644 index 000000000..cfe1e6482 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLAFKT.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLAFKT + { + } +} diff --git a/Dakota/Segmente/SegmentSLLAIMG.cs b/Dakota/Segmente/SegmentSLLAIMG.cs new file mode 100644 index 000000000..c02d03239 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLAIMG.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLAIMG + { + } +} diff --git a/Dakota/Segmente/SegmentSLLAINV.cs b/Dakota/Segmente/SegmentSLLAINV.cs new file mode 100644 index 000000000..f793cb104 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLAINV.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLAINV + { + } +} diff --git a/Dakota/Segmente/SegmentSLLANAD.cs b/Dakota/Segmente/SegmentSLLANAD.cs new file mode 100644 index 000000000..f44a7f567 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLANAD.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLANAD + { + } +} diff --git a/Dakota/Segmente/SegmentSLLAREC.cs b/Dakota/Segmente/SegmentSLLAREC.cs new file mode 100644 index 000000000..f48411451 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLAREC.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLAREC + { + } +} diff --git a/Dakota/Segmente/SegmentSLLAURI.cs b/Dakota/Segmente/SegmentSLLAURI.cs new file mode 100644 index 000000000..13c6762e6 --- /dev/null +++ b/Dakota/Segmente/SegmentSLLAURI.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + internal class SegmentSLLAURI + { + } +} diff --git a/Dakota/Segmente/SegmentUNB.cs b/Dakota/Segmente/SegmentUNB.cs new file mode 100644 index 000000000..5e139e242 --- /dev/null +++ b/Dakota/Segmente/SegmentUNB.cs @@ -0,0 +1,101 @@ +using System.Collections.Generic; + +namespace Dakota.Segmente +{ + /// + /// Kopf-Segment einer Nutzdatendatei; es dient zur Eröffnung, + /// Identifizierung und Beschreibung der Datei.Eine Nutzdatendatei + /// besteht aus der Folge UNB bis UNZ.Sie beinhaltet die Nachrichten SLGA und SLLA, die mehrfach wiederholbar sind.So ist es + /// möglich, dass ein oder mehrere Leistungserbringer Abrechnungen für ein oder mehrere Kostenträger übermitteln. + /// + internal class SegmentUNB : Segment + { + /// + /// UNOC:3 + /// + public Datenelementgruppe Syntax { get; private set; } + /// + /// Vereinbarte EDIFACT-Syntax; + /// hier: UNOC = Groß- und Kleinbuchstaben, Umlaut + /// + public Datenelement SyntaxKennung { get; private set; } + /// + /// Vereinbarte Version der Syntax; + /// hier: Version 3 (derzeit aktuell) + /// + public Datenelement SyntaxVersionsnummer { get; private set; } + /// + /// IK des Absenders ( Abrechnungsstelle mit oder ohne Inkassobefugnis oder LE) + /// Genutzt werden die ersten 9 Stellen; + /// einzutragen ist das IK der absendenden Stelle. + /// Diese Angabe muss übereinstimmen mit SLGA.FKT.IK Absender der Datei. + /// + public Datenelement Absenderdatei { get; private set; } + /// + /// IK des Empfängers (d.h. Datenannahmestelle mit Entschlüsselungsbefugnis); + /// genutzt werden die ersten 9 Stellen; +/// einzutragen ist das IK der empfangenden Stelle + /// + public Datenelement Empfangdatei { get; private set; } + /// + /// JJJJMMTT:HHMM + /// + public Datenelementgruppe DatumUhrzeit { get; private set; } + /// + /// Erstelldatum der Datei + /// + public Datenelement Datum { get; private set; } + /// + /// Erstelluhrzeit der Datei + /// + public Datenelement Uhrzeit { get; private set; } + /// + /// Ab Version 12 ist die Datenaustauschreferenz zwingend zu füllen. + /// Genutzt werden die ersten 5 Stellen; + /// einzutragen ist die fortlaufende + /// Nummer der Lieferungen zwischen + /// Absender und Empfänger mit führenden Nullen. + /// Bei Überlauf der Datenaustauschreferenz („99999“) ist wieder + /// bei Eins(„00001“) zu beginnen + /// + public Dateneinheit Datenaustauschreferenz { get; private set; } + /// + /// Einzutragen ist der Leistungserbringer-Sammelgruppenschlüssel, + /// siehe Schlüssel Anlage 3 Abschnitt 8.1.14 + /// + public Datenelement Leistungsbereich { get; private set; } + /// + /// Genutzt werden die ersten 11 Stellen; + /// einzutragen ist der logische Dateiname s.Anhang 1 zur Anlage 1 + /// zum Kapitel 4. + /// + public Datenelement Anwengundsreferenz { get; private set; } + /// + /// Inhalt = 0 wenn Testdatei + /// Inhalt = 1 wenn Erprobungsdatei + /// Inhalt = 2 wenn Echtdatei + /// + public Datenelement Testindikator { get; private set; } + + public SegmentUNB() + { + Syntax = new Datenelementgruppe(2); + SyntaxKennung = Syntax.Datenelemente[0] = new Datenelement(4); + SyntaxVersionsnummer = Syntax.Datenelemente[1] = new Datenelement(1); + Absenderdatei = new Datenelement(0, 35); + Empfangdatei = new Datenelement(0, 35); + DatumUhrzeit = new Datenelementgruppe(2); + Datum = DatumUhrzeit.Datenelemente[0] = new Datenelement(8); + Uhrzeit = DatumUhrzeit.Datenelemente[1] = new Datenelement(4); + Datenaustauschreferenz = new Datenelement(0, 14); + Leistungsbereich = new Datenelement(1); + Anwengundsreferenz = new Datenelement(0, 14); + Testindikator = new Datenelement(1); + } + + public override string GetHead() => "UNB"; + + public override List GetBody() + => new List { Syntax, Absenderdatei, Empfangdatei, DatumUhrzeit, Datenaustauschreferenz, Leistungsbereich, Anwengundsreferenz, Testindikator }; + } +} diff --git a/Dakota/Segmente/SegmentUNH.cs b/Dakota/Segmente/SegmentUNH.cs new file mode 100644 index 000000000..405a7d6ea --- /dev/null +++ b/Dakota/Segmente/SegmentUNH.cs @@ -0,0 +1,74 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Kopf-Segment einer Nachricht; es dient dazu, eine Nachricht zu + /// eröffnen, zu identifizieren und zu beschreiben.Eine Nachricht + /// besteht aus einer definierten Folge von Segmenten, die einmal + /// oder mehrfach vorkommen können oder nur bei bestimmten + /// Geschäftsvorfällen erforderlich sind + /// + internal class SegmentUNH : Segment + { + /// + /// Genutzt werden die ersten 5 Stellen; + /// einzutragen ist die fortlaufende + /// Nummer der UNH-Segmente zwischen UNB und UNZ mit führenden + /// Nullen, + /// z.B. 00001 für 1. UNH + /// + public Datenelement Nachrichtenreferenznummer { get; private set; } + /// + /// Bei Nachricht SLGA ist einzutragen: + /// SLGA:18:0:0 + /// Bei Nachricht SLLA ist einzutragen: + /// SLLA:18:0:0 + /// + public Datenelementgruppe Nachrichtenerkennung { get; private set; } + /// + /// Genutzt werden die ersten 4 Stellen; + /// einzutragen sind: SLGA oder SLLA + /// + public Datenelement NachrichtenTypKennung { get; private set; } + /// + /// Genutzt werden die ersten 2 Stellen; + /// einzutragen ist die Nummer der + /// benutzten Version des Nachrichtentypes lt.Abschnitt 5.5 dieser + /// Anlage; d.h.Version 18. + /// + public Datenelement Verionsnummer { get; private set; } + /// + /// Genutzt wird die erste Stelle; + /// Inhalt = 0 („Null“ muss angegeben + /// werden). + /// + public Datenelement FreigabeNrDesTypes { get; private set; } + /// + /// Genutzt wird die erste Stelle; + /// Inhalt = 0 („Null“ muss angegeben + /// werden). + /// + public Datenelement VerwaltendeOrganisation { get; private set; } + + + public SegmentUNH() + { + Nachrichtenreferenznummer = new Datenelement(0, 14); + Nachrichtenerkennung = new Datenelementgruppe(4); + NachrichtenTypKennung = Nachrichtenerkennung.Datenelemente[0] = new Datenelement(0, 6); + Verionsnummer = Nachrichtenerkennung.Datenelemente[1] = new Datenelement(0, 3); + FreigabeNrDesTypes = Nachrichtenerkennung.Datenelemente[2] = new Datenelement(0, 3); + VerwaltendeOrganisation = Nachrichtenerkennung.Datenelemente[3] = new Datenelement(0, 2); + } + + public override string GetHead() => "UNH"; + + public override List GetBody() + => new List { Nachrichtenreferenznummer, Nachrichtenerkennung}; + } +} diff --git a/Dakota/Segmente/SegmentUNT.cs b/Dakota/Segmente/SegmentUNT.cs new file mode 100644 index 000000000..ea5e8c022 --- /dev/null +++ b/Dakota/Segmente/SegmentUNT.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Ende-Segment einer Nachricht. Beendet eine Nachricht und ermöglicht die Prüfung auf Vollständigkeit + /// + internal class SegmentUNT : Segment + { + /// + /// Anzahl der Segmente in der Nachricht einschließlich der Segmente + /// UNH und UNT mit führenden Nullen. + /// + public Datenelement AnzahlEinheiten { get; private set; } + /// + /// wie in UNH + /// + public Datenelement Nachrichtenreferenznummer { get; private set; } + + public SegmentUNT() + { + AnzahlEinheiten = new Datenelement(6); + Nachrichtenreferenznummer = new Datenelement(0, 14); + } + + public override string GetHead() => "UNT"; + public override List GetBody() + => new List() { AnzahlEinheiten, Nachrichtenreferenznummer }; + } +} diff --git a/Dakota/Segmente/SegmentUNZ.cs b/Dakota/Segmente/SegmentUNZ.cs new file mode 100644 index 000000000..52ed06f92 --- /dev/null +++ b/Dakota/Segmente/SegmentUNZ.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Segmente +{ + /// + /// Ende-Segment einer Datei. Beendet eine Datei und ermöglicht + /// die Prüfung auf Vollständigkeit + /// + internal class SegmentUNZ : Segment + { + /// + /// Anzahl UNHs in der Nutzdatendatei + /// + public Datenelement AnzahlNachrichten { get; private set; } + /// + /// wie in UNB + /// + public Datenelement Datenaustauschreferenz { get; private set; } + + public SegmentUNZ() + { + AnzahlNachrichten = new Datenelement(6); + Datenaustauschreferenz = new Datenelement(0, 14); + } + + public override string GetHead() => "UNZ"; + + public override List GetBody() + => new List { AnzahlNachrichten, Datenaustauschreferenz}; + } +} diff --git a/Dakota/SozioTherapieDatei.cs b/Dakota/SozioTherapieDatei.cs new file mode 100644 index 000000000..641448ade --- /dev/null +++ b/Dakota/SozioTherapieDatei.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota +{ + internal class SozioTherapieDatei : Nutzdatendatei + { + public SegmentUNB UNB { get; set; } + + public SegmentUNZ UNZ { get; set; } + } +}