diff --git a/Report/ReportObjects/AdditionalServiceBookingRO.cs b/Report/ReportObjects/AdditionalServiceBookingRO.cs index 4499e7720..569e87f62 100644 --- a/Report/ReportObjects/AdditionalServiceBookingRO.cs +++ b/Report/ReportObjects/AdditionalServiceBookingRO.cs @@ -26,6 +26,62 @@ namespace BeWo.Report.ReportObjects public List Rows { get; set; } + public static AdditionalServiceBookingRO Create(AdditionalServiceRegion region, DateTime month) + { + var monat = GetMonat(month); + return Create(region, monat, month.Year); + } + + private static Monat GetMonat(DateTime month) + { + if (month.Month == 1) + { + return Monat.Januar; + } + if (month.Month == 2) + { + return Monat.Februar; + } + if (month.Month == 3) + { + return Monat.März; + } + if (month.Month == 4) + { + return Monat.April; + } + if (month.Month == 5) + { + return Monat.Mai; + } + if (month.Month == 6) + { + return Monat.Juni; + } + if (month.Month == 7) + { + return Monat.Juli; + } + if (month.Month == 8) + { + return Monat.August; + } + if (month.Month == 9) + { + return Monat.September; + } + if (month.Month == 10) + { + return Monat.Oktober; + } + if (month.Month == 11) + { + return Monat.November; + } + + return Monat.Dezember; + } + public static AdditionalServiceBookingRO Create(AdditionalServiceRegion region, Monat month, int year) { var result = new AdditionalServiceBookingRO diff --git a/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.Designer.cs b/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.Designer.cs index c0ab1d772..2950a9707 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.Designer.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.Designer.cs @@ -333,11 +333,11 @@ this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); this.GroupFooter2 = new DevExpress.XtraReports.UI.GroupFooterBand(); - this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); this.fieldIstFFO = new DevExpress.XtraReports.UI.CalculatedField(); this.fieldIstAndererKT = new DevExpress.XtraReports.UI.CalculatedField(); this.fieldIstSgb8 = new DevExpress.XtraReports.UI.CalculatedField(); this.fieldIstSgb9 = new DevExpress.XtraReports.UI.CalculatedField(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); ((System.ComponentModel.ISupportInitialize)(this.xrTableHeader)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.xrTableDetail)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.xrTableStaffelpreise)).BeginInit(); @@ -3078,7 +3078,7 @@ this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); this.xrLabel5.SizeF = new System.Drawing.SizeF(207.1503F, 23F); this.xrLabel5.StylePriority.UseFont = false; - this.xrLabel5.Text = "[Month] [Year]"; + this.xrLabel5.Text = "[Monat!MMMM yyyy]"; // // ReportHeader // @@ -3097,10 +3097,6 @@ this.GroupFooter2.Level = 1; this.GroupFooter2.Name = "GroupFooter2"; // - // bindingSource1 - // - this.bindingSource1.DataSource = typeof(LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot.AnwesenheitFruehUndSpaetbetreuung); - // // fieldIstFFO // this.fieldIstFFO.DataMember = "CustomerAnwesenheiten"; @@ -3128,6 +3124,10 @@ this.fieldIstSgb9.Expression = "Iif([IstSgb9], \'x\', \'\')\n"; this.fieldIstSgb9.Name = "fieldIstSgb9"; // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot.AnwesenheitFruehUndSpaetbetreuung); + // // AnwesenheitslisteFruehUndSpaetbetreuung // this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { diff --git a/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.cs b/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.cs index 4134669f7..723dce6a6 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/AnwesenheitslisteFruehUndSpaetbetreuung.cs @@ -70,16 +70,20 @@ namespace LebenshilfeFrankfurtOder { for (int i = 2; i < 33; i++) { - row.Cells[i].Text = String.Format("{0}", GetCellTextForStaffel(i - 1, staffel, true)); + var anz = staffel.GetAnzahlForDay(i - 1); + if (anz > 0) + { + row.Cells[i].Text = "x"; // String.Format("{0}", anz); + } + else + { + row.Cells[i].Text = ""; + } + } } - private object GetCellTextForStaffel(int v1, StaffelpreisProTag staffel, bool v2) - { - throw new NotImplementedException(); - } - private void SetCellColor(AnwesenheitFruehUndSpaetbetreuung pRo) { DateTime dt = pRo.Monat; diff --git a/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/AnwesenheitFruehUndSpaetbetreuung.cs b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/AnwesenheitFruehUndSpaetbetreuung.cs new file mode 100644 index 000000000..9b3f4b619 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/AnwesenheitFruehUndSpaetbetreuung.cs @@ -0,0 +1,623 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report.ReportObjects; +using BeWo.Service.DCEntityMapper; +using BeWo.Service.Invoicing; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; +using BS.Shared.Extensions; +using BS.Shared.Services; +using LebenshilfeFrankfurtOder.Utils; + +namespace LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot +{ + + //Berechnet anhand der Daten der ergänzenden Dienste die Abwesenheiten und die anzurechnenden Staffelpreise für die Früh- und Spätbetreuung + public class AnwesenheitFruehUndSpaetbetreuung + { + public List CustomerAnwesenheiten { get; set; } = new List(); + + public DateTime Monat { get; set; } + + public StaffelpreisProTag GesamtAnzahl { get; set; } = new StaffelpreisProTag(); + public StaffelpreisProTag Staffel1 { get; set; } = new StaffelpreisProTag(); + public StaffelpreisProTag Staffel2 { get; set; } = new StaffelpreisProTag(); + public StaffelpreisProTag Staffel3 { get; set; } = new StaffelpreisProTag(); + public StaffelpreisProTag Staffel4 { get; set; } = new StaffelpreisProTag(); + public StaffelpreisProTag Staffel5 { get; set; } = new StaffelpreisProTag(); + + internal void BerechneGesamtAnwesenheit(AdditionalServiceBookingRO roFrueh, AdditionalServiceBookingRO roSpaet) + { + + Monat = new DateTime(roFrueh.Year, roFrueh.MonthInt, 1); + + foreach (var sRow in roFrueh.Rows) + { + //Prüfe ob schon in Frühbetreuung, sonst füge Row zum Gesamt RO hinzu + var row = CustomerAnwesenheiten.FirstOrDefault(a => a.CustomerDC.CustomerOid == sRow.CustomerDC.CustomerOid); + if (row == null) + { + CustomerAnwesenheiten.Add(CreateCustomerAnwesenheit(sRow, Monat)); + } + else + { + AddAnwesenheit(row, sRow); + } + } + + foreach (var sRow in roSpaet.Rows) + { + //Prüfe ob schon in Frühbetreuung, sonst füge Row zum Gesamt RO hinzu + var row = CustomerAnwesenheiten.FirstOrDefault(a => a.CustomerDC.CustomerOid == sRow.CustomerDC.CustomerOid); + if (row == null) + { + CustomerAnwesenheiten.Add(CreateCustomerAnwesenheit(sRow, Monat)); + } + else + { + AddAnwesenheit(row, sRow); + } + } + + BerechneSummenUndStaffelpreise(); + } + + private void AddAnwesenheit(CustomerAnwesenheit row, AdditionalServiceBookingRow sRow) + { + if (String.IsNullOrEmpty(row.AttendanceOnDay1)) + { + row.AttendanceOnDay1 = sRow.AttendanceOnDay1; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay2)) + { + row.AttendanceOnDay2 = sRow.AttendanceOnDay2; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay3)) + { + row.AttendanceOnDay3 = sRow.AttendanceOnDay3; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay4)) + { + row.AttendanceOnDay4 = sRow.AttendanceOnDay4; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay5)) + { + row.AttendanceOnDay5 = sRow.AttendanceOnDay5; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay6)) + { + row.AttendanceOnDay6 = sRow.AttendanceOnDay6; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay7)) + { + row.AttendanceOnDay7 = sRow.AttendanceOnDay7; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay8)) + { + row.AttendanceOnDay8 = sRow.AttendanceOnDay8; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay9)) + { + row.AttendanceOnDay9 = sRow.AttendanceOnDay9; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay10)) + { + row.AttendanceOnDay10 = sRow.AttendanceOnDay10; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay11)) + { + row.AttendanceOnDay11 = sRow.AttendanceOnDay11; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay12)) + { + row.AttendanceOnDay12 = sRow.AttendanceOnDay12; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay13)) + { + row.AttendanceOnDay13 = sRow.AttendanceOnDay13; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay14)) + { + row.AttendanceOnDay14 = sRow.AttendanceOnDay14; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay15)) + { + row.AttendanceOnDay15 = sRow.AttendanceOnDay15; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay16)) + { + row.AttendanceOnDay16 = sRow.AttendanceOnDay16; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay17)) + { + row.AttendanceOnDay17 = sRow.AttendanceOnDay17; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay18)) + { + row.AttendanceOnDay18 = sRow.AttendanceOnDay18; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay19)) + { + row.AttendanceOnDay19 = sRow.AttendanceOnDay19; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay20)) + { + row.AttendanceOnDay20 = sRow.AttendanceOnDay20; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay21)) + { + row.AttendanceOnDay21 = sRow.AttendanceOnDay21; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay22)) + { + row.AttendanceOnDay22 = sRow.AttendanceOnDay22; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay23)) + { + row.AttendanceOnDay23 = sRow.AttendanceOnDay23; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay24)) + { + row.AttendanceOnDay24 = sRow.AttendanceOnDay24; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay25)) + { + row.AttendanceOnDay25 = sRow.AttendanceOnDay25; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay26)) + { + row.AttendanceOnDay26 = sRow.AttendanceOnDay26; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay27)) + { + row.AttendanceOnDay27 = sRow.AttendanceOnDay27; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay28)) + { + row.AttendanceOnDay28 = sRow.AttendanceOnDay28; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay29)) + { + row.AttendanceOnDay29 = sRow.AttendanceOnDay29; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay30)) + { + row.AttendanceOnDay30 = sRow.AttendanceOnDay30; + } + if (String.IsNullOrEmpty(row.AttendanceOnDay31)) + { + row.AttendanceOnDay31 = sRow.AttendanceOnDay31; + } + } + + private void BerechneSummenUndStaffelpreise() + { + foreach (var ca in CustomerAnwesenheiten) + { + DateTime dt = new DateTime(ca.Monat.Year, ca.Monat.Month, 1); + DateTime end = dt.AddMonths(1); + + while (dt < end) + { + if (FrankfurtOderHelper.IstAnwesend(dt, ca)) + { + IncrementAnzahl(dt, GesamtAnzahl); + } + + dt = dt.AddDays(1); + } + } + + SetzeStaffelpreise(); + } + + private void SetzeStaffelpreise() + { + DateTime dt = new DateTime(Monat.Year, Monat.Month, 1); + DateTime end = dt.AddMonths(1); + + Staffel1.Preis = FrankfurtOderHelper.GetStaffelPreis(1, dt) ?? 0; + Staffel2.Preis = FrankfurtOderHelper.GetStaffelPreis(2, dt) ?? 0; + Staffel3.Preis = FrankfurtOderHelper.GetStaffelPreis(3, dt) ?? 0; + Staffel4.Preis = FrankfurtOderHelper.GetStaffelPreis(4, dt) ?? 0; + Staffel5.Preis = FrankfurtOderHelper.GetStaffelPreis(5, dt) ?? 0; + + while (dt < end) + { + var anzahl = GetGesamtAnzahl(GesamtAnzahl, dt); + + var staffel = GetStaffelForAnzahl(anzahl); + + if (staffel != null) + { + IncrementAnzahl(dt, staffel); + } + dt = dt.AddDays(1); + } + } + + public StaffelpreisProTag GetStaffelForAnzahl(int anzahl) + { + //Staffelpreise + //Staffelpreis 1 bis zu 2 Leistungsberechtigte + //Staffelpreis 2 bis zu 4 Leistungsberechtigte + //Staffelpreis 3 bis zu 6 Leistungsberechtigte + //Staffelpreis 4 bis zu 8 Leistungsberechtigte + //Staffelpreis 5 bis zu 10 Leistungsberechtigte + if (anzahl > 0) + { + if (anzahl <= 2) + { + return Staffel1; + } + else if (anzahl <= 4) + { + return Staffel2; + } + else if (anzahl <= 6) + { + return Staffel3; + } + else if (anzahl <= 8) + { + return Staffel4; + } + else + { + return Staffel5; + } + } + + return null; + } + private int GetGesamtAnzahl(StaffelpreisProTag preis, DateTime dt) + { + if (dt.Day == 1) + { + return preis.AnzahlTag1; + } + else if (dt.Day == 2) + { + return preis.AnzahlTag2; + } + else if (dt.Day == 3) + { + return preis.AnzahlTag3; + } + else if (dt.Day == 4) + { + return preis.AnzahlTag4; + } + else if (dt.Day == 5) + { + return preis.AnzahlTag5; + } + else if (dt.Day == 6) + { + return preis.AnzahlTag6; + } + else if (dt.Day == 7) + { + return preis.AnzahlTag7; + } + else if (dt.Day == 8) + { + return preis.AnzahlTag8; + } + else if (dt.Day == 9) + { + return preis.AnzahlTag9; + } + else if (dt.Day == 10) + { + return preis.AnzahlTag10; + } + else if (dt.Day == 11) + { + return preis.AnzahlTag11; + } + else if (dt.Day == 12) + { + return preis.AnzahlTag12; + } + else if (dt.Day == 13) + { + return preis.AnzahlTag13; + } + else if (dt.Day == 14) + { + return preis.AnzahlTag14; + } + else if (dt.Day == 15) + { + return preis.AnzahlTag15; + } + else if (dt.Day == 16) + { + return preis.AnzahlTag16; + } + else if (dt.Day == 17) + { + return preis.AnzahlTag17; + } + else if (dt.Day == 18) + { + return preis.AnzahlTag18; + } + else if (dt.Day == 19) + { + return preis.AnzahlTag19; + } + else if (dt.Day == 20) + { + return preis.AnzahlTag20; + } + else if (dt.Day == 21) + { + return preis.AnzahlTag21; + } + else if (dt.Day == 22) + { + return preis.AnzahlTag22; + } + else if (dt.Day == 23) + { + return preis.AnzahlTag23; + } + else if (dt.Day == 24) + { + return preis.AnzahlTag24; + } + else if (dt.Day == 25) + { + return preis.AnzahlTag25; + } + else if (dt.Day == 26) + { + return preis.AnzahlTag26; + } + else if (dt.Day == 27) + { + return preis.AnzahlTag27; + } + else if (dt.Day == 28) + { + return preis.AnzahlTag28; + } + else if (dt.Day == 29) + { + return preis.AnzahlTag29; + } + else if (dt.Day == 30) + { + return preis.AnzahlTag30; + } + else if (dt.Day == 31) + { + return preis.AnzahlTag31; + } + + return 0; + } + + private void IncrementAnzahl(DateTime dt, StaffelpreisProTag preis) + { + if (dt.Day == 1) + { + preis.AnzahlTag1++; + } + else if (dt.Day == 2) + { + preis.AnzahlTag2++; + } + else if (dt.Day == 3) + { + preis.AnzahlTag3++; + } + else if (dt.Day == 4) + { + preis.AnzahlTag4++; + } + else if (dt.Day == 5) + { + preis.AnzahlTag5++; + } + else if (dt.Day == 6) + { + preis.AnzahlTag6++; + } + else if (dt.Day == 7) + { + preis.AnzahlTag7++; + } + else if (dt.Day == 8) + { + preis.AnzahlTag8++; + } + else if (dt.Day == 9) + { + preis.AnzahlTag9++; + } + else if (dt.Day == 10) + { + preis.AnzahlTag10++; + } + else if (dt.Day == 11) + { + preis.AnzahlTag11++; + } + else if (dt.Day == 12) + { + preis.AnzahlTag12++; + } + else if (dt.Day == 13) + { + preis.AnzahlTag13++; + } + else if (dt.Day == 14) + { + preis.AnzahlTag14++; + } + else if (dt.Day == 15) + { + preis.AnzahlTag15++; + } + else if (dt.Day == 16) + { + preis.AnzahlTag16++; + } + else if (dt.Day == 17) + { + preis.AnzahlTag17++; + } + else if (dt.Day == 18) + { + preis.AnzahlTag18++; + } + else if (dt.Day == 19) + { + preis.AnzahlTag19++; + } + else if (dt.Day == 20) + { + preis.AnzahlTag20++; + } + else if (dt.Day == 21) + { + preis.AnzahlTag21++; + } + else if (dt.Day == 22) + { + preis.AnzahlTag22++; + } + else if (dt.Day == 23) + { + preis.AnzahlTag23++; + } + else if (dt.Day == 24) + { + preis.AnzahlTag24++; + } + else if (dt.Day == 25) + { + preis.AnzahlTag25++; + } + else if (dt.Day == 26) + { + preis.AnzahlTag26++; + } + else if (dt.Day == 27) + { + preis.AnzahlTag27++; + } + else if (dt.Day == 28) + { + preis.AnzahlTag28++; + } + else if (dt.Day == 29) + { + preis.AnzahlTag29++; + } + else if (dt.Day == 30) + { + preis.AnzahlTag30++; + } + else if (dt.Day == 31) + { + preis.AnzahlTag31++; + } + } + + private CustomerAnwesenheit CreateCustomerAnwesenheit(AdditionalServiceBookingRow row, DateTime monat) + { + var ca = new CustomerAnwesenheit(); + ca.Monat = monat; + ca.CustomerDC = row.CustomerDC; + + ca.IstSgb9 = FrankfurtOderHelper.IstSgbIX(ca.CustomerDC.DateOfBirth, monat); + ca.IstSgb8 = !ca.IstSgb9; + + var c2s = GetCostbearer2SupportConcept(ca.CustomerDC); + ca.Costbearer2SupportConcept = c2s; + + if (c2s?.CostBearer.Organisation != null) + { + if (c2s.CostBearer.Organisation.Name.Contains("Stadt Frankfurt (Oder)")) + { + ca.IstFFO = true; + } + else + { + ca.IstAndererKT = true; + } + } + + SetzeAnwesenheiten(ca, row); + + return ca; + } + + private void SetzeAnwesenheiten(CustomerAnwesenheit ca, AdditionalServiceBookingRow row) + { + ca.AttendanceOnDay1 = row.AttendanceOnDay1; + ca.AttendanceOnDay2 = row.AttendanceOnDay2; + ca.AttendanceOnDay3 = row.AttendanceOnDay3; + ca.AttendanceOnDay4 = row.AttendanceOnDay4; + ca.AttendanceOnDay5 = row.AttendanceOnDay5; + ca.AttendanceOnDay6 = row.AttendanceOnDay6; + ca.AttendanceOnDay7 = row.AttendanceOnDay7; + ca.AttendanceOnDay8 = row.AttendanceOnDay8; + ca.AttendanceOnDay9 = row.AttendanceOnDay9; + ca.AttendanceOnDay10 = row.AttendanceOnDay10; + ca.AttendanceOnDay11 = row.AttendanceOnDay11; + ca.AttendanceOnDay12 = row.AttendanceOnDay12; + ca.AttendanceOnDay13 = row.AttendanceOnDay13; + ca.AttendanceOnDay14 = row.AttendanceOnDay14; + ca.AttendanceOnDay15 = row.AttendanceOnDay15; + ca.AttendanceOnDay16 = row.AttendanceOnDay16; + ca.AttendanceOnDay17 = row.AttendanceOnDay17; + ca.AttendanceOnDay18 = row.AttendanceOnDay18; + ca.AttendanceOnDay19 = row.AttendanceOnDay19; + ca.AttendanceOnDay20 = row.AttendanceOnDay20; + ca.AttendanceOnDay21 = row.AttendanceOnDay21; + ca.AttendanceOnDay22 = row.AttendanceOnDay22; + ca.AttendanceOnDay23 = row.AttendanceOnDay23; + ca.AttendanceOnDay24 = row.AttendanceOnDay24; + ca.AttendanceOnDay25 = row.AttendanceOnDay25; + ca.AttendanceOnDay26 = row.AttendanceOnDay26; + ca.AttendanceOnDay27 = row.AttendanceOnDay27; + ca.AttendanceOnDay28 = row.AttendanceOnDay28; + ca.AttendanceOnDay29 = row.AttendanceOnDay29; + ca.AttendanceOnDay30 = row.AttendanceOnDay30; + ca.AttendanceOnDay31 = row.AttendanceOnDay31; + + } + + private CostBearer2SupportConcept GetCostbearer2SupportConcept(CompactCustomerDC customerDC) + { + var c = DAOFactory.GenericDAO.LoadByID(customerDC.CustomerOid); + + foreach (var sc in c.SupportConcepts) + { + foreach (var c2s in sc.CostBearer2SupportConceptList) + { + foreach (var ap in c2s.ApprovalPeriodList) + { + if (ap.ServiceCategory != null && ap.ServiceCategory.Name.ToLower().Contains("außerschulisches betreuungsangebot")) + { + return c2s; + } + } + } + } + return null; + } + + } +} diff --git a/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/CustomerAnwesenheit.cs b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/CustomerAnwesenheit.cs new file mode 100644 index 000000000..80b785b96 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/CustomerAnwesenheit.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report.ReportObjects; +using BeWo.Service.DCEntityMapper; +using BeWo.Service.Invoicing; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; +using BS.Shared.Extensions; +using BS.Shared.Services; + +namespace LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot +{ + + public class CustomerAnwesenheit + { + public DateTime Monat { get; set; } + public CompactCustomerDC CustomerDC { get; set; } + public bool IstFFO { get; set; } + public bool IstAndererKT { get; set; } + public bool IstSgb8 { get; set; } + public bool IstSgb9 { get; set; } + public string AttendanceOnDay1 { get; set; } + + public string AttendanceOnDay2 { get; set; } + + public string AttendanceOnDay3 { get; set; } + + public string AttendanceOnDay4 { get; set; } + + public string AttendanceOnDay5 { get; set; } + + public string AttendanceOnDay6 { get; set; } + + public string AttendanceOnDay7 { get; set; } + + public string AttendanceOnDay8 { get; set; } + + public string AttendanceOnDay9 { get; set; } + + public string AttendanceOnDay10 { get; set; } + + public string AttendanceOnDay11 { get; set; } + + public string AttendanceOnDay12 { get; set; } + + public string AttendanceOnDay13 { get; set; } + + public string AttendanceOnDay14 { get; set; } + + public string AttendanceOnDay15 { get; set; } + + public string AttendanceOnDay16 { get; set; } + + public string AttendanceOnDay17 { get; set; } + + public string AttendanceOnDay18 { get; set; } + + public string AttendanceOnDay19 { get; set; } + + public string AttendanceOnDay20 { get; set; } + + public string AttendanceOnDay21 { get; set; } + + public string AttendanceOnDay22 { get; set; } + + public string AttendanceOnDay23 { get; set; } + + public string AttendanceOnDay24 { get; set; } + + public string AttendanceOnDay25 { get; set; } + + public string AttendanceOnDay26 { get; set; } + + public string AttendanceOnDay27 { get; set; } + + public string AttendanceOnDay28 { get; set; } + + public string AttendanceOnDay29 { get; set; } + + public string AttendanceOnDay30 { get; set; } + + public string AttendanceOnDay31 { get; set; } + + public int AttendanceMonthCount { get; set; } + + public int AbsenceTimeMonthCount { get; set; } + public CostBearer2SupportConcept Costbearer2SupportConcept { get; internal set; } + } +} diff --git a/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/StaffelpreisProTag.cs b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/StaffelpreisProTag.cs new file mode 100644 index 000000000..8c63fdeb5 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/AusserschulischesBetreuungsangebot/StaffelpreisProTag.cs @@ -0,0 +1,219 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report.ReportObjects; +using BeWo.Service.DCEntityMapper; +using BeWo.Service.Invoicing; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; +using BS.Shared.Extensions; +using BS.Shared.Services; + +namespace LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot +{ + + public class StaffelpreisProTag + { + public int Staffel { get; set; } + public decimal Preis { get; set; } + public int AnzahlTag1 { get; set; } + + public int AnzahlTag2 { get; set; } + + public int AnzahlTag3 { get; set; } + + public int AnzahlTag4 { get; set; } + + public int AnzahlTag5 { get; set; } + + public int AnzahlTag6 { get; set; } + + public int AnzahlTag7 { get; set; } + + public int AnzahlTag8 { get; set; } + + public int AnzahlTag9 { get; set; } + + public int AnzahlTag10 { get; set; } + + public int AnzahlTag11 { get; set; } + + public int AnzahlTag12 { get; set; } + + public int AnzahlTag13 { get; set; } + + public int AnzahlTag14 { get; set; } + + public int AnzahlTag15 { get; set; } + + public int AnzahlTag16 { get; set; } + + public int AnzahlTag17 { get; set; } + + public int AnzahlTag18 { get; set; } + + public int AnzahlTag19 { get; set; } + + public int AnzahlTag20 { get; set; } + + public int AnzahlTag21 { get; set; } + + public int AnzahlTag22 { get; set; } + + public int AnzahlTag23 { get; set; } + + public int AnzahlTag24 { get; set; } + + public int AnzahlTag25 { get; set; } + + public int AnzahlTag26 { get; set; } + + public int AnzahlTag27 { get; set; } + + public int AnzahlTag28 { get; set; } + + public int AnzahlTag29 { get; set; } + + public int AnzahlTag30 { get; set; } + + public int AnzahlTag31 { get; set; } + + public int AnzahlGesamt { get; set; } + + + public int GetAnzahlForDay(int day) + { + if (day == 1) + { + return AnzahlTag1; + } + if (day == 2) + { + return AnzahlTag2; + } + if (day == 3) + { + return AnzahlTag3; + } + if (day == 4) + { + return AnzahlTag4; + } + if (day == 5) + { + return AnzahlTag5; + } + if (day == 6) + { + return AnzahlTag6; + } + if (day == 7) + { + return AnzahlTag7; + } + if (day == 8) + { + return AnzahlTag8; + } + if (day == 9) + { + return AnzahlTag9; + } + if (day == 10) + { + return AnzahlTag10; + } + if (day == 11) + { + return AnzahlTag11; + } + if (day == 12) + { + return AnzahlTag12; + } + if (day == 13) + { + return AnzahlTag13; + } + if (day == 14) + { + return AnzahlTag14; + } + if (day == 15) + { + return AnzahlTag15; + } + if (day == 16) + { + return AnzahlTag16; + } + if (day == 17) + { + return AnzahlTag17; + } + if (day == 18) + { + return AnzahlTag18; + } + if (day == 19) + { + return AnzahlTag19; + } + if (day == 20) + { + return AnzahlTag20; + } + if (day == 21) + { + return AnzahlTag21; + } + if (day == 22) + { + return AnzahlTag22; + } + if (day == 23) + { + return AnzahlTag23; + } + if (day == 24) + { + return AnzahlTag24; + } + if (day == 25) + { + return AnzahlTag25; + } + if (day == 26) + { + return AnzahlTag26; + } + if (day == 27) + { + return AnzahlTag27; + } + if (day == 28) + { + return AnzahlTag28; + } + if (day == 29) + { + return AnzahlTag29; + } + if (day == 30) + { + return AnzahlTag30; + } + if (day == 31) + { + return AnzahlTag31; + } + + return 0; + } + } +} diff --git a/ReportImp/LebenshilfeFrankfurtOder/CustomReportCreator.cs b/ReportImp/LebenshilfeFrankfurtOder/CustomReportCreator.cs index db96dcb55..c557d8c39 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/CustomReportCreator.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/CustomReportCreator.cs @@ -452,11 +452,15 @@ namespace LebenshilfeFrankfurtOder { var lnRO = LeistungsnachweisSGBIXRO.Create(anwFrueUndSpaet, row); - var leistungsnachweis = new LeistungsnachweisSGBIX(); - leistungsnachweis.SetReportDataSource(lnRO); - leistungsnachweis.CreateDocument(); + if (lnRO.Rows.Count(r => !String.IsNullOrEmpty(r.Anwesend)) > 0) + { + var leistungsnachweis = new LeistungsnachweisSGBIX(); + leistungsnachweis.SetReportDataSource(lnRO); + leistungsnachweis.CreateDocument(); - report.Pages.AddRange(leistungsnachweis.Pages); + report.Pages.AddRange(leistungsnachweis.Pages); + } + } } } @@ -531,6 +535,10 @@ namespace LebenshilfeFrankfurtOder { return CreateAbrechnung(queryOid, queryReportId, AbrechnungsEnum.BesondereWohnform, false); } + if (queryOid == 1500) + { + return CreateAbrechnung(queryOid, queryReportId, AbrechnungsEnum.AusserschulischesBetreuungsangebot, false); + } return base.CreateQueryReport(queryOid, queryReportId); } @@ -633,6 +641,10 @@ namespace LebenshilfeFrankfurtOder serviceCategoryOid = 78;// Oid von Besondere Wohnform WST bbMb invoices = CreateAbrechnungBesondereWohnform(start, start.AddMonths(1).AddTicks(-1), customerOid, serviceCategoryOid); } + else if (abrechnungsArt == AbrechnungsEnum.AusserschulischesBetreuungsangebot) + { + invoices = CreateAbrechnungAusserschulischesBetreuungsangebot(start, customerOid); + } List reallyNewInvoices = null; if (customerOid.HasValue) @@ -1234,7 +1246,44 @@ namespace LebenshilfeFrankfurtOder } - private List CreateAbrechnungWst(DateTime start, DateTime end, long? customerOid) + private List CreateAbrechnungAusserschulischesBetreuungsangebot(DateTime monat, long? customerOid) + { + var fruehRegion = DAOFactory.GenericDAO.LoadByID(30); + var spaetRegion = DAOFactory.GenericDAO.LoadByID(30); + + + var roFrueh = AdditionalServiceBookingRO.Create(fruehRegion, monat); + var roSpaet = AdditionalServiceBookingRO.Create(spaetRegion, monat); + + + var afs = new AnwesenheitFruehUndSpaetbetreuung(); + afs.BerechneGesamtAnwesenheit(roFrueh, roSpaet); + + + var invoicePeriod = new DateTimeSpan(monat, monat.AddMonths(1).AddTicks(-1)); + + //IList supportConcepts = GetSupportConcepts(invoicePeriod.StartDate, invoicePeriod.EndDate, "Tagesstruktur", "pw11813", customerOid, null); + + //var supportConcepts2ServiceRecords = new Dictionary>(); + + //foreach (var sc in supportConcepts) + //{ + // if (!supportConcepts2ServiceRecords.ContainsKey(sc)) + // { + // supportConcepts2ServiceRecords.Add(sc, new List()); + // } + //} + + + var creator = new AusserschulischesBetreuungsangebotInvoiceCreation(); + + return creator.GenerateServiceInvoices(invoicePeriod, afs); + + } + + + + private List CreateAbrechnungWst(DateTime start, DateTime end, long? customerOid) { var invoicePeriod = new DateTimeSpan(start, end); @@ -1618,6 +1667,7 @@ namespace LebenshilfeFrankfurtOder FED = 2, Einzelfallhilfe = 3, ABW = 4, - BesondereWohnform = 5 + BesondereWohnform = 5, + AusserschulischesBetreuungsangebot = 6 } } diff --git a/ReportImp/LebenshilfeFrankfurtOder/Invoicing/AusserschulischesBetreuungsangebotInvoiceCreation.cs b/ReportImp/LebenshilfeFrankfurtOder/Invoicing/AusserschulischesBetreuungsangebotInvoiceCreation.cs new file mode 100644 index 000000000..594159067 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/Invoicing/AusserschulischesBetreuungsangebotInvoiceCreation.cs @@ -0,0 +1,374 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using BeWo.Data; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Service.DCEntityMapper; +using BeWo.Service.Invoicing; +using BeWo.Service.Plugins; +using BeWo.Service.ServiceImplementations; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; +using BS.Shared.Extensions; +using BS.Shared.Services; +using DevExpress.XtraReports.UI; +using LebenshilfeFrankfurtOder.Utils; +using LebenshilfeFrankfurtOder.AusserschulischesBetreuungsangebot; + +namespace LebenshilfeFrankfurtOder.Invoicing +{ + + public class AusserschulischesBetreuungsangebotInvoiceCreation : InvoiceCreation + { + + public override void SetInvoiceId(ServiceInvoice invoice) + { + invoice.InvoiceBase.InvoiceId = "RechnungABA"; + invoice.InvoiceBase.InvoiceTypeText = "aBA"; + } + + + public List GenerateServiceInvoices(DateTimeSpan invoicePeriod, AnwesenheitFruehUndSpaetbetreuung afs) + { + var invoiceList = CreateInvoices(invoicePeriod, afs); + + return invoiceList.Select(item => MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(item)).ToList(); + } + + private IList CreateInvoices(DateTimeSpan invoicePeriod, AnwesenheitFruehUndSpaetbetreuung afs) + { + var invoiceList = new List(); + var invoiceCounter = 0; + + //LH Frankfurt Oder bekommt eine eigene Sammel Rechnung + //Alle anderen Rechnungen gehen ans entsprechende Jugendamt + + var ffoAnwesenheiten = afs.CustomerAnwesenheiten.Where(a => a.IstFFO).ToList(); + if (ffoAnwesenheiten.Count > 0) + { + invoiceList.Add(CreateInvoice(invoiceCounter, invoicePeriod, afs, ffoAnwesenheiten)); + invoiceCounter++; + } + + + foreach (var ca in afs.CustomerAnwesenheiten) + { + if (!ca.IstFFO && ca.Costbearer2SupportConcept != null) + { + var i = CreateInvoice(invoiceCounter, invoicePeriod, afs, new List { ca }); + + var c = i.GetTotalClaim(); + + if (c.HasValue && c.Value > 0) + { + invoiceList.Add(i); + invoiceCounter++; + } + } + } + + return invoiceList; + } + + private ServiceInvoice CreateInvoice(int invoiceCounter, DateTimeSpan invoicePeriod, AnwesenheitFruehUndSpaetbetreuung afs, IList anwesenheiten) + { + var invoice = new ServiceInvoice(); + + SetInvoiceId(invoice); + var c2s = anwesenheiten[0].Costbearer2SupportConcept; + SetRecipientInformation(invoice, c2s.CostBearer); + + if (c2s.CostBearerContactPerson != null) + { + if (c2s.CostBearerContactPerson.Sex.HasValue && + c2s.CostBearerContactPerson.Sex.Value == Sex.Male) + { + invoice.InvoiceBase.RecipientPersonFirstName = "Herr "; + } + else if (c2s.CostBearerContactPerson.Sex.HasValue && + c2s.CostBearerContactPerson.Sex.Value == Sex.Female) + { + invoice.InvoiceBase.RecipientPersonFirstName = "Frau "; + } + else + { + invoice.InvoiceBase.RecipientPersonFirstName = ""; + } + invoice.InvoiceBase.RecipientPersonFirstName += c2s.CostBearerContactPerson.FirstName; + invoice.InvoiceBase.RecipientPersonLastName = c2s.CostBearerContactPerson.LastName; + } + + SetSenderInformation(invoice); + SetInvoiceBaseData(invoiceCounter, invoice, c2s.CostBearer, invoicePeriod, new List()); + SetServiceInvoicePeriods(invoice, invoicePeriod, afs, anwesenheiten); + + + SetServiceInvoicePeriodAmounts(invoice); + + return invoice; + + } + + + public override void SetSenderInformation(ServiceInvoice serviceInvoice) + { + ApplicationUser user = null; + if (LoggedInUserOperationContextExt.Current != null) + { + user = LoggedInUserOperationContextExt.Current.User; + } + else + { + user = SessionFacade.LoggedInUser; + } + + var mandator = new OperationsServiceImp().GetMandator2(false); + serviceInvoice.InvoiceBase.SenderAddress = new Address + { + Street = mandator.Street, + PostalCode = mandator.PostalCode, + Town = mandator.Town, + State = mandator.State + }; + + if (user != null) + { + serviceInvoice.InvoiceBase.CreatorFirstName = serviceInvoice.InvoiceBase.SenderFirstName = user.Employee.Person.FirstName; + serviceInvoice.InvoiceBase.CreatorLastName = serviceInvoice.InvoiceBase.SenderLastName = user.Employee.Person.LastName; + serviceInvoice.InvoiceBase.SenderContacts = user.Employee.Person.Contacts.Select(i => i.CopyToNew()).ToList(); + + } + } + + private void SetServiceInvoicePeriods(ServiceInvoice invoice, DateTimeSpan invoicePeriod, AnwesenheitFruehUndSpaetbetreuung afs, IList anwesenheiten) + { + var invoiceAccountingPeriodSpan = new DateTimeSpan + { + StartDateTime = invoice.InvoiceBase.AccountingPeriodStart.Value, + EndDateTime = invoice.InvoiceBase.AccountingPeriodEnd.Value + }; + + + + //if (tsc.SupportConceptApprovalPeriod != null) + //{ + // SupportConceptApprovalPeriodDC approvalPeriodDC = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDC(tsc.SupportConceptApprovalPeriod); + + + + // ServiceInvoicePeriod serviceInvoicePeriod = CreateServiceInvoicePeriod(approvalPeriodDC, invoiceAccountingPeriodSpan); + // serviceInvoicePeriod.SupportConceptApprovalPeriod = tsc.SupportConceptApprovalPeriod; + // serviceInvoicePeriod.Customer = tsc.CostBearer2SupportConcept.SupportConcept.Customer; + + // CostBearer costBearer = tsc.CostBearer2SupportConcept.CostBearer; + // List costRates = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(costBearer.CostRatePeriods); + + // CostRatePeriodDC serviceUnit = costRates.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, DateTime.Now); + // serviceInvoicePeriod.ServiceUnitName = serviceUnit.UnitName; + + + // var itemList = CreateInvoiceItems(invoice, serviceInvoicePeriod, invoicePeriod, serviceInvoicePeriod.SupportConceptApprovalPeriod); + // serviceInvoicePeriod.InvoiceItemList.AddRange(itemList); + + + // if (serviceInvoicePeriod.InvoiceItemList.Count > 0) + // invoice.ServiceInvoicePeriodList.Add(serviceInvoicePeriod); + //} + } + + + + private List CreateInvoiceItems(ServiceInvoice invoice, ServiceInvoicePeriod sip, DateTimeSpan invoicePeriod, SupportConceptApprovalPeriod scap) + { + sip.ApprovedFixedAmount = 0; + List list = new List(); + + DateTime dt = invoicePeriod.StartDate; + var bookings = DAOFactory.SearchDAO.GetAdditionalServiceBookingsForCustomer(sip.Customer.Oid.Value, invoicePeriod.StartDate, invoicePeriod.EndDate); + + var ccdc = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(sip.Customer); + while (dt <= invoicePeriod.EndDate) + { + list.Add(CreateInvoiceItem(dt, scap, bookings, sip.Customer, ccdc)); + dt = dt.AddDays(1); + } + + + + return list; + } + + private InvoiceItem CreateInvoiceItem(DateTime dt, SupportConceptApprovalPeriod scap, IEnumerable bookings, Customer c, CompactCustomerDC ccdc) + { + var invoiceItem = new InvoiceItem(); + + bool hatTagesstruktur = false; + bool hatVerpflegung = false; + HasBookings(dt, bookings, c, out hatTagesstruktur, out hatVerpflegung); + + decimal ts = 0; + + if (dt.DayOfWeek != DayOfWeek.Saturday && dt.DayOfWeek != DayOfWeek.Sunday) + { + var at = GetAbsenceTimes(dt, c.AbsenceTimes); + if (at != null) + { + var name = at.AbsenceReason.Description.ToLower(); + if (name.Contains("urlaub")) + { + invoiceItem.UnitDescription = "U"; + } + else if (name.Contains("krank")) + { + invoiceItem.UnitDescription = "K"; + } + else if (name.Contains("unentschuldigt")) + { + invoiceItem.UnitDescription = "UE"; + } + else if (name.Contains("entschuldigt")) + { + invoiceItem.UnitDescription = "E"; + } + else if (name.Contains("corona")) + { + invoiceItem.UnitDescription = "C"; + } + else + { + invoiceItem.UnitDescription = "U"; + } + + if (DarfAbwesenheitAbrechnen(ccdc, dt)) + { + ts = GetTagessatz(dt, scap) ?? 0; + } + } + } + + if (hatTagesstruktur && String.IsNullOrEmpty(invoiceItem.UnitDescription)) + { + ts = GetTagessatz(dt, scap) ?? 0; + invoiceItem.UnitDescription = "I"; + } + if (hatVerpflegung) + { + invoiceItem.Notice = "Mittag gegessen"; + } + + invoiceItem.AmountPerUnit = ts; + invoiceItem.UnitCount = 1; + invoiceItem.AmountTotal = ts; + invoiceItem.ItemPeriodStart = dt; + invoiceItem.ItemPeriodEnd = dt; + invoiceItem.GrossAmountTotal = ts; + invoiceItem.AccountingInterval = AccountingIntervalType.Daily; + if (scap != null) + { + invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid; + + if (scap.ServiceCategory != null) + { + invoiceItem.ItemDescription = scap.ServiceCategory.Name; + } + } + + return invoiceItem; + } + + private bool DarfAbwesenheitAbrechnen(CompactCustomerDC customer, DateTime dt) + { + var tage = FrankfurtOderHelper.CalculateAbsenceTimes(customer, dt, true); + if (tage.TageAbwesendImJahrBisZumAngegebenenDatum > 42) + { + return false; + } + return true; + } + + private void HasBookings(DateTime dt, IEnumerable bookings, Customer c, out bool hatTagesstruktur, out bool hatVerpflegung) + { + hatTagesstruktur = false; + hatVerpflegung = false; + foreach (var b in bookings) + { + if (b.AdditionalServiceRegion.IsActive != ActivationTypeId.Deleted && + b.AdditionalServiceRegion.AdditionalService.IsActive != ActivationTypeId.Deleted) + { + var angebot = b.AdditionalServiceRegion.AdditionalService; + if (angebot.Name == "Tagesstruktur" || angebot.Name == "Tagesstruktur Mittagsverpflegung") + { + if (b.Datum.Value.Date == dt.Date) + { + foreach (var c2a in b.Customer2AddServiceBookings) + { + if (c2a.CustomerOid == c.Oid.Value && c2a.Participated) + { + if (angebot.Name == "Tagesstruktur") + { + hatTagesstruktur = true; + } + else if (angebot.Name == "Tagesstruktur Mittagsverpflegung") + { + hatVerpflegung = true; + } + + } + } + } + } + } + } + } + + private AbsenceTime GetAbsenceTimes(DateTime dt, IList absenceTimes) + { + foreach (var at in absenceTimes) + { + if (IstTsAbsenceTime(at)) + { + if ((!at.Start.HasValue || at.Start.Value <= dt) && (!at.End.HasValue || at.End.Value >= dt)) + { + return at; + } + } + } + + return null; + } + + private bool IstTsAbsenceTime(AbsenceTime at) + { + var name = at.AbsenceReason.Description; + if (!name.Contains("WST")) + { + return true; + } + + return false; + } + + private decimal? GetTagessatz(DateTime dt, SupportConceptApprovalPeriod scap) + { + if (scap.ServiceCategory != null) + { + var crps = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(scap.ServiceCategory + .CostRatePeriods); + + var cr = crps.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney, dt); + if (cr != null && cr.CostRateValue.HasValue) + { + return cr.CostRateValue.Value; + } + + } + + return 0; + } + + } + +} diff --git a/ReportImp/LebenshilfeFrankfurtOder/LebenshilfeFrankfurtOder.csproj b/ReportImp/LebenshilfeFrankfurtOder/LebenshilfeFrankfurtOder.csproj index 38bfb9174..08fe1fe2c 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/LebenshilfeFrankfurtOder.csproj +++ b/ReportImp/LebenshilfeFrankfurtOder/LebenshilfeFrankfurtOder.csproj @@ -77,6 +77,7 @@ + Component @@ -188,6 +189,12 @@ RechnungFud.cs + + Component + + + RechnungAusserschulischesBetreuungsangebot.cs + Component @@ -351,6 +358,10 @@ RechnungFud.cs Designer + + RechnungAusserschulischesBetreuungsangebot.cs + Designer + RechnungHortPrivat.cs Designer diff --git a/ReportImp/LebenshilfeFrankfurtOder/LeistungsnachweisSGBIX.Designer.cs b/ReportImp/LebenshilfeFrankfurtOder/LeistungsnachweisSGBIX.Designer.cs index cdcb93b89..a1cf8bd02 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/LeistungsnachweisSGBIX.Designer.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/LeistungsnachweisSGBIX.Designer.cs @@ -30,6 +30,7 @@ namespace LebenshilfeFrankfurtOder private void InitializeComponent() { this.components = new System.ComponentModel.Container(); + DevExpress.XtraReports.UI.XRSummary xrSummary1 = new DevExpress.XtraReports.UI.XRSummary(); DevExpress.XtraReports.UI.XRWatermark xrWatermark1 = new DevExpress.XtraReports.UI.XRWatermark(); this.Detail = new DevExpress.XtraReports.UI.DetailBand(); this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); @@ -342,10 +343,14 @@ namespace LebenshilfeFrankfurtOder // // xrTableCell6 // - this.xrTableCell6.Multiline = true; + this.xrTableCell6.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "Rows.BetragNachStaffel")}); this.xrTableCell6.Name = "xrTableCell6"; this.xrTableCell6.StylePriority.UsePadding = false; this.xrTableCell6.StylePriority.UseTextAlignment = false; + xrSummary1.FormatString = "{0:c}"; + xrSummary1.Running = DevExpress.XtraReports.UI.SummaryRunning.Group; + this.xrTableCell6.Summary = xrSummary1; this.xrTableCell6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; this.xrTableCell6.Weight = 0.17513886337834458D; // @@ -382,7 +387,7 @@ namespace LebenshilfeFrankfurtOder this.xrLabel4.StylePriority.UseFont = false; this.xrLabel4.StylePriority.UsePadding = false; this.xrLabel4.StylePriority.UseTextAlignment = false; - this.xrLabel4.Text = "Name Kind: [Customer]"; + this.xrLabel4.Text = "Name Kind: [CustomerDC.LastNameFirstName]"; this.xrLabel4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; // // xrLabel3 diff --git a/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.Designer.cs b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.Designer.cs new file mode 100644 index 000000000..09e466923 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.Designer.cs @@ -0,0 +1,1417 @@ +using BeWo.Report.ReportObjects; +namespace LebenshilfeFrankfurtOder +{ + partial class RechnungAusserschulischesBetreuungsangebot + { + /// + /// 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(RechnungAusserschulischesBetreuungsangebot)); + 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.xrRichText1 = new DevExpress.XtraReports.UI.XRRichText(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel20 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel19 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel21 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel22 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel23 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel24 = new DevExpress.XtraReports.UI.XRLabel(); + this.cellFaelligkeit = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel29 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel28 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel27 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel26 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel25 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblKlienten = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable3 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow2 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellAnzahl1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEinheit1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellBetrag1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellGesamt1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow7 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell9 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellAnzahl2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEinheit2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellBetrag2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellGesamt2 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow8 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell29 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellAnzahl3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEinheit3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellBetrag3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellGesamt3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow9 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell33 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellAnzahl4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEinheit4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellBetrag4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellGesamt4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow10 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell37 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellAnzahl5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEinheit5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellBetrag5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellGesamt5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrLabel38 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel32 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel33 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel34 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable2 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow1 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell1 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell3 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell7 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell4 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell5 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow17 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell8 = new DevExpress.XtraReports.UI.XRTableCell(); + this.lblRechnung = new DevExpress.XtraReports.UI.XRLabel(); + this.lblAdresse = new DevExpress.XtraReports.UI.XRLabel(); + this.ruleRateFactorNull = new DevExpress.XtraReports.UI.FormattingRule(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.rtFooterAlt = new DevExpress.XtraReports.UI.XRRichText(); + this.rtFooterNeu = new DevExpress.XtraReports.UI.XRRichText(); + this.xrLine1 = new DevExpress.XtraReports.UI.XRLine(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.GroupFooter1 = new DevExpress.XtraReports.UI.GroupFooterBand(); + this.xrTable1 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow3 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell11 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell15 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell16 = new DevExpress.XtraReports.UI.XRTableCell(); + this.lblGesamt = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow4 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell13 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell14 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell18 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell19 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow5 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell20 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell21 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell22 = new DevExpress.XtraReports.UI.XRTableCell(); + this.cellEigenanteil = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow11 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell32 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell34 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell35 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell36 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableRow6 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell24 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell25 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell26 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell27 = new DevExpress.XtraReports.UI.XRTableCell(); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel39 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.rtFooterAlt)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.rtFooterNeu)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).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.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrRichText1, + this.xrLabel3, + this.xrLabel20, + this.xrLabel19, + this.xrLabel21, + this.xrLabel22, + this.xrLabel23, + this.xrLabel24, + this.cellFaelligkeit, + this.xrLabel29, + this.xrLabel28, + this.xrLabel27, + this.xrLabel26, + this.xrLabel25, + this.lblKlienten, + this.xrTable3, + this.xrLabel38, + this.xrLabel32, + this.xrLabel33, + this.xrLabel34, + this.xrLabel4, + this.xrTable2, + this.lblRechnung, + this.lblAdresse}); + this.ReportHeader.HeightF = 592.9166F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // xrRichText1 + // + this.xrRichText1.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.xrRichText1.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 20F); + this.xrRichText1.Name = "xrRichText1"; + this.xrRichText1.SerializableRtfString = resources.GetString("xrRichText1.SerializableRtfString"); + this.xrRichText1.SizeF = new System.Drawing.SizeF(312.0002F, 117.5001F); + this.xrRichText1.StylePriority.UseFont = false; + // + // xrLabel3 + // + this.xrLabel3.CanGrow = false; + this.xrLabel3.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 0F); + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(297.21F, 20F); + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Familienentlastender Dienst"; + // + // xrLabel20 + // + this.xrLabel20.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top))); + this.xrLabel20.CanGrow = false; + this.xrLabel20.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 137.5001F); + this.xrLabel20.Name = "xrLabel20"; + this.xrLabel20.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel20.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel20.StylePriority.UseBorders = false; + this.xrLabel20.StylePriority.UseFont = false; + this.xrLabel20.Text = "IK-Nummer:"; + // + // xrLabel19 + // + this.xrLabel19.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrLabel19.CanGrow = false; + this.xrLabel19.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.xrLabel19.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 157.5002F); + this.xrLabel19.Name = "xrLabel19"; + this.xrLabel19.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel19.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel19.StylePriority.UseBorders = false; + this.xrLabel19.StylePriority.UseFont = false; + this.xrLabel19.Text = "Versichertennr:"; + // + // xrLabel21 + // + this.xrLabel21.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrLabel21.CanGrow = false; + this.xrLabel21.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.xrLabel21.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 177.5002F); + this.xrLabel21.Name = "xrLabel21"; + this.xrLabel21.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel21.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel21.StylePriority.UseBorders = false; + this.xrLabel21.StylePriority.UseFont = false; + this.xrLabel21.Text = "Kunden-Nr.:"; + // + // xrLabel22 + // + this.xrLabel22.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrLabel22.CanGrow = false; + this.xrLabel22.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.xrLabel22.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 197.5002F); + this.xrLabel22.Name = "xrLabel22"; + this.xrLabel22.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel22.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel22.StylePriority.UseBorders = false; + this.xrLabel22.StylePriority.UseFont = false; + this.xrLabel22.Text = "Rechnungs-Nr.:"; + // + // xrLabel23 + // + this.xrLabel23.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrLabel23.CanGrow = false; + this.xrLabel23.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.xrLabel23.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 217.5002F); + this.xrLabel23.Name = "xrLabel23"; + this.xrLabel23.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel23.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel23.StylePriority.UseBorders = false; + this.xrLabel23.StylePriority.UseFont = false; + this.xrLabel23.Text = "Rechnungsdatum:"; + // + // xrLabel24 + // + this.xrLabel24.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrLabel24.CanGrow = false; + this.xrLabel24.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.xrLabel24.LocationFloat = new DevExpress.Utils.PointFloat(409.9998F, 237.5002F); + this.xrLabel24.Name = "xrLabel24"; + this.xrLabel24.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel24.SizeF = new System.Drawing.SizeF(119.1895F, 20F); + this.xrLabel24.StylePriority.UseBorders = false; + this.xrLabel24.StylePriority.UseFont = false; + this.xrLabel24.Text = "Fälligkeit:"; + // + // cellFaelligkeit + // + this.cellFaelligkeit.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Right | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.cellFaelligkeit.CanGrow = false; + this.cellFaelligkeit.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.cellFaelligkeit.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 237.5002F); + this.cellFaelligkeit.Name = "cellFaelligkeit"; + this.cellFaelligkeit.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.cellFaelligkeit.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.cellFaelligkeit.StylePriority.UseBorders = false; + this.cellFaelligkeit.StylePriority.UseFont = false; + this.cellFaelligkeit.StylePriority.UseTextAlignment = false; + this.cellFaelligkeit.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel29 + // + this.xrLabel29.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrLabel29.CanGrow = false; + this.xrLabel29.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceDate")}); + this.xrLabel29.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.xrLabel29.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 217.5002F); + this.xrLabel29.Name = "xrLabel29"; + this.xrLabel29.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel29.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.xrLabel29.StylePriority.UseBorders = false; + this.xrLabel29.StylePriority.UseFont = false; + this.xrLabel29.StylePriority.UseTextAlignment = false; + this.xrLabel29.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel28 + // + this.xrLabel28.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrLabel28.CanGrow = false; + this.xrLabel28.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceNumber")}); + this.xrLabel28.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.xrLabel28.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 197.5002F); + this.xrLabel28.Name = "xrLabel28"; + this.xrLabel28.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel28.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.xrLabel28.StylePriority.UseBorders = false; + this.xrLabel28.StylePriority.UseFont = false; + this.xrLabel28.StylePriority.UseTextAlignment = false; + this.xrLabel28.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel27 + // + this.xrLabel27.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrLabel27.CanGrow = false; + this.xrLabel27.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "OrganisationDebitorNumber")}); + this.xrLabel27.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.xrLabel27.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 177.5002F); + this.xrLabel27.Name = "xrLabel27"; + this.xrLabel27.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel27.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.xrLabel27.StylePriority.UseBorders = false; + this.xrLabel27.StylePriority.UseFont = false; + this.xrLabel27.StylePriority.UseTextAlignment = false; + this.xrLabel27.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel26 + // + this.xrLabel26.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrLabel26.CanGrow = false; + this.xrLabel26.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "CustomerReferenceNumber")}); + this.xrLabel26.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.xrLabel26.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 157.5002F); + this.xrLabel26.Name = "xrLabel26"; + this.xrLabel26.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel26.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.xrLabel26.StylePriority.UseBorders = false; + this.xrLabel26.StylePriority.UseFont = false; + this.xrLabel26.StylePriority.UseTextAlignment = false; + this.xrLabel26.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // xrLabel25 + // + this.xrLabel25.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right))); + this.xrLabel25.CanGrow = false; + this.xrLabel25.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel25.LocationFloat = new DevExpress.Utils.PointFloat(529.1893F, 137.5001F); + this.xrLabel25.Name = "xrLabel25"; + this.xrLabel25.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel25.SizeF = new System.Drawing.SizeF(167.3101F, 20F); + this.xrLabel25.StylePriority.UseBorders = false; + this.xrLabel25.StylePriority.UseFont = false; + this.xrLabel25.StylePriority.UseTextAlignment = false; + this.xrLabel25.Text = "501205613"; + this.xrLabel25.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopRight; + // + // lblKlienten + // + this.lblKlienten.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.lblKlienten.LocationFloat = new DevExpress.Utils.PointFloat(175.5436F, 367.3611F); + this.lblKlienten.Multiline = true; + this.lblKlienten.Name = "lblKlienten"; + this.lblKlienten.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblKlienten.SizeF = new System.Drawing.SizeF(520.9559F, 19.99994F); + this.lblKlienten.StylePriority.UseFont = false; + this.lblKlienten.Text = "Klienten:"; + // + // xrTable3 + // + this.xrTable3.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTable3.LocationFloat = new DevExpress.Utils.PointFloat(0.000406901F, 492.9167F); + this.xrTable3.Name = "xrTable3"; + this.xrTable3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTable3.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow2, + this.xrTableRow7, + this.xrTableRow8, + this.xrTableRow9, + this.xrTableRow10}); + this.xrTable3.SizeF = new System.Drawing.SizeF(696.5F, 100F); + this.xrTable3.StylePriority.UseBackColor = false; + this.xrTable3.StylePriority.UseBorderColor = false; + this.xrTable3.StylePriority.UseFont = false; + this.xrTable3.StylePriority.UsePadding = false; + // + // xrTableRow2 + // + this.xrTableRow2.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell2, + this.cellAnzahl1, + this.cellEinheit1, + this.cellBetrag1, + this.cellGesamt1}); + this.xrTableRow2.Name = "xrTableRow2"; + this.xrTableRow2.Weight = 0.10000000000000003D; + // + // xrTableCell2 + // + this.xrTableCell2.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell2.Multiline = true; + this.xrTableCell2.Name = "xrTableCell2"; + this.xrTableCell2.StylePriority.UseBorders = false; + this.xrTableCell2.StylePriority.UseFont = false; + this.xrTableCell2.StylePriority.UsePadding = false; + this.xrTableCell2.StylePriority.UseTextAlignment = false; + this.xrTableCell2.Text = "Staffelpreis 1"; + this.xrTableCell2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell2.Weight = 0.46153846153846145D; + // + // cellAnzahl1 + // + this.cellAnzahl1.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellAnzahl1.Name = "cellAnzahl1"; + this.cellAnzahl1.StylePriority.UseBorders = false; + this.cellAnzahl1.StylePriority.UseTextAlignment = false; + this.cellAnzahl1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellAnzahl1.Weight = 0.099999999999999978D; + // + // cellEinheit1 + // + this.cellEinheit1.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellEinheit1.CanShrink = true; + this.cellEinheit1.Name = "cellEinheit1"; + this.cellEinheit1.StylePriority.UseBorders = false; + this.cellEinheit1.StylePriority.UseFont = false; + this.cellEinheit1.StylePriority.UsePadding = false; + this.cellEinheit1.StylePriority.UseTextAlignment = false; + this.cellEinheit1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellEinheit1.Weight = 0.1538461538461538D; + // + // cellBetrag1 + // + this.cellBetrag1.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellBetrag1.Name = "cellBetrag1"; + this.cellBetrag1.StylePriority.UseBorderColor = false; + this.cellBetrag1.StylePriority.UseBorders = false; + this.cellBetrag1.StylePriority.UseFont = false; + this.cellBetrag1.StylePriority.UsePadding = false; + this.cellBetrag1.StylePriority.UseTextAlignment = false; + this.cellBetrag1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellBetrag1.Weight = 0.14615384615384613D; + // + // cellGesamt1 + // + this.cellGesamt1.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellGesamt1.Name = "cellGesamt1"; + this.cellGesamt1.StylePriority.UseBorderColor = false; + this.cellGesamt1.StylePriority.UseBorders = false; + this.cellGesamt1.StylePriority.UseFont = false; + this.cellGesamt1.StylePriority.UsePadding = false; + this.cellGesamt1.StylePriority.UseTextAlignment = false; + this.cellGesamt1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellGesamt1.Weight = 0.20999999999999996D; + // + // xrTableRow7 + // + this.xrTableRow7.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell9, + this.cellAnzahl2, + this.cellEinheit2, + this.cellBetrag2, + this.cellGesamt2}); + this.xrTableRow7.Name = "xrTableRow7"; + this.xrTableRow7.Weight = 0.10000000000000003D; + // + // xrTableCell9 + // + this.xrTableCell9.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell9.Name = "xrTableCell9"; + this.xrTableCell9.StylePriority.UseBorders = false; + this.xrTableCell9.StylePriority.UseTextAlignment = false; + this.xrTableCell9.Text = "Staffelpreis 2"; + this.xrTableCell9.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell9.Weight = 0.46153846153846145D; + // + // cellAnzahl2 + // + this.cellAnzahl2.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellAnzahl2.Name = "cellAnzahl2"; + this.cellAnzahl2.StylePriority.UseBorders = false; + this.cellAnzahl2.StylePriority.UseTextAlignment = false; + this.cellAnzahl2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellAnzahl2.Weight = 0.099999999999999978D; + // + // cellEinheit2 + // + this.cellEinheit2.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellEinheit2.Name = "cellEinheit2"; + this.cellEinheit2.StylePriority.UseBorders = false; + this.cellEinheit2.StylePriority.UseTextAlignment = false; + this.cellEinheit2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellEinheit2.Weight = 0.1538461538461538D; + // + // cellBetrag2 + // + this.cellBetrag2.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellBetrag2.Name = "cellBetrag2"; + this.cellBetrag2.StylePriority.UseBorders = false; + this.cellBetrag2.StylePriority.UseTextAlignment = false; + this.cellBetrag2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellBetrag2.Weight = 0.14615384615384613D; + // + // cellGesamt2 + // + this.cellGesamt2.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellGesamt2.Name = "cellGesamt2"; + this.cellGesamt2.StylePriority.UseBorders = false; + this.cellGesamt2.StylePriority.UseTextAlignment = false; + this.cellGesamt2.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellGesamt2.Weight = 0.20999999999999996D; + // + // xrTableRow8 + // + this.xrTableRow8.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell29, + this.cellAnzahl3, + this.cellEinheit3, + this.cellBetrag3, + this.cellGesamt3}); + this.xrTableRow8.Name = "xrTableRow8"; + this.xrTableRow8.Weight = 0.10000000000000003D; + // + // xrTableCell29 + // + this.xrTableCell29.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell29.Name = "xrTableCell29"; + this.xrTableCell29.StylePriority.UseBorders = false; + this.xrTableCell29.StylePriority.UseTextAlignment = false; + this.xrTableCell29.Text = "Staffelpreis 3"; + this.xrTableCell29.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell29.Weight = 0.46153846153846145D; + // + // cellAnzahl3 + // + this.cellAnzahl3.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellAnzahl3.Name = "cellAnzahl3"; + this.cellAnzahl3.StylePriority.UseBorders = false; + this.cellAnzahl3.StylePriority.UseTextAlignment = false; + this.cellAnzahl3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellAnzahl3.Weight = 0.099999999999999978D; + // + // cellEinheit3 + // + this.cellEinheit3.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellEinheit3.Name = "cellEinheit3"; + this.cellEinheit3.StylePriority.UseBorders = false; + this.cellEinheit3.StylePriority.UseTextAlignment = false; + this.cellEinheit3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellEinheit3.Weight = 0.1538461538461538D; + // + // cellBetrag3 + // + this.cellBetrag3.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellBetrag3.Name = "cellBetrag3"; + this.cellBetrag3.StylePriority.UseBorders = false; + this.cellBetrag3.StylePriority.UseTextAlignment = false; + this.cellBetrag3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellBetrag3.Weight = 0.14615384615384613D; + // + // cellGesamt3 + // + this.cellGesamt3.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellGesamt3.Name = "cellGesamt3"; + this.cellGesamt3.StylePriority.UseBorders = false; + this.cellGesamt3.StylePriority.UseTextAlignment = false; + this.cellGesamt3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellGesamt3.Weight = 0.20999999999999996D; + // + // xrTableRow9 + // + this.xrTableRow9.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell33, + this.cellAnzahl4, + this.cellEinheit4, + this.cellBetrag4, + this.cellGesamt4}); + this.xrTableRow9.Name = "xrTableRow9"; + this.xrTableRow9.Weight = 0.10000000000000003D; + // + // xrTableCell33 + // + this.xrTableCell33.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell33.Name = "xrTableCell33"; + this.xrTableCell33.StylePriority.UseBorders = false; + this.xrTableCell33.StylePriority.UseTextAlignment = false; + this.xrTableCell33.Text = "Staffelpreis 4"; + this.xrTableCell33.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell33.Weight = 0.46153846153846145D; + // + // cellAnzahl4 + // + this.cellAnzahl4.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellAnzahl4.Name = "cellAnzahl4"; + this.cellAnzahl4.StylePriority.UseBorders = false; + this.cellAnzahl4.StylePriority.UseTextAlignment = false; + this.cellAnzahl4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellAnzahl4.Weight = 0.099999999999999978D; + // + // cellEinheit4 + // + this.cellEinheit4.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellEinheit4.Name = "cellEinheit4"; + this.cellEinheit4.StylePriority.UseBorders = false; + this.cellEinheit4.StylePriority.UseTextAlignment = false; + this.cellEinheit4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellEinheit4.Weight = 0.1538461538461538D; + // + // cellBetrag4 + // + this.cellBetrag4.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellBetrag4.Name = "cellBetrag4"; + this.cellBetrag4.StylePriority.UseBorders = false; + this.cellBetrag4.StylePriority.UseTextAlignment = false; + this.cellBetrag4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellBetrag4.Weight = 0.14615384615384613D; + // + // cellGesamt4 + // + this.cellGesamt4.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellGesamt4.Name = "cellGesamt4"; + this.cellGesamt4.StylePriority.UseBorders = false; + this.cellGesamt4.StylePriority.UseTextAlignment = false; + this.cellGesamt4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellGesamt4.Weight = 0.20999999999999996D; + // + // xrTableRow10 + // + this.xrTableRow10.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell37, + this.cellAnzahl5, + this.cellEinheit5, + this.cellBetrag5, + this.cellGesamt5}); + this.xrTableRow10.Name = "xrTableRow10"; + this.xrTableRow10.Weight = 0.10000000000000003D; + // + // xrTableCell37 + // + this.xrTableCell37.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell37.Name = "xrTableCell37"; + this.xrTableCell37.StylePriority.UseBorders = false; + this.xrTableCell37.StylePriority.UseTextAlignment = false; + this.xrTableCell37.Text = "Staffelpreis 5"; + this.xrTableCell37.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell37.Weight = 0.46153846153846145D; + // + // cellAnzahl5 + // + this.cellAnzahl5.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellAnzahl5.Name = "cellAnzahl5"; + this.cellAnzahl5.StylePriority.UseBorders = false; + this.cellAnzahl5.StylePriority.UseTextAlignment = false; + this.cellAnzahl5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellAnzahl5.Weight = 0.099999999999999978D; + // + // cellEinheit5 + // + this.cellEinheit5.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellEinheit5.Name = "cellEinheit5"; + this.cellEinheit5.StylePriority.UseBorders = false; + this.cellEinheit5.StylePriority.UseTextAlignment = false; + this.cellEinheit5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellEinheit5.Weight = 0.1538461538461538D; + // + // cellBetrag5 + // + this.cellBetrag5.Borders = DevExpress.XtraPrinting.BorderSide.None; + this.cellBetrag5.Name = "cellBetrag5"; + this.cellBetrag5.StylePriority.UseBorders = false; + this.cellBetrag5.StylePriority.UseTextAlignment = false; + this.cellBetrag5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.cellBetrag5.Weight = 0.14615384615384613D; + // + // cellGesamt5 + // + this.cellGesamt5.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellGesamt5.Name = "cellGesamt5"; + this.cellGesamt5.StylePriority.UseBorders = false; + this.cellGesamt5.StylePriority.UseTextAlignment = false; + this.cellGesamt5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellGesamt5.Weight = 0.20999999999999996D; + // + // xrLabel38 + // + this.xrLabel38.Font = new DevExpress.Drawing.DXFont("Arial", 8F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel38.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrLabel38.Multiline = true; + this.xrLabel38.Name = "xrLabel38"; + this.xrLabel38.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel38.SizeF = new System.Drawing.SizeF(392.2079F, 20.93748F); + this.xrLabel38.StylePriority.UseFont = false; + this.xrLabel38.Text = "LEBENSHILFE Frankfurt (Oder), Hansastraße 3, 15234 Frankfurt (Oder)"; + // + // xrLabel32 + // + this.xrLabel32.CanGrow = false; + this.xrLabel32.Font = new DevExpress.Drawing.DXFont("Arial", 12F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel32.LocationFloat = new DevExpress.Utils.PointFloat(70.0004F, 367.3611F); + this.xrLabel32.Name = "xrLabel32"; + this.xrLabel32.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel32.SizeF = new System.Drawing.SizeF(105.5432F, 19.99994F); + this.xrLabel32.StylePriority.UseFont = false; + this.xrLabel32.Text = "Klienten:"; + // + // xrLabel33 + // + this.xrLabel33.CanGrow = false; + this.xrLabel33.Font = new DevExpress.Drawing.DXFont("Arial", 12F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel33.LocationFloat = new DevExpress.Utils.PointFloat(70.00021F, 412.9167F); + this.xrLabel33.Name = "xrLabel33"; + this.xrLabel33.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel33.SizeF = new System.Drawing.SizeF(105.5435F, 20F); + this.xrLabel33.StylePriority.UseFont = false; + this.xrLabel33.Text = "Zeitraum:"; + // + // xrLabel34 + // + this.xrLabel34.CanGrow = false; + this.xrLabel34.Font = new DevExpress.Drawing.DXFont("Arial", 12F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel34.LocationFloat = new DevExpress.Utils.PointFloat(175.5436F, 412.9167F); + this.xrLabel34.Name = "xrLabel34"; + this.xrLabel34.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel34.SizeF = new System.Drawing.SizeF(520.9559F, 20F); + this.xrLabel34.StylePriority.UseFont = false; + this.xrLabel34.Text = "[AccountingPeriodStart!dd.MM.yyyy] bis [AccountingPeriodEnd!dd.MM.yyyy]"; + // + // xrLabel4 + // + this.xrLabel4.CanGrow = false; + this.xrLabel4.Font = new DevExpress.Drawing.DXFont("Arial", 12F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(70.00021F, 310F); + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(606.5F, 20F); + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "Außerschulisches Betreuungsangebot"; + // + // xrTable2 + // + this.xrTable2.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTable2.LocationFloat = new DevExpress.Utils.PointFloat(0.000406901F, 452.9167F); + this.xrTable2.Name = "xrTable2"; + this.xrTable2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTable2.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow1, + this.xrTableRow17}); + this.xrTable2.SizeF = new System.Drawing.SizeF(696.5F, 40F); + this.xrTable2.StylePriority.UseBackColor = false; + this.xrTable2.StylePriority.UseBorderColor = false; + this.xrTable2.StylePriority.UseFont = false; + this.xrTable2.StylePriority.UsePadding = false; + // + // xrTableRow1 + // + this.xrTableRow1.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell1, + this.xrTableCell3, + this.xrTableCell7, + this.xrTableCell4, + this.xrTableCell6, + this.xrTableCell5}); + this.xrTableRow1.Name = "xrTableRow1"; + this.xrTableRow1.Weight = 0.10000000000000003D; + // + // xrTableCell1 + // + this.xrTableCell1.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell1.Multiline = true; + this.xrTableCell1.Name = "xrTableCell1"; + this.xrTableCell1.StylePriority.UseBorders = false; + this.xrTableCell1.StylePriority.UseFont = false; + this.xrTableCell1.StylePriority.UsePadding = false; + this.xrTableCell1.StylePriority.UseTextAlignment = false; + this.xrTableCell1.Text = "Bezeichnung"; + this.xrTableCell1.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell1.Weight = 0.26923076923076911D; + // + // xrTableCell3 + // + this.xrTableCell3.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell3.Name = "xrTableCell3"; + this.xrTableCell3.StylePriority.UseBorders = false; + this.xrTableCell3.StylePriority.UseTextAlignment = false; + this.xrTableCell3.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell3.Weight = 0.1923076688326322D; + // + // xrTableCell7 + // + this.xrTableCell7.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell7.Name = "xrTableCell7"; + this.xrTableCell7.StylePriority.UseBorders = false; + this.xrTableCell7.StylePriority.UseTextAlignment = false; + this.xrTableCell7.Text = "Anzahl"; + this.xrTableCell7.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell7.Weight = 0.099999999999999978D; + // + // xrTableCell4 + // + this.xrTableCell4.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell4.CanShrink = true; + this.xrTableCell4.Name = "xrTableCell4"; + this.xrTableCell4.StylePriority.UseBorders = false; + this.xrTableCell4.StylePriority.UseFont = false; + this.xrTableCell4.StylePriority.UsePadding = false; + this.xrTableCell4.StylePriority.UseTextAlignment = false; + this.xrTableCell4.Text = "Einheit"; + this.xrTableCell4.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell4.Weight = 0.15384615384615383D; + // + // xrTableCell6 + // + this.xrTableCell6.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.StylePriority.UseBorderColor = false; + this.xrTableCell6.StylePriority.UseBorders = false; + this.xrTableCell6.StylePriority.UseFont = false; + this.xrTableCell6.StylePriority.UsePadding = false; + this.xrTableCell6.StylePriority.UseTextAlignment = false; + this.xrTableCell6.Text = "Betrag"; + this.xrTableCell6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell6.Weight = 0.14615386962890622D; + // + // xrTableCell5 + // + this.xrTableCell5.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell5.Name = "xrTableCell5"; + 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.Text = "Gesamt"; + this.xrTableCell5.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell5.Weight = 0.20999999999999996D; + // + // xrTableRow17 + // + this.xrTableRow17.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell8}); + this.xrTableRow17.Name = "xrTableRow17"; + this.xrTableRow17.Weight = 0.10000000000000003D; + // + // xrTableCell8 + // + this.xrTableCell8.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell8.Name = "xrTableCell8"; + this.xrTableCell8.StylePriority.UseBorders = false; + this.xrTableCell8.StylePriority.UseTextAlignment = false; + this.xrTableCell8.Text = "Betreuungsleistung"; + this.xrTableCell8.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell8.Weight = 1.0715384615384613D; + // + // lblRechnung + // + this.lblRechnung.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(51)))), ((int)(((byte)(102)))), ((int)(((byte)(255))))); + this.lblRechnung.CanGrow = false; + this.lblRechnung.Font = new DevExpress.Drawing.DXFont("Arial", 12F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.lblRechnung.LocationFloat = new DevExpress.Utils.PointFloat(0.000406901F, 278.3333F); + this.lblRechnung.Name = "lblRechnung"; + this.lblRechnung.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblRechnung.SizeF = new System.Drawing.SizeF(696.4996F, 20F); + this.lblRechnung.StylePriority.UseBackColor = false; + this.lblRechnung.StylePriority.UseFont = false; + this.lblRechnung.StylePriority.UseTextAlignment = false; + this.lblRechnung.Text = "Rechnung"; + this.lblRechnung.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + // + // lblAdresse + // + this.lblAdresse.Font = new DevExpress.Drawing.DXFont("Arial", 12F, 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, 35F); + 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(392.2079F, 149.5209F); + this.lblAdresse.StylePriority.UseFont = false; + this.lblAdresse.Text = "Anschrift"; + // + // ruleRateFactorNull + // + this.ruleRateFactorNull.Condition = "[RateFactorText2] == ?"; + this.ruleRateFactorNull.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.ruleRateFactorNull.Name = "ruleRateFactorNull"; + // + // topMarginBand1 + // + this.topMarginBand1.HeightF = 200F; + this.topMarginBand1.Name = "topMarginBand1"; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.rtFooterAlt, + this.rtFooterNeu, + this.xrLine1}); + this.bottomMarginBand1.HeightF = 287.9167F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // rtFooterAlt + // + this.rtFooterAlt.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.rtFooterAlt.LocationFloat = new DevExpress.Utils.PointFloat(0F, 10F); + this.rtFooterAlt.Name = "rtFooterAlt"; + this.rtFooterAlt.SerializableRtfString = resources.GetString("rtFooterAlt.SerializableRtfString"); + this.rtFooterAlt.SizeF = new System.Drawing.SizeF(712.0003F, 90F); + this.rtFooterAlt.StylePriority.UseFont = false; + // + // rtFooterNeu + // + this.rtFooterNeu.Font = new DevExpress.Drawing.DXFont("Arial", 8F); + this.rtFooterNeu.LocationFloat = new DevExpress.Utils.PointFloat(0F, 100F); + this.rtFooterNeu.Name = "rtFooterNeu"; + this.rtFooterNeu.SerializableRtfString = resources.GetString("rtFooterNeu.SerializableRtfString"); + this.rtFooterNeu.SizeF = new System.Drawing.SizeF(712.0003F, 90F); + this.rtFooterNeu.StylePriority.UseFont = false; + // + // xrLine1 + // + this.xrLine1.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(112)))), ((int)(((byte)(197))))); + this.xrLine1.LocationFloat = new DevExpress.Utils.PointFloat(0.0002543131F, 0F); + this.xrLine1.Name = "xrLine1"; + this.xrLine1.SizeF = new System.Drawing.SizeF(696.4991F, 6.25F); + this.xrLine1.StylePriority.UseForeColor = false; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.ServiceInvoiceRO); + // + // GroupFooter1 + // + this.GroupFooter1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable1}); + this.GroupFooter1.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.GroupFooter1.Name = "GroupFooter1"; + this.GroupFooter1.StylePriority.UseFont = false; + // + // xrTable1 + // + this.xrTable1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable1.Name = "xrTable1"; + this.xrTable1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrTable1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow3, + this.xrTableRow4, + this.xrTableRow5, + this.xrTableRow11, + this.xrTableRow6}); + this.xrTable1.SizeF = new System.Drawing.SizeF(696.5F, 100F); + this.xrTable1.StylePriority.UseBackColor = false; + this.xrTable1.StylePriority.UseBorderColor = false; + this.xrTable1.StylePriority.UseBorders = false; + this.xrTable1.StylePriority.UsePadding = false; + // + // xrTableRow3 + // + this.xrTableRow3.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell11, + this.xrTableCell15, + this.xrTableCell16, + this.lblGesamt}); + this.xrTableRow3.Name = "xrTableRow3"; + this.xrTableRow3.Weight = 0.10000000000000003D; + // + // xrTableCell11 + // + this.xrTableCell11.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top))); + this.xrTableCell11.Multiline = true; + this.xrTableCell11.Name = "xrTableCell11"; + this.xrTableCell11.StylePriority.UseBorders = false; + this.xrTableCell11.StylePriority.UseFont = false; + this.xrTableCell11.StylePriority.UsePadding = false; + this.xrTableCell11.StylePriority.UseTextAlignment = false; + this.xrTableCell11.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell11.Weight = 0.10769230769230767D; + // + // xrTableCell15 + // + this.xrTableCell15.Borders = DevExpress.XtraPrinting.BorderSide.Top; + this.xrTableCell15.CanShrink = true; + this.xrTableCell15.Name = "xrTableCell15"; + this.xrTableCell15.StylePriority.UseBorders = false; + this.xrTableCell15.StylePriority.UseFont = false; + this.xrTableCell15.StylePriority.UsePadding = false; + this.xrTableCell15.StylePriority.UseTextAlignment = false; + this.xrTableCell15.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell15.Weight = 0.35384615384615381D; + // + // xrTableCell16 + // + this.xrTableCell16.Borders = DevExpress.XtraPrinting.BorderSide.Top; + this.xrTableCell16.Name = "xrTableCell16"; + this.xrTableCell16.StylePriority.UseBorderColor = false; + this.xrTableCell16.StylePriority.UseBorders = false; + this.xrTableCell16.StylePriority.UseFont = false; + this.xrTableCell16.StylePriority.UsePadding = false; + this.xrTableCell16.StylePriority.UseTextAlignment = false; + this.xrTableCell16.Text = "Rechnungsbetrag netto"; + this.xrTableCell16.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell16.Weight = 0.39999999999999991D; + // + // lblGesamt + // + this.lblGesamt.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right))); + this.lblGesamt.Name = "lblGesamt"; + this.lblGesamt.StylePriority.UseBorderColor = false; + this.lblGesamt.StylePriority.UseBorders = false; + this.lblGesamt.StylePriority.UseFont = false; + this.lblGesamt.StylePriority.UsePadding = false; + this.lblGesamt.StylePriority.UseTextAlignment = false; + this.lblGesamt.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.lblGesamt.Weight = 0.20999999999999996D; + // + // xrTableRow4 + // + this.xrTableRow4.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell13, + this.xrTableCell14, + this.xrTableCell18, + this.xrTableCell19}); + this.xrTableRow4.Name = "xrTableRow4"; + this.xrTableRow4.Weight = 0.10000000000000003D; + // + // xrTableCell13 + // + this.xrTableCell13.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell13.Name = "xrTableCell13"; + this.xrTableCell13.StylePriority.UseBorders = false; + this.xrTableCell13.StylePriority.UseTextAlignment = false; + this.xrTableCell13.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell13.Weight = 0.10769230769230767D; + // + // xrTableCell14 + // + this.xrTableCell14.Name = "xrTableCell14"; + this.xrTableCell14.StylePriority.UseBorders = false; + this.xrTableCell14.StylePriority.UseTextAlignment = false; + this.xrTableCell14.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell14.Weight = 0.35384615384615381D; + // + // xrTableCell18 + // + this.xrTableCell18.Name = "xrTableCell18"; + this.xrTableCell18.StylePriority.UseBorders = false; + this.xrTableCell18.StylePriority.UseTextAlignment = false; + this.xrTableCell18.Text = "befreit von der Mehrwertsteuer"; + this.xrTableCell18.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell18.Weight = 0.39999999999999991D; + // + // xrTableCell19 + // + this.xrTableCell19.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrTableCell19.Name = "xrTableCell19"; + this.xrTableCell19.StylePriority.UseBorders = false; + this.xrTableCell19.StylePriority.UseTextAlignment = false; + this.xrTableCell19.Text = "0,00 €"; + this.xrTableCell19.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell19.Weight = 0.20999999999999996D; + // + // xrTableRow5 + // + this.xrTableRow5.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell20, + this.xrTableCell21, + this.xrTableCell22, + this.cellEigenanteil}); + this.xrTableRow5.Name = "xrTableRow5"; + this.xrTableRow5.Weight = 0.10000000000000003D; + // + // xrTableCell20 + // + this.xrTableCell20.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell20.Name = "xrTableCell20"; + this.xrTableCell20.StylePriority.UseBorders = false; + this.xrTableCell20.StylePriority.UseTextAlignment = false; + this.xrTableCell20.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell20.Weight = 0.10769230769230767D; + // + // xrTableCell21 + // + this.xrTableCell21.Name = "xrTableCell21"; + this.xrTableCell21.StylePriority.UseTextAlignment = false; + this.xrTableCell21.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell21.Weight = 0.35384615384615381D; + // + // xrTableCell22 + // + this.xrTableCell22.Name = "xrTableCell22"; + this.xrTableCell22.StylePriority.UseTextAlignment = false; + this.xrTableCell22.Text = "abzüglich Eigenanteil (siehe Anlage)"; + this.xrTableCell22.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell22.Weight = 0.39999999999999991D; + // + // cellEigenanteil + // + this.cellEigenanteil.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.cellEigenanteil.Name = "cellEigenanteil"; + this.cellEigenanteil.StylePriority.UseBorders = false; + this.cellEigenanteil.StylePriority.UseTextAlignment = false; + this.cellEigenanteil.Text = "0,00 €"; + this.cellEigenanteil.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.cellEigenanteil.Weight = 0.20999999999999996D; + // + // xrTableRow11 + // + this.xrTableRow11.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell32, + this.xrTableCell34, + this.xrTableCell35, + this.xrTableCell36}); + this.xrTableRow11.Name = "xrTableRow11"; + this.xrTableRow11.Weight = 0.10000000000000003D; + // + // xrTableCell32 + // + this.xrTableCell32.Borders = DevExpress.XtraPrinting.BorderSide.Left; + this.xrTableCell32.Name = "xrTableCell32"; + this.xrTableCell32.StylePriority.UseBorders = false; + this.xrTableCell32.StylePriority.UseTextAlignment = false; + this.xrTableCell32.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell32.Weight = 0.10769230769230767D; + // + // xrTableCell34 + // + this.xrTableCell34.Name = "xrTableCell34"; + this.xrTableCell34.StylePriority.UseTextAlignment = false; + this.xrTableCell34.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell34.Weight = 0.35384615384615381D; + // + // xrTableCell35 + // + this.xrTableCell35.Name = "xrTableCell35"; + this.xrTableCell35.StylePriority.UseTextAlignment = false; + this.xrTableCell35.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell35.Weight = 0.39999999999999991D; + // + // xrTableCell36 + // + this.xrTableCell36.Borders = DevExpress.XtraPrinting.BorderSide.Right; + this.xrTableCell36.Name = "xrTableCell36"; + this.xrTableCell36.StylePriority.UseBorders = false; + this.xrTableCell36.StylePriority.UseTextAlignment = false; + this.xrTableCell36.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell36.Weight = 0.20999999999999996D; + // + // xrTableRow6 + // + this.xrTableRow6.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell24, + this.xrTableCell25, + this.xrTableCell26, + this.xrTableCell27}); + this.xrTableRow6.Name = "xrTableRow6"; + this.xrTableRow6.Weight = 0.10000000000000003D; + // + // xrTableCell24 + // + this.xrTableCell24.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell24.Name = "xrTableCell24"; + this.xrTableCell24.StylePriority.UseBorders = false; + this.xrTableCell24.StylePriority.UseTextAlignment = false; + this.xrTableCell24.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell24.Weight = 0.10769230769230767D; + // + // xrTableCell25 + // + this.xrTableCell25.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell25.Name = "xrTableCell25"; + this.xrTableCell25.StylePriority.UseBorders = false; + this.xrTableCell25.StylePriority.UseTextAlignment = false; + this.xrTableCell25.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter; + this.xrTableCell25.Weight = 0.35384615384615381D; + // + // xrTableCell26 + // + this.xrTableCell26.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell26.Name = "xrTableCell26"; + this.xrTableCell26.StylePriority.UseBorders = false; + this.xrTableCell26.StylePriority.UseFont = false; + this.xrTableCell26.StylePriority.UseTextAlignment = false; + this.xrTableCell26.Text = "Rechnungsbetrag brutto"; + this.xrTableCell26.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell26.Weight = 0.39999999999999991D; + // + // xrTableCell27 + // + this.xrTableCell27.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell27.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "GrossClaim")}); + this.xrTableCell27.Font = new DevExpress.Drawing.DXFont("Arial", 11F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrTableCell27.Name = "xrTableCell27"; + this.xrTableCell27.StylePriority.UseBorders = false; + this.xrTableCell27.StylePriority.UseFont = false; + this.xrTableCell27.StylePriority.UseTextAlignment = false; + this.xrTableCell27.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell27.Weight = 0.20999999999999996D; + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel39, + this.xrLabel2}); + this.ReportFooter.HeightF = 95.83334F; + this.ReportFooter.Name = "ReportFooter"; + // + // xrLabel39 + // + this.xrLabel39.CanGrow = false; + this.xrLabel39.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Bold, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.xrLabel39.LocationFloat = new DevExpress.Utils.PointFloat(0F, 69.16666F); + this.xrLabel39.Multiline = true; + this.xrLabel39.Name = "xrLabel39"; + this.xrLabel39.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel39.SizeF = new System.Drawing.SizeF(696.4994F, 26.66667F); + this.xrLabel39.StylePriority.UseFont = false; + this.xrLabel39.StylePriority.UseTextAlignment = false; + this.xrLabel39.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopCenter; + // + // xrLabel2 + // + this.xrLabel2.CanGrow = false; + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(0F, 20.00001F); + 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(696.4994F, 49.16668F); + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "Bitte überweisen Sie den Rechnungsbetrag unter Angabe der Kunden-Nr. und der Rech" + + "nungs-Nr. auf das unten angegebene Konto."; + // + // RechnungAusserschulischesBetreuungsangebot + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.topMarginBand1, + this.bottomMarginBand1, + this.GroupFooter1, + this.ReportFooter}); + this.DataSource = this.bindingSource1; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.Font = new DevExpress.Drawing.DXFont("Arial", 10F, DevExpress.Drawing.DXFontStyle.Regular, DevExpress.Drawing.DXGraphicsUnit.Point, new DevExpress.Drawing.DXFontAdditionalProperty[] { + new DevExpress.Drawing.DXFontAdditionalProperty("GdiCharSet", ((byte)(0)))}); + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleRateFactorNull}); + this.Margins = new DevExpress.Drawing.DXMargins(70F, 35F, 200F, 287.9167F); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = DevExpress.Drawing.Printing.DXPaperKind.A4; + this.Version = "23.2"; + xrWatermark1.Id = "Watermark1"; + xrWatermark1.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("xrWatermark1.ImageSource")); + xrWatermark1.ImageViewMode = DevExpress.XtraPrinting.Drawing.ImageViewMode.Stretch; + xrWatermark1.PageRange = "1"; + this.Watermarks.Add(xrWatermark1); + ((System.ComponentModel.ISupportInitialize)(this.xrRichText1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.rtFooterAlt)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.rtFooterNeu)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).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.XRLabel lblAdresse; + private DevExpress.XtraReports.UI.GroupFooterBand GroupFooter1; + private DevExpress.XtraReports.UI.XRLabel lblRechnung; + private DevExpress.XtraReports.UI.XRTable xrTable2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell1; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.XRLabel xrLabel32; + private DevExpress.XtraReports.UI.XRLabel xrLabel33; + private DevExpress.XtraReports.UI.XRLabel xrLabel34; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRTable xrTable1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell15; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell16; + private DevExpress.XtraReports.UI.XRTableCell lblGesamt; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow4; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell13; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell14; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell18; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell19; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell20; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell21; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell22; + private DevExpress.XtraReports.UI.XRTableCell cellEigenanteil; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell24; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell25; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell26; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell27; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.XRLine xrLine1; + private DevExpress.XtraReports.UI.XRLabel xrLabel38; + private DevExpress.XtraReports.UI.XRTable xrTable3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow2; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell2; + private DevExpress.XtraReports.UI.XRTableCell cellEinheit1; + private DevExpress.XtraReports.UI.XRTableCell cellBetrag1; + private DevExpress.XtraReports.UI.XRTableCell cellGesamt1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow7; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell9; + private DevExpress.XtraReports.UI.XRTableCell cellEinheit2; + private DevExpress.XtraReports.UI.XRTableCell cellBetrag2; + private DevExpress.XtraReports.UI.XRTableCell cellGesamt2; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow8; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell29; + private DevExpress.XtraReports.UI.XRTableCell cellEinheit3; + private DevExpress.XtraReports.UI.XRTableCell cellBetrag3; + private DevExpress.XtraReports.UI.XRTableCell cellGesamt3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow9; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell33; + private DevExpress.XtraReports.UI.XRTableCell cellEinheit4; + private DevExpress.XtraReports.UI.XRTableCell cellBetrag4; + private DevExpress.XtraReports.UI.XRTableCell cellGesamt4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell37; + private DevExpress.XtraReports.UI.XRTableCell cellEinheit5; + private DevExpress.XtraReports.UI.XRTableCell cellBetrag5; + private DevExpress.XtraReports.UI.XRTableCell cellGesamt5; + private DevExpress.XtraReports.UI.XRLabel lblKlienten; + private DevExpress.XtraReports.UI.XRTableCell cellAnzahl1; + private DevExpress.XtraReports.UI.XRTableCell cellAnzahl2; + private DevExpress.XtraReports.UI.XRTableCell cellAnzahl3; + private DevExpress.XtraReports.UI.XRTableCell cellAnzahl4; + private DevExpress.XtraReports.UI.XRTableCell cellAnzahl5; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell3; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell7; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow17; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell8; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell32; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell34; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell35; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell36; + private DevExpress.XtraReports.UI.XRLabel xrLabel20; + private DevExpress.XtraReports.UI.XRLabel xrLabel19; + private DevExpress.XtraReports.UI.XRLabel xrLabel21; + private DevExpress.XtraReports.UI.XRLabel xrLabel22; + private DevExpress.XtraReports.UI.XRLabel xrLabel23; + private DevExpress.XtraReports.UI.XRLabel xrLabel24; + private DevExpress.XtraReports.UI.XRLabel cellFaelligkeit; + private DevExpress.XtraReports.UI.XRLabel xrLabel29; + private DevExpress.XtraReports.UI.XRLabel xrLabel28; + private DevExpress.XtraReports.UI.XRLabel xrLabel27; + private DevExpress.XtraReports.UI.XRLabel xrLabel26; + private DevExpress.XtraReports.UI.XRLabel xrLabel25; + private DevExpress.XtraReports.UI.XRLabel xrLabel39; + private DevExpress.XtraReports.UI.XRRichText xrRichText1; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRRichText rtFooterAlt; + private DevExpress.XtraReports.UI.XRRichText rtFooterNeu; + } +} diff --git a/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.cs b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.cs new file mode 100644 index 000000000..b7a513110 --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.cs @@ -0,0 +1,269 @@ +using System; +using System.Text; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Report; +using BeWo.Report.ReportObjects; +using BS.Shared; +using BS.Shared.Core; +using DevExpress.XtraReports.UI; +using LebenshilfeFrankfurtOder.Utils; + +namespace LebenshilfeFrankfurtOder +{ + [IDSpecificClass(Identifier = "RechnungHort")] + public partial class RechnungAusserschulischesBetreuungsangebot : XtraReport, IBeWoReport + { + public RechnungAusserschulischesBetreuungsangebot() + { + this.InitializeComponent(); + } + + public void SetReportDataSource(ServiceInvoiceRO pRO) + { + if (!String.IsNullOrEmpty(pRO.SenderContactPersonMail)) + { + pRO.SenderContactPersonMail = pRO.SenderContactPersonMail.Replace("E-Mail:", "").Trim(); + } + if (!String.IsNullOrEmpty(pRO.SenderContactPersonPhone)) + { + pRO.SenderContactPersonPhone = pRO.SenderContactPersonPhone.Replace("Tel.:", "").Trim(); + + //lblPhoneBearbeiter.Text = pRO.SenderContactPersonPhone; + } + if (!String.IsNullOrEmpty(pRO.SenderContactPersonFax)) + { + pRO.SenderContactPersonFax = pRO.SenderContactPersonFax.Replace("Fax:", "").Trim(); + } + + if (!String.IsNullOrEmpty(pRO.SenderContactPerson)) + { + //lblBearbeiter.Text = pRO.SenderContactPerson; + } + + + StringBuilder sb = new StringBuilder(); + + if (!String.IsNullOrEmpty(pRO.RecipientOrganisation)) + { + sb.AppendLine(pRO.RecipientOrganisation); + } + + if (String.IsNullOrEmpty(pRO.RecipientContactPerson)) + { + pRO.RecipientContactPerson = GetContactPerson(pRO); + } + if (!String.IsNullOrEmpty(pRO.RecipientContactPerson)) + { + sb.AppendLine(pRO.RecipientContactPerson); + } + if (!String.IsNullOrEmpty(pRO.RecipientStreet)) + { + sb.AppendLine(pRO.RecipientStreet); + } + if (!String.IsNullOrEmpty(pRO.RecipientPostCodeAndTown)) + { + sb.AppendLine(pRO.RecipientPostCodeAndTown); + } + lblAdresse.Text = sb.ToString(); + + pRO.Notice = ""; + + cellFaelligkeit.Text = String.Format("{0:dd.MM.yyyy}", pRO.InvoiceDateTime.Value.AddDays(14)); + + String klientenNamen = ""; + + String defaultEinheit = "Tage"; + + decimal anzahl1 = 0; + decimal anzahl2 = 0; + decimal anzahl3 = 0; + decimal anzahl5 = 0; + + decimal betrag1 = FrankfurtOderHelper.PREIS_HORT_BIS_3_KINDER; + decimal betrag2 = FrankfurtOderHelper.PREIS_HORT_AB_4_KINDER; + decimal betrag3 = FrankfurtOderHelper.PREIS_HORT_AB_6_KINDER; + decimal betrag5 = FrankfurtOderHelper.GetPreisFerienbetreuung(pRO.AccountingPeriodStart); + + decimal gesamt1 = 0; + decimal gesamt2 = 0; + decimal gesamt3 = 0; + decimal gesamt5 = 0; + decimal eigenanteil = 0; + + if (pRO.ServiceInvoicePeriods != null) + { + foreach (var sip in pRO.ServiceInvoicePeriods) + { + if (!String.IsNullOrEmpty(sip.Notice)) + { + klientenNamen = sip.Notice; + } + + foreach (var ii in sip.ServiceInvoiceItems) + { + if (ii.ServiceDescription.Contains("3")) + { + anzahl1 = ii.UnitCount ?? 0; + betrag1 = ii.AmountPerUnit ?? betrag1; + gesamt1 = ii.NetAmount ?? 0; + + } + else if (ii.ServiceDescription.Contains("4")) + { + anzahl2 = ii.UnitCount ?? 0; + betrag2 = ii.AmountPerUnit ?? betrag2; + gesamt2 = ii.NetAmount ?? 0; + + } + else if (ii.ServiceDescription.Contains("6")) + { + anzahl3 = ii.UnitCount ?? 0; + betrag3 = ii.AmountPerUnit ?? betrag3; + gesamt3 = ii.NetAmount ?? 0; + + } + else if (ii.ServiceDescription.Contains("Ferien")) + { + anzahl5 = ii.UnitCount ?? 0; + betrag5 = ii.AmountPerUnit ?? betrag5; + gesamt5 = ii.NetAmount ?? 0; + + } + else if (ii.ServiceDescription.Contains("Eigenanteil")) + { + eigenanteil += ii.NetAmount ?? 0; + } + } + + + } + + } + + lblKlienten.Text = String.Format("Hort: {0}", klientenNamen); + + pRO.OrganisationDebitorNumber = GetKundennummer(pRO); + + cellAnzahl1.Text = String.Format("{0:0}", anzahl1); + cellAnzahl2.Text = String.Format("{0:0}", anzahl2); + cellAnzahl3.Text = String.Format("{0:0}", anzahl3); + cellAnzahl4.Text = ""; + cellAnzahl5.Text = String.Format("{0:0}", anzahl5); + + cellEinheit1.Text = String.Format("{0}", defaultEinheit); + cellEinheit2.Text = String.Format("{0}", defaultEinheit); + cellEinheit3.Text = String.Format("{0}", defaultEinheit); + cellEinheit4.Text = ""; + cellEinheit5.Text = String.Format("{0}", defaultEinheit); + + + cellBetrag1.Text = String.Format("{0:#,##0.00}", betrag1); + cellBetrag2.Text = String.Format("{0:#,##0.00}", betrag2); + cellBetrag3.Text = String.Format("{0:#,##0.00}", betrag3); + cellBetrag4.Text = ""; + cellBetrag5.Text = String.Format("{0:#,##0.00}", betrag5); + + + cellGesamt1.Text = String.Format("{0:c}", gesamt1); + cellGesamt2.Text = String.Format("{0:c}", gesamt2); + cellGesamt3.Text = String.Format("{0:c}", gesamt3); + cellGesamt4.Text = ""; + cellGesamt5.Text = String.Format("{0:c}", gesamt5); + + cellEigenanteil.Text = String.Format("{0:c}", eigenanteil); + lblGesamt.Text = String.Format("{0:c}", gesamt1 + gesamt2 + gesamt3 + gesamt5); + + SetRechnungsText(pRO); + SetFooter(pRO); + + this.bindingSource1.DataSource = pRO; + } + + private void SetFooter(ServiceInvoiceRO pRO) + { + rtFooterNeu.LocationF = rtFooterAlt.LocationF; + + this.bottomMarginBand1.HeightF = 100; + + if (pRO.InvoiceDateTime.HasValue && pRO.InvoiceDateTime.Value >= new DateTime(2025, 4, 1)) + { + //CB: siehe https://tool.bewoplaner.de/support_edit.php?Refresh=1&SupportOID=124179 + rtFooterNeu.Visible = true; + rtFooterAlt.Visible = false; + } + else + { + rtFooterNeu.Visible = false; + rtFooterAlt.Visible = true; + } + } + + private void SetRechnungsText(ServiceInvoiceRO pRO) + { + if (pRO.InvoiceBase != null && !String.IsNullOrEmpty(pRO.InvoiceBase.InvoiceTypeText) && pRO.InvoiceBase.InvoiceTypeText.Contains("Storno")) + { + lblRechnung.Text = "Storno Rechnung"; + } + } + + private string GetContactPerson(ServiceInvoiceRO pRo) + { + String ap = ""; + + if (pRo.ServiceInvoicePeriods != null) + { + foreach (var sip in pRo.ServiceInvoicePeriods) + { + + if (sip.CostBearer2SupportConcept != null && + sip.CostBearer2SupportConcept.CostBearerContactPerson != null) + { + ap = ""; + + if (sip.CostBearer2SupportConcept.CostBearerContactPerson.Sex.HasValue && + sip.CostBearer2SupportConcept.CostBearerContactPerson.Sex.Value == Sex.Male) + { + ap = "Herr "; + } + else if (sip.CostBearer2SupportConcept.CostBearerContactPerson.Sex.HasValue && + sip.CostBearer2SupportConcept.CostBearerContactPerson.Sex.Value == Sex.Female) + { + ap = "Frau "; + } + + + ap += sip.CostBearer2SupportConcept.CostBearerContactPerson.FirstName; + + if (ap.Length > 0) + { + ap += " "; + } + ap += sip.CostBearer2SupportConcept.CostBearerContactPerson.LastName; + } + } + } + + return ap; + } + + private string GetKundennummer(ServiceInvoiceRO pRo) + { + if (pRo.ServiceInvoicePeriods != null) + { + foreach (var sip in pRo.ServiceInvoicePeriods) + { + if (sip.CostBearer2SupportConcept != null) + { + if (!String.IsNullOrEmpty(sip.CostBearer2SupportConcept.CostBearer.Organisation.DebitorNumber)) + { + return sip.CostBearer2SupportConcept.CostBearer.Organisation.DebitorNumber; + } + } + } + } + + return ""; + } + } +} \ No newline at end of file diff --git a/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.resx b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.resx new file mode 100644 index 000000000..8fea6e61e --- /dev/null +++ b/ReportImp/LebenshilfeFrankfurtOder/RechnungAusserschulischesBetreuungsangebot.resx @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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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 + + + 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 + + + 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 + + + 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 + + \ No newline at end of file diff --git a/ReportImp/LebenshilfeFrankfurtOder/Reporting/LeistungsnachweisSGBIXRO.cs b/ReportImp/LebenshilfeFrankfurtOder/Reporting/LeistungsnachweisSGBIXRO.cs index e703e6dde..fed78a9f4 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/Reporting/LeistungsnachweisSGBIXRO.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/Reporting/LeistungsnachweisSGBIXRO.cs @@ -53,6 +53,18 @@ namespace LebenshilfeFrankfurtOder.Reporting row.AnzahlKinder = (row.AnzahlKinder ?? 0) + 1; } } + + var staffel = afs.GetStaffelForAnzahl(row.AnzahlKinder ?? 0); + + if (staffel != null) + { + row.BetragNachStaffel = staffel.Preis; + if (row.AnzahlKinder > 0) + { + row.BetragNachStaffel /= row.AnzahlKinder; + } + } + } result.Rows.Add(row); diff --git a/ReportImp/LebenshilfeFrankfurtOder/Utils/FrankfurtOderHelper.cs b/ReportImp/LebenshilfeFrankfurtOder/Utils/FrankfurtOderHelper.cs index df40e1451..721a8c343 100644 --- a/ReportImp/LebenshilfeFrankfurtOder/Utils/FrankfurtOderHelper.cs +++ b/ReportImp/LebenshilfeFrankfurtOder/Utils/FrankfurtOderHelper.cs @@ -445,127 +445,127 @@ namespace LebenshilfeFrankfurtOder.Utils { if (dt.Day == 1) { - return row.AttendanceOnDay1 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay1); } else if (dt.Day == 2) { - return row.AttendanceOnDay2 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay2); } else if (dt.Day == 3) { - return row.AttendanceOnDay3 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay3); } else if (dt.Day == 4) { - return row.AttendanceOnDay4 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay4); } else if (dt.Day == 5) { - return row.AttendanceOnDay5 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay5); } else if (dt.Day == 6) { - return row.AttendanceOnDay6 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay6); } else if (dt.Day == 7) { - return row.AttendanceOnDay7 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay7); } else if (dt.Day == 8) { - return row.AttendanceOnDay8 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay8); } else if (dt.Day == 9) { - return row.AttendanceOnDay9 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay9); } else if (dt.Day == 10) { - return row.AttendanceOnDay10 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay10); } else if (dt.Day == 11) { - return row.AttendanceOnDay11 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay11); } else if (dt.Day == 12) { - return row.AttendanceOnDay12 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay12); } else if (dt.Day == 13) { - return row.AttendanceOnDay13 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay13); } else if (dt.Day == 14) { - return row.AttendanceOnDay14 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay14); } else if (dt.Day == 15) { - return row.AttendanceOnDay15 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay15); } else if (dt.Day == 16) { - return row.AttendanceOnDay16 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay16); } else if (dt.Day == 17) { - return row.AttendanceOnDay17 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay17); } else if (dt.Day == 18) { - return row.AttendanceOnDay18 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay18); } else if (dt.Day == 19) { - return row.AttendanceOnDay19 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay19); } else if (dt.Day == 20) { - return row.AttendanceOnDay20 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay20); } else if (dt.Day == 21) { - return row.AttendanceOnDay21 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay21); } else if (dt.Day == 22) { - return row.AttendanceOnDay22 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay22); } else if (dt.Day == 23) { - return row.AttendanceOnDay23 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay23); } else if (dt.Day == 24) { - return row.AttendanceOnDay24 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay24); } else if (dt.Day == 25) { - return row.AttendanceOnDay25 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay25); } else if (dt.Day == 26) { - return row.AttendanceOnDay26 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay26); } else if (dt.Day == 27) { - return row.AttendanceOnDay27 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay27); } else if (dt.Day == 28) { - return row.AttendanceOnDay28 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay28); } else if (dt.Day == 29) { - return row.AttendanceOnDay29 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay29); } else if (dt.Day == 30) { - return row.AttendanceOnDay30 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay30); } else if (dt.Day == 31) { - return row.AttendanceOnDay31 == "x"; + return !String.IsNullOrWhiteSpace(row.AttendanceOnDay31); } return false;