diff --git a/ReportImp/AufEigenenFuessenStehen/AufEigenenFuessenStehen.csproj b/ReportImp/AufEigenenFuessenStehen/AufEigenenFuessenStehen.csproj index 330919680..f1d95d379 100644 --- a/ReportImp/AufEigenenFuessenStehen/AufEigenenFuessenStehen.csproj +++ b/ReportImp/AufEigenenFuessenStehen/AufEigenenFuessenStehen.csproj @@ -1,83 +1,123 @@ - - - - - Debug - AnyCPU - {3180F78D-DB13-4169-87F5-1511619A7D38} - Library - Properties - AufEigenenFuessenStehen - 1733934665_Reports - v4.7.2 - 512 - - - - true - full - false - ..\..\CustomerDlls\ - DEBUG;TRACE - prompt - 4 - - - pdbonly - true - ..\..\CustomerDlls\ - TRACE - prompt - 4 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Component - - - ServicesOverviewReport.cs - - - - - - ServicesOverviewReport.cs - Designer - - - - - {40D8B312-EA64-49E3-A31A-5E57ED4D5654} - Report - - - - - - + + + + + Debug + AnyCPU + {3180F78D-DB13-4169-87F5-1511619A7D38} + Library + Properties + AufEigenenFuessenStehen + 1733934665_Reports + v4.7.2 + 512 + + + + true + full + false + ..\..\CustomerDlls\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + ..\..\CustomerDlls\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + Component + + + LeistungsnachweisSoziotherapie.cs + + + + True + True + Resources.resx + + + Component + + + ServicesOverviewReport.cs + + + Component + + + SoziotherapieRechnung.cs + + + + + LeistungsnachweisSoziotherapie.cs + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + ServicesOverviewReport.cs + Designer + + + SoziotherapieRechnung.cs + Designer + + + + + {b0d73e3d-4ae7-4024-93a6-db1f46d7ccee} + Data + + + {40D8B312-EA64-49E3-A31A-5E57ED4D5654} + Report + + + {094331c3-ecee-4c89-bbfd-4c9ded89f0ef} + Service + + + {2f50b83d-a3f0-4ec4-979a-3f9b7e3d8ed4} + Shared + + + + + + \ No newline at end of file diff --git a/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.cs b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.cs new file mode 100644 index 000000000..eee3f193c --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.cs @@ -0,0 +1,122 @@ +using System; +using BeWo.Report.ReportObjects; +using BeWo.Report; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Service.DCEntityMapper; + +namespace AufEigenenFuessenStehen +{ + + public partial class LeistungsnachweisSoziotherapie : DevExpress.XtraReports.UI.XtraReport, IBeWoReport + { + public LeistungsnachweisSoziotherapie() + { + InitializeComponent(); + } + + public void SetReportDataSource(ServicesOverviewRO pRO) + { + double gesamt = 0; + double gesamtGruppe = 0; + + if (pRO.Services != null) + { + foreach (ServicesOverviewRO.ServiceDetail s in pRO.Services) + { + var serviceRecord = DAOFactory.GenericDAO.LoadByID(s.ServiceRecordOid); + pRO.ReferenceNumber = serviceRecord.CostBearer2SupportConcept.CustomerReferenceNumber; + if (serviceRecord.CostBearer2SupportConcept.ApprovedStartDate != null) + pRO.ApprovedStartDate = String.Format("{0:dd.MM.yyyy}", serviceRecord.CostBearer2SupportConcept.ApprovedStartDate); + if (serviceRecord.CostBearer2SupportConcept.ApprovedEndDate != null) + pRO.ApprovedEndDate = String.Format("{0:dd.MM.yyyy}", serviceRecord.CostBearer2SupportConcept.ApprovedEndDate); + var srDc = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(serviceRecord); + + s.GoalList = String.Empty; + if (srDc.Goals != null && srDc.Goals.Count > 0) + { + + foreach (var goal in srDc.Goals) + { + if (!String.IsNullOrEmpty(goal.Abbreviation)) + { + if (s.GoalList.Length > 0) + s.GoalList += ", "; + s.GoalList += goal.Abbreviation; + } + } + } + if (s.ServiceDescription.Contains("Gruppe")) // Erstellung meist über Mehrfachbuchung + { + s.IsGroup = true; + } + + if (s.IsGroup) + { + gesamtGruppe += s.Minutes; + s.ServiceDescription = "E"; + s.Notice5 = "2002672"; + } + else + { + gesamt += s.Minutes; + } + + if (s.ServiceDescription.Contains("Video")) + { + s.ServiceDescription = "V"; + if (s.Minutes <= 30) + { + s.Notice5 = "2001615"; + } + else + { + s.Notice5 = "2001616"; + } + } + else if (s.ServiceDescription.Contains("Telefon")) + { + s.ServiceDescription = "T"; + if (s.Minutes <= 30) + { + s.Notice5 = "2001618"; + } + else + { + s.Notice5 = "2001617"; + } + } + else if (s.ServiceDescription.Contains("Probe")) + { + s.Notice5 = "2001607"; + } + + else if (s.ServiceDescription.Contains("Einrichtung") || s.ServiceDescription == "E" || s.ServiceDescription.Contains("Gruppe")) + { + s.ServiceDescription = "E"; + } + else + { + s.ServiceDescription = "A"; + if (s.Minutes <= 30) + { + s.Notice5 = "2001612"; + } + else + { + s.Notice5 = "2001610"; + } + } + } + } + + cellGesamt.Text = String.Format("{0:0.00}", gesamt / 60); + if (gesamtGruppe > 0) + { + cellGesamtGruppe.Text = String.Format("{0:0.00}", gesamtGruppe / 60); + } + + this.bindingSource1.DataSource = pRO; + } + } +} diff --git a/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.designer.cs b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.designer.cs new file mode 100644 index 000000000..f729236b9 --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.designer.cs @@ -0,0 +1,865 @@ +using BeWo.Report.ReportObjects; +namespace AufEigenenFuessenStehen +{ + partial class LeistungsnachweisSoziotherapie + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components; + + /// + /// 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); + } + + #region Designer generated code + + /// + /// 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(LeistungsnachweisSoziotherapie)); + this.Detail = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTableServiceRecords1 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow2 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell11 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell7 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell16 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell19 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell14 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail1 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable3 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow6 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell17 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell13 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell15 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell12 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell8 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell10 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell20 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell18 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell9 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupHeader1 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.GroupFooter1 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.cellGesamtGruppe = new DevExpress.XtraReports.UI.XRLabel(); + this.cellGesamt = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.formattingRuleStartDate = new DevExpress.XtraReports.UI.FormattingRule(); + this.formattingRuleServiceDesc = new DevExpress.XtraReports.UI.FormattingRule(); + this.formattingRuleCostBearer = new DevExpress.XtraReports.UI.FormattingRule(); + this.formattingRuleEmployeeName = new DevExpress.XtraReports.UI.FormattingRule(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel10 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel7 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.fieldEinzel = new DevExpress.XtraReports.UI.CalculatedField(); + this.fieldBillableFLS = new DevExpress.XtraReports.UI.CalculatedField(); + this.fieldAbrechenbareFLS = new DevExpress.XtraReports.UI.CalculatedField(); + this.xrLabel12 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel23 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel15 = new DevExpress.XtraReports.UI.XRLabel(); + this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel9 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel17 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel16 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel13 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel14 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblIkNr = new DevExpress.XtraReports.UI.XRLabel(); + this.lblAdresse = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.fieldArt = new DevExpress.XtraReports.UI.CalculatedField(); + this.fieldGroup = new DevExpress.XtraReports.UI.CalculatedField(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel18 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrPictureBox2 = new DevExpress.XtraReports.UI.XRPictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.xrTableServiceRecords1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + // + // Detail + // + this.Detail.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.Detail.HeightF = 0F; + this.Detail.Name = "Detail"; + this.Detail.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail.StylePriority.UseFont = false; + this.Detail.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrTableServiceRecords1 + // + this.xrTableServiceRecords1.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableServiceRecords1.LocationFloat = new DevExpress.Utils.PointFloat(0.0005086263F, 0F); + this.xrTableServiceRecords1.Name = "xrTableServiceRecords1"; + this.xrTableServiceRecords1.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.xrTableServiceRecords1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow2}); + this.xrTableServiceRecords1.SizeF = new System.Drawing.SizeF(1097.458F, 60F); + this.xrTableServiceRecords1.StylePriority.UseBackColor = false; + this.xrTableServiceRecords1.StylePriority.UseBorders = false; + this.xrTableServiceRecords1.StylePriority.UseFont = false; + this.xrTableServiceRecords1.StylePriority.UseTextAlignment = false; + this.xrTableServiceRecords1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + // + // xrTableRow2 + // + this.xrTableRow2.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell4, + this.xrTableCell3, + this.xrTableCell6, + this.xrTableCell1, + this.xrTableCell11, + this.xrTableCell7, + this.xrTableCell16, + this.xrTableCell19, + this.xrTableCell14, + this.xrTableCell5}); + this.xrTableRow2.Name = "xrTableRow2"; + this.xrTableRow2.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.xrTableRow2.StylePriority.UseTextAlignment = false; + this.xrTableRow2.Weight = 1.875D; + // + // xrTableCell4 + // + this.xrTableCell4.Name = "xrTableCell4"; + this.xrTableCell4.Text = "Ort"; + this.xrTableCell4.Weight = 0.24385912943517524D; + // + // xrTableCell3 + // + this.xrTableCell3.Name = "xrTableCell3"; + this.xrTableCell3.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 2, 0, 0, 100F); + this.xrTableCell3.StylePriority.UseFont = false; + this.xrTableCell3.StylePriority.UseTextAlignment = false; + this.xrTableCell3.Text = "Datum"; + this.xrTableCell3.Weight = 0.24385913270146492D; + // + // xrTableCell6 + // + this.xrTableCell6.Multiline = true; + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.Text = "Uhrzeit\r\n(von - bis)"; + this.xrTableCell6.Weight = 0.34140277718578993D; + // + // xrTableCell1 + // + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.Text = "Leistungsart"; + this.xrTableCell1.Weight = 0.26824505480994043D; + // + // xrTableCell11 + // + this.xrTableCell11.Multiline = true; + this.xrTableCell11.Name = "xrTableCell11"; + this.xrTableCell11.StylePriority.UseFont = false; + this.xrTableCell11.StylePriority.UsePadding = false; + this.xrTableCell11.StylePriority.UseTextAlignment = false; + this.xrTableCell11.Text = "Anzahl\r\nEinheiten*\r\nEinzeln"; + this.xrTableCell11.Weight = 0.20728026932304136D; + // + // xrTableCell7 + // + this.xrTableCell7.Multiline = true; + this.xrTableCell7.Name = "xrTableCell7"; + this.xrTableCell7.Text = "Anzahl\r\nEinheiten*\r\nGruppe"; + this.xrTableCell7.Weight = 0.20728026091063453D; + // + // xrTableCell16 + // + this.xrTableCell16.Name = "xrTableCell16"; + this.xrTableCell16.Text = "Leistungsform"; + this.xrTableCell16.Weight = 0.280438005341767D; + // + // xrTableCell19 + // + this.xrTableCell19.Name = "xrTableCell19"; + this.xrTableCell19.Text = "Schlüssel"; + this.xrTableCell19.Weight = 0.19508730895313436D; + // + // xrTableCell14 + // + this.xrTableCell14.Name = "xrTableCell14"; + this.xrTableCell14.Text = "Handzeichen Soziothera-peut/in"; + this.xrTableCell14.Weight = 0.25605209371119086D; + // + // xrTableCell5 + // + this.xrTableCell5.Name = "xrTableCell5"; + this.xrTableCell5.Text = "Datum, Unterschrift versicherte Person"; + this.xrTableCell5.Weight = 0.43274761671964435D; + // + // DetailReport + // + this.DetailReport.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail1, + this.GroupHeader1, + this.GroupFooter1}); + this.DetailReport.DataMember = "Services"; + this.DetailReport.DataSource = this.bindingSource1; + this.DetailReport.Level = 0; + this.DetailReport.Name = "DetailReport"; + this.DetailReport.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.DetailReport.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // Detail1 + // + this.Detail1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable3}); + this.Detail1.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.Detail1.HeightF = 25F; + this.Detail1.Name = "Detail1"; + this.Detail1.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail1.StylePriority.UseFont = false; + this.Detail1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrTable3 + // + this.xrTable3.BorderColor = System.Drawing.Color.Black; + this.xrTable3.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTable3.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable3.Name = "xrTable3"; + this.xrTable3.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.xrTable3.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow6}); + this.xrTable3.SizeF = new System.Drawing.SizeF(1097.458F, 25F); + this.xrTable3.StylePriority.UseFont = false; + this.xrTable3.StylePriority.UseTextAlignment = false; + this.xrTable3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + // + // xrTableRow6 + // + this.xrTableRow6.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell17, + this.xrTableCell13, + this.xrTableCell15, + this.xrTableCell12, + this.xrTableCell2, + this.xrTableCell8, + this.xrTableCell10, + this.xrTableCell20, + this.xrTableCell18, + this.xrTableCell9}); + this.xrTableRow6.Name = "xrTableRow6"; + this.xrTableRow6.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.xrTableRow6.StylePriority.UseTextAlignment = false; + this.xrTableRow6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableRow6.Weight = 1.25D; + // + // xrTableCell17 + // + this.xrTableCell17.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.Notice2")}); + this.xrTableCell17.Name = "xrTableCell17"; + this.xrTableCell17.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 2, 0, 0, 100F); + this.xrTableCell17.StylePriority.UsePadding = false; + this.xrTableCell17.StylePriority.UseTextAlignment = false; + this.xrTableCell17.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell17.Weight = 0.12626263699193913D; + // + // xrTableCell13 + // + this.xrTableCell13.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.StartDate", "{0:dd.MM.yyyy}")}); + this.xrTableCell13.Name = "xrTableCell13"; + this.xrTableCell13.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 2, 0, 0, 100F); + this.xrTableCell13.StylePriority.UseFont = false; + this.xrTableCell13.StylePriority.UsePadding = false; + this.xrTableCell13.StylePriority.UseTextAlignment = false; + this.xrTableCell13.Text = "xrTableCell13"; + this.xrTableCell13.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell13.Weight = 0.12626263699193913D; + // + // xrTableCell15 + // + this.xrTableCell15.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.TimeRangeString", "{0:HH:mm}")}); + this.xrTableCell15.Name = "xrTableCell15"; + this.xrTableCell15.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 5, 0, 0, 100F); + this.xrTableCell15.StylePriority.UseFont = false; + this.xrTableCell15.StylePriority.UsePadding = false; + this.xrTableCell15.StylePriority.UseTextAlignment = false; + this.xrTableCell15.Text = "xrTableCell15"; + this.xrTableCell15.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell15.Weight = 0.17676769478719556D; + // + // xrTableCell12 + // + this.xrTableCell12.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.Notice5")}); + this.xrTableCell12.Name = "xrTableCell12"; + this.xrTableCell12.Weight = 0.138888903265244D; + // + // xrTableCell2 + // + this.xrTableCell2.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.fieldEinzel", "{0:0.00}")}); + this.xrTableCell2.Name = "xrTableCell2"; + this.xrTableCell2.StylePriority.UseTextAlignment = false; + this.xrTableCell2.Text = "xrTableCell2"; + this.xrTableCell2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell2.Weight = 0.1073232412993016D; + // + // xrTableCell8 + // + this.xrTableCell8.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.fieldGroup", "{0:0.00}")}); + this.xrTableCell8.Name = "xrTableCell8"; + this.xrTableCell8.Weight = 0.10732324744166573D; + // + // xrTableCell10 + // + this.xrTableCell10.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.ServiceDescription")}); + this.xrTableCell10.Name = "xrTableCell10"; + this.xrTableCell10.Weight = 0.14520203233717263D; + // + // xrTableCell20 + // + this.xrTableCell20.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.GoalList")}); + this.xrTableCell20.Name = "xrTableCell20"; + this.xrTableCell20.StylePriority.UseTextAlignment = false; + this.xrTableCell20.Text = "xrTableCell20"; + this.xrTableCell20.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell20.Weight = 0.10101011051826002D; + // + // xrTableCell18 + // + this.xrTableCell18.Name = "xrTableCell18"; + this.xrTableCell18.StylePriority.UsePadding = false; + this.xrTableCell18.StylePriority.UseTextAlignment = false; + this.xrTableCell18.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell18.Weight = 0.13257577011985949D; + // + // xrTableCell9 + // + this.xrTableCell9.Multiline = true; + this.xrTableCell9.Name = "xrTableCell9"; + this.xrTableCell9.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 0, 0, 0, 100F); + this.xrTableCell9.StylePriority.UsePadding = false; + this.xrTableCell9.StylePriority.UseTextAlignment = false; + this.xrTableCell9.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell9.Weight = 0.22406316231377763D; + // + // GroupHeader1 + // + this.GroupHeader1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTableServiceRecords1}); + this.GroupHeader1.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.GroupHeader1.HeightF = 60F; + this.GroupHeader1.Name = "GroupHeader1"; + this.GroupHeader1.RepeatEveryPage = true; + this.GroupHeader1.StylePriority.UseFont = false; + // + // GroupFooter1 + // + this.GroupFooter1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.cellGesamtGruppe, + this.cellGesamt, + this.xrLabel8, + this.xrLabel6, + this.xrLabel11}); + this.GroupFooter1.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.GroupFooter1.HeightF = 122.5208F; + this.GroupFooter1.Name = "GroupFooter1"; + this.GroupFooter1.StylePriority.UseFont = false; + // + // cellGesamtGruppe + // + this.cellGesamtGruppe.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.cellGesamtGruppe.BorderWidth = 1F; + this.cellGesamtGruppe.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.cellGesamtGruppe.LocationFloat = new DevExpress.Utils.PointFloat(535.0005F, 0F); + this.cellGesamtGruppe.Name = "cellGesamtGruppe"; + this.cellGesamtGruppe.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 3, 0, 0, 100F); + this.cellGesamtGruppe.SizeF = new System.Drawing.SizeF(85F, 24.25F); + this.cellGesamtGruppe.StylePriority.UseBorders = false; + this.cellGesamtGruppe.StylePriority.UseBorderWidth = false; + this.cellGesamtGruppe.StylePriority.UseFont = false; + this.cellGesamtGruppe.StylePriority.UsePadding = false; + this.cellGesamtGruppe.StylePriority.UseTextAlignment = false; + this.cellGesamtGruppe.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + // + // cellGesamt + // + this.cellGesamt.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.cellGesamt.BorderWidth = 1F; + this.cellGesamt.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.cellGesamt.LocationFloat = new DevExpress.Utils.PointFloat(449.9998F, 0F); + this.cellGesamt.Name = "cellGesamt"; + this.cellGesamt.Padding = new DevExpress.XtraPrinting.PaddingInfo(3, 3, 0, 0, 100F); + this.cellGesamt.SizeF = new System.Drawing.SizeF(85F, 24.25F); + this.cellGesamt.StylePriority.UseBorders = false; + this.cellGesamt.StylePriority.UseBorderWidth = false; + this.cellGesamt.StylePriority.UseFont = false; + this.cellGesamt.StylePriority.UsePadding = false; + this.cellGesamt.StylePriority.UseTextAlignment = false; + this.cellGesamt.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + // + // xrLabel8 + // + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(630.0004F, 36.41668F); + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(386.3333F, 17.99997F); + this.xrLabel8.StylePriority.UseBorders = false; + this.xrLabel8.StylePriority.UseFont = false; + this.xrLabel8.Text = "Datum, Unterschrift Leistungserbringer"; + // + // xrLabel6 + // + this.xrLabel6.Borders = DevExpress.XtraPrinting.BorderSide.Bottom; + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(630F, 82.02082F); + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(467.4581F, 17.99997F); + this.xrLabel6.StylePriority.UseBorders = false; + this.xrLabel6.StylePriority.UseFont = false; + // + // xrLabel11 + // + this.xrLabel11.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrLabel11.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(200F, 0F); + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 3, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(249.9996F, 24.24997F); + this.xrLabel11.StylePriority.UseBorders = false; + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.StylePriority.UsePadding = false; + this.xrLabel11.StylePriority.UseTextAlignment = false; + this.xrLabel11.Text = "Einheiten gesamt:"; + this.xrLabel11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.ServicesOverviewRO); + // + // formattingRuleStartDate + // + this.formattingRuleStartDate.Condition = "[StartDate2] < [StartDate]"; + this.formattingRuleStartDate.DataMember = "ServicesDouble"; + this.formattingRuleStartDate.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.formattingRuleStartDate.Name = "formattingRuleStartDate"; + // + // formattingRuleServiceDesc + // + this.formattingRuleServiceDesc.Condition = "[StartDate2] < [StartDate]"; + this.formattingRuleServiceDesc.DataMember = "ServicesDouble"; + this.formattingRuleServiceDesc.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.formattingRuleServiceDesc.Name = "formattingRuleServiceDesc"; + // + // formattingRuleCostBearer + // + this.formattingRuleCostBearer.Condition = "[StartDate2] < [StartDate]"; + this.formattingRuleCostBearer.DataMember = "ServicesDouble"; + this.formattingRuleCostBearer.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.formattingRuleCostBearer.Name = "formattingRuleCostBearer"; + // + // formattingRuleEmployeeName + // + this.formattingRuleEmployeeName.Condition = "[StartDate2] < [StartDate]"; + this.formattingRuleEmployeeName.DataMember = "ServicesDouble"; + this.formattingRuleEmployeeName.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.formattingRuleEmployeeName.Name = "formattingRuleEmployeeName"; + // + // topMarginBand1 + // + this.topMarginBand1.Font = new DevExpress.Drawing.DXFont("Times New Roman", 9.75F); + this.topMarginBand1.HeightF = 50F; + this.topMarginBand1.Name = "topMarginBand1"; + this.topMarginBand1.StylePriority.UseFont = false; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.HeightF = 30F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel10, + this.xrLabel7, + this.xrLabel4}); + this.ReportFooter.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.ReportFooter.HeightF = 82.95835F; + this.ReportFooter.Name = "ReportFooter"; + this.ReportFooter.StylePriority.UseFont = false; + // + // xrLabel10 + // + this.xrLabel10.Font = new DevExpress.Drawing.DXFont("Arial", 10F); + this.xrLabel10.LocationFloat = new DevExpress.Utils.PointFloat(570.1245F, 0F); + this.xrLabel10.Multiline = true; + this.xrLabel10.Name = "xrLabel10"; + this.xrLabel10.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel10.SizeF = new System.Drawing.SizeF(538.8751F, 82.95835F); + this.xrLabel10.StylePriority.UseFont = false; + this.xrLabel10.Text = resources.GetString("xrLabel10.Text"); + // + // xrLabel7 + // + this.xrLabel7.Font = new DevExpress.Drawing.DXFont("Arial", 10F); + this.xrLabel7.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrLabel7.Name = "xrLabel7"; + this.xrLabel7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel7.SizeF = new System.Drawing.SizeF(100F, 20F); + this.xrLabel7.StylePriority.UseFont = false; + this.xrLabel7.Text = "Schlüssel:"; + // + // xrLabel4 + // + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("Arial", 10F); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(100.4163F, 0F); + this.xrLabel4.Multiline = true; + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(413.1666F, 82.95835F); + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "1 Soziotherapeutische Dokumentation\r\n2 Verordnung Formular 26 & 27, Erstellung So" + + "ziotherapieplan\r\n3 Arbeiten im sozialen Umfeld\r\n4 Motivation- (Antrieb) relevant" + + "es Training"; + // + // fieldEinzel + // + this.fieldEinzel.DataMember = "Services"; + this.fieldEinzel.Expression = "Iif([IsGroup], ?, [Minutes] / 60)"; + this.fieldEinzel.FieldType = DevExpress.XtraReports.UI.FieldType.Decimal; + this.fieldEinzel.Name = "fieldEinzel"; + // + // fieldBillableFLS + // + this.fieldBillableFLS.Expression = "[TotalFLMBillable] / 60"; + this.fieldBillableFLS.FieldType = DevExpress.XtraReports.UI.FieldType.Decimal; + this.fieldBillableFLS.Name = "fieldBillableFLS"; + // + // fieldAbrechenbareFLS + // + this.fieldAbrechenbareFLS.Expression = "([TotalFLMBillable] / 60) * 1.2"; + this.fieldAbrechenbareFLS.FieldType = DevExpress.XtraReports.UI.FieldType.Decimal; + this.fieldAbrechenbareFLS.Name = "fieldAbrechenbareFLS"; + // + // xrLabel12 + // + this.xrLabel12.LocationFloat = new DevExpress.Utils.PointFloat(0F, 100F); + this.xrLabel12.Name = "xrLabel12"; + this.xrLabel12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel12.SizeF = new System.Drawing.SizeF(248.7709F, 20F); + this.xrLabel12.StylePriority.UseFont = false; + this.xrLabel12.Text = "Name der versicherten Person: "; + // + // xrLabel23 + // + this.xrLabel23.LocationFloat = new DevExpress.Utils.PointFloat(248.7709F, 100F); + this.xrLabel23.Name = "xrLabel23"; + this.xrLabel23.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel23.SizeF = new System.Drawing.SizeF(358.2291F, 20F); + this.xrLabel23.StylePriority.UseBorders = false; + this.xrLabel23.StylePriority.UseFont = false; + this.xrLabel23.Text = "[CustomerFirstName] [CustomerLastName]"; + // + // xrLabel15 + // + this.xrLabel15.LocationFloat = new DevExpress.Utils.PointFloat(0F, 39.99999F); + this.xrLabel15.Name = "xrLabel15"; + this.xrLabel15.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel15.SizeF = new System.Drawing.SizeF(248.7709F, 20F); + this.xrLabel15.StylePriority.UseFont = false; + this.xrLabel15.Text = "Leistungserbringer: "; + // + // ReportHeader + // + this.ReportHeader.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrPictureBox2, + this.xrLabel3, + this.xrLabel18, + this.xrLabel5, + this.xrLabel2, + this.xrLabel9, + this.xrLabel17, + this.xrLabel16, + this.xrLabel13, + this.xrLabel14, + this.lblIkNr, + this.lblAdresse, + this.xrLabel1, + this.xrLabel15, + this.xrLabel23, + this.xrLabel12}); + this.ReportHeader.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.ReportHeader.HeightF = 200F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // xrLabel5 + // + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(248.7709F, 130F); + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(358.2291F, 20F); + this.xrLabel5.StylePriority.UseBorders = false; + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "[ApprovedStartDate] - [ApprovedEndDate]"; + // + // xrLabel2 + // + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(607F, 100F); + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(167.396F, 20F); + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "Versichertennummer:"; + // + // xrLabel9 + // + this.xrLabel9.LocationFloat = new DevExpress.Utils.PointFloat(774.396F, 100F); + this.xrLabel9.Name = "xrLabel9"; + this.xrLabel9.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel9.SizeF = new System.Drawing.SizeF(199.5204F, 20F); + this.xrLabel9.StylePriority.UseBorders = false; + this.xrLabel9.StylePriority.UseFont = false; + this.xrLabel9.Text = "[ReferenceNumber]"; + // + // xrLabel17 + // + this.xrLabel17.LocationFloat = new DevExpress.Utils.PointFloat(0F, 160F); + this.xrLabel17.Name = "xrLabel17"; + this.xrLabel17.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel17.SizeF = new System.Drawing.SizeF(378.4584F, 20F); + this.xrLabel17.StylePriority.UseFont = false; + this.xrLabel17.Text = "Soziotherapeutische Maßnahmen"; + // + // xrLabel16 + // + this.xrLabel16.LocationFloat = new DevExpress.Utils.PointFloat(0F, 130F); + this.xrLabel16.Name = "xrLabel16"; + this.xrLabel16.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel16.SizeF = new System.Drawing.SizeF(248.7709F, 20F); + this.xrLabel16.StylePriority.UseFont = false; + this.xrLabel16.Text = "Zeitraum von - bis: "; + // + // xrLabel13 + // + this.xrLabel13.LocationFloat = new DevExpress.Utils.PointFloat(607F, 70.00002F); + this.xrLabel13.Name = "xrLabel13"; + this.xrLabel13.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel13.SizeF = new System.Drawing.SizeF(167.396F, 20F); + this.xrLabel13.StylePriority.UseFont = false; + this.xrLabel13.Text = "Krankenkasse:"; + // + // xrLabel14 + // + this.xrLabel14.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Services.CostBearer")}); + this.xrLabel14.LocationFloat = new DevExpress.Utils.PointFloat(774.396F, 70.00002F); + this.xrLabel14.Name = "xrLabel14"; + this.xrLabel14.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel14.SizeF = new System.Drawing.SizeF(199.5204F, 20F); + this.xrLabel14.StylePriority.UseBorders = false; + this.xrLabel14.StylePriority.UseFont = false; + // + // lblIkNr + // + this.lblIkNr.LocationFloat = new DevExpress.Utils.PointFloat(0F, 70.00002F); + this.lblIkNr.Name = "lblIkNr"; + this.lblIkNr.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblIkNr.SizeF = new System.Drawing.SizeF(402.7499F, 20F); + this.lblIkNr.StylePriority.UseFont = false; + this.lblIkNr.Text = "IK-Nr.: 490 50 65 91"; + // + // lblAdresse + // + this.lblAdresse.LocationFloat = new DevExpress.Utils.PointFloat(248.7709F, 39.99999F); + this.lblAdresse.Name = "lblAdresse"; + this.lblAdresse.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblAdresse.SizeF = new System.Drawing.SizeF(725.1455F, 20F); + this.lblAdresse.StylePriority.UseFont = false; + this.lblAdresse.Text = " Birgit Apel de Santos ABW \"Auf eigenen Füßen stehen\", Knapmannstrasse 14a, 58453" + + " Witten"; + // + // xrLabel1 + // + this.xrLabel1.Font = new DevExpress.Drawing.DXFont("Arial", 13F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrLabel1.Name = "xrLabel1"; + this.xrLabel1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel1.SizeF = new System.Drawing.SizeF(578.9792F, 20F); + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.Text = "Soziotherapeutischer Leistungsnachweis"; + // + // fieldArt + // + this.fieldArt.DataMember = "Services"; + this.fieldArt.Expression = "Iif([IsGroup], \'G\', \'E\')"; + this.fieldArt.FieldType = DevExpress.XtraReports.UI.FieldType.DateTime; + this.fieldArt.Name = "fieldArt"; + // + // fieldGroup + // + this.fieldGroup.DataMember = "Services"; + this.fieldGroup.Expression = "Iif([IsGroup], [Minutes] / 60, ?)"; + this.fieldGroup.FieldType = DevExpress.XtraReports.UI.FieldType.Decimal; + this.fieldGroup.Name = "fieldGroup"; + // + // xrLabel3 + // + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(607F, 130F); + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(167.396F, 20F); + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Geburtsdatum:"; + // + // xrLabel18 + // + this.xrLabel18.LocationFloat = new DevExpress.Utils.PointFloat(774.3958F, 130F); + this.xrLabel18.Name = "xrLabel18"; + this.xrLabel18.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel18.SizeF = new System.Drawing.SizeF(199.5206F, 20F); + this.xrLabel18.StylePriority.UseBorders = false; + this.xrLabel18.StylePriority.UseFont = false; + this.xrLabel18.Text = "CustomerBirthday!dd.MM.yyyy]"; + // + // xrPictureBox2 + // + this.xrPictureBox2.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox2.ImageSource")); + this.xrPictureBox2.LocationFloat = new DevExpress.Utils.PointFloat(973.9164F, 0F); + this.xrPictureBox2.Name = "xrPictureBox2"; + this.xrPictureBox2.SizeF = new System.Drawing.SizeF(135.0835F, 200F); + this.xrPictureBox2.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // LeistungsnachweisSoziotherapie + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.DetailReport, + this.ReportHeader, + this.topMarginBand1, + this.bottomMarginBand1, + this.ReportFooter}); + this.CalculatedFields.AddRange(new DevExpress.XtraReports.UI.CalculatedField[] { + this.fieldEinzel, + this.fieldBillableFLS, + this.fieldAbrechenbareFLS, + this.fieldArt, + this.fieldGroup}); + this.DataSource = this.bindingSource1; + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.formattingRuleStartDate, + this.formattingRuleServiceDesc, + this.formattingRuleCostBearer, + this.formattingRuleEmployeeName}); + this.Landscape = true; + this.Margins = new DevExpress.Drawing.DXMargins(30F, 30F, 50F, 30F); + this.PageHeight = 827; + this.PageWidth = 1169; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.SnapGridSize = 9F; + this.Version = "23.2"; + ((System.ComponentModel.ISupportInitialize)(this.xrTableServiceRecords1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + + } + + #endregion + + private DevExpress.XtraReports.UI.DetailBand Detail; + private System.Windows.Forms.BindingSource bindingSource1; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport; + private DevExpress.XtraReports.UI.DetailBand Detail1; + private DevExpress.XtraReports.UI.XRTable xrTable3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell15; + private DevExpress.XtraReports.UI.XRTable xrTableServiceRecords1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell13; + private DevExpress.XtraReports.UI.FormattingRule formattingRuleStartDate; + private DevExpress.XtraReports.UI.FormattingRule formattingRuleServiceDesc; + private DevExpress.XtraReports.UI.FormattingRule formattingRuleCostBearer; + private DevExpress.XtraReports.UI.FormattingRule formattingRuleEmployeeName; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.CalculatedField fieldEinzel; + private DevExpress.XtraReports.UI.XRLabel cellGesamt; + private DevExpress.XtraReports.UI.CalculatedField fieldBillableFLS; + private DevExpress.XtraReports.UI.CalculatedField fieldAbrechenbareFLS; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell2; + private DevExpress.XtraReports.UI.GroupHeaderBand GroupHeader1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell7; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.XRLabel xrLabel12; + private DevExpress.XtraReports.UI.XRLabel xrLabel23; + private DevExpress.XtraReports.UI.XRLabel xrLabel15; + private DevExpress.XtraReports.UI.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell12; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell8; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell9; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + private DevExpress.XtraReports.UI.XRLabel lblAdresse; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.XRLabel lblIkNr; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.XRLabel xrLabel9; + private DevExpress.XtraReports.UI.XRLabel xrLabel17; + private DevExpress.XtraReports.UI.XRLabel xrLabel16; + private DevExpress.XtraReports.UI.XRLabel xrLabel13; + private DevExpress.XtraReports.UI.XRLabel xrLabel14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell16; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell17; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell18; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.CalculatedField fieldArt; + private DevExpress.XtraReports.UI.CalculatedField fieldGroup; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter1; + private DevExpress.XtraReports.UI.XRLabel xrLabel10; + private DevExpress.XtraReports.UI.XRLabel xrLabel7; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell19; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell20; + private DevExpress.XtraReports.UI.XRLabel cellGesamtGruppe; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRLabel xrLabel18; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox2; + } +} diff --git a/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.resx b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.resx new file mode 100644 index 000000000..af295b1d5 --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/LeistungsnachweisSoziotherapie.resx @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 5 Training zur handlungsrelevanten Willensbildung +6 Anleitung z. Verbesserung d. Krankheitswahrnehmung +7 Hilfe in Krisensituationen +8 Koordination von Behandlungsmaßnahmen & Leistungen - Absprache Verordner +9: Probatorische Stunden + + + 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 + + \ No newline at end of file diff --git a/ReportImp/AufEigenenFuessenStehen/Logo AufEigenenFuessenStehen.png b/ReportImp/AufEigenenFuessenStehen/Logo AufEigenenFuessenStehen.png new file mode 100644 index 000000000..d0a2e7963 Binary files /dev/null and b/ReportImp/AufEigenenFuessenStehen/Logo AufEigenenFuessenStehen.png differ diff --git a/ReportImp/AufEigenenFuessenStehen/Logo.png b/ReportImp/AufEigenenFuessenStehen/Logo.png new file mode 100644 index 000000000..caa8da098 Binary files /dev/null and b/ReportImp/AufEigenenFuessenStehen/Logo.png differ diff --git a/ReportImp/AufEigenenFuessenStehen/Properties/Resources.Designer.cs b/ReportImp/AufEigenenFuessenStehen/Properties/Resources.Designer.cs new file mode 100644 index 000000000..64bd61014 --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/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 AufEigenenFuessenStehen.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("AufEigenenFuessenStehen.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/AufEigenenFuessenStehen/Properties/Resources.resx b/ReportImp/AufEigenenFuessenStehen/Properties/Resources.resx new file mode 100644 index 000000000..29dcb1b3a --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/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/AufEigenenFuessenStehen/Properties/licenses.licx b/ReportImp/AufEigenenFuessenStehen/Properties/licenses.licx index e69de29bb..f98ef57fd 100644 --- a/ReportImp/AufEigenenFuessenStehen/Properties/licenses.licx +++ b/ReportImp/AufEigenenFuessenStehen/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/AufEigenenFuessenStehen/SoziotherapieRechnung.Designer.cs b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.Designer.cs new file mode 100644 index 000000000..3054ae9cb --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.Designer.cs @@ -0,0 +1,926 @@ +using BeWo.Report.ReportObjects; +namespace AufEigenenFuessenStehen +{ + partial class SoziotherapieRechnung + { + /// + /// 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(SoziotherapieRechnung)); + DevExpress.XtraReports.UI.XRWatermark xrWatermark1 = new DevExpress.XtraReports.UI.XRWatermark(); + this.Detail = new DevExpress.XtraReports.UI.DetailBand(); + this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.ruleRateFactorNull = new DevExpress.XtraReports.UI.FormattingRule(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.Page1 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblAdresse = new DevExpress.XtraReports.UI.XRLabel(); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable4 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow10 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell18 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow14 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell19 = new DevExpress.XtraReports.UI.XRTableCell(); + this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail1 = new DevExpress.XtraReports.UI.DetailBand(); + this.DetailReport1 = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail2 = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable6 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow25 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell40 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell42 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell20 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell44 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell45 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell47 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupHeader1 = new DevExpress.XtraReports.UI.GroupHeaderBand(); + this.xrTable5 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow23 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell32 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell37 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell14 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell33 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell36 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell34 = new DevExpress.XtraReports.UI.XRTableCell(); + this.GroupFooter1 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrTable1 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow1 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel9 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrPictureBox2 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.xrLabel10 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel12 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel13 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel14 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel15 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel16 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).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; + // + // ReportHeader + // + this.ReportHeader.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.ReportHeader.HeightF = 0F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // ruleRateFactorNull + // + this.ruleRateFactorNull.Condition = "[RateFactorText2] == ?"; + this.ruleRateFactorNull.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.ruleRateFactorNull.Name = "ruleRateFactorNull"; + // + // topMarginBand1 + // + this.topMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel12, + this.xrPictureBox2, + this.xrLabel9, + this.xrLabel8, + this.xrLabel3}); + this.topMarginBand1.HeightF = 148.1768F; + this.topMarginBand1.Name = "topMarginBand1"; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel1}); + this.bottomMarginBand1.Font = new DevExpress.Drawing.DXFont("Arial", 7F); + this.bottomMarginBand1.HeightF = 88.12486F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + this.bottomMarginBand1.StylePriority.UseFont = false; + // + // Page1 + // + this.Page1.BorderWidth = 2F; + this.Page1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel16, + this.xrLabel15, + this.xrLabel14, + this.xrLabel13, + this.xrLabel11, + this.xrLabel10, + this.xrLabel4, + this.lblAdresse}); + this.Page1.Font = new DevExpress.Drawing.DXFont("Arial", 10F); + this.Page1.HeightF = 279.9945F; + this.Page1.Name = "Page1"; + this.Page1.StylePriority.UseBorderWidth = false; + this.Page1.StylePriority.UseFont = false; + // + // xrLabel4 + // + this.xrLabel4.BackColor = System.Drawing.Color.Transparent; + this.xrLabel4.CanShrink = true; + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(380.3333F, 152.3445F); + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(269.6666F, 25.00006F); + this.xrLabel4.StylePriority.UseBackColor = false; + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "Rechnung [InvoiceNumber]"; + this.xrLabel4.WordWrap = false; + // + // lblAdresse + // + this.lblAdresse.Font = new DevExpress.Drawing.DXFont("Arial", 9F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.lblAdresse.LocationFloat = new DevExpress.Utils.PointFloat(0F, 21.95832F); + this.lblAdresse.Multiline = true; + this.lblAdresse.Name = "lblAdresse"; + this.lblAdresse.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblAdresse.SizeF = new System.Drawing.SizeF(317F, 111.5F); + this.lblAdresse.StylePriority.UseFont = false; + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel6, + this.xrLabel2, + this.xrLabel5, + this.xrTable4}); + this.ReportFooter.Font = new DevExpress.Drawing.DXFont("Times New Roman", 10F); + this.ReportFooter.HeightF = 250.6878F; + this.ReportFooter.Name = "ReportFooter"; + this.ReportFooter.StylePriority.UseFont = false; + // + // xrLabel2 + // + this.xrLabel2.BackColor = System.Drawing.Color.Transparent; + this.xrLabel2.CanShrink = true; + this.xrLabel2.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(0F, 59.18134F); + this.xrLabel2.Multiline = true; + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(649.9999F, 125.7432F); + this.xrLabel2.StylePriority.UseBackColor = false; + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = resources.GetString("xrLabel2.Text"); + this.xrLabel2.WordWrap = false; + // + // xrLabel5 + // + this.xrLabel5.Font = new DevExpress.Drawing.DXFont("Arial", 9F, DevExpress.Drawing.DXFontStyle.Italic, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(250F, 17F); + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "Abschließende Bemerkungen:"; + // + // xrTable4 + // + this.xrTable4.Font = new DevExpress.Drawing.DXFont("Arial", 9F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTable4.LocationFloat = new DevExpress.Utils.PointFloat(0F, 24.99998F); + this.xrTable4.Name = "xrTable4"; + this.xrTable4.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow10, + this.xrTableRow14}); + this.xrTable4.SizeF = new System.Drawing.SizeF(650F, 26F); + this.xrTable4.StylePriority.UseFont = false; + // + // xrTableRow10 + // + this.xrTableRow10.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell18}); + this.xrTableRow10.Name = "xrTableRow10"; + this.xrTableRow10.Weight = 0.38095238095238093D; + // + // xrTableCell18 + // + this.xrTableCell18.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Notice")}); + this.xrTableCell18.Name = "xrTableCell18"; + this.xrTableCell18.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTableCell18.StylePriority.UsePadding = false; + this.xrTableCell18.Text = "xrTableCell1"; + this.xrTableCell18.Weight = 3D; + // + // xrTableRow14 + // + this.xrTableRow14.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell19}); + this.xrTableRow14.Name = "xrTableRow14"; + this.xrTableRow14.Weight = 0.23809523809523808D; + // + // xrTableCell19 + // + this.xrTableCell19.Name = "xrTableCell19"; + this.xrTableCell19.Weight = 3D; + // + // DetailReport + // + this.DetailReport.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail1, + this.DetailReport1}); + this.DetailReport.DataMember = "ServiceInvoicePeriods"; + this.DetailReport.DataSource = this.bindingSource1; + this.DetailReport.Level = 0; + this.DetailReport.Name = "DetailReport"; + // + // Detail1 + // + this.Detail1.HeightF = 0F; + this.Detail1.Name = "Detail1"; + // + // DetailReport1 + // + this.DetailReport1.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail2, + this.GroupHeader1, + this.GroupFooter1}); + this.DetailReport1.DataMember = "ServiceInvoicePeriods.ServiceInvoiceItems"; + this.DetailReport1.DataSource = this.bindingSource1; + this.DetailReport1.Level = 0; + this.DetailReport1.Name = "DetailReport1"; + // + // Detail2 + // + this.Detail2.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable6}); + this.Detail2.HeightF = 25F; + this.Detail2.Name = "Detail2"; + // + // xrTable6 + // + this.xrTable6.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrTable6.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable6.Name = "xrTable6"; + this.xrTable6.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow25}); + this.xrTable6.SizeF = new System.Drawing.SizeF(650.7153F, 25F); + this.xrTable6.StylePriority.UseFont = false; + // + // xrTableRow25 + // + this.xrTableRow25.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell40, + this.xrTableCell42, + this.xrTableCell20, + this.xrTableCell44, + this.xrTableCell45, + this.xrTableCell47}); + this.xrTableRow25.Name = "xrTableRow25"; + this.xrTableRow25.Weight = 1D; + // + // xrTableCell40 + // + this.xrTableCell40.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell40.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell40.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.UnitDescription")}); + this.xrTableCell40.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell40.Name = "xrTableCell40"; + this.xrTableCell40.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell40.StylePriority.UseBorderColor = false; + this.xrTableCell40.StylePriority.UseBorders = false; + this.xrTableCell40.StylePriority.UseFont = false; + this.xrTableCell40.StylePriority.UsePadding = false; + this.xrTableCell40.StylePriority.UseTextAlignment = false; + this.xrTableCell40.Text = "Soziotherapie"; + this.xrTableCell40.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell40.Weight = 0.48703970276798481D; + // + // xrTableCell42 + // + this.xrTableCell42.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell42.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell42.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.ServiceDescription")}); + this.xrTableCell42.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell42.Name = "xrTableCell42"; + this.xrTableCell42.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell42.StylePriority.UseBorderColor = false; + this.xrTableCell42.StylePriority.UseBorders = false; + this.xrTableCell42.StylePriority.UseFont = false; + this.xrTableCell42.StylePriority.UsePadding = false; + this.xrTableCell42.StylePriority.UseTextAlignment = false; + this.xrTableCell42.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell42.Weight = 1.107949290423365D; + // + // xrTableCell20 + // + this.xrTableCell20.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell20.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell20.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.UnitCount")}); + this.xrTableCell20.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell20.Name = "xrTableCell20"; + this.xrTableCell20.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell20.StylePriority.UseBorderColor = false; + this.xrTableCell20.StylePriority.UseBorders = false; + this.xrTableCell20.StylePriority.UseFont = false; + this.xrTableCell20.StylePriority.UsePadding = false; + this.xrTableCell20.StylePriority.UseTextAlignment = false; + this.xrTableCell20.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell20.TextFormatString = "{0:0.##}"; + this.xrTableCell20.Weight = 0.22822139477225151D; + // + // xrTableCell44 + // + this.xrTableCell44.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell44.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell44.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.HourlyRateString")}); + this.xrTableCell44.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell44.Name = "xrTableCell44"; + this.xrTableCell44.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell44.StylePriority.UseBorderColor = false; + this.xrTableCell44.StylePriority.UseBorders = false; + this.xrTableCell44.StylePriority.UseFont = false; + this.xrTableCell44.StylePriority.UsePadding = false; + this.xrTableCell44.StylePriority.UseTextAlignment = false; + this.xrTableCell44.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell44.TextFormatString = "{0:}"; + this.xrTableCell44.Weight = 0.22822139477225151D; + // + // xrTableCell45 + // + this.xrTableCell45.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell45.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell45.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.HourlyRate", "{0:0.00}")}); + this.xrTableCell45.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell45.Name = "xrTableCell45"; + this.xrTableCell45.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell45.StylePriority.UseBorderColor = false; + this.xrTableCell45.StylePriority.UseBorders = false; + this.xrTableCell45.StylePriority.UseFont = false; + this.xrTableCell45.StylePriority.UsePadding = false; + this.xrTableCell45.StylePriority.UseTextAlignment = false; + this.xrTableCell45.Text = "xrTableCell45"; + this.xrTableCell45.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell45.Weight = 0.31486369486210231D; + // + // xrTableCell47 + // + this.xrTableCell47.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell47.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell47.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "ServiceInvoicePeriods.ServiceInvoiceItems.GrossAmount")}); + this.xrTableCell47.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell47.Name = "xrTableCell47"; + this.xrTableCell47.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell47.StylePriority.UseBorderColor = false; + this.xrTableCell47.StylePriority.UseBorders = false; + this.xrTableCell47.StylePriority.UseFont = false; + this.xrTableCell47.StylePriority.UsePadding = false; + this.xrTableCell47.StylePriority.UseTextAlignment = false; + this.xrTableCell47.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell47.Weight = 0.40632358217756026D; + // + // GroupHeader1 + // + this.GroupHeader1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable5}); + this.GroupHeader1.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.GroupHeader1.HeightF = 25F; + this.GroupHeader1.Name = "GroupHeader1"; + this.GroupHeader1.StylePriority.UseFont = false; + // + // xrTable5 + // + this.xrTable5.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable5.Name = "xrTable5"; + this.xrTable5.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow23}); + this.xrTable5.SizeF = new System.Drawing.SizeF(650.7153F, 25F); + // + // xrTableRow23 + // + this.xrTableRow23.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell32, + this.xrTableCell37, + this.xrTableCell14, + this.xrTableCell33, + this.xrTableCell36, + this.xrTableCell34}); + this.xrTableRow23.Name = "xrTableRow23"; + this.xrTableRow23.Weight = 1D; + // + // xrTableCell32 + // + this.xrTableCell32.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell32.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell32.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell32.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell32.Name = "xrTableCell32"; + this.xrTableCell32.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell32.StylePriority.UseBackColor = false; + this.xrTableCell32.StylePriority.UseBorderColor = false; + this.xrTableCell32.StylePriority.UseBorders = false; + this.xrTableCell32.StylePriority.UseFont = false; + this.xrTableCell32.StylePriority.UsePadding = false; + this.xrTableCell32.StylePriority.UseTextAlignment = false; + this.xrTableCell32.Text = "Positionsnummer"; + this.xrTableCell32.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell32.Weight = 0.48703975698113955D; + // + // xrTableCell37 + // + this.xrTableCell37.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell37.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell37.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell37.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell37.Name = "xrTableCell37"; + this.xrTableCell37.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell37.StylePriority.UseBackColor = false; + this.xrTableCell37.StylePriority.UseBorderColor = false; + this.xrTableCell37.StylePriority.UseBorders = false; + this.xrTableCell37.StylePriority.UseFont = false; + this.xrTableCell37.StylePriority.UsePadding = false; + this.xrTableCell37.StylePriority.UseTextAlignment = false; + this.xrTableCell37.Text = "Bezeichnung"; + this.xrTableCell37.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell37.Weight = 1.1079493430789218D; + // + // xrTableCell14 + // + this.xrTableCell14.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell14.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell14.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell14.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell14.Name = "xrTableCell14"; + this.xrTableCell14.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell14.StylePriority.UseBackColor = false; + this.xrTableCell14.StylePriority.UseBorderColor = false; + this.xrTableCell14.StylePriority.UseBorders = false; + this.xrTableCell14.StylePriority.UseFont = false; + this.xrTableCell14.StylePriority.UsePadding = false; + this.xrTableCell14.StylePriority.UseTextAlignment = false; + this.xrTableCell14.Text = "Menge"; + this.xrTableCell14.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell14.Weight = 0.22822136142383243D; + // + // xrTableCell33 + // + this.xrTableCell33.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell33.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell33.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell33.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell33.Name = "xrTableCell33"; + this.xrTableCell33.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell33.StylePriority.UseBackColor = false; + this.xrTableCell33.StylePriority.UseBorderColor = false; + this.xrTableCell33.StylePriority.UseBorders = false; + this.xrTableCell33.StylePriority.UseFont = false; + this.xrTableCell33.StylePriority.UsePadding = false; + this.xrTableCell33.StylePriority.UseTextAlignment = false; + this.xrTableCell33.Text = "Einheit"; + this.xrTableCell33.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell33.Weight = 0.22822136142383243D; + // + // xrTableCell36 + // + this.xrTableCell36.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell36.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell36.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell36.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell36.Name = "xrTableCell36"; + this.xrTableCell36.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell36.StylePriority.UseBackColor = false; + this.xrTableCell36.StylePriority.UseBorderColor = false; + this.xrTableCell36.StylePriority.UseBorders = false; + this.xrTableCell36.StylePriority.UseFont = false; + this.xrTableCell36.StylePriority.UsePadding = false; + this.xrTableCell36.StylePriority.UseTextAlignment = false; + this.xrTableCell36.Text = "Preis"; + this.xrTableCell36.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell36.Weight = 0.31486374942651824D; + // + // xrTableCell34 + // + this.xrTableCell34.BackColor = System.Drawing.Color.Transparent; + this.xrTableCell34.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell34.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell34.Font = new DevExpress.Drawing.DXFont("Arial", 9F); + this.xrTableCell34.Name = "xrTableCell34"; + this.xrTableCell34.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell34.StylePriority.UseBackColor = false; + this.xrTableCell34.StylePriority.UseBorderColor = false; + this.xrTableCell34.StylePriority.UseBorders = false; + this.xrTableCell34.StylePriority.UseFont = false; + this.xrTableCell34.StylePriority.UsePadding = false; + this.xrTableCell34.StylePriority.UseTextAlignment = false; + this.xrTableCell34.Text = "Gesamtbetrag"; + this.xrTableCell34.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell34.Weight = 0.40632415697457513D; + // + // GroupFooter1 + // + this.GroupFooter1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable1}); + this.GroupFooter1.HeightF = 38.62159F; + this.GroupFooter1.Name = "GroupFooter1"; + // + // xrTable1 + // + this.xrTable1.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrTable1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable1.Name = "xrTable1"; + this.xrTable1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow1}); + this.xrTable1.SizeF = new System.Drawing.SizeF(649.9999F, 25F); + this.xrTable1.StylePriority.UseFont = false; + // + // xrTableRow1 + // + this.xrTableRow1.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell1, + this.xrTableCell5}); + this.xrTableRow1.Name = "xrTableRow1"; + this.xrTableRow1.Weight = 1D; + // + // xrTableCell1 + // + this.xrTableCell1.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell1.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell1.Font = new DevExpress.Drawing.DXFont("Arial", 11.25F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 100F); + this.xrTableCell1.StylePriority.UseBorderColor = false; + this.xrTableCell1.StylePriority.UseBorders = false; + this.xrTableCell1.StylePriority.UseFont = false; + this.xrTableCell1.StylePriority.UsePadding = false; + this.xrTableCell1.StylePriority.UseTextAlignment = false; + this.xrTableCell1.Text = "Rechnungsbetrag"; + this.xrTableCell1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell1.Weight = 2.3662953373904871D; + // + // xrTableCell5 + // + this.xrTableCell5.BorderColor = System.Drawing.Color.DarkGray; + this.xrTableCell5.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell5.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "GrossClaim")}); + this.xrTableCell5.Font = new DevExpress.Drawing.DXFont("Arial", 11.25F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTableCell5.Name = "xrTableCell5"; + this.xrTableCell5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 2, 2, 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.MiddleRight; + this.xrTableCell5.Weight = 0.40327538447920763D; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.ServiceInvoiceRO); + // + // xrLabel3 + // + this.xrLabel3.Font = new DevExpress.Drawing.DXFont("Lucida Calligraphy", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel3.ForeColor = System.Drawing.Color.DimGray; + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(0F, 48.2286F); + 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(356.4574F, 21.91666F); + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.StylePriority.UseForeColor = false; + this.xrLabel3.StylePriority.UseTextAlignment = false; + this.xrLabel3.Text = "„A u f e i g e n e n F ü ß e n s t e h e n“"; + this.xrLabel3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + // + // xrLabel8 + // + this.xrLabel8.Font = new DevExpress.Drawing.DXFont("Lucida Calligraphy", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel8.ForeColor = System.Drawing.Color.Black; + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(0F, 70.14524F); + this.xrLabel8.Multiline = true; + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(356.4574F, 21.91666F); + this.xrLabel8.StylePriority.UseFont = false; + this.xrLabel8.StylePriority.UseForeColor = false; + this.xrLabel8.StylePriority.UseTextAlignment = false; + this.xrLabel8.Text = "Soziotherapie - ABW"; + this.xrLabel8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + // + // xrLabel9 + // + this.xrLabel9.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel9.ForeColor = System.Drawing.Color.Black; + this.xrLabel9.LocationFloat = new DevExpress.Utils.PointFloat(0F, 104.3007F); + this.xrLabel9.Multiline = true; + this.xrLabel9.Name = "xrLabel9"; + this.xrLabel9.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel9.SizeF = new System.Drawing.SizeF(356.4574F, 43.87611F); + this.xrLabel9.StylePriority.UseFont = false; + this.xrLabel9.StylePriority.UseForeColor = false; + this.xrLabel9.StylePriority.UseTextAlignment = false; + this.xrLabel9.Text = "Knapmannstrasse 14a\r\n58453 Witten"; + this.xrLabel9.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + // + // xrPictureBox2 + // + this.xrPictureBox2.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrPictureBox2.ImageSource")); + this.xrPictureBox2.LocationFloat = new DevExpress.Utils.PointFloat(554.0692F, 42.2286F); + this.xrPictureBox2.Name = "xrPictureBox2"; + this.xrPictureBox2.SizeF = new System.Drawing.SizeF(121.6462F, 105.9482F); + this.xrPictureBox2.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // xrLabel10 + // + this.xrLabel10.Font = new DevExpress.Drawing.DXFont("Arial", 6F, DevExpress.Drawing.DXFontStyle.Underline); + this.xrLabel10.ForeColor = System.Drawing.Color.Black; + this.xrLabel10.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrLabel10.Multiline = true; + this.xrLabel10.Name = "xrLabel10"; + this.xrLabel10.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel10.SizeF = new System.Drawing.SizeF(317F, 21.95832F); + this.xrLabel10.StylePriority.UseFont = false; + this.xrLabel10.StylePriority.UseForeColor = false; + this.xrLabel10.StylePriority.UseTextAlignment = false; + this.xrLabel10.Text = "Auf eigenen Füßen stehen, Knapmannstrasse 14a, 58453 Witten"; + this.xrLabel10.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrLabel11 + // + this.xrLabel11.BackColor = System.Drawing.Color.Transparent; + this.xrLabel11.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel11.BorderWidth = 1F; + this.xrLabel11.CanShrink = true; + this.xrLabel11.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(380.3333F, 0F); + this.xrLabel11.Multiline = true; + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(91.76584F, 81.09345F); + this.xrLabel11.StylePriority.UseBackColor = false; + this.xrLabel11.StylePriority.UseBorders = false; + this.xrLabel11.StylePriority.UseBorderWidth = false; + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.Text = "Ansprechpartner\r\n\r\nTEL\r\nMOBIL\r\nFAX\r\nE-MAIL"; + this.xrLabel11.WordWrap = false; + // + // xrLabel12 + // + this.xrLabel12.BackColor = System.Drawing.Color.Transparent; + this.xrLabel12.CanShrink = true; + this.xrLabel12.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel12.LocationFloat = new DevExpress.Utils.PointFloat(380.3333F, 123.1767F); + this.xrLabel12.Name = "xrLabel12"; + this.xrLabel12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel12.SizeF = new System.Drawing.SizeF(173.7359F, 25.00005F); + this.xrLabel12.StylePriority.UseBackColor = false; + this.xrLabel12.StylePriority.UseFont = false; + this.xrLabel12.Text = "Witten, den [InvoiceDateTime!dd. MM.yyyy]"; + this.xrLabel12.WordWrap = false; + // + // xrLabel13 + // + this.xrLabel13.BackColor = System.Drawing.Color.Transparent; + this.xrLabel13.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel13.BorderWidth = 1F; + this.xrLabel13.CanShrink = true; + this.xrLabel13.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrLabel13.LocationFloat = new DevExpress.Utils.PointFloat(472.0992F, 0F); + this.xrLabel13.Multiline = true; + this.xrLabel13.Name = "xrLabel13"; + this.xrLabel13.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel13.SizeF = new System.Drawing.SizeF(178.6161F, 81.09345F); + this.xrLabel13.StylePriority.UseBackColor = false; + this.xrLabel13.StylePriority.UseBorders = false; + this.xrLabel13.StylePriority.UseBorderWidth = false; + this.xrLabel13.StylePriority.UseFont = false; + this.xrLabel13.Text = "[SenderContactPerson]\r\n\r\n[SenderContactPersonPhone]\r\n0177 / 67 25 391\r\n[SenderCon" + + "tactPersonFax]\r\naufeigenenfuessenstehen@web.de"; + this.xrLabel13.WordWrap = false; + // + // xrLabel14 + // + this.xrLabel14.BackColor = System.Drawing.Color.Transparent; + this.xrLabel14.CanShrink = true; + this.xrLabel14.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold); + this.xrLabel14.LocationFloat = new DevExpress.Utils.PointFloat(0F, 152.3445F); + this.xrLabel14.Multiline = true; + this.xrLabel14.Name = "xrLabel14"; + this.xrLabel14.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel14.SizeF = new System.Drawing.SizeF(269.6666F, 40.20273F); + this.xrLabel14.StylePriority.UseBackColor = false; + this.xrLabel14.StylePriority.UseFont = false; + this.xrLabel14.Text = "IK-Nummer: 490 50 65 91\t\t\r\nSoziotherapie"; + this.xrLabel14.WordWrap = false; + // + // xrLabel15 + // + this.xrLabel15.BackColor = System.Drawing.Color.Transparent; + this.xrLabel15.CanShrink = true; + this.xrLabel15.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel15.LocationFloat = new DevExpress.Utils.PointFloat(0F, 202.2634F); + this.xrLabel15.Multiline = true; + this.xrLabel15.Name = "xrLabel15"; + this.xrLabel15.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel15.SizeF = new System.Drawing.SizeF(269.6666F, 57.09462F); + this.xrLabel15.StylePriority.UseBackColor = false; + this.xrLabel15.StylePriority.UseFont = false; + this.xrLabel15.Text = "für: [CustomerName]\r\nKrankenkasse: \r\nZeitraum:\t[AccountingPeriod]"; + this.xrLabel15.WordWrap = false; + // + // xrLabel16 + // + this.xrLabel16.BackColor = System.Drawing.Color.Transparent; + this.xrLabel16.CanShrink = true; + this.xrLabel16.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel16.LocationFloat = new DevExpress.Utils.PointFloat(381.0488F, 202.2635F); + this.xrLabel16.Multiline = true; + this.xrLabel16.Name = "xrLabel16"; + this.xrLabel16.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel16.SizeF = new System.Drawing.SizeF(269.6666F, 40.20273F); + this.xrLabel16.StylePriority.UseBackColor = false; + this.xrLabel16.StylePriority.UseFont = false; + this.xrLabel16.Text = "geboren am: [CustomerBirthdate!dd.MM.yyyy]\r\nVersicherten-Nummer: [CustomerReferen" + + "ceNumber]"; + this.xrLabel16.WordWrap = false; + // + // xrLabel1 + // + this.xrLabel1.BackColor = System.Drawing.Color.Transparent; + this.xrLabel1.CanShrink = true; + this.xrLabel1.Font = new DevExpress.Drawing.DXFont("Arial", 7F); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + 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(649.9999F, 69.99995F); + this.xrLabel1.StylePriority.UseBackColor = false; + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.Text = resources.GetString("xrLabel1.Text"); + this.xrLabel1.WordWrap = false; + // + // xrLabel6 + // + this.xrLabel6.BackColor = System.Drawing.Color.Transparent; + this.xrLabel6.CanShrink = true; + this.xrLabel6.Font = new DevExpress.Drawing.DXFont("Arial", 11F); + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(0F, 223.6317F); + this.xrLabel6.Multiline = true; + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(250F, 21.85805F); + this.xrLabel6.StylePriority.UseBackColor = false; + this.xrLabel6.StylePriority.UseFont = false; + this.xrLabel6.Text = "Birgit Apel de Santos"; + this.xrLabel6.WordWrap = false; + // + // SoziotherapieRechnung + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.topMarginBand1, + this.bottomMarginBand1, + this.Page1, + this.ReportFooter, + this.DetailReport}); + this.DataSource = this.bindingSource1; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.Font = new DevExpress.Drawing.DXFont("Verdana", 10F); + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleRateFactorNull}); + this.Margins = new DevExpress.Drawing.DXMargins(100F, 50F, 148.1768F, 88.12486F); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.Version = "23.2"; + xrWatermark1.Id = "Watermark1"; + this.Watermarks.Add(xrWatermark1); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable6)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable5)).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.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.FormattingRule ruleRateFactorNull; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.GroupHeaderBand Page1; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.XRLabel lblAdresse; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport; + private DevExpress.XtraReports.UI.DetailBand Detail1; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport1; + private DevExpress.XtraReports.UI.DetailBand Detail2; + private DevExpress.XtraReports.UI.GroupHeaderBand GroupHeader1; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter1; + private DevExpress.XtraReports.UI.XRTable xrTable5; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow23; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell32; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell37; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell33; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell36; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell34; + private DevExpress.XtraReports.UI.XRTable xrTable6; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow25; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell40; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell42; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell44; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell45; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell47; + private DevExpress.XtraReports.UI.XRTable xrTable1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.XRTable xrTable4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell18; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell19; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell20; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell14; + private DevExpress.XtraReports.UI.XRLabel xrLabel9; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox2; + private DevExpress.XtraReports.UI.XRLabel xrLabel10; + private DevExpress.XtraReports.UI.XRLabel xrLabel12; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRLabel xrLabel13; + private DevExpress.XtraReports.UI.XRLabel xrLabel16; + private DevExpress.XtraReports.UI.XRLabel xrLabel15; + private DevExpress.XtraReports.UI.XRLabel xrLabel14; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + } +} diff --git a/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.cs b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.cs new file mode 100644 index 000000000..84634c86e --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.cs @@ -0,0 +1,90 @@ +using BeWo.Report; +using BeWo.Report.ReportObjects; +using DevExpress.XtraReports.UI; +using System; +using System.Text; + +namespace AufEigenenFuessenStehen +{ + public partial class SoziotherapieRechnung : XtraReport, IBeWoReport + { + public SoziotherapieRechnung() + { + this.InitializeComponent(); + } + + public void SetReportDataSource(ServiceInvoiceRO pRO) + { + string poBox = null; + if (pRO.InvoiceBase.RecipientContactInformations.Count > 0) + { + foreach (var i in pRO.InvoiceBase.RecipientContactInformations) + { + if (i.ContactType == BS.Shared.ContactType.private_POBox) + poBox = i.ContactValue; + } + } + + StringBuilder sb = new StringBuilder(); + + if (!String.IsNullOrEmpty(pRO.RecipientOrganisation)) + { + sb.AppendLine(pRO.RecipientOrganisation); + } + if (!String.IsNullOrEmpty(pRO.RecipientAddressLine1)) + { + sb.AppendLine(pRO.RecipientAddressLine1); + } + if (!String.IsNullOrEmpty(pRO.RecipientContactPerson)) + { + sb.AppendLine(pRO.RecipientContactPerson); + } + if (!String.IsNullOrEmpty(pRO.RecipientDivision) && !String.IsNullOrEmpty(pRO.RecipientOrganisation)) + { + sb.AppendLine(pRO.RecipientDivision); + } + if (!String.IsNullOrEmpty(poBox)) + { + sb.AppendLine(poBox); + } + else if (!String.IsNullOrEmpty(pRO.RecipientPoBox)) + { + sb.AppendLine(pRO.RecipientPoBox); + } + else if (!String.IsNullOrEmpty(pRO.RecipientStreet)) + { + sb.AppendLine(pRO.RecipientStreet); + } + if (!String.IsNullOrEmpty(pRO.RecipientPostCodeAndTown)) + { + sb.AppendLine(""); + sb.AppendLine(pRO.RecipientPostCodeAndTown); + } + lblAdresse.Text = sb.ToString(); + + decimal hours = 0; + if (pRO.ServiceInvoicePeriods != null) + { + foreach (var sip in pRO.ServiceInvoicePeriods) + { + foreach (var ii in sip.ServiceInvoiceItems) + { + hours += ii.Hours ?? 0; + if (ii.UnitDescription == null || !ii.UnitDescription.StartsWith("GPos")) + { + ii.UnitDescription = ""; + } + + // Einheit setzen + ii.HourlyRateString = "Stunden"; + if (ii.ServiceDescription != null && ii.ServiceDescription.ToLower().Contains("hausbesuchpauschale")) + { + ii.HourlyRateString = "Anzahl"; + } + } + } + } + this.bindingSource1.DataSource = pRO; + } + } +} \ No newline at end of file diff --git a/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.resx b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.resx new file mode 100644 index 000000000..747f1c1a2 --- /dev/null +++ b/ReportImp/AufEigenenFuessenStehen/SoziotherapieRechnung.resx @@ -0,0 +1,136 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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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 + + + Vom Berufsverband der Soziotherapeuten e.V. und dem vdek wurde eine Soziotherapie-Einheit auf 60 Minuten festgelegt – 50 Minuten in direkter +Arbeit am Klienten (Direkte Leistung) und 10 Minuten indirekte Leistungen für Anfahrt etc. + + + Bitte überweisen Sie den obigen Rechnungsbetrag unter Angabe unserer Rechnungsnummer auf folgendes Konto: + +Kontoinhaber: Birgit Apel de Santos +IBAN: DE56 4525 0035 0007 2254 51 +BIC: WELADED1WTN + +Mit freundlichen Grüßen + + \ No newline at end of file