diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/ClaudiaHeizmannHeilpaedagogik.csproj b/ReportImp/ClaudiaHeizmannHeilpaedagogik/ClaudiaHeizmannHeilpaedagogik.csproj new file mode 100644 index 000000000..ec3f5ebfd --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/ClaudiaHeizmannHeilpaedagogik.csproj @@ -0,0 +1,101 @@ + + + + + Debug + AnyCPU + {BA5DDD2F-7282-4793-A898-B664936B1703} + Library + Properties + ClaudiaHeizmannHeilpaedagogik + 6652893693_Reports + v4.7.2 + 512 + + + + true + full + false + ..\..\CustomerDlls\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + ..\..\CustomerDlls\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + Component + + + QuittierungsbelegIfsEingangsdiagnostik.cs + + + + + {B0D73E3D-4AE7-4024-93A6-DB1F46D7CCEE} + Data + + + {40d8b312-ea64-49e3-a31a-5e57ed4d5654} + Report + + + {094331c3-ecee-4c89-bbfd-4c9ded89f0ef} + Service + + + {2f50b83d-a3f0-4ec4-979a-3f9b7e3d8ed4} + Shared + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + QuittierungsbelegIfsEingangsdiagnostik.cs + Designer + + + + \ No newline at end of file diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/Logo.jpg b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Logo.jpg new file mode 100644 index 000000000..caa95b27e Binary files /dev/null and b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Logo.jpg differ diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/AssemblyInfo.cs b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..930888dd6 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/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("KundeXyz")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("KundeXyz")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[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("c1fed668-adb9-47e0-b589-1389618e1b6e")] + +// 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/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.Designer.cs b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.Designer.cs new file mode 100644 index 000000000..f395cc7e5 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.42000 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +namespace ClaudiaHeizmannHeilpaedagogik.Properties { + using System; + + + /// + /// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + /// + // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert + // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. + // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen + // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ClaudiaHeizmannHeilpaedagogik.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Ãœberschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + /// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.resx b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/licenses.licx b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/licenses.licx new file mode 100644 index 000000000..d59547a61 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/Properties/licenses.licx @@ -0,0 +1 @@ +DevExpress.XtraReports.UI.XtraReport, DevExpress.XtraReports.v23.2, Version=23.2.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.Designer.cs b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.Designer.cs new file mode 100644 index 000000000..34773d70e --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.Designer.cs @@ -0,0 +1,653 @@ +using BeWo.Report.ReportObjects; +namespace ClaudiaHeizmannHeilpaedagogik +{ + partial class QuittierungsbelegIfsEingangsdiagnostik + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(QuittierungsbelegIfsEingangsdiagnostik)); + this.Detail = new DevExpress.XtraReports.UI.DetailBand(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrPictureBox1 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.lblNachweisFuer = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable3 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow14 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell41 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell16 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.fieldEinzel = new DevExpress.XtraReports.UI.CalculatedField(); + this.fieldGruppe = new DevExpress.XtraReports.UI.CalculatedField(); + this.DetailReport2 = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail3 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable2 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow1 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupFooter2 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrTable1 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow2 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell7 = new DevExpress.XtraReports.UI.XRTableCell(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.ruleBorderUnten = new DevExpress.XtraReports.UI.FormattingRule(); + this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblBewilligungen = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel7 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTableCell8 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell9 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell10 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow3 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell11 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell13 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell14 = new DevExpress.XtraReports.UI.XRTableCell(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + // + // Detail + // + this.Detail.HeightF = 0F; + this.Detail.Name = "Detail"; + this.Detail.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrLabel11 + // + this.xrLabel11.Font = new DevExpress.Drawing.DXFont("Segoe UI", 14F); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(384.2522F, 0F); + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(342.7475F, 29.50003F); + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.Text = "Beleg-Nr.: [CustomerInsuranceNumer]-FF-[EndDate!!yyyy-MM]"; + // + // xrLabel6 + // + this.xrLabel6.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(45.83359F, 123.7917F); + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(347.29F, 23F); + this.xrLabel6.StylePriority.UseFont = false; + this.xrLabel6.Text = "Aktenzeichen: [ReferenceNumber]"; + // + // xrPictureBox1 + // + this.xrPictureBox1.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox1.ImageSource")); + this.xrPictureBox1.LocationFloat = new DevExpress.Utils.PointFloat(45.83359F, 58.625F); + this.xrPictureBox1.Name = "xrPictureBox1"; + this.xrPictureBox1.SizeF = new System.Drawing.SizeF(672.205F, 110.0834F); + this.xrPictureBox1.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // topMarginBand1 + // + this.topMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrPictureBox1}); + this.topMarginBand1.HeightF = 257.25F; + this.topMarginBand1.Name = "topMarginBand1"; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // lblNachweisFuer + // + this.lblNachweisFuer.Font = new DevExpress.Drawing.DXFont("Segoe UI", 16F, DevExpress.Drawing.DXFontStyle.Bold); + this.lblNachweisFuer.LocationFloat = new DevExpress.Utils.PointFloat(45.83359F, 0F); + this.lblNachweisFuer.Name = "lblNachweisFuer"; + this.lblNachweisFuer.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblNachweisFuer.SizeF = new System.Drawing.SizeF(268.8335F, 32.99999F); + this.lblNachweisFuer.StylePriority.UseFont = false; + this.lblNachweisFuer.Text = "Fördernachweis/-konto"; + // + // xrTable3 + // + this.xrTable3.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTable3.Font = new DevExpress.Drawing.DXFont("Segoe UI", 10F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTable3.LocationFloat = new DevExpress.Utils.PointFloat(45.8298F, 400.125F); + this.xrTable3.Name = "xrTable3"; + this.xrTable3.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow14}); + this.xrTable3.SizeF = new System.Drawing.SizeF(681.1699F, 25F); + this.xrTable3.StylePriority.UseBorderColor = false; + this.xrTable3.StylePriority.UseBorders = false; + this.xrTable3.StylePriority.UseFont = false; + this.xrTable3.StylePriority.UseTextAlignment = false; + this.xrTable3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + // + // xrTableRow14 + // + this.xrTableRow14.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell41, + this.xrTableCell16, + this.xrTableCell6, + this.xrTableCell8}); + this.xrTableRow14.Name = "xrTableRow14"; + this.xrTableRow14.StylePriority.UseBackColor = false; + this.xrTableRow14.Weight = 0.0343897370597854D; + // + // xrTableCell41 + // + this.xrTableCell41.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell41.Name = "xrTableCell41"; + this.xrTableCell41.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell41.StylePriority.UseBorders = false; + this.xrTableCell41.StylePriority.UseFont = false; + this.xrTableCell41.StylePriority.UsePadding = false; + this.xrTableCell41.StylePriority.UseTextAlignment = false; + this.xrTableCell41.Text = "Datum/Monat"; + this.xrTableCell41.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + this.xrTableCell41.Weight = 0.21153845590663789D; + // + // xrTableCell16 + // + this.xrTableCell16.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell16.Multiline = true; + this.xrTableCell16.Name = "xrTableCell16"; + this.xrTableCell16.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell16.StylePriority.UseBorders = false; + this.xrTableCell16.StylePriority.UseFont = false; + this.xrTableCell16.StylePriority.UsePadding = false; + this.xrTableCell16.StylePriority.UseTextAlignment = false; + this.xrTableCell16.Text = "Leistungsbeschreibung"; + this.xrTableCell16.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + this.xrTableCell16.Weight = 0.32275958398488036D; + // + // xrTableCell6 + // + this.xrTableCell6.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell6.Multiline = true; + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.StylePriority.UseBorders = false; + this.xrTableCell6.StylePriority.UseFont = false; + this.xrTableCell6.Text = "Einheiten"; + this.xrTableCell6.Weight = 0.19294558358324743D; + // + // fieldEinzel + // + this.fieldEinzel.DataMember = "ServiceInvoicePeriods.ServiceInvoiceItems"; + this.fieldEinzel.Expression = "Iif([ServiceDescription] == \'Einzelbetreuung\', \'x\', \'\')"; + this.fieldEinzel.Name = "fieldEinzel"; + // + // fieldGruppe + // + this.fieldGruppe.DataMember = "ServiceInvoicePeriods.ServiceInvoiceItems"; + this.fieldGruppe.Expression = "Iif([ServiceDescription] == \'Gruppenbetreuung\', \'x\', \'\')"; + this.fieldGruppe.Name = "fieldGruppe"; + // + // DetailReport2 + // + this.DetailReport2.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail3, + this.GroupFooter2}); + this.DetailReport2.DataMember = "Services"; + this.DetailReport2.DataSource = this.bindingSource1; + this.DetailReport2.Level = 0; + this.DetailReport2.Name = "DetailReport2"; + // + // Detail3 + // + this.Detail3.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable2}); + this.Detail3.Font = new DevExpress.Drawing.DXFont("Segoe UI", 10F); + this.Detail3.HeightF = 24F; + this.Detail3.Name = "Detail3"; + this.Detail3.StylePriority.UseFont = false; + // + // xrTable2 + // + this.xrTable2.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTable2.LocationFloat = new DevExpress.Utils.PointFloat(45.83003F, 0F); + this.xrTable2.Name = "xrTable2"; + this.xrTable2.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow1}); + this.xrTable2.SizeF = new System.Drawing.SizeF(681.1698F, 24F); + this.xrTable2.StylePriority.UseBackColor = false; + this.xrTable2.StylePriority.UseBorderColor = false; + this.xrTable2.StylePriority.UseBorders = false; + // + // xrTableRow1 + // + this.xrTableRow1.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell1, + this.xrTableCell2, + this.xrTableCell3, + this.xrTableCell9}); + this.xrTableRow1.Name = "xrTableRow1"; + this.xrTableRow1.StylePriority.UseFont = false; + this.xrTableRow1.Weight = 0.12000000000000002D; + // + // xrTableCell1 + // + this.xrTableCell1.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.StartDateString", "{0:dd.MM.yyyy}")}); + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell1.StylePriority.UseBorders = false; + this.xrTableCell1.StylePriority.UsePadding = false; + this.xrTableCell1.StylePriority.UseTextAlignment = false; + this.xrTableCell1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell1.Weight = 0.21153810941256002D; + // + // xrTableCell2 + // + this.xrTableCell2.CanShrink = true; + this.xrTableCell2.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.Notice", "{0:0.##}")}); + this.xrTableCell2.Multiline = true; + this.xrTableCell2.Name = "xrTableCell2"; + this.xrTableCell2.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 2, 0, 0, 100F); + this.xrTableCell2.StylePriority.UseBorderColor = false; + this.xrTableCell2.StylePriority.UseBorders = false; + this.xrTableCell2.StylePriority.UseFont = false; + this.xrTableCell2.StylePriority.UsePadding = false; + this.xrTableCell2.StylePriority.UseTextAlignment = false; + this.xrTableCell2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell2.Weight = 0.32275956373948306D; + // + // xrTableCell3 + // + this.xrTableCell3.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell3.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.Notice2")}); + this.xrTableCell3.Name = "xrTableCell3"; + this.xrTableCell3.StylePriority.UseBorders = false; + this.xrTableCell3.StylePriority.UseTextAlignment = false; + this.xrTableCell3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell3.Weight = 0.1929456974909855D; + // + // GroupFooter2 + // + this.GroupFooter2.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable1}); + this.GroupFooter2.HeightF = 48F; + this.GroupFooter2.Name = "GroupFooter2"; + // + // xrTable1 + // + this.xrTable1.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTable1.LocationFloat = new DevExpress.Utils.PointFloat(45.83354F, 0F); + this.xrTable1.Name = "xrTable1"; + this.xrTable1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow3, + this.xrTableRow2}); + this.xrTable1.SizeF = new System.Drawing.SizeF(681.1663F, 48F); + this.xrTable1.StylePriority.UseBackColor = false; + this.xrTable1.StylePriority.UseBorderColor = false; + this.xrTable1.StylePriority.UseBorders = false; + // + // xrTableRow2 + // + this.xrTableRow2.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell4, + this.xrTableCell5, + this.xrTableCell7, + this.xrTableCell10}); + this.xrTableRow2.Name = "xrTableRow2"; + this.xrTableRow2.StylePriority.UseFont = false; + this.xrTableRow2.Weight = 0.12000000000000002D; + // + // xrTableCell4 + // + this.xrTableCell4.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell4.Name = "xrTableCell4"; + this.xrTableCell4.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell4.StylePriority.UseBorders = false; + this.xrTableCell4.StylePriority.UseFont = false; + this.xrTableCell4.StylePriority.UsePadding = false; + this.xrTableCell4.StylePriority.UseTextAlignment = false; + this.xrTableCell4.Text = "Summe"; + this.xrTableCell4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell4.Weight = 0.21153268667367781D; + // + // xrTableCell5 + // + this.xrTableCell5.CanShrink = true; + this.xrTableCell5.Multiline = true; + this.xrTableCell5.Name = "xrTableCell5"; + this.xrTableCell5.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 2, 0, 0, 100F); + this.xrTableCell5.StylePriority.UseBorderColor = false; + this.xrTableCell5.StylePriority.UseBorders = false; + this.xrTableCell5.StylePriority.UseFont = false; + this.xrTableCell5.StylePriority.UsePadding = false; + this.xrTableCell5.StylePriority.UseTextAlignment = false; + this.xrTableCell5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell5.Weight = 0.32275963416466336D; + // + // xrTableCell7 + // + this.xrTableCell7.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell7.Name = "xrTableCell7"; + this.xrTableCell7.StylePriority.UseBorders = false; + this.xrTableCell7.StylePriority.UseTextAlignment = false; + this.xrTableCell7.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell7.Weight = 0.19294560359074503D; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.ServicesOverviewRO); + // + // ruleBorderUnten + // + this.ruleBorderUnten.Condition = "([DataSource.RowCount] == 0)\n Or \n([DataSource.CurrentRowIndex] == [DataSource.Ro" + + "wCount] - 1)"; + this.ruleBorderUnten.DataMember = "Services"; + this.ruleBorderUnten.Formatting.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.ruleBorderUnten.Name = "ruleBorderUnten"; + // + // ReportHeader + // + this.ReportHeader.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel8, + this.xrLabel7, + this.xrLabel5, + this.xrLabel4, + this.lblBewilligungen, + this.xrLabel1, + this.xrLabel3, + this.xrLabel2, + this.xrTable3, + this.lblNachweisFuer, + this.xrLabel11, + this.xrLabel6}); + this.ReportHeader.Font = new DevExpress.Drawing.DXFont("Segoe UI", 10F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.ReportHeader.HeightF = 425.125F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // xrLabel2 + // + this.xrLabel2.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Costbearer")}); + this.xrLabel2.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(45.83359F, 77.79166F); + this.xrLabel2.Multiline = true; + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 96F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(681.166F, 23F); + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "xrLabel2"; + this.xrLabel2.TextFormatString = "Bewilligung/Behörde: {0}"; + // + // xrLabel3 + // + this.xrLabel3.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(45.83359F, 100.7917F); + this.xrLabel3.Multiline = true; + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(681.1661F, 23F); + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Bewilligungsdatum/-zeitraum: [CostBearer2SupportConceptList.SupportConcept.Approv" + + "alDate!dd.MM.yyyy] / [ApprovedStartDate] - [ApprovedEndDate]"; + this.xrLabel3.TextFormatString = "Bewilligungsdatum/-zeitraum:"; + // + // xrLabel1 + // + this.xrLabel1.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(45.83375F, 161.75F); + this.xrLabel1.Multiline = true; + this.xrLabel1.Name = "xrLabel1"; + this.xrLabel1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel1.SizeF = new System.Drawing.SizeF(681.166F, 23F); + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.Text = "Umfang:"; + this.xrLabel1.TextFormatString = "Umfang:"; + // + // lblBewilligungen + // + this.lblBewilligungen.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.lblBewilligungen.LocationFloat = new DevExpress.Utils.PointFloat(45.83378F, 208.2083F); + this.lblBewilligungen.Multiline = true; + this.lblBewilligungen.Name = "lblBewilligungen"; + this.lblBewilligungen.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblBewilligungen.SizeF = new System.Drawing.SizeF(681.166F, 71.95831F); + this.lblBewilligungen.StylePriority.UseFont = false; + this.lblBewilligungen.TextFormatString = "Umfang:"; + // + // xrLabel4 + // + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(45.82984F, 301.5F); + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(450.0037F, 23F); + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "Für Name: [CustomerFirstName] [CustomerLastName], *[CustomerBirthday!dd.MM.yyyy]"; + // + // xrLabel5 + // + this.xrLabel5.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(508.8355F, 301.5F); + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(218.1642F, 23.00003F); + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "Aktenzeichen: [CustomerInsuranceNumer]-FF"; + // + // xrLabel7 + // + this.xrLabel7.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel7.LocationFloat = new DevExpress.Utils.PointFloat(45.82984F, 342.75F); + this.xrLabel7.Name = "xrLabel7"; + this.xrLabel7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel7.SizeF = new System.Drawing.SizeF(106.7059F, 23.00003F); + this.xrLabel7.StylePriority.UseFont = false; + this.xrLabel7.Text = "Jahr/Monat:"; + // + // xrLabel8 + // + this.xrLabel8.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "EndDate")}); + this.xrLabel8.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F); + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(152.5357F, 342.75F); + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(106.7059F, 23.00003F); + this.xrLabel8.StylePriority.UseFont = false; + this.xrLabel8.TextFormatString = "{0:yyyy-MM}"; + // + // xrTableCell8 + // + this.xrTableCell8.Font = new DevExpress.Drawing.DXFont("Segoe UI", 12F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell8.Multiline = true; + this.xrTableCell8.Name = "xrTableCell8"; + this.xrTableCell8.StylePriority.UseBorders = false; + this.xrTableCell8.StylePriority.UseFont = false; + this.xrTableCell8.Text = "Unterschriften"; + this.xrTableCell8.Weight = 0.3207100403051642D; + // + // xrTableCell9 + // + this.xrTableCell9.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell9.Multiline = true; + this.xrTableCell9.Name = "xrTableCell9"; + this.xrTableCell9.StylePriority.UseBorders = false; + this.xrTableCell9.StylePriority.UseTextAlignment = false; + this.xrTableCell9.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell9.Weight = 0.32071006709896221D; + // + // xrTableCell10 + // + this.xrTableCell10.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell10.Multiline = true; + this.xrTableCell10.Name = "xrTableCell10"; + this.xrTableCell10.StylePriority.UseBorders = false; + this.xrTableCell10.StylePriority.UseTextAlignment = false; + this.xrTableCell10.Text = "xrTableCell10"; + this.xrTableCell10.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell10.Weight = 0.32071026793714941D; + // + // xrTableRow3 + // + this.xrTableRow3.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell11, + this.xrTableCell13, + this.xrTableCell14}); + this.xrTableRow3.Name = "xrTableRow3"; + this.xrTableRow3.StylePriority.UseFont = false; + this.xrTableRow3.Weight = 0.12000000000000002D; + // + // xrTableCell11 + // + this.xrTableCell11.Multiline = true; + this.xrTableCell11.Name = "xrTableCell11"; + this.xrTableCell11.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell11.StylePriority.UseBorders = false; + this.xrTableCell11.StylePriority.UsePadding = false; + this.xrTableCell11.StylePriority.UseTextAlignment = false; + this.xrTableCell11.Text = "(1 Behandlung21seinheit – BE à 45 Min.)"; + this.xrTableCell11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell11.Weight = 0.53429232083834122D; + // + // xrTableCell13 + // + this.xrTableCell13.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell13.Multiline = true; + this.xrTableCell13.Name = "xrTableCell13"; + this.xrTableCell13.StylePriority.UseBorders = false; + this.xrTableCell13.StylePriority.UseTextAlignment = false; + this.xrTableCell13.Text = "xrTableCell13"; + this.xrTableCell13.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell13.Weight = 0.19294560359074503D; + // + // xrTableCell14 + // + this.xrTableCell14.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell14.Multiline = true; + this.xrTableCell14.Name = "xrTableCell14"; + this.xrTableCell14.StylePriority.UseBorders = false; + this.xrTableCell14.StylePriority.UseTextAlignment = false; + this.xrTableCell14.Text = "xrTableCell14"; + this.xrTableCell14.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell14.Weight = 0.32071026793714941D; + // + // QuittierungsbelegIfsEingangsdiagnostik + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.topMarginBand1, + this.bottomMarginBand1, + this.DetailReport2}); + this.CalculatedFields.AddRange(new DevExpress.XtraReports.UI.CalculatedField[] { + this.fieldEinzel, + this.fieldGruppe}); + this.DataSource = this.bindingSource1; + this.DisplayName = "Behandlungsnachweis"; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.Font = new DevExpress.Drawing.DXFont("Segoe UI", 9F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleBorderUnten}); + this.Margins = new DevExpress.Drawing.DXMargins(30F, 45F, 257.25F, 100F); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.Version = "23.2"; + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + + } + + + private DevExpress.XtraReports.UI.DetailBand Detail; + private System.Windows.Forms.BindingSource bindingSource1; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.XRTable xrTable3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell16; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell41; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox1; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + private DevExpress.XtraReports.UI.CalculatedField fieldEinzel; + private DevExpress.XtraReports.UI.CalculatedField fieldGruppe; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport2; + private DevExpress.XtraReports.UI.DetailBand Detail3; + private DevExpress.XtraReports.UI.XRTable xrTable2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell3; + private DevExpress.XtraReports.UI.FormattingRule ruleBorderUnten; + private DevExpress.XtraReports.UI.XRLabel lblNachweisFuer; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter2; + private DevExpress.XtraReports.UI.XRTable xrTable1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell7; + private DevExpress.XtraReports.UI.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell8; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell9; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell13; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell10; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.XRLabel xrLabel7; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRLabel lblBewilligungen; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + } +} diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.cs b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.cs new file mode 100644 index 000000000..459d19704 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.cs @@ -0,0 +1,156 @@ +using System; +using System.Text; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report; +using BeWo.Report.ReportObjects; +using BeWo.Service.ServiceImplementations; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using DevExpress.XtraReports.UI; + +namespace ClaudiaHeizmannHeilpaedagogik +{ + public partial class QuittierungsbelegIfsEingangsdiagnostik : XtraReport, IBeWoReport + { + public QuittierungsbelegIfsEingangsdiagnostik() + { + this.InitializeComponent(); + } + + public void SetReportDataSource(ServicesOverviewRO pRO) + { + //SetzeAdresse(pRO); + pRO.CustomerInsuranceNumer = pRO.CustomerLastName.Substring(0, 2) + pRO.CustomerFirstName.Substring(0, 2); + + //lblNachweisFuer.Text = String.Format("Behandlungsnachweis für: {0}, geb. am {1:dd.MM.yyyy}", pRO.CustomerName, pRO.CustomerBirthday); + + lblNachweisFuer.Text = String.Format("Leistungsnachweis für: {0}, geb. am {1:dd.MM.yyyy}", pRO.CustomerName, pRO.CustomerBirthday); + + lblMonatJahr.Text = String.Format("Monat/Jahr: {0:MM}/{0:yyyy}", pRO.StartDate); + + foreach (var sd in pRO.Services) + { + + //sd.Notice = String.Format("{0:0.##}", sd.Minutes / 60); + //sd.Notice = sd.ServiceDescription.Replace("IFS","").Replace("-","").Trim(); + pRO.MainAttendant = sd.EmployeeFullname; + sd.Notice = sd.ServiceDescription; + sd.Notice2 = InvoiceHelper.GetUnitString(((decimal)sd.Minutes * (4m / 3m) / 60m)); + + //if (sd.CustomerCount > 1) + //{ + // sd.Notice2 = ""; + // sd.Notice3 = ""; + // sd.Notice4 = String.Format("{0} Kinder", sd.CustomerCount); + //} + //else + //{ + // sd.Notice4 = ""; + // if (sd.ServiceDescription.Contains("mobil")) + // { + // sd.Notice2 = "X"; + // sd.Notice3 = ""; + // } + // else + // { + // sd.Notice2 = ""; + // sd.Notice3 = "X"; + // } + + //} + } + + lblDatum.Text = String.Format("{0:dd.MM.yyyy}", DateTime.Now); + pRO.ReferenceNumber = GetAktenzeichen(pRO); + this.bindingSource1.DataSource = pRO; + } + + private void SetzeAdresse(ServicesOverviewRO pRo) + { + if (pRo.SupportConceptCostBearer != null) + { + var org = pRo.SupportConceptCostBearer.CostBearer; + StringBuilder sb = new StringBuilder(); + + if (org.Name.Contains("Bezirk Oberbayern")) + { + org.Name = "Bezirk Oberbayern"; + + } + + sb.AppendLine(org.Name); + + var orgEnt = DAOFactory.GenericDAO.LoadByID(org.OrganisationOid); + if (!String.IsNullOrEmpty(org.Name2)) + { + sb.AppendLine(org.Name2); + } + + if (!String.IsNullOrEmpty(org.Street)) + { + sb.AppendLine(org.Street); + } + + sb.AppendLine(String.Format("{0} {1}", org.PostalCode, org.Town)); + + + //lblAdresse.Text = sb.ToString(); + } + } + + + private SupportConceptStatisticsDC GetStatistics(ServiceInvoiceRO ro) + { + if (ro.InvoiceBase.SupportConceptCostBearerRelDc != null) + { + var service = new OperationsServiceImp(); + + + long cb2scOid = ro.InvoiceBase.SupportConceptCostBearerRelDc.CostBearer2SupportConceptOid.Value; + + + return service.CreateSupportConceptStatistics(cb2scOid, ro.AccountingPeriodEnd); + + //if (stats.PeriodStatistics != null && stats.PeriodStatistics.Count > 0) + //{ + // foreach (var ps in stats.PeriodStatistics) + // { + // if (ps.SupportConceptApprovalPeriod != null && + // ps.SupportConceptApprovalPeriod.ServiceCategory != null && + // (ps.SupportConceptApprovalPeriod.ServiceCategory.Name.StartsWith("Verhinderung") || + // ps.SupportConceptApprovalPeriod.ServiceCategory.Name.StartsWith("Betreuungsleistungen"))) + // { + // return ps; + // } + // } + //} + + //return null; + } + return null; + } + + private String GetAktenzeichen(ServicesOverviewRO ro) + { + var cb = ""; + foreach (var sd in ro.Services) + { + cb = sd.CostBearer; + } + + if (ro.CostBearer2SupportConceptList != null) + { + foreach (var c2s in ro.CostBearer2SupportConceptList) + { + if (c2s.CostBearer.Organisation.Name == cb) + { + return c2s.CustomerReferenceNumber; + } + } + } + return null; + } + } +} \ No newline at end of file diff --git a/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.resx b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.resx new file mode 100644 index 000000000..ba05bbd84 --- /dev/null +++ b/ReportImp/ClaudiaHeizmannHeilpaedagogik/QuittierungsbelegIfsEingangsdiagnostik.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file