diff --git a/BeWoOhneReports.sln b/BeWoOhneReports.sln index 13075a9e8..e99b93568 100644 --- a/BeWoOhneReports.sln +++ b/BeWoOhneReports.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 15 -VisualStudioVersion = 15.0.27004.2009 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.33927.289 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Client", "Client", "{E7543C39-A44C-40C9-82C9-E7FAA2D9A852}" EndProject @@ -31,6 +31,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ChatController", "..\Chat\C EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dakota", "Dakota\Dakota.csproj", "{47331732-DD96-4075-869F-83AA9F3F9937}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{B6039E62-D43E-477A-BE82-EADB1057A3A2}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + EndProjectSection +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|.NET = Debug|.NET diff --git a/Dakota/Dakota.csproj b/Dakota/Dakota.csproj index 32c984e69..c28ba3841 100644 --- a/Dakota/Dakota.csproj +++ b/Dakota/Dakota.csproj @@ -44,22 +44,26 @@ + - - - - + + + + - - - - - + + + + + + + + @@ -73,7 +77,6 @@ - @@ -92,9 +95,13 @@ - + + + {B0D73E3D-4AE7-4024-93A6-DB1F46D7CCEE} + Data + {2F50B83D-A3F0-4EC4-979A-3F9B7E3D8ED4} Shared diff --git a/Dakota/DakotaEnums.cs b/Dakota/DakotaEnums.cs index ed1dbcc47..0c0fe2d70 100644 --- a/Dakota/DakotaEnums.cs +++ b/Dakota/DakotaEnums.cs @@ -17,4 +17,15 @@ namespace Dakota Alpha, Numerisch } + + public enum Kassenart + { + HKK, + AOK, + BKK, + IKK, + Knappschaft, + SVLFG, + VDEK + } } diff --git a/Dakota/DakotaFile.cs b/Dakota/DakotaFile.cs index 73925cfe0..88b828c7c 100644 --- a/Dakota/DakotaFile.cs +++ b/Dakota/DakotaFile.cs @@ -1,19 +1,21 @@ -using BS.Shared.DataContracts; +using BeWo.Data.Entities; +using BS.Shared.DataContracts; using Dakota.Models; -using Dakota.Models.Datei; -using Dakota.Models.Nachricht; +using Dakota.Models.Block; +using Dakota.Models.Nachrichten; using Dakota.Models.Segmente; using System; using System.Collections.Generic; +using System.Linq; namespace Dakota { /// - /// Interne Logik + /// Nutzdatendatei mit Logik /// - public class DakotaFile : IRowable + internal class DakotaFile : Nachricht { - internal SozioTherapieEinzelnachweis SozioTherapieEinzelnachweis { get; set; } + internal BlockNutzdatendatei Nutzdatendatei { get; private set; } internal DateTime Created { get; private set; } internal int NachrichtenCounter { get; set; } @@ -21,55 +23,120 @@ namespace Dakota internal int SegmentSLGACounter { get; set; } internal int SegmentSLLACounter { get; set; } - // UNB - internal SegmentUNB SegmentUNB => SozioTherapieEinzelnachweis.UNB; - // Block - internal BlockKrankenkarteVerordnung BlockKrankenkarteVerordnung => SozioTherapieEinzelnachweis.BlockKrankenkarteVerordnung; - // SLGA - internal SegmentUNH BlockSLGAUNH => BlockKrankenkarteVerordnung.SLGAUNH; - internal NachrichtSLGA2 BlockSLGANachricht => BlockKrankenkarteVerordnung.SLGANachricht2; - internal SegmentUNT BlockSLGAUNT => BlockKrankenkarteVerordnung.SLGAUNT; - // SLLA - internal SegmentUNH BlockSLLAUNH => BlockKrankenkarteVerordnung.SLLAUNH; - internal NachrichtSLLA2 BlockSLLANachricht => BlockKrankenkarteVerordnung.SLLANachricht2; - internal SegmentUNT BlockSLLAUNT => BlockKrankenkarteVerordnung.SLLAUNT; - // UNZ - internal SegmentUNZ SegmentUNZ => SozioTherapieEinzelnachweis.UNZ; - - public DakotaFile() + // Rene26 Comment + //// UNB + //internal SegmentUNB SegmentUNB => SozioTherapieEinzelnachweis.UNB; + //// Block + //internal + //internal BlockKrankenkarteVerordnung BlockKrankenkarteVerordnung => SozioTherapieEinzelnachweis.BlockKrankenkarteVerordnung; + //// SLGA + //internal SegmentUNH BlockSLGAUNH => BlockKrankenkarteVerordnung.SLGAUNH; + //internal NachrichtSLGA2 BlockSLGANachricht => BlockKrankenkarteVerordnung.SLGANachricht2; + //internal SegmentUNT BlockSLGAUNT => BlockKrankenkarteVerordnung.SLGAUNT; + //// SLLA + //internal SegmentUNH BlockSLLAUNH => BlockKrankenkarteVerordnung.SLLAUNH; + //internal NachrichtSLLA2 BlockSLLANachricht => BlockKrankenkarteVerordnung.SLLANachricht2; + //internal SegmentUNT BlockSLLAUNT => BlockKrankenkarteVerordnung.SLLAUNT; + //// UNZ + //internal SegmentUNZ SegmentUNZ => SozioTherapieEinzelnachweis.UNZ; + + internal DakotaFileInfo Info { get; set; } + + internal DakotaFile(DakotaFileInfo info) { - SozioTherapieEinzelnachweis = new SozioTherapieEinzelnachweis(); + Nutzdatendatei = new BlockNutzdatendatei(); + + Info = info; + Created = DateTime.Now; NachrichtenCounter = 1; AnzahlUNHCounter = 0; SegmentSLGACounter = 0; SegmentSLLACounter = 0; + + GenerateUNBSegment(); } - public void Generate(DakotaFileInfo info) + internal void AddInvoiceItem(InvoiceItem invoice) { - GenerateUNB(info); - GenerateBlockSLGA(info); - GenerateBlockSLLA(info); - GenerateUNZ(info); + var kostentrager = "123456789"; + var kostentragerblock = Nutzdatendatei.BlockKostenträger.FirstOrDefault(block => block.IKKostenträger == kostentrager); + + if (kostentragerblock is null) + { + kostentragerblock = GenerateBlockKostentrager(invoice); + + Nutzdatendatei.BlockKostenträger.Add(kostentragerblock); + } + + var krankenversichten = "987654321"; + var krankenversichtenblock = kostentragerblock.BlockKrankenkarteVerordnung.FirstOrDefault(block => block.IKKrankenkasseKVKarte == krankenversichten); + + AddInvoiceItemIntoBlock(krankenversichtenblock, invoice); + + kostentragerblock.Update(); } - public void GenerateUNB(DakotaFileInfo info) + internal void AddInvoiceItemIntoBlock(BlockKrankenkarteVerordnung block, InvoiceItem invoice) { - SegmentUNB.SyntaxKennung.SetValue("UNOC"); - SegmentUNB.SyntaxVersionsnummer.SetValue("3"); - SegmentUNB.Absenderdatei.SetValue(info.Absenderbezeichnung); - SegmentUNB.Empfangdatei.SetValue(info.Empfangerbezeichnung); - SegmentUNB.Datum.SetValue(Created.ToString("yyyyMMdd")); - SegmentUNB.Uhrzeit.SetValue(Created.ToString("HHmm")); - SegmentUNB.Datenaustauschreferenz.SetFilledIntValue(info.Datenaustauschreferenz, 5); - SegmentUNB.Leistungsbereich.SetValue("O"); - SegmentUNB.Anwengundsreferenz.SetValue(info.Anwendungsreferenz); - SegmentUNB.Testindikator.SetValue(info.Testindikator.Value); + // Wie soll das hier sein + + // SLLA } - public void GenerateBlockSLGA(DakotaFileInfo info) + private BlockKostenträger GenerateBlockKostentrager(InvoiceItem invoice) + { + var block = new BlockKostenträger(); + + var nachrefnum = ++AnzahlUNHCounter; + + block.SegmentUNH.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); + block.SegmentUNH.NachrichtenTypKennung.SetValue("SLGA"); + block.SegmentUNH.Verionsnummer.SetValue("18"); + block.SegmentUNH.FreigabeNrDesTypes.SetValue("0"); + block.SegmentUNH.VerwaltendeOrganisation.SetValue("0"); + + block.SegmentUNT.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); + // ! block.SegmentUNT.AnzahlEinheiten.SetValue("0"); + } + + private BlockKrankenkarteVerordnung GenerateBlockKrankenkarte(InvoiceItem invoice) + { + var block = new BlockKrankenkarteVerordnung(); + + var nachrefnum = ++AnzahlUNHCounter; + + block.SegmentSLGAUNH.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); + block.SegmentSLGAUNH.NachrichtenTypKennung.SetValue("SLGA"); + block.SegmentSLGAUNH.Verionsnummer.SetValue("18"); + block.SegmentSLGAUNH.FreigabeNrDesTypes.SetValue("0"); + block.SegmentSLGAUNH.VerwaltendeOrganisation.SetValue("0"); + + block.SegmentSLGAUNT.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); + // ! block.SegmentSLGAUNT.AnzahlEinheiten.SetValue("0"); + } + + internal void Finish() + { + GenerateUNZSegment(); + } + + private void GenerateUNBSegment() + { + Nutzdatendatei.SegmentUNB.SyntaxKennung.SetValue("UNOC"); + Nutzdatendatei.SegmentUNB.SyntaxVersionsnummer.SetValue("3"); + Nutzdatendatei.SegmentUNB.Absenderdatei.SetValue(Info.Absenderbezeichnung); + Nutzdatendatei.SegmentUNB.Empfangdatei.SetValue(Info.Empfangerbezeichnung); + Nutzdatendatei.SegmentUNB.Datum.SetValue(Created.ToString("yyyyMMdd")); + Nutzdatendatei.SegmentUNB.Uhrzeit.SetValue(Created.ToString("HHmm")); + Nutzdatendatei.SegmentUNB.Datenaustauschreferenz.SetFilledIntValue(Info.Datenaustauschreferenz, 5); + Nutzdatendatei.SegmentUNB.Leistungsbereich.SetValue(Info.Leistungsbereich.Value); + Nutzdatendatei.SegmentUNB.Anwengundsreferenz.SetValue(Info.Anwendungsreferenz); + Nutzdatendatei.SegmentUNB.Testindikator.SetValue(Info.Testindikator.Value); + } + + private void GenerateBlockSLGA(DakotaFileInfo info) { //UNH, UNT, FKT, REC, GES00, GES, NAM SegmentSLGACounter += 7; @@ -122,7 +189,7 @@ namespace Dakota BlockSLGAUNT.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); } - public void GenerateBlockSLLA(DakotaFileInfo info) + private void GenerateBlockSLLA(DakotaFileInfo info) { SegmentSLLACounter++; AnzahlUNHCounter++; @@ -221,10 +288,10 @@ namespace Dakota BlockSLLAUNT.Nachrichtenreferenznummer.SetFilledIntValue(nachrefnum, 5); } - public void GenerateUNZ(DakotaFileInfo info) + private void GenerateUNZSegment() { - SegmentUNZ.AnzahlNachrichten.SetFilledIntValue(AnzahlUNHCounter, 6); - SegmentUNZ.Datenaustauschreferenz.SetFilledIntValue(info.Datenaustauschreferenz, 5); + Nutzdatendatei.SegmentUNZ.AnzahlNachrichten.SetFilledIntValue(AnzahlUNHCounter, 6); + Nutzdatendatei.SegmentUNZ.Datenaustauschreferenz.SetFilledIntValue(Info.Datenaustauschreferenz, 5); } public void foo(long? invoiceBaseOid) @@ -283,9 +350,9 @@ namespace Dakota } - public string GetRows() + public override List GetSegments() { - return SozioTherapieEinzelnachweis.GetRows(); + return Nutzdatendatei.GetSegments(); } } } diff --git a/Dakota/DakotaFileCreator.cs b/Dakota/DakotaFileCreator.cs new file mode 100644 index 000000000..33521bc2b --- /dev/null +++ b/Dakota/DakotaFileCreator.cs @@ -0,0 +1,145 @@ +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BS.Shared.DataContracts; +using Dakota; +using Dakota.Models.Schlüssel; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BeWo.Service.ServiceUtils.Generell +{ + public static class DakotaFileCreator + { + internal struct DakotaKeyDictionary + { + public DateTime DateTime { get; set; } + public Kassenart Kassenart { get; set; } + public string Kostenträger { get; set; } + + public override bool Equals(object obj) + { + if (obj == null || GetType() != obj.GetType()) + { + return false; + } + + var objectToCompareWith = (DakotaKeyDictionary)obj; + + return objectToCompareWith.DateTime == DateTime && objectToCompareWith.Kassenart == Kassenart && + objectToCompareWith.Kostenträger == Kostenträger; + + } + } + + /// + /// Ein Datei erzeungnis + /// + /// + /// + //public static string generateasciicode(list invoiceitems) + //{ + // var info = loadinfo(invoiceitems); + + // var file = new dakotafile(info); + + // file.generate(); + + // return file.getrows(); + //} + + public static List GenerateDakotaFilesByMonth(int year, int month) + { + var dict = GenerateDakotaFiles(year, month); + + return dict.Values.Select(x => x.GetRows()).ToList(); + } + + internal static Dictionary GenerateDakotaFiles(int year, int month) + { + // Datum, Kassenart, Kostenträger + var res = new Dictionary(); + + var invoiceitems = DAOFactory.GenericDAO.GetAllActive(); + + var first = new DateTime(year, month, 1); + var last = new DateTime(year, month, 1).AddMonths(1).AddDays(-1); + + var filtered = invoiceitems.Where(x => x.ItemPeriodStart == first && x.ItemPeriodEnd == last); + + foreach (var invoice in filtered) + { + // Aufteilen + // 1. Monat/Jahr - erstmal gleich + // 2. Kassenart - aok, bkk, lkk + // Kostenträger - kt1, kt2, kt3 + // Leistungsbereich - immer soziotherapie + + + DakotaKeyDictionary currentkey = new DakotaKeyDictionary(); + currentkey.DateTime = first; + currentkey.Kassenart = Kassenart.BKK; + currentkey.Kostenträger = ""; + + var dakota = res.FirstOrDefault(keypair => keypair.Key.Equals(currentkey)).Value; + + if (dakota is null) + { + var info = LoadInfo(invoice); + + dakota = new DakotaFile(info); + + res.Add(currentkey, dakota); + } + + dakota.AddInvoiceItem(invoice); + } + + return res; + } + + public static DakotaFileInfo LoadInfo(InvoiceItem invoice) + { + throw new NotImplementedException(); + } + + public static DakotaFileInfo LoadInfos(List invoiceItems) + { + var res = new DakotaFileInfo(); + + res.Absenderbezeichnung = "123456789"; + res.Empfangerbezeichnung = "987654321"; + res.Datenaustauschreferenz = 1; + res.Leistungsbereich = SchlüsselLeistungserbringerSammelgruppenschlussel.SoziotherapeutischerLeistungserbringer; + res.Anwendungsreferenz = "abovollkra.txt"; + res.Testindikator = SchlüsselTestindikator.Testdatei; + + res.IKLeistungserbringers = "abovollkrass.txt"; + res.IKKostenträger = "abovollkrass.txt"; + res.IKKrankenkasse = "abovollkrass.txt"; + // res.Rechnungsnummer = dc.InvoiceBase.InvoiceNumber; + // Einheitlich monatlich + // res.Rechnungsdatum = dc.InvoiceBase.InvoiceDate.Value; + + res.Summenstatus = SchlüsselSummenstatus.Mitglieder; + res.Gesamtrechnungsbetrag = 3.5m; + res.Gesamtbruttobetrag = 3.5m; + res.GesamtbetragZuzahlung = 3.5m; + res.Rechnungsart = SchlüsselRechnungsart.AbrechnungVonLeistungserbringer; + res.Name1 = "nam7"; + res.Name2 = "nam4"; + res.Name3 = "nam3"; + res.Name4 = "nam1"; + + res.Verarbeitungskennzeichen = SchlüsselVerarbeitungskennzeichen.AbrechnungOhneBesonderheit; + + res.IKKrankenkasse = "abovollkrass.txt"; + + res.InvoiceItems = invoiceItems; + + return res; + } + } +} diff --git a/Dakota/DakotaFileInfo.cs b/Dakota/DakotaFileInfo.cs index a692ad9b3..89ba51179 100644 --- a/Dakota/DakotaFileInfo.cs +++ b/Dakota/DakotaFileInfo.cs @@ -1,5 +1,7 @@ -using Dakota.Models.Schlüssel; +using BS.Shared.DataContracts; +using Dakota.Models.Schlüssel; using System; +using System.Collections.Generic; namespace Dakota { @@ -50,6 +52,12 @@ namespace Dakota } } /// + /// Einzutragen ist der Leistungserbringer-Sammelgruppenschlüssel, + /// siehe Schlüssel Anlage 3 Abschnitt + /// 8.1.14. + /// + public SchlüsselLeistungserbringerSammelgruppenschlussel Leistungsbereich { get; set; } + /// /// Genutzt werden die ersten 11 Stellen; /// einzutragen ist der logische Dateiname s.Anhang 1 zur Anlage 1 /// zum Kapitel 4. @@ -145,10 +153,6 @@ namespace Dakota /// public decimal GesamtbetragZuzahlung { get; set; } /// - /// Name bzw. Firmenbezeichnung des - /// Rechnungsstellers(Leistungserbringer oder Abrechnungsstelle - /// - /// /// /// Siehe Schlüssel Rechnungsart /// Anlage 3 Abschnitt 8.1.4. /// Dieser Schlüsselwert muss in der @@ -156,6 +160,10 @@ namespace Dakota /// zugehörigen SLGA-und SLLA-Nachrichten gleich sein. /// public SchlüsselRechnungsart Rechnungsart { get; set; } + /// + /// Name bzw. Firmenbezeichnung des + /// Rechnungsstellers(Leistungserbringer oder Abrechnungsstelle + /// public string Name1 { get; set; } /// /// ggf. Ansprechpartner und Telefonnummer. diff --git a/Dakota/Models/Abrechnungsposition.cs b/Dakota/Models/Abrechnungsposition.cs deleted file mode 100644 index 2acfc4a6b..000000000 --- a/Dakota/Models/Abrechnungsposition.cs +++ /dev/null @@ -1,47 +0,0 @@ -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models -{ - internal class Abrechnungsposition - { - public SegmentSLLAENF SegmentSLLAENF { get; private set; } - /// - /// Mit diesem Segment können weitere Informationen, bezogen /// auf die abzurechnende Position übermittelt werden.Hier können u.a.die Uhrzeit und die gefahrenen Kilometer angegeben - /// werden. Es kann je abzurechnende Position einmal vorkommen - /// - public SegmentSLLASUT SegmentSLLASUT { get; private set; } - /// - /// Mit diesem Segment kann zu jeder abzurechnenden Position - /// ein Text(z.B.als Begründung) hinterlegt werden.Es kann je - /// abzurechnende Position einmal vorkommen. - /// - public SegmentSLLATXT SegmentSLLATXT { get; private set; } - /// - /// Mit diesem Segment kann zu jeder abzurechnenden Position /// Mehrwertsteuer angegeben werden.Benutzt werden soll das /// Segment nur dann, wenn dem in ENF genannten Einzelbetrag - /// die Mehrwertsteuer hinzuzurechnen ist. - /// - ///public SegmentSLLAMWS SegmentSLLAMWS { get; private set; } - - /// - - public Abrechnungsposition() - { - SegmentSLLAENF = new SegmentSLLAENF(); - SegmentSLLASUT = new SegmentSLLASUT(); - SegmentSLLATXT = new SegmentSLLATXT(); - //SegmentSLLAMWS = new SegmentSLLAMWS(); - } - - public List GetSegments() - { - return new List() { SegmentSLLAENF, SegmentSLLASUT, SegmentSLLATXT, - }; - //SegmentSLLAMWS }; - } - } -} diff --git a/Dakota/Models/Block/BlockAbrechnungsfall.cs b/Dakota/Models/Block/BlockAbrechnungsfall.cs new file mode 100644 index 000000000..28ac2e723 --- /dev/null +++ b/Dakota/Models/Block/BlockAbrechnungsfall.cs @@ -0,0 +1,121 @@ +using Dakota.Models.Segmente; +using Dakota.Models.Nachrichten; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Dakota.Models.Segmente.SLLA; + +namespace Dakota.Models.Block +{ + internal class BlockAbrechnungsfall : Nachricht + { + + /// + /// 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; } + + /// + /// Das Segment dient zur Abrechnung der einzelnen Positionen, + /// die für den abzurechnenden Fall angefallen sind.Es ist so oft + /// wiederholbar, wie Abrechnungspositionen vorkommen. + /// + public SegmentSLLAENF SegmentSLLAENF { get; private set; } + /// + /// Mit diesem Segment können weitere Informationen, bezogen + /// auf die abzurechnende Position übermittelt werden.Hier können u.a.die Uhrzeit und die gefahrenen Kilometer angegeben + /// werden. Es kann je abzurechnende Position einmal vorkommen + /// + public SegmentSLLASUT SegmentSLLASUT { get; private set; } + /// + /// Mit diesem Segment kann zu jeder abzurechnenden Position + /// ein Text(z.B.als Begründung) hinterlegt werden.Es kann je + /// abzurechnende Position einmal vorkommen. + /// + public SegmentSLLATXT SegmentSLLATXT { get; private set; } + /// + /// Mit diesem Segment kann zu jeder abzurechnenden Position + /// Mehrwertsteuer angegeben werden.Benutzt werden soll das + /// Segment nur dann, wenn dem in ENF genannten Einzelbetrag + /// die Mehrwertsteuer hinzuzurechnen ist. + /// + public SegmentSLLAMWS SegmentSLLAMWS { get; private set; } + /// + /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist + /// für spätere Ausprägungen reserviert. + /// + public SegmentSLLAZUZ SegmentSLLAZUZ { get; private set; } + /// + /// Das Segment enthält allgemeine Angaben zum Abrechnungsfall (Verordnung) und ist zu übermitteln, wenn eine ärztliche + /// Verordnung, ein Reparatur- oder Berechtigungsschein oder + /// Unfall/BVG vorliegt. + /// + public SegmentSLLAZUV SegmentSLLAZUV { get; private set; } + /// + /// Das Segment dient zur Angabe der Diagnose und ist so oft + /// wiederholbar, wie Diagnosen vorliegen + /// + public SegmentSLLADIA SegmentSLLADIA { get; private set; } + /// + /// Das Segment enthält Angaben über die von der Krankenkasse + /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu + /// übermitteln, wenn diese vorliegt. + /// + public SegmentSLLASKZ SegmentSLLASKZ { get; private set; } + /// + /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung) + /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer) + /// + public SegmentSLLABES SegmentSLLABES { get; private set; } + + public BlockAbrechnungsfall() + { + + SegmentSLLAINV = new SegmentSLLAINV(); + SegmentSLLAURI = new SegmentSLLAURI(); + SegmentSLLANAD = new SegmentSLLANAD(); + SegmentSLLAIMG = new SegmentSLLAIMG(); + + SegmentSLLAENF = new SegmentSLLAENF(); + SegmentSLLASUT = new SegmentSLLASUT(); + SegmentSLLATXT = new SegmentSLLATXT(); + SegmentSLLAMWS = new SegmentSLLAMWS(); + SegmentSLLAZUZ = new SegmentSLLAZUZ(); + SegmentSLLAZUV = new SegmentSLLAZUV(); + SegmentSLLADIA = new SegmentSLLADIA(); + SegmentSLLASKZ = new SegmentSLLASKZ(); + SegmentSLLABES = new SegmentSLLABES(); + } + + public override List GetSegments() + { + return new List() {SegmentSLLAINV, SegmentSLLAURI, SegmentSLLANAD, SegmentSLLAIMG, + SegmentSLLAENF, SegmentSLLASUT, SegmentSLLATXT, SegmentSLLAMWS, + SegmentSLLAZUZ, SegmentSLLAZUV, SegmentSLLADIA, SegmentSLLASKZ, SegmentSLLABES}; + } + } +} diff --git a/Dakota/Models/Block/BlockKostenträger.cs b/Dakota/Models/Block/BlockKostenträger.cs new file mode 100644 index 000000000..b7a894a37 --- /dev/null +++ b/Dakota/Models/Block/BlockKostenträger.cs @@ -0,0 +1,51 @@ +using Dakota.Models.Nachrichten; +using Dakota.Models.Segmente; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Block +{ + /// + /// Wiederhole folgenden Block je IK des Kostenträgers + /// + internal class BlockKostenträger : Nachricht + { + public SegmentUNH SegmentUNH { get; private set; } + public NachrichtSLGA NachrichtSLGA { get; private set; } + public SegmentUNT SegmentUNT { get; private set; } + public List BlockKrankenkarteVerordnung { get; private set; } + + public string IKKostenträger + { + get { return NachrichtSLGA.SegmentFKT.IKKostenträger.GetValue(); } + set { NachrichtSLGA.SegmentFKT.IKKostenträger.SetValue(value); } + } + + internal BlockKostenträger() + { + SegmentUNH = new SegmentUNH(); + NachrichtSLGA = new NachrichtSLGA(); + SegmentUNT = new SegmentUNT(GetSegmentLength); + BlockKrankenkarteVerordnung = new List(); + } + + public override List GetSegments() + { + var list = new List(); + + list.Add(SegmentUNH); + list.AddRange(NachrichtSLGA.GetSegments()); + list.Add(SegmentUNT); + + foreach (var block in BlockKrankenkarteVerordnung) + { + list.AddRange(block.GetSegments()); + } + + return list; + } + } +} diff --git a/Dakota/Models/Block/BlockKrankenkarteVerordnung.cs b/Dakota/Models/Block/BlockKrankenkarteVerordnung.cs new file mode 100644 index 000000000..fab2ba01a --- /dev/null +++ b/Dakota/Models/Block/BlockKrankenkarteVerordnung.cs @@ -0,0 +1,55 @@ +using Dakota.Models.Nachrichten; +using Dakota.Models.Segmente; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Block +{ + /// + /// Wiederhole folgenden Block je IK der Krankenkarte bzw der Verordnung + /// + internal class BlockKrankenkarteVerordnung : Nachricht + { + public SegmentUNH SegmentSLGAUNH { get; private set; } + public NachrichtSLGA2 SLGANachricht2 { get; private set; } + public SegmentUNT SegmentSLGAUNT { get; private set; } + public SegmentUNH SegmentSLLAUNH { get; private set; } + public NachrichtSLLA2 SLLANachricht2 { get; private set; } + public SegmentUNT SegmentSLLAUNT { get; private set; } + + public BlockKrankenkarteVerordnung() + { + SegmentSLGAUNH = new SegmentUNH(); + SLGANachricht2 = new NachrichtSLGA2(); + SegmentSLGAUNT = new SegmentUNT(SLGASegmentLength); + SegmentSLLAUNH = new SegmentUNH(); + SLLANachricht2 = new NachrichtSLLA2(); + SegmentSLLAUNT = new SegmentUNT(SLLASegmentLength); + } + + public string IKKrankenkasseKVKarte + { + get { return SLGANachricht2.SegmentFKT.IKKrankenkasseKVKarte.GetValue(); } + set { SLGANachricht2.SegmentFKT.IKKrankenkasseKVKarte.SetValue(value); } + } + + public int SLGASegmentLength() => SLGANachricht2.GetSegmentLength() + 2; + public int SLLASegmentLength() => SLLANachricht2.GetSegmentLength() + 2; + + public override List GetSegments() + { + var list = new List() { SegmentSLGAUNH }; + list.AddRange(SLGANachricht2.GetSegments()); + list.Add(SegmentSLGAUNT); + + list.Add(SegmentSLLAUNH); + list.AddRange(SLLANachricht2.GetSegments()); + list.Add(SegmentSLLAUNT); + + return list; + } + } +} diff --git a/Dakota/Models/Block/BlockNutzdatendatei.cs b/Dakota/Models/Block/BlockNutzdatendatei.cs new file mode 100644 index 000000000..c7deb01ba --- /dev/null +++ b/Dakota/Models/Block/BlockNutzdatendatei.cs @@ -0,0 +1,44 @@ +using Dakota.Models.Nachrichten; +using Dakota.Models.Segmente; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Block +{ + /// + /// Nutzdatendatei ohne Logik + /// + internal class BlockNutzdatendatei : Nachricht + { + public SegmentUNB SegmentUNB { get; private set; } + public List BlockKostenträger { get; private set; } + public SegmentUNZ SegmentUNZ { get; private set; } + + internal BlockNutzdatendatei() + { + SegmentUNB = new SegmentUNB(); + BlockKostenträger = new List(); + SegmentUNZ = new SegmentUNZ(); + } + + public override List GetSegments() + { + var list = new List() + { + SegmentUNB + }; + + foreach (var block in BlockKostenträger) + { + list.AddRange(block.GetSegments()); + } + + list.Add(SegmentUNZ); + + return list; + } + } +} diff --git a/Dakota/Models/Datei/BlockKostenträger.cs b/Dakota/Models/Datei/BlockKostenträger.cs deleted file mode 100644 index 0b2aae291..000000000 --- a/Dakota/Models/Datei/BlockKostenträger.cs +++ /dev/null @@ -1,34 +0,0 @@ -using Dakota.Models.Nachricht; -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Datei -{ - /// - /// Wiederhole folgenden Block je IK des Kostenträgers - /// - internal class BlockKostenträger : IRowable - { - public SegmentUNH UNH { get; private set; } - public NachrichtSLGA NachrichtSLGA { get; private set; } - public SegmentUNT UNT { get; private set; } - public List BlockKrankenkarteVerordnung { get; set; } - - internal BlockKostenträger() - { - UNH = new SegmentUNH(); - NachrichtSLGA = new NachrichtSLGA(); - UNT = new SegmentUNT(); - BlockKrankenkarteVerordnung = new List(); - } - - public string GetRows() - { - return UNH.GetRows() + NachrichtSLGA.GetRows() + UNT.GetRows() + string.Join("", BlockKrankenkarteVerordnung.Select(x => x.GetRows())); - } - } -} diff --git a/Dakota/Models/Datei/BlockKrankenkarteVerordnung.cs b/Dakota/Models/Datei/BlockKrankenkarteVerordnung.cs deleted file mode 100644 index ab95c1d43..000000000 --- a/Dakota/Models/Datei/BlockKrankenkarteVerordnung.cs +++ /dev/null @@ -1,39 +0,0 @@ -using Dakota.Models.Nachricht; -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Datei -{ - /// - /// Wiederhole folgenden Block je IK der Krankenkarte bzw der Verordnung - /// - internal class BlockKrankenkarteVerordnung : IRowable - { - public SegmentUNH SLGAUNH { get; private set; } - public NachrichtSLGA2 SLGANachricht2 { get; private set; } - public SegmentUNT SLGAUNT { get; private set; } - public SegmentUNH SLLAUNH { get; private set; } - public NachrichtSLLA2 SLLANachricht2 { get; private set; } - public SegmentUNT SLLAUNT { get; private set; } - - public BlockKrankenkarteVerordnung() - { - SLGAUNH = new SegmentUNH(); - SLGANachricht2 = new NachrichtSLGA2(); - SLGAUNT = new SegmentUNT(); - SLLAUNH = new SegmentUNH(); - SLLANachricht2 = new NachrichtSLLA2(); - SLLAUNT = new SegmentUNT(); - } - - public string GetRows() - { - return SLGAUNH.GetRows() + SLGANachricht2.GetRows() + SLGAUNT.GetRows() + - SLLAUNH.GetRows() + SLLANachricht2.GetRows() + SLLAUNT.GetRows(); - } - } -} diff --git a/Dakota/Models/Datei/Nutzdatendatei.cs b/Dakota/Models/Datei/Nutzdatendatei.cs deleted file mode 100644 index 0c4b3fdd0..000000000 --- a/Dakota/Models/Datei/Nutzdatendatei.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Datei -{ - internal class Nutzdatendatei - { - - //public List Nachrichten { get; set; } - - //public Nutzdatendatei() - //{ - // Nachrichten = new List(); - //} - } -} diff --git a/Dakota/Models/Datei/SozioTherapieDatei.cs b/Dakota/Models/Datei/SozioTherapieDatei.cs deleted file mode 100644 index 763faec9c..000000000 --- a/Dakota/Models/Datei/SozioTherapieDatei.cs +++ /dev/null @@ -1,26 +0,0 @@ -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Datei -{ - internal class SozioTherapieDatei : IRowable - { - public SegmentUNB UNB { get; set; } - public List BlockKostenträger { get; set; } - public SegmentUNZ UNZ { get; set; } - - internal SozioTherapieDatei() - { - BlockKostenträger = new List(); - } - - public string GetRows() - { - return UNB.GetRows() + string.Join(string.Empty, BlockKostenträger.Select(x => x.GetRows())) + UNZ.GetRows(); - } - } -} diff --git a/Dakota/Models/Datei/SozioTherapieEinzelnachweis.cs b/Dakota/Models/Datei/SozioTherapieEinzelnachweis.cs deleted file mode 100644 index 61f146570..000000000 --- a/Dakota/Models/Datei/SozioTherapieEinzelnachweis.cs +++ /dev/null @@ -1,28 +0,0 @@ -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Datei -{ - internal class SozioTherapieEinzelnachweis : IRowable - { - public SegmentUNB UNB { get; set; } - public BlockKrankenkarteVerordnung BlockKrankenkarteVerordnung { get; set; } - public SegmentUNZ UNZ { get; set; } - - internal SozioTherapieEinzelnachweis() - { - UNB = new SegmentUNB(); - BlockKrankenkarteVerordnung = new BlockKrankenkarteVerordnung(); - UNZ = new SegmentUNZ(); - } - - public string GetRows() - { - return UNB.GetRows() + string.Join(string.Empty, BlockKrankenkarteVerordnung.GetRows() + UNZ.GetRows()); - } - } -} diff --git a/Dakota/Models/DatenelementCounter.cs b/Dakota/Models/DatenelementCounter.cs new file mode 100644 index 000000000..bbe6b65e7 --- /dev/null +++ b/Dakota/Models/DatenelementCounter.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models +{ + internal class DatenelementCounter : Datenelement + { + public Func Counter { get; private set; } + + public DatenelementCounter(string title, int count, Func counter) : base(title, count, Feldart.Muss) + { + Counter = counter; + } + + public void Update() + { + SetFilledIntValue(Counter(), MinStellen); + } + + public override string GetValue() + { + Update(); + + return base.GetValue(); + } + } +} diff --git a/Dakota/Models/IRowable.cs b/Dakota/Models/IRowable.cs index e424e319e..a3d9b3b07 100644 --- a/Dakota/Models/IRowable.cs +++ b/Dakota/Models/IRowable.cs @@ -6,7 +6,7 @@ using System.Threading.Tasks; namespace Dakota.Models { - public interface IRowable + internal interface IRow { string GetRows(); } diff --git a/Dakota/Models/Nachricht/Nachricht.cs b/Dakota/Models/Nachrichten/Nachricht.cs similarity index 64% rename from Dakota/Models/Nachricht/Nachricht.cs rename to Dakota/Models/Nachrichten/Nachricht.cs index de7f2b488..c7f4ce221 100644 --- a/Dakota/Models/Nachricht/Nachricht.cs +++ b/Dakota/Models/Nachrichten/Nachricht.cs @@ -5,11 +5,16 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Dakota.Models.Nachricht +namespace Dakota.Models.Nachrichten { - internal abstract class Nachricht : IRowable + internal abstract class Nachricht : IRow { public abstract List GetSegments(); + + public int GetSegmentLength() + { + return GetSegments().Count; + } public string GetRows() { diff --git a/Dakota/Models/Nachricht/NachrichtSLGA.cs b/Dakota/Models/Nachrichten/NachrichtSLGA.cs similarity index 96% rename from Dakota/Models/Nachricht/NachrichtSLGA.cs rename to Dakota/Models/Nachrichten/NachrichtSLGA.cs index 52cd87268..caddada42 100644 --- a/Dakota/Models/Nachricht/NachrichtSLGA.cs +++ b/Dakota/Models/Nachrichten/NachrichtSLGA.cs @@ -1,11 +1,12 @@ using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLGA; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Dakota.Models.Nachricht +namespace Dakota.Models.Nachrichten { /// /// Gesamtaufstellung der diff --git a/Dakota/Models/Nachricht/NachrichtSLGA2.cs b/Dakota/Models/Nachrichten/NachrichtSLGA2.cs similarity index 96% rename from Dakota/Models/Nachricht/NachrichtSLGA2.cs rename to Dakota/Models/Nachrichten/NachrichtSLGA2.cs index b8d5c18f2..0002cdb78 100644 --- a/Dakota/Models/Nachricht/NachrichtSLGA2.cs +++ b/Dakota/Models/Nachrichten/NachrichtSLGA2.cs @@ -1,11 +1,12 @@ using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLGA; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; -namespace Dakota.Models.Nachricht +namespace Dakota.Models.Nachrichten { /// /// Gesamtaufstellung der diff --git a/Dakota/Models/Nachrichten/NachrichtSLGA3.cs b/Dakota/Models/Nachrichten/NachrichtSLGA3.cs new file mode 100644 index 000000000..a72c9327d --- /dev/null +++ b/Dakota/Models/Nachrichten/NachrichtSLGA3.cs @@ -0,0 +1,60 @@ +using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLGA; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Nachrichten +{ + /// + /// Gesamtaufstellung der + /// Abrechnung(Rechnung) + /// + internal class NachrichtSLGA3 : Nachricht + { + /// + /// 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; } + + public NachrichtSLGA3() + { + SegmentFKT = new SegmentSLGAFKT(); + SegmentREC = new SegmentSLGAREC(); + SegmentUST = new SegmentSLGAUST(); + SegmentSKO = new SegmentSLGASKO(); + SegmentGES = new SegmentSLGAGES(); + SegmentNAM = new SegmentSLGANAM(); + } + + public override List GetSegments() + { + return new List() { SegmentFKT, SegmentREC, SegmentUST, SegmentSKO, SegmentGES, SegmentNAM }; + } + } +} diff --git a/Dakota/Models/Nachricht/NachrichtSLLA.cs b/Dakota/Models/Nachrichten/NachrichtSLLA.cs similarity index 89% rename from Dakota/Models/Nachricht/NachrichtSLLA.cs rename to Dakota/Models/Nachrichten/NachrichtSLLA.cs index 01e90795e..48eba537a 100644 --- a/Dakota/Models/Nachricht/NachrichtSLLA.cs +++ b/Dakota/Models/Nachrichten/NachrichtSLLA.cs @@ -1,127 +1,134 @@ -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Nachricht -{ - /// - /// Leistungserbringer - /// - internal class NachrichtSLLA : Nachricht - { - /// - /// 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; } - - /// - /// Das Segment dient zur Abrechnung der einzelnen Positionen, /// die für den abzurechnenden Fall angefallen sind.Es ist so oft - /// wiederholbar, wie Abrechnungspositionen vorkommen. - /// - public SegmentSLLAENF SegmentSLLAENF { get; private set; } - /// - /// Mit diesem Segment können weitere Informationen, bezogen /// auf die abzurechnende Position übermittelt werden.Hier können u.a.die Uhrzeit und die gefahrenen Kilometer angegeben - /// werden. Es kann je abzurechnende Position einmal vorkommen - /// - public SegmentSLLASUT SegmentSLLASUT { get; private set; } - /// - /// Mit diesem Segment kann zu jeder abzurechnenden Position - /// ein Text(z.B.als Begründung) hinterlegt werden.Es kann je - /// abzurechnende Position einmal vorkommen. - /// - public SegmentSLLATXT SegmentSLLATXT { get; private set; } - /// - /// Mit diesem Segment kann zu jeder abzurechnenden Position /// Mehrwertsteuer angegeben werden.Benutzt werden soll das /// Segment nur dann, wenn dem in ENF genannten Einzelbetrag - /// die Mehrwertsteuer hinzuzurechnen ist. - /// - public SegmentSLLAMWS SegmentSLLAMWS { get; private set; } - /// - /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist - /// für spätere Ausprägungen reserviert. - /// - public SegmentSLLAZUZ SegmentSLLAZUZ { get; private set; } - /// - /// Das Segment enthält allgemeine Angaben zum Abrechnungsfall (Verordnung) und ist zu übermitteln, wenn eine ärztliche /// Verordnung, ein Reparatur- oder Berechtigungsschein oder - /// Unfall/BVG vorliegt. - /// - public SegmentSLLAZUV SegmentSLLAZUV { get; private set; } - /// - /// Das Segment dient zur Angabe der Diagnose und ist so oft - /// wiederholbar, wie Diagnosen vorliegen - /// - public SegmentSLLADIA SegmentSLLADIA { get; private set; } - /// - /// Das Segment enthält Angaben über die von der Krankenkasse /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu - /// übermitteln, wenn diese vorliegt. - /// - public SegmentSLLASKZ SegmentSLLASKZ { get; private set; } - /// - /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung) - /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer) - /// - public SegmentSLLABES SegmentSLLABES { get; private set; } - - public NachrichtSLLA() - { - SegmentSLLAFKT = new SegmentSLLAFKT(); - SegmentSLLAREC = new SegmentSLLAREC(); - SegmentSLLAINV = new SegmentSLLAINV(); - SegmentSLLAURI = new SegmentSLLAURI(); - SegmentSLLANAD = new SegmentSLLANAD(); - SegmentSLLAIMG = new SegmentSLLAIMG(); - - SegmentSLLAENF = new SegmentSLLAENF(); - SegmentSLLASUT = new SegmentSLLASUT(); - SegmentSLLATXT = new SegmentSLLATXT(); - SegmentSLLAMWS = new SegmentSLLAMWS(); - SegmentSLLAZUZ = new SegmentSLLAZUZ(); - SegmentSLLAZUV = new SegmentSLLAZUV(); - SegmentSLLADIA = new SegmentSLLADIA(); - SegmentSLLASKZ = new SegmentSLLASKZ(); - SegmentSLLABES = new SegmentSLLABES(); - } - - public override List GetSegments() - { - return new List() { SegmentSLLAFKT, SegmentSLLAREC, SegmentSLLAINV, SegmentSLLAURI, SegmentSLLANAD, SegmentSLLAIMG, - SegmentSLLAENF, SegmentSLLASUT, SegmentSLLATXT, SegmentSLLAMWS, - SegmentSLLAZUZ, SegmentSLLAZUV, SegmentSLLADIA, SegmentSLLASKZ, SegmentSLLABES - }; - } - } -} +using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLLA; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Nachrichten +{ + /// + /// Leistungserbringer + /// + internal class NachrichtSLLA : Nachricht + { + /// + /// 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; } + + /// + /// Das Segment dient zur Abrechnung der einzelnen Positionen, + /// die für den abzurechnenden Fall angefallen sind.Es ist so oft + /// wiederholbar, wie Abrechnungspositionen vorkommen. + /// + public SegmentSLLAENF SegmentSLLAENF { get; private set; } + /// + /// Mit diesem Segment können weitere Informationen, bezogen + /// auf die abzurechnende Position übermittelt werden.Hier können u.a.die Uhrzeit und die gefahrenen Kilometer angegeben + /// werden. Es kann je abzurechnende Position einmal vorkommen + /// + public SegmentSLLASUT SegmentSLLASUT { get; private set; } + /// + /// Mit diesem Segment kann zu jeder abzurechnenden Position + /// ein Text(z.B.als Begründung) hinterlegt werden.Es kann je + /// abzurechnende Position einmal vorkommen. + /// + public SegmentSLLATXT SegmentSLLATXT { get; private set; } + /// + /// Mit diesem Segment kann zu jeder abzurechnenden Position + /// Mehrwertsteuer angegeben werden.Benutzt werden soll das + /// Segment nur dann, wenn dem in ENF genannten Einzelbetrag + /// die Mehrwertsteuer hinzuzurechnen ist. + /// + public SegmentSLLAMWS SegmentSLLAMWS { get; private set; } + /// + /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist + /// für spätere Ausprägungen reserviert. + /// + public SegmentSLLAZUZ SegmentSLLAZUZ { get; private set; } + /// + /// Das Segment enthält allgemeine Angaben zum Abrechnungsfall (Verordnung) und ist zu übermitteln, wenn eine ärztliche + /// Verordnung, ein Reparatur- oder Berechtigungsschein oder + /// Unfall/BVG vorliegt. + /// + public SegmentSLLAZUV SegmentSLLAZUV { get; private set; } + /// + /// Das Segment dient zur Angabe der Diagnose und ist so oft + /// wiederholbar, wie Diagnosen vorliegen + /// + public SegmentSLLADIA SegmentSLLADIA { get; private set; } + /// + /// Das Segment enthält Angaben über die von der Krankenkasse + /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu + /// übermitteln, wenn diese vorliegt. + /// + public SegmentSLLASKZ SegmentSLLASKZ { get; private set; } + /// + /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung) + /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer) + /// + public SegmentSLLABES SegmentSLLABES { get; private set; } + + public NachrichtSLLA() + { + SegmentSLLAFKT = new SegmentSLLAFKT(); + SegmentSLLAREC = new SegmentSLLAREC(); + SegmentSLLAINV = new SegmentSLLAINV(); + SegmentSLLAURI = new SegmentSLLAURI(); + SegmentSLLANAD = new SegmentSLLANAD(); + SegmentSLLAIMG = new SegmentSLLAIMG(); + + SegmentSLLAENF = new SegmentSLLAENF(); + SegmentSLLASUT = new SegmentSLLASUT(); + SegmentSLLATXT = new SegmentSLLATXT(); + SegmentSLLAMWS = new SegmentSLLAMWS(); + SegmentSLLAZUZ = new SegmentSLLAZUZ(); + SegmentSLLAZUV = new SegmentSLLAZUV(); + SegmentSLLADIA = new SegmentSLLADIA(); + SegmentSLLASKZ = new SegmentSLLASKZ(); + SegmentSLLABES = new SegmentSLLABES(); + } + + public override List GetSegments() + { + return new List() { SegmentSLLAFKT, SegmentSLLAREC, SegmentSLLAINV, SegmentSLLAURI, SegmentSLLANAD, SegmentSLLAIMG, + SegmentSLLAENF, SegmentSLLASUT, SegmentSLLATXT, SegmentSLLAMWS, + SegmentSLLAZUZ, SegmentSLLAZUV, SegmentSLLADIA, SegmentSLLASKZ, SegmentSLLABES + }; + } + } +} diff --git a/Dakota/Models/Nachricht/NachrichtSLLA2.cs b/Dakota/Models/Nachrichten/NachrichtSLLA2.cs similarity index 94% rename from Dakota/Models/Nachricht/NachrichtSLLA2.cs rename to Dakota/Models/Nachrichten/NachrichtSLLA2.cs index 50e475c48..74001e25e 100644 --- a/Dakota/Models/Nachricht/NachrichtSLLA2.cs +++ b/Dakota/Models/Nachrichten/NachrichtSLLA2.cs @@ -1,116 +1,119 @@ -using Dakota.Models.Segmente; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Dakota.Models.Nachricht -{ - /// - /// Leistungserbringer - /// - internal class NachrichtSLLA2 : Nachricht - { - /// - /// 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; } - /// - /// Das Segment dient zur Abrechnung der einzelnen Positionen, /// die für den abzurechnenden Fall angefallen sind. - /// Es ist so oft - /// wiederholbar, wie Abrechnungspositionen vorkommen. - /// - public List Abrechnungspositions { get; set; } - /// - /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist - /// für spätere Ausprägungen reserviert. - /// - public SegmentSLLAZUV SegmentSLLAZUV { get; private set; } - /// - /// Das Segment dient zur Angabe der Diagnose und ist so oft - /// wiederholbar, wie Diagnosen vorliegen - /// - public SegmentSLLADIA SegmentSLLADIA { get; private set; } - /// - /// Das Segment enthält Angaben über die von der Krankenkasse /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu - /// übermitteln, wenn diese vorliegt. - /// - public SegmentSLLASKZ SegmentSLLASKZ { get; private set; } - /// - /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung) - /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer) - /// - public SegmentSLLABES SegmentSLLABES { get; private set; } - - public NachrichtSLLA2() - { - SegmentSLLAFKT = new SegmentSLLAFKT(); - SegmentSLLAREC = new SegmentSLLAREC(); - SegmentSLLAINV = new SegmentSLLAINV(); - SegmentSLLAURI = new SegmentSLLAURI(); - SegmentSLLANAD = new SegmentSLLANAD(); - SegmentSLLAIMG = new SegmentSLLAIMG(); - - Abrechnungspositions = new List(); - - SegmentSLLAZUV = new SegmentSLLAZUV(); - SegmentSLLADIA = new SegmentSLLADIA(); - SegmentSLLASKZ = new SegmentSLLASKZ(); - SegmentSLLABES = new SegmentSLLABES(); - } - - public void AddPosition(Abrechnungsposition pos) - { - Abrechnungspositions.Add(pos); - } - - public override List GetSegments() - { - var list = new List() { SegmentSLLAFKT, SegmentSLLAREC, SegmentSLLAINV, SegmentSLLAURI, SegmentSLLANAD, SegmentSLLAIMG }; - var list2 = new List() { SegmentSLLABES }; - //var list2 = new List() { SegmentSLLAZUZ, SegmentSLLAZUV, SegmentSLLADIA, SegmentSLLASKZ, SegmentSLLABES }; - - foreach (var seg in Abrechnungspositions) - { - list.AddRange(seg.GetSegments()); - } - - list.AddRange(list2); - - return list; - } - } -} +using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLLA; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Nachrichten +{ + /// + /// Leistungserbringer + /// + internal class NachrichtSLLA2 : Nachricht + { + /// + /// 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; } + /// + /// Das Segment dient zur Abrechnung der einzelnen Positionen, + /// die für den abzurechnenden Fall angefallen sind. + /// Es ist so oft + /// wiederholbar, wie Abrechnungspositionen vorkommen. + /// + public List Abrechnungspositions { get; set; } + /// + /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist + /// für spätere Ausprägungen reserviert. + /// + public SegmentSLLAZUV SegmentSLLAZUV { get; private set; } + /// + /// Das Segment dient zur Angabe der Diagnose und ist so oft + /// wiederholbar, wie Diagnosen vorliegen + /// + public SegmentSLLADIA SegmentSLLADIA { get; private set; } + /// + /// Das Segment enthält Angaben über die von der Krankenkasse + /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu + /// übermitteln, wenn diese vorliegt. + /// + public SegmentSLLASKZ SegmentSLLASKZ { get; private set; } + /// + /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung) + /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer) + /// + public SegmentSLLABES SegmentSLLABES { get; private set; } + + public NachrichtSLLA2() + { + SegmentSLLAFKT = new SegmentSLLAFKT(); + SegmentSLLAREC = new SegmentSLLAREC(); + SegmentSLLAINV = new SegmentSLLAINV(); + SegmentSLLAURI = new SegmentSLLAURI(); + SegmentSLLANAD = new SegmentSLLANAD(); + SegmentSLLAIMG = new SegmentSLLAIMG(); + + Abrechnungspositions = new List(); + + SegmentSLLAZUV = new SegmentSLLAZUV(); + SegmentSLLADIA = new SegmentSLLADIA(); + SegmentSLLASKZ = new SegmentSLLASKZ(); + SegmentSLLABES = new SegmentSLLABES(); + } + + public void AddPosition(Abrechnungsposition pos) + { + Abrechnungspositions.Add(pos); + } + + public override List GetSegments() + { + var list = new List() { SegmentSLLAFKT, SegmentSLLAREC, SegmentSLLAINV, SegmentSLLAURI, SegmentSLLANAD, SegmentSLLAIMG }; + var list2 = new List() { SegmentSLLABES }; + //var list2 = new List() { SegmentSLLAZUZ, SegmentSLLAZUV, SegmentSLLADIA, SegmentSLLASKZ, SegmentSLLABES }; + + foreach (var seg in Abrechnungspositions) + { + list.AddRange(seg.GetSegments()); + } + + list.AddRange(list2); + + return list; + } + } +} diff --git a/Dakota/Models/Nachrichten/NachrichtSLLA3.cs b/Dakota/Models/Nachrichten/NachrichtSLLA3.cs new file mode 100644 index 000000000..6f06f1781 --- /dev/null +++ b/Dakota/Models/Nachrichten/NachrichtSLLA3.cs @@ -0,0 +1,50 @@ +using Dakota.Models.Block; +using Dakota.Models.Segmente; +using Dakota.Models.Segmente.SLLA; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Nachrichten +{ + /// + /// Leistungserbringer + /// + internal class NachrichtSLLA3 : Nachricht + { + /// + /// 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; } + /// + /// Abrechnungsfälle (INV - BES) + /// + public List Abrechnungsfalle { get; set; } + + public NachrichtSLLA3() + { + SegmentSLLAFKT = new SegmentSLLAFKT(); + SegmentSLLAREC = new SegmentSLLAREC(); + } + + public override List GetSegments() + { + var list = new List() { SegmentSLLAFKT, SegmentSLLAREC }; + + foreach (var block in Abrechnungsfalle) + { + list.AddRange(block.GetSegments()); + } + + return list; + } + } +} diff --git a/Dakota/Models/Schlüssel/SchlüsselLeistungserbringerSammelgruppenschlussel.cs b/Dakota/Models/Schlüssel/SchlüsselLeistungserbringerSammelgruppenschlussel.cs new file mode 100644 index 000000000..62e48d4a3 --- /dev/null +++ b/Dakota/Models/Schlüssel/SchlüsselLeistungserbringerSammelgruppenschlussel.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Dakota.Models.Schlüssel +{ + public class SchlüsselLeistungserbringerSammelgruppenschlussel : Schlüssel + { + public SchlüsselLeistungserbringerSammelgruppenschlussel(string val) : base(val) { } + + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonHilfsmitteln => new SchlüsselLeistungserbringerSammelgruppenschlussel("A"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonHeilmitteln => new SchlüsselLeistungserbringerSammelgruppenschlussel("B"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonHäuslicherKrankenpflege => new SchlüsselLeistungserbringerSammelgruppenschlussel("C"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonHaushaltshilfe => new SchlüsselLeistungserbringerSammelgruppenschlussel("D"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonKrankentransportleistungen => new SchlüsselLeistungserbringerSammelgruppenschlussel("E"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel Hebammen => new SchlüsselLeistungserbringerSammelgruppenschlussel("F"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel NichtArztlicheDialyseachleistung => new SchlüsselLeistungserbringerSammelgruppenschlussel("G"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonRehabilitationssport => new SchlüsselLeistungserbringerSammelgruppenschlussel("H"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerVonFunktionstraining => new SchlüsselLeistungserbringerSammelgruppenschlussel("I"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel WeitereSonstigeLeistungserbringer => new SchlüsselLeistungserbringerSammelgruppenschlussel("J"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerPräventions => new SchlüsselLeistungserbringerSammelgruppenschlussel("K"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerRehamassnahmen => new SchlüsselLeistungserbringerSammelgruppenschlussel("L"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel SozialpädiatrischeZentren => new SchlüsselLeistungserbringerSammelgruppenschlussel("M"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel SoziotherapeutischerLeistungserbringer => new SchlüsselLeistungserbringerSammelgruppenschlussel("N"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel SAPV => new SchlüsselLeistungserbringerSammelgruppenschlussel("O"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel LeistungserbringerNach132gSGB => new SchlüsselLeistungserbringerSammelgruppenschlussel("P"); + public static SchlüsselLeistungserbringerSammelgruppenschlussel Kurzzeitpflege => new SchlüsselLeistungserbringerSammelgruppenschlussel("Q"); + } +} diff --git a/Dakota/Models/Segmente/SLGA/SegmentSLGAFKT.cs b/Dakota/Models/Segmente/SLGA/SegmentSLGAFKT.cs index 1746f66a7..60e88daa3 100644 --- a/Dakota/Models/Segmente/SLGA/SegmentSLGAFKT.cs +++ b/Dakota/Models/Segmente/SLGA/SegmentSLGAFKT.cs @@ -44,7 +44,7 @@ namespace Dakota.Models.Segmente.SLGA /// Angabe identisch mit SLLA.FKT.IK der /// Krankenkasse der zugehörigen SLLANachricht. /// - public Datenelement IKKrankenkasse { get; private set; } + public Datenelement IKKrankenkasseKVKarte { get; private set; } /// /// Einzutragen ist das IK des Absenders der Datei. Diese Angabe ist identisch mit UNB.Absender /// @@ -56,7 +56,7 @@ namespace Dakota.Models.Segmente.SLGA Sammelrechnung = new Datenelement("Sammelrechnung", 1, Feldart.Kann); IKLeistungserbringers = new Datenelement("IKLeistungserbringers", 9, Feldart.Muss); IKKostenträger = new Datenelement("IKKostenträger", 9, Feldart.Muss); - IKKrankenkasse = new Datenelement("IKKrankenkasse", 9, Feldart.Kann); + IKKrankenkasseKVKarte = new Datenelement("IKKrankenkasse", 9, Feldart.Kann); IKAbsender = new Datenelement("IKAbsender", 9, Feldart.Muss); } diff --git a/Dakota/Models/Segmente/Segment.cs b/Dakota/Models/Segmente/Segment.cs index 60ebeffdb..80c353dba 100644 --- a/Dakota/Models/Segmente/Segment.cs +++ b/Dakota/Models/Segmente/Segment.cs @@ -6,7 +6,7 @@ using System.Threading.Tasks; namespace Dakota.Models.Segmente { - internal abstract class Segment : IRowable + internal abstract class Segment : IRow { //public List Datenelemente { get; set; } diff --git a/Dakota/Models/Segmente/SegmentUNT.cs b/Dakota/Models/Segmente/SegmentUNT.cs index 2f990be56..8a6329d8c 100644 --- a/Dakota/Models/Segmente/SegmentUNT.cs +++ b/Dakota/Models/Segmente/SegmentUNT.cs @@ -15,15 +15,15 @@ namespace Dakota.Models.Segmente /// Anzahl der Segmente in der Nachricht einschließlich der Segmente /// UNH und UNT mit führenden Nullen. /// - public Datenelement AnzahlEinheiten { get; private set; } + public DatenelementCounter AnzahlEinheiten { get; private set; } /// /// wie in UNH /// public Datenelement Nachrichtenreferenznummer { get; private set; } - public SegmentUNT() + public SegmentUNT(Func counter) { - AnzahlEinheiten = new Datenelement("AnzahlEinheiten", 6, Feldart.Muss); + AnzahlEinheiten = new DatenelementCounter("AnzahlEinheiten", 6, counter); Nachrichtenreferenznummer = new Datenelement("Nachrichtenreferenznummer", 0, 14, Feldart.Muss); } diff --git a/Service/Service.csproj b/Service/Service.csproj index fd7726661..1930c9934 100644 --- a/Service/Service.csproj +++ b/Service/Service.csproj @@ -478,7 +478,6 @@ - @@ -519,9 +518,13 @@ + + + .editorconfig + Designer diff --git a/Service/ServiceImplementations/OperationsServiceImp.cs b/Service/ServiceImplementations/OperationsServiceImp.cs index 87df8d768..2eedcfbcc 100644 --- a/Service/ServiceImplementations/OperationsServiceImp.cs +++ b/Service/ServiceImplementations/OperationsServiceImp.cs @@ -7705,15 +7705,28 @@ namespace BeWo.Service.ServiceImplementations { try { - var baseoid = long.Parse((string)param); + // Hier Input Daten Aufbrechen und jeweils den Files zuordnen - var accounting = new AccountingServiceImp(); + // Dann jeweils Info erzeugen - var invoice = accounting.GetServiceInvoiceByInvoiceBaseOid(baseoid); + // Und final dann Datei(en) + + var year = 2023; + var month = 6; + + var rechnungsnummer = "xyz"; + + var code = DakotaFileCreator.GenerateDakotaFilesByMonth(year, month); + + //var baseoid = long.Parse((string)param); + + //var accounting = new AccountingServiceImp(); + + //var invoice = accounting.GetServiceInvoiceByInvoiceBaseOid(baseoid); - var code = DakotaFileCreator.GetAsciiCode(invoice); + //var code = DakotaFileCreator.GenerateAsciiCode(invoice); - return code; + return code.FirstOrDefault(); } catch (Exception e) { diff --git a/Service/ServiceUtils/Generell/DakotaFileCreator.cs b/Service/ServiceUtils/Generell/DakotaFileCreator.cs deleted file mode 100644 index 457c1c3b5..000000000 --- a/Service/ServiceUtils/Generell/DakotaFileCreator.cs +++ /dev/null @@ -1,64 +0,0 @@ -using BS.Shared.DataContracts; -using Dakota; -using Dakota.Models.Schlüssel; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace BeWo.Service.ServiceUtils.Generell -{ - public static class DakotaFileCreator - { - public static string GetAsciiCode(ServiceInvoiceDC dc) - { - var info = LoadInfo(dc); - - var file = new DakotaFile(); - - file.Generate(info); - - return file.GetRows(); - } - - public static DakotaFileInfo LoadInfo(ServiceInvoiceDC dc) - { - var res = new DakotaFileInfo(); - - res.Absenderbezeichnung = "123456789"; - res.Empfangerbezeichnung = "987654321"; - res.Datenaustauschreferenz = 1; - res.Anwendungsreferenz = "abovollkra.txt"; - res.Testindikator = SchlüsselTestindikator.Testdatei; - - res.IKLeistungserbringers = "abovollkrass.txt"; - res.IKKostenträger = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - res.Rechnungsnummer = dc.InvoiceBase.InvoiceNumber; - // Einheitlich monatlich - res.Rechnungsdatum = dc.InvoiceBase.InvoiceDate.Value; - - res.Summenstatus = SchlüsselSummenstatus.Mitglieder; - res.Gesamtrechnungsbetrag = 3.5m; - res.Gesamtbruttobetrag = 3.5m; - res.GesamtbetragZuzahlung = 3.5m; - res.Rechnungsart = SchlüsselRechnungsart.AbrechnungVonLeistungserbringer; - res.Name1 = "nam7"; - res.Name2 = "nam4"; - res.Name3 = "nam3"; - res.Name4 = "nam1"; - - res.Verarbeitungskennzeichen = SchlüsselVerarbeitungskennzeichen.AbrechnungOhneBesonderheit; - - res.IKKrankenkasse = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - res.IKKrankenkasse = "abovollkrass.txt"; - - return res; - } - } -}